మేము లైనక్స్ సిస్టమ్ కాల్ యొక్క నిర్వచనాన్ని పరిశీలించి, దాని అమలు వివరాలను పరిశీలించడానికి ముందు, ఒక సాధారణ లైనక్స్ సిస్టమ్ యొక్క వివిధ సాఫ్ట్వేర్ పొరలను నిర్వచించడంతో ప్రారంభించడం ఉత్తమం.
Linux కెర్నల్ అనేది ఒక ప్రత్యేక ప్రోగ్రామ్, ఇది మీ హార్డ్వేర్లో అందుబాటులో ఉన్న అత్యల్ప స్థాయిలో బూట్ అవుతుంది మరియు నడుస్తుంది. కంప్యూటర్లో అమలు అయ్యే ప్రతిదానిని ఆర్కెస్ట్రేట్ చేసే పని ఇందులో ఉంది, కీబోర్డ్, డిస్క్ మరియు నెట్వర్క్ ఈవెంట్లను హ్యాండిల్ చేయడంతోపాటు, అనేక ప్రోగ్రామ్లను సమాంతరంగా అమలు చేయడానికి టైమ్ స్లైస్లను అందిస్తుంది.
కెర్నల్ వినియోగదారు-స్థాయి ప్రోగ్రామ్ను అమలు చేసినప్పుడు, అది మెమరీ స్థలాన్ని వర్చువలైజ్ చేస్తుంది, తద్వారా ప్రోగ్రామ్లు అవి మెమరీలో నడుస్తున్న ఏకైక ప్రక్రియ అని నమ్ముతాయి. హార్డ్వేర్ మరియు సాఫ్ట్వేర్ ఐసోలేషన్ యొక్క ఈ రక్షిత బబుల్ భద్రత మరియు విశ్వసనీయతను పెంచుతుంది. ప్రత్యేక ప్రోగ్రామ్ ఇతర ప్రోగ్రామ్లకు చెందిన మెమరీని యాక్సెస్ చేయదు మరియు ఆ ప్రోగ్రామ్ క్రాష్ అయినట్లయితే, కెర్నల్ ముగుస్తుంది, తద్వారా అది సిస్టమ్కి హాని కలిగించదు.
Linux సిస్టమ్ కాల్లతో అడ్డంకిని బ్రీచ్ చేయడం
సిస్టమ్లోని ఇతర అనువర్తనాలు మరియు వినియోగదారులను రక్షించడానికి ప్రత్యేక హక్కు లేని అప్లికేషన్ల మధ్య ఈ ఒంటరి పొర అద్భుతమైన సరిహద్దును అందిస్తుంది. అయితే, కంప్యూటర్ మరియు బాహ్య ప్రపంచంలోని ఇతర అంశాలతో ఇంటర్ఫేస్ చేయడానికి కొంత మార్గం లేకుండా, ప్రోగ్రామ్లు ఏమీ సాధించలేవు.
పరస్పర చర్యను సులభతరం చేయడానికి, కెర్నల్ ఒక సాఫ్ట్వేర్ గేట్ని నియమిస్తుంది, ఇది కెర్నల్ దాని తరపున పనిచేయాలని అభ్యర్థించడానికి రన్నింగ్ ప్రోగ్రామ్ని అనుమతిస్తుంది. ఈ ఇంటర్ఫేస్ను సిస్టమ్ కాల్ అంటారు.
Linux అన్నింటికీ సంబంధించిన UNIX తత్వశాస్త్రాన్ని అనుసరిస్తుంది కాబట్టి, ఫైల్ని తెరవడం మరియు చదవడం లేదా వ్రాయడం ద్వారా అనేక విధులు నిర్వహించబడతాయి, ఇది పరికరం కావచ్చు. ఉదాహరణకు, విండోస్లో, యాదృచ్ఛిక బైట్లను యాక్సెస్ చేయడానికి మీరు CryptGenRandom అనే ఫంక్షన్ను ఉపయోగించవచ్చు. కానీ Linux లో, ఇది కేవలం ఫైల్/dev/urandom ని ఓపెన్ చేయడం ద్వారా మరియు ప్రామాణిక ఫైల్ ఇన్పుట్/అవుట్పుట్ సిస్టమ్ కాల్లను ఉపయోగించి బైట్లను చదవడం ద్వారా చేయవచ్చు. ఈ కీలకమైన వ్యత్యాసం సరళమైన సిస్టమ్ కాల్ ఇంటర్ఫేస్ని అనుమతిస్తుంది.
వేఫర్-సన్నని ర్యాపర్
చాలా అప్లికేషన్లలో, సిస్టమ్ కాల్లు నేరుగా కెర్నల్కు చేయబడవు. వాస్తవంగా అన్ని ప్రోగ్రామ్లు ప్రామాణిక సి లైబ్రరీలో లింక్ చేయబడతాయి, ఇది లైనక్స్ సిస్టమ్ కాల్ల చుట్టూ సన్నని కానీ ముఖ్యమైన రేపర్ను అందిస్తుంది. ఫంక్షన్ ఆర్గ్యుమెంట్లు సరైన ప్రాసెసర్ రిజిస్టర్లలోకి కాపీ చేయబడ్డాయని లైబ్రరీ నిర్ధారించుకుని, సంబంధిత లైనక్స్ సిస్టమ్ కాల్ను జారీ చేస్తుంది. కాల్ నుండి డేటాను స్వీకరించినప్పుడు, రేపర్ ఫలితాలను వివరిస్తుంది మరియు దానిని స్థిరమైన రీతిలో ప్రోగ్రామ్కు తిరిగి ఇస్తుంది.
తెర వెనుక
సిస్టమ్తో ఇంటరాక్ట్ అయ్యే ప్రోగ్రామ్లోని ప్రతి ఫంక్షన్ చివరికి సిస్టమ్ కాల్లోకి అనువదించబడుతుంది. దీన్ని చర్యలో చూడటానికి, ప్రాథమిక ఉదాహరణతో ప్రారంభిద్దాం.
శూన్యంప్రధాన() {}
ఇది బహుశా మీరు చూడగలిగే అత్యంత స్వల్పమైన సి ప్రోగ్రామ్. ఇది ప్రధాన ఎంట్రీ పాయింట్ ద్వారా నియంత్రణను పొందుతుంది మరియు తరువాత నిష్క్రమిస్తుంది. మెయిన్ శూన్యమైనదిగా నిర్వచించబడినందున ఇది విలువను కూడా తిరిగి ఇవ్వదు. ఫైల్ను ctest.c గా సేవ్ చేయండి మరియు దానిని కంపైల్ చేద్దాం:
gcc ctest.c -ctestఇది సంకలనం చేయబడిన తర్వాత, మేము ఫైల్ పరిమాణాన్ని 8664 బైట్లుగా చూడవచ్చు. ఇది మీ సిస్టమ్లో కొద్దిగా మారవచ్చు, కానీ అది 8k చుట్టూ ఉండాలి. ప్రవేశించడానికి మరియు నిష్క్రమించడానికి ఇది చాలా కోడ్! ఇది 8k కి కారణం ఏమిటంటే, libc రన్టైమ్ చేర్చబడింది. మేము చిహ్నాలను తీసివేసినప్పటికీ, అది ఇప్పటికీ 6k కంటే ఎక్కువ.
ఇంకా సరళమైన ఉదాహరణలో, లైనక్స్ సిస్టమ్ సి రన్టైమ్ని బట్టి కాకుండా నిష్క్రమించడానికి కాల్ చేయవచ్చు.
శూన్యం_ స్టార్ట్() {asm('movl $ 1,%eax;'
'xorl %ebx, %ebx;'
'int $ 0x80');
}
ఇక్కడ మేము 1 ని EAX రిజిస్టర్లోకి తరలించి, EBX రిజిస్టర్ని క్లియర్ చేయండి (అది తిరిగి వచ్చే విలువను కలిగి ఉంటుంది) తర్వాత Linux సిస్టమ్ కాల్ అంతరాయం 0x80 (లేదా దశాంశంలో 128) కి కాల్ చేయండి. ఈ అంతరాయం మా కాల్ను ప్రాసెస్ చేయడానికి కెర్నల్ను ప్రేరేపిస్తుంది.
మేము asmtest.c అని పిలువబడే మా కొత్త ఉదాహరణను సంకలనం చేసి, చిహ్నాలను తీసివేసి, ప్రామాణిక లైబ్రరీని మినహాయించినట్లయితే:
gcc-లు-nostdlib asmtest.c -o asmtestమేము 1k కంటే తక్కువ బైనరీని ఉత్పత్తి చేస్తాము (నా సిస్టమ్లో, ఇది 984 బైట్లను ఇస్తుంది). ఈ కోడ్లో ఎక్కువ భాగం ఎగ్జిక్యూటబుల్ హెడర్లు. మేము ఇప్పుడు డైరెక్ట్ Linux సిస్టమ్ కాల్కు కాల్ చేస్తున్నాము.
అన్ని ఆచరణాత్మక ప్రయోజనాల కోసం
దాదాపు అన్ని సందర్భాల్లో, మీరు మీ సి ప్రోగ్రామ్లలో నేరుగా సిస్టమ్ కాల్లు చేయాల్సిన అవసరం లేదు. అయితే మీరు అసెంబ్లీ భాషను ఉపయోగిస్తే, అవసరం ఏర్పడవచ్చు. ఏదేమైనా, ఆప్టిమైజేషన్లో, సి లైబ్రరీ ఫంక్షన్లు సిస్టమ్ కాల్లు చేయడానికి మరియు మీ పనితీరు-క్లిష్టమైన కోడ్ని మాత్రమే అసెంబ్లీ ఆదేశాలలో పొందుపరచడానికి ఉత్తమం.
సిస్టమ్ కాల్ ట్యుటోరియల్స్ ప్రోగ్రామ్ చేయడం ఎలా
అన్ని సిస్టమ్ కాల్ల జాబితా
మీరు Linux కోసం అందుబాటులో ఉన్న అన్ని సిస్టమ్ కాల్ల జాబితాను చూడాలనుకుంటే, మీరు ఈ రిఫరెన్స్ పేజీలను తనిఖీ చేయవచ్చు: LinuxHint.com లో సిస్టమ్ కాల్ల పూర్తి జాబితా, filippo.io/linux-syscall-table/ మరియు లేదా syscalls.kernelgrok.com