🥇 लहान मुलांसाठी बीपीएफ, पहिला भाग: विस्तारित बीपीएफ

सुरुवातीला एक तंत्रज्ञान होते आणि त्याला बीपीएफ असे म्हणतात. आम्ही तिच्याकडे पाहिलं मागील, या मालिकेचा जुना करार लेख. 2013 मध्ये, अॅलेक्सी स्टारोवोइटोव्ह आणि डॅनियल बोर्कमन यांच्या प्रयत्नांद्वारे, आधुनिक 64-बिट मशीनसाठी अनुकूल केलेली, त्याची सुधारित आवृत्ती विकसित केली गेली आणि लिनक्स कर्नलमध्ये समाविष्ट केली गेली. या नवीन तंत्रज्ञानाला थोडक्यात इंटर्नल बीपीएफ असे म्हटले गेले, नंतर विस्तारित बीपीएफ असे नाव देण्यात आले आणि आता, अनेक वर्षांनी, प्रत्येकजण त्याला फक्त बीपीएफ म्हणतो.

साधारणपणे बोलायचे झाल्यास, BPF तुम्हाला लिनक्स कर्नल स्पेसमध्ये अनियंत्रित वापरकर्त्याने पुरवलेला कोड चालवण्याची परवानगी देतो आणि नवीन आर्किटेक्चर इतके यशस्वी ठरले आहे की आम्हाला त्याच्या सर्व अनुप्रयोगांचे वर्णन करण्यासाठी आणखी डझनभर लेखांची आवश्यकता असेल. (विकासकांनी फक्त एकच गोष्ट चांगली केली नाही, जसे की तुम्ही खालील कार्यप्रदर्शन कोडमध्ये पाहू शकता, एक सभ्य लोगो तयार करत होता.)

हा लेख BPF व्हर्च्युअल मशीनची रचना, BPF सह कार्य करण्यासाठी कर्नल इंटरफेस, विकास साधने, तसेच विद्यमान क्षमतांचे संक्षिप्त, अतिशय संक्षिप्त विहंगावलोकन वर्णन करतो, उदा. BPF च्या व्यावहारिक अनुप्रयोगांच्या सखोल अभ्यासासाठी आपल्याला भविष्यात आवश्यक असलेली प्रत्येक गोष्ट.

लेखाचा सारांश

बीपीएफ आर्किटेक्चरचा परिचय. प्रथम, आम्ही BPF आर्किटेक्चरचे बर्ड्स आय व्ह्यू घेऊ आणि मुख्य घटकांची रूपरेषा देऊ.

BPF व्हर्च्युअल मशीनची रजिस्टर्स आणि कमांड सिस्टम. आधीच संपूर्ण आर्किटेक्चरची कल्पना असल्याने, आम्ही BPF व्हर्च्युअल मशीनच्या संरचनेचे वर्णन करू.

बीपीएफ वस्तूंचे जीवन चक्र, बीपीएफएस फाइल सिस्टम. या विभागात, आम्ही BPF वस्तूंचे जीवन चक्र जवळून पाहू - कार्यक्रम आणि नकाशे.

बीपीएफ सिस्टम कॉल वापरून वस्तू व्यवस्थापित करणे. आधीपासून असलेल्या सिस्टीमबद्दल काही समजूतदारपणामुळे, आम्ही शेवटी विशेष सिस्टम कॉल वापरून वापरकर्त्याच्या जागेवरून ऑब्जेक्ट्स कसे तयार आणि हाताळायचे ते पाहू. bpf(2).

Пишем программы BPF с помощью libbpf. अर्थात, आपण सिस्टम कॉल वापरून प्रोग्राम लिहू शकता. पण अवघड आहे. अधिक वास्तववादी परिस्थितीसाठी, आण्विक प्रोग्रामरनी एक लायब्ररी विकसित केली libbpf. आम्ही एक मूलभूत BPF ऍप्लिकेशन स्केलेटन तयार करू ज्याचा आम्ही पुढील उदाहरणांमध्ये वापर करू.

कर्नल मदतनीस. येथे आपण BPF प्रोग्राम्स कर्नल हेल्पर फंक्शन्समध्ये कसे प्रवेश करू शकतात ते शिकू - एक साधन जे नकाशांसह, क्लासिकच्या तुलनेत नवीन BPF च्या क्षमतांचा मूलभूतपणे विस्तार करते.

BPF प्रोग्राममधून नकाशांमध्ये प्रवेश. या टप्प्यापर्यंत, आम्ही नकाशे वापरणारे प्रोग्राम कसे तयार करू शकतो हे समजून घेण्यासाठी आम्हाला पुरेसे समजेल. आणि महान आणि पराक्रमी पडताळकामध्ये एक झटपट डोकावू.

विकास साधने. प्रयोगांसाठी आवश्यक युटिलिटीज आणि कर्नल कसे एकत्र करायचे यावरील मदत विभाग.

निष्कर्ष लेखाच्या शेवटी, ज्यांनी हे आतापर्यंत वाचले आहे त्यांना प्रेरक शब्द सापडतील आणि पुढील लेखांमध्ये काय होईल याचे थोडक्यात वर्णन मिळेल. ज्यांना पुढे चालू ठेवण्याची प्रतीक्षा करण्याची इच्छा किंवा क्षमता नाही त्यांच्यासाठी आम्ही स्वयं-अभ्यासासाठी अनेक लिंक्स देखील सूचीबद्ध करू.

बीपीएफ आर्किटेक्चरचा परिचय

आम्ही बीपीएफ आर्किटेक्चरचा विचार करण्यास सुरुवात करण्यापूर्वी, आम्ही शेवटच्या वेळी (ओह) याचा संदर्भ घेऊ क्लासिक BPF, जे RISC मशीनच्या आगमनाला प्रतिसाद म्हणून विकसित केले गेले आणि कार्यक्षम पॅकेट फिल्टरिंगची समस्या सोडवली. आर्किटेक्चर इतके यशस्वी ठरले की, बर्कले UNIX मध्ये नव्वदच्या दशकात जन्माला आल्याने, ते बहुतेक विद्यमान ऑपरेटिंग सिस्टमवर पोर्ट केले गेले, विसाव्या दशकात टिकून राहिले आणि अजूनही नवीन अनुप्रयोग शोधत आहे.

नवीन BPF 64-बिट मशीन्स, क्लाउड सेवा आणि SDN तयार करण्यासाठी साधनांची वाढती गरज यांच्या सर्वव्यापीतेला प्रतिसाद म्हणून विकसित केले गेले.Sऑफर-dपरिष्कृत nकाम करणे). क्लासिक BPF साठी सुधारित बदली म्हणून कर्नल नेटवर्क अभियंत्यांनी विकसित केलेले, नवीन BPF अक्षरशः सहा महिन्यांनंतर लिनक्स सिस्टम ट्रेस करण्याच्या कठीण कामात अनुप्रयोग सापडले आणि आता, सहा वर्षानंतर, आम्हाला फक्त पुढील लेखाची आवश्यकता असेल. विविध प्रकारच्या कार्यक्रमांची यादी करा.

मजेदार चित्रे

त्याच्या मुळात, BPF हे सँडबॉक्स व्हर्च्युअल मशीन आहे जे तुम्हाला सुरक्षेशी तडजोड न करता कर्नल स्पेसमध्ये “आरबिट्ररी” कोड चालवण्याची परवानगी देते. BPF प्रोग्राम्स वापरकर्त्याच्या जागेत तयार केले जातात, कर्नलमध्ये लोड केले जातात आणि काही इव्हेंट स्त्रोताशी जोडलेले असतात. एखादी घटना असू शकते, उदाहरणार्थ, नेटवर्क इंटरफेसवर पॅकेटचे वितरण, काही कर्नल फंक्शन लॉन्च करणे इ. पॅकेजच्या बाबतीत, BPF प्रोग्रामला पॅकेजच्या डेटा आणि मेटाडेटामध्ये प्रवेश असेल (वाचनासाठी आणि शक्यतो, प्रोग्रामच्या प्रकारानुसार लेखनासाठी); कर्नल फंक्शन चालवण्याच्या बाबतीत, वितर्क फंक्शन, कर्नल मेमरीसाठी पॉइंटर इ.

चला या प्रक्रियेवर बारकाईने नजर टाकूया. सुरुवातीला, क्लासिक बीपीएफमधील पहिल्या फरकाबद्दल बोलूया, ज्यासाठी असेंबलरमध्ये लिहिलेले प्रोग्राम. नवीन आवृत्तीमध्ये, आर्किटेक्चरचा विस्तार केला गेला ज्यामुळे उच्च-स्तरीय भाषांमध्ये प्रोग्राम्स लिहिता येतील, प्रामुख्याने, अर्थातच, C मध्ये. यासाठी, llvm साठी बॅकएंड विकसित केला गेला, जो तुम्हाला BPF आर्किटेक्चरसाठी बाईटेकोड तयार करण्यास अनुमती देतो.

BPF आर्किटेक्चरची रचना, काही प्रमाणात, आधुनिक मशीनवर कार्यक्षमतेने चालण्यासाठी केली गेली होती. हे कार्य व्यवहारात करण्यासाठी, BPF बाईटेकोड, एकदा कर्नलमध्ये लोड केल्यानंतर, JIT कंपाइलर नावाच्या घटकाचा वापर करून मूळ कोडमध्ये अनुवादित केले जातेJUst In Time). पुढे, जर तुम्हाला आठवत असेल, तर क्लासिक BPF मध्ये प्रोग्राम कर्नलमध्ये लोड केला गेला होता आणि इव्हेंट स्त्रोताशी अणुरीत्या जोडला गेला होता - सिंगल सिस्टम कॉलच्या संदर्भात. नवीन आर्किटेक्चरमध्ये, हे दोन टप्प्यांत घडते - प्रथम, सिस्टम कॉल वापरून कोड कर्नलमध्ये लोड केला जातो. bpf(2)आणि नंतर, नंतर, प्रोग्रामच्या प्रकारानुसार बदलणार्‍या इतर यंत्रणांद्वारे, प्रोग्राम इव्हेंट स्त्रोताशी संलग्न होतो.

येथे वाचकाला एक प्रश्न असू शकतो: हे शक्य आहे का? अशा कोडच्या अंमलबजावणीच्या सुरक्षिततेची हमी कशी दिली जाते? व्हेरिफायर (इंग्रजीमध्ये या स्टेजला व्हेरिफायर म्हणतात आणि मी इंग्रजी शब्द वापरणे सुरू ठेवेन):

व्हेरिफायर एक स्थिर विश्लेषक आहे जो प्रोग्राम कर्नलच्या सामान्य ऑपरेशनमध्ये व्यत्यय आणत नाही याची खात्री करतो. याचा अर्थ असा नाही की प्रोग्राम सिस्टमच्या ऑपरेशनमध्ये व्यत्यय आणू शकत नाही - बीपीएफ प्रोग्राम्स, प्रकारानुसार, कर्नल मेमरीचे विभाग वाचू आणि पुन्हा लिहू शकतात, फंक्शन्सची मूल्ये परत करू शकतात, ट्रिम करू शकतात, जोडू शकतात, पुन्हा लिहू शकतात. आणि नेटवर्क पॅकेट देखील फॉरवर्ड करा. व्हेरिफायर हमी देतो की BPF प्रोग्राम चालवल्याने कर्नल क्रॅश होणार नाही आणि नियमांनुसार, राईट ऍक्सेस असलेला प्रोग्राम, उदाहरणार्थ, आउटगोइंग पॅकेटचा डेटा, पॅकेटच्या बाहेर कर्नल मेमरी ओव्हरराईट करू शकणार नाही. BPF च्या इतर सर्व घटकांशी परिचित झाल्यानंतर, आम्ही संबंधित विभागात थोड्या अधिक तपशीलाने पडताळकाकडे पाहू.

मग आपण आतापर्यंत काय शिकलो? वापरकर्ता C मध्ये प्रोग्राम लिहितो, सिस्टम कॉल वापरून कर्नलमध्ये लोड करतो bpf(2), जिथे ते एका पडताळकाद्वारे तपासले जाते आणि मूळ बायकोडमध्ये भाषांतरित केले जाते. मग तोच किंवा दुसरा वापरकर्ता प्रोग्रामला इव्हेंट स्त्रोताशी जोडतो आणि तो कार्यान्वित करण्यास सुरवात करतो. अनेक कारणांसाठी बूट आणि कनेक्शन वेगळे करणे आवश्यक आहे. प्रथम, सत्यापनकर्ता चालवणे तुलनेने महाग आहे आणि तोच प्रोग्राम अनेक वेळा डाउनलोड करून आपण संगणकाचा वेळ वाया घालवतो. दुसरे म्हणजे, प्रोग्राम कसा जोडला जातो हे त्याच्या प्रकारावर अवलंबून असते आणि एक वर्षापूर्वी विकसित केलेला एक "सार्वत्रिक" इंटरफेस नवीन प्रकारच्या प्रोग्रामसाठी योग्य नसू शकतो. (जरी आता आर्किटेक्चर अधिक परिपक्व होत चालले आहे, तरीही हा इंटरफेस स्तरावर एकत्रित करण्याचा विचार आहे. libbpf.)

लक्षवेधक वाचकाच्या लक्षात येईल की आम्ही अद्याप चित्रांसह पूर्ण केलेले नाही. खरंच, वरील सर्व गोष्टी क्लासिक BPF च्या तुलनेत BPF मूलभूतपणे चित्र का बदलतात हे स्पष्ट करत नाही. सामायिक मेमरी आणि कर्नल हेल्पर फंक्शन्स वापरण्याची क्षमता ही दोन नवकल्पना ज्या लागूतेची व्याप्ती लक्षणीयरीत्या विस्तृत करतात. BPF मध्ये, सामायिक मेमरी तथाकथित नकाशे वापरून लागू केली जाते - विशिष्ट API सह सामायिक डेटा संरचना. त्यांना कदाचित हे नाव मिळाले कारण पहिला प्रकारचा नकाशा हॅश टेबल होता. त्यानंतर अॅरे दिसू लागले, स्थानिक (प्रति-सीपीयू) हॅश टेबल्स आणि स्थानिक अॅरे, शोध वृक्ष, BPF प्रोग्राम्सचे पॉइंटर असलेले नकाशे आणि बरेच काही. आमच्यासाठी आता मनोरंजक गोष्ट अशी आहे की BPF प्रोग्राम्समध्ये आता कॉल दरम्यान स्थिती टिकवून ठेवण्याची आणि इतर प्रोग्रामसह आणि वापरकर्त्याच्या जागेसह सामायिक करण्याची क्षमता आहे.

सिस्टम कॉल वापरून वापरकर्त्याच्या प्रक्रियेतून नकाशे ऍक्सेस केले जातात bpf(2), आणि हेल्पर फंक्शन्स वापरून कर्नलमध्ये चालणाऱ्या BPF प्रोग्राम्समधून. शिवाय, मदतनीस केवळ नकाशेसह कार्य करण्यासाठीच नाही तर इतर कर्नल क्षमतांमध्ये प्रवेश करण्यासाठी देखील अस्तित्वात आहेत. उदाहरणार्थ, BPF प्रोग्राम्स इतर इंटरफेसवर पॅकेट्स फॉरवर्ड करण्यासाठी, परफ इव्हेंट्स व्युत्पन्न करण्यासाठी, कर्नल स्ट्रक्चर्समध्ये प्रवेश करण्यासाठी मदतनीस फंक्शन्स वापरू शकतात.

सारांश, BPF कर्नल स्पेसमध्ये अनियंत्रित लोड करण्याची क्षमता प्रदान करते, म्हणजे, सत्यापनकर्ता-चाचणी, वापरकर्ता कोड. हा कोड कॉलमधील स्थिती वाचवू शकतो आणि वापरकर्त्याच्या जागेसह डेटाची देवाणघेवाण करू शकतो आणि या प्रकारच्या प्रोग्रामद्वारे अनुमत कर्नल उपप्रणालींमध्ये प्रवेश देखील आहे.

हे आधीच कर्नल मॉड्यूल्सद्वारे प्रदान केलेल्या क्षमतांसारखे आहे, ज्याच्या तुलनेत BPF चे काही फायदे आहेत (अर्थातच, आपण फक्त समान अनुप्रयोगांची तुलना करू शकता, उदाहरणार्थ, सिस्टम ट्रेसिंग - आपण BPF सह अनियंत्रित ड्रायव्हर लिहू शकत नाही). तुम्ही कमी एंट्री थ्रेशोल्ड (BPF वापरणार्‍या काही युटिलिटिजसाठी वापरकर्त्याला कर्नल प्रोग्रामिंग कौशल्ये किंवा प्रोग्रामिंग कौशल्ये असणे आवश्यक नसते), रनटाइम सुरक्षितता (लिहिताना ज्यांनी सिस्टीम मोडली नाही त्यांच्यासाठी टिप्पण्यांमध्ये हात वर करा. किंवा मॉड्युल्स चाचणी करणे), अणु-मॅड्यूल्स रीलोड करताना डाउनटाइम असतो आणि BPF सबसिस्टम हे सुनिश्चित करते की कोणतेही कार्यक्रम चुकले नाहीत (योग्य सांगायचे तर, हे सर्व प्रकारच्या BPF प्रोग्रामसाठी खरे नाही).

अशा क्षमतेची उपस्थिती बीपीएफला कर्नलचा विस्तार करण्यासाठी एक सार्वत्रिक साधन बनवते, ज्याची सरावाने पुष्टी केली जाते: बीपीएफमध्ये अधिकाधिक नवीन प्रकारचे प्रोग्राम जोडले जातात, अधिकाधिक मोठ्या कंपन्या 24×7 लढाऊ सर्व्हरवर बीपीएफ वापरतात, अधिकाधिक. स्टार्टअप्स त्यांचा व्यवसाय बीपीएफवर आधारित असलेल्या सोल्यूशन्सवर तयार करतात. BPF सर्वत्र वापरला जातो: DDoS हल्ल्यांपासून संरक्षण करण्यासाठी, SDN तयार करण्यासाठी (उदाहरणार्थ, kubernetes साठी नेटवर्क लागू करणे), मुख्य सिस्टम ट्रेसिंग टूल आणि स्टॅटिस्टिक्स कलेक्टर म्हणून, घुसखोरी शोध प्रणाली आणि सँडबॉक्स सिस्टम इ.

