ការណែនាំសង្ខេបអំពី BPF និង eBPF

សួស្តី ហាប! យើង​សូម​ជម្រាប​ជូន​លោក​អ្នក​ថា យើង​កំពុង​រៀបចំ​សៀវភៅ​សម្រាប់​ចេញ​ផ្សាយ»។លីនុច Observability ជាមួយ BPF".

ដោយសារម៉ាស៊ីននិម្មិត BPF បន្តវិវឌ្ឍ និងត្រូវបានប្រើប្រាស់យ៉ាងសកម្មក្នុងការអនុវត្ត យើងបានបកប្រែសម្រាប់អ្នកនូវអត្ថបទដែលពិពណ៌នាអំពីសមត្ថភាពចម្បង និងស្ថានភាពបច្ចុប្បន្នរបស់វា។

ក្នុងរយៈពេលប៉ុន្មានឆ្នាំចុងក្រោយនេះ ឧបករណ៍ និងបច្ចេកទេសសរសេរកម្មវិធីបានក្លាយជាការពេញនិយមកាន់តែខ្លាំងឡើងដើម្បីទូទាត់សងសម្រាប់ដែនកំណត់នៃខឺណែលលីនុច ក្នុងករណីដែលតម្រូវឱ្យដំណើរការកញ្ចប់ព័ត៌មានដែលមានប្រសិទ្ធភាពខ្ពស់។ បច្ចេកទេសដ៏ពេញនិយមបំផុតមួយនៃប្រភេទនេះត្រូវបានគេហៅថា ផ្លូវវាងខឺណែល (ផ្លូវវាងខឺណែល) និងអនុញ្ញាតឱ្យឆ្លងកាត់ស្រទាប់បណ្តាញខឺណែល ដើម្បីដំណើរការដំណើរការកញ្ចប់ព័ត៌មានទាំងអស់ពីទំហំអ្នកប្រើប្រាស់។ ការរំលងខឺណែលក៏ពាក់ព័ន្ធនឹងការគ្រប់គ្រងកាតបណ្តាញពី ចន្លោះអ្នកប្រើប្រាស់. និយាយម្យ៉ាងទៀតនៅពេលធ្វើការជាមួយកាតបណ្តាញយើងពឹងផ្អែកលើអ្នកបើកបរ ចន្លោះអ្នកប្រើប្រាស់.

តាមរយៈការផ្ទេរការគ្រប់គ្រងពេញលេញនៃកាតបណ្តាញទៅកម្មវិធី user-space យើងកាត់បន្ថយខឺណែលលើស (ការផ្លាស់ប្តូរបរិបទ ដំណើរការស្រទាប់បណ្តាញ ការរំខាន។ល។) ដែលមានសារៈសំខាន់ណាស់នៅពេលដំណើរការក្នុងល្បឿន 10Gb/s ឬខ្ពស់ជាងនេះ។ Kernel bypass បូករួមផ្សំនៃលក្ខណៈពិសេសផ្សេងទៀត (ដំណើរការបាច់) និងការលៃតម្រូវការអនុវត្តដោយប្រុងប្រយ័ត្ន (គណនេយ្យ NUMA, ភាពឯកោ CPUល) ត្រូវគ្នាទៅនឹងមូលដ្ឋានគ្រឹះនៃដំណើរការបណ្តាញដែលមានប្រសិទ្ធភាពខ្ពស់ក្នុងចន្លោះអ្នកប្រើប្រាស់។ ប្រហែលជាឧទាហរណ៍គំរូនៃវិធីសាស្រ្តថ្មីនេះចំពោះដំណើរការកញ្ចប់ព័ត៌មាន ឌី។ ភី។ ឌី។ ខេ ពី Intel (កញ្ចប់អភិវឌ្ឍន៍យន្តហោះទិន្នន័យ) ទោះបីជាមានឧបករណ៍ និងបច្ចេកទេសល្បីៗផ្សេងទៀត រួមទាំង VPP របស់ Cisco (Vector Packet Processing) Netmap និងជាការពិត។ Snabb.

ការរៀបចំអន្តរកម្មបណ្តាញក្នុងចន្លោះអ្នកប្រើប្រាស់មានគុណវិបត្តិមួយចំនួន៖

