🥇BPF सानाहरूका लागि, भाग एक: विस्तारित BPF

सुरुमा एउटा प्रविधि थियो र यसलाई बीपीएफ भनिन्थ्यो। हामीले उसलाई हेरे अघिल्लो, यो श्रृंखला को पुरानो नियम लेख। 2013 मा, Alexei Starovoitov र ड्यानियल Borkman को प्रयासहरु मार्फत, यसको एक सुधारिएको संस्करण, आधुनिक 64-बिट मिसिनहरु को लागी अनुकूलित, विकसित र लिनक्स कर्नेल मा समावेश गरिएको थियो। यो नयाँ प्रविधिलाई संक्षिप्त रूपमा आन्तरिक BPF भनिन्थ्यो, त्यसपछि विस्तारित BPF नामकरण गरियो, र अब, धेरै वर्ष पछि, सबैले यसलाई BPF मात्र भन्छन्।

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

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

लेखको सारांश

BPF वास्तुकला को परिचय। पहिले, हामी BPF वास्तुकलाको पक्षीको आँखाको दृश्य लिनेछौं र मुख्य घटकहरू रूपरेखा गर्नेछौं।

BPF भर्चुअल मेसिनको दर्ता र आदेश प्रणाली। पहिले नै समग्र वास्तुकला को एक विचार छ, हामी BPF भर्चुअल मेसिन को संरचना वर्णन गर्नेछौं।

BPF वस्तुहरूको जीवन चक्र, bpffs फाइल प्रणाली। यस खण्डमा, हामी BPF वस्तुहरू - कार्यक्रमहरू र नक्साहरूको जीवन चक्रलाई नजिकबाट हेर्नेछौं।

Bpf प्रणाली कल प्रयोग गरेर वस्तुहरू प्रबन्ध गर्नुहोस्। पहिले नै स्थानमा रहेको प्रणालीको केही बुझाइको साथ, हामी अन्तमा विशेष प्रणाली कल प्रयोग गरेर प्रयोगकर्ता स्पेसबाट वस्तुहरू कसरी सिर्जना र हेरफेर गर्ने भनेर हेर्नेछौं - bpf(2).

Пишем программы BPF с помощью libbpf. अवश्य पनि, तपाइँ प्रणाली कल प्रयोग गरेर प्रोग्रामहरू लेख्न सक्नुहुन्छ। तर गाह्रो छ। थप यथार्थवादी परिदृश्यको लागि, आणविक प्रोग्रामरहरूले पुस्तकालयको विकास गरे libbpf। हामी आधारभूत BPF अनुप्रयोग कंकाल सिर्जना गर्नेछौं जुन हामीले पछिका उदाहरणहरूमा प्रयोग गर्नेछौं।

कर्नेल सहयोगीहरू। यहाँ हामी BPF कार्यक्रमहरूले कर्नेल सहायक कार्यहरू कसरी पहुँच गर्न सक्छ भन्ने कुरा सिक्नेछौं - एउटा उपकरण जसले नक्साको साथमा, क्लासिकको तुलनामा नयाँ BPF को क्षमताहरूलाई मौलिक रूपमा विस्तार गर्छ।

BPF कार्यक्रमहरूबाट नक्साहरूमा पहुँच। यस बिन्दुमा, हामी नक्सा प्रयोग गर्ने कार्यक्रमहरू कसरी सिर्जना गर्न सक्छौं भनेर ठ्याक्कै बुझ्नको लागि पर्याप्त थाहा पाउनेछौं। र महान् र शक्तिशाली प्रमाणकर्तामा द्रुत झलक पनि लिऔं।

विकास उपकरणहरू। प्रयोगहरूको लागि आवश्यक उपयोगिताहरू र कर्नेल कसरी जम्मा गर्ने भन्ने बारे मद्दत खण्ड।

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

BPF वास्तुकला को परिचय

हामीले BPF वास्तुकलालाई विचार गर्न सुरु गर्नु अघि, हामी अन्तिम पटक (ओह) लाई सन्दर्भ गर्नेछौं क्लासिक BPF, जुन RISC मेसिनहरूको आगमनको प्रतिक्रियाको रूपमा विकसित गरिएको थियो र कुशल प्याकेट फिल्टरिङको समस्या समाधान गर्‍यो। वास्तुकला यति सफल भयो कि, बर्कले UNIX मा ड्यासिङ नब्बे को दशक मा जन्म भएको थियो, यो धेरै अवस्थित अपरेटिङ सिस्टम मा पोर्ट गरिएको थियो, पागल बीस को दशक मा बाँचे र अझै पनि नयाँ अनुप्रयोगहरु फेला पार्दै छ।

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

हास्यास्पद चित्रहरु

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

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

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

यहाँ पाठक एक प्रश्न हुन सक्छ: यो सम्भव छ? यस्तो कोडको कार्यान्वयन सुरक्षा कसरी ग्यारेन्टी गरिन्छ? प्रमाणिकरण भनिने BPF कार्यक्रमहरू लोड गर्ने चरणद्वारा कार्यान्वयन सुरक्षाको ग्यारेन्टी गरिन्छ (अङ्ग्रेजीमा यो चरणलाई भेरिफायर भनिन्छ र म अंग्रेजी शब्द प्रयोग गर्न जारी राख्नेछु):

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

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

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

प्रणाली कल प्रयोग गरेर प्रयोगकर्ता प्रक्रियाहरूबाट नक्सा पहुँच गरिन्छ bpf(2), र सहायक प्रकार्यहरू प्रयोग गरेर कर्नेलमा चलिरहेको BPF कार्यक्रमहरूबाट। यसबाहेक, सहयोगीहरू नक्साहरूसँग काम गर्न मात्र होइन, अन्य कर्नेल क्षमताहरूमा पहुँच गर्न पनि अवस्थित छन्। उदाहरणका लागि, BPF कार्यक्रमहरूले अन्य इन्टरफेसमा प्याकेटहरू फर्वार्ड गर्न, perf घटनाहरू उत्पन्न गर्न, कर्नेल संरचनाहरू पहुँच गर्न, र यस्तै अन्य कार्यहरू प्रयोग गर्न सक्छ।

सारांशमा, BPF ले कर्नेल स्पेसमा स्वेच्छाचारी, अर्थात्, प्रमाणिकरण-परीक्षण, प्रयोगकर्ता कोड लोड गर्ने क्षमता प्रदान गर्दछ। यो कोडले कलहरू बीचको अवस्था बचत गर्न सक्छ र प्रयोगकर्ता स्पेसको साथ डाटा आदानप्रदान गर्न सक्छ, र यस प्रकारको कार्यक्रमद्वारा अनुमति दिइएको कर्नेल उपप्रणालीहरूमा पहुँच पनि छ।

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

त्यस्ता क्षमताहरूको उपस्थितिले BPF लाई कर्नेल विस्तार गर्नको लागि एक विश्वव्यापी उपकरण बनाउँछ, जुन व्यवहारमा पुष्टि हुन्छ: BPF मा थप र धेरै नयाँ प्रकारका कार्यक्रमहरू थपिएका छन्, अधिक र अधिक ठूला कम्पनीहरूले BPF को लडाई सर्भरहरूमा 24 × 7, अधिक र अधिक प्रयोग गर्छन्। स्टार्टअपहरूले समाधानहरूमा आफ्नो व्यवसाय निर्माण गर्छन् जुन BPF मा आधारित छन्। BPF जताततै प्रयोग गरिन्छ: DDoS आक्रमणहरू विरुद्ध सुरक्षा गर्न, SDN सिर्जना गर्न (उदाहरणका लागि, kubernetes को लागि नेटवर्कहरू लागू गर्न), मुख्य प्रणाली ट्रेसिङ उपकरण र तथ्याङ्क सङ्कलकको रूपमा, घुसपैठ पत्ता लगाउने प्रणाली र स्यान्डबक्स प्रणालीहरूमा, आदि।

लेखको सिंहावलोकन भाग यहाँ समाप्त गरौं र भर्चुअल मेसिन र BPF इकोसिस्टमलाई थप विस्तारमा हेरौं।

विषयवस्तु: उपयोगिताहरू

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

BPF भर्चुअल मेसिन दर्ता र निर्देशन प्रणाली

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

BPF सँग एघार प्रयोगकर्ता-पहुँचयोग्य 64-बिट दर्ताहरू छन् r0-r10 र एक कार्यक्रम काउन्टर। दर्ता गर्नुहोस् r10 फ्रेम सूचक समावेश छ र पढ्न मात्र छ। कार्यक्रमहरूसँग रनटाइममा 512-बाइट स्ट्याक र नक्साको रूपमा साझा मेमोरीको असीमित मात्रामा पहुँच छ।

BPF कार्यक्रमहरूलाई प्रोग्राम-प्रकार कर्नेल सहयोगीहरूको एक निश्चित सेट र हालसालै, नियमित कार्यहरू चलाउन अनुमति दिइएको छ। प्रत्येक भनिने प्रकार्यले पाँचवटा तर्कहरू लिन सक्छ, दर्ताहरूमा पारित r1-r5, र रिटर्न मान पास गरिएको छ r0। यो ग्यारेन्टी छ कि समारोहबाट फर्केपछि, दर्ताको सामग्रीहरू r6-r9 परिवर्तन हुने छैन।

