BPF, eBPF എന്നിവയിലേക്കുള്ള ഒരു ഹ്രസ്വ ആമുഖം

ഹലോ, ഹബ്ർ! ഞങ്ങൾ ഒരു പുസ്തകം പ്രകാശനത്തിനായി തയ്യാറാക്കിക്കൊണ്ടിരിക്കുകയാണെന്ന് നിങ്ങളെ അറിയിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു."BPF ഉള്ള Linux നിരീക്ഷണക്ഷമത".

ബിപിഎഫ് വെർച്വൽ മെഷീൻ വികസിക്കുന്നത് തുടരുകയും പ്രായോഗികമായി സജീവമായി ഉപയോഗിക്കുകയും ചെയ്യുന്നതിനാൽ, അതിന്റെ പ്രധാന കഴിവുകളും നിലവിലെ അവസ്ഥയും വിവരിക്കുന്ന ഒരു ലേഖനം ഞങ്ങൾ നിങ്ങൾക്കായി വിവർത്തനം ചെയ്തിട്ടുണ്ട്.

സമീപ വർഷങ്ങളിൽ, ഉയർന്ന പെർഫോമൻസ് പാക്കറ്റ് പ്രോസസ്സിംഗ് ആവശ്യമുള്ള സന്ദർഭങ്ങളിൽ ലിനക്സ് കേർണലിന്റെ പരിമിതികൾ നികത്താൻ പ്രോഗ്രാമിംഗ് ടൂളുകളും ടെക്നിക്കുകളും കൂടുതൽ പ്രചാരത്തിലുണ്ട്. ഇത്തരത്തിലുള്ള ഏറ്റവും ജനപ്രിയമായ സാങ്കേതികതകളിലൊന്ന് വിളിക്കപ്പെടുന്നു കേർണൽ ബൈപാസ് (കേർണൽ ബൈപാസ്) കൂടാതെ, കേർണൽ നെറ്റ്‌വർക്ക് ലെയറിനെ മറികടന്ന്, യൂസർ സ്‌പെയ്‌സിൽ നിന്ന് എല്ലാ പാക്കറ്റ് പ്രോസസ്സിംഗും നടത്താൻ അനുവദിക്കുന്നു. കെർണൽ ബൈപാസ് ചെയ്യുന്നതിൽ നെറ്റ്‌വർക്ക് കാർഡ് നിയന്ത്രിക്കുന്നതും ഉൾപ്പെടുന്നു ഉപയോക്തൃ ഇടം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു നെറ്റ്‌വർക്ക് കാർഡുമായി പ്രവർത്തിക്കുമ്പോൾ, ഞങ്ങൾ ഡ്രൈവറെ ആശ്രയിക്കുന്നു ഉപയോക്തൃ ഇടം.

