Linux-இல் செயல்முறைகள்: ps, top, htop, kill, சிக்னல்கள் மற்றும் nice

Linux-இல் இயங்கும் ஒவ்வொரு நிரலும் அதற்கே உரிய PID எண், உரிமையாளர், நிலை மற்றும் முன்னுரிமை கொண்ட ஒரு செயல்முறை. செயல்முறைகளை ps, top மற்றும் htop கட்டளைகளால் பார்க்கலாம், kill மூலம் நிறுத்தலாம், nice மற்றும் renice மூலம் அவற்றின் முன்னுரிமையை மாற்றலாம். கீழே இந்தக் கட்டளைகளின் வெளியீட்டை எப்படி வாசிப்பது, எந்தச் சிக்னலை எப்போது அனுப்புவது, மேலும் kill -9 முதல் எதிர்வினையாக இருக்கக்கூடாது ஏன் என்பதைப் பார்க்கலாம்.

செயல்முறை மற்றும் PID என்றால் என்ன

செயல்முறை என்பது இயங்கிக்கொண்டிருக்கும் நிரல்: அதன் குறியீடு, நினைவகம், திறந்த கோப்புகள் மற்றும் பண்புகளின் தொகுப்பு. கர்னல் ஒவ்வொரு செயல்முறைக்கும் ஒரு தனித்துவமான PID அடையாளங்காட்டியைத் தருகிறது, மேலும் அதைத் தொடங்கிய பெற்றோரின் எண்ணான PPID-ஐயும் நினைவில் வைக்கிறது. அமைப்பில் உள்ள முதல் செயல்முறை, PID 1, பொதுவாக systemd ஆகும், அதுவே மற்ற அனைத்திற்கும் «மூதாதையர்».

புதிய செயல்முறை இரண்டு படிகளில் தோன்றுகிறது. முதலில் பெற்றோர் fork()-ஐ அழைத்து தனது நகலைப் பெறுகிறது, பின்னர் நகல் execve()-ஐ அழைத்து தனது குறியீட்டை புதிய நிரலின் குறியீட்டால் மாற்றுகிறது. டெர்மினலில் ls என்று தட்டும்போது bash இதைத்தான் செய்கிறது, பின்னர் wait() மூலம் குழந்தையின் முடிவுக்காகக் காத்திருக்கிறது.

$ echo $$          # தற்போதைய shell-இன் PID
4182
$ ps -o pid,ppid,cmd -p $$
    PID    PPID CMD
   4182    4170 -bash

ps கட்டளையால் செயல்முறைகளைப் பார்ப்பது

ps ஒரு முறை நிழற்படம் எடுக்கிறது: கட்டளை இயங்கிய அந்தக் கணத்தின் செயல்முறைகளைக் காட்டி முடிவடைகிறது. எந்த வாதமும் இல்லாவிட்டால் அது தற்போதைய டெர்மினலின் செயல்முறைகளை மட்டும் காட்டும், அதனால் நடைமுறையில் கிட்டத்தட்ட எப்போதும் இரண்டில் ஒரு விருப்பம் பயன்படுத்தப்படுகிறது.

$ ps aux | head -5
USER       PID %CPU %MEM    VSZ   RSS TTY   STAT START   TIME COMMAND
root         1  0.0  0.3 168540 12780 ?     Ss   09:12   0:03 /sbin/init
root         2  0.0  0.0      0     0 ?     S    09:12   0:00 [kthreadd]
www-data  1532  1.2  2.1 412308 86420 ?     S    09:15   1:47 php-fpm: pool www
postgres  1610  0.4  3.8 221004 154312 ?    Ss   09:15   0:31 postgres: checkpointer

இங்கு a — எல்லா பயனர்களின் செயல்முறைகள், u — உரிமையாளருடன் விரிவான வடிவம், x — டெர்மினல் இல்லாத செயல்முறைகள் (டீமன்கள்) உட்பட. System V பாணி மாற்று தொடரியல் — ps -ef: இது PPID-ஐக் காட்டும், யார் யாரைத் தொடங்கினார் என்று புரிந்துகொள்ள இது வசதியானது.