• ខឺណែល OS គឺជាស្រទាប់អរូបីសម្រាប់ធនធានផ្នែករឹង។ ដោយសារតែកម្មវិធីអវកាសអ្នកប្រើប្រាស់ត្រូវគ្រប់គ្រងធនធានរបស់ពួកគេដោយផ្ទាល់ ពួកគេក៏ត្រូវគ្រប់គ្រងផ្នែករឹងរបស់ពួកគេផងដែរ។ នេះច្រើនតែមានន័យថាត្រូវរៀបចំកម្មវិធីបញ្ជាផ្ទាល់របស់អ្នក។
• ដោយសារតែយើងបោះបង់ចោលទំហំខឺណែលទាំងស្រុង យើងក៏នឹងបោះបង់មុខងារបណ្តាញទាំងអស់ដែលផ្តល់ដោយខឺណែលផងដែរ។ កម្មវិធីលំហរបស់អ្នកប្រើត្រូវតែបំពេញមុខងារឡើងវិញដែលអាចត្រូវបានផ្តល់ដោយខឺណែល ឬប្រព័ន្ធប្រតិបត្តិការរួចហើយ។
• កម្មវិធីដំណើរការនៅក្នុងរបៀប sandbox ដែលកំណត់យ៉ាងធ្ងន់ធ្ងរនូវអន្តរកម្មរបស់ពួកគេ និងរារាំងពួកគេពីការរួមបញ្ចូលជាមួយផ្នែកផ្សេងទៀតនៃប្រព័ន្ធប្រតិបត្តិការ។

នៅក្នុងខ្លឹមសារ នៅពេលដែលបណ្តាញនៅក្នុងចន្លោះអ្នកប្រើប្រាស់ ការកើនឡើងនៃដំណើរការត្រូវបានសម្រេចដោយការផ្លាស់ប្តូរដំណើរការកញ្ចប់ព័ត៌មានពីខឺណែលទៅកាន់ទំហំអ្នកប្រើប្រាស់។ XDP ធ្វើផ្ទុយពីនេះ៖ វាផ្លាស់ទីកម្មវិធីបណ្តាញពីចន្លោះអ្នកប្រើប្រាស់ (តម្រង អ្នកដោះស្រាយ ការកំណត់ផ្លូវ។ល។) ទៅក្នុងចន្លោះខឺណែល។ XDP អនុញ្ញាតឱ្យយើងអនុវត្តមុខងារបណ្តាញមួយភ្លាមៗនៅពេលដែលកញ្ចប់ព័ត៌មានប៉ះចំណុចប្រទាក់បណ្តាញ និងមុនពេលវាចាប់ផ្តើមផ្លាស់ទីទៅក្នុងប្រព័ន្ធរងបណ្តាញខឺណែល។ ជាលទ្ធផល ល្បឿនដំណើរការកញ្ចប់ព័ត៌មានកើនឡើងយ៉ាងខ្លាំង។ ទោះយ៉ាងណាក៏ដោយ តើខឺណែលអនុញ្ញាតឱ្យអ្នកប្រើប្រតិបត្តិកម្មវិធីរបស់ពួកគេដោយរបៀបណា? មុននឹងឆ្លើយសំណួរនេះ សូមក្រឡេកមើលថាតើ BPF ជាអ្វី?

BPF និង eBPF

ទោះបីជាឈ្មោះច្រឡំក៏ដោយ BPF (Berkeley Packet Filtering) តាមពិតគឺជាគំរូម៉ាស៊ីននិម្មិត។ ម៉ាស៊ីននិម្មិតនេះត្រូវបានរចនាឡើងដំបូងដើម្បីគ្រប់គ្រងការត្រងកញ្ចប់ព័ត៌មាន ដូច្នេះឈ្មោះ។

ឧបករណ៍ដ៏ល្បីល្បាញបំផុតមួយដោយប្រើ BPF គឺ tcpdump. នៅពេលចាប់យកកញ្ចប់ព័ត៌មានដោយប្រើ tcpdump អ្នកប្រើប្រាស់អាចបញ្ជាក់កន្សោមមួយដើម្បីត្រងកញ្ចប់ព័ត៌មាន។ មានតែកញ្ចប់ព័ត៌មានដែលផ្គូផ្គងកន្សោមនេះទេដែលនឹងត្រូវបានចាប់យក។ ឧទាហរណ៍ កន្សោម "tcp dst port 80” សំដៅលើកញ្ចប់ព័ត៌មាន TCP ទាំងអស់ដែលមកដល់ច្រក 80។ កម្មវិធីចងក្រងអាចបង្រួមកន្សោមនេះដោយបំប្លែងវាទៅជា BPF bytecode ។