ഒരു യൂസർ-സ്പേസ് പ്രോഗ്രാമിലേക്ക് നെറ്റ്‌വർക്ക് കാർഡിന്റെ പൂർണ്ണ നിയന്ത്രണം കൈമാറുന്നതിലൂടെ, ഞങ്ങൾ കേർണൽ ഓവർഹെഡ് (സന്ദർഭ സ്വിച്ചിംഗ്, നെറ്റ്‌വർക്ക് ലെയർ പ്രോസസ്സിംഗ്, തടസ്സങ്ങൾ മുതലായവ) കുറയ്ക്കുന്നു, ഇത് 10Gb/s അല്ലെങ്കിൽ ഉയർന്ന വേഗതയിൽ പ്രവർത്തിക്കുമ്പോൾ വളരെ പ്രധാനമാണ്. കേർണൽ ബൈപാസും മറ്റ് ഫീച്ചറുകളുടെ സംയോജനവും (ബാച്ച് പ്രോസസ്സിംഗ്) കൂടാതെ ശ്രദ്ധാപൂർവ്വമായ പ്രകടന ട്യൂണിംഗ് (NUMA അക്കൗണ്ടിംഗ്, സിപിയു ഒറ്റപ്പെടൽ, മുതലായവ) ഉപയോക്തൃ സ്ഥലത്ത് ഉയർന്ന പ്രവർത്തനക്ഷമതയുള്ള നെറ്റ്‌വർക്ക് പ്രോസസ്സിംഗിന്റെ അടിസ്ഥാനകാര്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നു. പാക്കറ്റ് പ്രോസസ്സിംഗിലെ ഈ പുതിയ സമീപനത്തിന്റെ മാതൃകാപരമായ ഉദാഹരണം ഡിപിഡികെ ഇന്റലിൽ നിന്ന് (ഡാറ്റാ പ്ലെയിൻ വികസന കിറ്റ്), സിസ്‌കോയുടെ VPP (വെക്‌റ്റർ പാക്കറ്റ് പ്രോസസ്സിംഗ്), നെറ്റ്‌മാപ്പ് എന്നിവയുൾപ്പെടെ മറ്റ് അറിയപ്പെടുന്ന ഉപകരണങ്ങളും സാങ്കേതിക വിദ്യകളും ഉണ്ടെങ്കിലും, തീർച്ചയായും, സ്നാബ്.

ഉപയോക്തൃ സ്ഥലത്ത് നെറ്റ്‌വർക്ക് ഇടപെടലുകൾ സംഘടിപ്പിക്കുന്നതിന് നിരവധി ദോഷങ്ങളുണ്ട്:

• ഹാർഡ്‌വെയർ ഉറവിടങ്ങൾക്കായുള്ള ഒരു അമൂർത്ത പാളിയാണ് OS കേർണൽ. ഉപയോക്തൃ ബഹിരാകാശ പ്രോഗ്രാമുകൾക്ക് അവരുടെ ഉറവിടങ്ങൾ നേരിട്ട് കൈകാര്യം ചെയ്യേണ്ടതിനാൽ, അവർക്ക് അവരുടെ സ്വന്തം ഹാർഡ്‌വെയറും കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്. ഇത് പലപ്പോഴും നിങ്ങളുടെ സ്വന്തം ഡ്രൈവറുകൾ പ്രോഗ്രാം ചെയ്യണം എന്നാണ്.
• ഞങ്ങൾ കേർണൽ സ്പേസ് പൂർണ്ണമായും ഉപേക്ഷിക്കുന്നതിനാൽ, കേർണൽ നൽകുന്ന എല്ലാ നെറ്റ്‌വർക്കിംഗ് പ്രവർത്തനങ്ങളും ഞങ്ങൾ ഉപേക്ഷിക്കുകയാണ്. കേർണലോ ഓപ്പറേറ്റിംഗ് സിസ്റ്റമോ ഇതിനകം നൽകിയേക്കാവുന്ന സവിശേഷതകൾ യൂസർ സ്പേസ് പ്രോഗ്രാമുകൾ പുനഃസ്ഥാപിക്കേണ്ടതുണ്ട്.
• പ്രോഗ്രാമുകൾ സാൻഡ്‌ബോക്‌സ് മോഡിൽ പ്രവർത്തിക്കുന്നു, ഇത് അവയുടെ ഇടപെടൽ ഗൗരവമായി പരിമിതപ്പെടുത്തുകയും ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ മറ്റ് ഭാഗങ്ങളുമായി സംയോജിപ്പിക്കുന്നതിൽ നിന്ന് അവരെ തടയുകയും ചെയ്യുന്നു.

