ചെറിയ കുട്ടികൾക്കുള്ള ബിപിഎഫ്, ഭാഗം ഒന്ന്: വിപുലീകരിച്ച ബിപിഎഫ്

തുടക്കത്തിൽ ഒരു സാങ്കേതികവിദ്യ ഉണ്ടായിരുന്നു, അതിനെ ബിപിഎഫ് എന്ന് വിളിച്ചിരുന്നു. ഞങ്ങൾ അവളെ നോക്കി മുമ്പത്തെ, ഈ പരമ്പരയിലെ പഴയനിയമ ലേഖനം. 2013-ൽ, അലക്‌സി സ്റ്റാറോവോയ്‌റ്റോവ്, ഡാനിയൽ ബോർക്ക്മാൻ എന്നിവരുടെ ശ്രമഫലമായി, ആധുനിക 64-ബിറ്റ് മെഷീനുകൾക്കായി ഒപ്റ്റിമൈസ് ചെയ്‌ത അതിന്റെ മെച്ചപ്പെട്ട പതിപ്പ് വികസിപ്പിച്ച് ലിനക്‌സ് കേർണലിൽ ഉൾപ്പെടുത്തി. ഈ പുതിയ സാങ്കേതികവിദ്യയെ ചുരുക്കത്തിൽ ഇന്റേണൽ ബിപിഎഫ് എന്ന് വിളിച്ചിരുന്നു, പിന്നീട് എക്സ്റ്റെൻഡഡ് ബിപിഎഫ് എന്ന് പുനർനാമകരണം ചെയ്തു, ഇപ്പോൾ, കുറച്ച് വർഷങ്ങൾക്ക് ശേഷം, എല്ലാവരും അതിനെ ബിപിഎഫ് എന്ന് വിളിക്കുന്നു.

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

ഈ ലേഖനം ബിപിഎഫ് വെർച്വൽ മെഷീന്റെ ഘടന, ബിപിഎഫിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള കേർണൽ ഇന്റർഫേസുകൾ, വികസന ഉപകരണങ്ങൾ, നിലവിലുള്ള കഴിവുകളുടെ ഒരു ഹ്രസ്വവും വളരെ ഹ്രസ്വവുമായ അവലോകനം എന്നിവ വിവരിക്കുന്നു, അതായത്. ബിപിഎഫിന്റെ പ്രായോഗിക പ്രയോഗങ്ങളെക്കുറിച്ച് ആഴത്തിലുള്ള പഠനത്തിന് ഭാവിയിൽ നമുക്ക് ആവശ്യമായതെല്ലാം.

ലേഖനത്തിന്റെ സംഗ്രഹം

ബിപിഎഫ് ആർക്കിടെക്ചറിലേക്കുള്ള ആമുഖം. ആദ്യം, ഞങ്ങൾ BPF വാസ്തുവിദ്യയുടെ ഒരു പക്ഷി വീക്ഷണം എടുക്കുകയും പ്രധാന ഘടകങ്ങളുടെ രൂപരേഖ തയ്യാറാക്കുകയും ചെയ്യും.

ബിപിഎഫ് വെർച്വൽ മെഷീന്റെ രജിസ്റ്ററുകളും കമാൻഡ് സിസ്റ്റവും. ആർക്കിടെക്ചറിനെക്കുറിച്ച് മൊത്തത്തിൽ ഇതിനകം ഒരു ആശയം ഉണ്ട്, ഞങ്ങൾ ബിപിഎഫ് വെർച്വൽ മെഷീന്റെ ഘടന വിവരിക്കും.

BPF ഒബ്‌ജക്‌റ്റുകളുടെ ജീവിത ചക്രം, bpffs ഫയൽ സിസ്റ്റം. ഈ വിഭാഗത്തിൽ, BPF ഒബ്‌ജക്‌റ്റുകളുടെ - പ്രോഗ്രാമുകളുടെയും മാപ്പുകളുടെയും ജീവിത ചക്രം ഞങ്ങൾ സൂക്ഷ്മമായി പരിശോധിക്കും.

ബിപിഎഫ് സിസ്റ്റം കോൾ ഉപയോഗിച്ച് ഒബ്‌ജക്‌റ്റുകൾ നിയന്ത്രിക്കുന്നു. സിസ്റ്റം ഇതിനകം തന്നെ നിലവിലുണ്ട്, ഒരു പ്രത്യേക സിസ്റ്റം കോൾ ഉപയോഗിച്ച് ഉപയോക്തൃ സ്ഥലത്ത് നിന്ന് ഒബ്‌ജക്റ്റുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും കൈകാര്യം ചെയ്യാമെന്നും ഞങ്ങൾ അന്തിമമായി പരിശോധിക്കും - bpf(2).

Пишем программы BPF с помощью libbpf. തീർച്ചയായും, ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രോഗ്രാമുകൾ എഴുതാം. പക്ഷേ ബുദ്ധിമുട്ടാണ്. കൂടുതൽ യാഥാർത്ഥ്യമായ ഒരു സാഹചര്യത്തിനായി, ന്യൂക്ലിയർ പ്രോഗ്രാമർമാർ ഒരു ലൈബ്രറി വികസിപ്പിച്ചെടുത്തു libbpf. ഞങ്ങൾ ഒരു അടിസ്ഥാന BPF ആപ്ലിക്കേഷൻ അസ്ഥികൂടം സൃഷ്ടിക്കും, അത് തുടർന്നുള്ള ഉദാഹരണങ്ങളിൽ ഞങ്ങൾ ഉപയോഗിക്കും.

കേർണൽ സഹായികൾ. ബിപിഎഫ് പ്രോഗ്രാമുകൾക്ക് കേർണൽ ഹെൽപ്പർ ഫംഗ്‌ഷനുകൾ ആക്‌സസ് ചെയ്യാൻ കഴിയുന്നതെങ്ങനെയെന്ന് ഇവിടെ നമ്മൾ പഠിക്കും - മാപ്പുകൾക്കൊപ്പം, ക്ലാസിക് ഒന്നിനെ അപേക്ഷിച്ച് പുതിയ ബിപിഎഫിന്റെ കഴിവുകൾ അടിസ്ഥാനപരമായി വികസിപ്പിക്കുന്ന ഒരു ഉപകരണം.

BPF പ്രോഗ്രാമുകളിൽ നിന്ന് മാപ്പുകളിലേക്കുള്ള ആക്സസ്. ഈ ഘട്ടത്തിൽ, മാപ്പുകൾ ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കൃത്യമായി മനസ്സിലാക്കാൻ ഞങ്ങൾക്ക് വേണ്ടത്ര അറിയാം. മികച്ചതും ശക്തവുമായ വെരിഫയറിലേക്ക് നമുക്ക് പെട്ടെന്ന് എത്തിനോക്കാം.

വികസന ഉപകരണങ്ങൾ. പരീക്ഷണങ്ങൾക്കായി ആവശ്യമായ യൂട്ടിലിറ്റികളും കേർണലും എങ്ങനെ കൂട്ടിച്ചേർക്കാം എന്നതിനെക്കുറിച്ചുള്ള സഹായ വിഭാഗം.

ഉപസംഹാരം. ലേഖനത്തിന്റെ അവസാനം, ഇത് വരെ വായിക്കുന്നവർക്ക് പ്രചോദനം നൽകുന്ന വാക്കുകളും തുടർന്നുള്ള ലേഖനങ്ങളിൽ എന്ത് സംഭവിക്കും എന്നതിന്റെ ഒരു ഹ്രസ്വ വിവരണവും കണ്ടെത്തും. തുടർച്ചയ്ക്കായി കാത്തിരിക്കാനുള്ള ആഗ്രഹമോ കഴിവോ ഇല്ലാത്തവർക്കായി സ്വയം പഠനത്തിനായി ഞങ്ങൾ നിരവധി ലിങ്കുകൾ പട്ടികപ്പെടുത്തും.

ബിപിഎഫ് ആർക്കിടെക്ചറിലേക്കുള്ള ആമുഖം

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

64-ബിറ്റ് മെഷീനുകൾ, ക്ലൗഡ് സേവനങ്ങൾ, SDN സൃഷ്ടിക്കുന്നതിനുള്ള ടൂളുകളുടെ വർദ്ധിച്ച ആവശ്യകത എന്നിവയുടെ പ്രതികരണമായാണ് പുതിയ BPF വികസിപ്പിച്ചത്.Sപലപ്പോഴും-dനിർവചിച്ചു nഎറ്റ്വർക്കിംഗ്). ക്ലാസിക് BPF-ന് മെച്ചപ്പെട്ട പകരക്കാരനായി കേർണൽ നെറ്റ്‌വർക്ക് എഞ്ചിനീയർമാർ വികസിപ്പിച്ചെടുത്ത, പുതിയ BPF അക്ഷരാർത്ഥത്തിൽ ആറ് മാസത്തിന് ശേഷം ലിനക്സ് സിസ്റ്റങ്ങൾ കണ്ടെത്തുന്നതിനുള്ള ബുദ്ധിമുട്ടുള്ള ദൗത്യത്തിൽ ആപ്ലിക്കേഷനുകൾ കണ്ടെത്തി, ഇപ്പോൾ, അത് പ്രത്യക്ഷപ്പെട്ട് ആറ് വർഷത്തിന് ശേഷം, ഞങ്ങൾക്ക് അടുത്ത ലേഖനം മുഴുവൻ ആവശ്യമാണ്. വിവിധ തരം പ്രോഗ്രാമുകൾ പട്ടികപ്പെടുത്തുക.

രസകരമായ ചിത്രങ്ങൾ

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

ഈ പ്രക്രിയയെക്കുറിച്ച് നമുക്ക് കൂടുതൽ വിശദമായി നോക്കാം. ആരംഭിക്കുന്നതിന്, ക്ലാസിക് ബിപിഎഫിൽ നിന്നുള്ള ആദ്യ വ്യത്യാസത്തെക്കുറിച്ച് സംസാരിക്കാം, അതിനായി അസംബ്ലറിൽ എഴുതിയ പ്രോഗ്രാമുകൾ. പുതിയ പതിപ്പിൽ, ആർക്കിടെക്ചർ വിപുലീകരിച്ചു, അതിനാൽ പ്രോഗ്രാമുകൾ ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ എഴുതാം, പ്രാഥമികമായി, തീർച്ചയായും, സിയിൽ. ഇതിനായി, llvm-നുള്ള ഒരു ബാക്കെൻഡ് വികസിപ്പിച്ചെടുത്തു, ഇത് BPF ആർക്കിടെക്ചറിനായി ബൈറ്റ്കോഡ് സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

