छोटों के लिए बीपीएफ, भाग एक: विस्तारित बीपीएफ

शुरुआत में एक टेक्नोलॉजी थी और उसे BPF कहा जाता था. हमने उसकी ओर देखा पिछला, इस श्रृंखला का पुराना नियम लेख। 2013 में, एलेक्सी स्टारोवोइटोव और डैनियल बोर्कमैन के प्रयासों से, आधुनिक 64-बिट मशीनों के लिए अनुकूलित इसका एक उन्नत संस्करण विकसित किया गया और लिनक्स कर्नेल में शामिल किया गया। इस नई तकनीक को संक्षेप में आंतरिक बीपीएफ कहा गया, फिर इसका नाम विस्तारित बीपीएफ रखा गया, और अब, कई वर्षों के बाद, हर कोई इसे बस बीपीएफ कहता है।

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

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

लेख का सारांश

बीपीएफ आर्किटेक्चर का परिचय। सबसे पहले, हम बीपीएफ वास्तुकला पर एक विहंगम दृष्टि डालेंगे और मुख्य घटकों की रूपरेखा तैयार करेंगे।

बीपीएफ वर्चुअल मशीन के रजिस्टर और कमांड सिस्टम। समग्र रूप से वास्तुकला का पहले से ही एक विचार रखते हुए, हम बीपीएफ वर्चुअल मशीन की संरचना का वर्णन करेंगे।

BPF ऑब्जेक्ट का जीवन चक्र, bpffs फ़ाइल सिस्टम। इस खंड में, हम बीपीएफ वस्तुओं - कार्यक्रमों और मानचित्रों के जीवन चक्र पर करीब से नज़र डालेंगे।

बीपीएफ सिस्टम कॉल का उपयोग करके वस्तुओं का प्रबंधन करना। सिस्टम की पहले से ही कुछ समझ के साथ, हम अंततः देखेंगे कि एक विशेष सिस्टम कॉल का उपयोग करके उपयोगकर्ता स्थान से ऑब्जेक्ट कैसे बनाएं और हेरफेर करें - bpf(2).

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

कर्नेल सहायक. यहां हम सीखेंगे कि बीपीएफ प्रोग्राम कर्नेल हेल्पर फ़ंक्शंस तक कैसे पहुंच सकते हैं - एक उपकरण जो मानचित्रों के साथ, क्लासिक बीपीएफ की तुलना में नए बीपीएफ की क्षमताओं को मौलिक रूप से विस्तारित करता है।

बीपीएफ कार्यक्रमों से मानचित्रों तक पहुंच। इस बिंदु तक, हम यह समझने के लिए पर्याप्त रूप से जान जाएंगे कि हम मानचित्रों का उपयोग करने वाले प्रोग्राम कैसे बना सकते हैं। और आइए महान और शक्तिशाली सत्यापनकर्ता पर एक नज़र डालें।

विकास उपकरण। प्रयोगों के लिए आवश्यक उपयोगिताओं और कर्नेल को कैसे इकट्ठा किया जाए, इस पर सहायता अनुभाग।

निष्कर्ष. लेख के अंत में, जिन लोगों ने इसे अब तक पढ़ा है उन्हें प्रेरक शब्द मिलेंगे और निम्नलिखित लेखों में क्या होगा इसका संक्षिप्त विवरण मिलेगा। हम उन लोगों के लिए स्व-अध्ययन के लिए कई लिंक भी सूचीबद्ध करेंगे जिनके पास निरंतरता की प्रतीक्षा करने की इच्छा या क्षमता नहीं है।

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

इससे पहले कि हम बीपीएफ आर्किटेक्चर पर विचार करना शुरू करें, हम आखिरी बार (ओह) इसका संदर्भ लेंगे क्लासिक बीपीएफ, जिसे आरआईएससी मशीनों के आगमन की प्रतिक्रिया के रूप में विकसित किया गया था और कुशल पैकेट फ़िल्टरिंग की समस्या को हल किया गया था। आर्किटेक्चर इतना सफल साबित हुआ कि, बर्कले यूनिक्स में नब्बे के दशक में पैदा होने के बाद, इसे अधिकांश मौजूदा ऑपरेटिंग सिस्टम में पोर्ट किया गया, बीस के दशक में जीवित रहा और अभी भी नए एप्लिकेशन ढूंढ रहा है।

नया बीपीएफ 64-बिट मशीनों, क्लाउड सेवाओं की सर्वव्यापकता और एसडीएन बनाने के लिए उपकरणों की बढ़ती आवश्यकता की प्रतिक्रिया के रूप में विकसित किया गया था।Sसॉफ़्टवेयर-dपरिष्कृत nनेटवर्किंग)। क्लासिक बीपीएफ के बेहतर प्रतिस्थापन के रूप में कर्नेल नेटवर्क इंजीनियरों द्वारा विकसित, नए बीपीएफ को वस्तुतः छह महीने बाद लिनक्स सिस्टम को ट्रेस करने के कठिन कार्य में अनुप्रयोग मिला, और अब, इसकी उपस्थिति के छह साल बाद, हमें बस इसके लिए एक पूरे अगले लेख की आवश्यकता होगी विभिन्न प्रकार के कार्यक्रमों की सूची बनाएं।

मज़ाकिया तस्वीर

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

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

बीपीएफ आर्किटेक्चर को, आंशिक रूप से, आधुनिक मशीनों पर कुशलतापूर्वक चलाने के लिए डिज़ाइन किया गया था। इस कार्य को व्यवहार में लाने के लिए, BPF बाइटकोड, एक बार कर्नेल में लोड हो जाने पर, JIT कंपाइलर नामक घटक का उपयोग करके मूल कोड में अनुवादित किया जाता है (Jउस्त In Time)। आगे, यदि आपको याद हो, तो क्लासिक बीपीएफ में प्रोग्राम को कर्नेल में लोड किया गया था और परमाणु रूप से ईवेंट स्रोत से जोड़ा गया था - एकल सिस्टम कॉल के संदर्भ में। नए आर्किटेक्चर में, यह दो चरणों में होता है - पहला, सिस्टम कॉल का उपयोग करके कोड को कर्नेल में लोड किया जाता है bpf(2)और फिर, बाद में, अन्य तंत्रों के माध्यम से जो प्रोग्राम के प्रकार के आधार पर भिन्न होते हैं, प्रोग्राम इवेंट स्रोत से जुड़ जाता है।

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