സാരാംശത്തിൽ, ഉപയോക്തൃ സ്ഥലത്ത് നെറ്റ്‌വർക്കിംഗ് സംഭവിക്കുമ്പോൾ, കേർണലിൽ നിന്ന് ഉപയോക്തൃ സ്ഥലത്തേക്ക് പാക്കറ്റ് പ്രോസസ്സിംഗ് നീക്കുന്നതിലൂടെ പ്രകടന നേട്ടങ്ങൾ കൈവരിക്കാനാകും. XDP തികച്ചും വിപരീതമാണ് ചെയ്യുന്നത്: ഇത് നെറ്റ്‌വർക്കിംഗ് പ്രോഗ്രാമുകളെ യൂസർ സ്‌പെയ്‌സിൽ നിന്ന് (ഫിൽട്ടറുകൾ, റിസോൾവറുകൾ, റൂട്ടിംഗ് മുതലായവ) കേർണൽ സ്‌പെയ്‌സിലേക്ക് നീക്കുന്നു. ഒരു പാക്കറ്റ് ഒരു നെറ്റ്‌വർക്ക് ഇന്റർഫേസിൽ എത്തിയാലുടൻ അത് കേർണൽ നെറ്റ്‌വർക്ക് സബ്സിസ്റ്റത്തിലേക്ക് നീങ്ങാൻ തുടങ്ങുന്നതിനുമുമ്പ് ഒരു നെറ്റ്‌വർക്ക് ഫംഗ്‌ഷൻ നടത്താൻ XDP ഞങ്ങളെ അനുവദിക്കുന്നു. തൽഫലമായി, പാക്കറ്റ് പ്രോസസ്സിംഗ് വേഗത ഗണ്യമായി വർദ്ധിക്കുന്നു. എന്നിരുന്നാലും, കേർണൽ സ്പേസിൽ അവരുടെ പ്രോഗ്രാമുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കേർണൽ എങ്ങനെയാണ് ഉപയോക്താവിനെ അനുവദിക്കുന്നത്? ഈ ചോദ്യത്തിന് ഉത്തരം നൽകുന്നതിന് മുമ്പ്, BPF എന്താണെന്ന് നോക്കാം.

ബിപിഎഫ്, ഇബിപിഎഫ്

ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന പേര് ഉണ്ടായിരുന്നിട്ടും, BPF (Berkeley Packet Filtering) വാസ്തവത്തിൽ ഒരു വെർച്വൽ മെഷീൻ മോഡലാണ്. പാക്കറ്റ് ഫിൽട്ടറിംഗ് കൈകാര്യം ചെയ്യുന്നതിനാണ് ഈ വെർച്വൽ മെഷീൻ ആദ്യം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, അതിനാൽ ഈ പേര്.

BPF ഉപയോഗിക്കുന്ന ഏറ്റവും പ്രശസ്തമായ ടൂളുകളിൽ ഒന്നാണ് tcpdump. ഉപയോഗിച്ച് പാക്കറ്റുകൾ ക്യാപ്ചർ ചെയ്യുമ്പോൾ tcpdump പാക്കറ്റുകൾ ഫിൽട്ടർ ചെയ്യുന്നതിന് ഉപയോക്താവിന് ഒരു എക്സ്പ്രഷൻ വ്യക്തമാക്കാൻ കഴിയും. ഈ പദപ്രയോഗവുമായി പൊരുത്തപ്പെടുന്ന പാക്കറ്റുകൾ മാത്രമേ ക്യാപ്‌ചർ ചെയ്യൂ. ഉദാഹരണത്തിന്, പദപ്രയോഗം "tcp dst port 80” പോർട്ട് 80-ൽ എത്തുന്ന എല്ലാ TCP പാക്കറ്റുകളേയും സൂചിപ്പിക്കുന്നു. BPF ബൈറ്റ്കോഡിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിലൂടെ കംപൈലറിന് ഈ എക്സ്പ്രഷൻ ചെറുതാക്കാനാകും.

