లైనక్స్ కెర్నల్ అందించిన సిస్టమ్ కాల్‌లు సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో గ్లిబిసి ద్వారా బహిర్గతమవుతాయి. సిస్టమ్ కాల్ ఉపయోగించినప్పుడు, మీరు OS కి కమ్యూనికేట్ చేస్తున్నారు మరియు సిస్టమ్ కాల్ ఫంక్షన్లకు (రిటర్న్ వాల్యూస్) తిరిగి వచ్చే పారామితుల ద్వారా OS మీకు కమ్యూనికేట్ చేస్తుంది.
స్టాట్ సిస్టమ్ కాల్:
స్టాట్ సిస్టమ్ కాల్ అనేది ఫైల్ యాక్సెస్ చేయబడినప్పుడు తనిఖీ చేయడం వంటి ఫైల్ యొక్క స్థితిని తనిఖీ చేయడానికి లైనక్స్‌లో సిస్టమ్ కాల్. స్టాట్ () సిస్టమ్ కాల్ వాస్తవానికి ఫైల్ లక్షణాలను అందిస్తుంది. ఐనోడ్ యొక్క ఫైల్ లక్షణాలు ప్రాథమికంగా స్టాట్ () ఫంక్షన్ ద్వారా తిరిగి ఇవ్వబడతాయి. ఒక ఐనోడ్ ఫైల్ యొక్క మెటాడేటాను కలిగి ఉంటుంది. ఒక ఐనోడ్ కలిగి ఉంటుంది: ఫైల్ రకం, ఫైల్ పరిమాణం, ఫైల్ యాక్సెస్ చేసినప్పుడు (సవరించిన, తొలగించబడిన) టైమ్ స్టాంప్స్, మరియు ఫైల్ యొక్క మార్గం, యూజర్ ఐడి మరియు గ్రూప్ ఐడి, ఫైల్ లింక్‌లు , మరియు ఫైల్ కంటెంట్ యొక్క భౌతిక చిరునామా.
స్టాట్ () సిస్టమ్ కాల్‌కు అవసరమైన మొత్తం డేటాను ఐనోడ్ కలిగి ఉందని మేము చెప్పగలం మరియు ఇది ఐనోడ్ టేబుల్‌లో సేవ్ చేయబడిన ఫైల్ కోసం ఇండెక్స్ నంబర్. మీరు ఫైల్‌ను సృష్టించినప్పుడల్లా ఆ ఫైల్ కోసం ఒక ఐనోడ్ నంబర్ సృష్టించబడుతుంది. స్టాట్ సిస్టమ్ కాల్ ఉపయోగించి సిస్టమ్ టేబుల్స్ చూడవచ్చు.
సి స్టాట్ సిస్టమ్ కాల్ సింటాక్స్:
సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో స్టాట్ సిస్టమ్ కాల్‌ని ఉపయోగించడానికి, మీరు ఈ క్రింది హెడర్ ఫైల్‌ని చేర్చాలి:
#చేర్చండి
ఫైల్ యొక్క స్థితిని పొందడానికి స్టాట్ ఉపయోగించబడుతుంది. సి స్టాట్ సిస్టమ్ కాల్ సింటాక్స్ ప్రతి ఆపరేటింగ్ సిస్టమ్‌కు ఒకేలా ఉండకపోవచ్చు. Linux లో స్టాట్ సిస్టమ్ కాల్ కోసం వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
intరాష్ట్రం(కానిస్టేట్ చార్ *మార్గం, నిర్మాణాత్మకరాష్ట్రం*బఫ్)
Int లోని ఫంక్షన్ యొక్క రిటర్న్ రకం, ఫంక్షన్ విజయవంతంగా అమలు చేయబడితే, ఏవైనా లోపాలు ఉంటే 0 తిరిగి ఇవ్వబడుతుంది, -1 తిరిగి ఇవ్వబడుతుంది.
ఇక్కడ const char *మార్గం ఫైల్ పేరును నిర్దేశిస్తుంది. ఫైల్ మార్గం సింబాలిక్ లింక్ అయితే మీరు ఫైల్ పేరుకు బదులుగా లింక్‌ను పేర్కొనాలి.
అప్పుడు ఫంక్షన్‌లో మనకు స్టాట్ స్ట్రక్చర్ ఉంది, దీనిలో డేటా లేదా ఫైల్ గురించి సమాచారం నిల్వ చేయబడుతుంది, ఇది పేరు పెట్టబడిన పాయింటర్‌ని ఉపయోగిస్తుంది బఫ్, ఇది పారామీటర్‌గా పంపబడుతుంది మరియు కాల్ అమలు సమయంలో నింపబడుతుంది మరియు కాల్ తర్వాత వినియోగదారు చదవగలరు.
స్టాట్ నిర్మాణం:
హెడర్ ఫైల్‌లో నిర్వచించబడిన స్టాట్ స్ట్రక్చర్ కింది ఫీల్డ్‌లను కలిగి ఉంది:
నిర్మాణాత్మకరాష్ట్రం{
mode_t st_mode;
ino_t st_ino;
dev_t st_dev;
dev_t st_rdev;
nlink_t st_nlink;
uid_t st_uid;
gid_t st_gid;
ఆఫ్_టిst_ సైజు;
నిర్మాణాత్మకtimspec st_atim;
నిర్మాణాత్మకtimspec st_mtim;
నిర్మాణాత్మకtimspec st_ctim;
blksize_t st_blksize;
blkcnt_t st_blocks;
};
వివరణ:
- st_dev: ఇది ప్రస్తుతం మా ఫైల్‌లో ఉన్న పరికరం యొక్క ID.
- st_rdev: ఒక నిర్దిష్ట ఫైల్ ఒక నిర్దిష్ట పరికరాన్ని సూచిస్తుందని ఈ ఫీల్డ్ వివరిస్తుంది.
- st_ino: ఇది ఐనోడ్ నంబర్ లేదా ఫైల్ సీరియల్ నంబర్. ఇది ఇండెక్స్ నంబర్ కనుక ఇది అన్ని ఫైల్‌లకు ప్రత్యేకంగా ఉండాలి
- st_ పరిమాణం: st_size అనేది బైట్‌లలో ఫైల్ పరిమాణం.
- st_atime: ఫైల్‌ని యాక్సెస్ చేయడం చివరిసారి లేదా ఇటీవలి సమయం.
- st_ctime: ఫైల్ యొక్క స్థితి లేదా అనుమతులు మార్చబడిన ఇటీవలి సమయం ఇది.
- st_mtime: ఇది ఫైల్ సవరించిన ఇటీవలి సమయం.
- st_blksize: ఈ ఫీల్డ్ I/O ఫైల్ సిస్టమ్ కొరకు ప్రాధాన్య బ్లాక్ పరిమాణాన్ని ఇస్తుంది, ఇది ఫైల్ నుండి ఫైల్‌కు మారవచ్చు.
- st_blocks: ఈ ఫీల్డ్ 512 బైట్ల గుణిజాలలో మొత్తం బ్లాక్‌ల సంఖ్యను తెలియజేస్తుంది.
- st_nlink: ఈ ఫీల్డ్ మొత్తం హార్డ్ లింక్‌ల సంఖ్యను తెలియజేస్తుంది.
- st_uid: ఈ ఫీల్డ్ వినియోగదారు ID ని సూచిస్తుంది.
- st_gid: ఈ ఫీల్డ్ గ్రూప్ ID ని సూచిస్తుంది.
- st_mode: ఇది ఫైల్‌లోని అనుమతులను సూచిస్తుంది, ఫైల్‌లోని మోడ్‌లను తెలియజేస్తుంది. St_mode ఫీల్డ్ కోసం నిర్వచించాల్సిన ఫ్లాగ్‌లు క్రింది విధంగా ఉన్నాయి:
| జెండాలు | వివరణ | ఫ్లాగ్ విలువ |
|---|---|---|
| S_IFMT | ఒక ఫైల్ యొక్క మోడ్ విలువను పొందడానికి ఒక బిట్‌మాస్క్ ఉపయోగించబడుతుంది | 0170000 |
| S_IFSOCK | సాకెట్ యొక్క ఫైల్ స్థిరాంకం | 0140000 |
| S_IFLINK | సింబాలిక్ లింక్ యొక్క ఫైల్ స్థిరాంకం | 0120000 |
| S_IFREG | సాధారణ ఫైల్ కోసం ఫైల్ స్థిరాంకం | 0100000 |
| S_IFBLK | బ్లాక్ ఫైల్ కోసం ఫైల్ స్థిరాంకం | 0060000 |
| S_IFDIR | డైరెక్టరీ ఫైల్ కోసం ఫైల్ స్థిరాంకం | 0040000 |
| S_IFCHR | అక్షర ఫైల్ కోసం ఫైల్ స్థిరాంకం | 0020000 |
| S_IFIFO | ఫైఫో స్థిరాంకం | 0010000 |
| S_ISUID | వినియోగదారు ID బిట్ సెట్ చేయండి | 0004000 |
| S_ISGID | గ్రూప్ ఐడి బిట్ సెట్ చేయండి | 0002000 |
| S_ISVTX | భాగస్వామ్య వచనాన్ని సూచించే స్టిక్కీ బిట్ | 0001000 |
| S_IRWXU | యజమాని అనుమతులు (చదవడం, రాయడం, అమలు చేయడం) | 00700 |
| S_IRUSR | యజమాని కోసం అనుమతులను చదవండి | 00400 |
| S_IWUSR | యజమాని కోసం అనుమతులను వ్రాయండి | 00200 |
| S_IXUSR | యజమాని కోసం అనుమతులను అమలు చేయండి | 00100 |
| S_IRWXG | సమూహ అనుమతులు (చదవడం, రాయడం, అమలు చేయడం) | 00070 |
| S_IRGRP | సమూహం కోసం అనుమతులను చదవండి | 00040 |
| S_IWGRP | సమూహానికి అనుమతులను వ్రాయండి | 00020 |
| S_IXGRP | సమూహానికి అనుమతులను అమలు చేయండి | 00010 |
| S_IRWXO | ఇతరుల కోసం అనుమతులు (చదవడం, రాయడం, అమలు చేయడం) | 00007 |
| S_IROTH | ఇతరుల కోసం అనుమతులను చదవండి | 00004 |
| S_IWOTH | ఇతరుల కోసం అనుమతులను వ్రాయండి | 00002 |
| S_IXOTH | ఇతరులకు అనుమతులను అమలు చేయండి | 00001 |
స్టాట్ సిస్టమ్ కాల్ ఎలా ఉపయోగించాలి:
కింది ఉదాహరణ ఉబుంటులోని లైనక్స్‌లో సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో స్టాట్ సిస్టమ్ కాల్‌ను ఎలా ఉపయోగించాలో చూపుతుంది.
ఉదాహరణ 1:
కింది కోడ్‌లో మేము ఫైల్ మోడ్‌ను కనుగొనబోతున్నాము:
కోడ్:
#చేర్చండి#చేర్చండి
intప్రధాన()
{
// స్టాటర్ స్ట్రక్చర్‌కి పాయింటర్
నిర్మాణాత్మకరాష్ట్ర sfile;
// స్టాట్ సిస్టమ్ కాల్
రాష్ట్రం('stat.c', &sfile);
// st_mode యాక్సెస్ చేయడం (స్టాట్ స్ట్రక్ట్ యొక్క డేటా మెంబర్)
printf ('st_mode = %o',sfile.st_mode);
తిరిగి 0;
}
ప్రోగ్రామ్‌ను కంపైల్ చేయడం మరియు అమలు చేయడం క్రింది విధంగా వస్తుంది:
ఈ కోడ్‌లో, మేము ఫైల్ పేరును స్టాట్ సిస్టమ్ కాల్‌లో పాస్ చేసాము, ఆపై పాయింటర్ నుండి స్టాట్ స్ట్రక్ట్ వరకు ఉన్నది. పాయింట్ల నుండి స్టాట్ స్ట్రక్ట్ తరువాత st_mode ని యాక్సెస్ చేయడానికి ఉపయోగించబడుతుంది, ఇది printf స్టేట్‌మెంట్ ఉపయోగించి ఫైల్ మోడ్‌ను ప్రదర్శిస్తుంది.
హెడర్ ఫైల్ ఉపయోగించబడింది కాబట్టి మీరు స్టాట్ సిస్టమ్ కాల్‌ను ఉపయోగించవచ్చు. హెడర్ ఫైల్ అనేది ప్రామాణిక ఇన్‌పుట్/అవుట్‌పుట్ లైబ్రరీ ఫైల్ కాబట్టి మీరు మీ C కోడ్‌లో printf లేదా scanf ఉపయోగించవచ్చు.
ఉదాహరణ 2:
కింది కోడ్‌లో మేము స్టాట్ సిస్టమ్ కాల్ ఉపయోగించి ఫైల్ గురించి సమాచారాన్ని పొందబోతున్నాము:
కోడ్:
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
శూన్యంsfile(చార్ కానిస్టేట్ఫైల్ పేరు[]);
intప్రధాన(){
ssize_t చదవండి;
చార్*బఫర్= 0;
పరిమాణం_టిbuf_ సైజు= 0;
printf (తనిఖీ చేయడానికి ఫైల్ పేరును నమోదు చేయండి: n');
చదవండి=గెట్‌లైన్(&బఫర్, &buf_ సైజు,stdin);
ఉంటే (చదవండి<=0 ){
printf ('గెట్‌లైన్ విఫలమైంది n');
బయటకి దారి (1);
}
ఉంటే (బఫర్[చదవండి-1] == ' n'){
బఫర్[చదవండి-1] = 0;
}
intలు=తెరవండి(బఫర్,O_RDONLY);
ఉంటే(లు== -1){
printf ('ఫైల్ ఉనికిలో లేదు n');
బయటకి దారి (1);
}
లేకపోతే{
sfile(బఫర్);
}
ఉచిత (బఫర్);
తిరిగి 0;
}
శూన్యంsfile(చార్ కానిస్టేట్ఫైల్ పేరు[]){
నిర్మాణాత్మకరాష్ట్ర sfile;
ఉంటే(రాష్ట్రం(ఫైల్ పేరు, &sfile)== -1){
printf ('లోపం సంభవించింది n');
}
// స్టాట్ స్ట్రక్ట్ యొక్క డేటా సభ్యులను యాక్సెస్ చేస్తోంది
printf (' nఫైల్ st_uid %d n',sfile.st_uid);
printf (' nఫైల్ st_blksize %ld n',sfile.st_blksize);
printf (' nఫైల్ st_gid %d n',sfile.st_gid);
printf (' nఫైల్ st_blocks %ld n',sfile.st_ బ్లాక్స్);
printf (' nఫైల్ st_size %ld n',sfile.st_ సైజు);
printf (' nఫైల్ st_nlink% u n',(సంతకం చేయలేదు int)sfile.st_nlink);
printf (' nఫైల్ అనుమతుల వినియోగదారు n');
printf ((sfile.st_mode &S_IRUSR)? 'r':'-');
printf ((sfile.st_mode &S_IWUSR)? 'లో':'-');
printf ((sfile.st_mode &S_IXUSR)? 'x':'-');
printf (' n');
printf (' nఫైల్ అనుమతుల సమూహం n');
printf ((sfile.st_mode &S_IRGRP)? 'r':'-');
printf ((sfile.st_mode &S_IWGRP)? 'లో':'-');
printf ((sfile.st_mode &S_IXGRP)? 'x':'-');
printf (' n');
printf (' nఫైల్ అనుమతులు ఇతర n');
printf ((sfile.st_mode &S_IROTH)? 'r':'-');
printf ((sfile.st_mode &S_IWOTH)? 'లో':'-');
printf ((sfile.st_mode &S_IXOTH)? 'x':'-');
printf (' n');
}
అవుట్‌పుట్:
పై C కోడ్‌లో, మేము ఫైల్ పేరును నమోదు చేసాము మరియు ఫైల్ లేనట్లయితే ప్రోగ్రామ్ అమలు నిలిపివేయబడుతుంది. ఇది క్రింది చిత్రంలో ప్రదర్శించబడింది:
మా ఫైల్ ఉనికిలో ఉంటే, ఫంక్షన్ sfile (n) అని పిలువబడుతుంది, దీనిలో మేము ఫైల్ పేరును పాస్ చేసాము. ఫంక్షన్ లోపల, మొదటగా మేము స్టాట్ సిస్టమ్ కాల్‌ని ఉపయోగించాము, స్టాట్ () రిటర్న్స్ -1 ఉంటే అప్పుడు ఏదైనా దోషం తప్పదు కాబట్టి మెసేజ్ ప్రింట్ చేయబడుతుంది మరియు ప్రోగ్రామ్ అమలు నిలిపివేయబడుతుంది.
అప్పుడు printf స్టేట్‌మెంట్‌లో మేము డేటా సభ్యులను యాక్సెస్ చేయడానికి ఫంక్షన్ మరియు డాట్ సెపరేటర్ పేరును ఉపయోగించాము స్టాట్ స్ట్రక్ట్ .
అప్పుడు ఫైల్ మోడ్ కోసం మేము st_mode యొక్క మాక్రోలు లేదా ఫ్లాగ్‌లను యాక్సెస్ చేసాము. సంబంధిత మోడ్‌లను ముద్రించడానికి ఇక్కడ లాజికల్ మరియు ఆపరేటర్ ఉపయోగించబడుతుంది. పేర్కొన్న ఫైల్ (వినియోగదారు నమోదు చేసిన ఫైల్ పేరు) కోసం మేము వినియోగదారు, సమూహం మరియు ఇతరుల కోసం అనుమతుల కోసం తనిఖీ చేసాము.
దీనితో మీరు ఫైల్స్ గురించి OS కెర్నల్ నుండి సమాచారాన్ని పొందడానికి C ప్రోగ్రామింగ్ లాంగ్వేజ్ నుండి స్టాట్ సిస్టమ్ కాల్ ఎలా ఉపయోగించాలో చూడవచ్చు. మీకు ఏవైనా ప్రశ్నలు ఉంటే సంకోచించకండి వ్యాఖ్య విభాగం ద్వారా మాకు చెప్పండి.