सत्यापनकर्ता एक स्थैतिक विश्लेषक है जो यह सुनिश्चित करता है कि कोई प्रोग्राम कर्नेल के सामान्य संचालन को बाधित नहीं करता है। वैसे, इसका मतलब यह नहीं है कि प्रोग्राम सिस्टम के संचालन में हस्तक्षेप नहीं कर सकता है - बीपीएफ प्रोग्राम, प्रकार के आधार पर, कर्नेल मेमोरी के अनुभागों को पढ़ और फिर से लिख सकते हैं, फ़ंक्शन के मान लौटा सकते हैं, ट्रिम कर सकते हैं, जोड़ सकते हैं, फिर से लिख सकते हैं और यहां तक ​​कि नेटवर्क पैकेट भी अग्रेषित करें। सत्यापनकर्ता गारंटी देता है कि बीपीएफ प्रोग्राम चलाने से कर्नेल क्रैश नहीं होगा और एक प्रोग्राम, जिसके पास नियमों के अनुसार, लिखने की पहुंच है, उदाहरण के लिए, एक आउटगोइंग पैकेट का डेटा, पैकेट के बाहर कर्नेल मेमोरी को ओवरराइट करने में सक्षम नहीं होगा। बीपीएफ के अन्य सभी घटकों से परिचित होने के बाद, हम संबंधित अनुभाग में सत्यापनकर्ता को थोड़ा और विस्तार से देखेंगे।

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

चौकस पाठक देख सकते हैं कि हमने अभी तक चित्रों का अध्ययन समाप्त नहीं किया है। दरअसल, उपरोक्त सभी यह नहीं समझाते हैं कि क्लासिक बीपीएफ की तुलना में बीपीएफ मौलिक रूप से तस्वीर क्यों बदलता है। दो नवाचार जो प्रयोज्यता के दायरे को महत्वपूर्ण रूप से विस्तारित करते हैं, वे हैं साझा मेमोरी और कर्नेल हेल्पर फ़ंक्शंस का उपयोग करने की क्षमता। बीपीएफ में, साझा मेमोरी को तथाकथित मानचित्रों - एक विशिष्ट एपीआई के साथ साझा डेटा संरचनाओं का उपयोग करके कार्यान्वित किया जाता है। उन्हें यह नाम संभवतः इसलिए मिला क्योंकि प्रदर्शित होने वाला पहला प्रकार का मानचित्र एक हैश तालिका थी। फिर सरणियाँ दिखाई दीं, स्थानीय (प्रति-सीपीयू) हैश टेबल और स्थानीय सरणियाँ, खोज पेड़, बीपीएफ कार्यक्रमों के संकेतक वाले मानचित्र और बहुत कुछ। अब हमारे लिए दिलचस्प बात यह है कि बीपीएफ कार्यक्रमों में अब कॉल के बीच स्थिति को बनाए रखने और इसे अन्य कार्यक्रमों और उपयोगकर्ता स्थान के साथ साझा करने की क्षमता है।

सिस्टम कॉल का उपयोग करके उपयोगकर्ता प्रक्रियाओं से मानचित्र तक पहुंच प्राप्त की जाती है bpf(2), और सहायक फ़ंक्शंस का उपयोग करके कर्नेल में चल रहे बीपीएफ प्रोग्राम से। इसके अलावा, सहायक न केवल मानचित्रों के साथ काम करने के लिए मौजूद हैं, बल्कि अन्य कर्नेल क्षमताओं तक पहुंचने के लिए भी मौजूद हैं। उदाहरण के लिए, बीपीएफ प्रोग्राम पैकेट को अन्य इंटरफेस पर अग्रेषित करने, पूर्ण ईवेंट उत्पन्न करने, कर्नेल संरचनाओं तक पहुंचने आदि के लिए सहायक कार्यों का उपयोग कर सकते हैं।

संक्षेप में, बीपीएफ मनमाने ढंग से, यानी, सत्यापनकर्ता-परीक्षणित, उपयोगकर्ता कोड को कर्नेल स्पेस में लोड करने की क्षमता प्रदान करता है। यह कोड कॉल के बीच स्थिति को बचा सकता है और उपयोगकर्ता स्थान के साथ डेटा का आदान-प्रदान कर सकता है, और इस प्रकार के प्रोग्राम द्वारा अनुमत कर्नेल सबसिस्टम तक पहुंच भी है।

यह पहले से ही कर्नेल मॉड्यूल द्वारा प्रदान की गई क्षमताओं के समान है, जिसकी तुलना में बीपीएफ के कुछ फायदे हैं (बेशक, आप केवल समान अनुप्रयोगों की तुलना कर सकते हैं, उदाहरण के लिए, सिस्टम ट्रेसिंग - आप बीपीएफ के साथ एक मनमाना ड्राइवर नहीं लिख सकते हैं)। आप कम प्रवेश सीमा नोट कर सकते हैं (बीपीएफ का उपयोग करने वाली कुछ उपयोगिताओं के लिए उपयोगकर्ता को कर्नेल प्रोग्रामिंग कौशल, या सामान्य रूप से प्रोग्रामिंग कौशल की आवश्यकता नहीं होती है), रनटाइम सुरक्षा (उन लोगों के लिए टिप्पणियों में अपना हाथ उठाएं जिन्होंने लिखते समय सिस्टम को नहीं तोड़ा है या परीक्षण मॉड्यूल), परमाणुता - मॉड्यूल को पुनः लोड करते समय डाउनटाइम होता है, और बीपीएफ सबसिस्टम यह सुनिश्चित करता है कि कोई भी घटना छूट न जाए (निष्पक्ष होने के लिए, यह सभी प्रकार के बीपीएफ कार्यक्रमों के लिए सच नहीं है)।

ऐसी क्षमताओं की उपस्थिति बीपीएफ को कर्नेल के विस्तार के लिए एक सार्वभौमिक उपकरण बनाती है, जिसकी पुष्टि व्यवहार में की जाती है: अधिक से अधिक नए प्रकार के प्रोग्राम बीपीएफ में जोड़े जाते हैं, अधिक से अधिक बड़ी कंपनियां 24×7 लड़ाकू सर्वर पर बीपीएफ का उपयोग करती हैं, अधिक से अधिक स्टार्टअप अपना व्यवसाय उन समाधानों पर बनाते हैं जो बीपीएफ पर आधारित होते हैं। बीपीएफ का उपयोग हर जगह किया जाता है: डीडीओएस हमलों से बचाने में, एसडीएन बनाने में (उदाहरण के लिए, कुबेरनेट्स के लिए नेटवर्क लागू करना), मुख्य सिस्टम ट्रेसिंग टूल और सांख्यिकी संग्राहक के रूप में, घुसपैठ का पता लगाने वाले सिस्टम और सैंडबॉक्स सिस्टम आदि में।