$ 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-ബിറ്റ് പദമായി, അക്യുമുലേറ്ററിലേക്ക് പാക്കറ്റ് ലോഡ് ചെയ്യുന്നു. ഓഫ്‌സെറ്റ് 12 പാക്കറ്റിന്റെ ഈതർടൈപ്പുമായി യോജിക്കുന്നു.
• നിർദ്ദേശം (001): അക്യുമുലേറ്ററിലെ മൂല്യത്തെ 0x86dd-മായി താരതമ്യം ചെയ്യുന്നു, അതായത്, IPv6-നുള്ള ഈതർടൈപ്പ് മൂല്യവുമായി. ഫലം ശരിയാണെങ്കിൽ, പ്രോഗ്രാം കൌണ്ടർ നിർദ്ദേശത്തിലേക്ക് (002) പോകുന്നു, ഇല്ലെങ്കിൽ (006) ലേക്ക് പോകുന്നു.
• നിർദ്ദേശം (006): മൂല്യത്തെ 0x800-മായി താരതമ്യം ചെയ്യുന്നു (IPv4-നുള്ള ഈതർടൈപ്പ് മൂല്യം). ഉത്തരം ശരിയാണെങ്കിൽ, പ്രോഗ്രാം (007), ഇല്ലെങ്കിൽ (015) ലേക്ക് പോകുന്നു.

പാക്കറ്റ് ഫിൽട്ടറിംഗ് പ്രോഗ്രാം ഒരു ഫലം നൽകുന്നതുവരെ അങ്ങനെ. ഇത് സാധാരണയായി ഒരു ബൂളിയൻ ആണ്. പൂജ്യമല്ലാത്ത മൂല്യം (നിർദ്ദേശം (014)) തിരികെ നൽകുന്നത് അർത്ഥമാക്കുന്നത് പാക്കറ്റ് സ്വീകരിച്ചു എന്നാണ്, കൂടാതെ പൂജ്യം മൂല്യം (നിർദ്ദേശം (015)) നൽകുന്നതിനർത്ഥം പാക്കറ്റ് സ്വീകരിച്ചില്ല എന്നാണ്.

BPF വെർച്വൽ മെഷീനും അതിന്റെ ബൈറ്റ്കോഡും സ്റ്റീവ് മക്കാനും വാൻ ജേക്കബ്സണും 1992 അവസാനം അവരുടെ പേപ്പർ പ്രസിദ്ധീകരിച്ചപ്പോൾ നിർദ്ദേശിച്ചു. BSD പാക്കറ്റ് ഫിൽട്ടർ: ഉപയോക്തൃ-തല പാക്കറ്റ് ക്യാപ്ചറിനുള്ള പുതിയ ആർക്കിടെക്ചർ, ഈ സാങ്കേതികവിദ്യ ആദ്യമായി അവതരിപ്പിച്ചത് 1993 ലെ ശൈത്യകാലത്ത് യൂസെനിക്സ് കോൺഫറൻസിലാണ്.

BPF ഒരു വെർച്വൽ മെഷീനായതിനാൽ, പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കുന്ന പരിസ്ഥിതിയെ ഇത് നിർവചിക്കുന്നു. ബൈറ്റ്കോഡിന് പുറമേ, ബാച്ച് മെമ്മറി മോഡൽ (ബാച്ചിലേക്ക് ലോഡ് നിർദ്ദേശങ്ങൾ പരോക്ഷമായി പ്രയോഗിക്കുന്നു), രജിസ്റ്ററുകൾ (A, X; അക്യുമുലേറ്റർ, ഇൻഡെക്സ് രജിസ്റ്ററുകൾ), സ്ക്രാച്ച് മെമ്മറി സ്റ്റോറേജ്, ഒരു ഇൻപ്ലസിറ്റ് പ്രോഗ്രാം കൗണ്ടർ എന്നിവയും ഇത് നിർവചിക്കുന്നു. രസകരമെന്നു പറയട്ടെ, മോട്ടറോള 6502 ഐഎസ്എയുടെ മാതൃകയിലാണ് ബിപിഎഫ് ബൈറ്റ്കോഡ് രൂപപ്പെടുത്തിയത്. സ്റ്റീവ് മക്കാൻ തന്റെ കൃതിയിൽ അനുസ്മരിച്ചത് പോലെ പ്ലീനറി റിപ്പോർട്ട് Sharkfest '11-ൽ, Apple II-ലെ ഹൈസ്‌കൂൾ ദിവസങ്ങളിലെ പ്രോഗ്രാമിംഗിൽ നിന്ന്, ബിൽഡ് 6502-ൽ അദ്ദേഹത്തിന് പരിചിതമായിരുന്നു, ഈ അറിവ് BPF ബൈറ്റ്കോഡ് രൂപകൽപ്പന ചെയ്യുന്ന അദ്ദേഹത്തിന്റെ പ്രവർത്തനത്തെ സ്വാധീനിച്ചു.