कुशल कार्यक्रम अनुवादको लागि, दर्ता r0-r11 वर्तमान वास्तुकलाको ABI सुविधाहरूलाई ध्यानमा राख्दै सबै समर्थित आर्किटेक्चरहरू वास्तविक रेजिस्टरहरूमा अद्वितीय रूपमा म्याप गरिएका छन्। उदाहरण को लागी, को लागी x86_64 दर्ता गर्दछ r1-r5, प्रकार्य प्यारामिटरहरू पास गर्न प्रयोग गरिन्छ, मा प्रदर्शित हुन्छन् rdi, rsi, rdx, rcx, r8, जुन कार्यहरूमा प्यारामिटरहरू पास गर्न प्रयोग गरिन्छ x86_64। उदाहरणका लागि, बायाँको कोडले दायाँको कोडलाई यसरी अनुवाद गर्छ:

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

रेजिष्टर गर्नुहोस् r0 कार्यक्रम कार्यान्वयनको नतिजा र दर्तामा फर्काउन पनि प्रयोग गरिन्छ r1 कार्यक्रमलाई सन्दर्भमा एक सूचक पारित गरिएको छ - कार्यक्रमको प्रकारमा निर्भर गर्दै, यो हुन सक्छ, उदाहरणका लागि, संरचना struct xdp_md (XDP को लागि) वा संरचना struct __sk_buff (भिन्न नेटवर्क कार्यक्रमहरूको लागि) वा संरचना struct pt_regs (विभिन्न प्रकारका ट्रेसिङ कार्यक्रमहरूको लागि), आदि।

त्यसोभए, हामीसँग नक्साको रूपमा दर्ताहरू, कर्नेल सहयोगीहरू, स्ट्याक, एक सन्दर्भ सूचक र साझा मेमोरीको सेट थियो। यो सबै यात्रा मा बिल्कुल आवश्यक छ भन्ने छैन, तर ...

वर्णन जारी राखौं र यी वस्तुहरूसँग काम गर्ने आदेश प्रणालीको बारेमा कुरा गरौं। सबै (लगभग सबै) BPF निर्देशनहरूको निश्चित 64-बिट साइज छ। यदि तपाईंले 64-बिट बिग एन्डियन मेसिनमा एउटा निर्देशन हेर्नुभयो भने तपाईंले देख्नुहुनेछ

यो छ Code - यो निर्देशनको एन्कोडिङ हो, Dst/Src क्रमशः प्राप्तकर्ता र स्रोतको सङ्केतनहरू हुन्, Off - 16-बिट हस्ताक्षरित इन्डेन्टेशन, र Imm केही निर्देशनहरूमा प्रयोग गरिएको 32-बिट हस्ताक्षरित पूर्णांक हो (cBPF स्थिर K जस्तै)। इन्कोडिङ Code दुई प्रकार मध्ये एक छ:

निर्देशन कक्षाहरू 0, 1, 2, 3 ले मेमोरीसँग काम गर्ने आदेशहरू परिभाषित गर्दछ। तिनीहरूले भनिन्छ, BPF_LD, BPF_LDX, BPF_ST, BPF_STX, क्रमशः। कक्षा ४, ७ (BPF_ALU, BPF_ALU64ALU निर्देशनहरूको सेट गठन गर्नुहोस्। कक्षा ५, ६ (BPF_JMP, BPF_JMP32) जम्प निर्देशनहरू समावेश गर्दछ।

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

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

उदाहरण: तपाईको टाउकोमा BPF डिससेम्बल गर्दै

एउटा उदाहरण हेरौं जसमा हामी एउटा प्रोग्राम कम्पाइल गर्छौं readelf-example.c र नतिजा बाइनरी हेर्नुहोस्। हामी मूल सामग्री प्रकट गर्नेछौं readelf-example.c तल, हामीले बाइनरी कोडहरूबाट यसको तर्क पुनर्स्थापना गरेपछि:

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

आउटपुटमा पहिलो स्तम्भ readelf एक इन्डेन्टेशन हो र हाम्रो कार्यक्रम यसरी चार आदेशहरू समावेश गर्दछ:

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

आदेश कोडहरू बराबर छन् b7, 15, b7 и 95। सम्झनुहोस् कि कम्तिमा महत्त्वपूर्ण तीन बिटहरू निर्देशन वर्ग हुन्। हाम्रो अवस्थामा, सबै निर्देशनहरूको चौथो बिट खाली छ, त्यसैले निर्देशन कक्षाहरू क्रमशः 7, 5, 7, 5 छन्। कक्षा 7 हो। BPF_ALU64, र 5 छ BPF_JMP। दुबै कक्षाहरूको लागि, निर्देशन ढाँचा समान छ (माथि हेर्नुहोस्) र हामी हाम्रो कार्यक्रमलाई यसरी पुन: लेख्न सक्छौं (एकै समयमा हामी मानव रूपमा बाँकी स्तम्भहरू पुन: लेख्नेछौं):

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

अपरेशन b वर्ग ALU64 हो BPF_MOV। यसले गन्तव्य दर्तामा मान तोक्छ। यदि बिट सेट गरिएको छ s (स्रोत), त्यसपछि मान स्रोत दर्ताबाट लिइन्छ, र यदि, हाम्रो मामलामा, यो सेट गरिएको छैन भने, मान फिल्डबाट लिइन्छ। Imm। त्यसैले पहिलो र तेस्रो निर्देशनमा हामी अपरेशन गर्छौं r0 = Imm। यसबाहेक, JMP कक्षा १ सञ्चालन छ BPF_JEQ (यदि बराबर छ भने)। हाम्रो मामला मा, बिट देखि S शून्य छ, यसले स्रोत दर्ताको मानलाई क्षेत्रसँग तुलना गर्छ Imm। यदि मानहरू मेल खान्छ भने, त्यसपछि संक्रमण हुन्छ PC + Offकहाँ PC, सामान्य रूपमा, अर्को निर्देशनको ठेगाना समावेश गर्दछ। अन्तमा, JMP कक्षा 9 सञ्चालन छ BPF_EXIT। यो निर्देशनले कार्यक्रम समाप्त गर्छ, कर्नेलमा फर्कन्छ r0। हाम्रो तालिकामा नयाँ स्तम्भ थपौं:

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

हामी यसलाई थप सुविधाजनक फारममा पुन: लेख्न सक्छौं:

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

यदि हामीले दर्तामा के छ सम्झन्छौं r1 कार्यक्रम कर्नेलबाट सन्दर्भमा एक सूचक पास गरिएको छ, र दर्तामा r0 मान कर्नेलमा फर्काइन्छ, त्यसपछि हामी देख्न सक्छौं कि यदि सन्दर्भमा सूचक शून्य छ भने, हामी 1 फर्काउँछौं, र अन्यथा - 2। स्रोत हेरेर हामी सही छौं भनेर जाँच गरौं:

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

हो, यो एक अर्थहीन कार्यक्रम हो, तर यसले केवल चार सरल निर्देशनहरूमा अनुवाद गर्दछ।

अपवाद उदाहरण: 16-बाइट निर्देशन

हामीले पहिले उल्लेख गरेका थियौं कि केहि निर्देशनहरूले 64 बिट भन्दा बढी लिन्छन्। यो लागू हुन्छ, उदाहरणका लागि, निर्देशनहरूमा lddw (कोड = 0x18 = BPF_LD | BPF_DW | BPF_IMM) — फिल्डबाट एक दोहोरो शब्द दर्तामा लोड गर्नुहोस् Imm। तथ्य यो हो Imm 32 को साइज छ, र एक दोहोरो शब्द 64 बिट छ, त्यसैले 64-बिट निर्देशनमा 64-बिट तत्काल मान एक दर्तामा लोड गर्दा काम गर्दैन। यो गर्नका लागि, फिल्डमा 64-बिट मानको दोस्रो भाग भण्डारण गर्न दुई नजिकका निर्देशनहरू प्रयोग गरिन्छ Imm। उदाहरण:

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

बाइनरी कार्यक्रममा केवल दुई निर्देशनहरू छन्:

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

हामी निर्देशन सहित फेरि भेट्नेछौं lddw, जब हामी स्थानान्तरण र नक्सा संग काम गर्ने बारे कुरा गर्छौं।

उदाहरण: मानक उपकरणहरू प्रयोग गरी BPF छुट्याउने

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

$ llvm-objdump -d x64.o

Disassembly of section .text:

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

BPF वस्तुहरूको जीवनचक्र, bpffs फाइल प्रणाली

(मैले पहिलो पटक यस उपखण्डमा वर्णन गरिएका केही विवरणहरू बाट सिकें पोस्ट अलेक्सई स्टारोवोइटोभ मा BPF ब्लग.)

BPF वस्तुहरू - प्रोग्रामहरू र नक्साहरू - आदेशहरू प्रयोग गरेर प्रयोगकर्ता स्पेसबाट सिर्जना गरिएका छन् BPF_PROG_LOAD и BPF_MAP_CREATE प्रणाली कल bpf(2), हामी अर्को खण्डमा यो कसरी हुन्छ भन्ने बारे कुरा गर्नेछौं। यसले कर्नेल डेटा संरचनाहरू र तिनीहरूमध्ये प्रत्येकको लागि सिर्जना गर्दछ refcount (सन्दर्भ गणना) एकमा सेट गरिएको छ, र वस्तुलाई संकेत गर्ने फाइल वर्णनकर्ता प्रयोगकर्तालाई फर्काइन्छ। ह्यान्डल बन्द भएपछि refcount वस्तु एक द्वारा घटाइन्छ, र जब यो शून्य पुग्छ, वस्तु नष्ट हुन्छ।

यदि कार्यक्रम नक्सा प्रयोग गर्दछ, त्यसपछि refcount कार्यक्रम लोड गरेपछि यी नक्साहरू एकले बढाइन्छ, अर्थात्। तिनीहरूको फाइल वर्णनकर्ताहरू प्रयोगकर्ता प्रक्रियाबाट बन्द गर्न सकिन्छ र अझै पनि refcount शून्य हुनेछैन:

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

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

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

अर्कोतर्फ, कल्पना गर्नुहोस् कि तपाइँ कर्नेलमा ट्रेसपोइन्टमा जडान गर्न र धेरै वर्षहरूमा तथ्याङ्कहरू सङ्कलन गर्न चाहनुहुन्छ। यस अवस्थामा, तपाइँ प्रयोगकर्ता भाग पूरा गर्न र समय समयमा तथ्याङ्कमा फर्कन चाहानुहुन्छ। bpf फाइल प्रणालीले यो अवसर प्रदान गर्दछ। यो एक इन-मेमोरी-मात्र स्यूडो-फाइल प्रणाली हो जसले फाइलहरू सिर्जना गर्न अनुमति दिन्छ जसले BPF वस्तुहरू सन्दर्भ गर्दछ र यसरी बढ्छ। refcount वस्तुहरू। यस पछि, लोडर बाहिर निस्कन सक्छ, र यसले सिर्जना गरेको वस्तुहरू जीवित रहनेछन्।

BPF वस्तुहरू सन्दर्भ गर्ने bpffs मा फाइलहरू सिर्जना गर्नुलाई "पिनिङ" भनिन्छ (निम्न वाक्यांशमा जस्तै: "प्रक्रियाले BPF कार्यक्रम वा नक्सालाई पिन गर्न सक्छ")। BPF वस्तुहरूको लागि फाइल वस्तुहरू सिर्जना गर्नाले स्थानीय वस्तुहरूको आयु बढाउनको लागि मात्र होइन, तर विश्वव्यापी वस्तुहरूको उपयोगिताको लागि पनि अर्थपूर्ण हुन्छ - विश्वव्यापी DDoS सुरक्षा कार्यक्रमको उदाहरणमा फर्केर, हामी तथ्याङ्कहरू हेर्न सक्षम हुन चाहन्छौं। समय समयमा।

BPF फाइल प्रणाली सामान्यतया मा माउन्ट गरिएको छ /sys/fs/bpf, तर यो स्थानीय रूपमा पनि माउन्ट गर्न सकिन्छ, उदाहरणका लागि, यो जस्तै:

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

फाइल प्रणाली नामहरू आदेश प्रयोग गरेर सिर्जना गरिन्छ BPF_OBJ_PIN BPF प्रणाली कल। उदाहरणका लागि, एउटा प्रोग्राम लिनुहोस्, यसलाई कम्पाइल गर्नुहोस्, यसलाई अपलोड गर्नुहोस्, र यसलाई पिन गर्नुहोस् 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) (केही अप्रासंगिक रेखाहरू strace आउटपुटबाट हटाइयो):