आइए लेख के अवलोकन भाग को यहीं समाप्त करें और वर्चुअल मशीन और बीपीएफ पारिस्थितिकी तंत्र को अधिक विस्तार से देखें।

विषयांतर: उपयोगिताएँ

निम्नलिखित अनुभागों में उदाहरण चलाने में सक्षम होने के लिए, आपको कम से कम कई उपयोगिताओं की आवश्यकता हो सकती है llvm/clang बीपीएफ समर्थन के साथ और bpftool। अनुभाग में विकास उपकरण आप उपयोगिताओं को असेंबल करने के निर्देशों के साथ-साथ अपने कर्नेल को भी पढ़ सकते हैं। यह अनुभाग नीचे रखा गया है ताकि हमारी प्रस्तुति के सामंजस्य में खलल न पड़े।

बीपीएफ वर्चुअल मशीन रजिस्टर और निर्देश प्रणाली

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

बीपीएफ में ग्यारह उपयोगकर्ता-सुलभ 64-बिट रजिस्टर हैं r0-r10 और एक प्रोग्राम काउंटर. पंजीकरण करवाना r10 इसमें एक फ़्रेम पॉइंटर होता है और यह केवल-पढ़ने के लिए होता है। प्रोग्राम के पास रनटाइम पर 512-बाइट स्टैक और मानचित्रों के रूप में असीमित मात्रा में साझा मेमोरी तक पहुंच होती है।

बीपीएफ प्रोग्राम को प्रोग्राम-प्रकार के कर्नेल हेल्पर्स का एक विशिष्ट सेट और, हाल ही में, नियमित फ़ंक्शन चलाने की अनुमति है। प्रत्येक कॉल किए गए फ़ंक्शन में रजिस्टरों में पारित पांच तर्क तक हो सकते हैं r1-r5, और रिटर्न वैल्यू को पास कर दिया गया है r0. यह गारंटी दी जाती है कि फ़ंक्शन से लौटने के बाद, रजिस्टरों की सामग्री r6-r9 नहीं बदलेगा।

कुशल प्रोग्राम अनुवाद के लिए, रजिस्टर करें r0-r11 वर्तमान आर्किटेक्चर की एबीआई विशेषताओं को ध्यान में रखते हुए, सभी समर्थित आर्किटेक्चर को विशिष्ट रूप से वास्तविक रजिस्टरों में मैप किया जाता है। उदाहरण के लिए, के लिए 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 (एक्सडीपी के लिए) या संरचना struct __sk_buff (विभिन्न नेटवर्क प्रोग्राम के लिए) या संरचना struct pt_regs (विभिन्न प्रकार के ट्रेसिंग प्रोग्राम के लिए), आदि।

तो, हमारे पास रजिस्टरों, कर्नेल हेल्पर्स, एक स्टैक, एक संदर्भ सूचक और मानचित्रों के रूप में साझा मेमोरी का एक सेट था। ऐसा नहीं है कि यात्रा पर यह सब बिल्कुल जरूरी है, लेकिन...

आइए विवरण जारी रखें और इन वस्तुओं के साथ काम करने के लिए कमांड सिस्टम के बारे में बात करें। सभी (लगभग सभी) बीपीएफ निर्देशों का एक निश्चित 64-बिट आकार होता है। यदि आप 64-बिट बिग एंडियन मशीन पर एक निर्देश देखेंगे तो आप देखेंगे

यहां Code - यह निर्देश का एन्कोडिंग है, Dst/Src क्रमशः रिसीवर और स्रोत की एन्कोडिंग हैं, Off - 16-बिट हस्ताक्षरित इंडेंटेशन, और Imm एक 32-बिट हस्ताक्षरित पूर्णांक है जिसका उपयोग कुछ निर्देशों में किया जाता है (सीबीपीएफ स्थिरांक K के समान)। एन्कोडिंग 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.h и bpf_common.h, जो बीपीएफ निर्देशों के संख्यात्मक कोड को परिभाषित करते हैं। स्वयं वास्तुकला का अध्ययन करते समय और/या बायनेरिज़ को पार्स करते समय, आप जटिलता के क्रम में क्रमबद्ध निम्नलिखित स्रोतों में शब्दार्थ पा सकते हैं: अनौपचारिक ईबीपीएफ विशिष्टता, बीपीएफ और एक्सडीपी संदर्भ गाइड, निर्देश सेट, दस्तावेज़ीकरण/नेटवर्किंग/फ़िल्टर.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. इसके अलावा, जेएमपी क्लास 1 ऑपरेशन है बीपीएफ_जेईक्यू (यदि बराबर हो तो कूदें)। हमारे मामले में, बिट के बाद से S शून्य है, यह फ़ील्ड के साथ स्रोत रजिस्टर के मूल्य की तुलना करता है Imm. यदि मान मेल खाते हैं, तो संक्रमण होता है PC + Offजहां PC, हमेशा की तरह, अगले निर्देश का पता शामिल है। अंत में, जेएमपी क्लास 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, जब हम स्थानांतरण और मानचित्रों के साथ काम करने के बारे में बात करते हैं।

उदाहरण: मानक उपकरणों का उपयोग करके बीपीएफ को अलग करना

इसलिए, हमने बीपीएफ बाइनरी कोड पढ़ना सीख लिया है और यदि आवश्यक हो तो किसी भी निर्देश को पार्स करने के लिए तैयार हैं। हालाँकि, यह कहने योग्य है कि व्यवहार में मानक टूल का उपयोग करके प्रोग्राम को अलग करना अधिक सुविधाजनक और तेज़ है, उदाहरण के लिए:

$ 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 ऑब्जेक्ट का जीवनचक्र, bpffs फ़ाइल सिस्टम

(मैंने सबसे पहले इस उपधारा में वर्णित कुछ विवरण यहां से सीखे रोज़ा एलेक्सी स्टारोवोइटोव में बीपीएफ ब्लॉग.)

