ઑપરેટિંગ સિસ્ટમ્સનો પરિચય

હે હબર! હું તમારા ધ્યાન પર મારા મતે એક રસપ્રદ સાહિત્યના લેખો-અનુવાદોની શ્રેણી લાવવા માંગુ છું - OSTEP. આ સામગ્રી યુનિક્સ જેવી ઓપરેટિંગ સિસ્ટમના કામની ખૂબ ઊંડાણપૂર્વક ચર્ચા કરે છે, એટલે કે, પ્રક્રિયાઓ, વિવિધ શેડ્યુલર્સ, મેમરી અને અન્ય સમાન ઘટકો સાથે કામ કે જે આધુનિક OS બનાવે છે. તમે અહીં તમામ સામગ્રીની મૂળ જોઈ શકો છો અહીં. કૃપા કરીને નોંધો કે અનુવાદ અવ્યાવસાયિક રીતે કરવામાં આવ્યો હતો (તદ્દન મુક્તપણે), પરંતુ મને આશા છે કે મેં સામાન્ય અર્થ જાળવી રાખ્યો છે.

આ વિષય પર લેબ વર્ક અહીં મળી શકે છે:

• મૂળ
• મૂળ
• મારું અંગત અનુકૂલન

અન્ય ભાગો:

• ભાગ 1: પ્રસ્તાવના
• ભાગ 2: અમૂર્ત: પ્રક્રિયા
• ભાગ 3: પ્રક્રિયા API નો પરિચય

તમે મારી ચેનલ પર પણ જોઈ શકો છો ટેલિગ્રામ =)

એલાર્મ! આ વ્યાખ્યાન માટે એક લેબ છે! જુઓ ગીથબ

પ્રક્રિયા API

ચાલો UNIX સિસ્ટમમાં પ્રક્રિયા બનાવવાનું ઉદાહરણ જોઈએ. તે બે સિસ્ટમ કોલ્સ દ્વારા થાય છે કાંટો () и exec().

ફોર્કને કૉલ કરો()

એક પ્રોગ્રામનો વિચાર કરો જે ફોર્ક() કૉલ કરે છે. તેના અમલનું પરિણામ નીચે મુજબ હશે.

સૌ પ્રથમ, આપણે main() ફંક્શન દાખલ કરીએ છીએ અને સ્ટ્રીંગને સ્ક્રીન પર પ્રિન્ટ કરીએ છીએ. લાઇનમાં પ્રક્રિયા ઓળખકર્તા હોય છે જેને મૂળમાં કહેવામાં આવે છે PID અથવા પ્રક્રિયા ઓળખકર્તા. આ ઓળખકર્તાનો ઉપયોગ પ્રક્રિયાનો સંદર્ભ આપવા માટે UNIX માં થાય છે. આગળનો આદેશ ફોર્ક() ને કૉલ કરશે. આ બિંદુએ, પ્રક્રિયાની લગભગ ચોક્કસ નકલ બનાવવામાં આવે છે. OS માટે, એવું લાગે છે કે સિસ્ટમ પર સમાન પ્રોગ્રામની 2 નકલો ચાલી રહી છે, જે બદલામાં ફોર્ક() ફંક્શનમાંથી બહાર નીકળી જશે. મુખ્ય() ફંક્શનથી શરૂ કરીને, નવી બનાવેલી ચાઇલ્ડ પ્રક્રિયા (તેને બનાવેલી પેરેન્ટ પ્રક્રિયાના સંબંધમાં) હવે ચલાવવામાં આવશે નહીં. તે યાદ રાખવું જોઈએ કે બાળ પ્રક્રિયા એ પિતૃ પ્રક્રિયાની ચોક્કસ નકલ નથી; ખાસ કરીને, તેની પાસે તેની પોતાની સરનામાંની જગ્યા, તેના પોતાના રજિસ્ટર, એક્ઝિક્યુટેબલ સૂચનાઓનું પોતાનું નિર્દેશક અને તેના જેવા છે. આમ, ફોર્ક() ફંક્શનના કોલરને પરત કરેલ મૂલ્ય અલગ હશે. ખાસ કરીને, પિતૃ પ્રક્રિયાને વળતર તરીકે બાળક પ્રક્રિયાની PID મૂલ્ય પ્રાપ્ત થશે, અને બાળકને 0 જેટલું મૂલ્ય પ્રાપ્ત થશે. આ વળતર કોડનો ઉપયોગ કરીને, તમે પછી પ્રક્રિયાઓને અલગ કરી શકો છો અને તેમાંથી દરેકને તેનું પોતાનું કામ કરવા દબાણ કરી શકો છો. . જો કે, આ પ્રોગ્રામનો અમલ કડક રીતે વ્યાખ્યાયિત નથી. 2 પ્રક્રિયાઓમાં વિભાજન કર્યા પછી, OS તેમનું નિરીક્ષણ કરવાનું શરૂ કરે છે, તેમજ તેમના કાર્યની યોજના બનાવે છે. જો સિંગલ-કોર પ્રોસેસર પર એક્ઝિક્યુટ કરવામાં આવે, તો પ્રક્રિયાઓમાંથી એક, આ કિસ્સામાં, માતાપિતા કામ કરવાનું ચાલુ રાખશે, અને પછી બાળક પ્રક્રિયાને નિયંત્રણ પ્રાપ્ત થશે. પુનઃપ્રારંભ કરતી વખતે, પરિસ્થિતિ અલગ હોઈ શકે છે.

કૉલ રાહ ()