$ sudo tcpdump -d "tcp dst port 80"
(000) ldh [12] (001) jeq #0x86dd jt 2 jf 6
(002) ldb [20] (003) jeq #0x6 jt 4 jf 15
(004) ldh [56] (005) jeq #0x50 jt 14 jf 15
(006) jeq #0x800 jt 7 jf 15
(007) ldb [23] (008) jeq #0x6 jt 9 jf 15
(009) ldh [20] (010) jset #0x1fff jt 15 jf 11
(011) ldxb 4*([14]&0xf)
(012) ldh [x + 16] (013) jeq #0x50 jt 14 jf 15
(014) ret #262144
(015) ret #0

នេះជាអ្វីដែលកម្មវិធីខាងលើធ្វើជាមូលដ្ឋាន៖

• សេចក្តីណែនាំ (000): ផ្ទុកកញ្ចប់ព័ត៌មាននៅអុហ្វសិត 12 ជាពាក្យ 16 ប៊ីត ទៅក្នុង accumulator ។ អុហ្វសិត 12 ត្រូវគ្នាទៅនឹង ethertype នៃកញ្ចប់ព័ត៌មាន។
• សេចក្តីណែនាំ (001)៖ ប្រៀបធៀបតម្លៃនៅក្នុង accumulator ជាមួយ 0x86dd ពោលគឺជាមួយនឹងតម្លៃ ethertype សម្រាប់ IPv6។ ប្រសិនបើលទ្ធផលគឺពិត នោះកម្មវិធីរាប់បញ្ចូលទៅក្នុងការណែនាំ (002) ហើយប្រសិនបើមិនដូច្នោះទេ បន្ទាប់មកទៅ (006)។
• សេចក្តីណែនាំ (006)៖ ប្រៀបធៀបតម្លៃជាមួយ 0x800 (តម្លៃ ethertype សម្រាប់ IPv4)។ ប្រសិនបើចម្លើយគឺពិត នោះកម្មវិធីទៅកាន់ (007) បើមិនអញ្ចឹងទេ បន្ទាប់មកទៅ (015)។

ហើយបន្តរហូតដល់កម្មវិធីត្រងកញ្ចប់ត្រឡប់លទ្ធផល។ នេះជាធម្មតាប៊ូលីន។ ការត្រឡប់តម្លៃមិនមែនសូន្យ (ការណែនាំ (014)) មានន័យថាកញ្ចប់ព័ត៌មានត្រូវបានទទួលយក ហើយការត្រឡប់តម្លៃសូន្យ (ការណែនាំ (015)) មានន័យថាកញ្ចប់ព័ត៌មានមិនត្រូវបានទទួលយកទេ។

ម៉ាស៊ីននិម្មិត BPF និង bytecode របស់វាត្រូវបានស្នើឡើងដោយ Steve McCann និង Van Jacobson នៅចុងឆ្នាំ 1992 នៅពេលដែលក្រដាសរបស់ពួកគេត្រូវបានបោះពុម្ព តម្រងកញ្ចប់ BSD៖ ស្ថាបត្យកម្មថ្មីសម្រាប់ការចាប់យកកញ្ចប់ព័ត៌មានកម្រិតអ្នកប្រើប្រាស់បច្ចេកវិទ្យានេះត្រូវបានបង្ហាញជាលើកដំបូងនៅក្នុងសន្និសីទ Usenix ក្នុងរដូវរងារឆ្នាំ 1993 ។

ដោយសារតែ BPF គឺជាម៉ាស៊ីននិម្មិត វាកំណត់បរិយាកាសដែលកម្មវិធីដំណើរការ។ បន្ថែមពីលើ bytecode វាក៏កំណត់គំរូអង្គចងចាំបាច់ (ការណែនាំអំពីការផ្ទុកត្រូវបានអនុវត្តយ៉ាងជាក់លាក់ចំពោះបាច់) ការចុះឈ្មោះ (A និង X; accumulator និងលិបិក្រមចុះឈ្មោះ) ការផ្ទុកអង្គចងចាំកោស និងកម្មវិធីរាប់បញ្ចូលកម្មវិធី។ គួរឱ្យចាប់អារម្មណ៍ BPF bytecode ត្រូវបានយកគំរូតាម Motorola 6502 ISA ។ ដូចដែល Steve McCann បានរំលឹកនៅក្នុងរបស់គាត់។ របាយការណ៍ពេញអង្គ នៅ Sharkfest '11 គាត់ធ្លាប់ស្គាល់ Build 6502 តាំងពីរៀននៅវិទ្យាល័យរបស់គាត់ក្នុងការសរសេរកម្មវិធី Apple II ហើយចំណេះដឹងនេះបានជះឥទ្ធិពលលើការងាររបស់គាត់ដែលបង្កើត BPF bytecode ។

