chmod 755 vs u+x: Linux permissions తేడా ఏమిటి

chmod ఏమి మారుస్తుంది

chmod ఫైల్ లేదా directoryలోని permission bits ను మారుస్తుంది. ఈ bits ను రెండు notationలలో ఏదో ఒకదానిలో అందుకోవచ్చు. Numeric రూపం ప్రతి permission bit ను ఒకేసారి భర్తీ చేసే octal number. Symbolic రూపం user class మరియు operator ను పేర్కొంటుంది. మీరు పేర్కొన్న bits ను మాత్రమే ఇది సవరిస్తుంది. రెండూ చివరకు అదే system call కు దారితీస్తాయి. మీరు పేర్కొనని bits కు ఏమి జరుగుతుందన్నదే వాటి మధ్య తేడా.

Mode ను చదవడం మరియు mode ను మార్చడం వేర్వేరు పనులు. Long listingలోని అక్షరాలు ఇంకా స్పష్టంగా అర్థం కాకపోతే, ముందుగా drwxr-xr-x అంటే ఏమిటో ప్రతి field ప్రకారం తెలుసుకోండి చదవండి. ఈ guideలో ఆ permissions ను మాత్రమే మారుస్తాం.

ఇక్కడి అన్ని commands ను మీ సాధారణ login userగా అమలు చేయండి. root account ఈ checks ను దాటవేస్తుంది. అందువల్ల rootగా అమలు చేసిన permission demonstration ఏ విషయాన్నీ నిరూపించదు. మీరు కొత్త serverలో ఇంకా rootగా పని చేస్తుంటే, కనీస privileges కలిగిన సాధారణ userను సృష్టించండి; తరువాత ఈ guideకు తిరిగి రండి.

విసిరివేయగల sandbox ను ఏర్పాటు చేయండి

cd "$(mktemp -d)"
touch notes.txt

mktemp -d, /tmp కింద ఖాళీ directory ని సృష్టించి, అది రూపొందించిన path ను ప్రింట్ చేస్తుంది. command substitution ఆ path ను నేరుగా cd కు పంపుతుంది. కింద ఉన్న ఏ చర్య కూడా మీకు అవసరమైన file ను తాకదు.

ప్రతి మార్పు ఫలితాన్ని ఒకే command చూపిస్తుంది:

stat -c '%a %A %n' notes.txt

%a mode ను octal number గా ప్రింట్ చేస్తుంది. %A, long listing ఉపయోగించే letter రూపంలో అదే mode ను ప్రింట్ చేస్తుంది. %n name ను ప్రింట్ చేస్తుంది. తరువాతి blocks లో $ తో ప్రారంభమయ్యే line మీరు type చేయాల్సినది. దాని కింద ఉన్న line command ప్రింట్ చేసినది. వాటిని మీరే run చేయండి. మీ machine లో output line for line సరిపోవాలి, ఎందుకంటే numeric mode మీ environment లోని ఏ అంశంపైనా ఆధారపడదు.

సంఖ్యా రూపం: ప్రతి class కు ఒక octal digit

మొదటి digit file owner కు చెందుతుంది. రెండోది file group కు చెందుతుంది. మూడోది మిగతా అందరికీ చెందుతుంది. ప్రతి digit అనేది ఒక్కో bit విలువల మొత్తంగా ఉంటుంది. ఒక్కసారి ఒక bit ను set చేసి, `stat` ఏమి report చేస్తుందో చూడండి.

$ chmod 400 notes.txt
$ stat -c '%a %A %n' notes.txt
400 -r-------- notes.txt
$ chmod 200 notes.txt
$ stat -c '%a %A %n' notes.txt
200 --w------- notes.txt
$ chmod 100 notes.txt
$ stat -c '%a %A %n' notes.txt
100 ---x------ notes.txt