बीपीएफ ऑब्जेक्ट - प्रोग्राम और मानचित्र - कमांड का उपयोग करके उपयोगकर्ता स्थान से बनाए जाते हैं BPF_PROG_LOAD и BPF_MAP_CREATE सिस्टम कॉल bpf(2), हम अगले भाग में इस बारे में बात करेंगे कि यह वास्तव में कैसे होता है। यह उनमें से प्रत्येक के लिए कर्नेल डेटा संरचनाएँ बनाता है refcount (संदर्भ गणना) को एक पर सेट किया जाता है, और ऑब्जेक्ट की ओर इशारा करने वाला एक फ़ाइल डिस्क्रिप्टर उपयोगकर्ता को वापस कर दिया जाता है। हैंडल बंद होने के बाद refcount वस्तु एक से कम हो जाती है, और जब यह शून्य पर पहुंच जाती है, तो वस्तु नष्ट हो जाती है।

यदि प्रोग्राम मानचित्रों का उपयोग करता है, तो refcount प्रोग्राम लोड करने के बाद इन मानचित्रों को एक से बढ़ा दिया जाता है, अर्थात। उनके फ़ाइल डिस्क्रिप्टर को उपयोगकर्ता प्रक्रिया से और फिर भी बंद किया जा सकता है refcount शून्य नहीं होगा:

किसी प्रोग्राम को सफलतापूर्वक लोड करने के बाद, हम आमतौर पर इसे किसी प्रकार के इवेंट जनरेटर से जोड़ देते हैं। उदाहरण के लिए, हम इसे आने वाले पैकेटों को संसाधित करने या कुछ से कनेक्ट करने के लिए नेटवर्क इंटरफ़ेस पर रख सकते हैं tracepoint मूल में. इस बिंदु पर, संदर्भ काउंटर भी एक से बढ़ जाएगा और हम लोडर प्रोग्राम में फ़ाइल डिस्क्रिप्टर को बंद करने में सक्षम होंगे।

यदि अब हम बूटलोडर को बंद कर दें तो क्या होगा? यह इवेंट जनरेटर (हुक) के प्रकार पर निर्भर करता है। लोडर के पूरा होने के बाद सभी नेटवर्क हुक मौजूद रहेंगे, ये तथाकथित वैश्विक हुक हैं। और, उदाहरण के लिए, ट्रेस प्रोग्राम उस प्रक्रिया के समाप्त होने के बाद जारी किए जाएंगे जिसने उन्हें बनाया है (और इसलिए उन्हें "स्थानीय से प्रक्रिया तक" स्थानीय कहा जाता है)। तकनीकी रूप से, स्थानीय हुक में उपयोगकर्ता स्थान में हमेशा एक संबंधित फ़ाइल डिस्क्रिप्टर होता है और इसलिए प्रक्रिया बंद होने पर बंद हो जाता है, लेकिन वैश्विक हुक नहीं होता है। निम्नलिखित चित्र में, लाल क्रॉस का उपयोग करके, मैं यह दिखाने का प्रयास करता हूं कि लोडर प्रोग्राम की समाप्ति स्थानीय और वैश्विक हुक के मामले में वस्तुओं के जीवनकाल को कैसे प्रभावित करती है।

स्थानीय और वैश्विक हुक के बीच अंतर क्यों है? कुछ प्रकार के नेटवर्क प्रोग्राम चलाना उपयोगकर्ता स्थान के बिना समझ में आता है, उदाहरण के लिए, DDoS सुरक्षा की कल्पना करें - बूटलोडर नियम लिखता है और BPF प्रोग्राम को नेटवर्क इंटरफ़ेस से जोड़ता है, जिसके बाद बूटलोडर जा सकता है और खुद को मार सकता है। दूसरी ओर, एक डिबगिंग ट्रेस प्रोग्राम की कल्पना करें जिसे आपने दस मिनट में अपने घुटनों पर लिखा था - जब यह समाप्त हो जाएगा, तो आप चाहेंगे कि सिस्टम में कोई कचरा न बचे, और स्थानीय हुक यह सुनिश्चित करेंगे।

दूसरी ओर, कल्पना करें कि आप कर्नेल में एक ट्रेसप्वाइंट से जुड़ना चाहते हैं और कई वर्षों के आंकड़े एकत्र करना चाहते हैं। इस मामले में, आप उपयोगकर्ता भाग को पूरा करना चाहेंगे और समय-समय पर आंकड़ों पर वापस लौटना चाहेंगे। बीपीएफ फाइल सिस्टम यह अवसर प्रदान करता है। यह एक इन-मेमोरी-ओनली छद्म-फ़ाइल प्रणाली है जो उन फ़ाइलों के निर्माण की अनुमति देती है जो BPF ऑब्जेक्ट को संदर्भित करती हैं और इस प्रकार बढ़ती हैं refcount वस्तुएं. इसके बाद, लोडर बाहर निकल सकता है, और उसके द्वारा बनाई गई वस्तुएं जीवित रहेंगी।

बीपीएफएफ में फाइलें बनाना जो बीपीएफ ऑब्जेक्ट्स को संदर्भित करता है उसे "पिनिंग" कहा जाता है (जैसा कि निम्नलिखित वाक्यांश में है: "प्रक्रिया बीपीएफ प्रोग्राम या मैप को पिन कर सकती है")। बीपीएफ ऑब्जेक्ट के लिए फ़ाइल ऑब्जेक्ट बनाना न केवल स्थानीय ऑब्जेक्ट के जीवन को बढ़ाने के लिए, बल्कि वैश्विक ऑब्जेक्ट की उपयोगिता के लिए भी समझ में आता है - वैश्विक 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, जिसमें निम्नलिखित प्रोटोटाइप है:

#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_PROG_TYPE_XDP, जो मान लौटाएगा XDP_PASS (सभी पैकेज छोड़ें)। BPF असेंबलर में यह बहुत सरल दिखता है:

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_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()
};

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

बीपीएफ प्रोग्राम को परिभाषित करने के बाद, हम इसे कर्नेल में लोड करने के लिए आगे बढ़ते हैं। मापदंडों का हमारा न्यूनतम सेट 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 बीपीएफ आर्किटेक्चर में बाइनरी कोड के 16 बाइट्स - दो निर्देश - लगते हैं, लेकिन अपने मूल रूप (x86_64) में यह पहले से ही 40 बाइट्स है। आइए अपने कार्यक्रम को उसके मूल रूप में देखें:

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

कोई आश्चर्य नहीं। अब आइए JIT कंपाइलर द्वारा उत्पन्न कोड को देखें:

# 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), लेकिन निष्पक्षता में, हमारा कार्यक्रम बहुत सरल है, और गैर-तुच्छ कार्यक्रमों के लिए जेआईटी कंपाइलर द्वारा जोड़े गए प्रस्तावना और उपसंहार, निश्चित रूप से आवश्यक हैं।

मैप्स

बीपीएफ प्रोग्राम संरचित मेमोरी क्षेत्रों का उपयोग कर सकते हैं जो अन्य बीपीएफ प्रोग्राम और उपयोगकर्ता स्थान में प्रोग्राम दोनों के लिए पहुंच योग्य हैं। इन वस्तुओं को मानचित्र कहा जाता है और इस अनुभाग में हम दिखाएंगे कि सिस्टम कॉल का उपयोग करके उनमें हेरफेर कैसे किया जाए bpf.

आइए तुरंत कहें कि मानचित्रों की क्षमताएं केवल साझा मेमोरी तक पहुंच तक ही सीमित नहीं हैं। उदाहरण के लिए, विशेष-उद्देश्य वाले मानचित्र होते हैं, जिनमें बीपीएफ कार्यक्रमों के लिए संकेतक या नेटवर्क इंटरफेस के लिए संकेतक, पूर्ण घटनाओं के साथ काम करने के लिए मानचित्र आदि शामिल होते हैं। हम यहां उनके बारे में बात नहीं करेंगे, ताकि पाठक भ्रमित न हों। इसके अलावा, हम सिंक्रनाइज़ेशन मुद्दों को नजरअंदाज कर देते हैं, क्योंकि यह हमारे उदाहरणों के लिए महत्वपूर्ण नहीं है। उपलब्ध मानचित्र प्रकारों की पूरी सूची यहां पाई जा सकती है <linux/bpf.h>, और इस खंड में हम एक उदाहरण के रूप में ऐतिहासिक रूप से पहला प्रकार, हैश तालिका लेंगे BPF_MAP_TYPE_HASH.

यदि आप C++ में एक हैश तालिका बनाते हैं, तो आप कहेंगे unordered_map<int,long> woo, जिसका रूसी में अर्थ है "मुझे एक टेबल चाहिए।" woo असीमित आकार, जिनकी कुंजियाँ प्रकार की होती हैं int, और मान प्रकार हैं long" बीपीएफ हैश तालिका बनाने के लिए, हमें बहुत कुछ वही करने की आवश्यकता है, सिवाय इसके कि हमें तालिका का अधिकतम आकार निर्दिष्ट करना होगा, और कुंजियों और मानों के प्रकार निर्दिष्ट करने के बजाय, हमें बाइट्स में उनके आकार निर्दिष्ट करने की आवश्यकता है . मानचित्र बनाने के लिए कमांड का उपयोग करें 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.

इसलिए, हम बीपीएफ प्रोग्राम बना और लोड कर सकते हैं, साथ ही उपयोगकर्ता स्थान से मानचित्र बना और प्रबंधित कर सकते हैं। अब यह देखना तर्कसंगत है कि हम बीपीएफ कार्यक्रमों से मानचित्रों का उपयोग कैसे कर सकते हैं। हम इसके बारे में मशीन मैक्रो कोड में पढ़ने में कठिन प्रोग्रामों की भाषा में बात कर सकते हैं, लेकिन वास्तव में यह दिखाने का समय आ गया है कि बीपीएफ प्रोग्राम वास्तव में कैसे लिखे और बनाए रखे जाते हैं - का उपयोग करके libbpf.

(उन पाठकों के लिए जो निम्न-स्तरीय उदाहरण की कमी से असंतुष्ट हैं: हम उन कार्यक्रमों का विस्तार से विश्लेषण करेंगे जो मानचित्रों और सहायक कार्यों का उपयोग करते हैं libbpf और आपको बताएंगे कि अनुदेश स्तर पर क्या होता है। उन पाठकों के लिए जो असंतुष्ट हैं बहुत ज्यादा, हमने जोड़ा उदाहरण लेख में उचित स्थान पर।)

Libbpf का उपयोग करके BPF प्रोग्राम लिखना

मशीन कोड का उपयोग करके बीपीएफ प्रोग्राम लिखना केवल पहली बार ही दिलचस्प हो सकता है, और फिर तृप्ति आ जाती है। इस समय आपको अपना ध्यान इस ओर लगाने की जरूरत है llvm, जिसमें बीपीएफ आर्किटेक्चर के लिए कोड तैयार करने के लिए एक बैकएंड है, साथ ही एक लाइब्रेरी भी है libbpf, जो आपको बीपीएफ अनुप्रयोगों के उपयोगकर्ता पक्ष को लिखने और उपयोग करके उत्पन्न बीपीएफ कार्यक्रमों के कोड को लोड करने की अनुमति देता है llvm/clang.

वास्तव में, जैसा कि हम इस और बाद के लेखों में देखेंगे, libbpf इसके (या इसी तरह के उपकरणों के बिना) काफी काम करता है - iproute2, libbcc, libbpf-go, आदि) जीना असंभव है। प्रोजेक्ट की बेहतरीन विशेषताओं में से एक libbpf बीपीएफ सीओ-आरई (एक बार संकलित करें, हर जगह चलाएं) - एक प्रोजेक्ट जो आपको बीपीएफ प्रोग्राम लिखने की अनुमति देता है जो एक कर्नेल से दूसरे कर्नेल में पोर्टेबल होते हैं, विभिन्न एपीआई पर चलने की क्षमता के साथ (उदाहरण के लिए, जब कर्नेल संरचना संस्करण से बदलती है) संस्करण के लिए)। CO-RE के साथ काम करने में सक्षम होने के लिए, आपके कर्नेल को 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, आइए कई (अधिक या कम अर्थहीन) परीक्षण कार्यक्रम लिखें और विस्तार से विश्लेषण करें कि यह सब कैसे काम करता है। यह हमें निम्नलिखित अनुभागों में अधिक आसानी से समझाने की अनुमति देगा कि बीपीएफ प्रोग्राम मैप्स, कर्नेल हेल्पर्स, बीटीएफ आदि के साथ कैसे इंटरैक्ट करते हैं।

आमतौर पर परियोजनाओं का उपयोग करना libbpf GitHub रिपॉजिटरी को git सबमॉड्यूल के रूप में जोड़ें, हम भी ऐसा ही करेंगे:

$ 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, और एक सहायक प्रोग्राम लिखें जो इसे कर्नेल में लोड करेगा। निम्नलिखित अनुभागों में हम बीपीएफ कार्यक्रम और सहायक कार्यक्रम दोनों की क्षमताओं का विस्तार करेंगे।