$ 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

वस्तुहरू मेटाउँदै

वस्तुहरू मेटाउने बारे बोल्दै, यो स्पष्ट गर्न आवश्यक छ कि हामीले हुक (घटना जेनेरेटर) बाट कार्यक्रम विच्छेद गरेपछि, कुनै पनि नयाँ घटनाले यसको सुरुवातलाई ट्रिगर गर्दैन, यद्यपि, कार्यक्रमका सबै वर्तमान उदाहरणहरू सामान्य क्रममा पूरा हुनेछन्। ।

केहि प्रकारका BPF कार्यक्रमहरूले तपाईंलाई उडानमा कार्यक्रम प्रतिस्थापन गर्न अनुमति दिन्छ, अर्थात्। अनुक्रम परमाणु प्रदान गर्नुहोस् replace = detach old program, attach new program। यस अवस्थामा, कार्यक्रमको पुरानो संस्करणका सबै सक्रिय उदाहरणहरूले तिनीहरूको काम समाप्त गर्नेछ, र नयाँ कार्यक्रमबाट नयाँ घटना ह्यान्डलरहरू सिर्जना गरिनेछ, र यहाँ "परमाणविकता" को अर्थ एउटा पनि घटना छुटेको छैन।

घटना स्रोतहरूमा कार्यक्रमहरू संलग्न गर्दै

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

बीपीएफ प्रणाली कल प्रयोग गरेर वस्तुहरू हेरफेर गर्दै

BPF कार्यक्रमहरू

सबै BPF वस्तुहरू प्रणाली कल प्रयोग गरेर प्रयोगकर्ता स्पेसबाट सिर्जना र व्यवस्थित हुन्छन् bpf, निम्न प्रोटोटाइप भएको:

#include <linux/bpf.h>

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

यहाँ छ टोली cmd प्रकार को मान मध्ये एक हो enum bpf_cmd, attr - एक विशेष कार्यक्रम को लागी प्यारामिटरहरु को लागी एक सूचक र size - सूचक अनुसार वस्तु आकार, अर्थात् सामान्यतया यो sizeof(*attr)। कर्नेल 5.8 मा प्रणाली कल bpf 34 विभिन्न आदेशहरू समर्थन गर्दछ, र परिभाषा union bpf_attr 200 लाइनहरू ओगटेको छ। तर हामी यसबाट डराउनु हुँदैन, किनकि हामी धेरै लेखहरूको क्रममा आदेशहरू र प्यारामिटरहरूसँग परिचित हुनेछौं।

टोलीबाट सुरु गरौं BPF_PROG_LOAD, जसले BPF कार्यक्रमहरू सिर्जना गर्दछ - BPF निर्देशनहरूको सेट लिन्छ र कर्नेलमा लोड गर्दछ। लोडिङको क्षणमा, प्रमाणिकरण सुरु हुन्छ, र त्यसपछि JIT कम्पाइलर र, सफल कार्यान्वयन पछि, प्रोग्राम फाइल वर्णनकर्ता प्रयोगकर्तालाई फर्काइन्छ। हामीले अघिल्लो खण्डमा उहाँलाई के हुन्छ देख्यौं BPF वस्तुहरूको जीवन चक्रको बारेमा.

हामी अब एउटा कस्टम प्रोग्राम लेख्नेछौं जसले साधारण BPF प्रोग्राम लोड गर्नेछ, तर पहिले हामीले कुन प्रकारको प्रोग्राम लोड गर्न चाहन्छौं भनेर निर्णय गर्न आवश्यक छ - हामीले चयन गर्नुपर्नेछ। प्रकार र यस प्रकारको ढाँचा भित्र, एउटा प्रोग्राम लेख्नुहोस् जसले प्रमाणिकरण परीक्षण पास गर्नेछ। यद्यपि, प्रक्रियालाई जटिल नबनाउनको लागि, यहाँ एक तयार समाधान छ: हामी जस्तै कार्यक्रम लिनेछौं 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 कार्यक्रम। यस अवस्थामा, BPF कार्यक्रमको प्रत्येक निर्देशन संरचनामा प्याक गरिएको छ bpf_insn। पहिलो तत्व insns निर्देशनहरूको पालना गर्दछ r0 = 2, दोस्रो - exit.

रिट्रीट। कर्नेलले मेसिन कोडहरू लेख्न र कर्नेल हेडर फाइल प्रयोग गर्नका लागि थप सुविधाजनक म्याक्रोहरू परिभाषित गर्दछ। tools/include/linux/filter.h हामी लेख्न सक्छौं

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

तर नेटिभ कोडमा BPF प्रोग्रामहरू लेख्न केवल कर्नेलमा परीक्षणहरू र BPF बारेमा लेखहरू लेख्नको लागि आवश्यक छ, यी म्याक्रोहरूको अनुपस्थितिले वास्तवमा विकासकर्ताको जीवनलाई जटिल बनाउँदैन।

BPF कार्यक्रम परिभाषित गरेपछि, हामी यसलाई कर्नेलमा लोड गर्न अगाडि बढ्छौं। हाम्रो प्यारामिटरहरूको न्यूनतम सेट attr कार्यक्रमको प्रकार, सेट र निर्देशनहरूको संख्या, आवश्यक इजाजतपत्र, र नाम समावेश गर्दछ "woo", जुन हामीले डाउनलोड गरेपछि प्रणालीमा हाम्रो कार्यक्रम फेला पार्न प्रयोग गर्छौं। कार्यक्रम, प्रतिज्ञा अनुसार, प्रणाली कल प्रयोग गरेर प्रणालीमा लोड हुन्छ bpf.

कार्यक्रमको अन्त्यमा हामी अनन्त लूपमा पुग्छौं जसले पेलोडलाई सिमुलेट गर्छ। यो बिना, प्रोग्रामलाई कर्नेलद्वारा मारिनेछ जब प्रणालीले हामीलाई फिर्ता गरेको फाइल वर्णनकर्ता बन्द हुन्छ। bpf, र हामीले यसलाई प्रणालीमा देख्ने छैनौं।

खैर, हामी परीक्षणको लागि तयार छौं। भेला गरौं र कार्यक्रम अन्तर्गत चलाउनुहोस् straceजाँच गर्न को लागी सबै कुरा यो जस्तै काम गरिरहेको छ:

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

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