BPF ആർക്കിടെക്ചർ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, ഭാഗികമായി, ആധുനിക മെഷീനുകളിൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കാനാണ്. ഇത് പ്രായോഗികമാക്കാൻ, ബിപിഎഫ് ബൈറ്റ്കോഡ്, കേർണലിലേക്ക് ലോഡ് ചെയ്തുകഴിഞ്ഞാൽ, ജെഐടി കമ്പൈലർ (JIT കംപൈലർ) എന്ന ഘടകം ഉപയോഗിച്ച് നേറ്റീവ് കോഡിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു.Just In Time). അടുത്തതായി, നിങ്ങൾ ഓർക്കുന്നുണ്ടെങ്കിൽ, ക്ലാസിക് BPF-ൽ പ്രോഗ്രാം കേർണലിലേക്ക് ലോഡ് ചെയ്യുകയും ഇവന്റ് ഉറവിടത്തിലേക്ക് ആറ്റോമിക് ആയി ഘടിപ്പിക്കുകയും ചെയ്തു - ഒരൊറ്റ സിസ്റ്റം കോളിന്റെ പശ്ചാത്തലത്തിൽ. പുതിയ ആർക്കിടെക്ചറിൽ, ഇത് രണ്ട് ഘട്ടങ്ങളിലായാണ് സംഭവിക്കുന്നത് - ആദ്യം, സിസ്റ്റം കോൾ ഉപയോഗിച്ച് കോഡ് കേർണലിലേക്ക് ലോഡ് ചെയ്യുന്നു. bpf(2)തുടർന്ന്, പിന്നീട്, പ്രോഗ്രാമിന്റെ തരം അനുസരിച്ച് വ്യത്യാസപ്പെടുന്ന മറ്റ് മെക്കാനിസങ്ങളിലൂടെ, പ്രോഗ്രാം ഇവന്റ് ഉറവിടത്തിലേക്ക് അറ്റാച്ചുചെയ്യുന്നു.

ഇവിടെ വായനക്കാരന് ഒരു ചോദ്യം ഉണ്ടായേക്കാം: അത് സാധ്യമായിരുന്നോ? അത്തരം കോഡിന്റെ നിർവ്വഹണ സുരക്ഷ എങ്ങനെയാണ് ഉറപ്പ് നൽകുന്നത്? വെരിഫയർ (ഇംഗ്ലീഷിൽ ഈ ഘട്ടത്തെ വെരിഫയർ എന്ന് വിളിക്കുന്നു, ഞാൻ ഇംഗ്ലീഷ് വാക്ക് ഉപയോഗിക്കുന്നത് തുടരും):

വെരിഫയർ ഒരു സ്റ്റാറ്റിക് അനലൈസറാണ്, ഒരു പ്രോഗ്രാം കേർണലിന്റെ സാധാരണ പ്രവർത്തനത്തെ തടസ്സപ്പെടുത്തുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു. സിസ്റ്റത്തിന്റെ പ്രവർത്തനത്തെ പ്രോഗ്രാമിന് തടസ്സപ്പെടുത്താൻ കഴിയില്ലെന്ന് ഇത് അർത്ഥമാക്കുന്നില്ല - തരം അനുസരിച്ച്, ബിപിഎഫ് പ്രോഗ്രാമുകൾക്ക് കേർണൽ മെമ്മറിയുടെ വിഭാഗങ്ങൾ വായിക്കാനും മാറ്റിയെഴുതാനും കഴിയും, ഫംഗ്ഷനുകളുടെ മൂല്യങ്ങൾ മടക്കിനൽകുക, ട്രിം ചെയ്യുക, കൂട്ടിച്ചേർക്കുക, വീണ്ടും എഴുതുക കൂടാതെ ഫോർവേഡ് നെറ്റ്‌വർക്ക് പാക്കറ്റുകൾ പോലും. ഒരു ബിപിഎഫ് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നത് കേർണലിനെ ക്രാഷ് ചെയ്യില്ലെന്നും നിയമങ്ങൾ അനുസരിച്ച്, റൈറ്റ് ആക്‌സസ് ഉള്ള ഒരു പ്രോഗ്രാമിന്, ഉദാഹരണത്തിന്, ഔട്ട്‌ഗോയിംഗ് പാക്കറ്റിന്റെ ഡാറ്റയ്ക്ക് പാക്കറ്റിന് പുറത്ത് കേർണൽ മെമ്മറി പുനരാലേഖനം ചെയ്യാൻ കഴിയില്ലെന്നും വെരിഫയർ ഉറപ്പ് നൽകുന്നു. BPF-ന്റെ മറ്റെല്ലാ ഘടകങ്ങളും പരിചയപ്പെട്ടതിന് ശേഷം, അനുബന്ധ വിഭാഗത്തിൽ ഞങ്ങൾ വെരിഫയറിനെ കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കും.

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

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

ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ച് ഉപയോക്തൃ പ്രക്രിയകളിൽ നിന്ന് മാപ്‌സ് ആക്‌സസ് ചെയ്യപ്പെടുന്നു bpf(2), കൂടാതെ ഹെൽപ്പർ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് കേർണലിൽ പ്രവർത്തിക്കുന്ന BPF പ്രോഗ്രാമുകളിൽ നിന്നും. കൂടാതെ, മാപ്പുകളിൽ പ്രവർത്തിക്കാൻ മാത്രമല്ല, മറ്റ് കേർണൽ കഴിവുകൾ ആക്സസ് ചെയ്യാനും സഹായികൾ നിലവിലുണ്ട്. ഉദാഹരണത്തിന്, മറ്റ് ഇന്റർഫേസുകളിലേക്ക് പാക്കറ്റുകൾ കൈമാറുന്നതിനും പെർഫ് ഇവന്റുകൾ സൃഷ്ടിക്കുന്നതിനും കേർണൽ ഘടനകൾ ആക്‌സസ് ചെയ്യുന്നതിനും ബിപിഎഫ് പ്രോഗ്രാമുകൾക്ക് ഹെൽപ്പർ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കാം.

ചുരുക്കത്തിൽ, കേർണൽ സ്‌പെയ്‌സിലേക്ക് അനിയന്ത്രിതമായ, അതായത് വെരിഫയർ-ടെസ്റ്റ് ചെയ്‌ത ഉപയോക്തൃ കോഡ് ലോഡ് ചെയ്യാനുള്ള കഴിവ് BPF നൽകുന്നു. ഈ കോഡിന് കോളുകൾക്കിടയിൽ അവസ്ഥ സംരക്ഷിക്കാനും ഉപയോക്തൃ ഇടം ഉപയോഗിച്ച് ഡാറ്റ കൈമാറ്റം ചെയ്യാനും കഴിയും, കൂടാതെ ഇത്തരത്തിലുള്ള പ്രോഗ്രാം അനുവദിക്കുന്ന കേർണൽ സബ്സിസ്റ്റങ്ങളിലേക്കുള്ള ആക്‌സസ്സും ഉണ്ട്.

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

അത്തരം കഴിവുകളുടെ സാന്നിധ്യം ബിപിഎഫിനെ കേർണൽ വികസിപ്പിക്കുന്നതിനുള്ള ഒരു സാർവത്രിക ഉപകരണമാക്കി മാറ്റുന്നു, ഇത് പ്രായോഗികമായി സ്ഥിരീകരിക്കുന്നു: കൂടുതൽ കൂടുതൽ പുതിയ തരം പ്രോഗ്രാമുകൾ ബിപിഎഫിലേക്ക് ചേർക്കുന്നു, കൂടുതൽ കൂടുതൽ വലിയ കമ്പനികൾ കോംബാറ്റ് സെർവറുകളിൽ 24×7 ബിപിഎഫ് ഉപയോഗിക്കുന്നു, കൂടുതൽ കൂടുതൽ BPF അടിസ്ഥാനമാക്കിയുള്ള പരിഹാരങ്ങൾ അടിസ്ഥാനമാക്കിയാണ് സ്റ്റാർട്ടപ്പുകൾ അവരുടെ ബിസിനസ്സ് കെട്ടിപ്പടുക്കുന്നത്. എല്ലായിടത്തും BPF ഉപയോഗിക്കുന്നു: DDoS ആക്രമണങ്ങളിൽ നിന്ന് പരിരക്ഷിക്കുന്നതിനും, SDN സൃഷ്ടിക്കുന്നതിനും (ഉദാഹരണത്തിന്, kubernetes-നായി നെറ്റ്‌വർക്കുകൾ നടപ്പിലാക്കുന്നതിനും), പ്രധാന സിസ്റ്റം ട്രെയ്‌സിംഗ് ഉപകരണമായും സ്ഥിതിവിവരക്കണക്കുകൾ ശേഖരിക്കുന്നവരായും, നുഴഞ്ഞുകയറ്റം കണ്ടെത്തൽ സംവിധാനങ്ങളിലും സാൻഡ്‌ബോക്‌സ് സിസ്റ്റങ്ങളിലും മുതലായവ.

ലേഖനത്തിന്റെ അവലോകന ഭാഗം ഇവിടെ പൂർത്തിയാക്കി വെർച്വൽ മെഷീനും ബിപിഎഫ് ഇക്കോസിസ്റ്റവും കൂടുതൽ വിശദമായി നോക്കാം.

വ്യതിചലനം: യൂട്ടിലിറ്റികൾ

ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിലെ ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾക്ക് കുറഞ്ഞത് നിരവധി യൂട്ടിലിറ്റികൾ ആവശ്യമായി വന്നേക്കാം llvm/clang bpf പിന്തുണയോടെ ഒപ്പം bpftool. വിഭാഗത്തിൽ വികസന ഉപകരണങ്ങൾ യൂട്ടിലിറ്റികൾ കൂട്ടിച്ചേർക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങളും നിങ്ങളുടെ കേർണലും നിങ്ങൾക്ക് വായിക്കാം. ഞങ്ങളുടെ അവതരണത്തിന്റെ യോജിപ്പിന് ഭംഗം വരാതിരിക്കാനാണ് ഈ ഭാഗം താഴെ നൽകിയിരിക്കുന്നത്.

BPF വെർച്വൽ മെഷീൻ രജിസ്റ്ററുകളും ഇൻസ്ട്രക്ഷൻ സിസ്റ്റവും

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

ബിപിഎഫിന് ഉപയോക്താക്കൾക്ക് ആക്സസ് ചെയ്യാവുന്ന പതിനൊന്ന് 64-ബിറ്റ് രജിസ്റ്ററുകൾ ഉണ്ട് r0-r10 ഒരു പ്രോഗ്രാം കൗണ്ടറും. രജിസ്റ്റർ ചെയ്യുക r10 ഒരു ഫ്രെയിം പോയിന്റർ അടങ്ങിയിരിക്കുന്നു, വായിക്കാൻ മാത്രം. പ്രോഗ്രാമുകൾക്ക് റൺടൈമിൽ 512-ബൈറ്റ് സ്റ്റാക്കിലേക്കും മാപ്പുകളുടെ രൂപത്തിൽ അൺലിമിറ്റഡ് മെമ്മറി പങ്കിടലിലേക്കും ആക്സസ് ഉണ്ട്.