ps உடன் பயனுள்ள முறைகள்

# நினைவகத்தில் முதல் 10
ps aux --sort=-%mem | head -11

# செயலியில் முதல் 10
ps aux --sort=-%cpu | head -11

# தனிப்பயன் நெடுவரிசைகள்
ps -eo pid,ppid,user,ni,stat,etime,cmd

# செயல்முறைகளின் மரம்
ps -ef --forest
pstree -p

# பெயரால் PID-ஐக் கண்டறிவது
pgrep -a nginx
pidof nginx

உன்னதமான தவறு — ps aux | grep nginx மூலம் செயல்முறையைத் தேடி, வெளியீட்டில் grep-ஏ வருவது. pgrep அல்லது grep [n]ginx தந்திரத்தைப் பயன்படுத்துங்கள், அது தனது சொந்த கட்டளை வரியுடன் பொருந்தாது.

செயல்முறை நிலைகள்: R, S, D, Z, T

STAT நெடுவரிசையின் எழுத்து குப்பை அல்ல, அது செயல்முறையின் உண்மையான நிலை. அதன் அடிப்படையில் சுமையை விளக்கவும், kill உதவுமா என்றும் தீர்மானிக்கவும் வேண்டும்.

எழுத்துக்குப் பின் வரும் கூடுதல் குறியீடுகளும் பயனுள்ளவை: s — அமர்வின் தலைவர், + — டெர்மினலின் முன்னணி செயல்முறை, < — உயர்ந்த முன்னுரிமை, N — குறைந்த முன்னுரிமை, l — பல-இழை (multithreaded).

D நிலையில் உள்ள செயல்முறை

D நிலையில் உள்ள செயல்முறை கணினி அழைப்புக்குள் இருந்து, எடுத்துக்காட்டாக வட்டின் பதிலுக்காக அல்லது உறைந்துபோன NFS-க்காகக் காத்திருக்கிறது. அதற்கு எந்த சிக்னலும் சென்றடையாது, SIGKILL கூட. அதனால் kill -9 இங்கு பயனற்றது: காத்திருப்புக்கான காரணத்தைத் தேட வேண்டும் — iostat, dmesg, பிணைய சேமிப்பகத்தின் நிலை ஆகியவற்றைப் பார்க்க வேண்டும்.

Zombie செயல்முறைகள்

Zombie ஏற்கனவே இறந்துவிட்டது: அது CPU-வையோ நினைவகத்தையோ பயன்படுத்துவதில்லை, செயல்முறை அட்டவணையில் ஒரு வரியை மட்டுமே ஆக்கிரமிக்கிறது. அதை கொல்ல முடியாது — அது ஏற்கனவே முடிந்துவிட்டது. பெற்றோர் wait()-ஐ அழைக்கும்போது அல்லது பெற்றோரே முடிவடைந்து zombie-ஐ PID 1 தத்தெடுக்கும்போது அது மறையும்.

# zombie-களையும் அவற்றின் பெற்றோர்களையும் கண்டறிவது
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /Z/'

ஒரு zombie தீங்கற்றது. அவை நூற்றுக்கணக்கில் இருந்து எண்ணிக்கை அதிகரித்தால், பெற்றோர் நிரலில் பிழை உள்ளது: அதை சரி செய்ய வேண்டும் அல்லது மறுதொடக்கம் செய்ய வேண்டும்.

top: நேரடி நேரத்தில் செயல்முறைகள் மற்றும் சுமை

top அதே பட்டியலைக் காட்டுகிறது, ஆனால் ஒவ்வொரு சில வினாடிக்கும் அதைப் புதுப்பித்து, அமைப்பின் சுருக்கத்தையும் தருகிறது. «சர்வர் மெதுவாக இருக்கிறது» என்றால் முதலில் இயக்கும் கட்டளை இது.