लेखाचा विहंगावलोकन भाग येथे पूर्ण करू आणि व्हर्च्युअल मशीन आणि BPF इकोसिस्टम अधिक तपशीलवार पाहू.

विषयांतर: उपयुक्तता

खालील विभागांमधील उदाहरणे चालवण्यास सक्षम होण्यासाठी, तुम्हाला अनेक उपयुक्तता आवश्यक असू शकतात, किमान llvm/clang bpf समर्थनासह आणि bpftool. विभागात विकास साधने तुम्ही युटिलिटीज एकत्र करण्यासाठी सूचना वाचू शकता, तसेच तुमचे कर्नल. आमच्या सादरीकरणातील सुसंवाद बिघडू नये म्हणून हा विभाग खाली ठेवला आहे.

बीपीएफ व्हर्च्युअल मशीन रजिस्टर्स आणि इंस्ट्रक्शन सिस्टम

बीपीएफचे आर्किटेक्चर आणि कमांड सिस्टम हे लक्षात घेऊन विकसित केले गेले आहे की प्रोग्राम सी भाषेत लिहिले जातील आणि कर्नलमध्ये लोड केल्यानंतर, मूळ कोडमध्ये अनुवादित केले जातील. म्हणून, आधुनिक मशीन्सच्या क्षमतांचा गणिती अर्थाने छेदनबिंदूकडे लक्ष देऊन, रजिस्टर्सची संख्या आणि आदेशांचा संच निवडला गेला. याव्यतिरिक्त, प्रोग्राम्सवर विविध निर्बंध लादण्यात आले होते, उदाहरणार्थ, अलीकडे पर्यंत लूप आणि सबरूटीन लिहिणे शक्य नव्हते आणि सूचनांची संख्या 4096 पर्यंत मर्यादित होती (आता विशेषाधिकार प्राप्त प्रोग्राम एक दशलक्ष सूचना लोड करू शकतात).

BPF मध्ये अकरा वापरकर्ता-प्रवेशयोग्य 64-बिट नोंदणी आहेत r0-r10 आणि प्रोग्राम काउंटर. नोंदणी करा r10 फ्रेम पॉइंटर आहे आणि ते केवळ वाचनीय आहे. प्रोग्राम्सना रनटाइमवर 512-बाइट स्टॅक आणि नकाशांच्या स्वरूपात अमर्यादित सामायिक मेमरीमध्ये प्रवेश असतो.

BPF प्रोग्राम्सना प्रोग्राम-प्रकार कर्नल मदतनीसांचा विशिष्ट संच आणि अगदी अलीकडे, नियमित कार्ये चालवण्याची परवानगी आहे. प्रत्येक कॉल फंक्शन पाच वितर्क घेऊ शकतात, जे रजिस्टरमध्ये पास केले जातात r1-r5, आणि परतावा मूल्य कडे पास केले जाते r0. फंक्शनमधून परत आल्यानंतर, रजिस्टरमधील सामग्रीची हमी दिली जाते r6-r9 बदलणार नाही.

कार्यक्षम प्रोग्राम भाषांतरासाठी, नोंदणी r0-r11 सध्याच्या आर्किटेक्चरची ABI वैशिष्ट्ये विचारात घेऊन, सर्व समर्थित आर्किटेक्चर्स रिअल रजिस्टर्समध्ये अनन्यपणे मॅप केल्या जातात. उदाहरणार्थ, साठी x86_64 नोंदणी r1-r5, फंक्शन पॅरामीटर्स पास करण्यासाठी वापरले जाते, वर प्रदर्शित केले जाते rdi, rsi, rdx, rcx, r8, जे फंक्शन्सवर पॅरामीटर्स पास करण्यासाठी वापरले जातात x86_64. उदाहरणार्थ, डावीकडील कोड उजवीकडील कोडमध्ये याप्रमाणे अनुवादित होतो:

1:  (b7) r1 = 1                    mov    $0x1,%rdi
2:  (b7) r2 = 2                    mov    $0x2,%rsi
3:  (b7) r3 = 3                    mov    $0x3,%rdx
4:  (b7) r4 = 4                    mov    $0x4,%rcx
5:  (b7) r5 = 5                    mov    $0x5,%r8
6:  (85) call pc+1                 callq  0x0000000000001ee8

नोंदणी करा r0 प्रोग्रामच्या अंमलबजावणीचा परिणाम आणि रजिस्टरमध्ये परत करण्यासाठी देखील वापरले जाते r1 प्रोग्रामला संदर्भासाठी एक पॉइंटर पास केला जातो - प्रोग्रामच्या प्रकारावर अवलंबून, हे असू शकते, उदाहरणार्थ, एक रचना struct xdp_md (XDP साठी) किंवा रचना struct __sk_buff (वेगवेगळ्या नेटवर्क प्रोग्रामसाठी) किंवा संरचना struct pt_regs (विविध प्रकारच्या ट्रेसिंग प्रोग्रामसाठी), इ.

तर, आमच्याकडे रजिस्टर्स, कर्नल हेल्पर, स्टॅक, कॉन्टेक्स्ट पॉइंटर आणि सामायिक मेमरी नकाशांच्या स्वरूपात होती. प्रवासात हे सर्व आवश्यक आहे असे नाही, पण...

चला वर्णन चालू ठेवू आणि या ऑब्जेक्ट्ससह कार्य करण्यासाठी कमांड सिस्टमबद्दल बोलूया. सर्व (जवळजवळ सर्वच) BPF सूचनांमध्ये निश्चित 64-बिट आकार असतो. तुम्ही 64-बिट बिग एंडियन मशीनवरील एक सूचना पाहिल्यास तुम्हाला दिसेल

तो आहे Code - हे निर्देशांचे एन्कोडिंग आहे, Dst/Src अनुक्रमे प्राप्तकर्ता आणि स्त्रोताचे एन्कोडिंग आहेत, Off - 16-बिट स्वाक्षरी केलेले इंडेंटेशन, आणि Imm काही सूचनांमध्ये (cBPF स्थिर K प्रमाणे) वापरलेला 32-बिट स्वाक्षरी केलेला पूर्णांक आहे. एन्कोडिंग Code दोन प्रकारांपैकी एक आहे:

सूचना वर्ग 0, 1, 2, 3 मेमरीसह कार्य करण्यासाठी कमांड परिभाषित करतात. ते म्हटले जाते, BPF_LD, BPF_LDX, BPF_ST, BPF_STX, अनुक्रमे. इयत्ता 4, 7 (BPF_ALU, BPF_ALU64) ALU सूचनांचा संच तयार करा. इयत्ता 5, 6 (BPF_JMP, BPF_JMP32) मध्ये जंप सूचना असतात.

BPF सूचना प्रणालीचा अभ्यास करण्यासाठी पुढील योजना खालीलप्रमाणे आहे: सर्व सूचना आणि त्यांचे पॅरामीटर्स काळजीपूर्वक सूचीबद्ध करण्याऐवजी, आम्ही या विभागात काही उदाहरणे पाहू आणि त्यांच्यावरून हे स्पष्ट होईल की सूचना प्रत्यक्षात कशा कार्य करतात आणि कशा प्रकारे कार्य करतात. BPF साठी कोणतीही बायनरी फाइल मॅन्युअली डिस्सेम्बल करा. लेखात नंतर सामग्री एकत्रित करण्यासाठी, आम्ही व्हेरिफायर, जेआयटी कंपायलर, क्लासिक बीपीएफचे भाषांतर, तसेच नकाशे, कॉलिंग फंक्शन्स इत्यादींचा अभ्यास करताना वैयक्तिक सूचनांसह देखील भेटू.

जेव्हा आम्ही वैयक्तिक सूचनांबद्दल बोलतो, तेव्हा आम्ही मुख्य फाइल्सचा संदर्भ घेऊ bpf.h и bpf_common.h, जे BPF निर्देशांचे संख्यात्मक कोड परिभाषित करतात. तुम्ही स्वतः आर्किटेक्चरचा अभ्यास करत असताना आणि/किंवा बायनरी पार्स करत असताना, तुम्हाला क्लिष्टतेच्या क्रमाने क्रमवारी लावलेल्या खालील स्रोतांमध्ये शब्दार्थ सापडतील: अनधिकृत eBPF तपशील, BPF आणि XDP संदर्भ मार्गदर्शक, सूचना संच, Documentation/networking/filter.txt आणि, अर्थातच, लिनक्स स्त्रोत कोडमध्ये - सत्यापनकर्ता, जेआयटी, बीपीएफ इंटरप्रिटर.

उदाहरण: तुमच्या डोक्यात बीपीएफ वेगळे करणे

चला एक उदाहरण पाहू ज्यामध्ये आपण प्रोग्राम संकलित करतो readelf-example.c आणि परिणामी बायनरी पहा. आम्ही मूळ सामग्री उघड करू readelf-example.c खाली, आम्ही बायनरी कोडमधून त्याचे तर्क पुनर्संचयित केल्यानंतर:

$ clang -target bpf -c readelf-example.c -o readelf-example.o -O2
$ llvm-readelf -x .text readelf-example.o
Hex dump of section '.text':
0x00000000 b7000000 01000000 15010100 00000000 ................
0x00000010 b7000000 02000000 95000000 00000000 ................

आउटपुटमधील पहिला स्तंभ readelf एक इंडेंटेशन आहे आणि आमच्या प्रोग्राममध्ये अशा प्रकारे चार कमांड आहेत:

Code Dst Src Off  Imm
b7   0   0   0000 01000000
15   0   1   0100 00000000
b7   0   0   0000 02000000
95   0   0   0000 00000000

कमांड कोड समान आहेत b7, 15, b7 и 95. लक्षात ठेवा की कमीत कमी महत्त्वपूर्ण तीन बिट्स निर्देश वर्ग आहेत. आमच्या बाबतीत, सर्व सूचनांचा चौथा भाग रिकामा आहे, त्यामुळे सूचना वर्ग अनुक्रमे 7, 5, 7, 5 आहेत. वर्ग 7 आहे BPF_ALU64, आणि 5 आहे BPF_JMP. दोन्ही वर्गांसाठी, सूचनांचे स्वरूप सारखेच आहे (वर पहा) आणि आम्ही आमचा प्रोग्राम याप्रमाणे पुन्हा लिहू शकतो (त्याचवेळी आम्ही उर्वरित स्तंभ मानवी स्वरूपात पुन्हा लिहू):

Op S  Class   Dst Src Off  Imm
b  0  ALU64   0   0   0    1
1  0  JMP     0   1   1    0
b  0  ALU64   0   0   0    2
9  0  JMP     0   0   0    0

ऑपरेशन b वर्ग ALU64 - हे आहे BPF_MOV. हे गंतव्य रजिस्टरला मूल्य नियुक्त करते. बिट सेट केले असल्यास s (स्रोत), नंतर मूल्य स्त्रोत रजिस्टरमधून घेतले जाते, आणि जर, आमच्या बाबतीत, ते सेट केलेले नसेल, तर मूल्य फील्डमधून घेतले जाते Imm. म्हणून पहिल्या आणि तिसऱ्या निर्देशांमध्ये आम्ही ऑपरेशन करतो r0 = Imm. पुढे, JMP वर्ग 1 ऑपरेशन आहे BPF_JEQ (समान असल्यास उडी मारणे). आमच्या बाबतीत, बिट पासून S शून्य आहे, ते स्त्रोत रजिस्टरच्या मूल्याची फील्डशी तुलना करते Imm. जर मूल्ये जुळत असतील तर संक्रमण होते PC + Offकुठे PC, नेहमीप्रमाणे, पुढील सूचनांचा पत्ता समाविष्टीत आहे. शेवटी, JMP वर्ग 9 ऑपरेशन आहे BPF_EXIT. ही सूचना कर्नलवर परत येऊन प्रोग्राम बंद करते r0. चला आमच्या टेबलमध्ये एक नवीन स्तंभ जोडूया:

Op    S  Class   Dst Src Off  Imm    Disassm
MOV   0  ALU64   0   0   0    1      r0 = 1
JEQ   0  JMP     0   1   1    0      if (r1 == 0) goto pc+1
MOV   0  ALU64   0   0   0    2      r0 = 2
EXIT  0  JMP     0   0   0    0      exit

आम्ही हे अधिक सोयीस्कर स्वरूपात पुन्हा लिहू शकतो:

     r0 = 1
     if (r1 == 0) goto END
     r0 = 2
END:
     exit

नोंदवहीत काय आहे ते आठवले तर r1 प्रोग्रॅमला कर्नल आणि रजिस्टरमधून संदर्भाकडे एक पॉइंटर पास केला जातो r0 एक मूल्य कर्नलला परत केले जाते, नंतर आपण पाहू शकतो की जर संदर्भाचा पॉइंटर शून्य असेल तर आपण 1 परत करतो आणि अन्यथा - 2. स्त्रोत बघून आपण बरोबर आहोत हे तपासू:

$ cat readelf-example.c
int foo(void *ctx)
{
        return ctx ? 2 : 1;
}

होय, हा एक अर्थहीन प्रोग्राम आहे, परंतु तो फक्त चार सोप्या सूचनांमध्ये अनुवादित करतो.

अपवाद उदाहरण: 16-बाइट सूचना

आम्ही आधी उल्लेख केला आहे की काही सूचना 64 बिट्स पेक्षा जास्त घेतात. हे लागू होते, उदाहरणार्थ, निर्देशांवर lddw (कोड = 0x18 = BPF_LD | BPF_DW | BPF_IMM) — फील्डमधून दुहेरी शब्द रजिस्टरमध्ये लोड करा Imm... वस्तुस्थिती अशी आहे Imm 32 चा आकार आहे, आणि दुहेरी शब्द 64 बिट्स आहे, म्हणून एका 64-बिट निर्देशामध्ये 64-बिट तात्काळ मूल्य एका रजिस्टरमध्ये लोड करणे कार्य करणार नाही. हे करण्यासाठी, फील्डमध्ये 64-बिट मूल्याचा दुसरा भाग संचयित करण्यासाठी दोन समीप सूचना वापरल्या जातात Imm. उदाहरणः

$ cat x64.c
long foo(void *ctx)
{
        return 0x11223344aabbccdd;
}
$ clang -target bpf -c x64.c -o x64.o -O2
$ llvm-readelf -x .text x64.o
Hex dump of section '.text':
0x00000000 18000000 ddccbbaa 00000000 44332211 ............D3".
0x00000010 95000000 00000000                   ........

बायनरी प्रोग्राममध्ये फक्त दोन सूचना आहेत:

Binary                                 Disassm
18000000 ddccbbaa 00000000 44332211    r0 = Imm[0]|Imm[1]
95000000 00000000                      exit

आम्ही सूचनांसह पुन्हा भेटू lddw, जेव्हा आपण स्थान बदलण्याबद्दल आणि नकाशांसह कार्य करण्याबद्दल बोलतो.

उदाहरण: मानक साधनांचा वापर करून BPF वेगळे करणे

म्हणून, आम्ही BPF बायनरी कोड वाचण्यास शिकलो आहोत आणि आवश्यक असल्यास कोणत्याही सूचनांचे विश्लेषण करण्यास तयार आहोत. तथापि, हे सांगण्यासारखे आहे की सराव मध्ये मानक साधनांचा वापर करून प्रोग्राम वेगळे करणे अधिक सोयीस्कर आणि वेगवान आहे, उदाहरणार्थ:

$ llvm-objdump -d x64.o

Disassembly of section .text:

0000000000000000 <foo>:
 0: 18 00 00 00 dd cc bb aa 00 00 00 00 44 33 22 11 r0 = 1234605617868164317 ll
 2: 95 00 00 00 00 00 00 00 exit

बीपीएफ वस्तूंचे जीवनचक्र, बीपीएफएस फाइल सिस्टम

(या उपविभागात वर्णन केलेले काही तपशील मी प्रथम कडून शिकले उपवास अॅलेक्सी स्टारोवोइटोव्ह मध्ये BPF ब्लॉग.)

BPF ऑब्जेक्ट्स - प्रोग्राम आणि नकाशे - कमांड वापरून वापरकर्त्याच्या जागेवरून तयार केले जातात BPF_PROG_LOAD и BPF_MAP_CREATE सिस्टम कॉल bpf(2)हे नेमके कसे होते याबद्दल आपण पुढील भागात चर्चा करू. हे कर्नल डेटा स्ट्रक्चर्स आणि प्रत्येकासाठी तयार करते refcount (संदर्भ संख्या) एक वर सेट केले आहे, आणि ऑब्जेक्टकडे निर्देश करणारा फाइल वर्णनकर्ता वापरकर्त्याला परत केला जातो. हँडल बंद केल्यानंतर refcount वस्तू एकाने कमी होते आणि जेव्हा ती शून्यावर पोहोचते तेव्हा ती वस्तू नष्ट होते.

जर प्रोग्राम नकाशे वापरत असेल तर refcount प्रोग्राम लोड केल्यानंतर हे नकाशे एकाने वाढवले जातात, म्हणजे. त्यांचे फाइल वर्णनकर्ता वापरकर्ता प्रक्रियेतून बंद केले जाऊ शकतात आणि तरीही refcount शून्य होणार नाही:

प्रोग्राम यशस्वीरित्या लोड केल्यानंतर, आम्ही सामान्यतः तो काही प्रकारच्या इव्हेंट जनरेटरशी संलग्न करतो. उदाहरणार्थ, येणार्‍या पॅकेट्सवर प्रक्रिया करण्यासाठी किंवा काहीशी कनेक्ट करण्यासाठी आम्ही ते नेटवर्क इंटरफेसवर ठेवू शकतो tracepoint कोर मध्ये. या टप्प्यावर, संदर्भ काउंटर देखील एक ने वाढेल आणि आम्ही लोडर प्रोग्राममध्ये फाइल वर्णनकर्ता बंद करण्यास सक्षम होऊ.