అక్షరాలు digits కు అనుగుణంగా ఉంటాయి. మొదట ఉన్న file-type character తర్వాతి మొదటి మూడు అక్షరాలు owner కు చెందినవి, తదుపరి మూడు group కు చెందినవి, చివరి మూడు మిగతా అందరికీ చెందినవి. ఒకే class లోని bits ను కలపడానికి వాటి విలువలను జోడించండి.

$ chmod 600 notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt
$ chmod 700 notes.txt
$ stat -c '%a %A %n' notes.txt
700 -rwx------ notes.txt
$ chmod 750 notes.txt
$ stat -c '%a %A %n' notes.txt
750 -rwxr-x--- notes.txt

Numeric mode అనేది absolute. ప్రతి run లో అది మొత్తం తొమ్మిది bits ను రాస్తుంది. అందువల్ల మీరు పరిగణించని class కు చెందిన bits కూడా రాయబడతాయి.

$ chmod 755 notes.txt
$ stat -c '%a %A %n' notes.txt
755 -rwxr-xr-x notes.txt
$ chmod 600 notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt

రెండో command group గురించి లేదా మిగతా అందరి గురించి ఏమీ చెప్పలేదు. అయినప్పటికీ వాటి bits కూడా మారాయి. ఇదే numeric form యొక్క స్వభావం. అందుకే చిన్న మార్పు కోసం numeric form సరైన సాధనం కాదు. (`chmod` setuid, setgid మరియు sticky bits ను కూడా నిర్వహిస్తుంది. ఇవి ఈ మూడు digits కు ముందు ఉండే నాలుగో digit లో ఉంటాయి. అది ప్రత్యేక అంశం. ఈ guide మాత్రం ఈ మూడు digits తోనే కొనసాగుతుంది.)

సింబాలిక్ రూపం: class, operator, తరువాత bits

ముందుగా class ను రాయాలి. u owner ను, g group ను, o మిగతా అందరినీ, a ఈ మూడింటినీ కలిపి సూచిస్తుంది. తరువాత operator ను రాయాలి: + bits ను జోడిస్తుంది, - bits ను తొలగిస్తుంది, = మీరు జాబితా చేసిన bits కు ఆ class ను ఖచ్చితంగా సెట్ చేసి, మిగిలిన bits ను clear చేస్తుంది. తరువాత bits ను r, w లేదా x రూపంలో రాయాలి.

$ chmod 640 notes.txt
$ stat -c '%a %A %n' notes.txt
640 -rw-r----- notes.txt
$ chmod u+x notes.txt
$ stat -c '%a %A %n' notes.txt
740 -rwxr----- notes.txt
$ chmod g-r notes.txt
$ stat -c '%a %A %n' notes.txt
700 -rwx------ notes.txt
$ chmod o=r notes.txt
$ stat -c '%a %A %n' notes.txt
704 -rwx---r-- notes.txt

ప్రతి command ఒక class ను మాత్రమే మార్చి, మిగతా classes ను ఉన్నట్టుగానే ఉంచింది. Clauses ను commaలతో, spaces లేకుండా కలపాలి. chmod వాటిని ఎడమ నుంచి కుడికి వర్తింపజేస్తుంది.

$ chmod u=rw,go=r notes.txt
$ stat -c '%a %A %n' notes.txt
644 -rw-r--r-- notes.txt
$ chmod go= notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt

equals sign తర్వాత ఏమీ లేకుండా ఉన్న go=, group మరియు మిగతా అందరి bits అన్నింటినీ తొలగిస్తుంది. Owner మాత్రమే చదవగలిగే file కు, ఉదాహరణకు private SSH key pair భాగానికి, ఇదే సరైన రూపం.

chmod తన చర్యను కూడా report చేయగలదు. స్క్రీన్‌ను ఎవరూ పర్యవేక్షించని script లో ఇది ముఖ్యమైనది.

chmod -v u+x notes.txt
chmod -v u+x notes.txt

