లైనక్స్ OS మరియు ప్రోగ్రామ్‌లలో డోర్‌వే అందించడానికి లైనక్స్ డిస్ట్రిబ్యూషన్లలో సిస్టమ్ కాల్స్ ఉపయోగించబడతాయి. లైనక్స్ ఆపరేటింగ్ సిస్టమ్ సి లాంగ్వేజ్‌ని ఉపయోగిస్తున్నప్పుడు సిస్టమ్ కాల్‌లకు మద్దతు ఇవ్వడానికి గ్లిబ్‌సి లైబ్రరీని ఉపయోగిస్తుంది. సిస్టమ్ కాల్‌లను ఉపయోగించడానికి ఇంకా చాలా మార్గాలు ఉన్నాయి. ఈ ఆర్టికల్ గైడ్‌లో, మేము లైనక్స్ సిస్టమ్‌లో ఓపెన్ సిస్టమ్ కాల్ గురించి చర్చిస్తాము. ఓపెన్ సిస్టమ్ కాల్ పాత్‌లో పేర్కొన్న ఫైల్‌ను త్వరగా తెరవడానికి ఉపయోగించబడింది. ఇది వినియోగదారు సృష్టించిన ఫైల్ యొక్క ఫైల్ డిస్క్రిప్టర్ గురించి మాకు తెలియజేస్తుంది. మేము ఓపెన్ సిస్టమ్ కాల్‌ని పొందడానికి ఉబుంటు 20.04 ని ఉపయోగిస్తున్నాము.
లైబ్రరీలను ఇన్‌స్టాల్ చేయండి
సి భాషకు కొన్ని అదనపు లైబ్రరీ ప్యాకేజీలు అవసరం. ముందుగా, సిస్టమ్ కాల్‌లకు సంబంధించిన సమాచారాన్ని తనిఖీ చేయడానికి మీరు manpages-dev ప్యాకేజీని ఇన్‌స్టాల్ చేయాలి. కార్యాచరణ ప్రాంతం నుండి కమాండ్ లైన్ టెర్మినల్‌ను తెరిచి, మ్యాన్‌పేజీలను ఇన్‌స్టాల్ చేయడానికి క్రింది సూచనలను అమలు చేయండి.
$ sudo apt మ్యాన్‌పేజీలను ఇన్‌స్టాల్ చేయండి-దేవ్
ఇన్‌స్టాలేషన్ పూర్తి చేయడానికి అవుట్‌పుట్ క్రింద ఇవ్వబడింది.
ఇప్పుడు మేము ఈ క్రింది విధంగా man ఆదేశాన్ని ఉపయోగించి ఓపెన్ సిస్టమ్ కాల్ కోసం తనిఖీ చేస్తాము.
$ మనిషి2తెరవండి 
ఓపెన్ సిస్టమ్ కాల్ కోసం అవుట్‌పుట్ మ్యాన్ పేజీ క్రింద చూపబడింది. దానికి సంబంధించిన అదనపు సమాచారాన్ని మీరు చూడవచ్చు. నిష్క్రమించడానికి q బటన్ నొక్కండి.
సిస్టమ్ కాల్స్ కోసం జోడించాల్సిన అవసరమైన లైబ్రరీలలో మొదటి మూడు లైన్లను పై వాక్యనిర్మాణం చూపిస్తుంది. ఓపెన్ సిస్టమ్ కాల్ కోసం మూడు వాక్యనిర్మాణాలు అందుబాటులో ఉన్నాయి. మొదటి వాక్యనిర్మాణం మార్గం పేరును చూపుతుంది, ఇది తెరవాల్సిన ఫైల్ పేరు. రెండవ పరామితి, ఫ్లాగ్‌లు, ఫైల్ మోడ్‌ను చూపుతాయి, ఉదా., చదవడం లేదా వ్రాయడం. ఫైల్ లేనప్పుడు రెండవ వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు. పారామీటర్ మోడ్ ఫైల్‌లోని అధికారాలను చూపించడానికి ఉపయోగించబడుతుంది.
ఇప్పుడు ఉబుంటు 20.04 లైనక్స్ డిస్ట్రిబ్యూషన్‌లో సి కోడ్ డీబగ్గింగ్ కోసం GCC కంపైలర్‌ని ఇన్‌స్టాల్ చేసే సమయం వచ్చింది. దాని కోసం, అలా చేయడానికి షెల్‌లోని దిగువ సూచనలను అమలు చేయండి.
$ sudo apt gcc ని ఇన్‌స్టాల్ చేయండి 
GCC కంపైలర్‌ని ఇన్‌స్టాల్ చేయడం కొనసాగించడానికి Y ని నొక్కడం అవసరం, లేకపోతే ఇన్‌స్టాలేషన్‌ను మూసివేయడానికి n బటన్ నొక్కండి. కాబట్టి y బటన్ నొక్కండి మరియు కొనసాగించడానికి ఎంటర్ నొక్కండి.
పూర్తి చేయడానికి అవుట్‌పుట్ క్రింద చూపబడింది.
ఉదాహరణ 01
ఓపెన్ సిస్టమ్ కాల్ యొక్క చాలా సరళమైన ఉదాహరణను చూద్దాం. ముందుగా, కమాండ్ షెల్‌ని తెరిచి, సాధారణ టచ్ కమాండ్‌ని ఉపయోగించి కొత్త టెక్స్ట్ ఫైల్ test.txt ను ఈ క్రింది విధంగా సృష్టించండి:
$స్పర్శtest.txt 
దీనికి కొంత డేటాను మాన్యువల్‌గా జోడించండి. దిగువ పిల్లి ఆదేశాన్ని ఉపయోగించి మీరు ఫైల్‌లో డేటాను చూడవచ్చు.
$పిల్లిtest.txt 
ఇప్పుడు క్రింద చూపిన విధంగా షెల్‌లోని నానో కమాండ్‌ని ఉపయోగించి కొత్త సి ఫైల్‌ను సృష్టిద్దాం.
$నానోకొత్త సి 
దిగువ GNU నానో ఫైల్ తెరవబడుతుంది. మీరు దిగువ C భాష కోడ్‌ను టైప్ చేయాలి. సి కోడ్ సరిగ్గా అమలు చేయడానికి అవసరమైన లైబ్రరీ ప్యాకేజీలను మేము జోడించామని మీరు చూడవచ్చు. ఆ తరువాత, మేము ఓపెన్ సిస్టమ్ కాల్‌లో పని చేయడానికి ప్రధాన ఫంక్షన్‌ను నిర్వచించాము. మేము రెండు పూర్ణాంక వేరియబుల్స్ ప్రకటించాము. బఫర్ విలువలను లెక్కించడానికి n వేరియబుల్ ఉపయోగించబడుతుంది మరియు ఫైల్ డిస్క్రిప్టర్ కోసం fd ఉపయోగించబడుతుంది. మేము అక్షర రకం బఫర్ శ్రేణిని 50 పరిమాణం కలిగిన బఫ్‌గా ప్రకటించాము. ఫైల్ test.txt నుండి కంటెంట్‌ను చదవడానికి మరియు ఫైల్ డిస్క్రిప్టర్‌కు తిరిగి ఇవ్వడానికి ఓపెన్ సిస్టమ్ కాల్ ఉపయోగించబడింది. O_RDONLY పఠన ప్రయోజనాల కోసం ఉపయోగించబడింది. తదుపరి లైన్ బఫర్ నుండి 10 బైట్‌లను సేకరించి, పూర్ణాంకం n లోకి తిరిగి ఇవ్వడానికి రీడ్ సిస్టమ్ కాల్‌ను చూపుతుంది. అలాగే, ఫైల్ డిస్క్రిప్టర్‌లోకి కంటెంట్ లేదా బఫర్ డేటాను వ్రాయడానికి రైట్ కమాండ్ ఉపయోగించబడింది, ఇది ప్రస్తుతం మా విషయంలో అవుట్‌పుట్ స్క్రీన్. Ctrl+S ఉపయోగించి ఈ ఫైల్‌ని సేవ్ చేయండి మరియు Ctrl+X ఆదేశాన్ని ఉపయోగించి దాన్ని మూసివేయండి.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
intఎన్,ఎఫ్ డి;
చార్బఫ్[యాభై];
ఎఫ్ డి=తెరవండి(పరీక్ష.పదము,O_RDONLY);
ఎన్=చదవండి(ఎఫ్ డి,బఫ్, 10);
వ్రాయడానికి(1 ,బఫ్, 10);
దిగువ gcc ఆదేశాన్ని ఉపయోగించి ఓపెన్ సిస్టమ్ కాల్ కోసం ముందుగా C కోడ్‌ను కంపైల్ చేద్దాం.
$gccకొత్త సి 
ఓపెన్ సిస్టమ్ కాల్ కోసం ఇప్పుడు C కోడ్ కోసం అవుట్‌పుట్‌ను తనిఖీ చేసే సమయం వచ్చింది. షెల్‌లో దిగువ a.out ఆదేశాన్ని ఉపయోగిద్దాం. అవుట్‌పుట్ ఫైల్ test.txt లోని కంటెంట్ నుండి 10 బైట్‌లను ప్రదర్శిస్తుంది.
$/కు.బయటకు 
ఓపెన్ సిస్టమ్ కాల్ ఉపయోగించి ఒక ఫైల్ యొక్క కంటెంట్‌లను మరొక ఫైల్‌లోకి వ్రాయడానికి మరొక ఉదాహరణ తీసుకుందాం. దిగువన ఉన్న నానో ఆదేశాన్ని ఉపయోగించి కొత్త C ఫైల్‌ను సృష్టించడానికి.
$ నానో కొత్తది.c 
కాబట్టి చిన్న కోడ్‌తో అదే కోడ్‌ని తీసుకోండి. మేము కోడ్‌లోని మరొక ఫైల్ డిస్క్రిప్టర్‌ను fd1 గా నిర్వచించాము. ఒక అదనపు లైన్ మినహా అన్ని కోడ్‌లు ఒకే విధంగా ఉంటాయి. కోడ్ యొక్క రెండవ చివరి లైన్ ఓపెన్ సిస్టమ్ కాల్‌ని ఉపయోగించి O_CREAT మరియు మోడ్‌ని ఉపయోగించి లక్ష్యం పేరుతో ఒక కొత్త ఫైల్‌ని సృష్టించడానికి, O_WRONLY గా మాత్రమే వ్రాయండి. 0642 ఈ ఫైల్‌కు కేటాయించిన అధికారాలను చూపుతుంది. మరియు ఫైల్ కొత్త ఫైల్ డిస్క్రిప్టర్‌కు తిరిగి ఇవ్వబడింది. తదుపరి లైన్ దాని ఫైల్ డిస్క్రిప్టర్ ప్రకారం బఫర్‌లో కంటెంట్ బైట్‌లను వ్రాయమని ఆదేశాన్ని చూపించింది. ఫైల్‌ను సేవ్ చేసి దాన్ని మూసివేయండి.
C భాష ఫైల్‌ని డీబగ్ చేయడానికి gcc కంపైల్ ఆదేశాన్ని అమలు చేయండి.
$ gcc కొత్తది.cC కోడ్ యొక్క అవుట్‌పుట్‌ను ప్రదర్శించడానికి, షెల్‌లోని a.out సూచనను క్రింది విధంగా ప్రయత్నించండి. అవుట్‌పుట్ లేదు ఎందుకంటే కొత్తగా సృష్టించబడిన ఫైల్ లక్ష్యానికి అవుట్‌పుట్ మళ్ళించబడింది.
$/కు.బయటకుపిల్లి ఆదేశాన్ని ఉపయోగించి ఫైల్ లక్ష్యం యొక్క డేటాను తనిఖీ చేద్దాం. ఫైల్‌లో 20 బైట్‌లు ఉన్నాయని అవుట్‌పుట్ చూపుతుంది.
$ పిల్లి లక్ష్యం 
ముగింపు
పై ట్యుటోరియల్‌లో, gcc కంపైలర్‌ను ఉపయోగించడం ద్వారా C భాషలో ఓపెన్ సిస్టమ్ కాల్‌ను ఉపయోగించమని మేము మీకు వివరించాము. ఈ గైడ్‌లో వివరించిన విభిన్న ఉదాహరణల సహాయంతో మీకు కావలసిన ప్రోగ్రామ్‌ను అమలు చేయడానికి దారి తీస్తుంది.