आपण आता बूटलोडर बंद केल्यास काय होईल? हे इव्हेंट जनरेटर (हुक) च्या प्रकारावर अवलंबून असते. लोडर पूर्ण झाल्यानंतर सर्व नेटवर्क हुक अस्तित्वात असतील, हे तथाकथित ग्लोबल हुक आहेत. आणि, उदाहरणार्थ, ट्रेस प्रोग्राम्स तयार केलेल्या प्रक्रियेच्या समाप्तीनंतर सोडले जातील (आणि म्हणून त्यांना स्थानिक म्हणतात, "स्थानिक ते प्रक्रिया"). तांत्रिकदृष्ट्या, स्थानिक हुकमध्ये नेहमी वापरकर्त्याच्या जागेत संबंधित फाइल वर्णनकर्ता असतो आणि म्हणून जेव्हा प्रक्रिया बंद होते तेव्हा बंद होते, परंतु जागतिक हुक तसे करत नाहीत. खालील आकृतीमध्ये, रेड क्रॉस वापरून, मी हे दाखवण्याचा प्रयत्न करतो की लोडर प्रोग्रामच्या समाप्तीमुळे स्थानिक आणि जागतिक हुकच्या बाबतीत वस्तूंच्या आयुष्यावर कसा परिणाम होतो.

स्थानिक आणि जागतिक हुकमध्ये फरक का आहे? काही प्रकारचे नेटवर्क प्रोग्राम चालवणे वापरकर्त्याच्या जागेशिवाय अर्थपूर्ण आहे, उदाहरणार्थ, DDoS संरक्षणाची कल्पना करा - बूटलोडर नियम लिहितो आणि BPF प्रोग्रामला नेटवर्क इंटरफेसशी जोडतो, त्यानंतर बूटलोडर स्वतःला जाऊन मारून टाकू शकतो. दुसरीकडे, तुम्ही दहा मिनिटांत तुमच्या गुडघ्यांवर लिहिलेल्या डीबगिंग ट्रेस प्रोग्रामची कल्पना करा - जेव्हा ते पूर्ण होईल, तेव्हा तुम्हाला सिस्टममध्ये कचरा शिल्लक राहू नये असे वाटते आणि स्थानिक हुक हे सुनिश्चित करतील.

दुसरीकडे, कल्पना करा की तुम्हाला कर्नलमधील ट्रेसपॉईंटशी कनेक्ट करायचे आहे आणि अनेक वर्षांची आकडेवारी गोळा करायची आहे. या प्रकरणात, तुम्हाला वापरकर्ता भाग पूर्ण करायचा आहे आणि वेळोवेळी आकडेवारीकडे परत यायचे आहे. bpf फाइल सिस्टम ही संधी प्रदान करते. ही एक इन-मेमरी-ओन्ली स्यूडो-फाइल सिस्टम आहे जी BPF ऑब्जेक्ट्सचा संदर्भ देणाऱ्या फाइल्स तयार करण्यास परवानगी देते आणि त्यामुळे वाढ होते. refcount वस्तू. यानंतर, लोडर बाहेर पडू शकतो आणि त्याने तयार केलेल्या वस्तू जिवंत राहतील.

BPF ऑब्जेक्ट्सचा संदर्भ देणार्‍या bpffs मध्ये फाइल्स तयार करणे याला "पिनिंग" म्हणतात (पुढील वाक्यांशाप्रमाणे: "प्रक्रिया BPF प्रोग्राम किंवा नकाशा पिन करू शकते"). BPF ऑब्जेक्ट्ससाठी फाइल ऑब्जेक्ट्स तयार करणे केवळ स्थानिक वस्तूंचे आयुष्य वाढवण्यासाठीच नव्हे तर जागतिक वस्तूंच्या वापरासाठी देखील अर्थपूर्ण आहे - जागतिक DDoS संरक्षण कार्यक्रमाच्या उदाहरणाकडे परत जाताना, आम्हाला आकडेवारी पाहण्यास सक्षम व्हायचे आहे. वेळोवेळी.

BPF फाईल सिस्टीम सहसा मध्ये आरोहित केली जाते /sys/fs/bpf, परंतु ते स्थानिक पातळीवर देखील माउंट केले जाऊ शकते, उदाहरणार्थ, यासारखे:

$ mkdir bpf-mountpoint
$ sudo mount -t bpf none bpf-mountpoint

कमांड वापरून फाइल सिस्टमची नावे तयार केली जातात BPF_OBJ_PIN बीपीएफ सिस्टम कॉल. स्पष्ट करण्यासाठी, चला एक प्रोग्राम घेऊ, तो संकलित करू, तो अपलोड करू आणि त्यास पिन करू bpffs. आमचा प्रोग्राम काहीही उपयुक्त करत नाही, आम्ही फक्त कोड सादर करत आहोत जेणेकरून तुम्ही उदाहरण पुन्हा तयार करू शकता:

$ cat test.c
__attribute__((section("xdp"), used))
int test(void *ctx)
{
        return 0;
}

char _license[] __attribute__((section("license"), used)) = "GPL";

चला हा प्रोग्राम संकलित करू आणि फाइल सिस्टमची स्थानिक प्रत तयार करू bpffs:

$ clang -target bpf -c test.c -o test.o
$ mkdir bpf-mountpoint
$ sudo mount -t bpf none bpf-mountpoint

आता युटिलिटी वापरून आपला प्रोग्राम डाउनलोड करूया bpftool आणि सोबतचे सिस्टम कॉल पहा bpf(2) (स्ट्रेस आउटपुटमधून काही असंबद्ध रेषा काढून टाकल्या आहेत):

$ sudo strace -e bpf bpftool prog load ./test.o bpf-mountpoint/test
bpf(BPF_PROG_LOAD, {prog_type=BPF_PROG_TYPE_XDP, prog_name="test", ...}, 120) = 3
bpf(BPF_OBJ_PIN, {pathname="bpf-mountpoint/test", bpf_fd=3}, 120) = 0

येथे आपण वापरून प्रोग्राम लोड केला आहे BPF_PROG_LOAD, कर्नलकडून फाइल वर्णनकर्ता प्राप्त झाला 3 आणि कमांड वापरुन BPF_OBJ_PIN हा फाइल वर्णनकर्ता फाइल म्हणून पिन केला "bpf-mountpoint/test". यानंतर बूटलोडर प्रोग्राम bpftool काम पूर्ण केले, परंतु आमचा प्रोग्राम कर्नलमध्ये राहिला, जरी आम्ही तो कोणत्याही नेटवर्क इंटरफेसशी संलग्न केला नाही:

$ sudo bpftool prog | tail -3
783: xdp  name test  tag 5c8ba0cf164cb46c  gpl
        loaded_at 2020-05-05T13:27:08+0000  uid 0
        xlated 24B  jited 41B  memlock 4096B

आपण फाईल ऑब्जेक्ट सामान्यपणे हटवू शकतो unlink(2) आणि त्यानंतर संबंधित प्रोग्राम हटविला जाईल:

$ sudo rm ./bpf-mountpoint/test
$ sudo bpftool prog show id 783
Error: get by id (783): No such file or directory

वस्तू हटवत आहे

ऑब्जेक्ट्स हटविण्याबद्दल बोलताना, हे स्पष्ट करणे आवश्यक आहे की आम्ही हुक (इव्हेंट जनरेटर) वरून प्रोग्राम डिस्कनेक्ट केल्यावर, एकही नवीन इव्हेंट लॉन्च होणार नाही, तथापि, प्रोग्रामच्या सर्व वर्तमान घटना सामान्य क्रमाने पूर्ण केल्या जातील. .

काही प्रकारचे बीपीएफ प्रोग्राम आपल्याला फ्लायवर प्रोग्राम बदलण्याची परवानगी देतात, म्हणजे. अनुक्रम आण्विकता प्रदान करा replace = detach old program, attach new program. या प्रकरणात, प्रोग्रामच्या जुन्या आवृत्तीची सर्व सक्रिय उदाहरणे त्यांचे कार्य पूर्ण करतील आणि नवीन प्रोग्राममधून नवीन इव्हेंट हँडलर तयार केले जातील आणि येथे "अणुत्व" म्हणजे एकही कार्यक्रम चुकणार नाही.

कार्यक्रमांना इव्हेंट स्त्रोतांशी संलग्न करणे

या लेखात, आम्ही कार्यक्रमाच्या स्त्रोतांशी कनेक्टिंग प्रोग्रामचे स्वतंत्रपणे वर्णन करणार नाही, कारण विशिष्ट प्रकारच्या प्रोग्रामच्या संदर्भात याचा अभ्यास करणे अर्थपूर्ण आहे. सेमी. उदाहरण खाली, ज्यामध्ये XDP सारखे प्रोग्राम कसे जोडलेले आहेत ते आम्ही दाखवतो.

बीपीएफ सिस्टम कॉल वापरून ऑब्जेक्ट्स हाताळणे

बीपीएफ कार्यक्रम

सर्व BPF ऑब्जेक्ट्स सिस्टम कॉल वापरून वापरकर्त्याच्या जागेवरून तयार आणि व्यवस्थापित केल्या जातात bpf, खालील प्रोटोटाइप असलेले:

#include <linux/bpf.h>

int bpf(int cmd, union bpf_attr *attr, unsigned int size);

येथे संघ आहे cmd प्रकारातील मूल्यांपैकी एक आहे enum bpf_cmd, attr — विशिष्ट प्रोग्रामसाठी पॅरामीटर्ससाठी एक पॉइंटर आणि size - पॉइंटरनुसार ऑब्जेक्टचा आकार, म्हणजे सहसा हे sizeof(*attr). कर्नल 5.8 मध्ये सिस्टम कॉल bpf 34 भिन्न आदेशांना समर्थन देते, आणि व्याख्या union bpf_attr 200 ओळी व्यापतात. परंतु आपण यापासून घाबरू नये, कारण आपण अनेक लेखांदरम्यान आज्ञा आणि मापदंडांशी परिचित होऊ.

चला संघापासून सुरुवात करूया BPF_PROG_LOAD, जे BPF प्रोग्राम तयार करते - BPF सूचनांचा संच घेते आणि कर्नलमध्ये लोड करते. लोडिंगच्या क्षणी, सत्यापनकर्ता लॉन्च केला जातो, आणि नंतर JIT कंपाइलर आणि, यशस्वी अंमलबजावणीनंतर, प्रोग्राम फाइल वर्णनकर्ता वापरकर्त्यास परत केला जातो. त्याचे पुढे काय होते ते आपण मागील भागात पाहिले बीपीएफ वस्तूंच्या जीवन चक्राविषयी.

आम्ही आता एक सानुकूल प्रोग्राम लिहू जो एक साधा BPF प्रोग्राम लोड करेल, परंतु प्रथम आम्हाला कोणत्या प्रकारचा प्रोग्राम लोड करायचा आहे हे ठरवावे लागेल - आम्हाला निवडावे लागेल एक प्रकार आणि या प्रकारच्या फ्रेमवर्कमध्ये, एक प्रोग्राम लिहा जो पडताळणी चाचणी उत्तीर्ण करेल. तथापि, प्रक्रियेस गुंतागुंत न करण्यासाठी, येथे एक तयार उपाय आहे: आम्ही एक प्रोग्राम घेऊ BPF_PROG_TYPE_XDP, जे मूल्य परत करेल XDP_PASS (सर्व पॅकेजेस वगळा). बीपीएफ असेंबलरमध्ये हे अगदी सोपे दिसते:

r0 = 2
exit

आम्ही ठरविल्यानंतर की आम्ही अपलोड करू, आम्ही ते कसे करू ते आम्ही तुम्हाला सांगू शकतो:

#define _GNU_SOURCE
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/bpf.h>

static inline __u64 ptr_to_u64(const void *ptr)
{
        return (__u64) (unsigned long) ptr;
}

int main(void)
{
    struct bpf_insn insns[] = {
        {
            .code = BPF_ALU64 | BPF_MOV | BPF_K,
            .dst_reg = BPF_REG_0,
            .imm = XDP_PASS
        },
        {
            .code = BPF_JMP | BPF_EXIT
        },
    };

    union bpf_attr attr = {
        .prog_type = BPF_PROG_TYPE_XDP,
        .insns     = ptr_to_u64(insns),
        .insn_cnt  = sizeof(insns)/sizeof(insns[0]),
        .license   = ptr_to_u64("GPL"),
    };

    strncpy(attr.prog_name, "woo", sizeof(attr.prog_name));
    syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));

    for ( ;; )
        pause();
}

प्रोग्राममधील मनोरंजक घटना अॅरेच्या व्याख्येने सुरू होतात insns - मशीन कोडमध्ये आमचा बीपीएफ प्रोग्राम. या प्रकरणात, BPF प्रोग्रामची प्रत्येक सूचना संरचनेत पॅक केली जाते bpf_insn. पहिला घटक insns सूचनांचे पालन करते r0 = 2, दुसरा - exit.

माघार. कर्नल मशीन कोड लिहिण्यासाठी आणि कर्नल हेडर फाइल वापरण्यासाठी अधिक सोयीस्कर मॅक्रो परिभाषित करते tools/include/linux/filter.h आम्ही लिहू शकतो

struct bpf_insn insns[] = {
    BPF_MOV64_IMM(BPF_REG_0, XDP_PASS),
    BPF_EXIT_INSN()
};

परंतु मूळ कोडमध्ये BPF प्रोग्राम लिहिणे केवळ कर्नलमधील चाचण्या आणि BPF बद्दलचे लेख लिहिण्यासाठी आवश्यक असल्याने, या मॅक्रोच्या अनुपस्थितीमुळे विकसकाचे जीवन खरोखरच गुंतागुंतीचे होत नाही.

BPF प्रोग्राम परिभाषित केल्यानंतर, आम्ही ते कर्नलमध्ये लोड करण्यासाठी पुढे जाऊ. आमचा पॅरामीटर्सचा किमान संच attr प्रोग्राम प्रकार, संच आणि सूचनांची संख्या, आवश्यक परवाना आणि नाव समाविष्ट आहे "woo", ज्याचा वापर आम्ही डाउनलोड केल्यानंतर सिस्टमवर आमचा प्रोग्राम शोधण्यासाठी करतो. प्रोग्राम, वचन दिल्याप्रमाणे, सिस्टम कॉल वापरून सिस्टममध्ये लोड केला जातो bpf.

प्रोग्रामच्या शेवटी आपण अनंत लूपमध्ये पोहोचतो जे पेलोडचे अनुकरण करते. त्याशिवाय, जेव्हा सिस्टम कॉल आमच्याकडे परत आलेला फाइल वर्णनकर्ता बंद असेल तेव्हा प्रोग्राम कर्नलद्वारे मारला जाईल. bpf, आणि आम्ही ते सिस्टममध्ये पाहणार नाही.

बरं, आम्ही चाचणीसाठी तयार आहोत. च्या अंतर्गत कार्यक्रम एकत्र करून चालवू straceसर्वकाही जसे पाहिजे तसे कार्य करत आहे हे तपासण्यासाठी:

$ clang -g -O2 simple-prog.c -o simple-prog