ఇచ్చిన ప్రతి file కు -v ఒక line ను print చేస్తుంది. రెండు commands ను run చేసి, మీ screen పై కనిపించే రెండు lines ను పోల్చండి: మొదటి line file పేరును చూపుతుంది. అలాగే mode ఏ స్థితి నుంచి ఏ స్థితికి మార్చబడిందో report చేస్తుంది. రెండవ line mode అలాగే ఉంచబడిందని report చేస్తుంది, ఎందుకంటే జోడించమని చెప్పిన bit ఇప్పటికే set అయి ఉంది. File నిజంగా మారినప్పుడు మాత్రమే -c ఒక line ను print చేస్తుంది. అందువల్ల log లో ఉంచడానికి ఇది మెరుగైన ఎంపిక.

chmod 755 vs u+x: ఏ notation ఉపయోగించాలి

అదే ఫైల్‌తో రెండుసార్లు ప్రారంభించి, ప్రతి notation వల్ల ఫైల్‌లో మిగిలేది ఏమిటో పోల్చండి.

$ chmod 640 notes.txt
$ chmod 755 notes.txt
$ stat -c '%a %A %n' notes.txt
755 -rwxr-xr-x notes.txt
$ chmod 640 notes.txt
$ chmod u+x notes.txt
$ stat -c '%a %A %n' notes.txt
740 -rwxr----- notes.txt

రెండు commands కూడా ఫైల్ యజమానికి దాన్ని executable గా మార్చాయి. మిగిలిన రెండు permission classes ను మునుపటిలాగే ఉంచింది ఒక్క command మాత్రమే. మీరు కోరుకునే తుది స్థితి ఖచ్చితంగా తెలిసి, దాన్ని తప్పనిసరిగా అమలు చేయాలనుకుంటే numeric mode ఉపయోగించండి. మీరు ఎప్పుడూ చూడని machine పై కూడా deployment script అదే ఫలితాన్ని ఇవ్వాల్సి వచ్చినప్పుడు ఇది సరైన ఎంపిక. మీ ఉద్దేశంలోని వాక్యంలో add లేదా remove ఉంటే symbolic mode ఉపయోగించండి. Numeric form లో కొంత భాగాన్ని అలాగే ఉంచు అని చెప్పే మార్గం లేదు.

కొత్త file ప్రారంభమయ్యే mode chmod నుంచి రాదు. ఆ file ను సృష్టించిన process యొక్క umask నుంచి వస్తుంది. అక్కడ అమలులో ఉన్న విలువను చూడటానికి మీ స్వంత shell లో umask మరియు umask -S అమలు చేయండి. ఈ విలువ distributions మధ్య, మీ login shell మరియు systemd service మధ్య, అలాగే వేర్వేరు accounts మధ్య మారవచ్చు. ప్రతి కొత్త file యొక్క mode ను umask నిర్ణయిస్తుంది, కాబట్టి chmod అమలయ్యే ముందు మీరు ఏ స్థితి నుంచి ప్రారంభిస్తున్నారో అదే నిర్ణయిస్తుంది.

డైరెక్టరీలో execute bit చేసే పని

ఎక్కువ సమయం వృథా చేసే అపార్థం ఇదే. సాధారణ file విషయంలో execute bit ఉంటే kernel ఆ file ను run చేయవచ్చని అర్థం. డైరెక్టరీలో instructions ఉండవు కాబట్టి, అందులో run చేయడానికి ఏదీ ఉండదు. డైరెక్టరీపై execute bit అంటే traversal: దాని లోపల ఉన్న name ను resolve చేయడానికి అనుమతి. dir/file కు చేరుకోవాలంటే dir పై ఈ అనుమతి ఉండాలి. read bit వేరే permission. ఇది డైరెక్టరీలో ఉన్న names ను list చేయడానికి అనుమతిస్తుంది. ఈ రెండింటిలో ఒకటి మరొకటి లేకుండానే ఉండవచ్చు. అది అమలులో చూసిన తర్వాత ఈ విషయం సులభంగా అర్థమవుతుంది.