BPF പ്രോഗ്രാമുകൾക്ക് ഒരു പ്രത്യേക സെറ്റ് പ്രോഗ്രാം-ടൈപ്പ് കേർണൽ സഹായികളും അടുത്തകാലത്തായി റെഗുലർ ഫംഗ്ഷനുകളും പ്രവർത്തിപ്പിക്കാൻ അനുവാദമുണ്ട്. വിളിക്കപ്പെടുന്ന ഓരോ ഫംഗ്‌ഷനും രജിസ്റ്ററുകളിൽ പാസാക്കിയ അഞ്ച് ആർഗ്യുമെന്റുകൾ വരെ എടുക്കാം r1-r5, കൂടാതെ റിട്ടേൺ മൂല്യം കൈമാറുന്നു r0. ഫംഗ്ഷനിൽ നിന്ന് മടങ്ങിയെത്തിയ ശേഷം, രജിസ്റ്ററുകളുടെ ഉള്ളടക്കം ഉറപ്പുനൽകുന്നു r6-r9 മാറില്ല.

കാര്യക്ഷമമായ പ്രോഗ്രാം വിവർത്തനത്തിനായി, രജിസ്റ്റർ ചെയ്യുന്നു r0-r11 നിലവിലെ ആർക്കിടെക്ചറിന്റെ എബിഐ സവിശേഷതകൾ കണക്കിലെടുത്ത്, പിന്തുണയ്ക്കുന്ന എല്ലാ ആർക്കിടെക്ചറുകളും യഥാർത്ഥ രജിസ്റ്ററുകളിലേക്ക് അദ്വിതീയമായി മാപ്പ് ചെയ്തിരിക്കുന്നു. ഉദാഹരണത്തിന്, വേണ്ടി x86_64 രജിസ്റ്റർ ചെയ്യുന്നു r1-r5, ഫംഗ്‌ഷൻ പാരാമീറ്ററുകൾ കൈമാറാൻ ഉപയോഗിക്കുന്നു, അത് പ്രദർശിപ്പിക്കും rdi, rsi, rdx, rcx, r8, ഫംഗ്‌ഷനുകളിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറാൻ ഉപയോഗിക്കുന്നവ x86_64. ഉദാഹരണത്തിന്, ഇടതുവശത്തുള്ള കോഡ് ഇതുപോലെ വലതുവശത്തുള്ള കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നു:

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

രജിസ്റ്റർ ചെയ്യുക r0 പ്രോഗ്രാം എക്സിക്യൂഷന്റെ ഫലവും രജിസ്റ്ററിലും തിരികെ നൽകാനും ഉപയോഗിക്കുന്നു r1 പ്രോഗ്രാം സന്ദർഭത്തിലേക്ക് ഒരു പോയിന്റർ കൈമാറുന്നു - പ്രോഗ്രാമിന്റെ തരം അനുസരിച്ച്, ഇത് ഒരു ഘടനയായിരിക്കാം struct xdp_md (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, യഥാക്രമം. ക്ലാസുകൾ 4, 7 (BPF_ALU, BPF_ALU64) ALU നിർദ്ദേശങ്ങളുടെ ഒരു കൂട്ടം രൂപീകരിക്കുക. ക്ലാസുകൾ 5, 6 (BPF_JMP, BPF_JMP32) ജമ്പ് നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കുന്നു.

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

ഞങ്ങൾ വ്യക്തിഗത നിർദ്ദേശങ്ങളെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ, ഞങ്ങൾ പ്രധാന ഫയലുകൾ പരാമർശിക്കും bpf.h и bpf_common.h, BPF നിർദ്ദേശങ്ങളുടെ സംഖ്യാ കോഡുകൾ നിർവചിക്കുന്നു. സ്വന്തമായി ആർക്കിടെക്ചർ പഠിക്കുമ്പോൾ കൂടാതെ/അല്ലെങ്കിൽ ബൈനറികൾ പാഴ്‌സുചെയ്യുമ്പോൾ, സങ്കീർണ്ണതയുടെ ക്രമത്തിൽ അടുക്കിയിരിക്കുന്ന ഇനിപ്പറയുന്ന ഉറവിടങ്ങളിൽ സെമാന്റിക്‌സ് കണ്ടെത്താനാകും: അനൗദ്യോഗിക eBPF സ്പെസിഫിക്കേഷൻ, BPF, XDP റഫറൻസ് ഗൈഡ്, ഇൻസ്ട്രക്ഷൻ സെറ്റ്, ഡോക്യുമെന്റേഷൻ/നെറ്റ്‌വർക്കിംഗ്/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 ക്ലാസ് 1 പ്രവർത്തനമാണ് BPF_JEQ (തുല്യമാണെങ്കിൽ ചാടുക). ഞങ്ങളുടെ കാര്യത്തിൽ, ബിറ്റ് മുതൽ S പൂജ്യമാണ്, ഇത് ഉറവിട രജിസ്റ്ററിന്റെ മൂല്യത്തെ ഫീൽഡുമായി താരതമ്യം ചെയ്യുന്നു Imm. മൂല്യങ്ങൾ പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, പരിവർത്തനം സംഭവിക്കുന്നു PC + Offഎവിടെ PC, പതിവുപോലെ, അടുത്ത നിർദ്ദേശത്തിന്റെ വിലാസം അടങ്ങിയിരിക്കുന്നു. അവസാനമായി, JMP ക്ലാസ് 9 ഓപ്പറേഷൻ ആണ് BPF_EXIT. ഈ നിർദ്ദേശം പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നു, കേർണലിലേക്ക് മടങ്ങുന്നു r0. നമ്മുടെ പട്ടികയിലേക്ക് ഒരു പുതിയ കോളം ചേർക്കാം:

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

ഞങ്ങൾക്ക് ഇത് കൂടുതൽ സൗകര്യപ്രദമായ രൂപത്തിൽ മാറ്റിയെഴുതാം:

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

രജിസ്റ്ററിൽ ഉള്ളത് ഓർത്താൽ r1 പ്രോഗ്രാം കേർണലിൽ നിന്നും രജിസ്റ്ററിൽ നിന്നും സന്ദർഭത്തിലേക്ക് ഒരു പോയിന്റർ കൈമാറുന്നു r0 മൂല്യം കേർണലിലേക്ക് തിരികെ നൽകുന്നു, അപ്പോൾ സന്ദർഭത്തിലേക്കുള്ള പോയിന്റർ പൂജ്യമാണെങ്കിൽ, ഞങ്ങൾ 1 തിരികെ നൽകുന്നു, അല്ലാത്തപക്ഷം - 2. ഉറവിടം നോക്കി നമ്മൾ ശരിയാണോ എന്ന് പരിശോധിക്കാം:

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

അതെ, ഇതൊരു അർത്ഥശൂന്യമായ പ്രോഗ്രാമാണ്, എന്നാൽ ഇത് നാല് ലളിതമായ നിർദ്ദേശങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.

ഒഴിവാക്കൽ ഉദാഹരണം: 16-ബൈറ്റ് നിർദ്ദേശം

ചില നിർദ്ദേശങ്ങൾ 64 ബിറ്റുകളിൽ കൂടുതൽ എടുക്കുമെന്ന് ഞങ്ങൾ നേരത്തെ സൂചിപ്പിച്ചു. ഉദാഹരണത്തിന്, നിർദ്ദേശങ്ങൾക്ക് ഇത് ബാധകമാണ് lddw (കോഡ് = 0x18 = BPF_LD | BPF_DW | BPF_IMM) - ഫീൽഡുകളിൽ നിന്ന് ഒരു ഇരട്ട വാക്ക് രജിസ്റ്ററിലേക്ക് ലോഡ് ചെയ്യുക Imm. വസ്തുത അതാണ് Imm 32 വലുപ്പമുണ്ട്, ഇരട്ട വാക്ക് 64 ബിറ്റുകളാണ്, അതിനാൽ ഒരു 64-ബിറ്റ് നിർദ്ദേശത്തിൽ ഒരു രജിസ്റ്ററിലേക്ക് 64-ബിറ്റ് ഉടനടി മൂല്യം ലോഡ് ചെയ്യുന്നത് പ്രവർത്തിക്കില്ല. ഇത് ചെയ്യുന്നതിന്, ഫീൽഡിൽ 64-ബിറ്റ് മൂല്യത്തിന്റെ രണ്ടാം ഭാഗം സംഭരിക്കുന്നതിന് അടുത്തുള്ള രണ്ട് നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു Imm. ഉദാഹരണം:

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

ഒരു ബൈനറി പ്രോഗ്രാമിൽ രണ്ട് നിർദ്ദേശങ്ങൾ മാത്രമേയുള്ളൂ:

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

നിർദ്ദേശങ്ങളുമായി ഞങ്ങൾ വീണ്ടും കാണും lddw, ഞങ്ങൾ സ്ഥലം മാറ്റങ്ങളെക്കുറിച്ചും മാപ്പുകളോടൊപ്പം ജോലി ചെയ്യുന്നതിനെക്കുറിച്ചും സംസാരിക്കുമ്പോൾ.

ഉദാഹരണം: സ്റ്റാൻഡേർഡ് ടൂളുകൾ ഉപയോഗിച്ച് ബിപിഎഫ് ഡിസ്അസംബ്ലിംഗ് ചെയ്യുന്നു

അതിനാൽ, ഞങ്ങൾ BPF ബൈനറി കോഡുകൾ വായിക്കാൻ പഠിച്ചു, ആവശ്യമെങ്കിൽ ഏത് നിർദ്ദേശവും പാഴ്‌സ് ചെയ്യാൻ തയ്യാറാണ്. എന്നിരുന്നാലും, പ്രായോഗികമായി സ്റ്റാൻഡേർഡ് ടൂളുകൾ ഉപയോഗിച്ച് പ്രോഗ്രാമുകൾ ഡിസ്അസംബ്ലിംഗ് ചെയ്യുന്നത് കൂടുതൽ സൗകര്യപ്രദവും വേഗതയുമാണെന്ന് പറയേണ്ടതാണ്, ഉദാഹരണത്തിന്:

$ 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 ഫയൽ സിസ്റ്റം ഈ അവസരം നൽകുന്നു. ബിപിഎഫ് ഒബ്‌ജക്‌റ്റുകളെ പരാമർശിക്കുന്ന ഫയലുകൾ സൃഷ്‌ടിക്കാനും അതുവഴി വർദ്ധിപ്പിക്കാനും അനുവദിക്കുന്ന ഇൻ-മെമ്മറി-ഒൺലി സ്യൂഡോ-ഫയൽ സിസ്റ്റമാണിത്. 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) (സ്‌ട്രേസ് ഔട്ട്‌പുട്ടിൽ നിന്ന് ചില അപ്രസക്തമായ വരികൾ നീക്കം ചെയ്‌തു):

$ 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, ഇനിപ്പറയുന്ന പ്രോട്ടോടൈപ്പ് ഉണ്ട്:

#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 പ്രോഗ്രാം നിർവചിച്ച ശേഷം, ഞങ്ങൾ അത് കേർണലിലേക്ക് ലോഡുചെയ്യുന്നതിലേക്ക് നീങ്ങുന്നു. ഞങ്ങളുടെ മിനിമലിസ്റ്റ് പാരാമീറ്ററുകൾ 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 പ്രോഗ്രാമുകളിലേക്കുള്ള പോയിന്ററുകൾ അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് ഇന്റർഫേസുകളിലേക്കുള്ള പോയിന്ററുകൾ, പെർഫ് ഇവന്റുകൾക്കൊപ്പം പ്രവർത്തിക്കാനുള്ള മാപ്പുകൾ മുതലായവ അടങ്ങുന്ന പ്രത്യേക-ഉദ്ദേശ്യ മാപ്പുകൾ ഉണ്ട്. വായനക്കാരനെ ആശയക്കുഴപ്പത്തിലാക്കാതിരിക്കാൻ ഞങ്ങൾ അവരെക്കുറിച്ച് ഇവിടെ സംസാരിക്കില്ല. ഇതുകൂടാതെ, സമന്വയ പ്രശ്നങ്ങൾ ഞങ്ങൾ അവഗണിക്കുന്നു, കാരണം ഇത് ഞങ്ങളുടെ ഉദാഹരണങ്ങൾക്ക് പ്രധാനമല്ല. ലഭ്യമായ മാപ്പ് തരങ്ങളുടെ പൂർണ്ണമായ ലിസ്റ്റ് ഇതിൽ കാണാം <linux/bpf.h>, ഈ വിഭാഗത്തിൽ നമ്മൾ ചരിത്രപരമായി ആദ്യ തരം ഹാഷ് ടേബിൾ ഉദാഹരണമായി എടുക്കും BPF_MAP_TYPE_HASH.

നിങ്ങൾ C++ എന്നതിൽ ഒരു ഹാഷ് ടേബിൾ സൃഷ്ടിക്കുകയാണെങ്കിൽ, നിങ്ങൾ പറയും unordered_map<int,long> woo, റഷ്യൻ ഭാഷയിൽ "എനിക്ക് ഒരു മേശ വേണം woo പരിധിയില്ലാത്ത വലുപ്പം, അതിന്റെ കീകൾ തരം int, മൂല്യങ്ങൾ തരം long" ഒരു ബിപിഎഫ് ഹാഷ് ടേബിൾ സൃഷ്‌ടിക്കുന്നതിന്, പട്ടികയുടെ പരമാവധി വലുപ്പം വ്യക്തമാക്കണം എന്നതൊഴിച്ചാൽ, ഞങ്ങൾ ഒരേ കാര്യം തന്നെ ചെയ്യേണ്ടതുണ്ട്, കൂടാതെ കീകളുടെയും മൂല്യങ്ങളുടെയും തരങ്ങൾ വ്യക്തമാക്കുന്നതിനുപകരം, അവയുടെ വലുപ്പങ്ങൾ ബൈറ്റുകളിൽ വ്യക്തമാക്കേണ്ടതുണ്ട്. . മാപ്പുകൾ സൃഷ്ടിക്കാൻ കമാൻഡ് ഉപയോഗിക്കുക 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 എന്ന സംഖ്യയാണ് നമ്മുടെ വസ്തുവിന്റെ ആഗോള ഐഡി. കമാൻഡ് ഉപയോഗിച്ച് നിലവിലുള്ള ഒരു മാപ്പ് തുറക്കാൻ സിസ്റ്റത്തിലെ ഏത് പ്രോഗ്രാമിനും ഈ ഐഡി ഉപയോഗിക്കാം 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.

ശരി, നമുക്ക് കീ 1 ഉപയോഗിച്ച് മൂല്യം മാറ്റാം, നമ്മുടെ ബിസിനസ്സ് ലോജിക്കിന് രജിസ്ട്രേഷൻ ആവശ്യമാണെന്ന് പറയാം hash[1] = 2:

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

പ്രതീക്ഷിച്ചതുപോലെ, ഇത് വളരെ ലളിതമാണ്: കമാൻഡ് BPF_MAP_GET_FD_BY_ID ഐഡിയും കമാൻഡും ഉപയോഗിച്ച് ഞങ്ങളുടെ മാപ്പ് തുറക്കുന്നു BPF_MAP_UPDATE_ELEM മൂലകത്തെ തിരുത്തിയെഴുതുന്നു.

അതിനാൽ, ഒരു പ്രോഗ്രാമിൽ നിന്ന് ഒരു ഹാഷ് ടേബിൾ സൃഷ്ടിച്ച ശേഷം, നമുക്ക് മറ്റൊന്നിൽ നിന്ന് അതിന്റെ ഉള്ളടക്കങ്ങൾ വായിക്കാനും എഴുതാനും കഴിയും. കമാൻഡ് ലൈനിൽ നിന്ന് ഇത് ചെയ്യാൻ കഴിയുമെങ്കിൽ, സിസ്റ്റത്തിലെ മറ്റേതെങ്കിലും പ്രോഗ്രാമിന് ഇത് ചെയ്യാൻ കഴിയും. മുകളിൽ വിവരിച്ച കമാൻഡുകൾക്ക് പുറമേ, ഉപയോക്തൃ സ്ഥലത്ത് നിന്നുള്ള മാപ്പുകളിൽ പ്രവർത്തിക്കുന്നതിന്, ഇനിപ്പറയുന്നവ:

• BPF_MAP_LOOKUP_ELEM: കീ ഉപയോഗിച്ച് മൂല്യം കണ്ടെത്തുക
• BPF_MAP_UPDATE_ELEM: മൂല്യം അപ്ഡേറ്റ് ചെയ്യുക/സൃഷ്ടിക്കുക
• BPF_MAP_DELETE_ELEM: കീ നീക്കം ചെയ്യുക
• BPF_MAP_GET_NEXT_KEY: അടുത്ത (അല്ലെങ്കിൽ ആദ്യ) കീ കണ്ടെത്തുക
• BPF_MAP_GET_NEXT_ID: നിലവിലുള്ള എല്ലാ മാപ്പുകളിലൂടെയും പോകാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അങ്ങനെയാണ് ഇത് പ്രവർത്തിക്കുന്നത് bpftool map
• BPF_MAP_GET_FD_BY_ID: നിലവിലുള്ള ഒരു മാപ്പ് അതിന്റെ ആഗോള ഐഡി ഉപയോഗിച്ച് തുറക്കുക
• BPF_MAP_LOOKUP_AND_DELETE_ELEM: ഒരു വസ്തുവിന്റെ മൂല്യം ആറ്റോമിക് ആയി അപ്ഡേറ്റ് ചെയ്യുകയും പഴയത് തിരികെ നൽകുകയും ചെയ്യുക
• BPF_MAP_FREEZE: ഉപയോക്തൃ ഇടത്തിൽ നിന്ന് മാപ്പ് മാറ്റമില്ലാത്തതാക്കുക (ഈ പ്രവർത്തനം പഴയപടിയാക്കാൻ കഴിയില്ല)
• BPF_MAP_LOOKUP_BATCH, BPF_MAP_LOOKUP_AND_DELETE_BATCH, BPF_MAP_UPDATE_BATCH, BPF_MAP_DELETE_BATCH: ബഹുജന പ്രവർത്തനങ്ങൾ. ഉദാഹരണത്തിന്, BPF_MAP_LOOKUP_AND_DELETE_BATCH - മാപ്പിൽ നിന്ന് എല്ലാ മൂല്യങ്ങളും വായിക്കാനും പുനഃസജ്ജമാക്കാനുമുള്ള ഏക വിശ്വസനീയമായ മാർഗമാണിത്

ഈ കമാൻഡുകളെല്ലാം എല്ലാ മാപ്പ് തരങ്ങൾക്കും വേണ്ടി പ്രവർത്തിക്കില്ല, എന്നാൽ പൊതുവേ, ഉപയോക്തൃ സ്ഥലത്ത് നിന്നുള്ള മറ്റ് തരത്തിലുള്ള മാപ്പുകളിൽ പ്രവർത്തിക്കുന്നത് ഹാഷ് ടേബിളുകളിൽ പ്രവർത്തിക്കുന്നതിന് സമാനമാണ്.

ക്രമത്തിന് വേണ്ടി, നമുക്ക് ഹാഷ് ടേബിൾ പരീക്ഷണങ്ങൾ പൂർത്തിയാക്കാം. നാല് കീകൾ വരെ ഉൾക്കൊള്ളാൻ കഴിയുന്ന ഒരു പട്ടികയാണ് ഞങ്ങൾ സൃഷ്ടിച്ചതെന്ന് ഓർക്കുന്നുണ്ടോ? നമുക്ക് കുറച്ച് ഘടകങ്ങൾ കൂടി ചേർക്കാം:

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

ഇതുവരെ വളരെ നല്ലതായിരുന്നു:

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

ഒന്ന് കൂടി ചേർക്കാൻ ശ്രമിക്കാം:

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

പ്രതീക്ഷിച്ചതുപോലെ, ഞങ്ങൾ വിജയിച്ചില്ല. പിശക് കൂടുതൽ വിശദമായി നോക്കാം:

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

എല്ലാം ശരിയാണ്: പ്രതീക്ഷിച്ചതുപോലെ, ടീം BPF_MAP_UPDATE_ELEM ഒരു പുതിയ, അഞ്ചാമത്തെ, കീ സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്നു, പക്ഷേ ക്രാഷുകൾ E2BIG.

അതിനാൽ, ഞങ്ങൾക്ക് BPF പ്രോഗ്രാമുകൾ സൃഷ്‌ടിക്കാനും ലോഡുചെയ്യാനും ഉപയോക്തൃ സ്ഥലത്ത് നിന്ന് മാപ്പുകൾ സൃഷ്‌ടിക്കാനും നിയന്ത്രിക്കാനും കഴിയും. ബിപിഎഫ് പ്രോഗ്രാമുകളിൽ നിന്ന് തന്നെ നമുക്ക് മാപ്പുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കുന്നത് ഇപ്പോൾ യുക്തിസഹമാണ്. മെഷീൻ മാക്രോ കോഡുകളിലെ വായിക്കാൻ ബുദ്ധിമുട്ടുള്ള പ്രോഗ്രാമുകളുടെ ഭാഷയിൽ നമുക്ക് ഇതിനെക്കുറിച്ച് സംസാരിക്കാം, എന്നാൽ യഥാർത്ഥത്തിൽ BPF പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതുകയും പരിപാലിക്കുകയും ചെയ്യുന്നുവെന്ന് കാണിക്കേണ്ട സമയം അതിക്രമിച്ചിരിക്കുന്നു. libbpf.

(താഴ്ന്ന നിലയിലുള്ള ഉദാഹരണത്തിന്റെ അഭാവത്തിൽ അസംതൃപ്തരായ വായനക്കാർക്ക്: ഉപയോഗിച്ച് സൃഷ്ടിച്ച മാപ്പുകളും സഹായ പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്ന വിശദമായ പ്രോഗ്രാമുകൾ ഞങ്ങൾ വിശകലനം ചെയ്യും libbpf നിർദ്ദേശ തലത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് നിങ്ങളോട് പറയുക. അസംതൃപ്തരായ വായനക്കാർക്ക് വളരെ, ഞങ്ങൾ കൂട്ടിച്ചേർത്തു ഉദാഹരണം ലേഖനത്തിൽ ഉചിതമായ സ്ഥലത്ത്.)