$ sudo strace ./simple-prog
execve("./simple-prog", ["./simple-prog"], 0x7ffc7b553480 /* 13 vars */) = 0
...
bpf(BPF_PROG_LOAD, {prog_type=BPF_PROG_TYPE_XDP, insn_cnt=2, insns=0x7ffe03c4ed50, license="GPL", log_level=0, log_size=0, log_buf=NULL, kern_version=KERNEL_V
ERSION(0, 0, 0), prog_flags=0, prog_name="woo", prog_ifindex=0, expected_attach_type=BPF_CGROUP_INET_INGRESS}, 72) = 3
pause(

सर्व काही ठीक आहे, bpf(2) हँडल 3 आम्हाला परत केले आणि आम्ही एका अनंत लूपमध्ये गेलो pause(). चला सिस्टममध्ये आपला प्रोग्राम शोधण्याचा प्रयत्न करूया. हे करण्यासाठी आपण दुसऱ्या टर्मिनलवर जाऊ आणि युटिलिटी वापरू bpftool:

# bpftool prog | grep -A3 woo
390: xdp  name woo  tag 3b185187f1855c4c  gpl
        loaded_at 2020-08-31T24:66:44+0000  uid 0
        xlated 16B  jited 40B  memlock 4096B
        pids simple-prog(10381)

आम्ही पाहतो की सिस्टमवर एक लोड केलेला प्रोग्राम आहे woo ज्याचा ग्लोबल आयडी 390 आहे आणि सध्या प्रगतीपथावर आहे simple-prog प्रोग्रामकडे निर्देश करणारा एक खुला फाइल वर्णनकर्ता आहे (आणि जर simple-prog नंतर काम पूर्ण करेल woo अदृश्य होईल). अपेक्षेप्रमाणे कार्यक्रम woo BPF आर्किटेक्चरमधील बायनरी कोडचे - दोन सूचना - 16 बाइट्स घेते, परंतु त्याच्या मूळ स्वरूपात (x86_64) ते आधीच 40 बाइट्स आहे. चला आमचा प्रोग्राम त्याच्या मूळ स्वरूपात पाहू:

# bpftool prog dump xlated id 390
   0: (b7) r0 = 2
   1: (95) exit

आश्चर्य नाही. आता जेआयटी कंपाइलरने व्युत्पन्न केलेला कोड पाहू:

# bpftool prog dump jited id 390
bpf_prog_3b185187f1855c4c_woo:
   0:   nopl   0x0(%rax,%rax,1)
   5:   push   %rbp
   6:   mov    %rsp,%rbp
   9:   sub    $0x0,%rsp
  10:   push   %rbx
  11:   push   %r13
  13:   push   %r14
  15:   push   %r15
  17:   pushq  $0x0
  19:   mov    $0x2,%eax
  1e:   pop    %rbx
  1f:   pop    %r15
  21:   pop    %r14
  23:   pop    %r13
  25:   pop    %rbx
  26:   leaveq
  27:   retq

साठी फार प्रभावी नाही exit(2), परंतु निष्पक्षतेने, आमचा कार्यक्रम खूप सोपा आहे आणि क्षुल्लक नसलेल्या कार्यक्रमांसाठी JIT कंपाइलरने जोडलेले प्रस्तावना आणि उपसंहार अर्थातच आवश्यक आहेत.

नकाशे

BPF प्रोग्राम संरचित मेमरी क्षेत्रे वापरू शकतात जे इतर BPF प्रोग्राम्स आणि वापरकर्ता स्पेसमधील प्रोग्राम्ससाठी दोन्ही प्रवेशयोग्य आहेत. या वस्तूंना नकाशे म्हणतात आणि या विभागात आम्ही सिस्टीम कॉल वापरून त्यांची हाताळणी कशी करायची ते दाखवू bpf.

चला लगेच म्हणूया की नकाशांची क्षमता केवळ सामायिक मेमरीमध्ये प्रवेश करण्यापुरती मर्यादित नाही. तेथे विशेष हेतू असलेले नकाशे आहेत, उदाहरणार्थ, बीपीएफ प्रोग्रामचे पॉइंटर किंवा नेटवर्क इंटरफेसचे पॉइंटर, परफ इव्हेंटसह कार्य करण्यासाठी नकाशे इ. वाचकांचा गोंधळ होऊ नये म्हणून आम्ही त्यांच्याबद्दल येथे बोलणार नाही. याशिवाय, आम्ही सिंक्रोनाइझेशन समस्यांकडे दुर्लक्ष करतो, कारण हे आमच्या उदाहरणांसाठी महत्त्वाचे नाही. उपलब्ध नकाशा प्रकारांची संपूर्ण यादी यामध्ये आढळू शकते <linux/bpf.h>, आणि या विभागात आपण ऐतिहासिकदृष्ट्या पहिला प्रकार, हॅश टेबलचे उदाहरण घेऊ BPF_MAP_TYPE_HASH.

तुम्ही C++ मध्ये हॅश टेबल तयार केल्यास, तुम्ही म्हणाल unordered_map<int,long> woo, ज्याचा रशियन भाषेत अर्थ आहे “मला एक टेबल पाहिजे आहे woo अमर्यादित आकार, ज्याच्या कळा प्रकार आहेत int, आणि मूल्ये प्रकार आहेत long" BPF हॅश सारणी तयार करण्यासाठी, आपल्याला सारणीचा कमाल आकार निर्दिष्ट करावा लागेल आणि की आणि मूल्यांचे प्रकार निर्दिष्ट करण्याऐवजी, आपल्याला त्यांचे आकार बाइट्समध्ये निर्दिष्ट करावे लागतील. . नकाशे तयार करण्यासाठी कमांड वापरा BPF_MAP_CREATE सिस्टम कॉल bpf. चला एक कमी किंवा कमी प्रोग्राम पाहू जो नकाशा तयार करतो. बीपीएफ प्रोग्राम लोड करणार्‍या मागील प्रोग्रामनंतर, हे तुम्हाला सोपे वाटले पाहिजे:

$ cat simple-map.c
#define _GNU_SOURCE
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/bpf.h>

int main(void)
{
    union bpf_attr attr = {
        .map_type = BPF_MAP_TYPE_HASH,
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .max_entries = 4,
    };
    strncpy(attr.map_name, "woo", sizeof(attr.map_name));
    syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));

    for ( ;; )
        pause();
}

येथे आपण पॅरामीटर्सचा संच परिभाषित करतो attr, ज्यामध्ये आपण म्हणतो “मला की आणि आकार मूल्यांसह हॅश टेबलची आवश्यकता आहे sizeof(int), ज्यामध्ये मी जास्तीत जास्त चार घटक ठेवू शकतो." बीपीएफ नकाशे तयार करताना, तुम्ही इतर पॅरामीटर्स निर्दिष्ट करू शकता, उदाहरणार्थ, प्रोग्रामच्या उदाहरणाप्रमाणे, आम्ही ऑब्जेक्टचे नाव म्हणून निर्दिष्ट केले आहे "woo".

चला प्रोग्राम संकलित करू आणि चालवू:

$ clang -g -O2 simple-map.c -o simple-map
$ sudo strace ./simple-map
execve("./simple-map", ["./simple-map"], 0x7ffd40a27070 /* 14 vars */) = 0
...
bpf(BPF_MAP_CREATE, {map_type=BPF_MAP_TYPE_HASH, key_size=4, value_size=4, max_entries=4, map_name="woo", ...}, 72) = 3
pause(

हा आहे सिस्टम कॉल bpf(2) आम्हाला वर्णनकर्ता नकाशा क्रमांक परत केला 3 आणि नंतर प्रोग्राम, अपेक्षेप्रमाणे, सिस्टम कॉलमधील पुढील सूचनांची प्रतीक्षा करतो pause(2).

आता आपला प्रोग्राम बॅकग्राउंडवर पाठवू किंवा दुसरे टर्मिनल उघडू आणि युटिलिटी वापरून आपला ऑब्जेक्ट पाहू bpftool (आम्ही आमचा नकाशा त्याच्या नावावरून इतरांपेक्षा वेगळे करू शकतो):

$ sudo bpftool map
...
114: hash  name woo  flags 0x0
        key 4B  value 4B  max_entries 4  memlock 4096B
...

संख्या 114 हा आमच्या ऑब्जेक्टचा ग्लोबल आयडी आहे. कमांड वापरून विद्यमान नकाशा उघडण्यासाठी सिस्टमवरील कोणताही प्रोग्राम हा आयडी वापरू शकतो BPF_MAP_GET_FD_BY_ID सिस्टम कॉल bpf.

आता आपण आपल्या हॅश टेबलसह खेळू शकतो. चला त्यातील सामग्री पाहू:

$ sudo bpftool map dump id 114
Found 0 elements

रिकामे. चला त्यात एक मूल्य ठेवूया hash[1] = 1:

$ sudo bpftool map update id 114 key 1 0 0 0 value 1 0 0 0

चला पुन्हा टेबल पाहू:

$ sudo bpftool map dump id 114
key: 01 00 00 00  value: 01 00 00 00
Found 1 element

हुर्रे! आम्ही एक घटक जोडण्यात व्यवस्थापित केले. लक्षात घ्या की हे करण्यासाठी आम्हाला बाइट स्तरावर काम करावे लागेल, पासून bptftool हॅश टेबलमधील मूल्ये कोणत्या प्रकारची आहेत हे माहित नाही. (हे ज्ञान तिला बीटीएफ वापरून हस्तांतरित केले जाऊ शकते, परंतु आता त्याबद्दल अधिक.)

bpftool नक्की कसे वाचते आणि घटक जोडते? चला हुड अंतर्गत एक नजर टाकूया:

$ sudo strace -e bpf bpftool map dump id 114
bpf(BPF_MAP_GET_FD_BY_ID, {map_id=114, next_id=0, open_flags=0}, 120) = 3
bpf(BPF_MAP_GET_NEXT_KEY, {map_fd=3, key=NULL, next_key=0x55856ab65280}, 120) = 0
bpf(BPF_MAP_LOOKUP_ELEM, {map_fd=3, key=0x55856ab65280, value=0x55856ab652a0}, 120) = 0
key: 01 00 00 00  value: 01 00 00 00
bpf(BPF_MAP_GET_NEXT_KEY, {map_fd=3, key=0x55856ab65280, next_key=0x55856ab65280}, 120) = -1 ENOENT

प्रथम आम्ही कमांड वापरून नकाशा त्याच्या ग्लोबल आयडीने उघडला BPF_MAP_GET_FD_BY_ID и bpf(2) आम्हाला वर्णनकर्ता 3 परत केले. पुढे कमांड वापरून BPF_MAP_GET_NEXT_KEY पास करून आम्हाला टेबलमधील पहिली की सापडली NULL "मागील" की ला पॉइंटर म्हणून. आमच्याकडे चावी असेल तर आम्ही करू शकतो BPF_MAP_LOOKUP_ELEMजे पॉइंटरला मूल्य परत करते value. पुढची पायरी म्हणजे सध्याच्या कीला पॉइंटर देऊन पुढील घटक शोधण्याचा प्रयत्न करतो, परंतु आमच्या टेबलमध्ये फक्त एक घटक आणि कमांड असते. BPF_MAP_GET_NEXT_KEY परतावा ENOENT.

ठीक आहे, की 1 ने मूल्य बदलूया, असे म्हणूया की आमच्या व्यवसायाच्या तर्कासाठी नोंदणी आवश्यक आहे hash[1] = 2:

$ sudo strace -e bpf bpftool map update id 114 key 1 0 0 0 value 2 0 0 0
bpf(BPF_MAP_GET_FD_BY_ID, {map_id=114, next_id=0, open_flags=0}, 120) = 3
bpf(BPF_MAP_UPDATE_ELEM, {map_fd=3, key=0x55dcd72be260, value=0x55dcd72be280, flags=BPF_ANY}, 120) = 0

अपेक्षेप्रमाणे, हे अगदी सोपे आहे: आदेश BPF_MAP_GET_FD_BY_ID आयडी आणि कमांडद्वारे आमचा नकाशा उघडतो BPF_MAP_UPDATE_ELEM घटक अधिलिखित करते.

तर, एका प्रोग्राममधून हॅश टेबल तयार केल्यानंतर, आपण दुसर्‍या प्रोग्राममधून त्यातील मजकूर वाचू आणि लिहू शकतो. लक्षात ठेवा की जर आम्ही कमांड लाइनवरून हे करू शकलो, तर सिस्टमवरील इतर कोणताही प्रोग्राम ते करू शकतो. वर वर्णन केलेल्या आदेशांव्यतिरिक्त, वापरकर्त्याच्या जागेवरून नकाशांसह कार्य करण्यासाठी, खालील:

BPF_MAP_LOOKUP_ELEM: की द्वारे मूल्य शोधा
BPF_MAP_UPDATE_ELEM: मूल्य अद्यतनित / तयार करा
BPF_MAP_DELETE_ELEM: की काढा
BPF_MAP_GET_NEXT_KEY: पुढील (किंवा पहिली) की शोधा
BPF_MAP_GET_NEXT_ID: तुम्हाला सर्व विद्यमान नकाशांमधून जाण्याची परवानगी देते, ते कसे कार्य करते bpftool map
BPF_MAP_GET_FD_BY_ID: विद्यमान नकाशा त्याच्या जागतिक आयडीद्वारे उघडा
BPF_MAP_LOOKUP_AND_DELETE_ELEM: एखाद्या वस्तूचे मूल्य अणुअद्ययावत करा आणि जुने परत करा
BPF_MAP_FREEZE: वापरकर्ता स्थानावरून नकाशा अपरिवर्तनीय बनवा (हे ऑपरेशन पूर्ववत केले जाऊ शकत नाही)
BPF_MAP_LOOKUP_BATCH, BPF_MAP_LOOKUP_AND_DELETE_BATCH, BPF_MAP_UPDATE_BATCH, BPF_MAP_DELETE_BATCH: मोठ्या प्रमाणावर ऑपरेशन्स. उदाहरणार्थ, BPF_MAP_LOOKUP_AND_DELETE_BATCH - नकाशावरील सर्व मूल्ये वाचण्याचा आणि रीसेट करण्याचा हा एकमेव विश्वासार्ह मार्ग आहे

या सर्व आज्ञा सर्व नकाशा प्रकारांसाठी कार्य करत नाहीत, परंतु सर्वसाधारणपणे वापरकर्त्याच्या जागेवरून इतर प्रकारच्या नकाशांसह कार्य करणे हॅश टेबलसह कार्य करण्यासारखेच दिसते.

ऑर्डरच्या फायद्यासाठी, आमचे हॅश टेबल प्रयोग पूर्ण करूया. लक्षात ठेवा की आम्ही एक टेबल तयार केला आहे ज्यामध्ये चार की असू शकतात? चला आणखी काही घटक जोडूया:

$ sudo bpftool map update id 114 key 2 0 0 0 value 1 0 0 0
$ sudo bpftool map update id 114 key 3 0 0 0 value 1 0 0 0
$ sudo bpftool map update id 114 key 4 0 0 0 value 1 0 0 0

अजून तरी छान आहे:

$ sudo bpftool map dump id 114
key: 01 00 00 00  value: 01 00 00 00
key: 02 00 00 00  value: 01 00 00 00
key: 04 00 00 00  value: 01 00 00 00
key: 03 00 00 00  value: 01 00 00 00
Found 4 elements

चला आणखी एक जोडण्याचा प्रयत्न करूया:

$ sudo bpftool map update id 114 key 5 0 0 0 value 1 0 0 0
Error: update failed: Argument list too long

अपेक्षेप्रमाणे आम्ही यशस्वी झालो नाही. चला अधिक तपशीलाने त्रुटी पाहू:

$ sudo strace -e bpf bpftool map update id 114 key 5 0 0 0 value 1 0 0 0
bpf(BPF_MAP_GET_FD_BY_ID, {map_id=114, next_id=0, open_flags=0}, 120) = 3
bpf(BPF_OBJ_GET_INFO_BY_FD, {info={bpf_fd=3, info_len=80, info=0x7ffe6c626da0}}, 120) = 0
bpf(BPF_MAP_UPDATE_ELEM, {map_fd=3, key=0x56049ded5260, value=0x56049ded5280, flags=BPF_ANY}, 120) = -1 E2BIG (Argument list too long)
Error: update failed: Argument list too long
+++ exited with 255 +++

सर्व काही ठीक आहे: अपेक्षेप्रमाणे, संघ BPF_MAP_UPDATE_ELEM नवीन, पाचवी, की तयार करण्याचा प्रयत्न करते, परंतु क्रॅश होते E2BIG.

म्हणून, आम्ही BPF प्रोग्राम तयार आणि लोड करू शकतो, तसेच वापरकर्त्याच्या जागेवरून नकाशे तयार आणि व्यवस्थापित करू शकतो. आता आपण BPF प्रोग्राममधील नकाशे स्वतः कसे वापरू शकतो हे पाहणे तर्कसंगत आहे. मशीन मॅक्रो कोडमधील हार्ड-टू-रीड प्रोग्राम्सच्या भाषेत आपण याबद्दल बोलू शकतो, परंतु खरं तर BPF प्रोग्राम्स प्रत्यक्षात कसे लिहिले आणि राखले जातात हे दाखवण्याची वेळ आली आहे - वापरून libbpf.

(निम्न-स्तरीय उदाहरणाच्या अभावामुळे असमाधानी असलेल्या वाचकांसाठी: आम्ही तपशीलवार प्रोग्राम्सचे विश्लेषण करू जे नकाशे आणि मदतनीस कार्ये वापरून तयार केलेले libbpf आणि सूचना स्तरावर काय होते ते तुम्हाला सांगतो. असमाधानी असलेल्या वाचकांसाठी खुप, आम्ही जोडले उदाहरण लेखात योग्य ठिकाणी.)

libbpf वापरून BPF प्रोग्राम लिहिणे

मशीन कोड वापरून बीपीएफ प्रोग्राम लिहिणे केवळ प्रथमच मनोरंजक असू शकते आणि नंतर तृप्ति सेट होते. या क्षणी आपल्याला आपले लक्ष वळवण्याची आवश्यकता आहे llvm, ज्यामध्ये BPF आर्किटेक्चर तसेच लायब्ररीसाठी कोड जनरेट करण्यासाठी बॅकएंड आहे libbpf, जे तुम्हाला BPF ऍप्लिकेशन्सची वापरकर्ता बाजू लिहिण्यास आणि वापरून तयार केलेल्या BPF प्रोग्राम्सचा कोड लोड करण्यास अनुमती देते. llvm/clang.

खरं तर, जसे आपण या आणि त्यानंतरच्या लेखांमध्ये पाहणार आहोत, libbpf त्याशिवाय बरेच काम करते (किंवा तत्सम साधने - iproute2, libbcc, libbpf-go, इ.) जगणे अशक्य आहे. प्रकल्पाच्या किलर वैशिष्ट्यांपैकी एक libbpf BPF CO-RE (एकदा संकलित करा, सर्वत्र चालवा) - हा एक प्रकल्प आहे जो तुम्हाला एका कर्नलमधून दुसऱ्या कर्नलवर पोर्टेबल असलेले BPF प्रोग्राम लिहिण्याची परवानगी देतो, ज्यामध्ये वेगवेगळ्या API वर चालण्याची क्षमता असते (उदाहरणार्थ, जेव्हा कर्नलची रचना आवृत्तीमधून बदलते. आवृत्तीपर्यंत). CO-RE सह कार्य करण्यास सक्षम होण्यासाठी, तुमचे कर्नल BTF सपोर्टसह संकलित केले जाणे आवश्यक आहे (हे कसे करायचे ते आम्ही विभागात वर्णन करतो. विकास साधने. तुमचा कर्नल BTF ने बनवला आहे की नाही हे तुम्ही तपासू शकता - खालील फाइलच्या उपस्थितीने:

$ ls -lh /sys/kernel/btf/vmlinux
-r--r--r-- 1 root root 2.6M Jul 29 15:30 /sys/kernel/btf/vmlinux

ही फाईल कर्नलमध्ये वापरलेल्या सर्व डेटा प्रकारांबद्दल माहिती संग्रहित करते आणि वापरून आमच्या सर्व उदाहरणांमध्ये वापरली जाते libbpf. आम्ही पुढील लेखात CO-RE बद्दल तपशीलवार चर्चा करू, परंतु या लेखात - फक्त स्वतःला एक कर्नल तयार करा CONFIG_DEBUG_INFO_BTF.

लायब्ररी libbpf थेट निर्देशिकेत राहतो tools/lib/bpf कर्नल आणि त्याचा विकास मेलिंग सूचीद्वारे केला जातो [email protected]. तथापि, कर्नलच्या बाहेर राहणार्‍या ऍप्लिकेशन्सच्या गरजांसाठी वेगळे भांडार राखले जाते https://github.com/libbpf/libbpf ज्यामध्ये कर्नल लायब्ररी कमी-अधिक प्रमाणात वाचन प्रवेशासाठी मिरर केली जाते.

या विभागात आपण वापरणारा प्रकल्प कसा तयार करू शकतो ते पाहू libbpf, चला अनेक (अधिक किंवा कमी अर्थहीन) चाचणी प्रोग्राम लिहू आणि हे सर्व कसे कार्य करते याचे तपशीलवार विश्लेषण करूया. हे BPF प्रोग्राम्स नकाशे, कर्नल मदतनीस, BTF इत्यादींशी कसे संवाद साधतात हे खालील विभागांमध्ये अधिक सहजपणे स्पष्ट करण्यास अनुमती देईल.

सामान्यतः वापरून प्रकल्प libbpf गिट सबमॉड्यूल म्हणून गिटहब रेपॉजिटरी जोडा, आम्ही तेच करू:

$ mkdir /tmp/libbpf-example
$ cd /tmp/libbpf-example/
$ git init-db
Initialized empty Git repository in /tmp/libbpf-example/.git/
$ git submodule add https://github.com/libbpf/libbpf.git
Cloning into '/tmp/libbpf-example/libbpf'...
remote: Enumerating objects: 200, done.
remote: Counting objects: 100% (200/200), done.
remote: Compressing objects: 100% (103/103), done.
remote: Total 3354 (delta 101), reused 118 (delta 79), pack-reused 3154
Receiving objects: 100% (3354/3354), 2.05 MiB | 10.22 MiB/s, done.
Resolving deltas: 100% (2176/2176), done.

जात libbpf खूप सोपे:

$ cd libbpf/src
$ mkdir build
$ OBJDIR=build DESTDIR=root make -s install
$ find root
root
root/usr
root/usr/include
root/usr/include/bpf
root/usr/include/bpf/bpf_tracing.h
root/usr/include/bpf/xsk.h
root/usr/include/bpf/libbpf_common.h
root/usr/include/bpf/bpf_endian.h
root/usr/include/bpf/bpf_helpers.h
root/usr/include/bpf/btf.h
root/usr/include/bpf/bpf_helper_defs.h
root/usr/include/bpf/bpf.h
root/usr/include/bpf/libbpf_util.h
root/usr/include/bpf/libbpf.h
root/usr/include/bpf/bpf_core_read.h
root/usr/lib64
root/usr/lib64/libbpf.so.0.1.0
root/usr/lib64/libbpf.so.0
root/usr/lib64/libbpf.a
root/usr/lib64/libbpf.so
root/usr/lib64/pkgconfig
root/usr/lib64/pkgconfig/libbpf.pc

या विभागातील आमची पुढील योजना खालीलप्रमाणे आहे: आम्ही BPF कार्यक्रम लिहू BPF_PROG_TYPE_XDP, मागील उदाहरणाप्रमाणेच, परंतु C मध्ये, आम्ही ते वापरून संकलित करतो clang, आणि एक हेल्पर प्रोग्राम लिहा जो कर्नलमध्ये लोड करेल. पुढील विभागांमध्ये आम्ही BPF कार्यक्रम आणि सहाय्यक कार्यक्रम या दोन्हींच्या क्षमतांचा विस्तार करू.

उदाहरण: libbpf वापरून पूर्ण ॲप्लिकेशन तयार करणे

सुरुवातीला, आम्ही फाइल वापरतो /sys/kernel/btf/vmlinux, ज्याचा वर उल्लेख केला होता, आणि त्याच्या समतुल्य हेडर फाइलच्या स्वरूपात तयार करा:

$ bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

ही फाइल आमच्या कर्नलमध्ये उपलब्ध सर्व डेटा स्ट्रक्चर्स संचयित करेल, उदाहरणार्थ, कर्नलमध्ये IPv4 शीर्षलेख अशा प्रकारे परिभाषित केला जातो:

$ grep -A 12 'struct iphdr {' vmlinux.h
struct iphdr {
    __u8 ihl: 4;
    __u8 version: 4;
    __u8 tos;
    __be16 tot_len;
    __be16 id;
    __be16 frag_off;
    __u8 ttl;
    __u8 protocol;
    __sum16 check;
    __be32 saddr;
    __be32 daddr;
};

आता आम्ही आमचा BPF प्रोग्राम C मध्ये लिहू:

$ cat xdp-simple.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

SEC("xdp/simple")
int simple(void *ctx)
{
        return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

जरी आमचा कार्यक्रम अगदी सोपा होता, तरीही आम्हाला बर्याच तपशीलांकडे लक्ष देणे आवश्यक आहे. प्रथम, आम्ही समाविष्ट केलेली पहिली शीर्षलेख फाइल आहे vmlinux.h, जे आम्ही वापरून तयार केले आहे bpftool btf dump - आता कर्नल संरचना कशा दिसतात हे शोधण्यासाठी आम्हाला कर्नल-हेडर पॅकेज स्थापित करण्याची आवश्यकता नाही. खालील हेडर फाइल लायब्ररीतून आमच्याकडे येते libbpf. आता आपल्याला फक्त मॅक्रो परिभाषित करण्यासाठी त्याची आवश्यकता आहे SEC, जे वर्ण ELF ऑब्जेक्ट फाइलच्या योग्य विभागात पाठवते. आमचा कार्यक्रम विभागात समाविष्ट आहे xdp/simple, जेथे स्लॅश करण्यापूर्वी आम्ही प्रोग्राम प्रकार परिभाषित करतो BPF - हे वापरलेले अधिवेशन आहे libbpf, विभागाच्या नावावर आधारित ते स्टार्टअपवर योग्य प्रकार बदलेल bpf(2). BPF कार्यक्रम स्वतः आहे C - अतिशय सोपी आणि एका ओळीचा समावेश आहे return XDP_PASS. शेवटी, एक स्वतंत्र विभाग "license" परवान्याचे नाव आहे.

आम्ही आमचा प्रोग्राम llvm/clang, आवृत्ती >= 10.0.0 वापरून संकलित करू शकतो किंवा अजून चांगले, मोठे (विभाग पहा विकास साधने):

$ clang --version
clang version 11.0.0 (https://github.com/llvm/llvm-project.git afc287e0abec710398465ee1f86237513f2b5091)
...

$ clang -O2 -g -c -target bpf -I libbpf/src/root/usr/include xdp-simple.bpf.c -o xdp-simple.bpf.o

मनोरंजक वैशिष्ट्यांपैकी: आम्ही लक्ष्य आर्किटेक्चर सूचित करतो -target bpf आणि शीर्षलेखांचा मार्ग libbpf, जे आम्ही अलीकडे स्थापित केले आहे. तसेच, बद्दल विसरू नका -O2, या पर्यायाशिवाय तुम्ही भविष्यात आश्चर्यचकित होऊ शकता. चला आमचा कोड बघूया, आम्हाला हवा तो प्रोग्राम लिहायला आम्ही व्यवस्थापित केले का?

$ llvm-objdump --section=xdp/simple --no-show-raw-insn -D xdp-simple.bpf.o

xdp-simple.bpf.o:       file format elf64-bpf

Disassembly of section xdp/simple:

0000000000000000 <simple>:
       0:       r0 = 2
       1:       exit

होय, ते काम केले! आता, आमच्याकडे प्रोग्रामसह बायनरी फाइल आहे, आणि आम्हाला एक ऍप्लिकेशन तयार करायचे आहे जे ते कर्नलमध्ये लोड करेल. यासाठी ग्रंथालय libbpf आम्हाला दोन पर्याय देतात - खालच्या-स्तरीय API किंवा उच्च-स्तरीय API वापरा. आम्ही दुसऱ्या मार्गावर जाऊ, कारण आम्हाला BPF प्रोग्राम कसे लिहायचे, लोड करायचे आणि त्यांच्या पुढील अभ्यासासाठी कमीत कमी प्रयत्नात कसे जोडायचे हे शिकायचे आहे.

प्रथम, त्याच युटिलिटीचा वापर करून आपल्याला आपल्या प्रोग्रामचा बायनरी मधून “स्केलेटन” तयार करणे आवश्यक आहे. bpftool — BPF जगाचा स्विस चाकू (ज्याला शब्दशः घेतले जाऊ शकते, कारण डॅनियल बोर्कमन, BPF चे निर्माते आणि देखरेख करणारे एक स्विस आहेत):

$ bpftool gen skeleton xdp-simple.bpf.o > xdp-simple.skel.h

फाईलमध्ये xdp-simple.skel.h आमच्या प्रोग्रामचा बायनरी कोड आणि व्यवस्थापित करण्यासाठी कार्ये - लोड करणे, संलग्न करणे, हटवणे समाविष्ट आहे. आमच्या साध्या केसमध्ये हे ओव्हरकिलसारखे दिसते, परंतु ऑब्जेक्ट फाइलमध्ये अनेक बीपीएफ प्रोग्राम्स आणि नकाशे असतात अशा बाबतीतही हे कार्य करते आणि हे विशाल ELF लोड करण्यासाठी आम्हाला फक्त सांगाडा तयार करणे आवश्यक आहे आणि कस्टम ऍप्लिकेशनमधून एक किंवा दोन फंक्शन्स कॉल करणे आवश्यक आहे. लिहित आहेत चला आता पुढे जाऊया.

काटेकोरपणे सांगायचे तर, आमचा लोडर प्रोग्राम क्षुल्लक आहे:

#include <err.h>
#include <unistd.h>
#include "xdp-simple.skel.h"

int main(int argc, char **argv)
{
    struct xdp_simple_bpf *obj;

    obj = xdp_simple_bpf__open_and_load();
    if (!obj)
        err(1, "failed to open and/or load BPF objectn");

    pause();

    xdp_simple_bpf__destroy(obj);
}

तो आहे struct xdp_simple_bpf फाइल मध्ये परिभाषित xdp-simple.skel.h आणि आमच्या ऑब्जेक्ट फाइलचे वर्णन करते:

struct xdp_simple_bpf {
    struct bpf_object_skeleton *skeleton;
    struct bpf_object *obj;
    struct {
        struct bpf_program *simple;
    } progs;
    struct {
        struct bpf_link *simple;
    } links;
};

आम्ही येथे निम्न-स्तरीय API चे ट्रेस पाहू शकतो: रचना struct bpf_program *simple и struct bpf_link *simple. प्रथम रचना विशेषत: विभागात लिहिलेल्या आमच्या प्रोग्रामचे वर्णन करते xdp/simple, आणि दुसरा कार्यक्रम इव्हेंट स्त्रोताशी कसा जोडतो याचे वर्णन करतो.

कार्य xdp_simple_bpf__open_and_load, एखादे ईएलएफ ऑब्जेक्ट उघडते, त्याचे विश्लेषण करते, सर्व संरचना आणि सबस्ट्रक्चर्स तयार करते (प्रोग्राम व्यतिरिक्त, ईएलएफमध्ये इतर विभाग देखील असतात - डेटा, केवळ वाचनीय डेटा, डीबगिंग माहिती, परवाना इ.), आणि नंतर सिस्टम वापरून कर्नलमध्ये लोड करते. कॉल bpf, जे आम्ही प्रोग्राम संकलित आणि चालवून तपासू शकतो:

$ clang -O2 -I ./libbpf/src/root/usr/include/ xdp-simple.c -o xdp-simple ./libbpf/src/root/usr/lib64/libbpf.a -lelf -lz

$ sudo strace -e bpf ./xdp-simple
...
bpf(BPF_BTF_LOAD, 0x7ffdb8fd9670, 120)  = 3
bpf(BPF_PROG_LOAD, {prog_type=BPF_PROG_TYPE_XDP, insn_cnt=2, insns=0xdfd580, license="GPL", log_level=0, log_size=0, log_buf=NULL, kern_version=KERNEL_VERSION(5, 8, 0), prog_flags=0, prog_name="simple", prog_ifindex=0, expected_attach_type=0x25 /* BPF_??? */, ...}, 120) = 4

चला आता आमचा प्रोग्राम वापरून पाहू bpftool. चला तिचा आयडी शोधूया:

# bpftool p | grep -A4 simple
463: xdp  name simple  tag 3b185187f1855c4c  gpl
        loaded_at 2020-08-01T01:59:49+0000  uid 0
        xlated 16B  jited 40B  memlock 4096B
        btf_id 185
        pids xdp-simple(16498)

आणि डंप (आम्ही कमांडचा एक छोटा फॉर्म वापरतो bpftool prog dump xlated):

# bpftool p d x id 463
int simple(void *ctx):
; return XDP_PASS;
   0: (b7) r0 = 2
   1: (95) exit

काहीतरी नवीन! प्रोग्रामने आमच्या C स्त्रोत फाइलचे भाग छापले. हे लायब्ररीने केले libbpf, ज्याने बायनरीमध्ये डीबग विभाग आढळला, तो BTF ऑब्जेक्टमध्ये संकलित केला, वापरून कर्नलमध्ये लोड केला BPF_BTF_LOAD, आणि नंतर कमांडसह प्रोग्राम लोड करताना परिणामी फाइल वर्णनकर्ता निर्दिष्ट करा BPG_PROG_LOAD.

कर्नल मदतनीस

बीपीएफ प्रोग्राम्स "बाह्य" फंक्शन्स चालवू शकतात - कर्नल हेल्पर. हे सहाय्यक कार्ये BPF प्रोग्राम्सना कर्नल संरचनांमध्ये प्रवेश करण्यास, नकाशे व्यवस्थापित करण्यास आणि "वास्तविक जग" शी संवाद साधण्याची परवानगी देतात - परफ इव्हेंट तयार करणे, हार्डवेअर नियंत्रित करणे (उदाहरणार्थ, पॅकेट पुनर्निर्देशित करणे) इ.

उदाहरण: bpf_get_smp_processor_id

"उदाहरणार्थ शिकणे" या प्रतिमानाच्या चौकटीत, सहाय्यक कार्यांपैकी एकाचा विचार करूया, bpf_get_smp_processor_id(), निश्चित फाइल मध्ये kernel/bpf/helpers.c. तो प्रोसेसरचा नंबर देतो ज्यावर BPF प्रोग्राम चालू आहे. परंतु आम्हाला त्याच्या अर्थशास्त्रात तितके रस नाही कारण त्याची अंमलबजावणी एक ओळ घेते:

BPF_CALL_0(bpf_get_smp_processor_id)
{
    return smp_processor_id();
}

BPF हेल्पर फंक्शन व्याख्या लिनक्स सिस्टम कॉल व्याख्येप्रमाणेच आहेत. येथे, उदाहरणार्थ, कोणतेही वितर्क नसलेले फंक्शन परिभाषित केले आहे. (एक फंक्शन जे तीन वितर्क घेते, म्हणा, मॅक्रो वापरून परिभाषित केले जाते BPF_CALL_3. वितर्कांची कमाल संख्या पाच आहे.) तथापि, हा केवळ व्याख्येचा पहिला भाग आहे. दुसरा भाग प्रकार रचना परिभाषित करण्यासाठी आहे struct bpf_func_proto, ज्यामध्ये हेल्पर फंक्शनचे वर्णन आहे जे पडताळकाला समजते:

const struct bpf_func_proto bpf_get_smp_processor_id_proto = {
    .func     = bpf_get_smp_processor_id,
    .gpl_only = false,
    .ret_type = RET_INTEGER,
};

हेल्पर फंक्शन्सची नोंदणी करणे

विशिष्ट प्रकारच्या बीपीएफ प्रोग्राम्सना हे फंक्शन वापरण्यासाठी, त्यांनी त्याची नोंदणी करणे आवश्यक आहे, उदाहरणार्थ प्रकारासाठी BPF_PROG_TYPE_XDP कर्नलमध्ये फंक्शन परिभाषित केले आहे xdp_func_proto, जे हेल्पर फंक्शन आयडीवरून ठरवते की XDP या फंक्शनला सपोर्ट करते की नाही. आमचे कार्य आहे समर्थन:

static const struct bpf_func_proto *
xdp_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
{
    switch (func_id) {
    ...
    case BPF_FUNC_get_smp_processor_id:
        return &bpf_get_smp_processor_id_proto;
    ...
    }
}

नवीन BPF प्रोग्राम प्रकार फाइलमध्ये "परिभाषित" आहेत include/linux/bpf_types.h मॅक्रो वापरून BPF_PROG_TYPE. अवतरणांमध्ये परिभाषित केले आहे कारण ती तार्किक व्याख्या आहे, आणि C भाषेच्या अटींमध्ये कंक्रीट संरचनांच्या संपूर्ण संचाची व्याख्या इतर ठिकाणी आढळते. विशेषतः, फाइलमध्ये kernel/bpf/verifier.c फाइलमधील सर्व व्याख्या bpf_types.h स्ट्रक्चर्सची अॅरे तयार करण्यासाठी वापरली जातात bpf_verifier_ops[]:

static const struct bpf_verifier_ops *const bpf_verifier_ops[] = {
#define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) 
    [_id] = & _name ## _verifier_ops,
#include <linux/bpf_types.h>
#undef BPF_PROG_TYPE
};

म्हणजेच, प्रत्येक प्रकारच्या BPF प्रोग्रामसाठी, प्रकाराच्या डेटा स्ट्रक्चरसाठी एक पॉइंटर परिभाषित केला जातो struct bpf_verifier_ops, ज्याचा प्रारंभ मूल्यासह केला जातो _name ## _verifier_ops, म्हणजे, xdp_verifier_ops ते xdp. रचना xdp_verifier_ops द्वारा निर्धारित फाइल मध्ये net/core/filter.c खालीलप्रमाणे:

const struct bpf_verifier_ops xdp_verifier_ops = {
    .get_func_proto     = xdp_func_proto,
    .is_valid_access    = xdp_is_valid_access,
    .convert_ctx_access = xdp_convert_ctx_access,
    .gen_prologue       = bpf_noop_prologue,
};

येथे आपण आपले परिचित कार्य पाहतो xdp_func_proto, जे प्रत्येक वेळी आव्हानाचा सामना करताना सत्यापनकर्ता चालवेल काही बीपीएफ प्रोग्राममधील कार्ये, पहा verifier.c.

काल्पनिक BPF प्रोग्राम फंक्शनचा वापर कसा करतो ते पाहू bpf_get_smp_processor_id. हे करण्यासाठी, आम्ही आमच्या मागील विभागातील प्रोग्राम खालीलप्रमाणे पुन्हा लिहितो:

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

SEC("xdp/simple")
int simple(void *ctx)
{
    if (bpf_get_smp_processor_id() != 0)
        return XDP_DROP;
    return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

प्रतीक bpf_get_smp_processor_id द्वारा निर्धारित в <bpf/bpf_helper_defs.h> ग्रंथालये libbpf कसे

static u32 (*bpf_get_smp_processor_id)(void) = (void *) 8;

ते आहे, bpf_get_smp_processor_id एक फंक्शन पॉइंटर आहे ज्याचे मूल्य 8 आहे, जेथे 8 हे मूल्य आहे BPF_FUNC_get_smp_processor_id प्रकार enum bpf_fun_id, जे आमच्यासाठी फाइलमध्ये परिभाषित केले आहे vmlinux.h (फाइल bpf_helper_defs.h कर्नलमध्ये स्क्रिप्टद्वारे व्युत्पन्न केले जाते, म्हणून "जादू" संख्या ठीक आहेत). हे फंक्शन कोणतेही वितर्क घेत नाही आणि प्रकाराचे मूल्य मिळवते __u32. जेव्हा आम्ही ते आमच्या प्रोग्राममध्ये चालवतो, clang एक सूचना व्युत्पन्न करते BPF_CALL "योग्य प्रकार" चला प्रोग्राम संकलित करू आणि विभाग पाहू xdp/simple:

$ clang -O2 -g -c -target bpf -I libbpf/src/root/usr/include xdp-simple.bpf.c -o xdp-simple.bpf.o
$ llvm-objdump -D --section=xdp/simple xdp-simple.bpf.o

xdp-simple.bpf.o:       file format elf64-bpf

Disassembly of section xdp/simple:

0000000000000000 <simple>:
       0:       85 00 00 00 08 00 00 00 call 8
       1:       bf 01 00 00 00 00 00 00 r1 = r0
       2:       67 01 00 00 20 00 00 00 r1 <<= 32
       3:       77 01 00 00 20 00 00 00 r1 >>= 32
       4:       b7 00 00 00 02 00 00 00 r0 = 2
       5:       15 01 01 00 00 00 00 00 if r1 == 0 goto +1 <LBB0_2>
       6:       b7 00 00 00 01 00 00 00 r0 = 1

0000000000000038 <LBB0_2>:
       7:       95 00 00 00 00 00 00 00 exit

पहिल्या ओळीत आपण सूचना पाहतो call, पॅरामीटर IMM जे 8 च्या बरोबरीचे आहे, आणि SRC_REG - शून्य. सत्यापनकर्त्याद्वारे वापरल्या जाणार्‍या ABI करारानुसार, हे हेल्पर फंक्शन क्रमांक आठला कॉल आहे. एकदा ते लाँच केले की, तर्क सोपे आहे. रजिस्टरमधून परतावा मूल्य r0 वर कॉपी केले r1 आणि ओळी 2,3 वर ते टाइपमध्ये रूपांतरित केले जाते u32 - वरचे 32 बिट साफ केले आहेत. 4,5,6,7 ओळींवर आम्ही 2 परत करतो (XDP_PASS) किंवा 1 (XDP_DROP) ओळ 0 मधील हेल्पर फंक्शनने शून्य किंवा शून्य नसलेले मूल्य परत केले यावर अवलंबून.

चला स्वतःची चाचणी घेऊ: प्रोग्राम लोड करा आणि आउटपुट पहा bpftool prog dump xlated:

$ bpftool gen skeleton xdp-simple.bpf.o > xdp-simple.skel.h
$ clang -O2 -g -I ./libbpf/src/root/usr/include/ -o xdp-simple xdp-simple.c ./libbpf/src/root/usr/lib64/libbpf.a -lelf -lz
$ sudo ./xdp-simple &
[2] 10914

$ sudo bpftool p | grep simple
523: xdp  name simple  tag 44c38a10c657e1b0  gpl
        pids xdp-simple(10915)

$ sudo bpftool p d x id 523
int simple(void *ctx):
; if (bpf_get_smp_processor_id() != 0)
   0: (85) call bpf_get_smp_processor_id#114128
   1: (bf) r1 = r0
   2: (67) r1 <<= 32
   3: (77) r1 >>= 32
   4: (b7) r0 = 2
; }
   5: (15) if r1 == 0x0 goto pc+1
   6: (b7) r0 = 1
   7: (95) exit

ठीक आहे, पडताळकाला योग्य कर्नल-हेल्पर सापडला.

उदाहरण: युक्तिवाद पास करणे आणि शेवटी प्रोग्राम चालवणे!

सर्व रन-लेव्हल हेल्पर फंक्शन्सचा प्रोटोटाइप असतो

u64 fn(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)

हेल्पर फंक्शन्सचे पॅरामीटर्स रजिस्टरमध्ये पास केले जातात r1-r5, आणि मूल्य रजिस्टरमध्ये परत केले जाते r0. पाच पेक्षा जास्त युक्तिवाद घेणारी कोणतीही कार्ये नाहीत आणि भविष्यात त्यांच्यासाठी समर्थन जोडले जाणे अपेक्षित नाही.

चला नवीन कर्नल हेल्पर आणि BPF पॅरामीटर्स कसे पास करते ते पाहू. चला पुन्हा लिहू xdp-simple.bpf.c खालीलप्रमाणे (उर्वरित ओळी बदलल्या नाहीत):

SEC("xdp/simple")
int simple(void *ctx)
{
    bpf_printk("running on CPU%un", bpf_get_smp_processor_id());
    return XDP_PASS;
}

आमचा प्रोग्राम ज्या सीपीयूवर चालू आहे त्याचा नंबर प्रिंट करतो. चला ते संकलित करू आणि कोड पाहू:

$ llvm-objdump -D --section=xdp/simple --no-show-raw-insn xdp-simple.bpf.o

0000000000000000 <simple>:
       0:       r1 = 10
       1:       *(u16 *)(r10 - 8) = r1
       2:       r1 = 8441246879787806319 ll
       4:       *(u64 *)(r10 - 16) = r1
       5:       r1 = 2334956330918245746 ll
       7:       *(u64 *)(r10 - 24) = r1
       8:       call 8
       9:       r1 = r10
      10:       r1 += -24
      11:       r2 = 18
      12:       r3 = r0
      13:       call 6
      14:       r0 = 2
      15:       exit

ओळी 0-7 मध्ये आम्ही स्ट्रिंग लिहितो running on CPU%un, आणि नंतर ओळ 8 वर आम्ही परिचित एक चालवतो bpf_get_smp_processor_id. ओळी 9-12 वर आम्ही मदतनीस युक्तिवाद तयार करतो bpf_printk - नोंदणी r1, r2, r3. त्यापैकी तीन का आहेत आणि दोन नाहीत? कारण bpf_printk - हे मॅक्रो रॅपर आहे वास्तविक मदतनीसभोवती bpf_trace_printk, ज्याला फॉरमॅट स्ट्रिंगचा आकार पास करणे आवश्यक आहे.

आता यात दोन ओळी जोडू xdp-simple.cजेणेकरून आमचा प्रोग्राम इंटरफेसशी कनेक्ट होईल lo आणि खरोखर सुरुवात केली!

$ cat xdp-simple.c
#include <linux/if_link.h>
#include <err.h>
#include <unistd.h>
#include "xdp-simple.skel.h"

int main(int argc, char **argv)
{
    __u32 flags = XDP_FLAGS_SKB_MODE;
    struct xdp_simple_bpf *obj;

    obj = xdp_simple_bpf__open_and_load();
    if (!obj)
        err(1, "failed to open and/or load BPF objectn");

    bpf_set_link_xdp_fd(1, -1, flags);
    bpf_set_link_xdp_fd(1, bpf_program__fd(obj->progs.simple), flags);

cleanup:
    xdp_simple_bpf__destroy(obj);
}

येथे आपण फंक्शन वापरतो bpf_set_link_xdp_fd, जे XDP-प्रकारचे BPF प्रोग्राम नेटवर्क इंटरफेसशी जोडते. आम्ही इंटरफेस नंबर हार्डकोड केला lo, जे नेहमी 1 असते. जुना प्रोग्रॅम जोडलेला असेल तर प्रथम तो वेगळे करण्यासाठी आम्ही फंक्शन दोनदा चालवतो. लक्षात घ्या की आता आम्हाला आव्हानाची गरज नाही pause किंवा अनंत लूप: आमचा लोडर प्रोग्राम बाहेर पडेल, परंतु बीपीएफ प्रोग्राम इव्हेंट स्त्रोताशी जोडलेला असल्याने तो मारला जाणार नाही. यशस्वी डाउनलोड आणि कनेक्शननंतर, पोहोचणाऱ्या प्रत्येक नेटवर्क पॅकेटसाठी प्रोग्राम लॉन्च केला जाईल lo.

चला प्रोग्राम डाउनलोड करू आणि इंटरफेस पाहू lo:

$ sudo ./xdp-simple
$ sudo bpftool p | grep simple
669: xdp  name simple  tag 4fca62e77ccb43d6  gpl
$ ip l show dev lo
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 xdpgeneric qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    prog/xdp id 669

आम्ही डाउनलोड केलेल्या प्रोग्राममध्ये ID 669 आहे आणि आम्हाला तोच ID इंटरफेसवर दिसतो lo. आम्ही काही पॅकेजेस पाठवू 127.0.0.1 (विनंती + उत्तर):

$ ping -c1 localhost

आणि आता डीबग व्हर्च्युअल फाईलची सामग्री पाहू /sys/kernel/debug/tracing/trace_pipe, ज्यामध्ये bpf_printk त्याचे संदेश लिहितात:

# cat /sys/kernel/debug/tracing/trace_pipe
ping-13937 [000] d.s1 442015.377014: bpf_trace_printk: running on CPU0
ping-13937 [000] d.s1 442015.377027: bpf_trace_printk: running on CPU0

त्यावर दोन पॅकेजेस दिसल्या lo आणि CPU0 वर प्रक्रिया केली - आमचा पहिला पूर्ण वाढ झालेला अर्थहीन BPF प्रोग्राम काम करतो!

हे लक्षात घेण्यासारखे आहे bpf_printk ते डीबग फाइलवर लिहिते असे काही नाही: उत्पादनात वापरण्यासाठी हे सर्वात यशस्वी मदतनीस नाही, परंतु आमचे ध्येय काहीतरी सोपे दर्शविणे होते.

BPF प्रोग्राममधून नकाशे ऍक्सेस करणे

उदाहरण: BPF प्रोग्राममधील नकाशा वापरणे

मागील भागांमध्ये आपण युजर स्पेसमधून नकाशे कसे बनवायचे आणि कसे वापरायचे ते शिकलो आणि आता कर्नलचा भाग पाहू. चला, नेहमीप्रमाणे, एका उदाहरणासह प्रारंभ करूया. चला आपला कार्यक्रम पुन्हा लिहू xdp-simple.bpf.c खालीलप्रमाणे:

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 8);
    __type(key, u32);
    __type(value, u64);
} woo SEC(".maps");

SEC("xdp/simple")
int simple(void *ctx)
{
    u32 key = bpf_get_smp_processor_id();
    u32 *val;

    val = bpf_map_lookup_elem(&woo, &key);
    if (!val)
        return XDP_ABORTED;

    *val += 1;

    return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

कार्यक्रमाच्या सुरुवातीला आम्ही नकाशाची व्याख्या जोडली woo: हा 8-घटकांचा अॅरे आहे जो सारखी मूल्ये साठवतो u64 (C मध्ये आम्ही अशा अॅरेची व्याख्या करू u64 woo[8]). एका कार्यक्रमात "xdp/simple" आम्हाला सध्याचा प्रोसेसर क्रमांक व्हेरिएबलमध्ये मिळतो key आणि नंतर हेल्पर फंक्शन वापरून bpf_map_lookup_element आपल्याला अॅरेमधील संबंधित एंट्रीसाठी एक पॉइंटर मिळेल, जो आपण एकाने वाढवतो. रशियनमध्ये अनुवादित: आम्ही आकडेवारीची गणना करतो ज्यावर CPU ने इनकमिंग पॅकेटवर प्रक्रिया केली. चला प्रोग्राम चालवण्याचा प्रयत्न करूया:

$ clang -O2 -g -c -target bpf -I libbpf/src/root/usr/include xdp-simple.bpf.c -o xdp-simple.bpf.o
$ bpftool gen skeleton xdp-simple.bpf.o > xdp-simple.skel.h
$ clang -O2 -g -I ./libbpf/src/root/usr/include/ -o xdp-simple xdp-simple.c ./libbpf/src/root/usr/lib64/libbpf.a -lelf -lz
$ sudo ./xdp-simple

चला तपासूया की तिला हुक अप आहे lo आणि काही पॅकेट पाठवा:

$ ip l show dev lo
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 xdpgeneric qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    prog/xdp id 108

$ for s in `seq 234`; do sudo ping -f -c 100 127.0.0.1 >/dev/null 2>&1; done

आता अॅरेची सामग्री पाहू:

$ sudo bpftool map dump name woo
[
    { "key": 0, "value": 0 },
    { "key": 1, "value": 400 },
    { "key": 2, "value": 0 },
    { "key": 3, "value": 0 },
    { "key": 4, "value": 0 },
    { "key": 5, "value": 0 },
    { "key": 6, "value": 0 },
    { "key": 7, "value": 46400 }
]

जवळजवळ सर्व प्रक्रिया CPU7 वर प्रक्रिया केल्या गेल्या. हे आमच्यासाठी महत्त्वाचे नाही, मुख्य गोष्ट अशी आहे की प्रोग्राम कार्य करतो आणि आम्हाला BPF प्रोग्राममधून नकाशे कसे ऍक्सेस करायचे हे समजते - वापरून хелперов bpf_mp_*.

गूढ निर्देशांक

म्हणून, आम्ही कॉल्स वापरून BPF प्रोग्राममधून नकाशावर प्रवेश करू शकतो

val = bpf_map_lookup_elem(&woo, &key);

जेथे हेल्पर फंक्शन असे दिसते

void *bpf_map_lookup_elem(struct bpf_map *map, const void *key)

पण आम्ही एक पॉइंटर पास करत आहोत &woo अज्ञात संरचनेकडे struct { ... }...

जर आपण प्रोग्रॅम असेंबलर पाहिला तर आपल्याला ते मूल्य दिसते &woo प्रत्यक्षात परिभाषित केलेले नाही (ओळ 4):

llvm-objdump -D --section xdp/simple xdp-simple.bpf.o

xdp-simple.bpf.o:       file format elf64-bpf

Disassembly of section xdp/simple:

0000000000000000 <simple>:
       0:       85 00 00 00 08 00 00 00 call 8
       1:       63 0a fc ff 00 00 00 00 *(u32 *)(r10 - 4) = r0
       2:       bf a2 00 00 00 00 00 00 r2 = r10
       3:       07 02 00 00 fc ff ff ff r2 += -4
       4:       18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
       6:       85 00 00 00 01 00 00 00 call 1
...

आणि पुनर्स्थापना मध्ये समाविष्ट आहे:

$ llvm-readelf -r xdp-simple.bpf.o | head -4

Relocation section '.relxdp/simple' at offset 0xe18 contains 1 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
0000000000000020  0000002700000001 R_BPF_64_64            0000000000000000 woo

परंतु जर आपण आधीच लोड केलेला प्रोग्राम पाहिला तर आपल्याला योग्य नकाशाकडे एक पॉइंटर दिसेल (ओळ 4):

$ sudo bpftool prog dump x name simple
int simple(void *ctx):
   0: (85) call bpf_get_smp_processor_id#114128
   1: (63) *(u32 *)(r10 -4) = r0
   2: (bf) r2 = r10
   3: (07) r2 += -4
   4: (18) r1 = map[id:64]
...

अशाप्रकारे, आम्ही असा निष्कर्ष काढू शकतो की आमचा लोडर प्रोग्राम लॉन्च करण्याच्या वेळी, याची लिंक &woo लायब्ररीने काहीतरी बदलले libbpf. प्रथम आपण आउटपुट पाहू strace:

$ sudo strace -e bpf ./xdp-simple
...
bpf(BPF_MAP_CREATE, {map_type=BPF_MAP_TYPE_ARRAY, key_size=4, value_size=8, max_entries=8, map_name="woo", ...}, 120) = 4
bpf(BPF_PROG_LOAD, {prog_type=BPF_PROG_TYPE_XDP, prog_name="simple", ...}, 120) = 5

आम्ही ते पाहतो libbpf नकाशा तयार केला woo आणि नंतर आमचा प्रोग्राम डाउनलोड केला simple. आम्ही प्रोग्राम कसा लोड करतो ते जवळून पाहू:

कॉल xdp_simple_bpf__open_and_load फाईलमधून xdp-simple.skel.h
ज्यामुळे xdp_simple_bpf__load फाईलमधून xdp-simple.skel.h
ज्यामुळे bpf_object__load_skeleton फाईलमधून libbpf/src/libbpf.c
ज्यामुळे bpf_object__load_xattr पासून libbpf/src/libbpf.c

शेवटचे कार्य, इतर गोष्टींबरोबरच, कॉल करेल bpf_object__create_maps, जे विद्यमान नकाशे तयार करते किंवा उघडते, त्यांना फाइल वर्णनकर्त्यांमध्ये बदलते. (आम्ही इथेच पाहतो BPF_MAP_CREATE आउटपुट मध्ये strace.) पुढे फंक्शन म्हणतात bpf_object__relocate आणि तीच आम्हाला स्वारस्य आहे, कारण आम्ही जे पाहिले ते आम्हाला आठवते woo पुनर्स्थापना टेबल मध्ये. ते एक्सप्लोर करताना, आम्ही शेवटी फंक्शनमध्ये स्वतःला शोधतो bpf_program__relocate, जे नकाशाच्या पुनर्स्थापनेशी संबंधित आहे:

case RELO_LD64:
    insn[0].src_reg = BPF_PSEUDO_MAP_FD;
    insn[0].imm = obj->maps[relo->map_idx].fd;
    break;

म्हणून आम्ही आमच्या सूचना घेतो

18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll

आणि त्यात सोर्स रजिस्टर बदला BPF_PSEUDO_MAP_FD, आणि आमच्या नकाशाच्या फाइल वर्णनकर्त्याचे पहिले IMM आणि, जर ते समान असेल तर, उदाहरणार्थ, 0xdeadbeef, नंतर परिणामी आम्हाला सूचना प्राप्त होईल

18 11 00 00 ef eb ad de 00 00 00 00 00 00 00 00 r1 = 0 ll

अशा प्रकारे नकाशाची माहिती विशिष्ट लोड केलेल्या BPF प्रोग्राममध्ये हस्तांतरित केली जाते. या प्रकरणात, नकाशा वापरून तयार केले जाऊ शकते BPF_MAP_CREATE, आणि आयडी वापरून उघडले BPF_MAP_GET_FD_BY_ID.

एकूण, वापरताना libbpf अल्गोरिदम खालीलप्रमाणे आहे:

संकलनादरम्यान, नकाशांच्या दुव्यांसाठी पुनर्स्थित सारणीमध्ये रेकॉर्ड तयार केले जातात
libbpf ELF ऑब्जेक्ट बुक उघडते, सर्व वापरलेले नकाशे शोधते आणि त्यांच्यासाठी फाइल वर्णनकर्ता तयार करते
सूचनांचा भाग म्हणून फाइल वर्णनकर्ते कर्नलमध्ये लोड केले जातात LD64

जसे तुम्ही कल्पना करू शकता, अजून बरेच काही येणे बाकी आहे आणि आम्हाला गाभ्याकडे लक्ष द्यावे लागेल. सुदैवाने, आमच्याकडे एक सुगावा आहे - आम्ही अर्थ लिहून ठेवला आहे BPF_PSEUDO_MAP_FD स्त्रोत रजिस्टरमध्ये आणि आम्ही ते दफन करू शकतो, जे आम्हाला सर्व संतांच्या पवित्रतेकडे नेईल - kernel/bpf/verifier.c, जेथे विशिष्ट नावाचे फंक्शन फाइल डिस्क्रिप्टरला एका प्रकारच्या संरचनेच्या पत्त्यासह बदलते struct bpf_map:

static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) {
    ...

    f = fdget(insn[0].imm);
    map = __bpf_map_get(f);
    if (insn->src_reg == BPF_PSEUDO_MAP_FD) {
        addr = (unsigned long)map;
    }
    insn[0].imm = (u32)addr;
    insn[1].imm = addr >> 32;

(संपूर्ण कोड सापडेल दुवा). म्हणून आम्ही आमचे अल्गोरिदम वाढवू शकतो:

प्रोग्राम लोड करताना, पडताळक नकाशाचा योग्य वापर तपासतो आणि संबंधित संरचनेचा पत्ता लिहितो struct bpf_map

वापरून ELF बायनरी डाउनलोड करताना libbpf अजून बरेच काही चालू आहे, परंतु आम्ही इतर लेखांमध्ये याबद्दल चर्चा करू.

libbpf शिवाय प्रोग्राम आणि नकाशे लोड करत आहे

वचन दिल्याप्रमाणे, मदतीशिवाय नकाशे वापरणारा प्रोग्राम कसा तयार करायचा आणि लोड कसा करायचा हे जाणून घेऊ इच्छिणाऱ्या वाचकांसाठी येथे एक उदाहरण आहे. libbpf. जेव्हा तुम्ही अशा वातावरणात काम करत असाल ज्यासाठी तुम्ही अवलंबित्व तयार करू शकत नाही, किंवा प्रत्येक बिट जतन करू शकत नाही किंवा एखादा प्रोग्राम लिहू शकता तेव्हा हे उपयुक्त ठरू शकते. ply, जे उडताना BPF बायनरी कोड व्युत्पन्न करते.

तर्काचे अनुसरण करणे सोपे करण्यासाठी, आम्ही या हेतूंसाठी आमचे उदाहरण पुन्हा लिहू xdp-simple. या उदाहरणात चर्चा केलेल्या प्रोग्रामचा संपूर्ण आणि थोडा विस्तारित कोड यामध्ये आढळू शकतो सार.

आमच्या अर्जाचा तर्क खालीलप्रमाणे आहे:

एक प्रकारचा नकाशा तयार करा BPF_MAP_TYPE_ARRAY कमांड वापरून BPF_MAP_CREATE,
हा नकाशा वापरणारा प्रोग्राम तयार करा,
प्रोग्रामला इंटरफेसशी कनेक्ट करा lo,

ज्याचे भाषांतर माणसामध्ये असे होते

int main(void)
{
    int map_fd, prog_fd;

    map_fd = map_create();
    if (map_fd < 0)
        err(1, "bpf: BPF_MAP_CREATE");

    prog_fd = prog_load(map_fd);
    if (prog_fd < 0)
        err(1, "bpf: BPF_PROG_LOAD");

    xdp_attach(1, prog_fd);
}

तो आहे map_create आम्ही सिस्टम कॉलबद्दल पहिल्या उदाहरणात बनवल्याप्रमाणे नकाशा तयार करतो bpf - “कर्नल, कृपया मला 8 घटकांच्या अॅरेच्या स्वरूपात नवीन नकाशा बनवा __u64 आणि मला फाइल वर्णनकर्ता परत द्या":

static int map_create()
{
    union bpf_attr attr;

    memset(&attr, 0, sizeof(attr));
    attr.map_type = BPF_MAP_TYPE_ARRAY,
    attr.key_size = sizeof(__u32),
    attr.value_size = sizeof(__u64),
    attr.max_entries = 8,
    strncpy(attr.map_name, "woo", sizeof(attr.map_name));
    return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}

प्रोग्राम लोड करणे देखील सोपे आहे:

static int prog_load(int map_fd)
{
    union bpf_attr attr;
    struct bpf_insn insns[] = {
        ...
    };

    memset(&attr, 0, sizeof(attr));
    attr.prog_type = BPF_PROG_TYPE_XDP;
    attr.insns     = ptr_to_u64(insns);
    attr.insn_cnt  = sizeof(insns)/sizeof(insns[0]);
    attr.license   = ptr_to_u64("GPL");
    strncpy(attr.prog_name, "woo", sizeof(attr.prog_name));
    return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}

अवघड भाग prog_load आमच्या BPF प्रोग्रामची संरचनांची अॅरे म्हणून व्याख्या आहे struct bpf_insn insns[]. परंतु आम्ही C मध्ये असलेला प्रोग्राम वापरत असल्याने, आम्ही थोडी फसवणूक करू शकतो:

$ llvm-objdump -D --section xdp/simple xdp-simple.bpf.o

0000000000000000 <simple>:
       0:       85 00 00 00 08 00 00 00 call 8
       1:       63 0a fc ff 00 00 00 00 *(u32 *)(r10 - 4) = r0
       2:       bf a2 00 00 00 00 00 00 r2 = r10
       3:       07 02 00 00 fc ff ff ff r2 += -4
       4:       18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
       6:       85 00 00 00 01 00 00 00 call 1
       7:       b7 01 00 00 00 00 00 00 r1 = 0
       8:       15 00 04 00 00 00 00 00 if r0 == 0 goto +4 <LBB0_2>
       9:       61 01 00 00 00 00 00 00 r1 = *(u32 *)(r0 + 0)
      10:       07 01 00 00 01 00 00 00 r1 += 1
      11:       63 10 00 00 00 00 00 00 *(u32 *)(r0 + 0) = r1
      12:       b7 01 00 00 02 00 00 00 r1 = 2

0000000000000068 <LBB0_2>:
      13:       bf 10 00 00 00 00 00 00 r0 = r1
      14:       95 00 00 00 00 00 00 00 exit

एकूण, आपल्याला 14 सूचना रचनांच्या स्वरूपात लिहिण्याची आवश्यकता आहे struct bpf_insn (सल्ला: वरून डंप घ्या, सूचना विभाग पुन्हा वाचा, उघडा linux/bpf.h и linux/bpf_common.h आणि निश्चित करण्याचा प्रयत्न करा struct bpf_insn insns[] स्वतःहून):

struct bpf_insn insns[] = {
    /* 85 00 00 00 08 00 00 00 call 8 */
    {
        .code = BPF_JMP | BPF_CALL,
        .imm = 8,
    },

    /* 63 0a fc ff 00 00 00 00 *(u32 *)(r10 - 4) = r0 */
    {
        .code = BPF_MEM | BPF_STX,
        .off = -4,
        .src_reg = BPF_REG_0,
        .dst_reg = BPF_REG_10,
    },

    /* bf a2 00 00 00 00 00 00 r2 = r10 */
    {
        .code = BPF_ALU64 | BPF_MOV | BPF_X,
        .src_reg = BPF_REG_10,
        .dst_reg = BPF_REG_2,
    },

    /* 07 02 00 00 fc ff ff ff r2 += -4 */
    {
        .code = BPF_ALU64 | BPF_ADD | BPF_K,
        .dst_reg = BPF_REG_2,
        .imm = -4,
    },

    /* 18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll */
    {
        .code = BPF_LD | BPF_DW | BPF_IMM,
        .src_reg = BPF_PSEUDO_MAP_FD,
        .dst_reg = BPF_REG_1,
        .imm = map_fd,
    },
    { }, /* placeholder */

    /* 85 00 00 00 01 00 00 00 call 1 */
    {
        .code = BPF_JMP | BPF_CALL,
        .imm = 1,
    },

    /* b7 01 00 00 00 00 00 00 r1 = 0 */
    {
        .code = BPF_ALU64 | BPF_MOV | BPF_K,
        .dst_reg = BPF_REG_1,
        .imm = 0,
    },

    /* 15 00 04 00 00 00 00 00 if r0 == 0 goto +4 <LBB0_2> */
    {
        .code = BPF_JMP | BPF_JEQ | BPF_K,
        .off = 4,
        .src_reg = BPF_REG_0,
        .imm = 0,
    },

    /* 61 01 00 00 00 00 00 00 r1 = *(u32 *)(r0 + 0) */
    {
        .code = BPF_MEM | BPF_LDX,
        .off = 0,
        .src_reg = BPF_REG_0,
        .dst_reg = BPF_REG_1,
    },

    /* 07 01 00 00 01 00 00 00 r1 += 1 */
    {
        .code = BPF_ALU64 | BPF_ADD | BPF_K,
        .dst_reg = BPF_REG_1,
        .imm = 1,
    },

    /* 63 10 00 00 00 00 00 00 *(u32 *)(r0 + 0) = r1 */
    {
        .code = BPF_MEM | BPF_STX,
        .src_reg = BPF_REG_1,
        .dst_reg = BPF_REG_0,
    },

    /* b7 01 00 00 02 00 00 00 r1 = 2 */
    {
        .code = BPF_ALU64 | BPF_MOV | BPF_K,
        .dst_reg = BPF_REG_1,
        .imm = 2,
    },

    /* <LBB0_2>: bf 10 00 00 00 00 00 00 r0 = r1 */
    {
        .code = BPF_ALU64 | BPF_MOV | BPF_X,
        .src_reg = BPF_REG_1,
        .dst_reg = BPF_REG_0,
    },

    /* 95 00 00 00 00 00 00 00 exit */
    {
        .code = BPF_JMP | BPF_EXIT
    },
};

ज्यांनी हे स्वतः लिहिले नाही त्यांच्यासाठी एक व्यायाम - शोधा map_fd.

आमच्या कार्यक्रमात अजून एक अज्ञात भाग शिल्लक आहे - xdp_attach. दुर्दैवाने, XDP सारखे प्रोग्राम सिस्टम कॉल वापरून कनेक्ट केले जाऊ शकत नाहीत bpf. ज्या लोकांनी बीपीएफ आणि एक्सडीपी तयार केले ते ऑनलाइन लिनक्स समुदायातील होते, याचा अर्थ त्यांनी त्यांच्यासाठी सर्वात परिचित एक वापरला (परंतु नाही सामान्य लोक) कर्नलशी संवाद साधण्यासाठी इंटरफेस: नेटलिंक सॉकेट्स, देखील पहा आरएफसी 3549. अंमलबजावणी करण्याचा सर्वात सोपा मार्ग xdp_attach पासून कोड कॉपी करत आहे libbpf, म्हणजे, फाइलमधून netlink.c, जे आम्ही केले ते थोडेसे लहान करून:

नेटलिंक सॉकेट्सच्या जगात आपले स्वागत आहे

नेटलिंक सॉकेट प्रकार उघडा NETLINK_ROUTE:

int netlink_open(__u32 *nl_pid)
{
    struct sockaddr_nl sa;
    socklen_t addrlen;
    int one = 1, ret;
    int sock;

    memset(&sa, 0, sizeof(sa));
    sa.nl_family = AF_NETLINK;

    sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sock < 0)
        err(1, "socket");

    if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK, &one, sizeof(one)) < 0)
        warnx("netlink error reporting not supported");

    if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)
        err(1, "bind");

    addrlen = sizeof(sa);
    if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0)
        err(1, "getsockname");

    *nl_pid = sa.nl_pid;
    return sock;
}