BPF പിന്തുണ ലിനക്സ് കേർണലിൽ v2.5-ലും അതിലും ഉയർന്ന പതിപ്പുകളിലും നടപ്പിലാക്കുന്നു, പ്രധാനമായും ജെയ് ഷുലിസ്റ്റിന്റെ ശ്രമങ്ങളാൽ ചേർത്തു. 2011 വരെ BPF കോഡ് മാറ്റമില്ലാതെ തുടർന്നു, എറിക് ഡുമാസെറ്റ് JIT മോഡിൽ പ്രവർത്തിപ്പിക്കുന്നതിനായി BPF വ്യാഖ്യാതാവിനെ പുനർരൂപകൽപ്പന ചെയ്തു (ഉറവിടം: പാക്കറ്റ് ഫിൽട്ടറുകൾക്ക് JIT). ഇതിനുശേഷം, കെർണലിന്, ബിപിഎഫ് ബൈറ്റ്കോഡ് വ്യാഖ്യാനിക്കുന്നതിനുപകരം, ബിപിഎഫ് പ്രോഗ്രാമുകളെ ടാർഗെറ്റ് ആർക്കിടെക്ചറിലേക്ക് നേരിട്ട് പരിവർത്തനം ചെയ്യാൻ കഴിയും: x86, ARM, MIPS മുതലായവ.

പിന്നീട്, 2014-ൽ അലക്സി സ്റ്റാരോവോയ്റ്റോവ് ബിപിഎഫിനായി ഒരു പുതിയ ജെഐടി സംവിധാനം നിർദ്ദേശിച്ചു. വാസ്തവത്തിൽ, ഈ പുതിയ JIT ഒരു പുതിയ BPF-അധിഷ്ഠിത വാസ്തുവിദ്യയായി മാറി, അതിനെ eBPF എന്ന് വിളിക്കപ്പെട്ടു. രണ്ട് VM-കളും കുറച്ച് കാലത്തേക്ക് ഒരുമിച്ച് നിലനിന്നിരുന്നതായി ഞാൻ കരുതുന്നു, എന്നാൽ നിലവിൽ eBPF അടിസ്ഥാനമാക്കിയാണ് പാക്കറ്റ് ഫിൽട്ടറിംഗ് നടപ്പിലാക്കുന്നത്. വാസ്തവത്തിൽ, ആധുനിക ഡോക്യുമെന്റേഷന്റെ പല ഉദാഹരണങ്ങളിലും, BPF എന്നത് eBPF ആണെന്നും ക്ലാസിക്കൽ BPF ആണ് ഇന്ന് cBPF എന്നും അറിയപ്പെടുന്നത്.

eBPF ക്ലാസിക് BPF വെർച്വൽ മെഷീനെ പല തരത്തിൽ വിപുലീകരിക്കുന്നു:

• ആധുനിക 64-ബിറ്റ് ആർക്കിടെക്ചറുകളെ അടിസ്ഥാനമാക്കി. eBPF 64-ബിറ്റ് രജിസ്റ്ററുകൾ ഉപയോഗിക്കുകയും ലഭ്യമായ രജിസ്റ്ററുകളുടെ എണ്ണം 2 (അക്യുമുലേറ്ററും X) ൽ നിന്ന് 10 ആയി വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു. eBPF അധിക ഒപ്‌കോഡുകളും നൽകുന്നു (BPF_MOV, BPF_JNE, BPF_CALL...).
• നെറ്റ്‌വർക്ക് ലെയർ സബ്സിസ്റ്റത്തിൽ നിന്ന് വേർപെടുത്തി. BPF ബാച്ച് ഡാറ്റ മോഡലുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. പാക്കറ്റ് ഫിൽട്ടറിംഗിനായി ഇത് ഉപയോഗിച്ചതിനാൽ, നെറ്റ്‌വർക്ക് ആശയവിനിമയങ്ങൾ നൽകുന്ന സബ്സിസ്റ്റത്തിലാണ് അതിന്റെ കോഡ് സ്ഥിതി ചെയ്യുന്നത്. എന്നിരുന്നാലും, eBPF വെർച്വൽ മെഷീൻ ഇനി ഡാറ്റ മോഡലുമായി ബന്ധിപ്പിച്ചിട്ടില്ല, മാത്രമല്ല ഏത് ആവശ്യത്തിനും ഉപയോഗിക്കാൻ കഴിയും. അതിനാൽ, ഇപ്പോൾ eBPF പ്രോഗ്രാം ട്രേസ്‌പോയിന്റിലേക്കോ kprobe-ലേക്കോ ബന്ധിപ്പിക്കാൻ കഴിയും. ഇത് eBPF ഇൻസ്ട്രുമെന്റേഷൻ, പെർഫോമൻസ് അനാലിസിസ്, മറ്റ് കേർണൽ സബ്സിസ്റ്റങ്ങളുടെ പശ്ചാത്തലത്തിൽ മറ്റ് പല ഉപയോഗ കേസുകൾ എന്നിവയിലേക്കുള്ള വഴി തുറക്കുന്നു. ഇപ്പോൾ eBPF കോഡ് അതിന്റെ സ്വന്തം പാതയിലാണ് സ്ഥിതി ചെയ്യുന്നത്: kernel/bpf.
• മാപ്‌സ് എന്ന് വിളിക്കുന്ന ആഗോള ഡാറ്റ സ്റ്റോറുകൾ. ഉപയോക്തൃ സ്ഥലത്തിനും കേർണൽ സ്‌പെയ്‌സിനും ഇടയിൽ ഡാറ്റാ കൈമാറ്റം സാധ്യമാക്കുന്ന കീ-വാല്യൂ സ്റ്റോറുകളാണ് മാപ്‌സ്. eBPF നിരവധി തരം മാപ്പുകൾ നൽകുന്നു.
• ദ്വിതീയ പ്രവർത്തനങ്ങൾ. പ്രത്യേകിച്ചും, ഒരു പാക്കേജ് മാറ്റിയെഴുതാൻ, ഒരു ചെക്ക്സം കണക്കാക്കുക അല്ലെങ്കിൽ ഒരു പാക്കേജ് ക്ലോൺ ചെയ്യുക. ഈ ഫംഗ്‌ഷനുകൾ കേർണലിനുള്ളിൽ പ്രവർത്തിക്കുന്നു, അവ യൂസർ-സ്‌പേസ് പ്രോഗ്രാമുകളല്ല. eBPF പ്രോഗ്രാമുകളിൽ നിന്നും നിങ്ങൾക്ക് സിസ്റ്റം കോളുകൾ ചെയ്യാനും കഴിയും.
• കോളുകൾ അവസാനിപ്പിക്കുക. ഇബിപിഎഫിലെ പ്രോഗ്രാം വലുപ്പം 4096 ബൈറ്റുകളായി പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. ടെയിൽ കോൾ ഫീച്ചർ ഒരു eBPF പ്രോഗ്രാമിനെ ഒരു പുതിയ eBPF പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം കൈമാറ്റം ചെയ്യാനും അങ്ങനെ ഈ പരിമിതി മറികടക്കാനും അനുവദിക്കുന്നു (32 പ്രോഗ്രാമുകൾ വരെ ഈ രീതിയിൽ ലിങ്ക് ചെയ്യാം).