libbpf ഉപയോഗിച്ച് BPF പ്രോഗ്രാമുകൾ എഴുതുന്നു

മെഷീൻ കോഡുകൾ ഉപയോഗിച്ച് BPF പ്രോഗ്രാമുകൾ എഴുതുന്നത് ആദ്യമായി രസകരമായിരിക്കും, തുടർന്ന് സംതൃപ്തി ആരംഭിക്കും. ഈ നിമിഷം നിങ്ങളുടെ ശ്രദ്ധ തിരിക്കേണ്ടതുണ്ട് llvm, BPF ആർക്കിടെക്ചറിനായി കോഡ് സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ബാക്കെൻഡും ലൈബ്രറിയും ഉണ്ട് libbpf, ഇത് BPF ആപ്ലിക്കേഷനുകളുടെ ഉപയോക്തൃ വശം എഴുതാനും ഉപയോഗിച്ച് സൃഷ്ടിച്ച BPF പ്രോഗ്രാമുകളുടെ കോഡ് ലോഡ് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു llvm/clang.

വാസ്തവത്തിൽ, ഇതിലും തുടർന്നുള്ള ലേഖനങ്ങളിലും നമ്മൾ കാണും, libbpf ഇത് കൂടാതെ ധാരാളം ജോലികൾ ചെയ്യുന്നു (അല്ലെങ്കിൽ സമാനമായ ഉപകരണങ്ങൾ - iproute2, libbcc, libbpf-go, മുതലായവ) ജീവിക്കാൻ അസാധ്യമാണ്. പദ്ധതിയുടെ കൊലയാളി സവിശേഷതകളിൽ ഒന്ന് libbpf BPF CO-RE (ഒരിക്കൽ കംപൈൽ ചെയ്യുക, എല്ലായിടത്തും പ്രവർത്തിപ്പിക്കുക) - വ്യത്യസ്ത API-കളിൽ പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവോടെ (ഉദാഹരണത്തിന്, പതിപ്പിൽ നിന്ന് കേർണൽ ഘടന മാറുമ്പോൾ, ഒരു കേർണലിൽ നിന്ന് മറ്റൊന്നിലേക്ക് പോർട്ടബിൾ ചെയ്യാവുന്ന BPF പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോജക്റ്റ് പതിപ്പിലേക്ക്). 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, നമുക്ക് നിരവധി (കൂടുതലോ കുറവോ അർത്ഥശൂന്യമായ) ടെസ്റ്റ് പ്രോഗ്രാമുകൾ എഴുതുകയും എല്ലാം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വിശദമായി വിശകലനം ചെയ്യുകയും ചെയ്യാം. മാപ്പുകൾ, കേർണൽ സഹായികൾ, BTF മുതലായവയുമായി BPF പ്രോഗ്രാമുകൾ എങ്ങനെ സംവദിക്കുന്നുവെന്ന് കൃത്യമായി ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ കൂടുതൽ എളുപ്പത്തിൽ വിശദീകരിക്കാൻ ഇത് ഞങ്ങളെ അനുവദിക്കും.

സാധാരണയായി ഉപയോഗിക്കുന്ന പ്രോജക്റ്റുകൾ libbpf ഒരു git സബ്‌മോഡ്യൂളായി ഒരു 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, മുമ്പത്തെ ഉദാഹരണത്തിലെ പോലെ തന്നെ, എന്നാൽ സിയിൽ, ഞങ്ങൾ ഇത് ഉപയോഗിച്ച് കംപൈൽ ചെയ്യുന്നു 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 - ബിപിഎഫ് ലോകത്തിന്റെ സ്വിസ് കത്തി (അക്ഷരാർത്ഥത്തിൽ എടുക്കാം, കാരണം ബിപിഎഫിന്റെ സ്രഷ്ടാക്കളിലും പരിപാലിക്കുന്നവരിലൊരാളായ ഡാനിയൽ ബോർക്ക്മാൻ സ്വിസ്സ് ആണ്):

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

ഫയലിൽ xdp-simple.skel.h ഞങ്ങളുടെ പ്രോഗ്രാമിന്റെ ബൈനറി കോഡും കൈകാര്യം ചെയ്യുന്നതിനുള്ള പ്രവർത്തനങ്ങളും അടങ്ങിയിരിക്കുന്നു - ലോഡ് ചെയ്യൽ, അറ്റാച്ചുചെയ്യൽ, ഞങ്ങളുടെ ഒബ്ജക്റ്റ് ഇല്ലാതാക്കൽ. ഞങ്ങളുടെ ലളിതമായ സാഹചര്യത്തിൽ ഇത് ഓവർകിൽ പോലെ കാണപ്പെടുന്നു, എന്നാൽ ഒബ്‌ജക്റ്റ് ഫയലിൽ നിരവധി ബിപിഎഫ് പ്രോഗ്രാമുകളും മാപ്പുകളും അടങ്ങിയിരിക്കുന്ന സാഹചര്യത്തിലും ഇത് പ്രവർത്തിക്കുന്നു, ഈ ഭീമൻ ELF ലോഡുചെയ്യാൻ നമുക്ക് അസ്ഥികൂടം സൃഷ്‌ടിച്ച് ഞങ്ങൾ ഇഷ്‌ടാനുസൃത അപ്ലിക്കേഷനിൽ നിന്ന് ഒന്നോ രണ്ടോ ഫംഗ്‌ഷനുകൾ വിളിക്കേണ്ടതുണ്ട്. എഴുതുന്നു ഇനി നമുക്ക് മുന്നോട്ട് പോകാം.

കൃത്യമായി പറഞ്ഞാൽ, ഞങ്ങളുടെ ലോഡർ പ്രോഗ്രാം നിസ്സാരമാണ്:

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

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

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

    pause();

    xdp_simple_bpf__destroy(obj);
}

ഇത് struct xdp_simple_bpf ഫയലിൽ നിർവചിച്ചിരിക്കുന്നു xdp-simple.skel.h ഞങ്ങളുടെ ഒബ്‌ജക്റ്റ് ഫയലിനെ വിവരിക്കുകയും ചെയ്യുന്നു:

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

ഒരു താഴ്ന്ന നിലയിലുള്ള API യുടെ അടയാളങ്ങൾ നമുക്ക് ഇവിടെ കാണാം: ഘടന struct bpf_program *simple и struct bpf_link *simple. വിഭാഗത്തിൽ എഴുതിയിരിക്കുന്ന ഞങ്ങളുടെ പ്രോഗ്രാമിനെ ആദ്യ ഘടന പ്രത്യേകം വിവരിക്കുന്നു xdp/simple, രണ്ടാമത്തേത് പ്രോഗ്രാം എങ്ങനെ ഇവന്റ് ഉറവിടവുമായി ബന്ധിപ്പിക്കുന്നു എന്ന് വിവരിക്കുന്നു.

ഫംഗ്ഷൻ xdp_simple_bpf__open_and_load, ഒരു 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

പുതിയ എന്തെങ്കിലും! പ്രോഗ്രാം ഞങ്ങളുടെ സി സോഴ്‌സ് ഫയലിന്റെ ഭാഗങ്ങൾ അച്ചടിച്ചു. ഇത് ലൈബ്രറിയാണ് ചെയ്തത് libbpf, ബൈനറിയിലെ ഡീബഗ് വിഭാഗം കണ്ടെത്തി, അത് ഒരു ബിടിഎഫ് ഒബ്‌ജക്റ്റിലേക്ക് സമാഹരിച്ചു, ഇത് ഉപയോഗിച്ച് കേർണലിലേക്ക് ലോഡ് ചെയ്തു BPF_BTF_LOAD, തുടർന്ന് കമാൻഡ് ഉപയോഗിച്ച് പ്രോഗ്രാം ലോഡ് ചെയ്യുമ്പോൾ തത്ഫലമായുണ്ടാകുന്ന ഫയൽ ഡിസ്ക്രിപ്റ്റർ വ്യക്തമാക്കി BPG_PROG_LOAD.

കേർണൽ സഹായികൾ

BPF പ്രോഗ്രാമുകൾക്ക് "ബാഹ്യ" പ്രവർത്തനങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും - കേർണൽ സഹായികൾ. ഈ സഹായ പ്രവർത്തനങ്ങൾ BPF പ്രോഗ്രാമുകളെ കേർണൽ ഘടനകൾ ആക്‌സസ് ചെയ്യാനും മാപ്പുകൾ നിയന്ത്രിക്കാനും "യഥാർത്ഥ ലോകവുമായി" ആശയവിനിമയം നടത്താനും അനുവദിക്കുന്നു - പെർഫ് ഇവന്റുകൾ സൃഷ്ടിക്കുക, ഹാർഡ്‌വെയർ നിയന്ത്രിക്കുക (ഉദാഹരണത്തിന്, പാക്കറ്റുകൾ റീഡയറക്‌ട് ചെയ്യുക) മുതലായവ.

ഉദാഹരണം: bpf_get_smp_processor_id

"ഉദാഹരണത്തിലൂടെ പഠിക്കുക" എന്ന മാതൃകയുടെ ചട്ടക്കൂടിനുള്ളിൽ, സഹായ പ്രവർത്തനങ്ങളിൽ ഒന്ന് പരിഗണിക്കാം, bpf_get_smp_processor_id(), ഉറപ്പാണ് ഫയലിൽ kernel/bpf/helpers.c. BPF പ്രോഗ്രാം പ്രവർത്തിക്കുന്ന പ്രോസസറിന്റെ നമ്പർ ഇത് നൽകുന്നു. എന്നാൽ അതിന്റെ നിർവ്വഹണം ഒരു വരി എടുക്കുന്നതിനാൽ അതിന്റെ അർത്ഥശാസ്ത്രത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമില്ല:

BPF_CALL_0(bpf_get_smp_processor_id)
{
    return smp_processor_id();
}

