From c6998e1daad18f2bf10b0dbff8c7441139a27795 Mon Sep 17 00:00:00 2001 From: Simone Piccardi Date: Thu, 16 Aug 2018 00:43:29 +0200 Subject: [PATCH] Ancora revisione --- img/argv_argc.dia | Bin 1644 -> 1743 bytes img/endianness.dia | Bin 1907 -> 2027 bytes img/environ_var.dia | Bin 1785 -> 1900 bytes img/memory_layout.dia | Bin 1451 -> 1616 bytes img/proc_beginend.dia | Bin 2519 -> 2584 bytes img/task_struct.dia | Bin 5159 -> 5243 bytes process.tex | 514 ++++++++++++++++++++++++------------------ prochand.tex | 146 ++++++------ 8 files changed, 369 insertions(+), 291 deletions(-) diff --git a/img/argv_argc.dia b/img/argv_argc.dia index 7889ffe003e310b9157aca6e80d09ace973a3aac..2252f8029ca714d06fa8851795a9296f8dd3c20f 100644 GIT binary patch literal 1743 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 JWxW3$J}f)opjXB>_{uEw9@YEb3_t1 zVTV8jq-|dIx33N4MnW!tX`MAvtA;w~aLhTMKOY~%=P$3bKzpWf;zwa$HvrT%8jhl| zA5QxE-#@;8B>I>8o6lq4`^0`Gu{YD$H^PK}>g&@qoqy`}US3{6uuQx(ib3EnKtg-} zdO_gzSfiePf1_#J0>)nI@pHvlFHK{AxJaoMdNbPBhu-MtB#sv0SkGG(?M6`$#oDtM z^z{!<*`fCeF})o*M`X{v2_44N`&lg-vcq-jh@R89EOs`J5}!3mm-D?Q6>|9Rtu{rg zgf$8$_a7eY5BVh(CpNMUU1+6}bmqkqKit>D`X*aRmc1(V% zG@xfH0&hvUpkY@87+Kj>?^6)i>)Ek@I5F_|aZ0;9#e zwE?l5I|8zxam;$UQf~f<0io2U>NaL9d#7EAkQaTU^)>kV@c8xHuiv3jLD7$lSydz{ z3e!W%`FZWhoB6@Aum8rTYhe-v41{$pNtYaBZK4+1r?2^iH zvbhwi6HGFjV-f_^&f4@kcm4d)U`CqvKrdvzkQwTr)Nq+FT}sYxfHvVTnZqvu&Lx}yt(!KtDP zQql$VCUk+cK^KV7^lDBQ7~ZYvf(uOXbfLCUiY{C=U2t2W3!nqSz&v=1Fu1^wf-tB` zjV=j;3!owlauNpeCWOIgT;0h=Z=uzl4CvO?od)EEo#M+o8`z}i!gbJvif}Pn2^XPs zArF{*0j~%c;VXEJtWqI!)gfcH5i(*^*m=n0DeNL-gy*muS*1eex;GItE|W8$;6-m2 zpshu37BrSjtKKS&-PNo#b40c1E$O6`@!dC>mD+7^2C;eUoHOKk?1D20Ph>Z;N^yqk z<_t~?oB;_A8MIYdzv2wCl-8?Ec88onRo2VP8AO-XR{vbNVYfh-(Aa-kLm*rs;17RBlaGH!GcW7{1s!+yARVCKjyEa@ zlyJYJ(Mma@D|p9`VXRRJ14N_&rJ+Ajh}0b-?YW|YBpD%zw7`>y;3Z77Rq?c%D9Tdu zr1oHUI8js;Px4L_?Khezx@`cUc=#)Jh^*jGmMtP`M`?%fr*??Q3xB3y`1{=t>4C*H zvvJ9%CHR4!7I4t51F&nFVY%6}pCHCHOB#4r4%kdFGvWf%4(%nWT^h=~YBVqF zKJ?(-ON0jOCZDnLRbFYU*^jIX2VNXUFZCxerz8&o8cvQ|W4CO~>HafIQ*F1K=k_(O zHZ`&*>j@0iOo5T5v-w|GhOCjw6?KulE_t3JChs{_R7DjU*X|ky8!ugan7ksX$BE3o8>1|^a| t-5>`g7eJXn$x@)yB`CQHlHLg<<)5?Hz24vKybt#N=06TO94J?Q004ZNkb(dJ diff --git a/img/environ_var.dia b/img/environ_var.dia index 318629baf38ff08dca46af0ba2ce6d28436fb474..2e448757decb3765929e25d0c3f1df6e5c5e2dd0 100644 GIT binary patch literal 1900 zcmV-y2b1_8iwFP!000021MQt%Z`(E$hVSz$1obwdMTz=K>lE#lp#`#~SksGP7y{a2 zY;H2;Npce3?6;4!mDu{S6G>F#lrHMl3U!W1o%bORNjdM{-_Jtrmc$8-*ieVS&^5xw zQ9#*bsDHcq<;2t9pB=pmC_d$XCo!IB{0x?ePeXm0rt{Om;O_1Ygv$h{Q4B)500|lV zhr+AR); z`kR~Vr4KSggPf%u*5`OaMlr$v)EhVW%lDfZpOd&~cs7p`%8R7Sd8tT^9r3eSIf|l?V7B&}#tYKiPcp_K53ya%YNa@{|g! z4?n8yxyqfyG}tZNT!|Vh!IJ+=$5L;}9Szdy_5H3}VgM0l+b`JG-?BG zvb1%~J(yp1W4;(AtA1p2ddsL>TdVD;0*~0lZqiXr7BnEqo`BDnsj)Q8iVgO)d$C;0 zrU_^=5Akw$6^eywY+;sC&N-Zrpd%X9;gsR|NgACLSR#SjnWJd*HyKOrBBs$@4;2z# z#t~z@I((#hGLN`glWtr-H4@i{3WL~{R~};|&aU+1X85XQu*t4O%dQ`99m2diw-2AT z!hLy&`z|E(Y?MIuJge<4Tk!qk(WWS@whQQTqsF-)rRYqvX0H7GRw_W zXL>X$T8>36*(4+nBOl+hkD+*f>i`ql$0l%~-OM8i$?SR@#jHGx?xI2~^Q%6uT&ait z&MNkIZG24$olMhuX9lqS{L5?RZ4|`;iTBmb0EU_Qu}mK!*F{b zgN-hpAe1X|pKd7yW=er=m4bl7qZdh33j#bv;65O9?YB07zWC7eCZwVn_KaByW$JF{ zD%s4HE99kw-O@N>HOc7?;@71I5lgH5iR0Q0A83cmq5he1swPp$aja`ex)f+do}QWb zDO$vo#M_;~^RJ_%&`Q}L(-JS}8VFjxYxwP)=A-aQk=VpdeuTMWLc}mO1xaQXNP@tT+kyMg6kWIlMGtOxuK3`% z_RFWz`I<^1@U&H7-e~$VcRw`921(J z;kbP;Di@lHQ7@ZO)%k_h7Ezwm{KDPJFCgqE!SGaq@na_#)k;AfC`D>lzSfEf?2T3| z@h({_P3xr8@|x9Rw^s|l`O?*50l2LePqtbb*GZ}6HLJzxLM>hoYH>GeK>*2Di>K70 z)KXN7+g>e5>OAjSEr=)Ok7}`jAzLkt>(oRo5ca7S2Pw5QRg2eNEp`uD@wc@iJ;S$E zzoM29OY`-9TdDZK;n6FzYw>|8T&z|Qec&VE?f@1LfBSZEp;iz3Sv@QTp_-XL$kjt= zbb%we%ZDDY%*W+JXaLXkyhB_*3~7?8wZp#F4t=$D_&NyHde0TKfa4%vGNqsipldl9 zrTFN{cHkjWYJE&`sxMAeMyF!c%VyODWu#&n1h(Fc+Wz>TOtgeyhjxqW7w2a-L%}x}tsiS=Oi8ke;72OKgXd0~^ zcF;CI<>`7U94pR+*|}E!T&w&zQsII+8Uk5eBx!QDoqNE2+;z@#G<0CQ&i^$2Qd39$ zO&zI?=dU0!LtRkGlFuY}!z2qB2gD?(nA9VaEJdV4CsOMTfzVv#C`j%+k@+}KvH`LV zWT5ov^4Ig>U>eQHU{1$lej})&Q$KVnN9F4Pl<~s>%IO49mV7+98$2DxnCZ)ht53tz z!HBZc!6J#pe-xg2#FM4qbm)`Ut+%|2t#y)Tuepou>1!T({moyOt5>B3HG{2Yu;tER zTeUOT-ONJQ@xkke4}KqfaJTuuhcNx|!QaaVU-3clK^`B_cjANJ2_GzA%jbgytUMo_ zzW9)XlBOqSK3^)B5x3SJ|8$<$l-A+0p+o3Bf8SasU8Ne$Ax- literal 1785 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 O{^oz%BmQbrQvd*9%OVc| literal 1451 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 diff --git a/img/task_struct.dia b/img/task_struct.dia index 39d21381621a212611599b1c88317e4050126287..250d93afbdc8fabba21ea72fd826919545d5825f 100644 GIT binary patch literal 5243 zcmV->6ol&^iwFP!000021MOX1Z|lgBeV<<;cwS|?zdz#K8*CQXOn}AS#U^a02)xZD4kNer+F2jJE z`*zILnXN7bNfaT(Tn?_4Mv_Uqxh8KncN5m!EUdX@SaW$fTFjT#GR>=flQ;AEEK7@( z)oS^Woo}Zcr!zCfjt#5BC~otrnxFXox9O~W%>Y&(Kcnrf$ek|p$#LLr9no@@$&-1_ z$6o&=-}6azH~MkxPl6IV&6*F~)!tJudyjdU-^{W@Bg~7c^PJn9{>jbhcV|g`A9?xp zjZfL}fhV=iI2K5BVf3PfYmjV_MF1w?6FZ)OFuIuH&Vd}3@ZPiS&Y`OlXe|+&@2Wz%jf0M!b`=^bMQZt;#&AY~YU;W|M^Y|}S zT1?XAWN;v3q=!S2N~Co}%S9+vBC_)OtLx(m+z3)Ob=o15Kp zFYP#s=`7ovA1gj2iB|lYCJgf-O$0m7U^dI{N8|aj*mtDejHotH-}m-MwYlff-FqJC zVCyc+r*~DmF_Z|x&pZFkd^yRMr$&PkMD*%GiDpbnCeE{GaXLB>!kvcaTdWwTG#i!G z(=6LHkQER2tFxb)U8@gQI6E77*ah%#LcBu{+vhd(aH70J@9Z%F_yBx+;QMc5@&Nis zSM(V?n46OHh(4N7ZEt*BV~wv_!jOHZkV5)AtJa4YWyNIA0XjLh{X8ygrAer+g4+BfFrapt|MvKQh+c4Oz5w!2WBmfkvUCxg9M z&c|6<4(dp#C7FFBKx|7V&Wq}hRr~qiHoebhPv*;|MR_r(?_OUn)W!N&f5~Q#S(T5| z%WpTc{I~6>@$KJa&!spBLWWwMm~)J7&&OBI$#cwX=cJA-p&;~-H$iNBlYH5DCIOfXlNruEU3j_#7Tb z0mA!n-MNdv+3y@)18hpV#DmDC&^= zQOtAhr-fOR3uY0C_RK64F>^Op_O<2~p@p?-Ujwkq*7y#y3p@7`0J{LYyoOzf?!Yb* zd1jZxL4)o}E_Thvr&5E}nVXeTLv55A=SID+iy1l$=`|4p^BN# z;WeUO!DAIst4%~503JR=Y5+(q0KqN*!o13jRsdnO+-L(3 z>-HN5i#8lA*afE<+g^SS;Y|(3R~1OxU+mlco*jJL{O{C z?(lEE}uOTZlC?T>mOnnw-!Pb3%vkX3%jAwbACtXv?(&RFjd!Kkr5 zWZnc=AUc0s0FsXc672{iDg;PgGBOy4NXeW(E&$0#%E=JqA}7NW>@_EYq}7A^2so>Po;gjwa>tb;W$x4zB*=36g_bwal?t)KPSo;PBc*tVpP3R;Mpch7Q_1a@Bj0s z|NHj0|NYB9fEL5iqMe$$dHV!fjENRiPqfI~$h`czibNR`8&{E&A+w%h94!^|`Os>; z^6|+241^d`>ji#d#Ds`^i@macn%Uph!kW8i=13EY3HRF1(HbF$v2_z`L~I(}zMi?v zmi=?|s(y~ULu;##K6R8i7m~^@5+N;wK6S#g*REFUtRp)M%JvD3_Us@0w|Cs&#N2C^ zm8TXbjdO=`vkpwgXzMTg)Z`QCqRT4_u)_~)?C`?^ z?C`^2hac$j>RGKxlpFM^0O*s?=<{AZ+i6hm5Pl%ti~@{Kq|+im1&(M`;K&dKI06cA zptitvJ9YpN8KC|~Hp*{gi0T^&#Wzq_U=ZR&L+iI|KTo)@P5al2fW+DpaV!Gf=CiDP zH=UtA&jO&df(TdujC28zqJ9(+)QNajcveJ6X-sSs5r~?(9*H927ML(R6AF+*M9hSw zpT0Mgx`>;2fUdo~(Y05E=-SJnYcC`gzELMlBt-yt=mtCjG=_q#8-RmyH(56oAnW$h z&qIZ1=OLk+2LR+7b<$Q)1#qua!@bfW+$#m{6{MvNLZpjKjPl&>MjAffbi2XES|rVG z7WrhjsH^oL5fd&EqoBu4%qeN!Q%YL7AwubUeNH`Z+(N9qNH%UMv(jGgVFisG0+S)^ z+!8Sv_SD>lYBx;~{gNTm#>9pUDK>8+A;ZOJv8a~A#b|6^fDJ>oKLj?6m}V#K29&c-OTdenrUf&WXMo! z4VE7=+?$X1sI8EU%`Tr)Z(BO z7^!b@P^Uow7(cXHh;bM0HSv7^Qo=%p8z?dqsC{6G z7^Yex9m1{NnvLLA#~Jnu7rey0W+YJ}kr+>AX=XW9N{FHPNnkChzSfD*lv{<3;V|vLJFGm~`_nbcjj9m|&jiY-?l(>5L7rJl^lxQkmTdU7X@GdhTTeG6OR6B}{n}neEhnps-w~ z-7L^>zk8BcI^)~`VQs43m_$fy+kYB__++$0<2&eok)b+HSJX-rPj5ydfzMzwl6TR= zztzb)O=`RDU04r|BR4BuI0&T~JI{P36Re5Ep81R%-;SgvGo9d5n~en`83!VAiTd5__&z&^UHE|RUu)(nAg043h#u2{ZpAwi*yDB z838vK#OL{wYY_r&;5_bMnfDHCp!nbkDXwxl2{vm^*hOckPr0odaVlVhz)fBHk1uEq_J$4ZP~B{HVn>&uv>P-Y}nH#O@cUK zL+VxIvtmQKmO5_OPyibO8y=aEz=rX%VNbg>3F?Fmnb&F<%Z6rt>kS!Nts{wt3&%i) zp~;ZJ{+%(Cq3$KqE;`FIv27V8yh;I#2`TN)OlEptW0e?04P}Ce*IawIalLA{@7?^j z_)y7qzN3t$o$Q@d1Kh43A4jDlxD#x0ughR-Y;ya&!KO%90Bmxf3t@mwz~<4aDbc-k zu5IMwHH5IqLJLi;vBq|hS|JNgf)vu8OQv=Q*Lr`&P%;H2Q~um)p*oaI3EoS|lyIWX zU{j2@hmfDZUqV~HjKlc`E zeJ$yN+ArQEUE?nFqHmFI)PBOZzD3zK^?Fl8s)bEW$H9in`Meq~zE42k5|9i9=vyKt z!`(!DFfyc$$WZzvLq_Z-BpcU|+8l(6hYatFnh(tjP-0L@gyQ;$DY2)v*OED*MDDj5 z1lz{fd{YgAlUigHNj1pBeOmqsOc;;}IaGqg%!INhChV@Tv^Qa&LJM36$=Hf3&E4KQ ziA21A0=ybt-OcZ_t3^H@o4-K*Nx6^_Y9Cl4hN+fK)tx6U+?kFag9Xut-SxahTq@m& zOQnBtsogkpOI)f#iA&`x#HG-WAH<~r1Gu+|OMBW2PD&>}kMisD7+$G;9$9BOR17Z9 zBzwHNo1}QS`H2s}?Fs1iC~$jXcYBlrw@3SJU{^Qb(Z&j5lFOCfBe1oK1QPxopRM7w zI6fMxYQXXF>G-HF8xd*ROI3|@qIZ@7N(5xHL_mco5s*+K0D9+r$S5azXBD7CKs8GQ zbchlG1tkIinFEl)E+C@=07f?f6JWbL4R8Ut?7@XN*@y@QsC70*8pY05z8YXJA_V2m z0Gk7_p^jjqLcpdG%~-8Q5ZFLG1F+eL4RezMAOTVUxLNY7LZkrTP6PFuJ=Je2?nIF) zefKBl!q|B3Pfo1GNEE5J`7DDH&K`uR5`?J{3sY53+t(=Jgbien2u*P_Gm-8TM4quA~z(^ehai>y`9oXT!Q)NyoCY;qBz_=pVp@0hv(4 zu7)u)A?}F@9c>Sf0+eoIR7c8dDm3qGq#Okm5}?AMJH*?B9aTVuaZ(}ai3+tFD#U)f z9GTN=JHs^>)Ka0q)+Aw6y?-i9k_3n_BoW%l0z?=q5z<~Z@X}5+nmRyFTHWkPYn3el zG-uG1_H*k1TAT-s9c7esfQ*uCWRwhSP!zs{38OHCQDHMm&?`1x??LyJTi3+VLZjzi zu}lx;%Vx+F8;gV}fw8?=sIpLBzZ)=kydTEoR zg_HQl?}E}g{#mam$v`Vg-3A5$5ClM-10d-r0MgzApyzd~Isl4i-3kJr&;bxETSXiI ziJk%=7o9?V%b?e-LhIEls-Ihh+Kw2UF#j>o_V`--8T)M@3W6vooI?0*QIPH@3erxZ zAPar}VUVq~Xv9I-cl*PRLxVsF0->&f5Jt#JBy|4W?+u}ly${!wP@7Ol#Zd_bp-|XR z$WBI0C4@q8hC)5<=7~{fF|$m_5P76Qd;Uv9f|Os^rV^}41dHKe$#1-(w?UD8e2r1Es@N1eN%B?{egEHsIINwu4 z4`qHcGarQIrZO$c7msX1O21^Y$E?c7>E$=`oqlV&{{HBRq1M3AlWVp+D}kUQB`60? zlZi%D3~dDhp?)hS*OqW1l@iwt%Nz>~z7zOP$7dvv)cYo>!)a%XIxC#ns*!-tv@^5m zW^2S|o$LLn?ELebbnZ5;*W{cTq?n`0{&v>Ciq&-Tnf&F6v?l7*uT1K`FL5M(%Y3@X zib?P&M?G5=4O>HXKA{tfNgD@=980RUzs BDYyUt literal 5159 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 V^Z$IE-u?2^{{v{Y1!~N}0RYr=>q!6r diff --git a/process.tex b/process.tex index f14150a..9a67fb5 100644 --- a/process.tex +++ b/process.tex @@ -381,7 +381,7 @@ linguaggio C all'interno della stessa, o se si richiede esplicitamente la chiusura invocando direttamente la funzione \func{exit}. Queste due modalità sono assolutamente equivalenti, dato che \func{exit} viene chiamata in maniera trasparente anche quando \code{main} ritorna, passandogli come argomento il -valore di ritorno. +valore indicato da \instruction{return}. La funzione \funcd{exit}, che è completamente generale, essendo definita dallo standard ANSI C, è quella che deve essere invocata per una terminazione @@ -406,7 +406,7 @@ vedremo a breve) che completa la terminazione del processo. \itindbeg{exit~status} -Il valore dell'argomento \param{status} o il valore di ritorno di \code{main}, +Il valore dell'argomento \param{status} o il valore di ritorno di \code{main} costituisce quello che viene chiamato lo \textsl{stato di uscita} (l'\textit{exit status}) del processo. In generale si usa questo valore per fornire al processo padre (come vedremo in sez.~\ref{sec:proc_wait}) delle @@ -415,22 +415,22 @@ terminato. Anche se l'argomento \param{status} (ed il valore di ritorno di \code{main}) sono numeri interi di tipo \ctyp{int}, si deve tener presente che il valore -dello stato di uscita viene comunque troncato ad 8 bit, -per cui deve essere sempre compreso fra 0 e 255. Si tenga presente che se si -raggiunge la fine della funzione \code{main} senza ritornare esplicitamente si -ha un valore di uscita indefinito, è pertanto consigliabile di concludere -sempre in maniera esplicita detta funzione. - -Non esiste un valore significato intrinseco della stato di uscita, ma una -convenzione in uso pressoché universale è quella di restituire 0 in caso di -successo e 1 in caso di fallimento. Una eccezione a questa convenzione è per i -programmi che effettuano dei confronti (come \cmd{diff}), che usano 0 per -indicare la corrispondenza, 1 per indicare la non corrispondenza e 2 per -indicare l'incapacità di effettuare il confronto. Un'altra convenzione riserva -i valori da 128 a 256 per usi speciali: ad esempio 128 viene usato per -indicare l'incapacità di eseguire un altro programma in un -sottoprocesso. Benché le convenzioni citate non siano seguite universalmente è -una buona idea tenerle presenti ed adottarle a seconda dei casi. +dello stato di uscita viene comunque troncato ad 8 bit, per cui deve essere +sempre compreso fra 0 e 255. Si tenga presente che se si raggiunge la fine +della funzione \code{main} senza ritornare esplicitamente si ha un valore di +uscita indefinito, è pertanto consigliabile di concludere sempre in maniera +esplicita detta funzione. + +Non esiste un significato intrinseco della stato di uscita, ma una convenzione +in uso pressoché universale è quella di restituire 0 in caso di successo e 1 +in caso di fallimento. Una eccezione a questa convenzione è per i programmi +che effettuano dei confronti (come \cmd{diff}), che usano 0 per indicare la +corrispondenza, 1 per indicare la non corrispondenza e 2 per indicare +l'incapacità di effettuare il confronto. Un'altra convenzione riserva i valori +da 128 a 256 per usi speciali: ad esempio 128 viene usato per indicare +l'incapacità di eseguire un altro programma in un sottoprocesso. Benché le +convenzioni citate non siano seguite universalmente è una buona idea tenerle +presenti ed adottarle a seconda dei casi. Si tenga presente inoltre che non è una buona idea usare eventuali codici di errore restituiti nella variabile \var{errno} (vedi sez.~\ref{sec:sys_errors}) @@ -473,8 +473,8 @@ sez.~\ref{sec:file_unix_interface} e sez.~\ref{sec:files_std_interface}). Infine fa sì che ogni figlio del processo sia adottato da \cmd{init} (vedi sez.~\ref{sec:proc_termination}), manda un segnale \signal{SIGCHLD} al processo padre (vedi -sez.~\ref{sec:sig_job_control}) e ritorna lo stato di uscita specificato -in \param{status} che può essere raccolto usando la funzione \func{wait} (vedi +sez.~\ref{sec:sig_job_control}) e salva lo stato di uscita specificato in +\param{status} che può essere raccolto usando la funzione \func{wait} (vedi sez.~\ref{sec:proc_wait}). Si tenga presente infine che oltre alla conclusione ``\textsl{normale}'' @@ -488,12 +488,12 @@ funzione \func{abort}; torneremo su questo in sez.~\ref{sec:proc_termination}. \label{sec:proc_atexit} Un'esigenza comune che si incontra è quella di dover effettuare una serie di -operazioni di pulizia (ad esempio salvare dei dati, ripristinare delle -impostazioni, eliminare dei file temporanei, ecc.) prima della conclusione di -un programma. In genere queste operazioni vengono fatte in un'apposita sezione -del programma, ma quando si realizza una libreria diventa antipatico dover -richiedere una chiamata esplicita ad una funzione di pulizia al programmatore -che la utilizza. +operazioni di pulizia prima della conclusione di un programma, ad esempio +salvare dei dati, ripristinare delle impostazioni, eliminare dei file +temporanei, ecc. In genere queste operazioni vengono fatte in un'apposita +sezione del programma, ma quando si realizza una libreria diventa antipatico +dover richiedere una chiamata esplicita ad una funzione di pulizia al +programmatore che la utilizza. È invece molto meno soggetto ad errori, e completamente trasparente all'utente, avere la possibilità di fare effettuare automaticamente la @@ -524,8 +524,11 @@ funzione di pulizia dovrà essere definita come \code{void function(void)}. Un'estensione di \func{atexit} è la funzione \funcd{on\_exit}, che le \acr{glibc} includono per compatibilità con SunOS ma che non è detto sia -definita su altri sistemi,\footnote{non essendo prevista dallo standard POSIX - è in genere preferibile evitarne l'uso.} il suo prototipo è: +definita su altri sistemi,\footnote{la funzione è disponibile dalle + \acr{glibc} 2.19 definendo la macro \macro{\_DEFAULT\_SOURCE}, mentre in + precedenza erano necessarie \macro{\_BSD\_SOURCE} o \macro{\_SVID\_SOURCE}; + non essendo prevista dallo standard POSIX è in generale preferibile evitarne + l'uso.} il suo prototipo è: \begin{funcproto}{ \fhead{stdlib.h} @@ -595,44 +598,44 @@ normalmente un programma è riportato in fig.~\ref{fig:proc_prog_start_stop}. \begin{figure}[htb] \centering -% \includegraphics[width=9cm]{img/proc_beginend} - \begin{tikzpicture}[>=stealth] - \filldraw[fill=black!35] (-0.3,0) rectangle (12,1); - \draw(5.5,0.5) node {\large{\textsf{kernel}}}; + \includegraphics[width=9cm]{img/proc_beginend} + % \begin{tikzpicture}[>=stealth] + % \filldraw[fill=black!35] (-0.3,0) rectangle (12,1); + % \draw(5.5,0.5) node {\large{\textsf{kernel}}}; - \filldraw[fill=black!15] (1.5,2) rectangle (4,3); - \draw (2.75,2.5) node {\texttt{ld-linux.so}}; - \draw [->] (2.75,1) -- (2.75,2); - \draw (2.75,1.5) node [anchor=west]{\texttt{execve}}; + % \filldraw[fill=black!15] (1.5,2) rectangle (4,3); + % \draw (2.75,2.5) node {\texttt{ld-linux.so}}; + % \draw [->] (2.75,1) -- (2.75,2); + % \draw (2.75,1.5) node [anchor=west]{\texttt{execve}}; - \filldraw[fill=black!15,rounded corners] (1.5,4) rectangle (4,5); - \draw (2.75,4.5) node {\texttt{main}}; + % \filldraw[fill=black!15,rounded corners] (1.5,4) rectangle (4,5); + % \draw (2.75,4.5) node {\texttt{main}}; - \draw [<->, dashed] (2.75,3) -- (2.75,4); - \draw [->] (1.5,4.5) -- (0.3,4.5) -- (0.3,1); - \draw (0.9,4.5) node [anchor=south] {\texttt{\_exit}}; + % \draw [<->, dashed] (2.75,3) -- (2.75,4); + % \draw [->] (1.5,4.5) -- (0.3,4.5) -- (0.3,1); + % \draw (0.9,4.5) node [anchor=south] {\texttt{\_exit}}; - \filldraw[fill=black!15,rounded corners] (1.5,6) rectangle (4,7); - \draw (2.75,6.5) node {\texttt{funzione}}; + % \filldraw[fill=black!15,rounded corners] (1.5,6) rectangle (4,7); + % \draw (2.75,6.5) node {\texttt{funzione}}; - \draw [<->, dashed] (2.75,5) -- (2.75,6); - \draw [->] (1.5,6.5) -- (0.05,6.5) -- (0.05,1); - \draw (0.9,6.5) node [anchor=south] {\texttt{\_exit}}; + % \draw [<->, dashed] (2.75,5) -- (2.75,6); + % \draw [->] (1.5,6.5) -- (0.05,6.5) -- (0.05,1); + % \draw (0.9,6.5) node [anchor=south] {\texttt{\_exit}}; - \draw (6.75,4.5) node (exit) [rectangle,fill=black!15,minimum width=2.5cm,minimum height=1cm,rounded corners, draw]{\texttt{exit}}; + % \draw (6.75,4.5) node (exit) [rectangle,fill=black!15,minimum width=2.5cm,minimum height=1cm,rounded corners, draw]{\texttt{exit}}; - \draw[->] (4,6.5) -- node[anchor=south west]{\texttt{exit}} (exit); - \draw[->] (4,4.5) -- node[anchor=south]{\texttt{exit}} (exit); - \draw[->] (exit) -- node[anchor=east]{\texttt{\_exit}}(6.75,1); + % \draw[->] (4,6.5) -- node[anchor=south west]{\texttt{exit}} (exit); + % \draw[->] (4,4.5) -- node[anchor=south]{\texttt{exit}} (exit); + % \draw[->] (exit) -- node[anchor=east]{\texttt{\_exit}}(6.75,1); - \draw (10,4.5) node (exithandler1) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}}; - \draw (10,5.5) node (exithandler2) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}}; - \draw (10,3.5) node (stream) [rectangle,fill=black!15,rounded corners, draw]{\textsf{chiusura stream}}; + % \draw (10,4.5) node (exithandler1) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}}; + % \draw (10,5.5) node (exithandler2) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}}; + % \draw (10,3.5) node (stream) [rectangle,fill=black!15,rounded corners, draw]{\textsf{chiusura stream}}; - \draw[<->, dashed] (exithandler1) -- (exit); - \draw[<->, dashed] (exithandler2) -- (exit); - \draw[<->, dashed] (stream) -- (exit); - \end{tikzpicture} + % \draw[<->, dashed] (exithandler1) -- (exit); + % \draw[<->, dashed] (exithandler2) -- (exit); + % \draw[<->, dashed] (stream) -- (exit); + % \end{tikzpicture} \caption{Schema dell'avvio e della conclusione di un programma.} \label{fig:proc_prog_start_stop} \end{figure} @@ -857,27 +860,27 @@ programma C viene suddiviso nei seguenti segmenti: \begin{figure}[htb] \centering -% \includegraphics[height=12cm]{img/memory_layout} - \begin{tikzpicture} - \draw (0,0) rectangle (4,1); - \draw (2,0.5) node {\textit{text}}; - \draw (0,1) rectangle (4,2.5); - \draw (2,1.75) node {dati inizializzati}; - \draw (0,2.5) rectangle (4,5); - \draw (2,3.75) node {dati non inizializzati}; - \draw (0,5) rectangle (4,9); - \draw[dashed] (0,6) -- (4,6); - \draw[dashed] (0,8) -- (4,8); - \draw (2,5.5) node {\textit{heap}}; - \draw (2,8.5) node {\textit{stack}}; - \draw [->] (2,6) -- (2,6.5); - \draw [->] (2,8) -- (2,7.5); - \draw (0,9) rectangle (4,10); - \draw (2,9.5) node {\textit{environment}}; - \draw (4,0) node [anchor=west] {\texttt{0x08000000}}; - \draw (4,5) node [anchor=west] {\texttt{0x08xxxxxx}}; - \draw (4,9) node [anchor=west] {\texttt{0xC0000000}}; - \end{tikzpicture} + \includegraphics[height=10cm]{img/memory_layout} + % \begin{tikzpicture} + % \draw (0,0) rectangle (4,1); + % \draw (2,0.5) node {\textit{text}}; + % \draw (0,1) rectangle (4,2.5); + % \draw (2,1.75) node {dati inizializzati}; + % \draw (0,2.5) rectangle (4,5); + % \draw (2,3.75) node {dati non inizializzati}; + % \draw (0,5) rectangle (4,9); + % \draw[dashed] (0,6) -- (4,6); + % \draw[dashed] (0,8) -- (4,8); + % \draw (2,5.5) node {\textit{heap}}; + % \draw (2,8.5) node {\textit{stack}}; + % \draw [->] (2,6) -- (2,6.5); + % \draw [->] (2,8) -- (2,7.5); + % \draw (0,9) rectangle (4,10); + % \draw (2,9.5) node {\textit{environment}}; + % \draw (4,0) node [anchor=west] {\texttt{0x08000000}}; + % \draw (4,5) node [anchor=west] {\texttt{0x08xxxxxx}}; + % \draw (4,9) node [anchor=west] {\texttt{0xC0000000}}; + % \end{tikzpicture} \caption{Disposizione tipica dei segmenti di memoria di un processo.} \label{fig:proc_mem_layout} \end{figure} @@ -995,9 +998,9 @@ essere esplicitamente rilasciata usando la funzione \funcd{free},\footnote{le Questa funzione vuole come argomento \var{ptr} il puntatore restituito da una precedente chiamata ad una qualunque delle funzioni di allocazione che non sia -già stato liberato da un'altra chiamata a \func{free}. Se il valore -di \param{ptr} è \val{NULL} la funzione non fa niente, mentre se l'area di -memoria era già stata liberata da un precedente chiamata il comportamento +già stato liberato da un'altra chiamata a \func{free}. Se il valore di +\param{ptr} è \val{NULL} la funzione non fa niente, mentre se l'area di +memoria era già stata liberata da una precedente chiamata il comportamento della funzione è dichiarato indefinito, ma in genere comporta la corruzione dei dati di gestione dell'allocazione, che può dar luogo a problemi gravi, ad esempio un \textit{segmentation fault} in una successiva chiamata di una di @@ -1188,7 +1191,7 @@ programma\footnote{questo comporta anche il fatto che non è possibile modificare il puntatore nello \textit{stack} e non c'è modo di sapere se se ne sono superate le dimensioni, per cui in caso di fallimento nell'allocazione il comportamento del programma può risultare indefinito, dando luogo ad una -\textit{segment violation} la prima volta che cercherà di accedere alla +\textit{segment violation} la prima volta che si cerchi di accedere alla memoria non effettivamente disponibile. \index{segmento!dati|(} @@ -1305,7 +1308,7 @@ memoria virtuale è disponibile una apposita funzione di sistema, \funcd{mincore}, che però non è standardizzata da POSIX e pertanto non è disponibile su tutte le versioni di kernel unix-like;\footnote{nel caso di Linux devono essere comunque definite le macro \macro{\_BSD\_SOURCE} e - \macro{\_SVID\_SOURCE}.} il suo prototipo è: + \macro{\_SVID\_SOURCE} o \macro{\_DEFAULT\_SOURCE}.} il suo prototipo è: \begin{funcproto}{ \fhead{unistd.h} @@ -1351,7 +1354,7 @@ la pagina di memoria corrispondente è al momento residente in memoria, o cancellato altrimenti. Il comportamento sugli altri bit è indefinito, essendo questi al momento riservati per usi futuri. Per questo motivo in genere è comunque opportuno inizializzare a zero il contenuto del vettore, così che le -pagine attualmente residenti in memoria saranno indicata da un valore non +pagine attualmente residenti in memoria saranno indicate da un valore non nullo del byte corrispondente. Dato che lo stato della memoria di un processo può cambiare continuamente, il @@ -1422,11 +1425,15 @@ loro prototipi sono: {Entrambe le funzioni ritornano $0$ in caso di successo e $-1$ in caso di errore, nel qual caso \var{errno} assumerà uno dei valori: \begin{errlist} - \item[\errcode{EINVAL}] \param{len} non è un valore positivo. + \item[\errcode{EAGAIN}] una parte o tutto l'intervallo richiesto non può + essere bloccato per una mancanza temporanea di risorse. + \item[\errcode{EINVAL}] \param{len} non è un valore positivo o la somma con + \param{addr} causa un overflow. \item[\errcode{ENOMEM}] alcuni indirizzi dell’intervallo specificato non - corrispondono allo spazio di indirizzi del processo o si è superato il - limite di \const{RLIMIT\_MEMLOCK} per un processo non privilegiato (solo - per kernel a partire dal 2.6.9). + corrispondono allo spazio di indirizzi del processo o con \func{mlock} si + è superato il limite di \const{RLIMIT\_MEMLOCK} per un processo non + privilegiato (solo per kernel a partire dal 2.6.9) o si è superato il + limite di regioni di memoria con attributi diversi. \item[\errcode{EPERM}] il processo non è privilegiato (per kernel precedenti il 2.6.9) o si ha un limite nullo per \const{RLIMIT\_MEMLOCK} e il processo non è privilegiato (per kernel a partire dal 2.6.9). @@ -1435,15 +1442,13 @@ loro prototipi sono: Le due funzioni permettono rispettivamente di bloccare e sbloccare la paginazione per l'intervallo di memoria iniziante all'indirizzo \param{addr} e -lungo \param{len} byte. Tutte le pagine che contengono una parte -dell'intervallo bloccato sono mantenute in RAM per tutta la durata del -blocco. Con kernel diversi da Linux si può ottenere un errore di -\errcode{EINVAL} se \param{addr} non è un multiplo della dimensione delle -pagine di memoria, pertanto se si ha a cuore la portabilità si deve avere cura -di allinearne correttamente il valore. - -% TODO trattare mlock2, introdotta con il kernel 4.4 (vedi -% http://lwn.net/Articles/650538/) +lungo \param{len} byte. Al ritorno di \func{mlock} tutte le pagine che +contengono una parte dell'intervallo bloccato sono garantite essere in RAM e +vi verranno mantenute per tutta la durata del blocco. Con kernel diversi da +Linux si può ottenere un errore di \errcode{EINVAL} se \param{addr} non è un +multiplo della dimensione delle pagine di memoria, pertanto se si ha a cuore +la portabilità si deve avere cura di allinearne correttamente il valore. Il +blocco viene rimosso chiamando \func{munlock}. Altre due funzioni di sistema, \funcd{mlockall} e \funcd{munlockall}, consentono di bloccare genericamente la paginazione per l'intero spazio di @@ -1463,7 +1468,7 @@ indirizzi di un processo. I prototipi di queste funzioni sono: L'argomento \param{flags} di \func{mlockall} permette di controllarne il comportamento; esso deve essere specificato come maschera binaria dei valori -espressi dalle costanti riportate in tab.~\ref{tab:mlockall_flags}. +espressi dalle costanti riportate in tab.~\ref{tab:mlockall_flags}. \begin{table}[htb] \footnotesize @@ -1477,6 +1482,8 @@ espressi dalle costanti riportate in tab.~\ref{tab:mlockall_flags}. spazio di indirizzi del processo.\\ \constd{MCL\_FUTURE} & blocca tutte le pagine che verranno mappate nello spazio di indirizzi del processo.\\ + \constd{MCL\_ONFAULT}& esegue il blocco delle pagine selezionate solo + quando vengono utilizzate (dal kernel 4.4).\\ \hline \end{tabular} \caption{Valori e significato dell'argomento \param{flags} della funzione @@ -1491,22 +1498,68 @@ file mappati in memoria, i dati del kernel mappati in user space, la memoria condivisa. L'uso dell'argomento \param{flags} permette di selezionare con maggior finezza le pagine da bloccare, ad esempio usando \const{MCL\_FUTURE} ci si può limitare a tutte le pagine allocate a partire dalla chiamata della -funzione. - -In ogni caso un processo \textit{real-time} che deve entrare in una sezione -critica (vedi sez.~\ref{sec:proc_race_cond}) deve provvedere a riservare -memoria sufficiente prima dell'ingresso, per scongiurare l'occorrenza di un -eventuale \textit{page fault} causato dal meccanismo di \textit{copy on - write}. Infatti se nella sezione critica si va ad utilizzare memoria che -non è ancora stata riportata in RAM si potrebbe avere un \textit{page fault} -durante l'esecuzione della stessa, con conseguente rallentamento -(probabilmente inaccettabile) dei tempi di esecuzione. - -In genere si ovvia a questa problematica chiamando una funzione che ha -allocato una quantità sufficientemente ampia di variabili automatiche, in modo -che esse vengano mappate in RAM dallo \textit{stack}, dopo di che, per essere -sicuri che esse siano state effettivamente portate in memoria, ci si scrive -sopra. +funzione, mentre \const{MCL\_CURRENT} blocca tutte quelle correntemente +mappate. L'uso di \func{munlockall} invece sblocca sempre tutte le pagine di +memoria correntemente mappate nello spazio di indirizzi del programma. + +A partire dal kernel 4.4 alla funzione \func{mlockall} è stato aggiunto un +altro flag, \const{MCL\_ONFAULT}, che può essere abbinato a entrambi gli altri +due flag, e consente di modificare il comportamento della funzione per +ottenere migliori prestazioni. + +Il problema che si presenta infatti è che eseguire un \textit{memory lock} per +un intervallo ampio di memoria richiede che questa venga comunque allocata in +RAM, con altrettanti \textit{page fault} che ne assicurino la presenza; questo +vale per tutto l'intervallo e può avere un notevole costo in termini di +prestazioni, anche quando poi, nell'esecuzione del programma, venisse usata +solo una piccola parte dello stesso. L'uso di \const{MCL\_ONFAULT} previene il +\textit{page faulting} immediato di tutto l'intervallo, le pagine +dell'intervallo verranno bloccate, ma solo quando un \textit{page fault} +dovuto all'accesso ne richiede l'allocazione effettiva in RAM. + +Questo stesso comportamento non è ottenibile con \func{mlock}, che non dispone +di un argomento \param{flag} che consenta di richiederlo, per questo sempre +con il kernel 4.4 è stata aggiunta una ulteriore funzione di sistema, +\funcd{mlock2}, il cui prototipo è: + +\begin{funcproto}{ + \fhead{sys/mman.h} + \fdecl{int mlock2(const void *addr, size\_t len, int flags)} + \fdesc{Blocca la paginazione su un intervallo di memoria.} +} +{Le funzione ritornano $0$ in caso di successo e $-1$ in caso di errore, nel + qual caso \var{errno} assume gli stessi valori di \func{mlock} con + l'aggiunta id un possibile \errcode{EINVAL} anche se si è indicato un valore + errato di \param{flags}.} +\end{funcproto} + +% NOTA: per mlock2, introdotta con il kernel 4.4 (vedi +% http://lwn.net/Articles/650538/) + +Indicando un valore nullo per \param{flags} il comportamento della funzione è +identico a quello di \func{mlock}, l'unico altro valore possibile è +\constd{MLOCK\_ONFAULT} che ha lo stesso effetto sull'allocazione delle pagine +in RAM già descritto per \const{MCL\_ONFAULT}. + +Si tenga presente che un processo \textit{real-time} che intende usare il +\textit{memory locking} con \func{mlockall} per prevenire l'avvenire di un +eventuale \textit{page fault} ed il conseguente rallentamento (probabilmente +inaccettabile) dei tempi di esecuzione, deve comunque avere delle accortezze. +In particolare si deve assicurare di aver preventivamente bloccato una +quantità di spazio nello \textit{stack} sufficiente a garantire l'esecuzione +di tutte le funzioni che hanno i requisiti di criticità sui tempi. Infatti, +anche usando \const{MCL\_FUTURE}, in caso di allocazione di una nuova pagina +nello \textit{stack} durante l'esecuzione di una funzione (precedentemente non +usata e quindi non bloccata) si potrebbe avere un \textit{page fault}. + +In genere si ovvia a questa problematica chiamando inizialmente una funzione +che definisca una quantità sufficientemente ampia di variabili automatiche +(che si ricordi vengono allocate nello \textit{stack}) e ci scriva, in modo da +esser sicuri che le corrispondenti pagine vengano mappate nello spazio di +indirizzi del processo, per poi bloccarle. La scrittura è necessaria perché il +kernel usa il meccanismo di \textit{copy on write} (vedi +sez.~\ref{sec:proc_fork}) e le pagine potrebbero non essere allocate +immediatamente. \itindend{memory~locking} \index{memoria~virtuale|)} @@ -1534,8 +1587,9 @@ tal caso l'uso di \func{malloc} non è sufficiente, ed occorre utilizzare una funzione specifica. Tradizionalmente per rispondere a questa esigenza sono state create due -funzioni diverse, \funcd{memalign} e \funcd{valloc}, oggi obsolete; i -rispettivi prototipi sono: +funzioni diverse, \funcd{memalign} e \funcd{valloc}, oggi obsolete, cui si +aggiunge \funcd{pvalloc} come estensione GNU, anch'essa obsoleta; i rispettivi +prototipi sono: \begin{funcproto}{ \fhead{malloc.h} @@ -1545,6 +1599,9 @@ rispettivi prototipi sono: \fdecl{void *memalign(size\_t boundary, size\_t size)} \fdesc{Alloca un blocco di memoria allineato ad un multiplo di \param{boundary}.} +\fdecl{void *pvalloc(size\_t size)} +\fdesc{Alloca un blocco di memoria allineato alla dimensione di una pagina di + memoria.} } {Entrambe le funzioni ritornano un puntatore al blocco di memoria allocato in caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno} @@ -1556,11 +1613,13 @@ rispettivi prototipi sono: \end{funcproto} Le funzioni restituiscono il puntatore al buffer di memoria allocata di -dimensioni pari a \param{size}, che per \func{memalign} sarà un multiplo -di \param{boundary} mentre per \func{valloc} un multiplo della dimensione di -una pagina di memoria. Nel caso della versione fornita dalla \acr{glibc} la -memoria allocata con queste funzioni deve essere liberata con \func{free}, -cosa che non è detto accada con altre implementazioni. +dimensioni pari a \param{size}, che per \func{memalign} sarà un multiplo di +\param{boundary} mentre per \func{valloc} un multiplo della dimensione di una +pagina di memoria; lo stesso vale per \func{pvalloc} che però arrotonda +automaticamente la dimensione dell'allocazione al primo multiplo di una +pagina. Nel caso della versione fornita dalla \acr{glibc} la memoria allocata +con queste funzioni deve essere liberata con \func{free}, cosa che non è detto +accada con altre implementazioni. Nessuna delle due funzioni ha una chiara standardizzazione e nessuna delle due compare in POSIX.1, inoltre ci sono indicazioni discordi sui file che ne @@ -1569,8 +1628,8 @@ contengono la definizione;\footnote{secondo SUSv2 \func{valloc} è definita in e \acr{libc5} la dichiarano in \headfile{malloc.h}, lo stesso vale per \func{memalign} che in alcuni sistemi è dichiarata in \headfile{stdlib.h}.} per questo motivo il loro uso è sconsigliato, essendo state sostituite dalla -nuova \funcd{posix\_memalign}, che è stata standardizzata in POSIX.1d; il suo -prototipo è: +nuova \funcd{posix\_memalign}, che è stata standardizzata in POSIX.1d e +disponibile dalle \acr{glibc} 2.1.91; il suo prototipo è: \begin{funcproto}{ \fhead{stdlib.h} @@ -1582,7 +1641,7 @@ prototipo è: caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno} assumerà uno dei valori: \begin{errlist} - \item[\errcode{EINVAL}] \param{alignment} non è potenza di due e multiplo + \item[\errcode{EINVAL}] \param{alignment} non è potenza di due o un multiplo di \code{sizeof(void *)}. \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione. \end{errlist}} @@ -1594,10 +1653,26 @@ indicato da \param{memptr}. La funzione fallisce nelle stesse condizioni delle due funzioni precedenti, ma a loro differenza restituisce direttamente come valore di ritorno il codice di errore. Come per le precedenti la memoria allocata con \func{posix\_memalign} deve essere disallocata con \func{free}, -che in questo caso però è quanto richiesto dallo standard. Si tenga presente -infine che nessuna di queste funzioni inizializza il buffer di memoria -allocato, il loro comportamento cioè è analogo, allineamento a parte, a quello -di \func{malloc}. +che in questo caso però è quanto richiesto dallo standard. + +Dalla versione 2.16 delle \acr{glibc} è stata aggiunta anche la funzione +\funcd{aligned\_alloc}, prevista dallo standard C11 (e disponibile definendo +\const{\_ISOC11\_SOURCE}), il cui prototipo è: + +\begin{funcproto}{ +\fhead{malloc.h} +\fdecl{void *aligned\_alloc(size\_t alignment, size\_t size)} +\fdesc{Alloca un blocco di memoria allineato ad un multiplo + di \param{alignment}.} +} +{La funzione ha gli stessi valori di ritorno e codici di errore di + \func{memalign}.} +\end{funcproto} + +La funzione è identica a \func{memalign} ma richiede che \param{size} sia un +multiplo di \param{alignment}. Infine si tenga presente infine che nessuna di +queste funzioni inizializza il buffer di memoria allocato, il loro +comportamento cioè è analogo, allineamento a parte, a quello di \func{malloc}. Un secondo caso in cui risulta estremamente utile poter avere un maggior controllo delle modalità di allocazione della memoria è quello in cui cercano @@ -1623,7 +1698,7 @@ suo prototipo è: \fdecl{int mcheck(void (*abortfn) (enum mcheck\_status status))} \fdesc{Attiva i controlli di consistenza delle allocazioni di memoria.} } -{La funzione ritorna $0$ in caso di successo e $-1$ per un errorre; +{La funzione ritorna $0$ in caso di successo e $-1$ per un errore; \var{errno} non viene impostata.} \end{funcproto} @@ -1738,34 +1813,32 @@ contengono degli spazi evitando di spezzarli in parole diverse. \begin{figure}[htb] \centering -% \includegraphics[width=13cm]{img/argv_argc} -% \includegraphics[width=13cm]{img/argv_argc} - \begin{tikzpicture}[>=stealth] - \draw (0.5,2.5) rectangle (3.5,3); - \draw (2,2.75) node {\texttt{argc = 5}}; - \draw (5,2.5) rectangle (8,3); - \draw (6.5,2.75) node {\texttt{argv[0]}}; - \draw [->] (8,2.75) -- (9,2.75); - \draw (9,2.75) node [anchor=west] {\texttt{"touch"}}; - \draw (5,2) rectangle (8,2.5); - \draw (6.5,2.25) node {\texttt{argv[1]}}; - \draw [->] (8,2.25) -- (9,2.25); - \draw (9,2.25) node [anchor=west] {\texttt{"-r"}}; - \draw (5,1.5) rectangle (8,2); - \draw (6.5,1.75) node {\texttt{argv[2]}}; - \draw [->] (8,1.75) -- (9,1.75); - \draw (9,1.75) node [anchor=west] {\texttt{"riferimento.txt"}}; - \draw (5,1.0) rectangle (8,1.5); - \draw (6.5,1.25) node {\texttt{argv[3]}}; - \draw [->] (8,1.25) -- (9,1.25); - \draw (9,1.25) node [anchor=west] {\texttt{"-m"}}; - \draw (5,0.5) rectangle (8,1.0); - \draw (6.5,0.75) node {\texttt{argv[4]}}; - \draw [->] (8,0.75) -- (9,0.75); - \draw (9,0.75) node [anchor=west] {\texttt{"questofile.txt"}}; - \draw (4.25,3.5) node{\texttt{"touch -r riferimento.txt -m questofile.txt"}}; - - \end{tikzpicture} + \includegraphics[width=13cm]{img/argv_argc} + % \begin{tikzpicture}[>=stealth] + % \draw (0.5,2.5) rectangle (3.5,3); + % \draw (2,2.75) node {\texttt{argc = 5}}; + % \draw (5,2.5) rectangle (8,3); + % \draw (6.5,2.75) node {\texttt{argv[0]}}; + % \draw [->] (8,2.75) -- (9,2.75); + % \draw (9,2.75) node [anchor=west] {\texttt{"touch"}}; + % \draw (5,2) rectangle (8,2.5); + % \draw (6.5,2.25) node {\texttt{argv[1]}}; + % \draw [->] (8,2.25) -- (9,2.25); + % \draw (9,2.25) node [anchor=west] {\texttt{"-r"}}; + % \draw (5,1.5) rectangle (8,2); + % \draw (6.5,1.75) node {\texttt{argv[2]}}; + % \draw [->] (8,1.75) -- (9,1.75); + % \draw (9,1.75) node [anchor=west] {\texttt{"riferimento.txt"}}; + % \draw (5,1.0) rectangle (8,1.5); + % \draw (6.5,1.25) node {\texttt{argv[3]}}; + % \draw [->] (8,1.25) -- (9,1.25); + % \draw (9,1.25) node [anchor=west] {\texttt{"-m"}}; + % \draw (5,0.5) rectangle (8,1.0); + % \draw (6.5,0.75) node {\texttt{argv[4]}}; + % \draw [->] (8,0.75) -- (9,0.75); + % \draw (9,0.75) node [anchor=west] {\texttt{"questofile.txt"}}; + % \draw (4.25,3.5) node{\texttt{"touch -r riferimento.txt -m questofile.txt"}}; + % \end{tikzpicture} \caption{Esempio dei valori di \param{argv} e \param{argc} generati nella scansione di una riga di comando.} \label{fig:proc_argv_argc} @@ -1791,9 +1864,11 @@ tali: un elemento di \param{argv} successivo al primo che inizia con il carattere ``\texttt{-}'' e che non sia un singolo ``\texttt{-}'' o un ``\texttt{-{}-}'' viene considerato un'opzione. In genere le opzioni sono costituite da una lettera singola (preceduta dal carattere ``\texttt{-}'') e -possono avere o no un parametro associato. Un esempio tipico può essere quello -mostrato in fig.~\ref{fig:proc_argv_argc}. In quel caso le opzioni sono -\cmd{-r} e \cmd{-m} e la prima vuole un parametro mentre la seconda no +possono avere o no un parametro associato. + +Un esempio tipico può essere quello mostrato in +fig.~\ref{fig:proc_argv_argc}. In quel caso le opzioni sono \cmd{-r} e +\cmd{-m} e la prima vuole un parametro mentre la seconda no (\cmd{questofile.txt} è un argomento del programma, non un parametro di \cmd{-m}). @@ -1834,16 +1909,6 @@ ritornato il carattere ``\texttt{:}'', infine se viene incontrato il valore ``\texttt{-{}-}'' la scansione viene considerata conclusa, anche se vi sono altri elementi di \param{argv} che cominciano con il carattere ``\texttt{-}''. -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{\codesamplewidth} - \includecodesample{listati/option_code.c} - \end{minipage} - \normalsize - \caption{Esempio di codice per la gestione delle opzioni.} - \label{fig:proc_options_code} -\end{figure} - Quando \func{getopt} trova un'opzione fra quelle indicate in \param{optstring} essa ritorna il valore numerico del carattere, in questo modo si possono eseguire azioni specifiche usando uno \instruction{switch}; la funzione @@ -1858,6 +1923,16 @@ inoltre inizializza alcune variabili globali: \item \var{int optopt} contiene il carattere dell'opzione non riconosciuta. \end{itemize*} +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{\codesamplewidth} + \includecodesample{listati/option_code.c} + \end{minipage} + \normalsize + \caption{Esempio di codice per la gestione delle opzioni.} + \label{fig:proc_options_code} +\end{figure} + In fig.~\ref{fig:proc_options_code} si è mostrata la sezione del programma \file{fork\_test.c}, che useremo nel prossimo capitolo per effettuare dei test sulla creazione dei processi, deputata alla decodifica delle opzioni a riga di @@ -1923,34 +1998,34 @@ più comuni che normalmente sono definite dal sistema, è riportato in fig.~\ref{fig:proc_envirno_list}. \begin{figure}[htb] \centering -% \includegraphics[width=15 cm]{img/environ_var} - \begin{tikzpicture}[>=stealth] - \draw (2,3.5) node {\textsf{Environment pointer}}; - \draw (6,3.5) node {\textsf{Environment list}}; - \draw (10.5,3.5) node {\textsf{Environment string}}; - \draw (0.5,2.5) rectangle (3.5,3); - \draw (2,2.75) node {\texttt{environ}}; - \draw [->] (3.5,2.75) -- (4.5,2.75); - \draw (4.5,2.5) rectangle (7.5,3); - \draw (6,2.75) node {\texttt{environ[0]}}; - \draw (4.5,2) rectangle (7.5,2.5); - \draw (6,2.25) node {\texttt{environ[1]}}; - \draw (4.5,1.5) rectangle (7.5,2); - \draw (4.5,1) rectangle (7.5,1.5); - \draw (4.5,0.5) rectangle (7.5,1); - \draw (4.5,0) rectangle (7.5,0.5); - \draw (6,0.25) node {\texttt{NULL}}; - \draw [->] (7.5,2.75) -- (8.5,2.75); - \draw (8.5,2.75) node[right] {\texttt{HOME=/home/piccardi}}; - \draw [->] (7.5,2.25) -- (8.5,2.25); - \draw (8.5,2.25) node[right] {\texttt{PATH=:/bin:/usr/bin}}; - \draw [->] (7.5,1.75) -- (8.5,1.75); - \draw (8.5,1.75) node[right] {\texttt{SHELL=/bin/bash}}; - \draw [->] (7.5,1.25) -- (8.5,1.25); - \draw (8.5,1.25) node[right] {\texttt{EDITOR=emacs}}; - \draw [->] (7.5,0.75) -- (8.5,0.75); - \draw (8.5,0.75) node[right] {\texttt{OSTYPE=linux-gnu}}; - \end{tikzpicture} + \includegraphics[width=13cm]{img/environ_var} + % \begin{tikzpicture}[>=stealth] + % \draw (2,3.5) node {\textsf{Environment pointer}}; + % \draw (6,3.5) node {\textsf{Environment list}}; + % \draw (10.5,3.5) node {\textsf{Environment string}}; + % \draw (0.5,2.5) rectangle (3.5,3); + % \draw (2,2.75) node {\texttt{environ}}; + % \draw [->] (3.5,2.75) -- (4.5,2.75); + % \draw (4.5,2.5) rectangle (7.5,3); + % \draw (6,2.75) node {\texttt{environ[0]}}; + % \draw (4.5,2) rectangle (7.5,2.5); + % \draw (6,2.25) node {\texttt{environ[1]}}; + % \draw (4.5,1.5) rectangle (7.5,2); + % \draw (4.5,1) rectangle (7.5,1.5); + % \draw (4.5,0.5) rectangle (7.5,1); + % \draw (4.5,0) rectangle (7.5,0.5); + % \draw (6,0.25) node {\texttt{NULL}}; + % \draw [->] (7.5,2.75) -- (8.5,2.75); + % \draw (8.5,2.75) node[right] {\texttt{HOME=/home/piccardi}}; + % \draw [->] (7.5,2.25) -- (8.5,2.25); + % \draw (8.5,2.25) node[right] {\texttt{PATH=:/bin:/usr/bin}}; + % \draw [->] (7.5,1.75) -- (8.5,1.75); + % \draw (8.5,1.75) node[right] {\texttt{SHELL=/bin/bash}}; + % \draw [->] (7.5,1.25) -- (8.5,1.25); + % \draw (8.5,1.25) node[right] {\texttt{EDITOR=emacs}}; + % \draw [->] (7.5,0.75) -- (8.5,0.75); + % \draw (8.5,0.75) node[right] {\texttt{OSTYPE=linux-gnu}}; + % \end{tikzpicture} \caption{Esempio di lista delle variabili di ambiente.} \label{fig:proc_envirno_list} \end{figure} @@ -2075,7 +2150,7 @@ stringa che ne contiene il valore, nella forma ``\texttt{NOME=valore}''. Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da -utilizzare per impostare, modificare e per cancellare le variabili di +utilizzare per impostare, modificare e cancellare le variabili di ambiente. Uno schema delle funzioni previste nei vari standard e disponibili in Linux è riportato in tab.~\ref{tab:proc_env_func}. Tutte le funzioni sono state comunque inserite nello standard POSIX.1-2001, ad eccetto di @@ -2119,7 +2194,7 @@ sostituendo il relativo puntatore;\footnote{il comportamento è lo stesso delle dal prototipo.} pertanto ogni cambiamento alla stringa in questione si riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a questa funzione una variabile automatica (per evitare i problemi esposti in -sez.~\ref{sec:proc_var_passing}). Benché non sia richiesto dallo standard +sez.~\ref{sec:proc_var_passing}). Benché non sia richiesto dallo standard, nelle versioni della \acr{glibc} a partire dalla 2.1 la funzione è rientrante (vedi sez.~\ref{sec:proc_reentrant}). @@ -2678,10 +2753,11 @@ dei seguenti casi: \item come espressione a sé stante. \end{itemize*} -In generale, dato che l'unica differenza fra la chiamata diretta e quella -ottenuta nell'uscita con un \func{longjmp} è costituita dal valore di ritorno -di \func{setjmp}, pertanto quest'ultima viene usualmente chiamata all'interno -di un una istruzione \instr{if} che permetta di distinguere i due casi. +In generale, dato che l'unica differenza fra il risultato di una chiamata +diretta di \func{setjmp} e quello ottenuto nell'uscita con un \func{longjmp} è +costituita dal valore di ritorno della funzione, quest'ultima viene usualmente +chiamata all'interno di un una istruzione \instr{if} che permetta di +distinguere i due casi. Uno dei punti critici dei salti non-locali è quello del valore delle variabili, ed in particolare quello delle variabili automatiche della funzione @@ -2719,13 +2795,13 @@ dichiarandole tutte come \direct{volatile}.\footnote{la direttiva \itindbeg{endianness} Un altro dei problemi di programmazione che può dar luogo ad effetti -imprevisti è quello relativo alla cosiddetta \textit{endianness}. Questa è una -caratteristica generale dell'architettura hardware di un computer che dipende -dal fatto che la rappresentazione di un numero binario può essere fatta in due -modi, chiamati rispettivamente \textit{big endian} e \textit{little endian} a -seconda di come i singoli bit vengono aggregati per formare le variabili -intere (ed in genere in diretta corrispondenza a come sono poi in realtà -cablati sui bus interni del computer). +imprevisti è quello relativo alla cosiddetta \textit{endianness}. Questa è +una caratteristica generale dell'architettura hardware di un computer che +dipende dal fatto che la rappresentazione di un numero binario può essere +fatta in due modi, chiamati rispettivamente \textit{big endian} e +\textit{little endian}, a seconda di come i singoli bit vengono aggregati per +formare le variabili intere (ed in genere in diretta corrispondenza a come +sono poi in realtà cablati sui bus interni del computer). \begin{figure}[!htb] \centering \includegraphics[height=3cm]{img/endianness} @@ -2824,12 +2900,11 @@ il valore del confronto delle due variabili. In generale non ci si deve preoccupare della \textit{endianness} all'interno di un programma fintanto che questo non deve generare o manipolare dei dati -che sono scambiati con altre macchine, ad esempio tramite via rete o tramite -dei file binari. Nel primo caso la scelta è già stata fatta nella -standardizzazione dei protocolli, che hanno adottato il \textit{big endian} -(che viene detto anche per questo \textit{network order} e vedremo in -sez.~\ref{sec:sock_func_ord} le funzioni di conversione che devono essere -usate. +che sono scambiati con altre macchine, ad esempio via rete o tramite dei file +binari. Nel primo caso la scelta è già stata fatta nella standardizzazione dei +protocolli, che hanno adottato il \textit{big endian} (che viene detto anche +per questo \textit{network order}); vedremo in sez.~\ref{sec:sock_func_ord} le +funzioni di conversione che devono essere usate. Nel secondo caso occorre sapere quale \textit{endianness} è stata usata nei dati memorizzati sul file e tenerne conto nella rilettura e nella @@ -2854,7 +2929,7 @@ basterà scegliere una volta per tutte quale usare e attenersi alla scelta. % LocalWords: capability MEMLOCK limits getpagesize RLIMIT munlock sys const % LocalWords: addr len EINVAL EPERM mlockall munlockall flags l'OR CURRENT IFS % LocalWords: argc argv parsing questofile txt getopt optstring switch optarg -% LocalWords: optind opterr optopt POSIXLY CORRECT long options NdA +% LocalWords: optind opterr optopt POSIXLY CORRECT long options NdA group % LocalWords: option parameter list environ PATH HOME XPG tab LOGNAME LANG PWD % LocalWords: TERM PAGER TMPDIR getenv name SVr setenv unsetenv putenv opz gcc % LocalWords: clearenv libc value overwrite string reference result argument @@ -2871,9 +2946,10 @@ basterà scegliere una volta per tutte quale usare e attenersi alla scelta. % LocalWords: is to LC SIG str mem wcs assert ctype dirent fcntl signal stdio % LocalWords: times library utmp syscall number Filesystem Hierarchy pathname % LocalWords: context assembler sysconf fork Dinamic huge segmentation program -% LocalWords: break store Using +% LocalWords: break store using intptr ssize overflow ONFAULT faulting alloc %%% Local Variables: %%% mode: latex %%% TeX-master: "gapil" %%% End: +% LocalWords: scheduler pvalloc aligned ISOC ABCDEF diff --git a/prochand.tex b/prochand.tex index fc5e477..1d8cadb 100644 --- a/prochand.tex +++ b/prochand.tex @@ -39,12 +39,12 @@ terminazione dei processi, e per la messa in esecuzione degli altri programmi. \subsection{L'architettura della gestione dei processi} \label{sec:proc_hierarchy} -A differenza di quanto avviene in altri sistemi, ad esempio nel VMS la +A differenza di quanto avviene in altri sistemi, ad esempio nel VMS, dove la generazione di nuovi processi è un'operazione privilegiata, una delle caratteristiche fondanti di Unix, che esamineremo in dettaglio più avanti, è che qualunque processo può a sua volta generarne altri. Ogni processo è identificato presso il sistema da un numero univoco, il cosiddetto -\textit{Process ID} o, più brevemente, \ids{PID}, assegnato in forma +\textit{Process ID}, o più brevemente \ids{PID}, assegnato in forma progressiva (vedi sez.~\ref{sec:proc_pid}) quando il processo viene creato. Una seconda caratteristica di un sistema unix-like è che la generazione di un @@ -57,16 +57,16 @@ indichiamo nella linea di comando. Una terza caratteristica del sistema è che ogni processo è sempre stato generato da un altro processo, il processo generato viene chiamato \textit{processo figlio} (\textit{child process}) mentre quello che lo ha -viene chiamato \textsl{processo padre} (\textit{parent process}). Questo vale -per tutti i processi, con una sola eccezione, dato che ci deve essere un punto -di partenza esiste un processo speciale (che normalmente è \cmd{/sbin/init}), -che come abbiamo accennato in sez.~\ref{sec:intro_kern_and_sys} viene lanciato -dal kernel alla conclusione della fase di avvio. Essendo questo il primo -processo lanciato dal sistema ha sempre il \ids{PID} uguale a 1 e non è figlio -di nessun altro processo. - -Ovviamente \cmd{init} è un processo speciale che in genere si occupa di far -partire tutti gli altri processi necessari al funzionamento del sistema, +generato viene chiamato \textsl{processo padre} (\textit{parent + process}). Questo vale per tutti i processi, con una sola eccezione; dato +che ci deve essere un punto di partenza esiste un processo iniziale (che +normalmente è \cmd{/sbin/init}), che come accennato in +sez.~\ref{sec:intro_kern_and_sys} viene lanciato dal kernel alla conclusione +della fase di avvio. Essendo questo il primo processo lanciato dal sistema ha +sempre \ids{PID} uguale a 1 e non è figlio di nessun altro processo. + +Ovviamente \cmd{init} è un processo particolare che in genere si occupa di +lanciare tutti gli altri processi necessari al funzionamento del sistema, inoltre \cmd{init} è essenziale per svolgere una serie di compiti amministrativi nelle operazioni ordinarie del sistema (torneremo su alcuni di essi in sez.~\ref{sec:proc_termination}) e non può mai essere terminato. La @@ -138,10 +138,10 @@ Il kernel mantiene una tabella dei processi attivi, la cosiddetta questa tabella, costituita da una struttura \kstruct{task\_struct}, che contiene tutte le informazioni rilevanti per quel processo. Tutte le strutture usate a questo scopo sono dichiarate nell'\textit{header file} -\file{linux/sched.h}, ed uno schema semplificato, che riporta la struttura -delle principali informazioni contenute nella \texttt{task\_struct} (che in -seguito incontreremo a più riprese), è mostrato in -fig.~\ref{fig:proc_task_struct}. +\file{linux/sched.h}, ed in fig.~\ref{fig:proc_task_struct} si è riportato uno +schema semplificato che mostra la struttura delle principali informazioni +contenute nella \texttt{task\_struct}, che in seguito incontreremo a più +riprese. \begin{figure}[!htb] \centering \includegraphics[width=14cm]{img/task_struct} @@ -179,7 +179,7 @@ su macchine che non stanno facendo nulla, con un forte risparmio nell'uso dell'energia da parte del processore che può essere messo in stato di sospensione anche per lunghi periodi di tempo. -Indipendentemente dalle motivazioni per cui questo avviene, ogni volta che +Ma, indipendentemente dalle motivazioni per cui questo avviene, ogni volta che viene eseguito lo \textit{scheduler} effettua il calcolo delle priorità dei vari processi attivi (torneremo su questo in sez.~\ref{sec:proc_priority}) e stabilisce quale di essi debba essere posto in esecuzione fino alla successiva @@ -194,7 +194,7 @@ invocazione. Come accennato nella sezione precedente ogni processo viene identificato dal sistema da un numero identificativo univoco, il \textit{process ID} o -\ids{PID}. Questo è un tipo di dato standard, \type{pid\_t} che in genere è un +\ids{PID}. Questo è un tipo di dato standard, \type{pid\_t}, che in genere è un intero con segno (nel caso di Linux e della \acr{glibc} il tipo usato è \ctyp{int}). @@ -272,7 +272,7 @@ sez.~\ref{sec:proc_perms}. \subsection{La funzione \func{fork} e le funzioni di creazione dei processi} \label{sec:proc_fork} -La funzione di sistema \funcd{fork} è la funzione fondamentale della gestione +La funzione di sistema \func{fork} è la funzione fondamentale della gestione dei processi: come si è detto tradizionalmente l'unico modo di creare un nuovo processo era attraverso l'uso di questa funzione,\footnote{in realtà oggi la \textit{system call} usata da Linux per creare nuovi processi è \func{clone} @@ -282,18 +282,19 @@ processo era attraverso l'uso di questa funzione,\footnote{in realtà oggi la migliore interazione coi \textit{thread}.} essa quindi riveste un ruolo centrale tutte le volte che si devono scrivere programmi che usano il multitasking.\footnote{oggi questa rilevanza, con la diffusione dell'uso dei - \textit{thread} che tratteremo al cap.~\ref{cha:threads}, è in parte minore, - ma \func{fork} resta comunque la funzione principale per la creazione di - processi.} Il prototipo della funzione è: + \textit{thread}\unavref{ che tratteremo al cap.~\ref{cha:threads}}, è in + parte minore, ma \func{fork} resta comunque la funzione principale per la + creazione di processi.} Il prototipo di \funcd{fork} è: \begin{funcproto}{ \fhead{unistd.h} \fdecl{pid\_t fork(void)} \fdesc{Crea un nuovo processo.} } -{La funzione ritorna il \ids{PID} del figlio al padre e $0$ al figlio in caso - di successo e $-1$ al padre senza creare il figlio per un errore, - nel qual caso \var{errno} assumerà uno dei valori: + +{La funzione ritorna in caso di successo il \ids{PID} del figlio nel padre e + $0$ nel figlio mentre ritorna $-1$ nel padre, senza creare il figlio, per un + errore, al caso \var{errno} assumerà uno dei valori: \begin{errlist} \item[\errcode{EAGAIN}] non ci sono risorse sufficienti per creare un altro processo (per allocare la tabella delle pagine e le strutture del task) o @@ -304,7 +305,7 @@ multitasking.\footnote{oggi questa rilevanza, con la diffusione dell'uso dei \end{funcproto} Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che -il processo figlio continuano ad essere eseguiti normalmente a partire +il processo figlio continuano ad essere eseguiti normalmente, a partire dall'istruzione successiva alla \func{fork}. Il processo figlio è una copia del padre, e riceve una copia dei segmenti di testo, dati e dello \textit{stack} (vedi sez.~\ref{sec:proc_mem_layout}), ed esegue esattamente lo @@ -334,11 +335,11 @@ eseguito dal padre o dal figlio. Si noti come la funzione \func{fork} ritorni due volte, una nel padre e una nel figlio. La scelta di questi valori di ritorno non è casuale, un processo infatti può -avere più figli, ed il valore di ritorno di \func{fork} è l'unico modo che gli -permette di identificare quello appena creato. Al contrario un figlio ha -sempre un solo padre, il cui \ids{PID} può sempre essere ottenuto con -\func{getppid}, come spiegato in sez.~\ref{sec:proc_pid}, per cui si usa il -valore nullo, che non è il \ids{PID} di nessun processo. +avere più figli, ed il valore di ritorno di \func{fork} è l'unico che gli +permette di identificare qual è quello appena creato. Al contrario un figlio +ha sempre un solo padre il cui \ids{PID}, come spiegato in +sez.~\ref{sec:proc_pid}, può sempre essere ottenuto con \func{getppid}; per +questo si ritorna un valore nullo, che non è il \ids{PID} di nessun processo. Normalmente la chiamata a \func{fork} può fallire solo per due ragioni: o ci sono già troppi processi nel sistema, il che di solito è sintomo che @@ -353,7 +354,7 @@ ne esegue un'altra. È il caso tipico dei programmi server (il modello \textit{client-server} è illustrato in sez.~\ref{sec:net_cliserv}) in cui il padre riceve ed accetta le richieste da parte dei programmi client, per ciascuna delle quali pone in esecuzione un figlio che è incaricato di fornire -il servizio. +le risposte associate al servizio. La seconda modalità è quella in cui il processo vuole eseguire un altro programma; questo è ad esempio il caso della shell. In questo caso il processo @@ -393,8 +394,8 @@ degli eventuali tempi di attesa in secondi (eseguiti tramite la funzione \func{sleep}) per il padre ed il figlio (con \cmd{forktest -h} si ottiene la descrizione delle opzioni). Il codice completo, compresa la parte che gestisce le opzioni a riga di comando, è disponibile nel file \file{fork\_test.c}, -distribuito insieme agli altri sorgenti degli esempi su -\url{http://gapil.truelite.it/gapil_source.tgz}. +distribuito insieme agli altri sorgenti degli esempi della guida su +\url{http://gapil.gnulinux.it}. Decifrato il numero di figli da creare, il ciclo principale del programma (\texttt{\small 24-40}) esegue in successione la creazione dei processi figli @@ -460,36 +461,36 @@ In realtà con l'introduzione dei kernel della serie 2.6 lo \textit{scheduler} risultati precedenti infatti sono stati ottenuti usando un kernel della serie 2.4.} Questa è una ottimizzazione adottata per evitare che il padre, effettuando per primo una operazione di scrittura in memoria, attivasse il -meccanismo del \textit{copy on write}, operazione inutile qualora il figlio -venga creato solo per eseguire una \func{exec} su altro programma che scarta -completamente lo spazio degli indirizzi e rende superflua la copia della -memoria modificata dal padre. Eseguendo sempre per primo il figlio la -\func{exec} verrebbe effettuata subito, con la certezza di utilizzare +meccanismo del \textit{copy on write}, operazione inutile quando il figlio +viene creato solo per eseguire una \func{exec} per lanciare un altro programma +che scarta completamente lo spazio degli indirizzi e rende superflua la copia +della memoria modificata dal padre. Eseguendo sempre per primo il figlio la +\func{exec} verrebbe effettuata subito, con la certezza di utilizzare il \textit{copy on write} solo quando necessario. Con il kernel 2.6.32 però il comportamento è stato nuovamente cambiato, stavolta facendo eseguire per primo sempre il padre. Si è realizzato infatti -che l'eventualità prospettata per la scelta precedente era comunque molto -improbabile, mentre l'esecuzione immediata del padre presenta sempre il +che l'eventualità prospettata per la scelta precedente era comunque poco +probabile, mentre l'esecuzione immediata del padre presenta sempre il vantaggio di poter utilizzare immediatamente tutti i dati che sono nella cache -della CPU e nella unità di gestione della memoria virtuale senza doverli +della CPU e nell'unità di gestione della memoria virtuale, senza doverli invalidare, cosa che per i processori moderni, che hanno linee di cache interne molto profonde, avrebbe un forte impatto sulle prestazioni. Allora anche se quanto detto in precedenza vale come comportamento effettivo dei programmi soltanto per i kernel fino alla serie 2.4, per mantenere la portabilità con altri kernel unix-like, e con i diversi comportamenti adottati -dalle Linux nelle versioni successive, è opportuno non fare affidamento su -nessun tipo comportamento predefinito e non dare per assunta l'esecuzione -preventiva del padre o del figlio. - -Si noti poi come dopo la \func{fork}, essendo i segmenti di memoria utilizzati -dai singoli processi completamente indipendenti, le modifiche delle variabili -nei processi figli, come l'incremento di \var{i} in (\texttt{\small 31}), sono -visibili solo a loro, (ogni processo vede solo la propria copia della -memoria), e non hanno alcun effetto sul valore che le stesse variabili hanno -nel processo padre ed in eventuali altri processi figli che eseguano lo stesso -codice. +dalle Linux nella sua evoluzione, è comunque opportuno non fare affidamento su +nessun tipo di comportamento predefinito e non fare assunzioni sull'ordine di +esecuzione di padre e figlio. + +Si noti infine come dopo la \func{fork}, essendo i segmenti di memoria +utilizzati dai singoli processi completamente indipendenti, le modifiche delle +variabili nei processi figli, come l'incremento di \var{i} in (\texttt{\small + 31}), sono visibili solo a loro, (ogni processo vede solo la propria copia +della memoria), e non hanno alcun effetto sul valore che le stesse variabili +hanno nel processo padre ed in eventuali altri processi figli che eseguano lo +stesso codice. Un secondo aspetto molto importante nella creazione dei processi figli è quello dell'interazione dei vari processi con i file. Ne parleremo qui anche @@ -528,15 +529,15 @@ che come si vede è completamente diverso da quanto ottenevamo sul terminale. Il comportamento delle varie funzioni di interfaccia con i file è analizzato in gran dettaglio in sez.~\ref{sec:file_unix_interface} per l'interfaccia nativa Unix ed in sez.~\ref{sec:files_std_interface} per la standardizzazione -adottata nelle librerie del linguaggio C e valida per qualunque sistema -operativo. +adottata nelle librerie del linguaggio C, valida per qualunque sistema +operativo. Qui basta accennare che si sono usate le funzioni standard della libreria del C che prevedono l'output bufferizzato. Il punto è che questa bufferizzazione (che tratteremo in dettaglio in sez.~\ref{sec:file_buffering}) varia a seconda che si tratti di un file su disco, in cui il buffer viene scaricato su disco solo quando necessario, o di un terminale, in cui il buffer viene scaricato ad -ogni carattere di a capo. +ogni carattere di ``a capo''. Nel primo esempio allora avevamo che, essendovi un a capo nella stringa stampata, ad ogni chiamata a \func{printf} il buffer veniva scaricato, per cui @@ -566,19 +567,19 @@ viene rediretto come si è fatto nell'esempio, lo stesso avviene anche per tutti i figli. La funzione \func{fork} infatti ha la caratteristica di duplicare nei processi figli tutti i \textit{file descriptor} (vedi sez.~\ref{sec:file_fd}) dei file aperti nel processo padre (allo stesso modo -in cui lo fa la funzione \func{dup}, trattata in sez.~\ref{sec:file_dup}), il -che comporta che padre e figli condividono le stesse voci della \textit{file - table} (tratteremo in dettaglio questi termini in sez.~\ref{sec:file_fd} e -sez.~\ref{sec:file_shared_access}) fra cui c'è anche la posizione corrente nel -file. - -In questo modo se un processo scrive su un file aggiornerà la posizione -corrente sulla \textit{file table}, e tutti gli altri processi, che vedono la -stessa \textit{file table}, vedranno il nuovo valore. In questo modo si evita, -in casi come quello appena mostrato in cui diversi processi scrivono sullo -stesso file, che l'output successivo di un processo vada a sovrapporsi a -quello dei precedenti: l'output potrà risultare mescolato, ma non ci saranno -parti perdute per via di una sovrascrittura. +in cui lo fa la funzione \func{dup}, trattata in sez.~\ref{sec:file_dup}). Ciò +fa si che padre e figli condividano le stesse voci della \textit{file table} +(tratteremo in dettaglio questi termini in sez.~\ref{sec:file_fd} e +sez.~\ref{sec:file_shared_access}) fra le quali c'è anche la posizione +corrente nel file. + +Quando un processo scrive su un file la posizione corrente viene aggiornata +sulla \textit{file table}, e tutti gli altri processi, che vedono la stessa +\textit{file table}, vedranno il nuovo valore. In questo modo si evita, in +casi come quello appena mostrato in cui diversi processi scrivono sullo stesso +file, che l'output di un processo successivo vada a sovrapporsi a quello dei +precedenti: l'output potrà risultare mescolato, ma non ci saranno parti +perdute per via di una sovrascrittura. Questo tipo di comportamento è essenziale in tutti quei casi in cui il padre crea un figlio e attende la sua conclusione per proseguire, ed entrambi @@ -4503,7 +4504,7 @@ varie funzioni di libreria, che sono identificate aggiungendo il suffisso % LocalWords: nell'header scheduler system interrupt timer HZ asm Hertz clock % LocalWords: l'alpha tick fork wait waitpid exit exec image glibc int pgid ps % LocalWords: sid thread Ingo Molnar ppid getpid getppid sys unistd LD threads -% LocalWords: void tempnam pathname sibling cap errno EAGAIN ENOMEM +% LocalWords: void tempnam pathname sibling cap errno EAGAIN ENOMEM context % LocalWords: stack read only copy write tab client spawn forktest sleep PATH % LocalWords: source LIBRARY scheduling race condition printf descriptor dup % LocalWords: close group session tms lock vfork execve BSD stream main abort @@ -4513,7 +4514,7 @@ varie funzioni di libreria, che sono identificate aggiungendo il suffisso % LocalWords: filesystem noexec EPERM suid sgid root nosuid ENOEXEC ENOENT ELF % LocalWords: ETXTBSY EINVAL ELIBBAD BIG EFAULT EIO ENAMETOOLONG ELOOP ENOTDIR % LocalWords: ENFILE EMFILE argc execl path execv execle execlp execvp vector -% LocalWords: list environ NULL umask utime cutime ustime fcntl linker +% LocalWords: list environ NULL umask utime cutime ustime fcntl linker Posix % LocalWords: opendir libc interpreter FreeBSD capabilities mandatory access % LocalWords: control MAC SELinux security modules LSM superuser uid gid saved % LocalWords: effective euid egid dell' fsuid fsgid getuid geteuid getgid SVr @@ -4527,7 +4528,7 @@ varie funzioni di libreria, che sono identificate aggiungendo il suffisso % LocalWords: shmctl ioperm iopl chroot ptrace accounting swap reboot hangup % LocalWords: vhangup mknod lease permitted inherited inheritable bounding AND % LocalWords: capability capget capset header ESRCH undef version obj clear PT -% LocalWords: pag ssize length proc capgetp preemptive cache runnable contest +% LocalWords: pag ssize length proc capgetp preemptive cache runnable % LocalWords: SIGSTOP soft slice nice niceness counter which SC switch side % LocalWords: getpriority who setpriority RTLinux RTAI Adeos fault FIFO COUNT % LocalWords: yield Robin setscheduler policy param OTHER priority setparam to @@ -4559,6 +4560,7 @@ varie funzioni di libreria, che sono identificate aggiungendo il suffisso % LocalWords: NEWUTS SETTLS SIGHAND SYSVSEM UNTRACED tls ctid CLEARTID panic % LocalWords: loader EISDIR SIGTRAP uninterrutible killable EQUAL sizeof XOR % LocalWords: destset srcset ALLOC num cpus setsize emacs pager getty TID +% LocalWords: reaper SUBREAPER Library futex %%% Local Variables: %%% mode: latex -- 2.30.2