उदाहरण: 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, जो चरित्र को ईएलएफ ऑब्जेक्ट फ़ाइल के उपयुक्त अनुभाग में भेजता है। हमारा कार्यक्रम अनुभाग में निहित है xdp/simple, जहां स्लैश से पहले हम प्रोग्राम प्रकार BPF को परिभाषित करते हैं - यह वह कन्वेंशन है जिसका उपयोग किया जाता है libbpf, अनुभाग नाम के आधार पर यह स्टार्टअप पर सही प्रकार को प्रतिस्थापित करेगा bpf(2). बीपीएफ कार्यक्रम ही है 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 हमें दो विकल्प प्रदान करता है - निम्न-स्तरीय एपीआई या उच्च-स्तरीय एपीआई का उपयोग करें। हम दूसरे रास्ते पर जाएंगे, क्योंकि हम सीखना चाहते हैं कि बीपीएफ कार्यक्रमों को उनके बाद के अध्ययन के लिए न्यूनतम प्रयास के साथ कैसे लिखना, लोड करना और कनेक्ट करना है।

सबसे पहले, हमें उसी उपयोगिता का उपयोग करके अपने प्रोग्राम के बाइनरी से "कंकाल" उत्पन्न करने की आवश्यकता है bpftool - बीपीएफ दुनिया का स्विस चाकू (जिसे शाब्दिक रूप से लिया जा सकता है, क्योंकि डैनियल बोर्कमैन, बीपीएफ के रचनाकारों और अनुरक्षकों में से एक, स्विस है):

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

फाइल मैं xdp-simple.skel.h इसमें हमारे प्रोग्राम का बाइनरी कोड और हमारे ऑब्जेक्ट को प्रबंधित करने - लोड करने, संलग्न करने, हटाने के कार्य शामिल हैं। हमारे साधारण मामले में यह ओवरकिल जैसा दिखता है, लेकिन यह उस मामले में भी काम करता है जहां ऑब्जेक्ट फ़ाइल में कई बीपीएफ प्रोग्राम और मानचित्र होते हैं और इस विशाल ईएलएफ को लोड करने के लिए हमें केवल कंकाल उत्पन्न करने और कस्टम एप्लिकेशन से एक या दो फ़ंक्शन को कॉल करने की आवश्यकता होती है। लिख रहे हैं चलो अब आगे बढ़ते हैं.

सच कहूँ तो, हमारा लोडर प्रोग्राम तुच्छ है:

#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;
};

हम यहां निम्न-स्तरीय एपीआई के निशान देख सकते हैं: संरचना 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

कोई नई चीज़! प्रोग्राम ने हमारी सी स्रोत फ़ाइल के टुकड़े मुद्रित किए। यह पुस्तकालय द्वारा किया गया था libbpf, जिसने बाइनरी में डिबग अनुभाग पाया, इसे बीटीएफ ऑब्जेक्ट में संकलित किया, इसका उपयोग करके कर्नेल में लोड किया BPF_BTF_LOAD, और फिर कमांड के साथ प्रोग्राम लोड करते समय परिणामी फ़ाइल डिस्क्रिप्टर निर्दिष्ट करें BPG_PROG_LOAD.

कर्नेल सहायक

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

उदाहरण: bpf_get_smp_processor_id

"उदाहरण द्वारा सीखना" प्रतिमान के ढांचे के भीतर, आइए सहायक कार्यों में से एक पर विचार करें, bpf_get_smp_processor_id(), कुछ फाइल मैं kernel/bpf/helpers.c. यह उस प्रोसेसर का नंबर लौटाता है जिस पर इसे कॉल करने वाला बीपीएफ प्रोग्राम चल रहा है। लेकिन हमें इसके शब्दार्थ में उतनी दिलचस्पी नहीं है जितनी इस तथ्य में कि इसके कार्यान्वयन में एक पंक्ति लगती है:

BPF_CALL_0(bpf_get_smp_processor_id)
{
    return smp_processor_id();
}

बीपीएफ हेल्पर फ़ंक्शन परिभाषाएँ लिनक्स सिस्टम कॉल परिभाषाओं के समान हैं। यहां, उदाहरण के लिए, एक फ़ंक्शन परिभाषित किया गया है जिसमें कोई तर्क नहीं है। (एक फ़ंक्शन जो मान लीजिए, तीन तर्क लेता है, मैक्रो का उपयोग करके परिभाषित किया गया है 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;
    ...
    }
}

नए बीपीएफ प्रोग्राम प्रकार फ़ाइल में "परिभाषित" हैं include/linux/bpf_types.h मैक्रो का उपयोग करना BPF_PROG_TYPE. उद्धरणों में परिभाषित किया गया है क्योंकि यह एक तार्किक परिभाषा है, और सी भाषा के संदर्भ में कंक्रीट संरचनाओं के पूरे सेट की परिभाषा अन्य स्थानों पर होती है। विशेष रूप से, फ़ाइल में 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
};

अर्थात्, प्रत्येक प्रकार के बीपीएफ प्रोग्राम के लिए, प्रकार की डेटा संरचना के लिए एक संकेतक परिभाषित किया गया है 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_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 - शून्य। सत्यापनकर्ता द्वारा उपयोग किए गए एबीआई समझौते के अनुसार, यह हेल्पर फ़ंक्शन नंबर आठ पर एक कॉल है। एक बार लॉन्च होने के बाद, तर्क सरल है। रजिस्टर से वापसी मूल्य 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. ऐसा कोई फ़ंक्शन नहीं है जिसमें पांच से अधिक तर्क हों और भविष्य में उनके लिए समर्थन जोड़े जाने की उम्मीद नहीं है।

आइए नए कर्नेल हेल्पर पर एक नज़र डालें और जानें कि बीपीएफ कैसे पैरामीटर पास करता है। चलिए फिर से लिखते हैं 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;
}

हमारा प्रोग्राम उस CPU का नंबर प्रिंट करता है जिस पर वह चल रहा है। आइए इसे संकलित करें और कोड देखें:

$ 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

हमने जो प्रोग्राम डाउनलोड किया है उसकी आईडी 669 है और हमें इंटरफ़ेस पर वही आईडी दिखाई देती है 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 यह अकारण नहीं है कि यह डिबग फ़ाइल पर लिखता है: यह उत्पादन में उपयोग के लिए सबसे सफल सहायक नहीं है, लेकिन हमारा लक्ष्य कुछ सरल दिखाना था।