BPF ഹെൽപ്പർ ഫംഗ്‌ഷൻ നിർവചനങ്ങൾ Linux സിസ്റ്റം കോൾ നിർവചനങ്ങൾക്ക് സമാനമാണ്. ഇവിടെ, ഉദാഹരണത്തിന്, ആർഗ്യുമെന്റുകളില്ലാത്ത ഒരു ഫംഗ്ഷൻ നിർവചിച്ചിരിക്കുന്നു. (മൂന്ന് ആർഗ്യുമെന്റുകൾ എടുക്കുന്ന ഒരു ഫംഗ്ഷൻ മാക്രോ ഉപയോഗിച്ച് നിർവചിക്കപ്പെടുന്നു 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, ഇത് സഹായ ഫംഗ്‌ഷൻ ഐഡിയിൽ നിന്ന് 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. ഉദ്ധരണികളിൽ നിർവചിച്ചിരിക്കുന്നത് കാരണം ഇത് ഒരു ലോജിക്കൽ നിർവചനമാണ്, കൂടാതെ സി ഭാഷയിൽ ഒരു കൂട്ടം കോൺക്രീറ്റ് ഘടനകളുടെ നിർവചനം മറ്റ് സ്ഥലങ്ങളിൽ സംഭവിക്കുന്നു. പ്രത്യേകിച്ച്, ഫയലിൽ 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 - പൂജ്യം. വെരിഫയർ ഉപയോഗിക്കുന്ന എബിഐ കരാർ പ്രകാരം, ഇത് ഹെൽപ്പർ ഫംഗ്‌ഷൻ നമ്പർ എട്ടിലേക്കുള്ള കോളാണ്. അത് സമാരംഭിച്ചുകഴിഞ്ഞാൽ, യുക്തി ലളിതമാണ്. രജിസ്റ്ററിൽ നിന്ന് മൂല്യം തിരികെ നൽകുക r0 ലേക്ക് പകർത്തി r1 കൂടാതെ 2,3 വരികളിൽ ഇത് ടൈപ്പിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നു u32 - മുകളിലെ 32 ബിറ്റുകൾ മായ്ച്ചു. 4,5,6,7 വരികളിൽ ഞങ്ങൾ 2 മടങ്ങുന്നു (XDP_PASS) അല്ലെങ്കിൽ 1 (XDP_DROP) വരി 0-ൽ നിന്നുള്ള സഹായ പ്രവർത്തനം പൂജ്യമോ പൂജ്യമോ അല്ലാത്ത മൂല്യം നൽകിയിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ച്.

നമുക്ക് സ്വയം പരീക്ഷിക്കാം: പ്രോഗ്രാം ലോഡ് ചെയ്ത് ഔട്ട്പുട്ട് നോക്കുക bpftool prog dump xlated:

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

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

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

ശരി, വെരിഫയർ ശരിയായ കേർണൽ സഹായിയെ കണ്ടെത്തി.

ഉദാഹരണം: ആർഗ്യുമെന്റുകൾ പാസാക്കുകയും ഒടുവിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക!

എല്ലാ റൺ-ലെവൽ ഹെൽപ്പർ ഫംഗ്‌ഷനുകൾക്കും ഒരു പ്രോട്ടോടൈപ്പ് ഉണ്ട്

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

സഹായ പ്രവർത്തനങ്ങളിലേക്കുള്ള പാരാമീറ്ററുകൾ രജിസ്റ്ററുകളിൽ കൈമാറുന്നു r1-r5, മൂല്യം രജിസ്റ്ററിൽ തിരികെ നൽകുന്നു r0. അഞ്ചിൽ കൂടുതൽ ആർഗ്യുമെന്റുകൾ എടുക്കുന്ന ഫംഗ്‌ഷനുകളൊന്നുമില്ല, അവയ്‌ക്കുള്ള പിന്തുണ ഭാവിയിൽ ചേർക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നില്ല.

പുതിയ കേർണൽ ഹെൽപ്പറും BPF പാരാമീറ്ററുകൾ എങ്ങനെ കടന്നുപോകുന്നുവെന്നും നോക്കാം. മാറ്റിയെഴുതാം xdp-simple.bpf.c ഇനിപ്പറയുന്ന രീതിയിൽ (ബാക്കി വരികൾ മാറിയിട്ടില്ല):

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

ഞങ്ങളുടെ പ്രോഗ്രാം അത് പ്രവർത്തിക്കുന്ന സിപിയു നമ്പർ പ്രിന്റ് ചെയ്യുന്നു. നമുക്ക് അത് സമാഹരിച്ച് കോഡ് നോക്കാം:

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

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

0-7 വരികളിൽ ഞങ്ങൾ സ്ട്രിംഗ് എഴുതുന്നു running on CPU%un, തുടർന്ന് 8 വരിയിൽ ഞങ്ങൾ പരിചിതമായ ഒന്ന് പ്രവർത്തിപ്പിക്കുന്നു bpf_get_smp_processor_id. 9-12 വരികളിൽ ഞങ്ങൾ സഹായ വാദങ്ങൾ തയ്യാറാക്കുന്നു bpf_printk - രജിസ്റ്റർ ചെയ്യുന്നു r1, r2, r3. എന്തുകൊണ്ടാണ് അവയിൽ മൂന്നെണ്ണം, രണ്ടല്ല? കാരണം bpf_printk - ഇതൊരു മാക്രോ റാപ്പറാണ് യഥാർത്ഥ സഹായിയെ ചുറ്റിപ്പറ്റി bpf_trace_printk, ഫോർമാറ്റ് സ്ട്രിംഗിന്റെ വലുപ്പം കൈമാറേണ്ടതുണ്ട്.

ഇനി നമുക്ക് രണ്ട് വരികൾ ചേർക്കാം xdp-simple.cഅങ്ങനെ ഞങ്ങളുടെ പ്രോഗ്രാം ഇന്റർഫേസുമായി ബന്ധിപ്പിക്കുന്നു lo ശരിക്കും തുടങ്ങി!

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

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

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

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

cleanup:
    xdp_simple_bpf__destroy(obj);
}

ഇവിടെ നമ്മൾ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു bpf_set_link_xdp_fd, ഇത് XDP-തരം BPF പ്രോഗ്രാമുകളെ നെറ്റ്‌വർക്ക് ഇന്റർഫേസുകളിലേക്ക് ബന്ധിപ്പിക്കുന്നു. ഞങ്ങൾ ഇന്റർഫേസ് നമ്പർ ഹാർഡ്കോഡ് ചെയ്തു lo, ഇത് എല്ലായ്പ്പോഴും 1. പഴയ പ്രോഗ്രാം അറ്റാച്ച് ചെയ്തിട്ടുണ്ടെങ്കിൽ ആദ്യം വേർപെടുത്താൻ ഞങ്ങൾ ഫംഗ്ഷൻ രണ്ടുതവണ പ്രവർത്തിപ്പിക്കുന്നു. ഇപ്പോൾ ഞങ്ങൾക്ക് ഒരു വെല്ലുവിളി ആവശ്യമില്ല എന്നത് ശ്രദ്ധിക്കുക pause അല്ലെങ്കിൽ അനന്തമായ ലൂപ്പ്: ഞങ്ങളുടെ ലോഡർ പ്രോഗ്രാം പുറത്തുകടക്കും, എന്നാൽ ഇവന്റ് ഉറവിടവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നതിനാൽ 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

ഞങ്ങൾ ഡൗൺലോഡ് ചെയ്ത പ്രോഗ്രാമിന് ഐഡി 669 ഉണ്ട്, ഇന്റർഫേസിൽ ഞങ്ങൾ അതേ ഐഡി കാണുന്നു lo. ഞങ്ങൾ രണ്ട് പാക്കേജുകൾ അയയ്ക്കും 127.0.0.1 (അഭ്യർത്ഥന + മറുപടി):

$ ping -c1 localhost

ഇപ്പോൾ ഡീബഗ് വെർച്വൽ ഫയലിന്റെ ഉള്ളടക്കം നോക്കാം /sys/kernel/debug/tracing/trace_pipe, അതിൽ bpf_printk അവന്റെ സന്ദേശങ്ങൾ എഴുതുന്നു:

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

രണ്ട് പൊതികൾ കണ്ടെത്തി lo കൂടാതെ CPU0-ൽ പ്രോസസ്സ് ചെയ്തു - ഞങ്ങളുടെ ആദ്യത്തെ പൂർണ്ണമായ അർത്ഥശൂന്യമായ BPF പ്രോഗ്രാം പ്രവർത്തിച്ചു!

അത് എടുത്തുപറയേണ്ടതാണ് bpf_printk ഇത് ഡീബഗ് ഫയലിലേക്ക് എഴുതുന്നത് വെറുതെയല്ല: ഇത് ഉൽ‌പാദനത്തിൽ ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും വിജയകരമായ സഹായിയല്ല, പക്ഷേ ലളിതമായ എന്തെങ്കിലും കാണിക്കുക എന്നതായിരുന്നു ഞങ്ങളുടെ ലക്ഷ്യം.

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 അറേയിലെ അനുബന്ധ എൻട്രിയിലേക്ക് നമുക്ക് ഒരു പോയിന്റർ ലഭിക്കും, അത് നമ്മൾ ഒന്നായി വർദ്ധിപ്പിക്കും. റഷ്യൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്‌തു: ഇൻകമിംഗ് പാക്കറ്റുകൾ ഏത് സിപിയു പ്രോസസ്സ് ചെയ്തു എന്നതിന്റെ സ്ഥിതിവിവരക്കണക്കുകൾ ഞങ്ങൾ കണക്കാക്കുന്നു. പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കാം:

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

അവളുമായി ബന്ധമുണ്ടെന്ന് നമുക്ക് പരിശോധിക്കാം lo കൂടാതെ കുറച്ച് പാക്കറ്റുകൾ അയയ്ക്കുക:

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

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

ഇനി നമുക്ക് അറേയുടെ ഉള്ളടക്കം നോക്കാം:

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

മിക്കവാറും എല്ലാ പ്രക്രിയകളും CPU7-ൽ പ്രോസസ്സ് ചെയ്തു. ഇത് ഞങ്ങൾക്ക് പ്രധാനമല്ല, പ്രധാന കാര്യം പ്രോഗ്രാം പ്രവർത്തിക്കുന്നു, കൂടാതെ BPF പ്രോഗ്രാമുകളിൽ നിന്ന് മാപ്പുകൾ എങ്ങനെ ആക്സസ് ചെയ്യാമെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു - ഉപയോഗിച്ച് хелперов bpf_mp_*.

മിസ്റ്റിക്കൽ സൂചിക

അതിനാൽ, പോലുള്ള കോളുകൾ ഉപയോഗിച്ച് നമുക്ക് BPF പ്രോഗ്രാമിൽ നിന്ന് മാപ്പ് ആക്സസ് ചെയ്യാൻ കഴിയും

val = bpf_map_lookup_elem(&woo, &key);

ഹെൽപ്പർ ഫംഗ്‌ഷൻ ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്

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

എന്നാൽ ഞങ്ങൾ ഒരു പോയിന്റർ കടന്നുപോകുന്നു &woo പേരില്ലാത്ത ഒരു ഘടനയിലേക്ക് struct { ... }പങ്ക് € |

പ്രോഗ്രാം അസംബ്ലർ നോക്കിയാൽ, മൂല്യം നമുക്ക് കാണാം &woo യഥാർത്ഥത്തിൽ നിർവചിച്ചിട്ടില്ല (വരി 4):

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

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

Disassembly of section xdp/simple:

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

കൂടാതെ സ്ഥലംമാറ്റങ്ങളിൽ അടങ്ങിയിരിക്കുന്നു:

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

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

എന്നാൽ ഞങ്ങൾ ഇതിനകം ലോഡ് ചെയ്ത പ്രോഗ്രാം നോക്കുകയാണെങ്കിൽ, ശരിയായ മാപ്പിലേക്കുള്ള ഒരു പോയിന്റർ കാണാം (ലൈൻ 4):

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