ការគាំទ្រ BPF ត្រូវបានអនុវត្តនៅក្នុងខឺណែលលីនុចនៅក្នុងកំណែ v2.5 និងខ្ពស់ជាងនេះដែលត្រូវបានបន្ថែមជាចម្បងដោយការខិតខំប្រឹងប្រែងរបស់ Jay Schullist ។ លេខកូដ BPF នៅតែមិនផ្លាស់ប្តូររហូតដល់ឆ្នាំ 2011 នៅពេលដែល Eric Dumaset រចនាអ្នកបកប្រែ BPF ឡើងវិញដើម្បីដំណើរការក្នុងរបៀប JIT (ប្រភព៖ JIT សម្រាប់តម្រងកញ្ចប់) បន្ទាប់ពីនេះ ខឺណែលជំនួសឱ្យការបកស្រាយ BPF bytecode អាចបំប្លែងកម្មវិធី BPF ដោយផ្ទាល់ទៅជាស្ថាបត្យកម្មគោលដៅ៖ x86, ARM, MIPS ជាដើម។

ក្រោយមកក្នុងឆ្នាំ 2014 Alexey Starovoitov បានស្នើយន្តការ JIT ថ្មីសម្រាប់ BPF ។ តាមពិត JIT ថ្មីនេះបានក្លាយជាស្ថាបត្យកម្មដែលមានមូលដ្ឋានលើ BPF ថ្មី ហើយត្រូវបានគេហៅថា eBPF ។ ខ្ញុំគិតថា VMs ទាំងពីរបានរួមរស់ជាមួយគ្នាមួយរយៈ ប៉ុន្តែបច្ចុប្បន្នការត្រងកញ្ចប់ត្រូវបានអនុវត្តដោយផ្អែកលើ eBPF ។ តាមពិតនៅក្នុងឧទាហរណ៍ជាច្រើននៃឯកសារទំនើប BPF ត្រូវបានគេយល់ថាជា eBPF ហើយ BPF បុរាណត្រូវបានគេស្គាល់ថាជា cBPF ។

eBPF ពង្រីកម៉ាស៊ីននិម្មិត BPF បុរាណតាមវិធីជាច្រើន៖

• ផ្អែកលើស្ថាបត្យកម្ម 64 ប៊ីតទំនើប។ eBPF ប្រើការចុះឈ្មោះ 64-bit និងបង្កើនចំនួននៃការចុះឈ្មោះដែលមានពី 2 (accumulator និង X) ដល់ 10។ eBPF ក៏ផ្តល់នូវ opcodes បន្ថែមផងដែរ (BPF_MOV, BPF_JNE, BPF_CALL...)។
• បានផ្ដាច់ចេញពីប្រព័ន្ធរងស្រទាប់បណ្តាញ។ BPF ត្រូវបានចងភ្ជាប់ទៅនឹងគំរូទិន្នន័យបាច់។ ដោយសារវាត្រូវបានប្រើសម្រាប់ការត្រងកញ្ចប់ព័ត៌មាន កូដរបស់វាមានទីតាំងនៅក្នុងប្រព័ន្ធរងដែលផ្តល់ការទំនាក់ទំនងតាមបណ្តាញ។ ទោះយ៉ាងណាក៏ដោយ ម៉ាស៊ីននិម្មិត eBPF លែងជាប់ជាមួយគំរូទិន្នន័យទៀតហើយ ហើយអាចប្រើសម្រាប់គោលបំណងណាមួយ។ ដូច្នេះឥឡូវនេះកម្មវិធី eBPF អាចត្រូវបានភ្ជាប់ទៅ tracepoint ឬ kprobe ។ វាបើកផ្លូវទៅកាន់ឧបករណ៍ eBPF ការវិភាគការអនុវត្ត និងករណីប្រើប្រាស់ជាច្រើនទៀតនៅក្នុងបរិបទនៃប្រព័ន្ធរងខឺណែលផ្សេងទៀត។ ឥឡូវនេះលេខកូដ eBPF មានទីតាំងនៅក្នុងផ្លូវរបស់វាផ្ទាល់៖ ខឺណែល/bpf ។
• កន្លែងផ្ទុកទិន្នន័យសកលដែលហៅថាផែនទី។ ផែនទីគឺជាឃ្លាំងតម្លៃគន្លឹះដែលបើកការផ្លាស់ប្តូរទិន្នន័យរវាងទំហំអ្នកប្រើប្រាស់ និងទំហំខឺណែល។ eBPF ផ្តល់នូវផែនទីជាច្រើនប្រភេទ។
• មុខងារបន្ទាប់បន្សំ។ ជាពិសេស ដើម្បីសរសេរកញ្ចប់ឡើងវិញ គណនាមូលប្បទានប័ត្រ ឬក្លូនកញ្ចប់។ មុខងារទាំងនេះដំណើរការនៅខាងក្នុងខឺណែល ហើយមិនមែនជាកម្មវិធីលំហអ្នកប្រើប្រាស់ទេ។ អ្នកក៏អាចធ្វើការហៅជាប្រព័ន្ធពីកម្មវិធី eBPF ផងដែរ។
• បញ្ចប់ការហៅទូរសព្ទ។ ទំហំកម្មវិធីនៅក្នុង eBPF ត្រូវបានកំណត់ត្រឹម 4096 បៃ។ មុខងារហៅកន្ទុយអនុញ្ញាតឱ្យកម្មវិធី eBPF ផ្ទេរការគ្រប់គ្រងទៅកម្មវិធី eBPF ថ្មី ហើយដូច្នេះរំលងដែនកំណត់នេះ (រហូតដល់ 32 កម្មវិធីអាចត្រូវបានភ្ជាប់តាមវិធីនេះ)។

