ఆపరేటింగ్ సిస్టమ్స్ పరిచయం
హలో, హబ్ర్! నేను మీ దృష్టికి వ్యాసాల శ్రేణిని అందించాలనుకుంటున్నాను - నా అభిప్రాయంలో ఆసక్తికరమైన ఒక సాహిత్యం యొక్క అనువాదాలు - OSTEP. ఈ పదార్థం యునిక్స్ లాంటి ఆపరేటింగ్ సిస్టమ్‌ల పనిని చాలా లోతుగా పరిశీలిస్తుంది, అవి ప్రక్రియలు, వివిధ షెడ్యూలర్‌లు, మెమరీ మరియు ఆధునిక OSని రూపొందించే ఇతర సారూప్య భాగాలతో పని చేస్తాయి. మీరు ఇక్కడ అన్ని మెటీరియల్స్ యొక్క అసలైనదాన్ని చూడవచ్చు . అనువాదం వృత్తిపరంగా (చాలా స్వేచ్ఛగా) జరిగిందని దయచేసి గమనించండి, కానీ నేను సాధారణ అర్థాన్ని నిలుపుకున్నానని ఆశిస్తున్నాను.
ఈ విషయంపై ల్యాబ్ పనిని ఇక్కడ చూడవచ్చు:
ఇతర భాగాలు:
మీరు ఇక్కడ నా ఛానెల్‌ని కూడా చూడవచ్చు =)
అలారం! ఈ ఉపన్యాసం కోసం ప్రయోగశాల ఉంది! చూడు
ప్రాసెస్ API
UNIX సిస్టమ్‌లో ప్రక్రియను సృష్టించే ఉదాహరణను చూద్దాం. ఇది రెండు సిస్టమ్ కాల్స్ ద్వారా జరుగుతుంది ఫోర్క్ () и కార్యనిర్వాహకుడు ().
కాల్ ఫోర్క్()
ఫోర్క్() కాల్ చేసే ప్రోగ్రామ్‌ను పరిగణించండి. దాని అమలు ఫలితం క్రింది విధంగా ఉంటుంది.
అన్నింటిలో మొదటిది, మేము ప్రధాన () ఫంక్షన్‌ను నమోదు చేస్తాము మరియు స్ట్రింగ్‌ను స్క్రీన్‌కు ప్రింట్ చేస్తాము. లైన్ ప్రాసెస్ ఐడెంటిఫైయర్‌ని కలిగి ఉంది, దానిని అసలు దానిలో పిలుస్తారు PID లేదా ప్రాసెస్ ఐడెంటిఫైయర్. ఈ ఐడెంటిఫైయర్ ప్రక్రియను సూచించడానికి UNIXలో ఉపయోగించబడుతుంది. తదుపరి కమాండ్ ఫోర్క్ () అని పిలుస్తుంది. ఈ సమయంలో, ప్రక్రియ యొక్క దాదాపు ఖచ్చితమైన కాపీ సృష్టించబడుతుంది. OS కోసం, సిస్టమ్‌లో ఒకే ప్రోగ్రామ్ యొక్క 2 కాపీలు నడుస్తున్నట్లు కనిపిస్తోంది, ఇది ఫోర్క్() ఫంక్షన్ నుండి నిష్క్రమిస్తుంది. కొత్తగా సృష్టించబడిన చైల్డ్ ప్రాసెస్ (దానిని సృష్టించిన పేరెంట్ ప్రాసెస్‌కి సంబంధించి) ఇకపై మెయిన్() ఫంక్షన్ నుండి అమలు చేయబడదు. చైల్డ్ ప్రాసెస్ అనేది పేరెంట్ ప్రాసెస్ యొక్క ఖచ్చితమైన కాపీ కాదని గుర్తుంచుకోవాలి; ప్రత్యేకించి, దాని స్వంత చిరునామా స్థలం, దాని స్వంత రిజిస్టర్‌లు, ఎక్జిక్యూటబుల్ సూచనలకు దాని స్వంత పాయింటర్ మరియు ఇలాంటివి ఉన్నాయి. అందువలన, ఫోర్క్() ఫంక్షన్ యొక్క కాలర్‌కు తిరిగి వచ్చే విలువ భిన్నంగా ఉంటుంది. ప్రత్యేకించి, పేరెంట్ ప్రాసెస్ చైల్డ్ ప్రాసెస్ యొక్క PID విలువను రిటర్న్‌గా స్వీకరిస్తుంది మరియు చైల్డ్ 0కి సమానమైన విలువను అందుకుంటుంది. ఈ రిటర్న్ కోడ్‌లను ఉపయోగించి, మీరు ప్రాసెస్‌లను వేరు చేయవచ్చు మరియు వాటిలో ప్రతి దాని స్వంత పనిని చేయమని బలవంతం చేయవచ్చు. . అయితే, ఈ ప్రోగ్రామ్ యొక్క అమలు ఖచ్చితంగా నిర్వచించబడలేదు. 2 ప్రక్రియలుగా విభజించిన తర్వాత, OS వాటిని పర్యవేక్షించడం ప్రారంభిస్తుంది, అలాగే వారి పనిని ప్లాన్ చేస్తుంది. సింగిల్-కోర్ ప్రాసెసర్‌లో అమలు చేయబడితే, ప్రక్రియలలో ఒకటి, ఈ సందర్భంలో పేరెంట్ పనిని కొనసాగిస్తుంది, ఆపై పిల్లల ప్రక్రియ నియంత్రణను పొందుతుంది. పునఃప్రారంభించేటప్పుడు, పరిస్థితి భిన్నంగా ఉండవచ్చు.
కాల్ వెయిట్()
కింది ప్రోగ్రామ్‌ను పరిగణించండి. ఈ కార్యక్రమంలో, కాల్ ఉనికి కారణంగా వేచి ఉండండి () పిల్లల ప్రక్రియ పూర్తయ్యే వరకు పేరెంట్ ప్రాసెస్ ఎల్లప్పుడూ వేచి ఉంటుంది. ఈ సందర్భంలో, మేము స్క్రీన్‌పై ఖచ్చితంగా నిర్వచించబడిన టెక్స్ట్ అవుట్‌పుట్‌ని పొందుతాము
exec() కాల్
సవాలును పరిగణించండి కార్యనిర్వాహకుడు (). మనం పూర్తిగా భిన్నమైన ప్రోగ్రామ్‌ని అమలు చేయాలనుకున్నప్పుడు ఈ సిస్టమ్ కాల్ ఉపయోగపడుతుంది. ఇక్కడ మేము కాల్ చేస్తాము execvp() వర్డ్ కౌంటింగ్ ప్రోగ్రామ్ అయిన wc ప్రోగ్రామ్‌ను అమలు చేయడానికి. కార్యనిర్వాహక()ని పిలిచినప్పుడు ఏమి జరుగుతుంది? ఈ కాల్ ఎక్జిక్యూటబుల్ ఫైల్ పేరు మరియు కొన్ని పారామితులను ఆర్గ్యుమెంట్‌లుగా పంపింది. దీని తర్వాత ఈ ఎక్జిక్యూటబుల్ ఫైల్ నుండి కోడ్ మరియు స్టాటిక్ డేటా లోడ్ చేయబడతాయి మరియు కోడ్‌తో దాని స్వంత సెగ్మెంట్ భర్తీ చేయబడుతుంది. స్టాక్ మరియు హీప్ వంటి మిగిలిన మెమరీ ప్రాంతాలు పునఃప్రారంభించబడ్డాయి. దీని తరువాత OS ప్రోగ్రామ్‌ను అమలు చేస్తుంది, దీనికి వాదనల సమితిని పంపుతుంది. కాబట్టి మేము కొత్త ప్రాసెస్‌ని సృష్టించలేదు, ప్రస్తుతం నడుస్తున్న ప్రోగ్రామ్‌ను మరొక రన్నింగ్ ప్రోగ్రామ్‌గా మార్చాము. డిసెండెంట్‌లో ఎగ్జిక్యూట్ () కాల్‌ని అమలు చేసిన తర్వాత, అసలు ప్రోగ్రామ్ అస్సలు రన్ చేయనట్లు కనిపిస్తుంది.
ఈ ప్రారంభ సమస్య Unix షెల్‌కు పూర్తిగా సాధారణమైనది మరియు కాల్ చేసిన తర్వాత కోడ్‌ని అమలు చేయడానికి ఆ షెల్‌ను అనుమతిస్తుంది ఫోర్క్ (), కానీ కాల్ ముందు కార్యనిర్వాహకుడు (). అటువంటి కోడ్‌కు ఉదాహరణగా షెల్ ఎన్విరాన్‌మెంట్‌ని లాంచ్ చేసే ముందు దాని అవసరాలకు అనుగుణంగా సర్దుబాటు చేయడం.
షెల్ - కేవలం ఒక వినియోగదారు ప్రోగ్రామ్. ఆమె మీకు ఆహ్వాన పంక్తిని చూపుతుంది మరియు మీరు దానిలో ఏదైనా వ్రాయడానికి వేచి ఉంది. చాలా సందర్భాలలో, మీరు ప్రోగ్రామ్ పేరును అక్కడ వ్రాస్తే, షెల్ దాని స్థానాన్ని కనుగొని, ఫోర్క్() పద్ధతికి కాల్ చేసి, ఆపై ఒక కొత్త ప్రక్రియను సృష్టించడానికి కొన్ని రకాల ఎగ్జిక్యూటివ్()ని కాల్ చేస్తుంది మరియు దాన్ని ఉపయోగించి పూర్తయ్యే వరకు వేచి ఉండండి వేచి ఉండండి () కాల్. చైల్డ్ ప్రాసెస్ నిష్క్రమించినప్పుడు, షెల్ వెయిట్() కాల్ నుండి తిరిగి వస్తుంది మరియు ప్రాంప్ట్‌ను మళ్లీ ప్రింట్ చేస్తుంది మరియు తదుపరి కమాండ్ ఎంటర్ చేయడానికి వేచి ఉండండి.
ఫోర్క్() & exec() స్ప్లిట్ షెల్‌ను కింది పనులను చేయడానికి అనుమతిస్తుంది, ఉదాహరణకు:
wc ఫైల్ > new_file.
ఈ ఉదాహరణలో, wc ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఫైల్‌కి దారి మళ్లించబడుతుంది. షెల్ దీన్ని సాధించే విధానం చాలా సులభం - కాల్ చేయడానికి ముందు పిల్లల ప్రక్రియను సృష్టించడం ద్వారా కార్యనిర్వాహకుడు (), షెల్ ప్రామాణిక అవుట్‌పుట్‌ను మూసివేసి ఫైల్‌ను తెరుస్తుంది new_file, అందువలన, తదుపరి నడుస్తున్న ప్రోగ్రామ్ నుండి మొత్తం అవుట్‌పుట్ wc స్క్రీన్‌కి బదులుగా ఫైల్‌కి మళ్లించబడుతుంది.
యునిక్స్ పైపు వారు పైపు() కాల్‌ని ఉపయోగించే తేడాతో ఒకే విధంగా అమలు చేస్తారు. ఈ సందర్భంలో, ప్రక్రియ యొక్క అవుట్‌పుట్ స్ట్రీమ్ కెర్నల్‌లో ఉన్న పైప్ క్యూకి కనెక్ట్ చేయబడుతుంది, దానికి మరొక ప్రక్రియ యొక్క ఇన్‌పుట్ స్ట్రీమ్ కనెక్ట్ చేయబడుతుంది.
మూలం: www.habr.com