बीपीएफ कार्यक्रमों से मानचित्रों तक पहुंच

उदाहरण: बीपीएफ प्रोग्राम से मानचित्र का उपयोग करना

पिछले अनुभागों में हमने सीखा कि उपयोगकर्ता स्थान से मानचित्र कैसे बनाएं और उपयोग करें, और अब कर्नेल भाग को देखें। आइए, हमेशा की तरह, एक उदाहरण से शुरू करें। आइए अपने कार्यक्रम को फिर से लिखें 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 (सी में हम इस तरह की एक सरणी को परिभाषित करेंगे u64 woo[8]). एक कार्यक्रम में "xdp/simple" हम वर्तमान प्रोसेसर नंबर को एक वेरिएबल में प्राप्त करते हैं key और फिर सहायक फ़ंक्शन का उपयोग करें bpf_map_lookup_element हमें सरणी में संबंधित प्रविष्टि के लिए एक सूचक मिलता है, जिसे हम एक से बढ़ाते हैं। रूसी में अनुवादित: हम उन आँकड़ों की गणना करते हैं जिनके आधार पर सीपीयू ने आने वाले पैकेटों को संसाधित किया। आइए प्रोग्राम चलाने का प्रयास करें:

$ 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_mp_*.

रहस्यमय सूचकांक

तो, हम जैसे कॉल का उपयोग करके बीपीएफ प्रोग्राम से मानचित्र तक पहुंच सकते हैं

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_MAP_CREATE, और आईडी का उपयोग करके खोला गया BPF_MAP_GET_FD_BY_ID.

कुल, उपयोग करते समय libbpf एल्गोरिथ्म इस प्रकार है:

• संकलन के दौरान, मानचित्रों के लिंक के लिए स्थानांतरण तालिका में रिकॉर्ड बनाए जाते हैं
• libbpf ईएलएफ ऑब्जेक्ट बुक खोलता है, सभी उपयोग किए गए मानचित्र ढूंढता है और उनके लिए फ़ाइल डिस्क्रिप्टर बनाता है
• फ़ाइल डिस्क्रिप्टर को निर्देश के भाग के रूप में कर्नेल में लोड किया जाता है 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

ईएलएफ बाइनरी का उपयोग करते समय डाउनलोड करें libbpf अभी और भी बहुत कुछ चल रहा है, लेकिन हम उस पर अन्य लेखों में चर्चा करेंगे।

libbpf के बिना प्रोग्राम और मानचित्र लोड हो रहे हैं

जैसा कि वादा किया गया था, यहां उन पाठकों के लिए एक उदाहरण दिया गया है जो जानना चाहते हैं कि मानचित्रों का उपयोग करने वाला प्रोग्राम बिना सहायता के कैसे बनाया और लोड किया जाए libbpf. यह तब उपयोगी हो सकता है जब आप ऐसे वातावरण में काम कर रहे हों जिसके लिए आप निर्भरता नहीं बना सकते, या हर बिट को सहेज नहीं सकते, या कोई प्रोग्राम लिख रहे हों ply, जो तुरंत बीपीएफ बाइनरी कोड उत्पन्न करता है।

तर्क का पालन करना आसान बनाने के लिए, हम इन उद्देश्यों के लिए अपना उदाहरण फिर से लिखेंगे 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 संरचनाओं की एक श्रृंखला के रूप में हमारे बीपीएफ कार्यक्रम की परिभाषा है 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. जिन लोगों ने बीपीएफ और एक्सडीपी बनाया, वे ऑनलाइन लिनक्स समुदाय से थे, जिसका अर्थ है कि उन्होंने अपने सबसे परिचित लिनक्स समुदाय का उपयोग किया (लेकिन ऐसा नहीं किया) साधारण लोग) कर्नेल के साथ इंटरैक्ट करने के लिए इंटरफ़ेस: नेटलिंक सॉकेट, यह सभी देखें RFC3549. लागू करने का सबसे सरल तरीका 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 हमने प्रकार की जानकारी (बीटीएफ) लोड नहीं की। लेकिन हम अगली बार इस बारे में अधिक बात करेंगे।

विकास उपकरण

इस अनुभाग में, हम न्यूनतम बीपीएफ डेवलपर टूलकिट देखेंगे।

सामान्यतया, आपको BPF प्रोग्राम विकसित करने के लिए किसी विशेष चीज़ की आवश्यकता नहीं है - BPF किसी भी अच्छे वितरण कर्नेल पर चलता है, और प्रोग्राम का उपयोग करके बनाया जाता है clang, जिसे पैकेज से आपूर्ति की जा सकती है। हालाँकि, इस तथ्य के कारण कि BPF विकास के अधीन है, कर्नेल और उपकरण लगातार बदल रहे हैं, यदि आप 2019 से पुराने जमाने के तरीकों का उपयोग करके BPF प्रोग्राम नहीं लिखना चाहते हैं, तो आपको संकलन करना होगा

• llvm/clang
• pahole
• इसका मूल
• bpftool

(संदर्भ के लिए, यह अनुभाग और लेख के सभी उदाहरण डेबियन 10 पर चलाए गए थे।)

एलएलवीएम/क्लैंग

बीपीएफ एलएलवीएम के साथ मित्रतापूर्ण है और, हालांकि हाल ही में बीपीएफ के लिए कार्यक्रमों को जीसीसी का उपयोग करके संकलित किया जा सकता है, सभी मौजूदा विकास एलएलवीएम के लिए किए जाते हैं। इसलिए, सबसे पहले, हम वर्तमान संस्करण का निर्माण करेंगे clang गिट से:

$ 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 बीटीएफ प्रारूप में डिबगिंग जानकारी बनाने के लिए कर्नेल का निर्माण करते समय उपयोग किया जाता है। हम इस लेख में बीटीएफ तकनीक के विवरण के बारे में विस्तार से नहीं बताएंगे, सिवाय इसके कि यह सुविधाजनक है और हम इसका उपयोग करना चाहते हैं। इसलिए यदि आप अपना कर्नेल बनाने जा रहे हैं, तो पहले बनाएं 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

बीपीएफ के साथ प्रयोग के लिए गुठली

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