eBPF: ឧទាហរណ៍

មានឧទាហរណ៍ជាច្រើនសម្រាប់ eBPF នៅក្នុងប្រភពខឺណែលលីនុច។ ពួកវាមាននៅគំរូ/bpf/។ ដើម្បីចងក្រងឧទាហរណ៍ទាំងនេះ គ្រាន់តែបញ្ចូល៖

$ sudo make samples/bpf/

ខ្ញុំនឹងមិនសរសេរឧទាហរណ៍ថ្មីសម្រាប់ eBPF ខ្លួនឯងទេ ប៉ុន្តែនឹងប្រើគំរូមួយក្នុងចំណោមគំរូដែលមាននៅក្នុងគំរូ/bpf/។ ខ្ញុំនឹងមើលផ្នែកខ្លះនៃកូដ ហើយពន្យល់ពីរបៀបដែលវាដំណើរការ។ ជាឧទាហរណ៍ខ្ញុំបានជ្រើសរើសកម្មវិធី tracex4.

ជាទូទៅឧទាហរណ៍នីមួយៗក្នុងគំរូ/bpf/ មានឯកសារពីរ។ ក្នុងករណី​នេះ:

• tracex4_kern.cមានកូដប្រភពដែលត្រូវប្រតិបត្តិក្នុងខឺណែលជា eBPF bytecode។
• tracex4_user.cមានកម្មវិធីពីទំហំអ្នកប្រើប្រាស់។

ក្នុងករណីនេះយើងត្រូវចងក្រង tracex4_kern.c ទៅ eBPF bytecode ។ បច្ចុប្បន្ននៅក្នុង gcc មិនមានផ្នែកខាងក្រោយសម្រាប់ eBPF ទេ។ ជាសំណាងល្អ clang អាចបញ្ចេញ eBPF bytecode។ Makefile ការប្រើប្រាស់ clang សម្រាប់ការចងក្រង tracex4_kern.c ទៅឯកសារវត្ថុ។

ខ្ញុំបានរៀបរាប់ខាងលើថាលក្ខណៈពិសេសគួរឱ្យចាប់អារម្មណ៍បំផុតមួយនៃ eBPF គឺផែនទី។ tracex4_kern កំណត់ផែនទីមួយ៖

struct pair {
    u64 val;
    u64 ip;
};  

struct bpf_map_def SEC("maps") my_map = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(long),
    .value_size = sizeof(struct pair),
    .max_entries = 1000000,
};