അതിനാൽ, ഞങ്ങളുടെ ലോഡർ പ്രോഗ്രാം സമാരംഭിക്കുന്ന സമയത്ത്, ഇതിലേക്കുള്ള ലിങ്ക് എന്ന് നമുക്ക് നിഗമനം ചെയ്യാം &woo ഒരു ലൈബ്രറി ഉപയോഗിച്ച് എന്തെങ്കിലും മാറ്റിസ്ഥാപിച്ചു libbpf. ആദ്യം നമുക്ക് ഔട്ട്പുട്ട് നോക്കാം strace:

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

ഞങ്ങൾ അത് കാണുന്നു libbpf ഒരു മാപ്പ് സൃഷ്ടിച്ചു woo എന്നിട്ട് ഞങ്ങളുടെ പ്രോഗ്രാം ഡൗൺലോഡ് ചെയ്തു simple. പ്രോഗ്രാം ലോഡുചെയ്യുന്നത് എങ്ങനെയെന്ന് നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം:

• വിളി xdp_simple_bpf__open_and_load ഫയലിൽ നിന്ന് xdp-simple.skel.h
• കാരണമാകുന്നു xdp_simple_bpf__load ഫയലിൽ നിന്ന് xdp-simple.skel.h
• കാരണമാകുന്നു bpf_object__load_skeleton ഫയലിൽ നിന്ന് libbpf/src/libbpf.c
• കാരണമാകുന്നു bpf_object__load_xattr നിന്ന് libbpf/src/libbpf.c

അവസാന ഫംഗ്ഷൻ, മറ്റ് കാര്യങ്ങൾക്കൊപ്പം, വിളിക്കും bpf_object__create_maps, നിലവിലുള്ള മാപ്പുകൾ സൃഷ്ടിക്കുകയോ തുറക്കുകയോ ചെയ്യുന്നു, അവ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളാക്കി മാറ്റുന്നു. (ഇവിടെയാണ് നമ്മൾ കാണുന്നത് BPF_MAP_CREATE ഔട്ട്പുട്ടിൽ strace.) അടുത്തതായി ഫംഗ്ഷൻ വിളിക്കുന്നു bpf_object__relocate ഞങ്ങൾ കണ്ടത് ഓർക്കുന്നതിനാൽ അവളാണ് ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ളത് woo സ്ഥലംമാറ്റ പട്ടികയിൽ. അത് പര്യവേക്ഷണം ചെയ്യുന്നതിലൂടെ, ഒടുവിൽ നമ്മൾ പ്രവർത്തനത്തിൽ സ്വയം കണ്ടെത്തുന്നു bpf_program__relocate, ഏത് ഭൂപടത്തിന്റെ സ്ഥാനമാറ്റങ്ങൾ കൈകാര്യം ചെയ്യുന്നു:

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

അതിനാൽ ഞങ്ങൾ ഞങ്ങളുടെ നിർദ്ദേശങ്ങൾ സ്വീകരിക്കുന്നു

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

അതിലെ ഉറവിട രജിസ്റ്ററിന് പകരം വയ്ക്കുക BPF_PSEUDO_MAP_FD, കൂടാതെ ഞങ്ങളുടെ മാപ്പിന്റെ ഫയൽ ഡിസ്ക്രിപ്റ്ററിലേക്കുള്ള ആദ്യ IMM, അത് തുല്യമാണെങ്കിൽ, ഉദാഹരണത്തിന്, 0xdeadbeef, അപ്പോൾ ഫലമായി നമുക്ക് നിർദ്ദേശം ലഭിക്കും

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

ഒരു പ്രത്യേക ലോഡ് ചെയ്ത BPF പ്രോഗ്രാമിലേക്ക് മാപ്പ് വിവരങ്ങൾ കൈമാറുന്നത് ഇങ്ങനെയാണ്. ഈ സാഹചര്യത്തിൽ, മാപ്പ് ഉപയോഗിച്ച് സൃഷ്ടിക്കാൻ കഴിയും BPF_MAP_CREATE, കൂടാതെ ഐഡി ഉപയോഗിച്ച് തുറന്നത് BPF_MAP_GET_FD_BY_ID.

ആകെ, ഉപയോഗിക്കുമ്പോൾ libbpf അൽഗോരിതം ഇപ്രകാരമാണ്:

• സമാഹരിക്കുന്ന സമയത്ത്, മാപ്പുകളിലേക്കുള്ള ലിങ്കുകൾക്കായി റിലൊക്കേഷൻ ടേബിളിൽ റെക്കോർഡുകൾ സൃഷ്ടിക്കപ്പെടുന്നു
• libbpf ELF ഒബ്‌ജക്‌റ്റ് ബുക്ക് തുറക്കുന്നു, ഉപയോഗിച്ച എല്ലാ മാപ്പുകളും കണ്ടെത്തി അവയ്‌ക്കായി ഫയൽ ഡിസ്‌ക്രിപ്‌റ്ററുകൾ സൃഷ്‌ടിക്കുന്നു
• നിർദ്ദേശത്തിന്റെ ഭാഗമായി ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ കേർണലിലേക്ക് ലോഡ് ചെയ്യുന്നു LD64

നിങ്ങൾക്ക് ഊഹിക്കാവുന്നതുപോലെ, ഇനിയും വരാനുണ്ട്, ഞങ്ങൾ കാമ്പിലേക്ക് നോക്കേണ്ടതുണ്ട്. ഭാഗ്യവശാൽ, ഞങ്ങൾക്ക് ഒരു സൂചനയുണ്ട് - ഞങ്ങൾ അർത്ഥം എഴുതിയിട്ടുണ്ട് BPF_PSEUDO_MAP_FD സ്രോതസ് രജിസ്റ്ററിൽ ഇടുക, നമുക്ക് അത് അടക്കം ചെയ്യാം, അത് നമ്മെ എല്ലാ വിശുദ്ധരുടെയും വിശുദ്ധത്തിലേക്ക് നയിക്കും - kernel/bpf/verifier.c, ഇവിടെ ഒരു വ്യതിരിക്തമായ പേരുള്ള ഒരു ഫംഗ്‌ഷൻ ഒരു ഫയൽ ഡിസ്‌ക്രിപ്‌റ്ററിനെ ടൈപ്പിന്റെ ഘടനയുടെ വിലാസം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു struct bpf_map:

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

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

(പൂർണ്ണ കോഡ് കണ്ടെത്താനാകും ബന്ധം). അതിനാൽ നമുക്ക് ഞങ്ങളുടെ അൽഗോരിതം വികസിപ്പിക്കാം:

• പ്രോഗ്രാം ലോഡ് ചെയ്യുമ്പോൾ, വെരിഫയർ മാപ്പിന്റെ ശരിയായ ഉപയോഗം പരിശോധിക്കുകയും അനുബന്ധ ഘടനയുടെ വിലാസം എഴുതുകയും ചെയ്യുന്നു struct bpf_map

ഉപയോഗിച്ച് ELF ബൈനറി ഡൗൺലോഡ് ചെയ്യുമ്പോൾ libbpf ഇനിയും ഒരുപാട് കാര്യങ്ങൾ നടക്കുന്നുണ്ട്, എന്നാൽ ഞങ്ങൾ അത് മറ്റ് ലേഖനങ്ങളിൽ ചർച്ച ചെയ്യും.

libbpf ഇല്ലാതെ പ്രോഗ്രാമുകളും മാപ്പുകളും ലോഡ് ചെയ്യുന്നു

വാഗ്ദാനം ചെയ്തതുപോലെ, സഹായമില്ലാതെ മാപ്പുകൾ ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാം എങ്ങനെ സൃഷ്ടിക്കാമെന്നും ലോഡ് ചെയ്യാമെന്നും അറിയാൻ ആഗ്രഹിക്കുന്ന വായനക്കാർക്കുള്ള ഒരു ഉദാഹരണം ഇതാ libbpf. നിങ്ങൾക്ക് ഡിപൻഡൻസികൾ നിർമ്മിക്കാനോ ഓരോ ബിറ്റും സംരക്ഷിക്കാനോ അല്ലെങ്കിൽ ഒരു പ്രോഗ്രാം എഴുതാനോ കഴിയാത്ത ഒരു പരിതസ്ഥിതിയിൽ നിങ്ങൾ പ്രവർത്തിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും. ply, അത് ഈച്ചയിൽ BPF ബൈനറി കോഡ് സൃഷ്ടിക്കുന്നു.

യുക്തി പിന്തുടരുന്നത് എളുപ്പമാക്കുന്നതിന്, ഈ ആവശ്യങ്ങൾക്കായി ഞങ്ങൾ ഞങ്ങളുടെ ഉദാഹരണം മാറ്റിയെഴുതും xdp-simple. ഈ ഉദാഹരണത്തിൽ ചർച്ച ചെയ്ത പ്രോഗ്രാമിന്റെ പൂർണ്ണവും ചെറുതായി വിപുലീകരിച്ചതുമായ കോഡ് ഇതിൽ കാണാം ഗുസ്തി.

ഞങ്ങളുടെ അപേക്ഷയുടെ യുക്തി ഇപ്രകാരമാണ്:

• ഒരു തരം മാപ്പ് സൃഷ്ടിക്കുക BPF_MAP_TYPE_ARRAY കമാൻഡ് ഉപയോഗിച്ച് BPF_MAP_CREATE,
• ഈ മാപ്പ് ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുക,
• പ്രോഗ്രാം ഇന്റർഫേസുമായി ബന്ധിപ്പിക്കുക lo,

അത് മനുഷ്യനായി വിവർത്തനം ചെയ്യുന്നു

int main(void)
{
    int map_fd, prog_fd;

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

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

    xdp_attach(1, prog_fd);
}

ഇത് map_create സിസ്റ്റം കോളിനെക്കുറിച്ചുള്ള ആദ്യ ഉദാഹരണത്തിൽ ഞങ്ങൾ ചെയ്ത അതേ രീതിയിൽ ഒരു മാപ്പ് സൃഷ്ടിക്കുന്നു bpf - “കേർണൽ, ഇത് പോലെയുള്ള 8 ഘടകങ്ങളുടെ ഒരു ശ്രേണിയുടെ രൂപത്തിൽ എനിക്ക് ഒരു പുതിയ മാപ്പ് ഉണ്ടാക്കുക __u64 ഫയൽ ഡിസ്ക്രിപ്റ്റർ എനിക്ക് തിരികെ തരൂ":