कर्नेल बनाने के लिए आपको, सबसे पहले, स्वयं कर्नेल की, और दूसरी, एक कर्नेल कॉन्फ़िगरेशन फ़ाइल की आवश्यकता होती है। बीपीएफ के साथ प्रयोग करने के लिए हम सामान्य का उपयोग कर सकते हैं वैनीला कर्नेल या विकास कर्नेल में से एक। ऐतिहासिक रूप से, बीपीएफ का विकास लिनक्स नेटवर्किंग समुदाय के भीतर होता है और इसलिए सभी परिवर्तन अंततः लिनक्स नेटवर्किंग अनुरक्षक डेविड मिलर के माध्यम से होते हैं। उनकी प्रकृति के आधार पर - संपादन या नई सुविधाएँ - नेटवर्क परिवर्तन दो कोर में से एक में आते हैं - net या net-next. बीपीएफ के लिए परिवर्तन समान तरीके से वितरित किए जाते हैं bpf и bpf-next, जिन्हें फिर क्रमशः नेट और नेट-नेक्स्ट में पूल किया जाता है। अधिक जानकारी के लिए देखें bpf_devel_QA и नेटदेव-अक्सर पूछे जाने वाले प्रश्न. इसलिए अपने स्वाद और जिस सिस्टम पर आप परीक्षण कर रहे हैं उसकी स्थिरता आवश्यकताओं के आधार पर एक कर्नेल चुनें (*-next सूचीबद्ध कर्नेलों में से कर्नेल सबसे अस्थिर हैं)।

कर्नेल कॉन्फ़िगरेशन फ़ाइलों को प्रबंधित करने के तरीके के बारे में बात करना इस आलेख के दायरे से बाहर है - यह माना जाता है कि या तो आप पहले से ही जानते हैं कि यह कैसे करना है, या सीखने के लिए तैयार अपने आप। हालाँकि, निम्नलिखित निर्देश आपको एक कार्यशील बीपीएफ-सक्षम प्रणाली देने के लिए कमोबेश पर्याप्त होने चाहिए।

उपरोक्त कर्नेल में से एक डाउनलोड करें:

$ 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, लिनक्स कर्नेल के भाग के रूप में आपूर्ति की गई। यह बीपीएफ डेवलपर्स द्वारा बीपीएफ डेवलपर्स के लिए लिखा और रखरखाव किया जाता है और इसका उपयोग सभी प्रकार की बीपीएफ वस्तुओं को प्रबंधित करने के लिए किया जा सकता है - प्रोग्राम लोड करना, मानचित्र बनाना और संपादित करना, बीपीएफ पारिस्थितिकी तंत्र के जीवन का पता लगाना आदि। मैन पेजों के लिए स्रोत कोड के रूप में दस्तावेज़ीकरण पाया जा सकता है मूल में या, पहले से ही संकलित, नेटवर्क में.

इस लेखन के समय bpftool केवल आरएचईएल, फेडोरा और उबंटू के लिए तैयार आता है (उदाहरण के लिए देखें, यह धागा, जो पैकेजिंग की अधूरी कहानी बताता है 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
...

जो दिखाएगा कि आपके कर्नेल में कौन सी बीपीएफ सुविधाएँ सक्षम हैं।

वैसे, पिछली कमांड को इस तरह चलाया जा सकता है

# bpftool f p k

यह पैकेज से उपयोगिताओं के अनुरूप किया जाता है iproute2, उदाहरण के लिए, हम कहां कह सकते हैं ip a s eth0 के बदले ip addr show dev eth0.

निष्कर्ष

बीपीएफ आपको प्रभावी ढंग से मापने और कोर की कार्यक्षमता को बदलने के लिए पिस्सू को जूता देने की अनुमति देता है। सिस्टम UNIX की सर्वोत्तम परंपराओं में बहुत सफल साबित हुआ: एक सरल तंत्र जो आपको कर्नेल को (पुनः) प्रोग्राम करने की अनुमति देता है, बड़ी संख्या में लोगों और संगठनों को प्रयोग करने की अनुमति देता है। और, हालांकि प्रयोग, साथ ही साथ बीपीएफ बुनियादी ढांचे का विकास भी अभी पूरा नहीं हुआ है, सिस्टम में पहले से ही एक स्थिर एबीआई है जो आपको विश्वसनीय, और सबसे महत्वपूर्ण, प्रभावी व्यावसायिक तर्क बनाने की अनुमति देता है।

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

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

इस शृंखला में पिछले लेख

1. छोटों के लिए बीपीएफ, भाग शून्य: क्लासिक बीपीएफ

लिंक

1. बीपीएफ और एक्सडीपी संदर्भ गाइड - सिलियम से बीपीएफ पर दस्तावेज़ीकरण, या अधिक सटीक रूप से डैनियल बोर्कमैन से, जो बीपीएफ के रचनाकारों और अनुरक्षकों में से एक है। यह पहले गंभीर विवरणों में से एक है, जो दूसरों से इस मायने में भिन्न है कि डैनियल को ठीक-ठीक पता है कि वह किस बारे में लिख रहा है और इसमें कोई गलती नहीं है। विशेष रूप से, यह दस्तावेज़ बताता है कि प्रसिद्ध उपयोगिता का उपयोग करके एक्सडीपी और टीसी प्रकार के बीपीएफ कार्यक्रमों के साथ कैसे काम किया जाए ip पैकेज से iproute2.

2. दस्तावेज़ीकरण/नेटवर्किंग/फ़िल्टर.txt - क्लासिक और फिर विस्तारित बीपीएफ के लिए दस्तावेज़ीकरण के साथ मूल फ़ाइल। यदि आप असेंबली भाषा और तकनीकी वास्तुशिल्प विवरण में गहराई से जाना चाहते हैं तो एक अच्छा लेख पढ़ें।

3. फेसबुक से बीपीएफ के बारे में ब्लॉग. इसे शायद ही कभी अद्यतन किया जाता है, लेकिन उपयुक्त रूप से, जैसा कि एलेक्सी स्टारोवोइटोव (ईबीपीएफ के लेखक) और एंड्री नाक्रिइको - (अनुरक्षक) ने वहां लिखा है libbpf).

4. bpftool का रहस्य. bpftool के उपयोग के उदाहरणों और रहस्यों के साथ क्वेंटिन मोनेट का एक मनोरंजक ट्विटर थ्रेड।

5. बीपीएफ में गोता लगाएँ: पठन सामग्री की एक सूची. क्वेंटिन मोनेट से बीपीएफ दस्तावेज़ीकरण के लिंक की एक विशाल (और अभी भी बनी हुई) सूची।

स्रोत: www.habr.com