సిస్టమ్ కాల్ అనేది Linux కెర్నల్‌తో కమ్యూనికేట్ చేయడానికి ఒక ప్రక్రియను అనుమతించే ఫంక్షన్. కంప్యూటర్ ప్రోగ్రామ్ ఆపరేటింగ్ సిస్టమ్ కెర్నల్ నుండి సదుపాయాన్ని ఆర్డర్ చేయడానికి ఇది కేవలం ప్రోగ్రామాటిక్ మార్గం. సిస్టమ్ కాల్స్ ఆపరేటింగ్ సిస్టమ్ వనరులను API (అప్లికేషన్ ప్రోగ్రామింగ్ ఇంటర్‌ఫేస్) ద్వారా యూజర్ ప్రోగ్రామ్‌లకు బహిర్గతం చేస్తుంది. సిస్టమ్ కాల్‌లు కెర్నల్ ఫ్రేమ్‌వర్క్‌ను మాత్రమే యాక్సెస్ చేయగలవు. వనరులు అవసరమైన అన్ని సేవలకు సిస్టమ్ కాల్‌లు అవసరం.
Linux కెర్నల్ అనేది యాజమాన్య సాఫ్ట్‌వేర్, ఇది పరికరంలో కనీసం సంభావ్య దశలో లోడ్ అవుతుంది మరియు పనిచేస్తుంది. కీబోర్డ్, డిస్క్ డ్రైవ్ మరియు నెట్‌వర్క్ ఈవెంట్‌ల నుండి వివిధ ప్రోగ్రామ్‌లను ఏకకాలంలో అమలు చేయడానికి టైమ్ స్లైస్‌లను అందించడం వరకు మెషీన్‌లో జరిగే అన్నింటినీ ఆర్గనైజ్ చేయడం దీని పని. సాఫ్ట్‌వేర్ మరియు హార్డ్‌వేర్‌ల విభజన సురక్షితమైన బుడగను సృష్టిస్తుంది, అది రక్షణ మరియు విశ్వసనీయతను మెరుగుపరుస్తుంది. ప్రత్యేకించబడని అప్లికేషన్‌లు ఇతర ప్రోగ్రామ్ స్టోరేజ్‌ని చేరుకోలేకపోతున్నాయి, మరియు ఒకటి విఫలమైతే, కెర్నల్ ప్రాసెస్‌ను నిలిపివేస్తుంది, తద్వారా అది మొత్తం సిస్టమ్‌ని దెబ్బతీయదు.
పొర సన్నని ర్యాపర్:
కొన్ని ప్రోగ్రామ్‌లలో లైనక్స్ సిస్టమ్ కాల్‌లు కెర్నల్‌కు స్పష్టంగా అందించబడవు. దాదాపు అన్ని ప్రోగ్రామ్‌లు ప్రాథమిక సి లైబ్రరీని ఉపయోగిస్తాయి మరియు లైనక్స్ సిస్టమ్ కాల్‌లలో తేలికైన కానీ అవసరమైన రేపర్‌ను అందిస్తాయి. ఫీచర్ పారామితులు సరైన ప్రాసెసర్ రిజిస్టర్‌లలోకి అనువదించబడిందని నిర్ధారించుకున్న తర్వాత రిపోజిటరీ దానితో పాటుగా లైనక్స్ మెషిన్ కాల్‌ను అందిస్తుంది. సిస్టమ్ కాల్ నుండి రేపర్ డేటాను అందుకున్నప్పుడల్లా, దానిని విశ్లేషించి, ప్రోగ్రామ్‌కు స్పష్టంగా సహకరిస్తుంది. ప్రోగ్రామ్‌లోని ఏదైనా మెషిన్-ఇంటరాక్టివ్ ఆపరేషన్ చివరికి సిస్టమ్ కాల్‌గా మార్చబడుతుంది. కాబట్టి, వాటిలో కొన్నింటిని చూద్దాం. మన లైనక్స్ సిస్టమ్‌లో మనం ఉపయోగించగల లైనక్స్ సిస్టమ్ కాల్‌ల యొక్క సుదీర్ఘ జాబితా ఉంది. కొన్ని సాధారణ మరియు ఎక్కువగా ఉపయోగించే లైనక్స్ సిస్టమ్ కాల్‌ల జాబితా ఇక్కడ ఉంది.
- తెరవండి
- దగ్గరగా
- కార్యనిర్వహణ
- వ్రాయడానికి
- చదవండి
- లీసీక్
- ఎంచుకోండి
మా వ్యాసంలోని సి లాంగ్వేజ్‌ని ఉపయోగించి కొన్ని లైనక్స్ సిస్టమ్ కాల్‌లను చర్చించుకుందాం.
సిస్టమ్ కాల్ తెరువు:
పత్రాన్ని వేగంగా తెరవడానికి మా లైనక్స్ డిస్ట్రిబ్యూషన్‌లో ఓపెన్ సిస్టమ్ కాల్‌ని ఉపయోగించవచ్చు, దీనిని మేము మా సి భాష కోడ్‌లో పేర్కొంటాము. ముందుగా కమాండ్ టెర్మినల్‌ని ప్రారంభించండి. మీరు సత్వరమార్గం Ctrl+Alt+T ని ఉపయోగించవచ్చు. మీరు హోమ్ డైరెక్టరీలో ఒక టెక్స్ట్ ఫైల్ test.txt కలిగి ఉన్నారని అనుకుందాం మరియు దానిలో కొంత కంటెంట్ ఉంటుంది. కాబట్టి, ప్రారంభంలో, మీరు నానో ఎడిటర్ ద్వారా టెర్మినల్‌లో కొత్త సి రకం ఫైల్ పేరు new.c ని సృష్టించాలి. అందువల్ల, దిగువ నానో సూచనలను ప్రయత్నించండి.
$నానోకొత్త సి
ఇప్పుడు, నానో ఎడిటర్ ప్రారంభించబడింది. దిగువ చూపిన కోడ్‌ను అందులో టైప్ చేయండి. కోడ్‌లో మాకు రెండు ఫైల్ డిస్క్రిప్టర్లు ఉన్నాయి. రెండు ఫైల్‌లను ఓపెన్ సిస్టమ్ కాల్ ఉపయోగించి తెరవవచ్చు. మొదటి డిస్క్రిప్టర్‌లో రీడ్ కాల్ ఉంటుంది, రెండవది రైట్ ఫంక్షన్‌ను కలిగి ఉంటుంది. మొదటి ఓపెన్ కాల్ టెక్స్ట్ ఫైల్ test.txt ని తెరిచి దాని కంటెంట్‌ను ఫైల్ డిస్క్రిప్టర్ fd లో సేవ్ చేస్తుంది. రెండవ ఓపెన్ సిస్టమ్ కాల్ లక్ష్యం అనే ఫైల్‌ను సృష్టిస్తోంది. డాక్యుమెంట్ లక్ష్యం fd1 ఫైల్ డిస్క్రిప్టర్‌కి రీయింబర్స్ చేయబడింది. బఫర్‌లోని డేటా బైట్‌లను లిప్యంతరీకరించడానికి వ్రాత సూచన ఉపయోగించబడుతుంది. కోడ్‌ని సేవ్ చేయడానికి Ctrl+S ని నొక్కండి మరియు ఫైల్ నుండి నిష్క్రమించడానికి సత్వరమార్గం కీ Ctrl+X ని నొక్కండి.
ఈ C కోడ్‌ను కంపైల్ చేయడానికి gcc కంపైల్ సూచనను అమలు చేయండి.
$gccకొత్త సి 
క్రింది విధంగా షెల్‌లోని సాధారణ a.out ప్రశ్నను ఉపయోగించి కోడ్‌ను అమలు చేద్దాం:
$./a. అవుట్ 
అవుట్‌పుట్ డేటా ఫైల్ లక్ష్యానికి ప్రసారం చేయబడింది. పిల్లి ప్రశ్నను ఉపయోగించి లక్షిత ఫైల్‌ని తనిఖీ చేద్దాం. అవుట్‌పుట్ స్క్రీన్ లక్ష్యం ఫైల్‌లో 20 అక్షరాల డేటాను చూపుతోంది.
$పిల్లిలక్ష్యం 
Exec సిస్టమ్ కాల్:
ప్రస్తుతం ప్రాసెస్ చేయబడుతున్న ఫైల్‌ను అమలు చేయడానికి exec సిస్టమ్ కాల్ ఆఫ్ చేయబడుతోంది. మునుపటి ఎక్జిక్యూటబుల్ ఫైల్ ప్రత్యామ్నాయం చేయబడింది మరియు ఎక్సెక్ అని పిలవబడినప్పుడు ప్రస్తుత ఫైల్ ఆపరేట్ చేయబడుతుంది. ఎక్సెక్ సిస్టమ్ కాల్‌ని ఉపయోగించడం ద్వారా, అలా చేయడం వల్ల లూప్‌లోని పాత డాక్యుమెంట్ లేదా అప్లికేషన్‌ని తాజా దానితో భర్తీ చేయవచ్చని మనం అనుకోవచ్చు. మొత్తం సాఫ్ట్‌వేర్‌ని భర్తీ చేయడానికి కొత్త సాఫ్ట్‌వేర్ ఉపయోగించబడుతుంది. Exec () సిస్టమ్ కాల్ () అమలు చేసే యూజర్ ఇన్ఫర్మేషన్ సెక్షన్ కోసం ప్రత్యామ్నాయంగా exec () ని పిలిచినప్పుడు స్టేట్‌మెంట్‌లో టైటిల్ ఇవ్వబడిన డాక్యుమెంట్. కాబట్టి కమాండ్ టెర్మినల్‌ని తెరిచి, నానో ఎడిటర్‌ని ఉపయోగించి, కొత్త C రకం ఫైల్‌ని ఈ క్రింది విధంగా సృష్టించండి:
$నానోexp.c 
ఎడిటర్ ఇప్పుడు తెరవబడింది. దిగువ సి భాష కోడ్ మొత్తాన్ని అందులో వ్రాయండి. ఇందులో మూడు ప్రధాన గ్రంథాలయాలు ఉన్నాయి. ఆ తరువాత, ప్రధాన ఫంక్షన్ తక్షణం చేయబడింది. ప్రింట్ స్టేట్‌మెంట్ స్ట్రింగ్ డేటా మరియు ఎక్స్‌ప్రెస్ ఫైల్ యొక్క ప్రాసెస్ ఐడిని చూపుతోంది. ఈ ప్రయోజనం కోసం గెట్‌పిడ్ () ఫంక్షన్ ఉపయోగించబడింది. అప్పుడు మనలో కొన్ని విలువలతో కూడిన అక్షర రకం శ్రేణి ఉంటుంది. ఎక్సెక్ సిస్టమ్ కాల్ ఫైల్ పేరు మరియు శ్రేణి పైన ఉన్న ఒక-లైన్ వాదనగా తీసుకోవడానికి ఉపయోగించబడింది. ఇప్పుడు hello.c ఫైల్ ప్రాసెస్ చేయబడుతుంది. ఆ తరువాత, మరొక ముద్రణ ప్రకటన ఇప్పటివరకు వచ్చింది, కానీ అది ఎప్పటికీ అమలు చేయబడదు. ఈ ఫైల్‌ను సేవ్ చేయడానికి Ctrl+S నొక్కండి. నిష్క్రమించడానికి Ctrl+X నొక్కండి.
ఇప్పుడు నానో ఎడిటర్‌ని ఉపయోగించి hello.c అనే మరొక c ఫైల్‌ను సృష్టించే సమయం వచ్చింది. అలా చేయడానికి షెల్‌లోని దిగువ ప్రశ్నను ఉపయోగించండి.
$నానోహలో.సి 
దిగువ కోడ్‌ను దానిలో వ్రాయండి. ఈ కోడ్ ప్రధాన ఫంక్షన్‌లో రెండు ప్రింట్ స్టేట్‌మెంట్‌లను కలిగి ఉంది. మొదటిది దానిలో ఇచ్చిన స్ట్రింగ్‌ను మాత్రమే ముద్రించడం, మరియు రెండవది ప్రస్తుతం ఉపయోగించే ఫైల్ యొక్క ప్రాసెస్ ఐడిని తీసుకునేటప్పుడు స్ట్రింగ్‌ను ముద్రించడం, ఇది hello.c.
Gcc ఉపయోగించి రెండు ఫైల్‌లను ఒకదాని తర్వాత ఒకటి కంపైల్ చేద్దాం.
$gcc–O exp exp.c 
మేము exp.c ఫైల్‌ను అమలు చేసినప్పుడు, అది exp.c ఫైల్ నుండి మొదటి ముద్రణ స్టేట్‌మెంట్‌ను మరియు hello.c ఫైల్ నుండి రెండు ప్రింట్ లైన్‌లను అవుట్‌పుట్ చేస్తుంది.
$./exp 
ముగింపు:
మేము Linux సిస్టమ్ కాల్స్ యొక్క మొత్తం కాన్సెప్ట్ గురించి మరియు వాటిని మీ Linux సిస్టమ్‌లో ఎలా ఉపయోగించవచ్చో వివరించాము. ఈ భావనను అమలు చేస్తున్నప్పుడు మేము ఉబుంటు 20.04 ని ఉపయోగించాము.