top - 14:21:07 up 12 days,  3:02,  2 users,  load average: 1.84, 1.20, 0.95
Tasks: 213 total,   2 running, 211 sleeping,   0 stopped,   0 zombie
%Cpu(s): 23.1 us,  4.2 sy,  0.0 ni, 70.3 id,  1.9 wa,  0.0 hi,  0.5 si,  0.0 st
MiB Mem :   7821.4 total,    412.6 free,   3105.8 used,   4303.0 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   4398.2 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
   1532 www-data  20   0  412308  86420  14212 R  38.2   1.1   1:47.31 php-fpm
   1610 postgres  20   0  221004 154312 148900 S   6.0   1.9   0:31.08 postgres

%Cpu(s) வரியில் மிக முக்கியமானவை: us — பயனர் குறியீடு, sy — கர்னல், id — செயலற்றது, wa — வட்டுக்காகக் காத்திருப்பு. செயலி இலவசமாக இருக்கும்போதும் wa அதிகமாக இருந்தால், இடையூறு உள்ளீடு-வெளியீட்டில் இருப்பது உறுதி.

top-இன் விசைகள்

Scripts மற்றும் logs-க்கு batch முறை பயனுள்ளது: top -b -n 1 | head -20 ஊடாடல் இல்லாமல் ஒரு நிழற்படத்தை வெளியிடும். ஒரு குறிப்பிட்ட செயல்முறையைக் கண்காணிக்க — top -p 1532.

Load Average என்பது வரிசை, சதவீதம் அல்ல

load average-இன் மூன்று எண்கள் — கடைசி 1, 5 மற்றும் 15 நிமிடங்களின் சராசரி வரிசை நீளம். Linux-இல் அதில் R மற்றும் D நிலைகளில் உள்ள செயல்முறைகள் சேரும், சாதாரண உறக்கமான S சேராது. LA-ஐ கோர்களின் எண்ணிக்கையுடன் (nproc) ஒப்பிட வேண்டும்: 4 கோர்களில் மதிப்பு 4 என்றால் முழு சுமை, 12 என்றால் வரிசை திறனை விட மூன்று மடங்கு.

LA அதிகமாக இருந்து செயலி செயலற்றதாக இருந்தால், D நிலை செயல்முறைகளைத் தேடுங்கள்: ps -eo stat,pid,cmd | grep '^D'. கிட்டத்தட்ட எப்போதும் இது மெதுவான வட்டு அல்லது பிணைய சேமிப்பகம்.

htop: top-க்கு வசதியான மாற்று

htop அதே தகவலைக் காட்டுகிறது, ஆனால் கோர்களுக்கான வண்ண குறிகாட்டிகள், உருட்டுதல், சுட்டி ஆதரவு மற்றும் செயல்முறை மரத்துடன். பொதுவாக அதை நிறுவ வேண்டும்: sudo apt install htop அல்லது sudo dnf install htop.

• F3 அல்லது / — பெயரால் செயல்முறையைத் தேடு;
• F4 — பொருந்துபவற்றை மட்டும் விட்டுவிடும் வடிகட்டி;
• F5 அல்லது t — «பெற்றோர் — குழந்தைகள்» மரம்;
• F6 — வரிசைப்படுத்தும் நெடுவரிசையைத் தேர்ந்தெடு;
• F7 / F8 — nice-ஐ குறை அல்லது அதிகரி;
• F9 — தேர்ந்த செயல்முறைக்கான சிக்னல் பட்டியல்;
• Space — பல செயல்முறைகளை ஒரே செயலுக்குக் குறி இடு.

எதையும் நிறுவ முடியாத சர்வர்களில் top போதுமானது: அதிலும் முக்கிய செயல்பாடுகள் அனைத்தும் உள்ளன.

செயல்முறையை நிறுத்துவது எப்படி: kill மற்றும் சிக்னல்கள்

kill கட்டளை «கொல்வதில்லை», செயல்முறைக்கு ஒரு சிக்னலை அனுப்புகிறது. அடுத்து என்ன நடக்கும் என்பது சிக்னலைப் பொறுத்தும், நிரல் அதை எப்படிக் கையாளுகிறது என்பதைப் பொறுத்தும் அமைகிறது.

எண்கள் x86 மற்றும் ARM-க்கானவை; முழுப் பட்டியலை kill -l காட்டும். சிக்னலை எண்ணால் அல்லாமல் பெயரால் எழுதுவது நம்பகமானது.