static int map_create()
{
    union bpf_attr attr;

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

പ്രോഗ്രാം ലോഡുചെയ്യാനും എളുപ്പമാണ്:

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

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

തന്ത്രപ്രധാനമായ ഭാഗം prog_load എന്നത് ഞങ്ങളുടെ BPF പ്രോഗ്രാമിന്റെ നിർവചനം ഘടനകളുടെ ഒരു നിരയാണ് struct bpf_insn insns[]. എന്നാൽ നമ്മൾ സിയിൽ ഉള്ള ഒരു പ്രോഗ്രാം ഉപയോഗിക്കുന്നതിനാൽ, നമുക്ക് കുറച്ച് ചതിക്കാം:

$ 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, പാക്കേജിൽ നിന്ന് വിതരണം ചെയ്യാൻ കഴിയുന്നത്. എന്നിരുന്നാലും, ബിപിഎഫ് വികസിച്ചുകൊണ്ടിരിക്കുന്നതിനാൽ, കേർണലും ഉപകരണങ്ങളും നിരന്തരം മാറിക്കൊണ്ടിരിക്കുന്നു, 2019 മുതൽ പഴയ രീതിയിലുള്ള രീതികൾ ഉപയോഗിച്ച് ബിപിഎഫ് പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾ കംപൈൽ ചെയ്യേണ്ടിവരും.

• llvm/clang
• pahole
• അതിന്റെ കാതൽ
• bpftool

(റഫറൻസിനായി, ഈ വിഭാഗവും ലേഖനത്തിലെ എല്ലാ ഉദാഹരണങ്ങളും ഡെബിയൻ 10-ൽ പ്രവർത്തിപ്പിച്ചതാണ്.)

llvm/clang

ബി‌പി‌എഫ് എൽ‌എൽ‌വി‌എമ്മുമായി സൗഹൃദപരമാണ്, കൂടാതെ അടുത്തിടെ ബി‌പി‌എഫിനായുള്ള പ്രോഗ്രാമുകൾ‌ ജി‌സി‌സി ഉപയോഗിച്ച് സമാഹരിക്കാൻ‌ കഴിയുമെങ്കിലും, നിലവിലുള്ള എല്ലാ വികസനവും എൽ‌എൽ‌വി‌എമ്മിനായി നടപ്പിലാക്കുന്നു. അതിനാൽ, ഒന്നാമതായി, ഞങ്ങൾ നിലവിലെ പതിപ്പ് നിർമ്മിക്കും 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 ഫോർമാറ്റിൽ ഡീബഗ്ഗിംഗ് വിവരങ്ങൾ സൃഷ്ടിക്കാൻ കേർണൽ നിർമ്മിക്കുമ്പോൾ ഉപയോഗിക്കുന്നു. 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 വികസനം നടക്കുന്നത് ലിനക്സ് നെറ്റ്‌വർക്കിംഗ് കമ്മ്യൂണിറ്റിയിലാണ്, അതിനാൽ എല്ലാ മാറ്റങ്ങളും താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട് ലിനക്സ് നെറ്റ്‌വർക്കിംഗ് മെയിന്റനറായ ഡേവിഡ് മില്ലറിലൂടെ കടന്നുപോകുന്നു. അവയുടെ സ്വഭാവത്തെ ആശ്രയിച്ച് - എഡിറ്റുകൾ അല്ലെങ്കിൽ പുതിയ സവിശേഷതകൾ - നെറ്റ്‌വർക്ക് മാറ്റങ്ങൾ രണ്ട് കോറുകളിൽ ഒന്നായി വരുന്നു - 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, Linux കേർണലിന്റെ ഭാഗമായി വിതരണം ചെയ്തു. ഇത് ബിപിഎഫ് ഡവലപ്പർമാർക്കായി ബിപിഎഫ് ഡവലപ്പർമാർ എഴുതുകയും പരിപാലിക്കുകയും ചെയ്യുന്നു, കൂടാതെ എല്ലാത്തരം ബിപിഎഫ് ഒബ്‌ജക്റ്റുകളും - ലോഡ് പ്രോഗ്രാമുകൾ, മാപ്പുകൾ സൃഷ്ടിക്കുക, എഡിറ്റ് ചെയ്യുക, ബിപിഎഫ് ഇക്കോസിസ്റ്റത്തിന്റെ ജീവിതം പര്യവേക്ഷണം ചെയ്യുക തുടങ്ങിയവ കൈകാര്യം ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം. മാൻ പേജുകൾക്കുള്ള സോഴ്സ് കോഡുകളുടെ രൂപത്തിൽ ഡോക്യുമെന്റേഷൻ കണ്ടെത്താനാകും കാമ്പിൽ അല്ലെങ്കിൽ, ഇതിനകം സമാഹരിച്ചത്, നെറ്റിൽ.

ഇത് എഴുതുന്ന സമയത്ത് 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
...

നിങ്ങളുടെ കെർണലിൽ ഏത് ബിപിഎഫ് ഫീച്ചറുകൾ പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെന്ന് ഇത് കാണിക്കും.

വഴിയിൽ, മുമ്പത്തെ കമാൻഡ് ഇതുപോലെ പ്രവർത്തിപ്പിക്കാം

# bpftool f p k

പാക്കേജിൽ നിന്നുള്ള യൂട്ടിലിറ്റികളുമായുള്ള സാമ്യം ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് iproute2, നമുക്ക് എവിടെ, ഉദാഹരണത്തിന്, പറയാം ip a s eth0 പകരം ip addr show dev eth0.

തീരുമാനം

കാമ്പിന്റെ പ്രവർത്തനക്ഷമത ഫലപ്രദമായി അളക്കുന്നതിനും ഓൺ-ദി-ഫ്ലൈ മാറ്റുന്നതിനും ഒരു ചെള്ളിനെ ഷൂ ചെയ്യാൻ BPF നിങ്ങളെ അനുവദിക്കുന്നു. UNIX-ന്റെ ഏറ്റവും മികച്ച പാരമ്പര്യങ്ങളിൽ, സിസ്റ്റം വളരെ വിജയകരമായിരുന്നു: കേർണൽ (വീണ്ടും) പ്രോഗ്രാം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ലളിതമായ സംവിധാനം ധാരാളം ആളുകളെയും ഓർഗനൈസേഷനുകളെയും പരീക്ഷണങ്ങൾ നടത്താൻ അനുവദിച്ചു. കൂടാതെ, പരീക്ഷണങ്ങളും അതുപോലെ തന്നെ ബിപിഎഫ് ഇൻഫ്രാസ്ട്രക്ചറിന്റെ വികസനവും പൂർത്തിയായിട്ടില്ലെങ്കിലും, സിസ്റ്റത്തിന് ഇതിനകം സ്ഥിരതയുള്ള ഒരു എബിഐ ഉണ്ട്, അത് വിശ്വസനീയവും ഏറ്റവും പ്രധാനമായി ഫലപ്രദവുമായ ബിസിനസ്സ് ലോജിക്ക് നിർമ്മിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

എന്റെ അഭിപ്രായത്തിൽ, സാങ്കേതികവിദ്യ വളരെ ജനപ്രിയമായിത്തീർന്നുവെന്നത് ശ്രദ്ധിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, കാരണം ഒരു വശത്ത് അതിന് കഴിയും കളിക്കുക (ഒരു യന്ത്രത്തിന്റെ വാസ്തുവിദ്യ ഒരു സായാഹ്നത്തിൽ കൂടുതലോ കുറവോ മനസ്സിലാക്കാം), മറുവശത്ത്, അതിന്റെ രൂപത്തിന് മുമ്പ് പരിഹരിക്കാൻ കഴിയാത്ത (മനോഹരമായി) പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ. ഈ രണ്ട് ഘടകങ്ങളും ഒരുമിച്ച് ആളുകളെ പരീക്ഷിക്കാനും സ്വപ്നം കാണാനും പ്രേരിപ്പിക്കുന്നു, ഇത് കൂടുതൽ നൂതനമായ പരിഹാരങ്ങളുടെ ആവിർഭാവത്തിലേക്ക് നയിക്കുന്നു.

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

ഈ പരമ്പരയിലെ മുൻ ലേഖനങ്ങൾ

1. ചെറിയ കുട്ടികൾക്കുള്ള ബിപിഎഫ്, ഭാഗം പൂജ്യം: ക്ലാസിക് ബിപിഎഫ്

ലിങ്കുകൾ

1. BPF, XDP റഫറൻസ് ഗൈഡ് - സിലിയത്തിൽ നിന്നുള്ള ബിപിഎഫിനെക്കുറിച്ചുള്ള ഡോക്യുമെന്റേഷൻ, അല്ലെങ്കിൽ ബിപിഎഫിന്റെ സ്രഷ്‌ടാക്കളിലും പരിപാലിക്കുന്നവരിലൊരാളായ ഡാനിയൽ ബോർക്ക്‌മാനിൽ നിന്ന്. ഡാനിയേലിന് താൻ എന്താണ് എഴുതുന്നതെന്ന് കൃത്യമായി അറിയാമെന്നും അതിൽ തെറ്റുകളൊന്നുമില്ലാത്തതിനാലും മറ്റുള്ളവരിൽ നിന്ന് വ്യത്യസ്തമായ ആദ്യത്തെ ഗുരുതരമായ വിവരണങ്ങളിൽ ഒന്നാണിത്. പ്രത്യേകിച്ചും, അറിയപ്പെടുന്ന യൂട്ടിലിറ്റി ഉപയോഗിച്ച് XDP, TC തരങ്ങളുടെ BPF പ്രോഗ്രാമുകളുമായി എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് ഈ പ്രമാണം വിവരിക്കുന്നു. ip പാക്കേജിൽ നിന്ന് iproute2.

2. ഡോക്യുമെന്റേഷൻ/നെറ്റ്‌വർക്കിംഗ്/filter.txt — ക്ലാസിക്കിനുള്ള ഡോക്യുമെന്റേഷനോടുകൂടിയ യഥാർത്ഥ ഫയൽ, തുടർന്ന് വിപുലീകരിച്ച BPF. നിങ്ങൾക്ക് അസംബ്ലി ഭാഷയും സാങ്കേതിക വാസ്തുവിദ്യാ വിശദാംശങ്ങളും പരിശോധിക്കണമെങ്കിൽ ഒരു നല്ല വായന.

3. ഫേസ്ബുക്കിൽ നിന്ന് BPF നെക്കുറിച്ചുള്ള ബ്ലോഗ്. അലക്സി സ്റ്റാറോവോയിറ്റോവ് (ഇബിപിഎഫിന്റെ രചയിതാവ്) ആൻഡ്രി നക്രിക്കോ - (പരിപാലകൻ) എന്നിവർ അവിടെ എഴുതുന്നത് പോലെ, ഇത് വളരെ അപൂർവമായി മാത്രമേ അപ്ഡേറ്റ് ചെയ്യപ്പെടുന്നുള്ളൂ, എന്നാൽ ഉചിതമായി. libbpf).

4. bpftool-ന്റെ രഹസ്യങ്ങൾ. bpftool ഉപയോഗിക്കുന്നതിന്റെ ഉദാഹരണങ്ങളും രഹസ്യങ്ങളും അടങ്ങിയ Quentin Monnet-ൽ നിന്നുള്ള രസകരമായ ട്വിറ്റർ ത്രെഡ്.

5. BPF-ലേക്ക് ഡൈവ് ചെയ്യുക: വായന സാമഗ്രികളുടെ ഒരു ലിസ്റ്റ്. Quentin Monnet-ൽ നിന്നുള്ള BPF ഡോക്യുമെന്റേഷനിലേക്കുള്ള ലിങ്കുകളുടെ ഒരു വലിയ (ഇപ്പോഴും പരിപാലിക്കപ്പെടുന്ന) ലിസ്റ്റ്.

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