सबै ठीक छ, bpf(2) ह्यान्डल 3 हामीलाई फर्काइयो र हामी अनन्त लुपमा गयौं pause()। प्रणालीमा हाम्रो कार्यक्रम फेला पार्न प्रयास गरौं। यो गर्नको लागि हामी अर्को टर्मिनलमा जानेछौं र उपयोगिता प्रयोग गर्नेछौं bpftool:

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

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

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

कुनै आश्चर्य छैन। अब 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), तर निष्पक्षतामा, हाम्रो कार्यक्रम धेरै सरल छ, र गैर-तुच्छ कार्यक्रमहरूको लागि JIT कम्पाइलरले थपेको प्रस्तावना र उपसंहार अवश्य पनि आवश्यक छ।

नक्सा

BPF कार्यक्रमहरूले संरचित मेमोरी क्षेत्रहरू प्रयोग गर्न सक्छन् जुन अन्य BPF कार्यक्रमहरू र प्रयोगकर्ता स्पेसमा भएका कार्यक्रमहरूमा पहुँचयोग्य छन्। यी वस्तुहरूलाई नक्सा भनिन्छ र यस खण्डमा हामी तिनीहरूलाई प्रणाली कल प्रयोग गरेर कसरी हेरफेर गर्ने भनेर देखाउनेछौं bpf.

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

यदि तपाईंले ह्यास तालिका सिर्जना गर्नुभयो भने, भन्नुहोस्, C++, तपाईंले भन्नुहुनेछ unordered_map<int,long> woo, जसको रूसीमा अर्थ "मलाई टेबल चाहिन्छ woo असीमित आकार, जसको कुञ्जी प्रकारका छन् int, र मानहरू प्रकार हुन् long" BPF ह्यास तालिका बनाउनको लागि, हामीले तालिकाको अधिकतम आकार निर्दिष्ट गर्न बाहेक, हामीले धेरै कुराहरू गर्न आवश्यक छ, र कुञ्जी र मानहरूको प्रकार निर्दिष्ट गर्नुको सट्टा, हामीले बाइटहरूमा तिनीहरूको आकार निर्दिष्ट गर्न आवश्यक छ। । नक्सा बनाउन आदेश प्रयोग गर्नुहोस् BPF_MAP_CREATE प्रणाली कल bpf। नक्सा सिर्जना गर्ने कम वा कम न्यूनतम कार्यक्रमलाई हेरौं। 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), जसमा म अधिकतम चार तत्व राख्न सक्छु।" BPF नक्साहरू सिर्जना गर्दा, तपाइँ अन्य प्यारामिटरहरू निर्दिष्ट गर्न सक्नुहुन्छ, उदाहरणका लागि, कार्यक्रमको उदाहरणमा जस्तै, हामीले वस्तुको नाम निर्दिष्ट गरेका छौं। "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 हाम्रो वस्तुको विश्वव्यापी ID हो। प्रणालीमा कुनै पनि प्रोग्रामले आदेश प्रयोग गरेर अवस्थित नक्सा खोल्न यो ID प्रयोग गर्न सक्छ 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 थाहा छैन ह्यास तालिकामा कुन प्रकारका मानहरू छन्। (यो ज्ञान BTF प्रयोग गरेर उसलाई हस्तान्तरण गर्न सकिन्छ, तर अब त्यसमा थप।)

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.

ठीक छ, कुञ्जी १ द्वारा मान परिवर्तन गरौं, हाम्रो व्यापार तर्कलाई दर्ता गर्न आवश्यक छ भनौं। 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 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: यसको विश्वव्यापी ID द्वारा अवस्थित नक्सा खोल्नुहोस्
BPF_MAP_LOOKUP_AND_DELETE_ELEM: परमाणु रूपमा वस्तुको मान अद्यावधिक गर्नुहोस् र पुरानो फर्काउनुहोस्
BPF_MAP_FREEZE: प्रयोगकर्ता स्थानबाट नक्सा अपरिवर्तनीय बनाउनुहोस् (यस अपरेशनलाई अन्डू गर्न सकिँदैन)
BPF_MAP_LOOKUP_BATCH, BPF_MAP_LOOKUP_AND_DELETE_BATCH, BPF_MAP_UPDATE_BATCH, BPF_MAP_DELETE_BATCH: सामूहिक सञ्चालन। उदाहरणका लागि, BPF_MAP_LOOKUP_AND_DELETE_BATCH - यो नक्साबाट सबै मानहरू पढ्न र रिसेट गर्ने मात्र भरपर्दो तरिका हो

यी सबै आदेशहरू सबै नक्सा प्रकारका लागि काम गर्दैनन्, तर सामान्यतया प्रयोगकर्ता स्पेसबाट अन्य प्रकारका नक्साहरूसँग काम गर्दा ह्यास तालिकाहरूसँग काम गर्ने जस्तै देखिन्छ।

अर्डरको खातिर, हाम्रो ह्यास तालिका प्रयोगहरू समाप्त गरौं। याद गर्नुहोस् कि हामीले एउटा तालिका सिर्जना गर्यौं जसमा चार कुञ्जीहरू समावेश हुन सक्छन्? केही थप तत्वहरू थपौं:

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

अहिलेसम्म धेरै राम्रो:

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

अर्को थप्न प्रयास गरौं:

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

अपेक्षा गरेअनुसार हामी सफल भएनौं। त्रुटिलाई थप विवरणमा हेरौं:

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

सबै ठीक छ: अपेक्षित रूपमा, टोली BPF_MAP_UPDATE_ELEM नयाँ, पाँचौं, कुञ्जी सिर्जना गर्ने प्रयास गर्छ, तर क्र्यास हुन्छ E2BIG.

त्यसैले, हामी BPF प्रोग्रामहरू सिर्जना र लोड गर्न सक्छौं, साथै प्रयोगकर्ता स्पेसबाट नक्साहरू सिर्जना र व्यवस्थापन गर्न सक्छौं। अब हामीले BPF कार्यक्रमहरूबाट नक्साहरू कसरी प्रयोग गर्न सक्छौं भनेर हेर्नु तार्किक छ। हामीले मेसिन म्याक्रो कोडहरूमा पढ्न गाह्रो-पढ्ने कार्यक्रमहरूको भाषामा यसको बारेमा कुरा गर्न सक्छौं, तर वास्तवमा BPF कार्यक्रमहरू वास्तवमा कसरी लेखिएको र मर्मत गरिन्छ भनेर देखाउने समय आएको छ - प्रयोग गरेर। libbpf.

(निम्न-स्तरको उदाहरणको अभावमा असन्तुष्ट भएका पाठकहरूका लागि: हामी विस्तृत कार्यक्रमहरूमा विश्लेषण गर्नेछौं जुन नक्सा र सहायक कार्यहरू प्रयोग गरेर सिर्जना गरिन्छ। libbpf र निर्देशन स्तरमा के हुन्छ भनी बताउनुहोस्। असन्तुष्ट पाठकहरूको लागि धेरै धेरै, हामीले थप्यौं एक उदाहरण लेखमा उपयुक्त ठाउँमा।)

Libbpf प्रयोग गरेर BPF कार्यक्रमहरू लेख्दै

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

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

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

यो फाइलले कर्नेलमा प्रयोग गरिएका सबै डाटा प्रकारहरूको बारेमा जानकारी भण्डारण गर्छ र हाम्रा सबै उदाहरणहरूमा प्रयोग गरिन्छ libbpf। हामी अर्को लेखमा CO-RE को बारेमा विस्तृत रूपमा कुरा गर्नेछौं, तर यो एकमा - केवल आफैलाई एक कर्नेल बनाउनुहोस्। CONFIG_DEBUG_INFO_BTF.

पुस्तकालय libbpf डाइरेक्टरीमा रहन्छ tools/lib/bpf कर्नेल र यसको विकास मेलिङ सूची मार्फत गरिन्छ [email protected]। यद्यपि, कर्नेल बाहिर बस्ने अनुप्रयोगहरूको आवश्यकताहरूको लागि छुट्टै भण्डार राखिएको छ https://github.com/libbpf/libbpf जसमा कर्नेल लाइब्रेरीलाई कम वा कम पढ्नको लागि मिरर गरिएको छ।

यस खण्डमा हामी तपाइँ कसरी प्रयोग गर्ने परियोजना सिर्जना गर्न सक्नुहुन्छ भनेर हेर्नेछौं libbpf, धेरै (अधिक वा कम अर्थहीन) परीक्षण कार्यक्रमहरू लेखौं र यो सबै कसरी काम गर्दछ विस्तृत रूपमा विश्लेषण गरौं। यसले हामीलाई BPF कार्यक्रमहरूले नक्सा, कर्नेल सहयोगीहरू, BTF, इत्यादिसँग कसरी अन्तरक्रिया गर्छ भनेर निम्न खण्डहरूमा अझ सजिलै व्याख्या गर्न अनुमति दिनेछ।

सामान्यतया परियोजनाहरू प्रयोग गर्दै libbpf गिट सबमोड्युलको रूपमा GitHub भण्डार थप्नुहोस्, हामी त्यसै गर्नेछौं:

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

जाँदै libbpf एकदम सजिलो:

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