kill 1532              # SIGTERM
kill -TERM 1532        # அதே, வெளிப்படையாக
kill -HUP $(pidof nginx)   # கட்டமைப்பை மீண்டும் படி
kill -STOP 1532; kill -CONT 1532
kill -0 1532 && echo "செயல்முறை உயிருடன் உள்ளது"

சிக்னல் 0 எதையும் அனுப்பாது, செயல்முறை இருக்கிறதா என்றும், அதற்கு எழுத உங்களுக்கு உரிமை உள்ளதா என்றும் மட்டும் சரிபார்க்கும் — scripts-இல் வசதியானது.

kill -9-உடன் ஏன் தொடங்கக்கூடாது

SIGTERM நிரலுக்குக் கோப்புகளை மூடவும், இடையகங்களை வெளியேற்றவும், lock கோப்புகளை நீக்கவும், பரிவர்த்தனைகளை சீராக முடிக்கவும் வாய்ப்பளிக்கிறது. SIGKILL அனைத்தையும் உடனே துண்டிக்கிறது: முடிக்காத தரவு இழக்கப்படும், தற்காலிக கோப்புகள் அப்படியே இருக்கும், தரவுத்தளம் அடுத்த தொடக்கத்தில் மீட்பு நிலைக்குச் செல்லக்கூடும்.

சரியான வரிசை இது:

1. kill PID (SIGTERM) அனுப்புங்கள்.
2. 5–30 வினாடி காத்திருங்கள், kill -0 PID மூலம் சரிபாருங்கள்.
3. செயல்முறை உயிருடன் இருந்து, D நிலையில் இல்லையெனில் மட்டும் — kill -9 PID.

systemd-இன் சேவைகளுக்கு PID-ஐ கைமுறையாகத் தொடாமல் இருப்பது நல்லது: systemctl stop தானாகவே SIGTERM அனுப்பும், காலக்கெடு வரை காத்திருக்கும், பின்னர் SIGKILL-ஆல் முடிக்கும்.

pkill மற்றும் killall: பெயரால்

pkill -f "python worker.py"   # முழு கட்டளை வரியின்படி
pkill -u alice                 # பயனரின் எல்லா செயல்முறைகளும்
killall -TERM node             # node என்ற பெயருடைய எல்லாம்
pgrep -l -f worker             # எது வடிவத்தில் சிக்கும் என்று முதலில் பாருங்கள்

பெருமளவிலான pkill-க்கு முன் எப்போதும் அதே வடிவத்துடன் pgrep-ஐ இயக்குங்கள்: -f கட்டளை வரியின் எந்தப் பகுதியுடனும் பொருந்தும், எளிதாக தேவையற்றதைப் பிடித்துவிடும்.

உங்கள் சொந்த செயல்முறைகளுக்கு மட்டுமே சிக்னல் அனுப்ப முடியும்; மற்றவர்களுடையதற்கு sudo தேவை. Operation not permitted பிழை இதைத்தான் குறிக்கிறது.

செயல்முறை முன்னுரிமை: nice மற்றும் renice

nice மதிப்பு திட்டமிடலுக்கு யார் செயலிக்கு வழிவிட வேண்டும் என்பதைக் குறிக்கிறது. வரம்பு — -20 (மிக உயர்ந்த முன்னுரிமை) முதல் 19 வரை (எல்லோருக்கும் வழிவிடும்), இயல்பு 0. top-இல் அது NI நெடுவரிசையில் தெரியும், PR என்பது அதிலிருந்து பெறப்பட்ட உள் முன்னுரிமை.

# பளு அதிகமான பணியைக் குறைந்த முன்னுரிமையுடன் தொடங்கு
nice -n 10 tar czf backup.tar.gz /var/www

# இயங்கும் செயல்முறையின் முன்னுரிமையைக் குறை
renice -n 15 -p 1532

# உயர்த்து (root மட்டும்)
sudo renice -n -5 -p 1610

# பயனரின் எல்லா செயல்முறைகளும்
sudo renice -n 10 -u alice

