ఎక్సెక్ సిస్టమ్ కాల్ యాక్టివ్ ప్రాసెస్‌లో ఉండే ఫైల్‌ను ఎగ్జిక్యూట్ చేయడానికి ఉపయోగించబడుతుంది. Exec అని పిలవబడినప్పుడు మునుపటి ఎక్జిక్యూటబుల్ ఫైల్ భర్తీ చేయబడుతుంది మరియు కొత్త ఫైల్ అమలు చేయబడుతుంది.
మరింత ఖచ్చితంగా, మేము exec సిస్టమ్ కాల్‌ని ఉపయోగించి పాత ఫైల్ లేదా ప్రోగ్రామ్‌ని కొత్త ఫైల్ లేదా ప్రోగ్రామ్‌తో భర్తీ చేస్తామని చెప్పగలం. ప్రక్రియలోని మొత్తం కంటెంట్ కొత్త ప్రోగ్రామ్‌తో భర్తీ చేయబడుతుంది.
Exec () సిస్టమ్ కాల్‌ను అమలు చేసే యూజర్ డేటా సెగ్మెంట్ exec () కు కాల్ చేస్తున్నప్పుడు వాదనలో పేరు అందించబడిన డేటా ఫైల్‌తో భర్తీ చేయబడుతుంది.
కొత్త ప్రోగ్రామ్ అదే ప్రాసెస్ స్పేస్‌లో లోడ్ చేయబడింది. ప్రస్తుత ప్రక్రియ కేవలం కొత్త ప్రక్రియగా మార్చబడింది మరియు అందువల్ల ప్రాసెస్ ఐడి పిఐడి మార్చబడలేదు, ఎందుకంటే మేము ఒక కొత్త ప్రక్రియను సృష్టించడం లేదు ఎందుకంటే మేము ఒక ప్రక్రియను ఎక్సెక్‌లో మరొక ప్రక్రియతో భర్తీ చేస్తున్నాము.
ప్రస్తుతం నడుస్తున్న ప్రక్రియలో ఒకటి కంటే ఎక్కువ థ్రెడ్‌లు ఉన్నట్లయితే, అన్ని థ్రెడ్‌లు రద్దు చేయబడతాయి మరియు కొత్త ప్రాసెస్ ఇమేజ్ లోడ్ చేయబడుతుంది మరియు ఆపై అమలు చేయబడుతుంది. కరెంట్ ప్రాసెస్ యొక్క థ్రెడ్‌లను ముగించే విధ్వంసక విధులు లేవు.
ప్రక్రియ యొక్క PID మార్చబడలేదు కానీ ప్రక్రియ యొక్క డేటా, కోడ్, స్టాక్, కుప్ప మొదలైనవి మార్చబడ్డాయి మరియు కొత్తగా లోడ్ చేయబడిన ప్రక్రియతో భర్తీ చేయబడతాయి. కొత్త ప్రక్రియ ఎంట్రీ పాయింట్ నుండి అమలు చేయబడుతుంది.
Exec సిస్టమ్ కాల్ అనేది ఫంక్షన్ల సమాహారం మరియు C ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, ఈ ఫంక్షన్‌లకు ప్రామాణిక పేర్లు క్రింది విధంగా ఉన్నాయి:
- execl
- అమలు
- execlp
- execv
- అమలు
- execvp
ఈ విధులు ఒకే ఆధారాన్ని కలిగి ఉన్నాయని ఇక్కడ గమనించాలి కార్యనిర్వహణ తర్వాత ఒకటి లేదా అంతకంటే ఎక్కువ అక్షరాలు. ఇవి క్రింద వివరించబడ్డాయి:
మరియు: ఇది పర్యావరణ వేరియబుల్స్‌ను సూచించే పాయింటర్‌ల శ్రేణి మరియు కొత్తగా లోడ్ చేయబడిన ప్రక్రియకు స్పష్టంగా పంపబడుతుంది.
ది: l అనేది కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల జాబితా ఫంక్షన్‌కు పంపబడింది
p: p అనేది పాత్ ఎన్విరాన్మెంట్ వేరియబుల్, ఇది ప్రాసెస్‌లోకి లోడ్ చేయాల్సిన ఆర్గ్యుమెంట్‌గా పాస్ అయిన ఫైల్‌ను కనుగొనడంలో సహాయపడుతుంది.
v: v అనేది కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల కోసం. ఇవి ఫంక్షన్‌కు పాయింటర్‌ల శ్రేణిగా పంపబడతాయి.
ఎక్సెక్ ఎందుకు ఉపయోగించబడుతుంది?
వినియోగదారు అదే ప్రక్రియలో కొత్త ఫైల్ లేదా ప్రోగ్రామ్‌ను ప్రారంభించాలనుకున్నప్పుడు exec ఉపయోగించబడుతుంది.
Exec యొక్క అంతర్గత పని
కార్యనిర్వహణ పనిని అర్థం చేసుకోవడానికి ఈ క్రింది అంశాలను పరిగణించండి:
- ప్రస్తుత ప్రక్రియ చిత్రం కొత్త ప్రక్రియ చిత్రంతో భర్తీ చేయబడింది.
- కొత్త ప్రక్రియ చిత్రం మీరు exec ఆర్గ్యుమెంట్‌గా ఆమోదించినది
- ప్రస్తుతం నడుస్తున్న ప్రక్రియ ముగిసింది
- కొత్త ప్రాసెస్ ఇమేజ్ ఒకే ప్రాసెస్ ఐడి, అదే ఎన్విరాన్మెంట్ మరియు అదే ఫైల్ డిస్క్రిప్టర్ (ప్రాసెస్ రీప్లేస్ చేయబడనందున ప్రాసెస్ ఇమేజ్ రీప్లేస్ చేయబడింది)
- CPU స్టాట్ మరియు వర్చువల్ మెమరీ ప్రభావితం. ప్రస్తుత ప్రాసెస్ ఇమేజ్ యొక్క వర్చువల్ మెమరీ మ్యాపింగ్ కొత్త ప్రాసెస్ ఇమేజ్ యొక్క వర్చువల్ మెమరీ ద్వారా భర్తీ చేయబడుతుంది.
కార్యనిర్వాహక కుటుంబ విధుల సింటాక్స్:
Exec యొక్క ప్రతి ఫంక్షన్ కోసం కిందివి సింటాక్స్‌లు:
int execl (const char* path, const char* arg, ...)int execlp (const char* ఫైల్, const char* arg, ...)
int execle (const char* path, const char* arg, ..., char* const envp [])
int execv (const char* path, const char* argv [])
int execvp (const char* ఫైల్, const char* argv [])
int execvpe (const char* ఫైల్, const char* argv [], char* const envp [])
వివరణ:
ఈ ఫంక్షన్ల రిటర్న్ రకం Int. ప్రాసెస్ ఇమేజ్ విజయవంతంగా భర్తీ చేయబడినప్పుడు, కాలింగ్ ఫంక్షన్‌కి ఏదీ తిరిగి ఇవ్వబడదు ఎందుకంటే దీనిని పిలిచే ప్రక్రియ ఇకపై అమలు కావడం లేదు. కానీ ఏదైనా లోపం ఉంటే -1 తిరిగి ఇవ్వబడుతుంది. ఏదైనా లోపం సంభవించినట్లయితే ఎర్నో సెట్ చేయబడింది.
వాక్యనిర్మాణంలో:
- మార్గం అమలు చేయాల్సిన ఫైల్ యొక్క పూర్తి మార్గం పేరును పేర్కొనడానికి ఉపయోగించబడుతుంది.
- కోపం వాదన ఆమోదించబడింది. ఇది వాస్తవానికి ఫైల్ పేరు ప్రక్రియలో అమలు చేయబడుతుంది. చాలా సార్లు ఆర్గ్ మరియు మార్గం విలువ ఒకేలా ఉంటుంది.
- const char* arg ఫంక్షన్లలో execl (), execlp () మరియు execle () arg0, arg1, arg2, ..., argn గా పరిగణించబడుతుంది. ఇది ప్రాథమికంగా రద్దు చేసిన తీగలను రద్దు చేసే పాయింటర్‌ల జాబితా. ఇక్కడ మొదటి వాదన పాయింట్ 2 లో వివరించిన విధంగా అమలు చేయబడే ఫైల్ పేరును సూచిస్తుంది.
- ఎన్విపి పర్యావరణ వేరియబుల్స్‌ను సూచించే పాయింటర్‌లను కలిగి ఉన్న శ్రేణి.
- ఫైల్ కొత్త ప్రాసెస్ ఇమేజ్ ఫైల్ యొక్క మార్గాన్ని గుర్తించే మార్గం పేరును పేర్కొనడానికి ఉపయోగించబడుతుంది.
- Exec యొక్క ఫంక్షన్లు దీనితో ముగుస్తాయి మరియు కొత్త ప్రక్రియ చిత్రం కోసం పర్యావరణాన్ని మార్చడానికి ఉపయోగిస్తారు. ఈ ఫంక్షన్లు ఆర్గ్యుమెంట్ ఉపయోగించి పర్యావరణ సెట్టింగ్ జాబితాను పాస్ చేస్తాయి ఎన్విపి . ఈ ఆర్గ్యుమెంట్ అక్షరాల శ్రేణి, ఇది రద్దు చేయబడిన స్ట్రింగ్‌ను సూచిస్తుంది మరియు పర్యావరణ వేరియబుల్‌ను నిర్వచిస్తుంది.
ఎక్సెక్ ఫ్యామిలీ ఫంక్షన్‌లను ఉపయోగించడానికి, మీరు మీ సి ప్రోగ్రామ్‌లో కింది హెడర్ ఫైల్‌ను చేర్చాలి:
#చేర్చండిఉదాహరణ 1: C ప్రోగ్రామ్‌లో exec సిస్టమ్ కాల్‌ని ఉపయోగించడం
లైనక్స్, ఉబుంటులో సి ప్రోగ్రామింగ్‌లో మేము exec సిస్టమ్ కాల్‌ని ఉపయోగించిన కింది ఉదాహరణను పరిశీలించండి: మాకు ఇక్కడ రెండు c ఫైల్‌లు example.c మరియు hello.c ఉన్నాయి:
ఉదాహరణ. సి
కోడ్:
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(intargc, చార్ *argv[])
{
printf ('ఉదాహరణ యొక్క పిఐడి. సి = %డి n',గెట్‌పిడ్());
చార్ *వాదిస్తుంది[] = {'హలో', 'సి', 'ప్రోగ్రామింగ్',శూన్య};
execv('./హలో',వాదిస్తుంది);
printf ('తిరిగి ఉదాహరణకి');
తిరిగి 0;
}
హలో.సి
కోడ్:
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(intargc, చార్ *argv[])
{
printf ('మేము Hello.c లో ఉన్నాము n');
printf ('PID of hello.c = %d n',గెట్‌పిడ్());
తిరిగి 0;
}
అవుట్‌పుట్:
ఉదాహరణ యొక్క PID.c = 4733మేము Hello.c లో ఉన్నాము
హలో.సి = 4733 యొక్క PID
పై ఉదాహరణలో మనకు ఒక example.c ఫైల్ మరియు hello.c ఫైల్ ఉన్నాయి. ఉదాహరణ. సి ఫైల్‌లో ముందుగా మేము కరెంట్ ప్రాసెస్ ఐడిని ముద్రించాము (ఫైల్ ఉదాహరణ. సి కరెంట్ ప్రాసెస్‌లో రన్ అవుతోంది). తరువాత లైన్‌లో మేము క్యారెక్టర్ పాయింటర్‌ల శ్రేణిని సృష్టించాము. ఈ శ్రేణి యొక్క చివరి మూలకం అంతమయ్యే పాయింట్‌గా శూన్యంగా ఉండాలి.
అప్పుడు మేము execv () ఫంక్షన్‌ను ఉపయోగించాము, ఇది ఫైల్ పేరు మరియు అక్షర పాయింటర్ శ్రేణిని దాని వాదనగా తీసుకుంటుంది. మేము ఇక్కడ ఉపయోగించినట్లు గమనించాలి ./ ఫైల్ పేరుతో, ఇది ఫైల్ యొక్క మార్గాన్ని నిర్దేశిస్తుంది. ఫైల్ example.c నివసించే ఫోల్డర్‌లో ఉన్నందున పూర్తి మార్గాన్ని పేర్కొనవలసిన అవసరం లేదు.
Execv () ఫంక్షన్ అని పిలవబడినప్పుడు, మా ప్రాసెస్ ఇమేజ్ ఇప్పుడు భర్తీ చేయబడుతుంది ఫైల్. Example.c ప్రాసెస్‌లో లేదు కానీ ఫైల్ hello.c ప్రాసెస్‌లో ఉంది. ప్రాసెస్ ID ఒకటే అని చూడవచ్చు, hello.c అనేది ప్రాసెస్ ఇమేజ్ అయినా లేదా example.c అనేది ప్రాసెస్ ఇమేజ్ అయినా ప్రాసెస్ అదే మరియు ప్రాసెస్ ఇమేజ్ మాత్రమే భర్తీ చేయబడుతుంది.
Execv () అమలు చేయన తర్వాత printf () స్టేట్‌మెంట్‌ని మనం ఇక్కడ గమనించాల్సిన మరో విషయం ఉంది. ఎందుకంటే కొత్త ప్రాసెస్ ఇమేజ్ భర్తీ చేసిన తర్వాత కంట్రోల్ పాత ప్రాసెస్ ఇమేజ్‌కి తిరిగి రాదు. ప్రాసెస్ ఇమేజ్‌ని భర్తీ చేయడం విజయవంతం కానప్పుడు నియంత్రణ కాలింగ్ ఫంక్షన్‌కు మాత్రమే వస్తుంది. (ఈ సందర్భంలో రిటర్న్ విలువ -1).
ఫోర్క్ () మరియు exec () సిస్టమ్ కాల్‌ల మధ్య వ్యత్యాసం:
ఫోర్క్ () సిస్టమ్ కాల్ రన్నింగ్ ప్రాసెస్ యొక్క ఖచ్చితమైన కాపీని సృష్టించడానికి ఉపయోగించబడుతుంది మరియు సృష్టించిన కాపీ అనేది పిల్లల ప్రక్రియ మరియు రన్నింగ్ ప్రాసెస్ అనేది పేరెంట్ ప్రాసెస్. అయితే, ఒక ప్రక్రియ చిత్రాన్ని కొత్త ప్రాసెస్ ఇమేజ్‌తో భర్తీ చేయడానికి exec () సిస్టమ్ కాల్ ఉపయోగించబడుతుంది. అందువల్ల exec () సిస్టమ్ కాల్‌లో మాతృ మరియు పిల్లల ప్రక్రియల భావన లేదు.
ఫోర్క్ () సిస్టమ్‌లో పేరెంట్ కాల్ మరియు పిల్లల ప్రక్రియలు ఒకే సమయంలో అమలు చేయబడతాయి. కానీ exec () సిస్టమ్ కాల్‌లో, ప్రాసెస్ ఇమేజ్ రీప్లేస్‌మెంట్ విజయవంతమైతే, ఎగ్జిక్యూట్ ఫంక్షన్ అని పిలవబడే చోటికి కంట్రోల్ తిరిగి రాదు, అది కొత్త ప్రాసెస్‌ను అమలు చేస్తుంది. ఏదైనా లోపం ఉంటే మాత్రమే నియంత్రణ తిరిగి బదిలీ చేయబడుతుంది.
ఉదాహరణ 2: ఫోర్క్ () మరియు exec () సిస్టమ్ కాల్‌లను కలపడం
ఒకే ప్రోగ్రామ్‌లో మేము ఫోర్క్ () మరియు ఎక్సెక్ () సిస్టమ్ కాల్స్ రెండింటినీ ఉపయోగించిన కింది ఉదాహరణను పరిగణించండి:
ఉదాహరణ. సి
కోడ్:
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(intargc, చార్ *argv[])
{
printf ('ఉదాహరణ యొక్క పిఐడి. సి = %డి n',గెట్‌పిడ్());
pid_t p;
p=ఫోర్క్();
ఉంటే(p== -1)
{
printf ('ఫోర్క్ () కి కాల్ చేస్తున్నప్పుడు లోపం ఉంది');
}
ఉంటే(p==0)
{
printf ('మేము పిల్లల ప్రక్రియలో ఉన్నాము n');
printf (చైల్డ్ ప్రాసెస్ నుండి హలో.సికి కాల్ చేస్తోంది n');
చార్ *వాదిస్తుంది[] = {'హలో', 'సి', 'ప్రోగ్రామింగ్',శూన్య};
execv('./హలో',వాదిస్తుంది);
}
లేకపోతే
{
printf ('మేము మాతృ ప్రక్రియలో ఉన్నాము');
}
తిరిగి 0;
}
హలో.సి:
కోడ్:
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(intargc, చార్ *argv[])
{
printf ('మేము Hello.c లో ఉన్నాము n');
printf ('PID of hello.c = %d n',గెట్‌పిడ్());
తిరిగి 0;
}
అవుట్‌పుట్:
ఉదాహరణ యొక్క పిఐడి.సి = 4790మేము మాతృ ప్రక్రియలో ఉన్నాము
మేము చైల్డ్ ప్రాసెస్‌లో ఉన్నాము
పిల్లల ప్రక్రియ నుండి hello.c కి కాల్ చేస్తోంది
మేము hello.c లో ఉన్నాము
PID of hello.c = 4791
ఈ ఉదాహరణలో మేము ఫోర్క్ () సిస్టమ్ కాల్ ఉపయోగించాము. చైల్డ్ ప్రాసెస్ సృష్టించబడినప్పుడు 0 p కి కేటాయించబడుతుంది మరియు తరువాత మేము పిల్లల ప్రక్రియకు వెళ్తాము. ఇప్పుడు if (p == 0) తో స్టేట్‌మెంట్‌ల బ్లాక్ అమలు చేయబడుతుంది. ఒక సందేశం ప్రదర్శించబడుతుంది మరియు మేము execv () సిస్టమ్ కాల్ మరియు ప్రస్తుత చైల్డ్ ప్రాసెస్ ఇమేజ్‌ను ఉపయోగించాము. Execv () కి ముందు కాల్ చైల్డ్ మరియు పేరెంట్ ప్రాసెస్‌లు ఒకే విధంగా ఉంటాయి.
Example.c మరియు hello.c యొక్క PID ఇప్పుడు భిన్నంగా ఉందని చూడవచ్చు. దీనికి కారణం example.c అనేది పేరెంట్ ప్రాసెస్ ఇమేజ్ మరియు hello.c అనేది చైల్డ్ ప్రాసెస్ ఇమేజ్.