linux - मेरी प्रक्रिया किसने "मार डाली" और क्यों?

मुझे सबसे पहले बताएं कि ओमकिल्लर कब और क्यों आते हैं?

मान लें कि आपके पास 512 रैम + 1 जीबी स्वैप मेमोरी है। तो सिद्धांत रूप में, आपके सीपीयू की कुल 1.5 जीबी वर्चुअल मेमोरी तक पहुंच है।

अब, कुछ समय के लिए सब कुछ 1.5 जीबी के भीतर ठीक है। लेकिन अचानक (या धीरे-धीरे) आपके सिस्टम ने अधिक से अधिक स्मृति का उपभोग शुरू कर दिया है और यह कुल स्मृति का लगभग 9 5% बिंदु पर पहुंच गया है।

अब कहें कि किसी भी प्रक्रिया ने कर्नेल से स्मृति के बड़े हिस्से का अनुरोध किया है। कर्नेल उपलब्ध स्मृति के लिए जांच करें और यह पता लगाएं कि यह आपकी प्रक्रिया को और अधिक स्मृति आवंटित करने का कोई तरीका नहीं है। तो यह ओमकिल्लर ( http://linux-mm.org/OOM ) को कुछ मेमोरी कॉलिंग / आविष्कार करने की कोशिश करेगा।

ओमकिल्लर के पास प्रत्येक प्रक्रिया के लिए रैंक स्कोर करने के लिए अपना स्वयं का एल्गोरिदम है। आम तौर पर कौन सी प्रक्रिया अधिक मेमोरी का उपयोग करती है, पीड़ित को मारने का शिकार बन जाता है।

मुझे ओमकिल्लर के लॉग कहां मिल सकते हैं?

आमतौर पर / var / log निर्देशिका में। या तो /var/log/kern.log या / var / log / dmesg

आशा है कि यह आपकी मदद करेगा।

कुछ सामान्य समाधान:

1. स्मृति बढ़ाएं (स्वैप नहीं)
2. अपने कार्यक्रम में मेमोरी लीक पाएं और उन्हें ठीक करें
3. मेमोरी को प्रतिबंधित करें किसी भी प्रक्रिया का उपभोग कर सकते हैं (उदाहरण के लिए JVM स्मृति को JAVA_OPTS का उपयोग करके प्रतिबंधित किया जा सकता है)
4. लॉग और गूगल देखें :)

उपयोगकर्ता के पास हत्या या नियंत्रण + सी का उपयोग करके अपने स्वयं के कार्यक्रमों को मारने की क्षमता है, लेकिन मुझे लगता है कि ऐसा नहीं हुआ है, और उपयोगकर्ता ने आपको शिकायत की है।

रूट में पाठ्यक्रम के कार्यक्रमों को मारने की क्षमता है, लेकिन अगर किसी के पास आपकी मशीन पर जड़ है और सामानों को मार रहा है तो आपको बड़ी समस्याएं हैं।

यदि आप sysadmin नहीं हैं, तो sysadmin ने CPU, RAM, ort डिस्क उपयोग और ऑटो-किल्स प्रक्रियाओं पर कोटा सेट किया हो सकता है जो उन्हें पार करते हैं।

उन अनुमानों के अलावा, मुझे प्रोग्राम के बारे में अधिक जानकारी के बिना निश्चित नहीं है।

ओमकिल्लर (आउट-ऑफ-मेमोरी किलर) के साथ हमारे सिद्धांत अनुप्रयोग (यानी सर्वर मौजूद होने का कारण) और यह डेटा बेस प्रक्रियाओं को मारने के साथ हमारे पास एक ग्राहक साइट (रेड हैट, मुझे लगता है) पर लिनक्स के तहत आवर्ती समस्याएं हुई हैं।

प्रत्येक मामले में ओओएमकिल्लर ने बस निर्णय लिया कि प्रक्रियाएं बहुत संसाधनों के लिए उपयोग कर रही थीं ... मशीन संसाधनों की कमी के लिए असफल होने वाली भी नहीं थी। न तो एप्लिकेशन और न ही इसके डेटाबेस में मेमोरी लीक (या कोई अन्य संसाधन रिसाव) के साथ समस्याएं हैं।

मैं एक लिनक्स विशेषज्ञ नहीं हूं, लेकिन मैंने यह तय करने के लिए इसके एल्गोरिदम को इकट्ठा किया है कि कुछ मारना और क्या मारना जटिल है। इसके अलावा, मुझे बताया गया था (मैं इसकी सटीकता के रूप में बात नहीं कर सकता) कि ओमकिल्लर को कर्नेल में बेक किया गया है और आप इसे आसानी से नहीं चला सकते हैं।