यस खण्डमा हाम्रो अर्को योजना निम्नानुसार छ: हामी BPF कार्यक्रम जस्तै लेख्नेछौं BPF_PROG_TYPE_XDP, अघिल्लो उदाहरणमा जस्तै, तर C मा, हामी यसलाई प्रयोग गरेर कम्पाइल गर्छौं clang, र एउटा सहायक प्रोग्राम लेख्नुहोस् जसले यसलाई कर्नेलमा लोड गर्नेछ। निम्न खण्डहरूमा हामी BPF कार्यक्रम र सहायक कार्यक्रम दुवैको क्षमता विस्तार गर्नेछौं।

उदाहरण: libbpf प्रयोग गरेर पूर्ण अनुप्रयोग सिर्जना गर्दै

सुरु गर्न, हामी फाइल प्रयोग गर्छौं /sys/kernel/btf/vmlinux, जुन माथि उल्लेख गरिएको थियो, र हेडर फाइलको रूपमा यसको बराबर सिर्जना गर्नुहोस्:

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

यो फाइलले हाम्रो कर्नेलमा उपलब्ध सबै डाटा संरचनाहरू भण्डारण गर्नेछ, उदाहरणका लागि, कर्नेलमा IPv4 हेडरलाई यसरी परिभाषित गरिएको छ:

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

अब हामी हाम्रो BPF कार्यक्रम C मा लेख्नेछौं:

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

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

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

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

हामी हाम्रो कार्यक्रम llvm/clang, संस्करण >= 10.0.0, वा अझ राम्रो, ठूलो प्रयोग गरेर कम्पाइल गर्न सक्छौं (खण्ड हेर्नुहोस् विकास उपकरणहरू):

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

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

रोचक सुविधाहरू बीच: हामी लक्ष्य वास्तुकला संकेत गर्छौं -target bpf र हेडरहरूको लागि बाटो libbpf, जुन हामीले भर्खरै स्थापना गरेका छौं। साथै, को बारे मा नबिर्सनुहोस् -O2, यो विकल्प बिना तपाईं भविष्यमा आश्चर्यको लागि हुन सक्नुहुन्छ। हाम्रो कोड हेरौं, के हामीले चाहेको प्रोग्राम लेख्न व्यवस्थित गर्यौं?

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

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

Disassembly of section xdp/simple:

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

हो, यसले काम गर्यो! अब, हामीसँग प्रोग्रामसँग बाइनरी फाइल छ, र हामी एउटा अनुप्रयोग सिर्जना गर्न चाहन्छौं जसले यसलाई कर्नेलमा लोड गर्नेछ। यस उद्देश्यका लागि पुस्तकालय libbpf हामीलाई दुई विकल्पहरू प्रदान गर्दछ - निम्न-स्तर API वा उच्च-स्तर API प्रयोग गर्नुहोस्। हामी दोस्रो तरिकामा जानेछौं, किनकि हामी BPF कार्यक्रमहरू कसरी लेख्ने, लोड गर्ने र जोड्ने भनेर सिक्न चाहन्छौं तिनीहरूको पछिल्लो अध्ययनको लागि न्यूनतम प्रयासमा।

पहिले, हामीले उही उपयोगिता प्रयोग गरेर यसको बाइनरीबाट हाम्रो कार्यक्रमको "कङ्काल" उत्पन्न गर्न आवश्यक छ। bpftool - BPF संसारको स्विस चक्कु (जसलाई शाब्दिक रूपमा लिन सकिन्छ, किनकि BPF को सिर्जनाकर्ता र रखरखावकर्ताहरू मध्ये एक डेनियल बोर्कम्यान स्विस हुन्):

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

फाइलमा xdp-simple.skel.h हाम्रो कार्यक्रमको बाइनरी कोड र व्यवस्थापनका लागि कार्यहरू समावेश गर्दछ - लोड गर्ने, संलग्न गर्ने, हाम्रो वस्तु मेटाउने। हाम्रो साधारण अवस्थामा यो overkill जस्तो देखिन्छ, तर यसले वस्तु फाइलमा धेरै BPF प्रोग्रामहरू र नक्साहरू समावेश गरेको अवस्थामा पनि काम गर्दछ र यो विशाल ELF लोड गर्न हामीले केवल कंकाल उत्पन्न गर्न आवश्यक छ र अनुकूलन अनुप्रयोगबाट एक वा दुई प्रकार्यहरू कल गर्न आवश्यक छ। लेख्दै हुनुहुन्छ अब अगाडि बढौं।

कडा शब्दमा, हाम्रो लोडर कार्यक्रम तुच्छ छ:

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

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

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

    pause();

    xdp_simple_bpf__destroy(obj);
}

यो छ struct xdp_simple_bpf फाइलमा परिभाषित xdp-simple.skel.h र हाम्रो वस्तु फाइल वर्णन गर्दछ:

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

हामी यहाँ निम्न-स्तर API को ट्रेसहरू देख्न सक्छौं: संरचना struct bpf_program *simple и struct bpf_link *simple। पहिलो संरचनाले विशेष रूपमा हाम्रो कार्यक्रमको वर्णन गर्दछ, खण्डमा लेखिएको xdp/simple, र दोस्रोले कार्यक्रम कसरी घटना स्रोतमा जडान हुन्छ भनेर वर्णन गर्दछ।

समारोह xdp_simple_bpf__open_and_load, एउटा ELF वस्तु खोल्छ, यसलाई पार्स गर्छ, सबै संरचना र सबस्ट्रक्चरहरू सिर्जना गर्दछ (कार्यक्रम बाहेक, ELF ले अन्य खण्डहरू पनि समावेश गर्दछ - डाटा, केवल पढ्ने डाटा, डिबगिङ जानकारी, इजाजतपत्र, आदि), र त्यसपछि प्रणाली प्रयोग गरेर कर्नेलमा लोड गर्दछ। कल गर्नुहोस् bpf, जुन हामीले कम्पाइल र कार्यक्रम चलाएर जाँच गर्न सक्छौं:

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

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

अब हाम्रो कार्यक्रम प्रयोग गरेर हेरौं bpftool। उनको परिचय पत्र फेला पारौं:

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

र डम्प (हामी आदेशको छोटो रूप प्रयोग गर्दछौं bpftool prog dump xlated):

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

केहि नयाँ! कार्यक्रमले हाम्रो C स्रोत फाइलको टुक्रा प्रिन्ट गर्यो। यो पुस्तकालयले गरेको थियो libbpf, जसले बाइनरीमा डिबग खण्ड फेला पार्यो, यसलाई BTF वस्तुमा कम्पाइल गर्यो, यसलाई प्रयोग गरेर कर्नेलमा लोड गर्यो। BPF_BTF_LOAD, र त्यसपछि आदेशको साथ कार्यक्रम लोड गर्दा परिणाम फाइल वर्णनकर्ता निर्दिष्ट गर्नुहोस् BPG_PROG_LOAD.

कर्नेल सहयोगीहरू

BPF कार्यक्रमहरूले "बाह्य" प्रकार्यहरू चलाउन सक्छ - कर्नेल सहायकहरू। यी सहायक प्रकार्यहरूले BPF कार्यक्रमहरूलाई कर्नेल संरचनाहरू पहुँच गर्न, नक्साहरू व्यवस्थापन गर्न, र "वास्तविक संसार" सँग सञ्चार गर्न अनुमति दिन्छ - perf घटनाहरू सिर्जना गर्नुहोस्, हार्डवेयर नियन्त्रण गर्नुहोस् (उदाहरणका लागि, प्याकेटहरू पुन: निर्देशित गर्नुहोस्), आदि।

उदाहरण: bpf_get_smp_processor_id

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

BPF_CALL_0(bpf_get_smp_processor_id)
{
    return smp_processor_id();
}

BPF सहायक प्रकार्य परिभाषाहरू लिनक्स प्रणाली कल परिभाषाहरू जस्तै छन्। यहाँ, उदाहरणका लागि, एउटा प्रकार्य परिभाषित गरिएको छ जसमा कुनै तर्क छैन। (एक प्रकार्य जसले लिन्छ, भन्नुहोस्, म्याक्रो प्रयोग गरेर तीन तर्कहरू परिभाषित गरिएको छ BPF_CALL_3। तर्कहरूको अधिकतम संख्या पाँच हो।) यद्यपि, यो परिभाषाको पहिलो भाग मात्र हो। दोस्रो भाग प्रकार संरचना परिभाषित गर्न छ struct bpf_func_proto, जसमा सहायक प्रकार्यको विवरण समावेश छ जुन प्रमाणिकरणकर्ताले बुझ्दछ:

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

सहायक कार्यहरू दर्ता गर्दै

यो प्रकार्य प्रयोग गर्नको लागि एक विशेष प्रकारको BPF कार्यक्रमहरूको लागि, तिनीहरूले यसलाई दर्ता गर्नुपर्छ, उदाहरणका लागि प्रकारको लागि BPF_PROG_TYPE_XDP एक प्रकार्य कर्नेल मा परिभाषित गरिएको छ xdp_func_proto, जसले सहायक प्रकार्य ID बाट XDP ले यो प्रकार्यलाई समर्थन गर्छ वा गर्दैन भनेर निर्धारण गर्छ। हाम्रो कार्य हो समर्थन गर्दछ:

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

