मृतकों का दिन आ रहा है और यही कारण है कि हम इस बारे में बात करने के लिए LxA से थोड़ा ट्यूटोरियल करना चाहते हैं ज़ोंबी प्रक्रियाओं और हम उन्हें कैसे मार सकते हैं। सबसे पहली बात यह है कि ज़ोंबी प्रक्रिया क्या है, और वह यह है कि जैसा कि आप जानते हैं, लिनक्स कर्नेल में प्रक्रियाओं को प्रबंधित करने के लिए एक सबसिस्टम है और सीपीयू प्रसंस्करण प्रवाह को बनाने, भेजने, हटाने या प्राथमिकता देने के लिए अनुसूचक के साथ काम करता है। प्रक्रियाओं को मार डालो। ठीक है, कर्नेल का यह हिस्सा, यूनिक्स जैसी बाकी प्रणालियों की तरह, प्रक्रियाओं की विभिन्न स्थितियों के बीच अंतर करता है ...
तो हम पा सकते हैं एक प्रक्रिया यह नींद (S) अवस्था में हो सकता है, अर्थात सो रहा है। साथ ही एक चालू स्थिति (R) में प्रक्रियाएं जो वर्तमान में चल रही हैं या चल रही हैं, प्रक्रियाएं प्रतीक्षा (D) में शामिल होने के लिए इंतजार कर रही हैं, जेप्ट (T) या निलंबित हैं, और लाश (Z) या मृतक भी। एक ज़ोंबी या मृत प्रक्रिया वह है जिसे पहले से ही सफलतापूर्वक समाप्त कर दिया गया है, लेकिन कुछ सिस्टम संसाधनों को अपहरण कर लिया गया है क्योंकि लिनक्स अभी भी इसे प्रक्रिया तालिका में सहेज रहा है। आप पहले से ही जानते हैं कि जब कोई प्रक्रिया समाप्त हो जाती है, तो उसे इस स्थिति में नहीं रहना चाहिए, लेकिन पूरा हो जाता है और कर्नेल संसाधनों को मुक्त कर देता है ताकि अन्य प्रक्रियाएं उनका उपयोग कर सकें, मूल रूप से यह अधिग्रहित रैम को मुक्त करता है ...
खैर, जैसा कि इस प्रकार की ज़ोंबी प्रक्रियाओं का होना दिलचस्प नहीं है, हालांकि वे इतने अक्सर नहीं होते हैं, हम उन्हें यहां पर संकेत के लिए खोज और समाप्त कर सकते हैं। पहली बात यह है कि हमारे डिस्ट्रो में ज़ोंबी प्रक्रियाएं हैं या नहीं और इसके लिए हम खुद की मदद कर सकते हैं शीर्ष या 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 | पीएस -ईओ पीआईडी, पीपीआईडी | ग्रेप
2|
3 | मार -9
आपको ज़ोंबी प्रक्रिया की आईडी के लिए स्थानापन्न करना होगा जो आपको मिली है और इसे किल से मारने के लिए, उदाहरण में प्रतिस्थापित करने वाली मूल प्रक्रिया की आईडी का उपयोग करें, जाहिर है।
आप स्क्रिप्ट जोड़ सकते हैं:
$ बिल्ली
#! / Bin / bash
किल -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{प्रिंट $ 2}')
बेशक, यह कोई ऐसा कार्य नहीं है जो एक सामान्य उपयोगकर्ता हर समय करता है।
यह केवल व्यवस्थापक के लिए उपयोगी होगा, लेकिन इसे रूट के रूप में चलाना खतरनाक है, क्योंकि यह सिस्टम पर किसी भी प्रक्रिया को मार सकता है।
मैन किल में यह नोट है:
नोट आपके शेल (कमांड लाइन दुभाषिया) में एक बिल्ट-इन किल कमांड हो सकता है। आप कर सकते हैं
संघर्ष को हल करने के लिए यहां वर्णित कमांड को / बिन / किल के रूप में चलाने की आवश्यकता है।
बैश के पास वह आदेश है, यह इसके बारे में मैन बैश का हिस्सा है:
किल [-s sigspec | -एन साइनम | -सिगस्पेक] [पीआईडी | जॉबस्पेक] ...
किल-एल | -एल [सिगस्पेक | निकास_स्थिति]
पिड या जॉब द्वारा नामित प्रक्रियाओं के लिए सिगस्पेक या साइनम द्वारा नामित सिग्नल भेजें
कल्पना sigspec या तो केस-असंवेदनशील सिग्नल नाम है जैसे SIGKILL (or . के साथ)
SIG उपसर्ग के बिना) या एक संकेत संख्या; साइनम एक सिग्नल नंबर है। अगर
sigspec मौजूद नहीं है, तो SIGTERM मान लिया जाता है। -l का एक तर्क सूचीबद्ध करता है
संकेत नाम। यदि -l दिए जाने पर कोई तर्क दिया जाता है, तो उनके नाम
तर्कों के अनुरूप संकेत सूचीबद्ध हैं, और वापसी की स्थिति 0 है।
-l के लिए exit_status तर्क एक संख्या है जो या तो एक संकेत संख्या निर्दिष्ट करती है या
सिग्नल द्वारा समाप्त प्रक्रिया की निकास स्थिति। -L विकल्प समतुल्य है
-एल को उधार दिया। अगर कम से कम एक सिग्नल सफलतापूर्वक भेजा गया था, या
गलत अगर कोई त्रुटि होती है या कोई अमान्य विकल्प सामने आता है।
शुरुआत में वे बताते हैं कि कैसे बैश कुछ समस्याओं से बचने के लिए प्रक्रियाओं की रक्षा करता है, लेकिन यह मेरे लिए स्पष्ट नहीं है कि मैं रूट के रूप में चलाने के लिए एक सुरक्षित स्क्रिप्ट कैसे बना सकता हूं।
केवल एक चीज जिसके बारे में मैं सोच सकता हूं, वह है इसे इस तरह से सुरक्षित रखना:
$ बिल्ली
#! / Bin / bash
अगर [$ USER == "रूट"]
फिर गूंज $ 0 को रूट के रूप में न चलाएं !!! यह खतरनाक है!
निकास
fi
किल -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{प्रिंट $ 2}')
$
बैश की मार का प्रयोग करें, न कि / बिन / किल
आप कैसे देख सकते हैं कि मैं बैश में पारंगत नहीं हूं।
क्या आप जानते हैं कि एक सुरक्षित स्क्रिप्ट कैसे लिखी जाती है जो चाइल्ड प्रोसेस के उपयोगकर्ता के रूप में चलती है, भले ही वह रूट के रूप में चलती हो?
इस तरह मैन्युअल रूप से क्या किया जाएगा इसके बराबर कुछ:
$ सु;
$ किल -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{प्रिंट $ 2}')