eBPF: ഉദാഹരണം

ലിനക്സ് കേർണൽ ഉറവിടങ്ങളിൽ ഇബിപിഎഫിന് നിരവധി ഉദാഹരണങ്ങളുണ്ട്. അവ സാമ്പിളുകളിൽ/bpf/ എന്നതിൽ ലഭ്യമാണ്. ഈ ഉദാഹരണങ്ങൾ സമാഹരിക്കാൻ, നൽകുക:

$ sudo make samples/bpf/

eBPF-ന് ഞാൻ ഒരു പുതിയ ഉദാഹരണം എഴുതുകയില്ല, എന്നാൽ സാമ്പിളുകൾ/bpf/ എന്നതിൽ ലഭ്യമായ സാമ്പിളുകളിൽ ഒന്ന് ഉപയോഗിക്കും. ഞാൻ കോഡിന്റെ ചില ഭാഗങ്ങൾ നോക്കുകയും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വിശദീകരിക്കുകയും ചെയ്യും. ഒരു ഉദാഹരണമായി, ഞാൻ പ്രോഗ്രാം തിരഞ്ഞെടുത്തു tracex4.

പൊതുവേ, മാതൃകകൾ/bpf/ എന്നതിലെ ഓരോ ഉദാഹരണത്തിലും രണ്ട് ഫയലുകൾ അടങ്ങിയിരിക്കുന്നു. ഈ സാഹചര്യത്തിൽ:

• tracex4_kern.c, കേർണലിൽ eBPF ബൈറ്റ്കോഡ് ആയി എക്സിക്യൂട്ട് ചെയ്യേണ്ട സോഴ്സ് കോഡ് അടങ്ങിയിരിക്കുന്നു.
• tracex4_user.c, ഉപയോക്തൃ സ്ഥലത്ത് നിന്നുള്ള ഒരു പ്രോഗ്രാം അടങ്ങിയിരിക്കുന്നു.

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ കംപൈൽ ചെയ്യേണ്ടതുണ്ട് tracex4_kern.c eBPF ബൈറ്റ്കോഡിലേക്ക്. നിലവിൽ ഉള്ളത് gcc eBPF-ന് ബാക്കെൻഡ് ഇല്ല. ഭാഗ്യവശാൽ, clang eBPF ബൈറ്റ്കോഡ് ഔട്ട്പുട്ട് ചെയ്യാൻ കഴിയും. 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 കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. കോഡ് ഒബ്‌ജക്റ്റിന്റെ ഐപി ആട്രിബ്യൂട്ട് ഒരു മാപ്പിലേക്ക് സംരക്ഷിക്കുന്നു, തുടർന്ന് ഒബ്‌ജക്റ്റ് പ്രധാന പ്രോഗ്രാമിലൂടെ ലൂപ്പ് ചെയ്യുന്നു. ഉദാഹരണം:

$ 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

ഒരു യൂസർ സ്പേസ് പ്രോഗ്രാമും ഇബിപിഎഫ് പ്രോഗ്രാമും എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു? സമാരംഭിക്കുമ്പോൾ 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

സാമ്പിൾ/ബിപിഎഫ്/ എന്നതിലെ മറ്റെല്ലാ പ്രോഗ്രാമുകളും സമാനമായ രീതിയിൽ ക്രമീകരിച്ചിരിക്കുന്നു. അവയിൽ എല്ലായ്പ്പോഴും രണ്ട് ഫയലുകൾ അടങ്ങിയിരിക്കുന്നു:

• XXX_kern.c: eBPF പ്രോഗ്രാം.
• XXX_user.c: പ്രധാന പ്രോഗ്രാം.

ഇബിപിഎഫ് പ്രോഗ്രാം ഒരു വിഭാഗവുമായി ബന്ധപ്പെട്ട മാപ്പുകളും പ്രവർത്തനങ്ങളും തിരിച്ചറിയുന്നു. കേർണൽ ഒരു പ്രത്യേക തരത്തിലുള്ള ഇവന്റ് നൽകുമ്പോൾ (ഉദാഹരണത്തിന്, tracepoint), ബന്ധിത പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കുന്നു. കേർണൽ പ്രോഗ്രാമും യൂസർ സ്പേസ് പ്രോഗ്രാമും തമ്മിലുള്ള ആശയവിനിമയം കാർഡുകൾ നൽകുന്നു.

തീരുമാനം

ഈ ലേഖനം ബിപിഎഫിനെയും ഇബിപിഎഫിനെയും പൊതുവായി ചർച്ച ചെയ്തു. eBPF-നെ കുറിച്ച് ഇന്ന് ധാരാളം വിവരങ്ങളും ഉറവിടങ്ങളും ഉണ്ടെന്ന് എനിക്കറിയാം, അതിനാൽ കൂടുതൽ പഠനത്തിനായി ഞാൻ കുറച്ച് ഉറവിടങ്ങൾ കൂടി ശുപാർശ ചെയ്യും

ഞാൻ വായിക്കാൻ ശുപാർശ ചെയ്യുന്നു:

• ബിപിഎഫ്: സാർവത്രിക ഇൻ-കേർണൽ വെർച്വൽ മെഷീൻ ജോനാഥൻ കോർബറ്റ്. BPF-ലേക്കുള്ള ഒരു ആമുഖവും അത് eBPF ആയി എങ്ങനെ പരിണമിച്ചു എന്നതും.
• eBPF-നെക്കുറിച്ചുള്ള സമഗ്രമായ ആമുഖം ബ്രണ്ടൻ ഗ്രെഗ്. LWN.net-ൽ നിന്നുള്ള ലേഖനം. ബ്രണ്ടൻ eBPF-നെ കുറിച്ച് ഇടയ്ക്കിടെ ട്വീറ്റ് ചെയ്യുകയും തന്റെ വിഷയത്തെക്കുറിച്ചുള്ള വിഭവങ്ങളുടെ ഒരു ലിസ്റ്റ് പരിപാലിക്കുകയും ചെയ്യുന്നു ബ്ലോഗ് പോസ്റ്റ്.
• BPF, eBPF എന്നിവയെ കുറിച്ചുള്ള കുറിപ്പുകൾ ജൂലിയ ഇവാൻസ്. സുചക്ര ശർമ്മയുടെ അവതരണത്തെക്കുറിച്ചുള്ള അഭിപ്രായങ്ങൾ "ദി ബിഎസ്‌ഡി പാക്കറ്റ് ഫിൽട്ടർ: ഉപയോക്തൃ തലത്തിലുള്ള പാക്കറ്റ് ക്യാപ്‌ചറിനായുള്ള ഒരു പുതിയ ആർക്കിടെക്ചർ". അഭിപ്രായങ്ങൾ മികച്ചതും സ്ലൈഡുകൾ മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു.
• eBPF, ഭാഗം1: ഭൂതവും വർത്തമാനവും ഭാവിയും ഫെറിസ് എല്ലിസ്. കൂടെ ലോംഗ്രെഡ് തുടർച്ച, എന്നാൽ ഇത് വായിക്കേണ്ടതാണ്. eBPF-ൽ ഞാൻ കണ്ട ഏറ്റവും മികച്ച ലേഖനങ്ങളിൽ ഒന്ന്.

അവലംബം: www.habr.com