नयाँ BPF कार्यक्रम प्रकारहरू फाइलमा "परिभाषित" छन् include/linux/bpf_types.h म्याक्रो प्रयोग गर्दै BPF_PROG_TYPE। उद्धरणहरूमा परिभाषित गरिएको छ किनभने यो तार्किक परिभाषा हो, र C भाषाका सर्तहरूमा ठोस संरचनाहरूको सम्पूर्ण सेटको परिभाषा अन्य ठाउँहरूमा हुन्छ। विशेष गरी, फाइलमा kernel/bpf/verifier.c फाइलबाट सबै परिभाषाहरू bpf_types.h संरचनाहरूको एर्रे बनाउन प्रयोग गरिन्छ bpf_verifier_ops[]:

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

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

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

यहाँ हामी हाम्रो परिचित प्रकार्य देख्छौं xdp_func_proto, जसले प्रत्येक पटक चुनौतीको सामना गर्दा प्रमाणिकरण चलाउनेछ केहि BPF कार्यक्रम भित्र कार्यहरू, हेर्नुहोस् verifier.c.

काल्पनिक BPF कार्यक्रमले प्रकार्यलाई कसरी प्रयोग गर्छ हेरौं bpf_get_smp_processor_id। यो गर्नको लागि, हामी हाम्रो अघिल्लो खण्डबाट कार्यक्रमलाई निम्नानुसार पुन: लेख्छौं:

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

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

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

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

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

त्यो हो, bpf_get_smp_processor_id एक प्रकार्य सूचक हो जसको मान 8 हो, जहाँ 8 मान हो BPF_FUNC_get_smp_processor_id टाइप गर्नुहोस् enum bpf_fun_id, जुन हाम्रो लागि फाइलमा परिभाषित गरिएको छ vmlinux.h (फाइल bpf_helper_defs.h कर्नेलमा लिपिद्वारा उत्पन्न हुन्छ, त्यसैले "जादू" नम्बरहरू ठीक छन्)। यो प्रकार्यले कुनै तर्क लिदैन र प्रकारको मान फर्काउँछ __u32। जब हामी यसलाई हाम्रो कार्यक्रममा चलाउँछौं, clang निर्देशन उत्पन्न गर्दछ BPF_CALL "सही प्रकारको" कार्यक्रम संकलन गरौं र खण्ड हेरौं xdp/simple:

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

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

Disassembly of section xdp/simple:

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

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

पहिलो पङ्क्तिमा हामी निर्देशनहरू देख्छौं call, प्यारामिटर IMM जुन 8 को बराबर छ, र SRC_REG - शून्य। प्रमाणिकरणकर्ता द्वारा प्रयोग गरिएको ABI सम्झौता अनुसार, यो सहायक प्रकार्य नम्बर आठ को लागी कल हो। एक पटक यो सुरु भएपछि, तर्क सरल छ। दर्ताबाट मूल्य फिर्ता गर्नुहोस् r0 मा प्रतिलिपि गरियो r1 र लाइनहरु 2,3 मा यो टाइप मा रूपान्तरित छ u32 - माथिल्लो 32 बिटहरू खाली छन्। लाइन 4,5,6,7 मा हामी 2 फर्काउँछौं (XDP_PASS) वा १ (XDP_DROP) रेखा ० बाट सहायक प्रकार्यले शून्य वा गैर-शून्य मान फर्काएकोमा निर्भर गर्दछ।

आफैलाई परीक्षण गरौं: कार्यक्रम लोड गर्नुहोस् र आउटपुट हेर्नुहोस् bpftool prog dump xlated:

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

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

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

ठीक छ, प्रमाणिकरणकर्ताले सही कर्नेल-हेल्पर फेला पार्यो।

उदाहरण: तर्कहरू पास गर्दै र अन्तमा कार्यक्रम चलाउँदै!

सबै रन-स्तर सहयोगी प्रकार्यहरूसँग प्रोटोटाइप छ

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

सहायक प्रकार्यहरूमा प्यारामिटरहरू दर्ताहरूमा पास हुन्छन् r1-r5, र मान दर्तामा फर्काइन्छ r0। त्यहाँ पाँच भन्दा बढी तर्कहरू लिने कुनै प्रकार्यहरू छैनन्, र तिनीहरूका लागि समर्थन भविष्यमा थपिने अपेक्षा गरिएको छैन।

नयाँ कर्नेल हेल्पर र BPF ले प्यारामिटरहरू कसरी पास गर्छ भनेर हेरौं। फेरि लेखौं xdp-simple.bpf.c निम्नानुसार (बाँकी रेखाहरू परिवर्तन भएका छैनन्):

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

हाम्रो कार्यक्रमले 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 वा एक अनन्त लूप: हाम्रो लोडर कार्यक्रम बाहिर निस्कनेछ, तर घटना स्रोतमा जडान भएकोले BPF कार्यक्रम मारिनेछैन। सफल डाउनलोड र जडान पछि, कार्यक्रम प्रत्येक नेटवर्क प्याकेटमा आइपुग्दा सुरु गरिनेछ lo.

कार्यक्रम डाउनलोड गरौं र इन्टरफेस हेरौं lo:

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

हामीले डाउनलोड गरेको कार्यक्रममा ID 669 छ र हामी इन्टरफेसमा उही ID देख्छौं lo। हामी केही प्याकेजहरू पठाउनेछौं 127.0.0.1 (अनुरोध + जवाफ):

$ ping -c1 localhost

र अब डिबग भर्चुअल फाइलको सामग्री हेरौं /sys/kernel/debug/tracing/trace_pipe, जसमा bpf_printk आफ्ना सन्देशहरू लेख्छन्:

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

दुईवटा प्याकेज भेटिए lo र CPU0 मा प्रशोधन गरियो - हाम्रो पहिलो पूर्ण अर्थहीन BPF कार्यक्रमले काम गर्यो!

यो ध्यान दिन लायक छ bpf_printk यो डिबग फाइलमा लेख्ने कुनै पनि कुराको लागि होइन: यो उत्पादनमा प्रयोगको लागि सबैभन्दा सफल सहायक होइन, तर हाम्रो लक्ष्य केहि सरल देखाउने थियो।

BPF कार्यक्रमहरूबाट नक्साहरू पहुँच गर्दै

उदाहरण: BPF कार्यक्रमबाट नक्सा प्रयोग गर्दै

अघिल्लो खण्डहरूमा हामीले प्रयोगकर्ता स्पेसबाट नक्सा कसरी बनाउने र प्रयोग गर्ने भनेर सिकेका थियौं, र अब कर्नेल भाग हेरौं। सामान्य रूपमा, उदाहरणको साथ सुरू गरौं। हाम्रो कार्यक्रम पुन: लेखौं xdp-simple.bpf.c निम्न अनुसार:

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

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

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

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

    *val += 1;

    return XDP_PASS;
}

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

कार्यक्रमको सुरुमा हामीले नक्साको परिभाषा थप्यौं woo: यो 8-तत्व एरे हो जसले मानहरू जस्तै भण्डारण गर्दछ u64 (सी मा हामी यस्तो एरे परिभाषित गर्नेछौं u64 woo[8])। एक कार्यक्रममा "xdp/simple" हामीले हालको प्रोसेसर नम्बरलाई चरमा पाउँछौं key र त्यसपछि सहायक प्रकार्य प्रयोग गरेर bpf_map_lookup_element हामीले एरेमा सम्बन्धित प्रविष्टिमा एक सूचक पाउँछौं, जसलाई हामी एकले बढाउँछौं। रूसीमा अनुवादित: हामी तथ्याङ्कहरू गणना गर्छौं जसमा CPU ले आगमन प्याकेटहरू प्रशोधन गर्यो। कार्यक्रम चलाउन प्रयास गरौं:

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

उहाँसँग जोडिएको छ भनेर जाँच गरौं lo र केही प्याकेट पठाउनुहोस्:

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

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

अब एरेको सामग्री हेरौं:

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

लगभग सबै प्रक्रियाहरू CPU7 मा प्रशोधन गरिएको थियो। यो हाम्रो लागि महत्त्वपूर्ण छैन, मुख्य कुरा यो हो कि कार्यक्रमले काम गर्छ र हामीले BPF कार्यक्रमहरूबाट नक्साहरू कसरी पहुँच गर्ने भनेर बुझ्दछौं - प्रयोग गरेर хелперов bpf_mp_*.

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

त्यसोभए, हामी कलहरू प्रयोग गरेर BPF कार्यक्रमबाट नक्सा पहुँच गर्न सक्छौं

val = bpf_map_lookup_elem(&woo, &key);

जहाँ सहायक प्रकार्य जस्तो देखिन्छ

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

तर हामी एक सूचक पास गर्दैछौं &woo अज्ञात संरचनामा struct { ... }...

यदि हामी प्रोग्राम एसेम्बलरलाई हेर्छौं भने, हामी त्यो मान देख्छौं &woo वास्तवमा परिभाषित गरिएको छैन (लाइन ४):

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

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

Disassembly of section xdp/simple:

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

र स्थानान्तरणमा समावेश छ:

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

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

तर यदि हामीले पहिले नै लोड गरिएको प्रोग्रामलाई हेर्छौं भने, हामीले सही नक्सा (लाइन 4) मा एक सूचक देख्छौं:

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

यसैले, हामी निष्कर्षमा पुग्न सक्छौं कि हाम्रो लोडर कार्यक्रम सुरु गर्ने समयमा, लिङ्क &woo पुस्तकालय संग केहि द्वारा प्रतिस्थापित गरियो libbpf। पहिले हामी आउटपुट हेर्नेछौं strace:

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