BPF_MAP_TYPE_HASH គឺជាកាតមួយក្នុងចំណោមប្រភេទជាច្រើនដែលផ្តល់ដោយ eBPF ។ ក្នុងករណីនេះវាគ្រាន់តែជាសញ្ញា។ អ្នកប្រហែលជាបានកត់សម្គាល់ការផ្សាយពាណិជ្ជកម្មផងដែរ។ SEC("maps"). SEC គឺជាម៉ាក្រូដែលប្រើដើម្បីបង្កើតផ្នែកថ្មីនៃឯកសារគោលពីរ។ តាមពិតនៅក្នុងឧទាហរណ៍ tracex4_kern ផ្នែកពីរទៀតត្រូវបានកំណត់៖

SEC("kprobe/kmem_cache_free")
int bpf_prog1(struct pt_regs *ctx)
{   
    long ptr = PT_REGS_PARM2(ctx);

    bpf_map_delete_elem(&my_map, &ptr); 
    return 0;
}
    
SEC("kretprobe/kmem_cache_alloc_node") 
int bpf_prog2(struct pt_regs *ctx)
{
    long ptr = PT_REGS_RC(ctx);
    long ip = 0;

    // получаем ip-адрес вызывающей стороны kmem_cache_alloc_node() 
    BPF_KRETPROBE_READ_RET_IP(ip, ctx);

    struct pair v = {
        .val = bpf_ktime_get_ns(),
        .ip = ip,
    };
    
    bpf_map_update_elem(&my_map, &ptr, &v, BPF_ANY);
    return 0;
}   

មុខងារទាំងពីរនេះអនុញ្ញាតឱ្យអ្នកលុបធាតុចេញពីផែនទី (kprobe/kmem_cache_free) ហើយបន្ថែមធាតុថ្មីទៅផែនទី (kretprobe/kmem_cache_alloc_node) ឈ្មោះមុខងារទាំងអស់ដែលសរសេរជាអក្សរធំត្រូវគ្នាទៅនឹងម៉ាក្រូដែលបានកំណត់ក្នុង bpf_helpers.h.

ប្រសិនបើខ្ញុំបោះចោលផ្នែកនៃឯកសារវត្ថុនោះ ខ្ញុំគួរតែឃើញថាផ្នែកថ្មីទាំងនេះត្រូវបានកំណត់រួចហើយ៖

$ objdump -h tracex4_kern.o

tracex4_kern.o: file format elf64-little

Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00000000 0000000000000000 0000000000000000 00000040 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 kprobe/kmem_cache_free 00000048 0000000000000000 0000000000000000 00000040 2**3
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
2 kretprobe/kmem_cache_alloc_node 000000c0 0000000000000000 0000000000000000 00000088 2**3
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
3 maps 0000001c 0000000000000000 0000000000000000 00000148 2**2
CONTENTS, ALLOC, LOAD, DATA
4 license 00000004 0000000000000000 0000000000000000 00000164 2**0
CONTENTS, ALLOC, LOAD, DATA
5 version 00000004 0000000000000000 0000000000000000 00000168 2**2
CONTENTS, ALLOC, LOAD, DATA
6 .eh_frame 00000050 0000000000000000 0000000000000000 00000170 2**3
CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA

ក៏មានដែរ។ tracex4_user.c, កម្មវិធីសំខាន់។ ជាទូទៅកម្មវិធីនេះស្តាប់ព្រឹត្តិការណ៍ kmem_cache_alloc_node. នៅពេលដែលព្រឹត្តិការណ៍បែបនេះកើតឡើង កូដ eBPF ដែលត្រូវគ្នាត្រូវបានប្រតិបត្តិ។ កូដរក្សាទុកគុណលក្ខណៈ IP របស់វត្ថុទៅក្នុងផែនទី ហើយបន្ទាប់មកវត្ថុត្រូវបានរង្វិលជុំតាមរយៈកម្មវិធីមេ។ ឧទាហរណ៍៖

$ sudo ./tracex4
obj 0xffff8d6430f60a00 is 2sec old was allocated at ip ffffffff9891ad90
obj 0xffff8d6062ca5e00 is 23sec old was allocated at ip ffffffff98090e8f
obj 0xffff8d5f80161780 is 6sec old was allocated at ip ffffffff98090e8f

តើកម្មវិធីអវកាសអ្នកប្រើប្រាស់ និងកម្មវិធី eBPF មានទំនាក់ទំនងគ្នាដូចម្តេច? នៅលើការចាប់ផ្តើម tracex4_user.c ផ្ទុកឯកសារវត្ថុ tracex4_kern.o ដោយប្រើមុខងារ load_bpf_file.