जैसा कि डीईसीसी और एडम जास्क्यूविज़ ने कहा है, अपराधी ओओएम किलर की संभावना है। हालांकि, अगला प्रश्न यह है कि: मैं इसे कैसे रोकूं?

कई तरीके हैं:

1. यदि आप कर सकते हैं तो अपने सिस्टम को और रैम दें (यदि यह एक वीएम आसान है)
2. सुनिश्चित करें कि ओओएम हत्यारा एक अलग प्रक्रिया चुनता है।
3. ओओएम किलर को अक्षम करें
4. एक लिनक्स डिस्ट्रो चुनें जो ओओएम किलर के साथ जहाजों को अक्षम कर देता है।

मैंने पाया (2) विशेष रूप से कार्यान्वित करना आसान है, इस आलेख के लिए धन्यवाद।

मुझे हाल ही में इस समस्या का सामना करना पड़ा। आखिर में, मैंने पाया कि ओपनस्यूज ज़िप्पर अपडेट को स्वचालित रूप से कॉल करने के बाद ही मेरी प्रक्रियाएं मारे गए थे। ज़ीपर अपडेट को अक्षम करने के लिए मेरी समस्या हल हो गई।

यदि उपयोगकर्ता या sysadmin प्रोग्राम को मार नहीं सकता है तो कर्नेल हो सकता है। कर्नेल केवल चरम संसाधन भुखमरी (लगता है कि mem + स्वैप थकावट) जैसे असाधारण परिस्थितियों में एक प्रक्रिया को मार डालेगा।

यह विषय पर एक अच्छा लेख जैसा दिखता है: ओओएम हत्यारा को टमिंग ।

यह बात है कि लिनक्स स्मृति को कम करता है। जब कोई प्रक्रिया अधिक जगह मांगती है, तो लिनक्स इसे उस स्थान को देगा, भले ही इसे किसी अन्य प्रक्रिया द्वारा दावा किया गया हो, भले ही कोई वास्तव में उन सभी मेमोरी का उपयोग न करे जो वे मांगते हैं। प्रक्रिया को उस स्मृति का अनन्य उपयोग मिलेगा जब इसे वास्तव में उपयोग किया जाता है, जब यह इसके लिए पूछता है। यह आवंटन त्वरित बनाता है, और आपको "धोखा" देने और आपके पास वास्तव में अधिक स्मृति आवंटित करने की अनुमति दे सकता है। हालांकि, एक बार प्रक्रियाएं इस स्मृति का उपयोग शुरू करने के बाद, लिनक्स को एहसास हो सकता है कि यह स्मृति को आवंटित करने में बहुत उदार रहा है, और इसे मुक्त करने के लिए किसी प्रक्रिया को मारना होगा। मारने की प्रक्रिया खाता रनटाइम में लेने वाले स्कोर पर आधारित होती है (लंबी चल रही प्रक्रियाएं सुरक्षित होती हैं), स्मृति उपयोग (लालची प्रक्रियाएं कम सुरक्षित होती हैं), और कुछ अन्य कारक, जिसमें एक प्रक्रिया कम करने के लिए आप समायोजित कर सकते हैं मारने की संभावना है। यह लेख में बहुत अधिक विस्तार से वर्णित है।

संपादित करें: और यहां एक और लेख है जो बताता है कि प्रक्रिया को कैसे चुना जाता है (कुछ कर्नेल कोड उदाहरणों के साथ एनोटेटेड)। इसके बारे में बड़ी बात यह है कि इसमें विभिन्न badness() नियमों के पीछे तर्क पर कुछ टिप्पणी शामिल है।

सिस्टमटैप (या एक ट्रैसर) जैसे टूल कर्नेल सिग्नल-ट्रांसमिशन लॉजिक और रिपोर्ट की निगरानी कर सकते हैं। उदाहरण के लिए, https://sourceware.org/systemtap/examples/process/sigmon.stp

# stap .../sigmon.stp -x 31994 SIGKILL
   SPID     SNAME            RPID  RNAME            SIGNUM SIGNAME
   5609     bash             31994 find             9      SIGKILL

फ़िल्टरिंग if उस स्क्रिप्ट में ब्लॉक को स्वाद के लिए समायोजित किया जा सकता है, या सिस्टमवाइड सिग्नल ट्रैफिक का पता लगाने के लिए हटा दिया जा सकता है। बैकट्रैस एकत्र करके कारणों को और अलग किया जा सकता है (क्रमशः कर्नेल- और उपयोगकर्ता स्पेस के लिए जांच में एक print_backtrace() और / या print_ubacktrace() ) जोड़ें।