$ mkdir vault
$ printf 'hello\n' > vault/secret.txt
$ chmod 600 vault/secret.txt
$ chmod 100 vault
$ echo vault/*
vault/*
$ cat vault/secret.txt
hello

డైరెక్టరీని read చేయడం ద్వారా మాత్రమే vault/* expand చేయగలరు. అందువల్ల shell pattern ను ఎలాంటి మార్పు లేకుండా మళ్లీ output చేసింది. ఏదీ match కాని glob error ఇవ్వకుండా literal text గా పంపబడుతుంది. మీరు name ను స్వయంగా ఇచ్చి, traversal కు అనుమతి ఉన్నందున cat ఇప్పటికీ పనిచేసింది. ఇప్పుడు ఈ రెండు bits ను పరస్పరం మార్చండి.

$ chmod 400 vault
$ echo vault/*
vault/secret.txt
$ cat vault/secret.txt
cat: vault/secret.txt: Permission denied

Names కనిపిస్తాయి, కానీ contents కనిపించవు. Read మీకు list ఇస్తుంది. Execute లోపలికి వెళ్లే మార్గాన్ని ఇస్తుంది. మీరు ఉపయోగించే దాదాపు ప్రతి డైరెక్టరీకి ఈ రెండూ అవసరం.

$ chmod 500 vault
$ cat vault/secret.txt
hello

chmodలో numeric modeతో -R ఉపయోగిస్తే tree ఎందుకు దెబ్బతింటుంది

-R మొత్తం treeలోని ప్రతి అంశంపై నడిచి, ఎదురైన ప్రతిదానికి మీరు ఇచ్చిన modeను వర్తింపజేస్తుంది. Directoryకి మరియు data fileకి వేర్వేరు bits అవసరం. అందువల్ల రెండింటికీ ఒకే absolute number సరైనది కాదు. చిన్న treeను సృష్టించి, అది ఎలా తప్పుపడుతుందో పరిశీలించండి.

$ mkdir -p site/css
$ touch site/index.html site/css/main.css
$ printf '#!/bin/bash\necho hi\n' > site/deploy.sh
$ chmod 755 site site/css site/deploy.sh
$ chmod 644 site/index.html site/css/main.css
$ stat -c '%a %A %n' site site/css site/index.html site/css/main.css site/deploy.sh
755 drwxr-xr-x site
755 drwxr-xr-x site/css
644 -rw-r--r-- site/index.html
644 -rw-r--r-- site/css/main.css
755 -rwxr-xr-x site/deploy.sh

Static files ఉన్న directoryకి కావాల్సిన అమరిక ఇదే. ఇప్పుడు మొదటి recursive పొరపాటును చూడండి.

$ chmod -R 755 site
$ stat -c '%a %A %n' site/index.html site/css/main.css
755 -rwxr-xr-x site/index.html
755 -rwxr-xr-x site/css/main.css

ఏదీ విరిగిపోయినట్లు కనిపించదు. అదే సమస్య. ఈ పొరపాటు నిశ్శబ్దంగా జరుగుతుంది. అందువల్ల ఇది సంవత్సరాల పాటు copy చేసిన సూచనల్లో అలాగే కొనసాగుతుంది. ఇప్పుడు రెండు data files తమను తాము programsగా చూపిస్తున్నాయి. Git execute bitను నిల్వ చేస్తుంది. కాబట్టి మీ తదుపరి commitలో ఈ మార్పు చేరుతుంది. Repositoryను clone చేసే ప్రతి వ్యక్తికి అది కనిపిస్తుంది. అలాగే rsync మరియు tar ద్వారా మీరు treeను copy చేసే ప్రతి machineకూ ఈ మార్పు చేరుతుంది.

రెండవ recursive పొరపాటు వెంటనే కనిపిస్తుంది. Execute bit లేని modeను directoryకి ఇస్తే, ఆ directory మూసుకుపోతుంది.

$ chmod 644 site
$ stat -c '%a %A %n' site
644 drw-r--r-- site
$ echo site/*
site/css site/deploy.sh site/index.html
$ cd site
bash: cd: site: Permission denied
$ cat site/index.html
cat: site/index.html: Permission denied

Read bit మిగిలి ఉన్నందున పేర్లు ఇంకా జాబితాలో కనిపిస్తాయి. కానీ execute bit లేకపోవడంతో directoryలోని ప్రతి path మూసుకుపోతుంది. chmod -R 644 site ఒకే commandతో treeలోని ప్రతి directoryకి ఇదే చేస్తుంది. తరువాత కనిపించే ఫలితం ఎల్లప్పుడూ ఒకేలా ఉండదు. ఎందుకంటే chmod traverse చేస్తున్న అదే directories నుంచి traversal హక్కును తొలగించాల్సి వస్తుంది. అందువల్ల ఊహించకుండా, నిజంగా ఏ permissions వర్తించాయో find site -type d -exec stat -c '%a %n' {} +తో పరిశీలించండి. కొనసాగించే ముందు దీన్ని తిరిగి సరిచేయండి.

$ chmod 755 site
$ chmod 644 site/index.html site/css/main.css
$ stat -c '%a %A %n' site site/index.html
755 drwxr-xr-x site
644 -rw-r--r-- site/index.html

Recursive chmodకు undo ఉండదు. chmod తాను భర్తీ చేసిన permissionsను నమోదు చేయదు. కాబట్టి repair మీరే చేయాలి. గతంలో అవి ఎలా ఉన్నాయని మీరు నమ్ముతున్నారో దాని ఆధారంగా modesను మళ్లీ నిర్మించాలి. ఇది పొరపాటున rm -rf చేసిన తర్వాత filesను మళ్లీ నిర్మించడం లాగే నెమ్మదైన, అనిశ్చితమైన పని. అందువల్ల recursive commandను అమలు చేయడానికి ముందు దాని targetను పరిశీలించాలి.

capital X: ప్రతి ఫైల్‌పై కాకుండా directories పై execute

Symbolic modes లో X తో పాటు x కూడా ఉపయోగించవచ్చు. X execute bit ను అవసరమైన చోట మాత్రమే set చేస్తుంది: directory పై, లేదా ఏదైనా class కోసం ఇప్పటికే execute bit కలిగిన regular file పై. మీరు -R పాటించాలని కోరుకున్న నియమం ఇదే.

$ chmod -R u=rwX,go=rX site
$ stat -c '%a %A %n' site site/css site/index.html site/css/main.css site/deploy.sh
755 drwxr-xr-x site
755 drwxr-xr-x site/css
644 -rw-r--r-- site/index.html
644 -rw-r--r-- site/css/main.css
755 -rwxr-xr-x site/deploy.sh

ఒకే command తో directories traversable గా మిగిలాయి, data files మాత్రం మారలేదు. ఆ script కు ఇప్పటికే execute bit ఉండటంతో, దాని execute bit అలాగే ఉంది. ఇది X నియమంలోని రెండవ భాగం. X ఒక file కు ప్రస్తుతం ఉన్న mode ను చదువుతుంది. అందువల్ల అన్ని execute bits ఇప్పటికే తొలగిపోయిన file కు, దాని ద్వారా execute bit ను తిరిగి ఇవ్వలేరు.

$ chmod 644 site/deploy.sh
$ chmod -R u=rwX,go=rX site
$ stat -c '%a %A %n' site/deploy.sh
644 -rw-r--r-- site/deploy.sh
$ site/deploy.sh
bash: site/deploy.sh: Permission denied
$ chmod u+x site/deploy.sh
$ stat -c '%a %A %n' site/deploy.sh
744 -rwxr--r-- site/deploy.sh
$ site/deploy.sh
hi

ఇదే నియమం వ్యతిరేక దిశలో కూడా పనిచేస్తుంది. ఒక file కు ఇప్పటికే ఉన్న execute bit ను మరో class కు విస్తరించడానికి X ఉపయోగించవచ్చు:

$ chmod go+X site/deploy.sh
$ stat -c '%a %A %n' site/deploy.sh
755 -rwxr-xr-x site/deploy.sh

అందువల్ల మీరు runnable గా మార్చాలనుకున్న ఒక named file కోసం lowercase x ఉపయోగించాలి. మొత్తం tree పై మార్పు చేయడానికి X ఉపయోగించాలి. ప్రస్తుత mode ఆధారిత నియమం కాకుండా, ప్రతి రకమైన అంశానికి ఖచ్చితమైన mode కావాలంటే, walk ను find తో విడగొట్టండి.

find site -type d -exec chmod 755 {} +
find site -type f -exec chmod 644 {} +
chmod u+x site/deploy.sh

-type d directories ను ఎంచుకుంటుంది. -type f regular files ను ఎంచుకుంటుంది. అందువల్ల ప్రతి రకానికి తగిన mode లభిస్తుంది. ప్రతి file కోసం ప్రత్యేక process ప్రారంభించకుండా, -exec ... + అనేక paths ను ఒకే chmod call లో సమూహపరుస్తుంది. వేలాది entries ఉన్న tree లో ఇది ముఖ్యమైనది. script కు execute bit ను ప్రత్యేక line లో, ఉద్దేశపూర్వకంగా తిరిగి ఇస్తారు.

మీరు వెళ్లే ముందు ఫలితాన్ని తనిఖీ చేయండి

ఏదైనా recursive మార్పు చేసిన తర్వాత ముఖ్యమైన తప్పులను గుర్తించడానికి రెండు commands ఉపయోగపడతాయి. మొదటి command ద్వారా ఇకపై ప్రవేశించలేని directories జాబితా కనిపిస్తుంది.

find . -type d ! -perm -u+x

రెండవ command ద్వారా machine లోని ఏ account అయినా మార్చగలిగే files జాబితా కనిపిస్తుంది.

find . -type f -perm -o+w

-perm -o+w లో ప్రారంభంలోని - అంటే కనీసం ఈ bits అయినా అని అర్థం. అందువల్ల o class లో write bit సెట్ అయి ఉంటే, మిగతా bits ఎలా ఉన్నా ఆ file సరిపోతుంది. ఈ రెండు commands ఏదీ output ఇవ్వకపోవడమే మీరు కోరుకునే ఫలితం. మీరు ఇప్పుడే -R తో మార్చిన ఏదైనా tree యొక్క పైస్థాయి directory నుంచి రెండింటినీ run చేయండి. మీరు మార్చాలని ఉద్దేశించిన కొద్ది paths పై stat -c '%a %A %n' ను run చేయండి. అప్పుడు మీరు సెట్ చేశామని భావించిన mode నే kernel వాస్తవంగా కలిగి ఉందో నిర్ధారించవచ్చు.

FAQ

chmod 755 మరియు chmod u+x మధ్య తేడా ఏమిటి?

Numeric mode absolute గా పనిచేస్తుంది. ఇది ఫైల్‌లోని ప్రతి permission bit ను రాస్తుంది. కాబట్టి మీరు పరిగణించని classes కూడా మళ్లీ మార్చబడతాయి. Symbolic mode ఒక edit లాంటిది. u+x owner కోసం ఒక bit ను మాత్రమే జోడిస్తుంది. మిగతా ప్రతి bit ఉన్న విధంగానే ఉంటుంది. ఫైల్‌కు కావాల్సిన ఖచ్చితమైన చివరి స్థితి మీకు తెలిసినప్పుడు numeric రూపాన్ని ఉపయోగించండి. ఒక్క permission ను జోడించాలనుకున్నప్పుడు లేదా తొలగించాలనుకున్నప్పుడు symbolic రూపాన్ని ఉపయోగించండి. రెండు commands లో ఏదైనా అమలు చేయడానికి ముందు మరియు తర్వాత stat -c '%a %A %n' <file> ను run చేయండి. అప్పుడు తేడా output లో కనిపిస్తుంది.

web files ఉన్న directory పై chmod -R 755 ఉపయోగించడం ఎందుకు తప్పు?

ఎందుకంటే -R directories కు, regular files కు ఒకే absolute mode ను పంపుతుంది. కానీ ఈ రెండింటికి వేర్వేరు bits అవసరం. Directory ను traverse చేయడానికి execute bit అవసరం. HTML మరియు CSS వంటి data files కు అది అవసరం లేదు. వాటిని executable గా గుర్తిస్తే, మీ తదుపరి commit లో git ఆ మార్పును record చేస్తుంది. rsync కూడా ఆ మార్పును తదుపరి machine కు copy చేస్తుంది. Execute bit directories పై మాత్రమే వర్తించేలా chmod -R u=rwX,go=rX <dir> ను ఉపయోగించండి. లేదా find ను -type d మరియు -type f తో ఉపయోగించి ప్రతి రకానికి దాని స్వంత mode ఇవ్వండి.

Directory పై execute bit ఏమి చేస్తుంది?

ఇది execution కాదు, traversal ను అనుమతిస్తుంది. Directory లో run చేయడానికి ఏదీ ఉండదు. దానిలోని ఒక name ను resolve చేయడానికి execute bit permission ఇస్తుంది. కాబట్టి path చివరలోని file ను open చేయడానికి, ఆ path లోని ప్రతి directory పై ఈ bit అవసరం. Read bit వేరు. ఇది names ను list చేయడానికి అనుమతిస్తుంది. ఒకటి లేకుండా మరొకటి ఉండవచ్చు. Execute మాత్రమే ఉంటే, మీకు ముందే తెలిసిన name తో file ను open చేయవచ్చు. కానీ shell ఆ directory లో glob ను expand చేయలేదు. Read మాత్రమే ఉంటే names కనిపిస్తాయి. కానీ ఏదైనా name ను open చేయడానికి చేసే ప్రతి ప్రయత్నం విఫలమవుతుంది.

lowercase x కు బదులుగా capital X ను ఎప్పుడు ఉపయోగించాలి?

Command recursive గా ఉన్నప్పుడు X ను ఉపయోగించండి. X directories పై execute bit ను set చేస్తుంది. Regular files పై మాత్రం ఇప్పటికే ఏదైనా execute bit set అయి ఉన్నప్పుడు మాత్రమే దాన్ని set చేస్తుంది. అందువల్ల ఒకే pass తో data files ను programs గా మార్చకుండా tree ను traversable గా చేయవచ్చు. మీరు ఒక file ను మాత్రమే లక్ష్యంగా చేసుకుని, ఆ file పైనే మార్పు చేయాలనుకున్నప్పుడు lowercase x ను ఉపయోగించండి. ఒక పరిమితిని గుర్తుంచుకోవాలి. ఒక file పై execute bit ఎక్కడా మిగలకుండా ఇప్పటికే clear అయి ఉంటే X దాన్ని restore చేయలేదు. ఎందుకంటే match చేయడానికి దానికి ఏ bit మిగలదు. ఆ bit ను chmod u+x <file> తో మళ్లీ జోడించండి.

chmod ఫైల్‌ను ఎవరు own చేస్తున్నారో మార్చుతుందా?

లేదు. chmod permission bits ను మాత్రమే మారుస్తుంది. User ownership కు chown, group ownership కు chgrp బాధ్యత వహిస్తాయి. ఫైల్‌ను వేరే user కు అప్పగించడానికి root అవసరం. ఇది ముఖ్యమైన విషయం. ఎందుకంటే bits ఫైల్‌పై record అయిన owner మరియు group ఆధారంగా చదవబడతాయి. చివరిసారిగా ఫైల్‌ను రాసిన వ్యక్తి ఆధారంగా కాదు. మీరు అవసరమైన మూడు commands లో ఏది ఉపయోగించాలో నిర్ణయించే ముందు owner, group మరియు mode ను ఒకేసారి చూడటానికి stat -c '%U %G %a %n' <file> ను run చేయండి.