हामी त्यो देख्छौं libbpf नक्सा बनाए woo र त्यसपछि हाम्रो कार्यक्रम डाउनलोड simple। हामी कसरी कार्यक्रम लोड गर्छौं भनेर नजिकबाट हेरौं:

कल xdp_simple_bpf__open_and_load फाइलबाट xdp-simple.skel.h
जसले गर्दा हुन्छ xdp_simple_bpf__load फाइलबाट xdp-simple.skel.h
जसले गर्दा हुन्छ bpf_object__load_skeleton फाइलबाट libbpf/src/libbpf.c
जसले गर्दा हुन्छ bpf_object__load_xattr बाट libbpf/src/libbpf.c

अन्तिम प्रकार्य, अन्य चीजहरू बीच, कल गर्नेछ bpf_object__create_maps, जसले अवस्थित नक्साहरू सिर्जना गर्दछ वा खोल्छ, तिनीहरूलाई फाइल वर्णनकर्ताहरूमा परिणत गर्दछ। (यहाँ हामी देख्छौं BPF_MAP_CREATE आउटपुट मा strace.) अर्को प्रकार्य भनिन्छ bpf_object__relocate र यो उहाँ हो जसले हामीलाई चासो राख्छ, किनकि हामीले देखेका कुरा सम्झन्छौं woo स्थानान्तरण तालिकामा। यसलाई अन्वेषण गर्दै, हामी अन्ततः कार्यमा आफूलाई भेट्टाउँछौं bpf_program__relocate, जुन नक्सा स्थानान्तरणसँग सम्बन्धित छ:

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

त्यसैले हामी हाम्रो निर्देशन लिन्छौं

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

र यसमा स्रोत दर्ता प्रतिस्थापन गर्नुहोस् BPF_PSEUDO_MAP_FD, र हाम्रो नक्साको फाइल वर्णनकर्तामा पहिलो IMM र, यदि यो बराबर छ भने, उदाहरणका लागि, 0xdeadbeef, त्यसपछि परिणामको रूपमा हामीले निर्देशन प्राप्त गर्नेछौं

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

यसरी नक्सा जानकारी एक विशिष्ट लोड गरिएको BPF कार्यक्रममा स्थानान्तरण गरिन्छ। यस अवस्थामा, नक्सा प्रयोग गरेर सिर्जना गर्न सकिन्छ BPF_MAP_CREATE, र ID प्रयोग गरेर खोलियो BPF_MAP_GET_FD_BY_ID.

कुल, प्रयोग गर्दा libbpf एल्गोरिथ्म निम्न छ:

संकलनको क्रममा, रेकर्डहरू नक्सामा लिङ्कहरूको लागि स्थानान्तरण तालिकामा सिर्जना गरिन्छ
libbpf ELF वस्तु पुस्तक खोल्छ, सबै प्रयोग गरिएका नक्साहरू फेला पार्छ र तिनीहरूका लागि फाइल वर्णनकर्ताहरू सिर्जना गर्दछ
फाइल वर्णनकर्ताहरू निर्देशनको भागको रूपमा कर्नेलमा लोड हुन्छन् LD64

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

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

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

(पूर्ण कोड फेला पार्न सकिन्छ लिङ्क)। त्यसैले हामी हाम्रो एल्गोरिथ्म विस्तार गर्न सक्छौं:

कार्यक्रम लोड गर्दा, प्रमाणिकरणकर्ताले नक्साको सही प्रयोग जाँच गर्छ र सम्बन्धित संरचनाको ठेगाना लेख्छ। struct bpf_map

प्रयोग गरेर ELF बाइनरी डाउनलोड गर्दा libbpf त्यहाँ धेरै कुरा भइरहेको छ, तर हामी अन्य लेखहरूमा छलफल गर्नेछौं।

libbpf बिना कार्यक्रम र नक्सा लोड गर्दै

प्रतिज्ञा गरे अनुसार, नक्सा प्रयोग गर्ने कार्यक्रम कसरी सिर्जना गर्ने र लोड गर्ने भनेर जान्न चाहने पाठकहरूका लागि यहाँ एउटा उदाहरण छ, बिना मद्दत libbpf। यो उपयोगी हुन सक्छ जब तपाइँ एक वातावरण मा काम गरिरहनु भएको छ जसको लागि तपाइँ निर्भरताहरू निर्माण गर्न सक्नुहुन्न, वा प्रत्येक बिट बचत गर्न सक्नुहुन्छ, वा प्रोग्राम लेख्न सक्नुहुन्छ। ply, जसले उडानमा BPF बाइनरी कोड उत्पन्न गर्दछ।

तर्कलाई पछ्याउन सजिलो बनाउन, हामी यी उद्देश्यहरूको लागि हाम्रो उदाहरण पुन: लेख्नेछौं xdp-simple। यस उदाहरणमा छलफल गरिएको कार्यक्रमको पूर्ण र थोरै विस्तारित कोड यसमा फेला पार्न सकिन्छ सार.

हाम्रो आवेदन को तर्क निम्नानुसार छ:

एक प्रकारको नक्सा सिर्जना गर्नुहोस् BPF_MAP_TYPE_ARRAY आदेश प्रयोग गरेर BPF_MAP_CREATE,
यो नक्सा प्रयोग गर्ने कार्यक्रम सिर्जना गर्नुहोस्,
कार्यक्रमलाई इन्टरफेसमा जडान गर्नुहोस् lo,

जुन मानवमा अनुवाद हुन्छ

int main(void)
{
    int map_fd, prog_fd;

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

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

    xdp_attach(1, prog_fd);
}

यो छ map_create हामीले प्रणाली कलको बारेमा पहिलो उदाहरणमा गरे जस्तै नक्सा सिर्जना गर्दछ bpf - "कर्नेल, कृपया मलाई 8 तत्वहरूको एर्रेको रूपमा नयाँ नक्सा बनाउनुहोस् __u64 र मलाई फाइल वर्णनकर्ता फिर्ता दिनुहोस्":

