இறந்தவர்களின் நாள் வருகிறது, அதனால்தான் LxA இலிருந்து இந்த சிறிய டுடோரியலை நாங்கள் செய்ய விரும்புகிறோம் ஜாம்பி செயல்முறைகள் நாம் அவர்களை எவ்வாறு கொல்ல முடியும். முதலில் சொல்ல வேண்டியது என்னவென்றால், ஜாம்பி செயல்முறை என்ன, அது உங்களுக்குத் தெரிந்தபடி, லினக்ஸ் கர்னலில் செயல்முறைகளை நிர்வகிக்க ஒரு துணை அமைப்பு உள்ளது மற்றும் திட்டமிடலுடன் இணைந்து செயல்பட, முன்னுரிமையை வேறுபடுத்த, சிபியு செயலாக்க ஓட்டத்தை அனுப்ப அல்லது நீக்க மற்றும் செயல்முறைகளை கொல்லுங்கள். சரி, கர்னலின் இந்த பகுதி, மற்ற யூனிக்ஸ் போன்ற அமைப்புகளைப் போலவே, பல்வேறு மாநில செயல்முறைகளுக்கு இடையில் வேறுபடுகிறது ...
எனவே நாம் அதை கண்டுபிடிக்க முடியும் ஒரு செயல்முறை அது தூக்க (எஸ்) நிலையில் இருக்கலாம், அதாவது தூங்குகிறது. தற்போது இயங்கும் அல்லது இயங்கும், இயங்கும் நிலையில் (ஆர்) செயலாக்கங்கள், கலந்துகொள்ள காத்திருப்பது நிறுத்தப்பட்ட செயல்முறைகள் (டி), கலந்துகொள்ள காத்திருப்பது நிறுத்தப்பட்டவை, கெஸ்ப்ட் (டி) அல்லது இடைநீக்கம் செய்யப்பட்டவை, மற்றும் ஜோம்பிஸ் (இசட்) அல்லது இறந்தவர்களும். ஒரு ஜாம்பி அல்லது இறந்த செயல்முறை என்பது ஏற்கனவே வெற்றிகரமாக நிறுத்தப்பட்ட ஒன்றாகும், ஆனால் லினக்ஸ் அதை இன்னும் செயல்முறை அட்டவணையில் சேமித்து வருவதால் சில கணினி வளங்கள் கடத்தப்பட்டுள்ளன. ஒரு செயல்முறை முடிவடையும் போது, அது இந்த நிலையில் இருக்கக்கூடாது என்பது உங்களுக்கு முன்பே தெரியும், ஆனால் கர்னல் வளங்களை விடுவிக்கிறது, இதனால் மற்ற செயல்முறைகள் அவற்றைப் பயன்படுத்தலாம், அடிப்படையில் அது ஆக்கிரமிக்கப்பட்ட ரேமை விடுவிக்கிறது ...
சரி, இந்த வகை ஜாம்பி செயல்முறைகள் இருப்பது சுவாரஸ்யமானதல்ல என்பதால், அவை அடிக்கடி இல்லை என்றாலும், இங்கே சுட்டிக்காட்டப்பட்டுள்ளபடி அவற்றைத் தேடலாம் மற்றும் அகற்றலாம். முதல் விஷயம் என்னவென்றால், எங்கள் டிஸ்ட்ரோவில் ஜாம்பி செயல்முறைகள் உள்ளனவா என்பதைக் கண்டுபிடிப்பது, அதற்காக நாம் நமக்கு உதவ முடியும் மேல் அல்லது ps போன்ற கருவிகள். எடுத்துக்காட்டாக, இந்த இரண்டு விருப்பங்களில் ஒன்று:
ps -el | grep 'Z' ps aux | grep defunct
கண்டறியப்பட்டவுடன், நம்மால் முடியும் அவரைக் கொல்லுங்கள் நேரடியாக உடன்:
kill -HUP `ps -A -ostat,ppid,pid,cmd | grep -e ‘^[Zz]’ | awk ‘{print $2}’`
மற்றொரு மாற்று பெற்றோர் செயல்முறைகளைக் கண்டறிவது என்றாலும், முதல் ஒரு ஜாம்பி செயல்முறையை கொல்லுங்கள் நீங்கள் கழித்திருக்கலாம் என, அதைத் தக்கவைக்கும் பெற்றோர் செயல்முறைகளை நீங்கள் கொல்ல வேண்டும்:
ps -eo pid,ppid | grep <PID> kill -9 <PPID>
நீங்கள் மாற்ற வேண்டும் நீங்கள் கண்டறிந்த ஜாம்பி செயல்முறையின் ஐடி மூலமாகவும், அதைக் கொல்லவும் கொல்ல, பெற்றோர் செயல்முறையின் ஐடியைப் பயன்படுத்தவும் உதாரணமாக, வெளிப்படையாக.
நல்ல தளம்!
அவர்கள் எப்போதும் நம்மை சிக்கலில் இருந்து விடுவிக்கிறார்கள்.
எங்கே கூறுகிறது:
பெற்றோர் செயல்முறைகளைக் கண்டறிவதே மற்றொரு மாற்றாக இருந்தாலும், ஒரு ஜாம்பி செயல்முறையைக் கொல்ல, அதை ஆதரிக்கும் பெற்றோர் செயல்முறைகளை நீங்கள் கொல்ல வேண்டும், நீங்கள் முடிவு செய்திருக்கலாம்:
1 | ps -eo pid, ppid | grep
2|
3 | கொல்ல -9
நீங்கள் கண்டறிந்த ஜாம்பி செயல்முறையின் ஐடியை நீங்கள் மாற்ற வேண்டும் மற்றும் அதை கொலை செய்வதன் மூலம் கொல்ல, பெற்றோர் செயல்முறையின் ஐடியை எடுத்துக்காட்டில் மாற்றியமைக்க வேண்டும், வெளிப்படையாக.
நீங்கள் ஸ்கிரிப்டைச் சேர்க்கலாம்:
$cat killppid.sh
#! / பின் / பாஷ்
கொலை -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')
நிச்சயமாக, இது ஒரு சாதாரண பயனர் எப்போதும் செய்யும் பணி அல்ல.
இது நிர்வாகிக்கு மட்டுமே பயனுள்ளதாக இருக்கும், ஆனால் அதை ரூட்டாக இயக்குவது ஆபத்தானது, ஏனெனில் இது கணினியில் எந்த செயல்முறையையும் அழிக்கக்கூடும்.
மனிதக் கொலையில் இந்த குறிப்பு உள்ளது:
குறிப்புகள் உங்கள் ஷெல் (கட்டளை வரி மொழிபெயர்ப்பாளர்) உள்ளமைக்கப்பட்ட கொலை கட்டளையைக் கொண்டிருக்கலாம். நீங்கள் வேண்டுமானால்
மோதலைத் தீர்க்க இங்கு விவரிக்கப்பட்டுள்ள / bin / kill என கட்டளையை இயக்க வேண்டும்.
பாஷுக்கு அந்த கட்டளை உள்ளது, இது பற்றிய மேன் பாஷின் பகுதி இது:
கொல்ல [-s sigspec | -n சைனம் | -sigspec] [pid | வேலை விவரம்]...
கொல்ல -l | -L [sigspec | வெளியேறும்_நிலை]
பிட் அல்லது ஜாப் மூலம் பெயரிடப்பட்ட செயல்முறைகளுக்கு சிக்ஸ்பெக் அல்லது சிக்னம் மூலம் பெயரிடப்பட்ட சமிக்ஞையை அனுப்பவும்
விவரக்குறிப்பு sigspec என்பது SIGKILL (உடன் அல்லது
SIG முன்னொட்டு இல்லாமல்) அல்லது ஒரு சமிக்ஞை எண்; signum என்பது ஒரு சமிக்ஞை எண். என்றால்
sigspec இல்லை, பின்னர் SIGTERM கருதப்படுகிறது. -l இன் வாதம் பட்டியலிடுகிறது
சமிக்ஞை பெயர்கள். -l கொடுக்கப்படும் போது ஏதேனும் வாதங்கள் வழங்கப்பட்டால், பெயர்கள்
வாதங்களுடன் தொடர்புடைய சமிக்ஞைகள் பட்டியலிடப்பட்டுள்ளன, மேலும் திரும்பும் நிலை 0 ஆகும்.
-l க்கு exit_status வாதம் என்பது ஒரு சிக்னல் எண் அல்லது ஒன்றைக் குறிப்பிடும் எண்ணாகும்
ஒரு சமிக்ஞையால் நிறுத்தப்பட்ட ஒரு செயல்முறையின் வெளியேறும் நிலை. -L விருப்பம் சமமானது
கடன் கொடுத்தார் -எல். குறைந்தபட்சம் ஒரு சிக்னலாவது வெற்றிகரமாக அனுப்பப்பட்டிருந்தால், கில் ரிட்டர்ன்கள் உண்மை, அல்லது
பிழை ஏற்பட்டாலோ அல்லது தவறான விருப்பம் ஏற்பட்டாலோ தவறு.
சில சிக்கல்களைத் தவிர்ப்பதற்காக, பாஷ் செயல்முறைகளை எவ்வாறு பாதுகாக்கிறது என்பதை ஆரம்பத்தில் அவர்கள் விளக்குகிறார்கள், ஆனால் ரூட்டாக இயங்குவதற்கு பாதுகாப்பான ஸ்கிரிப்டை எவ்வாறு உருவாக்குவது என்பது எனக்கு தெளிவாகத் தெரியவில்லை.
இதை இப்படிப் பாதுகாக்க வேண்டும் என்று நான் நினைக்கும் ஒரே விஷயம்:
$cat killppid.sh
#! / பின் / பாஷ்
என்றால் [$ USER == "ரூட்"]
பிறகு எதிரொலி $0 ஐ ரூட்டாக இயக்க வேண்டாம் !!! இது ஆபத்தானது!
வெளியேறும்
fi
கொலை -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')
$
பாஷ்ஸ் கில் பயன்படுத்தவும், இல்லை / பின் / கொலை
நான் பாஷில் அதிகம் தேர்ச்சி பெறவில்லை என்பதை நீங்கள் எப்படிப் பார்க்க முடியும்.
ரூட்டாக இயங்கினாலும், சைல்டு செயல்முறையின் பயனராக இயங்கும் பாதுகாப்பான ஸ்கிரிப்டை எழுதுவது எப்படி என்று உங்களுக்குத் தெரியுமா?
இது போன்ற கைமுறையாக என்ன செய்ய வேண்டும் என்பதற்கு சமமான ஒன்று:
$ சு;
$ கொலை -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')