आम्ही या सॉकेटमधून वाचतो:

static int bpf_netlink_recv(int sock, __u32 nl_pid, int seq)
{
    bool multipart = true;
    struct nlmsgerr *errm;
    struct nlmsghdr *nh;
    char buf[4096];
    int len, ret;

    while (multipart) {
        multipart = false;
        len = recv(sock, buf, sizeof(buf), 0);
        if (len < 0)
            err(1, "recv");

        if (len == 0)
            break;

        for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
                nh = NLMSG_NEXT(nh, len)) {
            if (nh->nlmsg_pid != nl_pid)
                errx(1, "wrong pid");
            if (nh->nlmsg_seq != seq)
                errx(1, "INVSEQ");
            if (nh->nlmsg_flags & NLM_F_MULTI)
                multipart = true;
            switch (nh->nlmsg_type) {
                case NLMSG_ERROR:
                    errm = (struct nlmsgerr *)NLMSG_DATA(nh);
                    if (!errm->error)
                        continue;
                    ret = errm->error;
                    // libbpf_nla_dump_errormsg(nh); too many code to copy...
                    goto done;
                case NLMSG_DONE:
                    return 0;
                default:
                    break;
            }
        }
    }
    ret = 0;
done:
    return ret;
}

शेवटी, येथे आमचे कार्य आहे जे सॉकेट उघडते आणि त्यास फाइल वर्णन करणारा एक विशेष संदेश पाठवते:

static int xdp_attach(int ifindex, int prog_fd)
{
    int sock, seq = 0, ret;
    struct nlattr *nla, *nla_xdp;
    struct {
        struct nlmsghdr  nh;
        struct ifinfomsg ifinfo;
        char             attrbuf[64];
    } req;
    __u32 nl_pid = 0;

    sock = netlink_open(&nl_pid);
    if (sock < 0)
        return sock;

    memset(&req, 0, sizeof(req));
    req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
    req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
    req.nh.nlmsg_type = RTM_SETLINK;
    req.nh.nlmsg_pid = 0;
    req.nh.nlmsg_seq = ++seq;
    req.ifinfo.ifi_family = AF_UNSPEC;
    req.ifinfo.ifi_index = ifindex;

    /* started nested attribute for XDP */
    nla = (struct nlattr *)(((char *)&req)
            + NLMSG_ALIGN(req.nh.nlmsg_len));
    nla->nla_type = NLA_F_NESTED | IFLA_XDP;
    nla->nla_len = NLA_HDRLEN;

    /* add XDP fd */
    nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len);
    nla_xdp->nla_type = IFLA_XDP_FD;
    nla_xdp->nla_len = NLA_HDRLEN + sizeof(int);
    memcpy((char *)nla_xdp + NLA_HDRLEN, &prog_fd, sizeof(prog_fd));
    nla->nla_len += nla_xdp->nla_len;

    /* if user passed in any flags, add those too */
    __u32 flags = XDP_FLAGS_SKB_MODE;
    nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len);
    nla_xdp->nla_type = IFLA_XDP_FLAGS;
    nla_xdp->nla_len = NLA_HDRLEN + sizeof(flags);
    memcpy((char *)nla_xdp + NLA_HDRLEN, &flags, sizeof(flags));
    nla->nla_len += nla_xdp->nla_len;

    req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len);

    if (send(sock, &req, req.nh.nlmsg_len, 0) < 0)
        err(1, "send");
    ret = bpf_netlink_recv(sock, nl_pid, seq);

cleanup:
    close(sock);
    return ret;
}

तर, सर्वकाही चाचणीसाठी तयार आहे:

$ cc nolibbpf.c -o nolibbpf
$ sudo strace -e bpf ./nolibbpf
bpf(BPF_MAP_CREATE, {map_type=BPF_MAP_TYPE_ARRAY, map_name="woo", ...}, 72) = 3
bpf(BPF_PROG_LOAD, {prog_type=BPF_PROG_TYPE_XDP, insn_cnt=15, prog_name="woo", ...}, 72) = 4
+++ exited with 0 +++

चला पाहूया आमच्या प्रोग्रामशी कनेक्ट झाला आहे का lo:

$ ip l show dev lo
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 xdpgeneric qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    prog/xdp id 160

चला पिंग्स पाठवू आणि नकाशा पाहू:

$ for s in `seq 234`; do sudo ping -f -c 100 127.0.0.1 >/dev/null 2>&1; done
$ sudo bpftool m dump name woo
key: 00 00 00 00  value: 90 01 00 00 00 00 00 00
key: 01 00 00 00  value: 00 00 00 00 00 00 00 00
key: 02 00 00 00  value: 00 00 00 00 00 00 00 00
key: 03 00 00 00  value: 00 00 00 00 00 00 00 00
key: 04 00 00 00  value: 00 00 00 00 00 00 00 00
key: 05 00 00 00  value: 00 00 00 00 00 00 00 00
key: 06 00 00 00  value: 40 b5 00 00 00 00 00 00
key: 07 00 00 00  value: 00 00 00 00 00 00 00 00
Found 8 elements