static int map_create()
{
    union bpf_attr attr;

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

कार्यक्रम पनि लोड गर्न सजिलो छ:

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

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

कठिन भाग prog_load संरचनाहरूको एर्रेको रूपमा हाम्रो BPF कार्यक्रमको परिभाषा हो struct bpf_insn insns[]। तर हामीले C मा भएको प्रोग्राम प्रयोग गर्दैछौं, हामी थोरै धोखा दिन सक्छौं:

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

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

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

कुलमा, हामीले संरचनाको रूपमा 14 निर्देशनहरू लेख्न आवश्यक छ struct bpf_insn (सल्लाह: माथिबाट डम्प लिनुहोस्, निर्देशन खण्ड पुन: पढ्नुहोस्, खोल्नुहोस् linux/bpf.h и linux/bpf_common.h र निर्धारण गर्न प्रयास गर्नुहोस् struct bpf_insn insns[] आफ्नै मा):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

जो आफैले यो लेखेका छैनन् को लागी एक अभ्यास - खोज्नुहोस् map_fd.

हाम्रो कार्यक्रममा अझै एक अज्ञात भाग बाँकी छ - xdp_attach। दुर्भाग्यवश, XDP जस्ता प्रोग्रामहरू प्रणाली कल प्रयोग गरेर जडान गर्न सकिँदैन bpf। BPF र XDP सिर्जना गर्ने व्यक्तिहरू अनलाइन लिनक्स समुदायबाट आएका थिए, जसको मतलब तिनीहरूले आफूलाई सबैभन्दा परिचित एक प्रयोग गरे (तर होइन। सामान्य मानिसहरू) कर्नेलसँग अन्तरक्रिया गर्नको लागि इन्टरफेस: नेटलिङ्क सकेटहरू, पनि हेर्नुहोस् 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 हामीले प्रकार जानकारी (BTF) लोड गरेका छैनौं। तर हामी अर्को पटक यस बारे थप कुरा गर्नेछौं।

विकास उपकरणहरू

यस खण्डमा, हामी न्यूनतम BPF विकासकर्ता टूलकिट हेर्नेछौं।

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

llvm/clang
pahole
यसको मूल
bpftool

(सन्दर्भको लागि, यो खण्ड र लेखमा सबै उदाहरणहरू डेबियन 10 मा चलाइएको थियो।)

llvm/clang

BPF LLVM सँग मैत्री छ र, हालसालै BPF को लागि कार्यक्रमहरू gcc प्रयोग गरेर कम्पाइल गर्न सकिन्छ, सबै हालको विकास LLVM को लागी गरिन्छ। त्यसैले, सबै भन्दा पहिले, हामी हालको संस्करण निर्माण गर्नेछौं clang git बाट:

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

अब हामी जाँच गर्न सक्छौं कि सबै कुरा सही रूपमा सँगै आए:

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

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

(विधानसभा निर्देशनहरू clang मबाट लिएको bpf_devel_QA.)

हामीले भर्खरै बनाएका प्रोग्रामहरू स्थापना गर्ने छैनौं, तर बरु तिनीहरूलाई थप्नुहोस् PATH, उदाहरणका लागि:

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

(यो थप्न सकिन्छ .bashrc वा छुट्टै फाइलमा। व्यक्तिगत रूपमा, म यस्ता चीजहरू थप्छु ~/bin/activate-llvm.sh र आवश्यक हुँदा म गर्छु . activate-llvm.sh.)

Pahole र BTF

उपयोगिता pahole BTF ढाँचामा डिबगिङ जानकारी सिर्जना गर्न कर्नेल निर्माण गर्दा प्रयोग गरिन्छ। हामी यस लेखमा BTF प्रविधिको विवरणहरूको बारेमा विस्तृत रूपमा जानेछैनौं, यो सुविधाजनक छ र हामी यसलाई प्रयोग गर्न चाहन्छौं। त्यसैले यदि तपाइँ आफ्नो कर्नेल निर्माण गर्न जाँदै हुनुहुन्छ भने, पहिले निर्माण गर्नुहोस् pahole (बिना) pahole तपाईले विकल्पको साथ कर्नेल निर्माण गर्न सक्नुहुने छैन CONFIG_DEBUG_INFO_BTF:

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

BPF को साथ प्रयोग को लागी कर्नेल

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

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

कर्नेल कन्फिगरेसन फाइलहरू कसरी प्रबन्ध गर्ने भन्ने बारे कुरा गर्न यो लेखको दायराभन्दा बाहिर छ - यो मानिन्छ कि तपाईलाई यो कसरी गर्ने भनेर पहिले नै थाहा छ, वा सिक्न तयार छ आफ्नै मा। यद्यपि, निम्न निर्देशनहरू तपाईंलाई काम गर्ने BPF-सक्षम प्रणाली दिनको लागि पर्याप्त हुनुपर्दछ।

माथिको कर्नेल मध्ये एउटा डाउनलोड गर्नुहोस्:

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

न्यूनतम काम गर्ने कर्नेल कन्फिगरेसन बनाउनुहोस्:

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

फाइलमा BPF विकल्पहरू सक्षम गर्नुहोस् .config तपाईको आफ्नै छनौटको (सम्भवतः CONFIG_BPF पहिले नै सक्षम हुनेछ किनभने systemd यसलाई प्रयोग गर्दछ)। यहाँ यस लेखको लागि प्रयोग गरिएको कर्नेलबाट विकल्पहरूको सूची छ:

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

त्यसोभए हामी सजिलैसँग मोड्युलहरू र कर्नेलहरू जम्मा र स्थापना गर्न सक्छौं (यसैले, तपाईंले भर्खरै जम्मा गरिएको प्रयोग गरेर कर्नेललाई एसेम्बल गर्न सक्नुहुन्छ। clangथपेर CC=clang):

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

र नयाँ कर्नेलसँग रिबुट गर्नुहोस् (म यसको लागि प्रयोग गर्दछु kexec प्याकेजबाट kexec-tools):

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

bpftool

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

यो लेखन को समयमा bpftool RHEL, Fedora र Ubuntu को लागि मात्र तयार-निर्मित आउँछ (उदाहरणका लागि हेर्नुहोस्, यो धागो, जसले प्याकेजिङको अधूरो कथा बताउँछ bpftool डेबियन मा)। तर यदि तपाईंले पहिले नै आफ्नो कर्नेल निर्माण गर्नुभएको छ भने, त्यसपछि निर्माण गर्नुहोस् bpftool पाई जस्तै सजिलो:

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

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

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

$

(यहाँ ${linux} - यो तपाईंको कर्नेल डाइरेक्टरी हो।) यी आदेशहरू कार्यान्वयन गरेपछि bpftool निर्देशिकामा संकलन गरिनेछ ${linux}/tools/bpf/bpftool र यसलाई मार्गमा थप्न सकिन्छ (सबैभन्दा पहिले प्रयोगकर्तालाई root) वा केवल प्रतिलिपि गर्नुहोस् /usr/local/sbin.

सङ्कलन गर्नुहोस् bpftool यो पछिल्लो प्रयोग गर्न सबै भन्दा राम्रो छ clang, माथि वर्णन गरिए अनुसार जम्मा गरियो, र जाँच गर्नुहोस् कि यो सही रूपमा भेला भएको छ - प्रयोग गरेर, उदाहरणका लागि, आदेश

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

जसले तपाइँको कर्नेलमा कुन BPF सुविधाहरू सक्षम पारिएको देखाउनेछ।

वैसे, अघिल्लो आदेश को रूपमा चलाउन सकिन्छ

# bpftool f p k

यो प्याकेजबाट उपयोगिताहरु संग समानता द्वारा गरिन्छ iproute2, जहाँ हामी, उदाहरण को लागी, भन्न सक्छौं ip a s eth0 को सट्टा ip addr show dev eth0.

निष्कर्षमा

BPF ले तपाईंलाई प्रभावकारी रूपमा मापन गर्न र फ्लाईमा कोरको कार्यक्षमता परिवर्तन गर्न फ्लीलाई जुत्ता लगाउन अनुमति दिन्छ। प्रणाली धेरै सफल भएको छ, UNIX को उत्कृष्ट परम्पराहरूमा: एक साधारण संयन्त्र जसले तपाईंलाई कर्नेललाई (पुनः) कार्यक्रम गर्न अनुमति दिन्छ जसले ठूलो संख्यामा मानिसहरू र संस्थाहरूलाई प्रयोग गर्न अनुमति दिन्छ। र, यद्यपि प्रयोगहरू, साथै BPF पूर्वाधारको विकास आफैं, समाप्त हुनबाट टाढा छन्, प्रणालीसँग पहिले नै एक स्थिर ABI छ जसले तपाईंलाई विश्वसनीय, र सबैभन्दा महत्त्वपूर्ण, प्रभावकारी व्यापार तर्क निर्माण गर्न अनुमति दिन्छ।

म नोट गर्न चाहन्छु कि, मेरो विचारमा, टेक्नोलोजी धेरै लोकप्रिय भएको छ किनभने, एकतर्फ, यो गर्न सक्छ खेल्नु (मेसिनको वास्तुकला एक साँझमा कम वा कम बुझ्न सकिन्छ), र अर्कोतर्फ, यसको उपस्थिति अघि (सुन्दर रूपमा) समाधान गर्न नसकिने समस्याहरू समाधान गर्न। यी दुई कम्पोनेन्टहरूले मानिसहरूलाई प्रयोग गर्न र सपना देख्न बाध्य पार्छन्, जसले थप र अधिक नवीन समाधानहरूको उदयमा जान्छ।

यो लेख, यद्यपि विशेष रूपमा छोटो छैन, BPF को संसारको मात्र एक परिचय हो र "उन्नत" सुविधाहरू र वास्तुकलाको महत्त्वपूर्ण भागहरू वर्णन गर्दैन। अगाडि बढ्ने योजना यस्तो छ: अर्को लेख BPF कार्यक्रम प्रकारहरूको एक सिंहावलोकन हुनेछ (त्यहाँ 5.8 कर्नेलमा 30 प्रोग्राम प्रकारहरू समर्थित छन्), त्यसपछि हामी अन्तमा कर्नेल ट्रेसिङ प्रोग्रामहरू प्रयोग गरेर वास्तविक BPF अनुप्रयोगहरू कसरी लेख्ने भनेर हेर्नेछौं। उदाहरणको रूपमा, त्यसपछि BPF वास्तुकलामा थप गहिरो पाठ्यक्रमको लागि समय हो, त्यसपछि BPF नेटवर्किङ र सुरक्षा अनुप्रयोगहरूको उदाहरणहरू।

यस श्रृंखलामा अघिल्लो लेखहरू

सानाहरूका लागि BPF, भाग शून्य: क्लासिक BPF

लिङ्कहरू

BPF र XDP सन्दर्भ गाइड — cilium बाट BPF मा कागजात, वा BPF को सिर्जनाकर्ता र रखरखावकर्ताहरू मध्ये एक ड्यानियल बोर्कम्यानबाट। यो पहिलो गम्भीर विवरणहरू मध्ये एक हो, जुन अरूहरू भन्दा फरक छ कि डेनियललाई उसले के लेखिरहेको छ भन्ने कुरा थाहा छ र त्यहाँ कुनै गल्तीहरू छैनन्। विशेष गरी, यस कागजातले XDP र TC प्रकारका BPF कार्यक्रमहरूसँग कसरी परिचित उपयोगिता प्रयोग गरेर काम गर्ने भनेर वर्णन गर्दछ। ip प्याकेजबाट iproute2.
Documentation/networking/filter.txt - क्लासिक र त्यसपछि विस्तारित BPF को लागि दस्तावेज संग मूल फाइल। यदि तपाइँ विधानसभा भाषा र प्राविधिक वास्तुकला विवरणहरूमा जान चाहनुहुन्छ भने राम्रो पढ्नुहोस्।
फेसबुकबाट BPF बारे ब्लग। यो विरलै अपडेट गरिएको छ, तर उपयुक्त रूपमा, Alexei Starovoitov (eBPF का लेखक) र Andrii Nakryiko - (संरक्षणकर्ता) त्यहाँ लेख्छन्। libbpf).
bpftool को रहस्य। उदाहरणहरू र bpftool प्रयोग गर्ने रहस्यहरू सहित Quentin Monnet बाट मनोरञ्जनात्मक ट्विटर थ्रेड।
BPF मा डुब्नुहोस्: पठन सामग्रीको सूची। Quentin Monnet बाट BPF कागजातमा लिङ्कहरूको विशाल (र अझै राखिएको) सूची।

स्रोत: www.habr.com

सानाहरूका लागि BPF, भाग एक: विस्तारित BPF