નીચેના પ્રોગ્રામનો વિચાર કરો. આ કાર્યક્રમમાં કોલની હાજરીના કારણે તા રાહ જુઓ() માતાપિતા પ્રક્રિયા હંમેશા બાળક પ્રક્રિયા પૂર્ણ થવાની રાહ જોશે. આ કિસ્સામાં, અમને સ્ક્રીન પર સખત રીતે વ્યાખ્યાયિત ટેક્સ્ટ આઉટપુટ મળશે

exec() કૉલ

પડકારનો વિચાર કરો exec(). જ્યારે આપણે સંપૂર્ણપણે અલગ પ્રોગ્રામ ચલાવવા માંગીએ છીએ ત્યારે આ સિસ્ટમ કૉલ ઉપયોગી છે. અહીં અમે કૉલ કરીશું execvp() ડબલ્યુસી પ્રોગ્રામ ચલાવવા માટે જે શબ્દ ગણના કાર્યક્રમ છે. જ્યારે exec() કહેવાય છે ત્યારે શું થાય છે? આ કૉલને એક્ઝેક્યુટેબલ ફાઇલનું નામ અને દલીલો તરીકે કેટલાક પરિમાણો પસાર કરવામાં આવે છે. જે પછી આ એક્ઝિક્યુટેબલ ફાઈલમાંથી કોડ અને સ્ટેટિક ડેટા લોડ થાય છે અને કોડ સાથેનો પોતાનો સેગમેન્ટ ઓવરરાઈટ થઈ જાય છે. બાકીના મેમરી વિસ્તારો, જેમ કે સ્ટેક અને હીપ, ફરીથી શરૂ કરવામાં આવે છે. જે પછી OS ફક્ત પ્રોગ્રામને એક્ઝિક્યુટ કરે છે, તેને દલીલોનો સમૂહ પસાર કરે છે. તેથી અમે નવી પ્રક્રિયા બનાવી નથી, અમે ફક્ત વર્તમાનમાં ચાલી રહેલા પ્રોગ્રામને બીજા ચાલી રહેલા પ્રોગ્રામમાં રૂપાંતરિત કર્યું છે. વંશજમાં exec() કોલ એક્ઝિક્યુટ કર્યા પછી, એવું લાગે છે કે જાણે મૂળ પ્રોગ્રામ બિલકુલ ચાલ્યો ન હતો.

યુનિક્સ શેલ માટે આ સ્ટાર્ટઅપ ગૂંચવણ સંપૂર્ણપણે સામાન્ય છે, અને તે શેલને કૉલ કર્યા પછી કોડ ચલાવવાની મંજૂરી આપે છે. કાંટો (), પરંતુ કૉલ પહેલાં exec(). આવા કોડનું ઉદાહરણ શેલ એન્વાયર્નમેન્ટને લોંચ કરવામાં આવતા પ્રોગ્રામની જરૂરિયાતો સાથે સમાયોજિત કરવાનું છે, તેને લોન્ચ કરતા પહેલા.

શેલ - માત્ર એક વપરાશકર્તા કાર્યક્રમ. તે તમને આમંત્રણ લાઇન બતાવે છે અને તમે તેમાં કંઈક લખો તેની રાહ જુએ છે. મોટા ભાગના કિસ્સાઓમાં, જો તમે ત્યાં પ્રોગ્રામનું નામ લખો છો, તો શેલ તેનું સ્થાન શોધી કાઢશે, ફોર્ક() પદ્ધતિને કૉલ કરશે અને પછી નવી પ્રક્રિયા બનાવવા માટે અમુક પ્રકારના exec()ને કૉલ કરશે અને તેનો ઉપયોગ કરીને પૂર્ણ થવાની રાહ જુઓ. wait() કૉલ કરો. જ્યારે ચાઇલ્ડ પ્રક્રિયા બહાર નીકળે છે, ત્યારે શેલ wait() કૉલમાંથી પાછો આવશે અને ફરીથી પ્રોમ્પ્ટને છાપશે અને આગલો આદેશ દાખલ થવાની રાહ જુઓ.

ફોર્ક() અને exec() સ્પ્લિટ શેલને નીચેની બાબતો કરવા દે છે, ઉદાહરણ તરીકે:
wc ફાઇલ > new_file.

આ ઉદાહરણમાં, wc પ્રોગ્રામનું આઉટપુટ ફાઇલમાં રીડાયરેક્ટ થાય છે. શેલ જે રીતે આ હાંસલ કરે છે તે એકદમ સરળ છે - કૉલ કરતા પહેલા બાળક પ્રક્રિયા બનાવીને exec(), શેલ પ્રમાણભૂત આઉટપુટ બંધ કરે છે અને ફાઇલ ખોલે છે નવી_ફાઈલ, આમ, આગળ ચાલી રહેલા પ્રોગ્રામમાંથી તમામ આઉટપુટ wc સ્ક્રીનને બદલે ફાઇલ પર રીડાયરેક્ટ કરવામાં આવશે.

યુનિક્સ પાઇપ સમાન રીતે લાગુ કરવામાં આવે છે, તફાવત સાથે કે તેઓ પાઇપ() કોલનો ઉપયોગ કરે છે. આ કિસ્સામાં, પ્રક્રિયાનો આઉટપુટ સ્ટ્રીમ કર્નલમાં સ્થિત પાઇપ કતાર સાથે જોડાયેલ હશે, જેની સાથે બીજી પ્રક્રિયાનો ઇનપુટ સ્ટ્રીમ કનેક્ટ થશે.

સોર્સ: www.habr.com