हुर्रे, सर्वकाही कार्य करते. लक्षात ठेवा, आमचा नकाशा पुन्हा बाइट्सच्या स्वरूपात प्रदर्शित झाला आहे. हे त्या वस्तुस्थितीमुळे आहे, विपरीत libbpf आम्ही प्रकार माहिती (BTF) लोड केली नाही. पण आम्ही पुढच्या वेळी याबद्दल अधिक बोलू.

विकास साधने

या विभागात, आम्ही किमान BPF विकसक टूलकिट पाहू.

सर्वसाधारणपणे, बीपीएफ प्रोग्राम विकसित करण्यासाठी तुम्हाला विशेष कशाचीही आवश्यकता नाही - बीपीएफ कोणत्याही सभ्य वितरण कर्नलवर चालते आणि प्रोग्राम वापरून तयार केले जातात clang, जे पॅकेजमधून पुरवले जाऊ शकते. तथापि, बीपीएफ विकासाधीन आहे या वस्तुस्थितीमुळे, कर्नल आणि साधने सतत बदलत आहेत, जर तुम्हाला 2019 पासून जुन्या पद्धतींचा वापर करून बीपीएफ प्रोग्राम लिहायचा नसेल, तर तुम्हाला संकलित करावे लागेल.

llvm/clang
pahole
त्याचा गाभा
bpftool

(संदर्भासाठी, हा विभाग आणि लेखातील सर्व उदाहरणे डेबियन 10 वर चालवली गेली होती.)

llvm/clang

BPF LLVM सह अनुकूल आहे आणि, जरी अलीकडे BPF साठी कार्यक्रम gcc वापरून संकलित केले जाऊ शकतात, तरीही सर्व चालू विकास LLVM साठी केला जातो. म्हणून, सर्व प्रथम, आम्ही वर्तमान आवृत्ती तयार करू clang git वरून:

$ sudo apt install ninja-build
$ git clone --depth 1 https://github.com/llvm/llvm-project.git
$ mkdir -p llvm-project/llvm/build/install
$ cd llvm-project/llvm/build
$ cmake .. -G "Ninja" -DLLVM_TARGETS_TO_BUILD="BPF;X86" 
                      -DLLVM_ENABLE_PROJECTS="clang" 
                      -DBUILD_SHARED_LIBS=OFF 
                      -DCMAKE_BUILD_TYPE=Release 
                      -DLLVM_BUILD_RUNTIME=OFF
$ time ninja
... много времени спустя
$

आता आम्ही सर्वकाही योग्यरित्या एकत्र आले की नाही हे तपासू शकतो:

$ ./bin/llc --version
LLVM (http://llvm.org/):
  LLVM version 11.0.0git
  Optimized build.
  Default target: x86_64-unknown-linux-gnu
  Host CPU: znver1

  Registered Targets:
    bpf    - BPF (host endian)
    bpfeb  - BPF (big endian)
    bpfel  - BPF (little endian)
    x86    - 32-bit X86: Pentium-Pro and above
    x86-64 - 64-bit X86: EM64T and AMD64

(विधानसभा सूचना clang माझ्याकडून घेतले bpf_devel_QA.)

आम्ही नुकतेच तयार केलेले प्रोग्राम स्थापित करणार नाही, परंतु त्याऐवजी त्यांना जोडू PATH, उदाहरणार्थ:

export PATH="`pwd`/bin:$PATH"

(हे यात जोडले जाऊ शकते .bashrc किंवा वेगळ्या फाईलमध्ये. वैयक्तिकरित्या, मी यासारख्या गोष्टी जोडतो ~/bin/activate-llvm.sh आणि जेव्हा आवश्यक असेल तेव्हा मी ते करतो . activate-llvm.sh.)

Pahole आणि BTF

उपयुक्तता pahole बीटीएफ फॉरमॅटमध्ये डीबगिंग माहिती तयार करण्यासाठी कर्नल तयार करताना वापरले जाते. आम्ही या लेखात BTF तंत्रज्ञानाच्या तपशीलांबद्दल तपशीलात जाणार नाही, त्याशिवाय ते सोयीचे आहे आणि आम्हाला ते वापरायचे आहे. म्हणून जर तुम्ही तुमचा कर्नल तयार करणार असाल तर प्रथम तयार करा pahole (विना pahole तुम्ही पर्यायासह कर्नल तयार करू शकणार नाही CONFIG_DEBUG_INFO_BTF:

$ git clone https://git.kernel.org/pub/scm/devel/pahole/pahole.git
$ cd pahole/
$ sudo apt install cmake
$ mkdir build
$ cd build/
$ cmake -D__LIB=lib ..
$ make
$ sudo make install
$ which pahole
/usr/local/bin/pahole

BPF सह प्रयोग करण्यासाठी कर्नल

BPF च्या शक्यतांचा शोध घेत असताना, मला माझा स्वतःचा गाभा एकत्र करायचा आहे. सर्वसाधारणपणे, हे आवश्यक नाही, कारण तुम्ही वितरण कर्नलवर बीपीएफ प्रोग्राम्स संकलित आणि लोड करण्यास सक्षम असाल, तथापि, तुमचा स्वतःचा कर्नल तुम्हाला नवीनतम बीपीएफ वैशिष्ट्ये वापरण्याची परवानगी देतो, जी तुमच्या वितरणामध्ये महिन्यांत उत्तम प्रकारे दिसून येईल. , किंवा, काही डीबगिंग साधनांच्या बाबतीत नजीकच्या भविष्यात अजिबात पॅकेज केले जाणार नाही. तसेच, स्वतःच्या गाभ्यामुळे संहितेचा प्रयोग करणे महत्त्वाचे वाटते.

कर्नल तयार करण्यासाठी तुम्हाला प्रथम, कर्नल स्वतः आणि दुसरे म्हणजे, कर्नल कॉन्फिगरेशन फाइल आवश्यक आहे. बीपीएफचा प्रयोग करण्यासाठी आपण नेहमीचा वापरु शकतो व्हॅनिला कर्नल किंवा विकास कर्नलपैकी एक. ऐतिहासिकदृष्ट्या, बीपीएफ विकास लिनक्स नेटवर्किंग समुदायामध्ये होतो आणि म्हणूनच सर्व बदल लवकर किंवा नंतर डेव्हिड मिलर, लिनक्स नेटवर्किंग मेंटेनरद्वारे होतात. त्यांच्या स्वभावानुसार - संपादने किंवा नवीन वैशिष्ट्ये - नेटवर्क बदल दोनपैकी एका कोरमध्ये येतात - net किंवा net-next. BPF साठी बदल दरम्यान समान प्रकारे वितरीत केले जातात bpf и bpf-next, जे नंतर अनुक्रमे नेट आणि नेट-नेक्स्टमध्ये एकत्र केले जातात. अधिक तपशीलांसाठी, पहा bpf_devel_QA и netdev-FAQ. त्यामुळे तुमची चव आणि तुम्ही चाचणी करत असलेल्या प्रणालीच्या स्थिरतेच्या गरजांवर आधारित कर्नल निवडा (*-next कर्नल सूचीबद्ध केलेल्यांपैकी सर्वात अस्थिर आहेत).

कर्नल कॉन्फिगरेशन फाइल्स कशा व्यवस्थापित करायच्या याबद्दल बोलणे या लेखाच्या व्याप्तीच्या पलीकडे आहे - असे गृहीत धरले जाते की हे कसे करायचे हे तुम्हाला आधीच माहित आहे किंवा शिकण्यासाठी तयार स्वतःहून. तथापि, तुम्हाला कार्यरत BPF-सक्षम प्रणाली देण्यासाठी खालील सूचना कमी-अधिक प्रमाणात असाव्यात.

वरील कर्नलपैकी एक डाउनलोड करा:

$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git
$ cd bpf-next

किमान कार्यरत कर्नल कॉन्फिगरेशन तयार करा:

$ cp /boot/config-`uname -r` .config
$ make localmodconfig

फाइलमध्ये बीपीएफ पर्याय सक्षम करा .config तुमच्या स्वतःच्या निवडीनुसार (बहुधा CONFIG_BPF systemd वापरत असल्याने आधीच सक्षम केले जाईल). या लेखासाठी वापरलेल्या कर्नलमधील पर्यायांची यादी येथे आहे:

CONFIG_CGROUP_BPF=y
CONFIG_BPF=y
CONFIG_BPF_LSM=y
CONFIG_BPF_SYSCALL=y
CONFIG_ARCH_WANT_DEFAULT_BPF_JIT=y
CONFIG_BPF_JIT_ALWAYS_ON=y
CONFIG_BPF_JIT_DEFAULT_ON=y
CONFIG_IPV6_SEG6_BPF=y
# CONFIG_NETFILTER_XT_MATCH_BPF is not set
# CONFIG_BPFILTER is not set
CONFIG_NET_CLS_BPF=y
CONFIG_NET_ACT_BPF=y
CONFIG_BPF_JIT=y
CONFIG_BPF_STREAM_PARSER=y
CONFIG_LWTUNNEL_BPF=y
CONFIG_HAVE_EBPF_JIT=y
CONFIG_BPF_EVENTS=y
CONFIG_BPF_KPROBE_OVERRIDE=y
CONFIG_DEBUG_INFO_BTF=y

मग आम्ही मॉड्यूल्स आणि कर्नल सहजपणे एकत्र आणि स्थापित करू शकतो (तसे, तुम्ही नवीन असेंबल वापरून कर्नल एकत्र करू शकता. clangमिळवून CC=clang):

$ make -s -j $(getconf _NPROCESSORS_ONLN)
$ sudo make modules_install
$ sudo make install

आणि नवीन कर्नलसह रीबूट करा (मी यासाठी वापरतो kexec पॅकेजमधून kexec-tools):

v=5.8.0-rc6+ # если вы пересобираете текущее ядро, то можно делать v=`uname -r`
sudo kexec -l -t bzImage /boot/vmlinuz-$v --initrd=/boot/initrd.img-$v --reuse-cmdline &&
sudo kexec -e

bpftool

लेखातील सर्वात सामान्यपणे वापरली जाणारी उपयुक्तता असेल bpftool, लिनक्स कर्नलचा भाग म्हणून पुरवले जाते. हे BPF विकसकांसाठी BPF विकसकांद्वारे लिहिलेले आणि देखरेख केले जाते आणि सर्व प्रकारच्या BPF वस्तू व्यवस्थापित करण्यासाठी वापरले जाऊ शकते - प्रोग्राम लोड करणे, नकाशे तयार करणे आणि संपादित करणे, BPF इकोसिस्टमचे जीवन एक्सप्लोर करणे इ. मॅन पृष्ठांसाठी स्त्रोत कोडच्या स्वरूपात दस्तऐवजीकरण आढळू शकते कोर मध्ये किंवा, आधीच संकलित, नेटवर.

या लेखनाच्या वेळी bpftool फक्त RHEL, Fedora आणि Ubuntu साठी रेडीमेड येते (पहा, उदाहरणार्थ, हा धागा, जे पॅकेजिंगची अपूर्ण कथा सांगते bpftool डेबियन मध्ये). परंतु जर तुम्ही तुमचे कर्नल आधीच तयार केले असेल तर तयार करा bpftool पाईसारखे सोपे:

$ cd ${linux}/tools/bpf/bpftool
# ... пропишите пути к последнему clang, как рассказано выше
$ make -s

Auto-detecting system features:
...                        libbfd: [ on  ]
...        disassembler-four-args: [ on  ]
...                          zlib: [ on  ]
...                        libcap: [ on  ]
...               clang-bpf-co-re: [ on  ]

Auto-detecting system features:
...                        libelf: [ on  ]
...                          zlib: [ on  ]
...                           bpf: [ on  ]

$

(येथे ${linux} - ही तुमची कर्नल डिरेक्टरी आहे.) या कमांड्स कार्यान्वित केल्यानंतर bpftool निर्देशिकेत गोळा केले जाईल ${linux}/tools/bpf/bpftool आणि ते मार्गात जोडले जाऊ शकते (सर्व प्रथम वापरकर्त्यासाठी root) किंवा फक्त कॉपी करा /usr/local/sbin.

गोळा करा bpftool नंतरचे वापरणे चांगले clang, वर वर्णन केल्याप्रमाणे एकत्र केले आहे, आणि ते योग्यरित्या एकत्र केले आहे की नाही ते तपासा - उदाहरणार्थ, कमांड वापरून

$ sudo bpftool feature probe kernel
Scanning system configuration...
bpf() syscall for unprivileged users is enabled
JIT compiler is enabled
JIT compiler hardening is disabled
JIT compiler kallsyms exports are enabled for root
...

जे तुमच्या कर्नलमध्ये कोणती BPF वैशिष्ट्ये सक्षम आहेत हे दर्शवेल.

तसे, मागील कमांड म्हणून चालविली जाऊ शकते

# bpftool f p k

हे पॅकेजमधील युटिलिटिजच्या सादृश्याने केले जाते iproute2, जिथे आपण, उदाहरणार्थ, म्हणू शकतो ip a s eth0 त्याऐवजी ip addr show dev eth0.

निष्कर्ष

BPF तुम्हाला प्रभावीपणे मोजण्यासाठी आणि जाता-जाता कोरची कार्यक्षमता बदलण्यासाठी पिसूला जोडण्याची परवानगी देते. युनिक्सच्या सर्वोत्कृष्ट परंपरांमध्ये ही प्रणाली खूप यशस्वी ठरली: एक साधी यंत्रणा जी तुम्हाला कर्नल प्रोग्राम (पुन्हा) करण्याची परवानगी देते ज्यामुळे मोठ्या संख्येने लोक आणि संस्थांना प्रयोग करण्याची परवानगी मिळते. आणि, जरी प्रयोग, तसेच BPF पायाभूत सुविधांचा विकास, पूर्ण होण्यापासून खूप दूर असले तरी, सिस्टममध्ये आधीपासूनच एक स्थिर ABI आहे जो तुम्हाला विश्वासार्ह आणि सर्वात महत्त्वाचे म्हणजे प्रभावी व्यवसाय तर्क तयार करण्यास अनुमती देतो.

मी हे लक्षात घेऊ इच्छितो की, माझ्या मते, तंत्रज्ञान इतके लोकप्रिय झाले आहे कारण, एकीकडे, ते करू शकते खेळणे (एखाद्या यंत्राचे आर्किटेक्चर एका संध्याकाळी कमी-अधिक प्रमाणात समजले जाऊ शकते), आणि दुसरीकडे, त्याच्या देखाव्यापूर्वी (सुंदरपणे) सोडवता न येणाऱ्या समस्यांचे निराकरण करण्यासाठी. हे दोन घटक एकत्रितपणे लोकांना प्रयोग करण्यास आणि स्वप्न पाहण्यास भाग पाडतात, ज्यामुळे अधिकाधिक नाविन्यपूर्ण उपायांचा उदय होतो.

हा लेख, जरी विशेषतः लहान नसला तरी, BPF च्या जगाचा केवळ परिचय आहे आणि "प्रगत" वैशिष्ट्ये आणि आर्किटेक्चरच्या महत्त्वपूर्ण भागांचे वर्णन करत नाही. पुढे जाणारी योजना अशी आहे: पुढील लेख BPF प्रोग्राम प्रकारांचे विहंगावलोकन असेल (5.8 कर्नलमध्ये 30 प्रोग्राम प्रकार समर्थित आहेत), नंतर आम्ही शेवटी कर्नल ट्रेसिंग प्रोग्राम वापरून वास्तविक BPF अनुप्रयोग कसे लिहायचे ते पाहू. उदाहरण म्हणून, BPF आर्किटेक्चरच्या अधिक सखोल अभ्यासक्रमासाठी, त्यानंतर BPF नेटवर्किंग आणि सुरक्षा अनुप्रयोगांची उदाहरणे देण्याची वेळ आली आहे.

या मालिकेतील मागील लेख

लहान मुलांसाठी BPF, भाग शून्य: क्लासिक BPF

दुवे

BPF आणि XDP संदर्भ मार्गदर्शक — सिलियम वरून BPF वर दस्तऐवजीकरण, किंवा अधिक तंतोतंत डॅनियल बोर्कमन, BPF चे निर्माते आणि देखभाल करणार्‍यांपैकी एक. हे पहिले गंभीर वर्णनांपैकी एक आहे, जे इतरांपेक्षा वेगळे आहे की डॅनियलला माहित आहे की तो कशाबद्दल लिहित आहे आणि तेथे कोणत्याही चुका नाहीत. विशेषतः, हा दस्तऐवज सुप्रसिद्ध युटिलिटी वापरून XDP आणि TC प्रकारच्या BPF प्रोग्रामसह कसे कार्य करावे याचे वर्णन करतो. ip पॅकेजमधून iproute2.
Documentation/networking/filter.txt - क्लासिक आणि नंतर विस्तारित बीपीएफसाठी कागदपत्रांसह मूळ फाइल. जर तुम्हाला असेंब्ली भाषा आणि तांत्रिक वास्तुशास्त्रीय तपशीलांचा अभ्यास करायचा असेल तर चांगले वाचन.
फेसबुक वरून BPF बद्दल ब्लॉग. अलेक्सी स्टारोवोइटोव्ह (eBPF चे लेखक) आणि Andrii Nakryiko - (देखभाल करणारा) तेथे लिहिल्याप्रमाणे ते क्वचितच, परंतु योग्यरित्या अद्यतनित केले जाते. libbpf).
bpftool चे रहस्य. बीपीएफटूल वापरण्याची उदाहरणे आणि रहस्यांसह क्वेंटिन मोनेटचा एक मनोरंजक ट्विटर थ्रेड.
BPF मध्ये जा: वाचन सामग्रीची यादी. Quentin Monnet कडून BPF दस्तऐवजीकरणाच्या लिंक्सची एक विशाल (आणि अजूनही राखलेली) सूची.

स्त्रोत: www.habr.com

लहान मुलांसाठी बीपीएफ, भाग एक: विस्तारित बीपीएफ