சாதாரண பயனர் தனது செயல்முறைகளின் முன்னுரிமையை மட்டுமே குறைக்க முடியும், எதிர்மறை மதிப்புகள் root-க்கு மட்டுமே. nice-இன் எல்லையைப் புரிந்துகொள்வதும் முக்கியம்: அது CPU-வை மட்டுமே பாதிக்கிறது. பணி வட்டின் மூலம் அமைப்பை மெதுவாக்கினால் ionice -c3 கட்டளை பயன்படுத்துங்கள் — idle வகுப்பு, வட்டு யாருக்கும் தேவையற்றபோது மட்டுமே அதைப் பெறும்.

பின்னணி செயல்முறைகள் மற்றும் shell பணிகள்

கட்டளையை & சேர்த்து பின்னணியில் இயக்கலாம், அல்லது Ctrl+Z மூலம் இடைநிறுத்தலாம். Shell பணிகளின் பட்டியலை வைத்திருக்கும், அதை உள்ளமைந்த கட்டளைகள் கட்டுப்படுத்தும்.

$ long_task &
[1] 5120
$ jobs
[1]+  Running    long_task &
$ fg %1        # முன்னணிக்குக் கொண்டுவா
^Z             # இடைநிறுத்து (SIGTSTP)
$ bg %1        # பின்னணியில் தொடர்

டெர்மினலை மூடும்போது shell பணிகளுக்கு SIGHUP அனுப்புகிறது, அவை முடிந்துவிடும். வெளியேறிய பின்னும் செயல்முறை உயிருடன் இருக்க, nohup கட்டளை & மூலம் தொடங்குங்கள், disown கட்டளையால் பிரியுங்கள் அல்லது tmux பயன்படுத்துங்கள். நிரந்தர வேலைக்கு அதை systemd சேவையாக அமைப்பது சரியானது.

பொதுவான கண்டறிதல் சூழ்நிலைகள்

செயலியை யார் விழுங்குகிறார்கள்

top -o %CPU            # அல்லது top-க்குள் P
ps -eo pid,user,%cpu,etime,cmd --sort=-%cpu | head

ஒரு செயல்முறை பயனின்றி CPU-வை விழுங்கினால், முதலில் renice மூலம் அதன் முன்னுரிமையைக் குறையுங்கள் — அது பாதுகாப்பானது மற்றும் விஷயத்தை ஆராய நேரம் தருகிறது.

போர்ட்டை யார் பிடித்திருக்கிறார்கள்

sudo ss -ltnp | grep :8080
sudo lsof -i :8080

வெளியீட்டில் PID இருக்கும், அதன் மூலம் /proc/PID/-இல் இயக்கக் கோப்பு (exe), வேலை கோப்பகம் (cwd) மற்றும் வாதங்கள் (cmdline) ஆகியவற்றைக் கண்டறியலாம்.

செயல்முறை எதிர்பாராமல் மறைந்தது

பொதுவான காரணம் — OOM Killer, நினைவகம் குறையும்போது செயல்முறைகளைக் கொல்லும் கர்னல் பொறிமுறை. சரிபார்க்க: dmesg -T | grep -i oom அல்லது journalctl -k | grep -i "killed process".

சுருக்கம்

Linux செயல்முறைகளுடன் வேலை செய்ய ஒரு சிறிய கட்டளைத் தொகுப்பு போதும்: நிழற்படத்துக்கு ps aux, கண்காணிப்புக்கு top மற்றும் htop, சரியான சிக்னலுடன் நிறுத்த kill, முன்னுரிமைகளுக்கு nice/renice. செயல்படுவதற்கு முன் செயல்முறையின் நிலையைப் படியுங்கள்: zombie-களையும் D நிலை செயல்முறைகளையும் சிக்னல்களால் குணப்படுத்த முடியாது. எப்போதும் SIGTERM-இல் தொடங்குங்கள், kill -9-ஐ கடைசி வழியாக வையுங்கள். செயல்முறைகள், நினைவகம், Load Average மற்றும் கணினி அழைப்புகள் ஆகியவை Linux பாடத்திட்டத்தில் நடைமுறையில் விரிவாக விளக்கப்பட்டுள்ளன.