int main(int ac, char **argv)
{
    struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY};
    char filename[256];
    int i;

    snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);

    if (setrlimit(RLIMIT_MEMLOCK, &r)) {
        perror("setrlimit(RLIMIT_MEMLOCK, RLIM_INFINITY)");
        return 1;
    }

    if (load_bpf_file(filename)) {
        printf("%s", bpf_log_buf);
        return 1;
    }

    for (i = 0; ; i++) {
        print_old_objects(map_fd[1]);
        sleep(1);
    }

    return 0;
}

ពេលកំពុងធ្វើ load_bpf_file ការស៊ើបអង្កេតដែលបានកំណត់នៅក្នុងឯកសារ eBPF ត្រូវបានបន្ថែមទៅ /sys/kernel/debug/tracing/kprobe_events. ឥឡូវនេះ យើងស្តាប់ព្រឹត្តិការណ៍ទាំងនេះ ហើយកម្មវិធីរបស់យើងអាចធ្វើអ្វីមួយនៅពេលដែលវាកើតឡើង។

$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:kprobes/kmem_cache_free kmem_cache_free
r:kprobes/kmem_cache_alloc_node kmem_cache_alloc_node

កម្មវិធីផ្សេងទៀតទាំងអស់នៅក្នុងគំរូ / bpf / ត្រូវបានរៀបចំស្រដៀងគ្នា។ ពួកគេតែងតែមានឯកសារពីរ៖

• XXX_kern.c៖ កម្មវិធី eBPF ។
• XXX_user.c៖ កម្មវិធីសំខាន់។

កម្មវិធី eBPF កំណត់ផែនទី និងមុខងារដែលភ្ជាប់ជាមួយផ្នែកមួយ។ នៅពេលដែលខឺណែលចេញព្រឹត្តិការណ៍នៃប្រភេទជាក់លាក់មួយ (ឧទាហរណ៍ tracepoint) មុខងារដែលបានកំណត់ត្រូវបានប្រតិបត្តិ។ កាតផ្តល់ទំនាក់ទំនងរវាងកម្មវិធីខឺណែល និងកម្មវិធីលំហអ្នកប្រើប្រាស់។

សេចក្តីសន្និដ្ឋាន

អត្ថបទនេះបានពិភាក្សាអំពី BPF និង eBPF ក្នុងន័យទូទៅ។ ខ្ញុំដឹងថាមានព័ត៌មាន និងធនធានជាច្រើនអំពី eBPF ថ្ងៃនេះ ដូច្នេះខ្ញុំនឹងណែនាំធនធានមួយចំនួនបន្ថែមទៀតសម្រាប់ការសិក្សាបន្ថែម។

ខ្ញុំសូមណែនាំឱ្យអាន៖

• BPF៖ ម៉ាស៊ីននិម្មិតក្នុងខឺណែលជាសកល Jonathan Corbett ។ ការណែនាំអំពី BPF និងរបៀបដែលវាវិវត្តទៅជា eBPF ។
• ការណែនាំយ៉ាងម៉ត់ចត់ចំពោះ eBPF លោក Brendan Gregg ។ អត្ថបទពី LWN.net ។ Brendan ជាញឹកញាប់ tweets អំពី eBPF និងរក្សាបញ្ជីនៃធនធាននៅលើប្រធានបទនៅលើរបស់គាត់។ ការប្រកាសកំណត់ហេតុបណ្ដាញ.
• កំណត់ចំណាំលើ BPF & eBPF Julia Evans ។ មតិយោបល់លើបទបង្ហាញដោយ Suchakra Sharma “តម្រងកញ្ចប់ BSD៖ ស្ថាបត្យកម្មថ្មីសម្រាប់ការចាប់យកកញ្ចប់ព័ត៌មានកម្រិតអ្នកប្រើប្រាស់”។ មតិយោបល់គឺល្អហើយពិតជាជួយអ្នកឱ្យយល់ពីស្លាយ។
• eBPF ផ្នែកទី 1៖ អតីតកាល បច្ចុប្បន្នកាល និងអនាគតកាល Ferris Ellis ។ អានយូរជាមួយ ការបន្តប៉ុន្តែវាមានតម្លៃអាន។ អត្ថបទដ៏ល្អបំផុតមួយដែលខ្ញុំបានឆ្លងកាត់នៅលើ eBPF ។

ប្រភព: www.habr.com