BPF અને eBPF નો સંક્ષિપ્ત પરિચય

હે હબર! અમે તમને જાણ કરીએ છીએ કે અમે એક પુસ્તક બહાર પાડવાની તૈયારી કરી રહ્યા છીએ"BPF સાથે Linux અવલોકનક્ષમતા".

જેમ જેમ BPF વર્ચ્યુઅલ મશીન સતત વિકસિત થઈ રહ્યું છે અને વ્યવહારમાં તેનો સક્રિયપણે ઉપયોગ થાય છે, અમે તમારા માટે તેના મુખ્ય લક્ષણો અને વર્તમાન સ્થિતિનું વર્ણન કરતા લેખનો અનુવાદ કર્યો છે.

તાજેતરના વર્ષોમાં, ઉચ્ચ-પ્રદર્શન પેકેટ પ્રોસેસિંગની આવશ્યકતા હોય તેવા કિસ્સામાં Linux કર્નલની મર્યાદાઓને વળતર આપવા માટે પ્રોગ્રામિંગ સાધનો અને તકનીકોએ લોકપ્રિયતા મેળવી છે. આ પ્રકારની સૌથી લોકપ્રિય પદ્ધતિઓમાંની એક કહેવામાં આવે છે કોર બાયપાસ (કર્નલ બાયપાસ) અને યુઝર સ્પેસમાંથી તમામ પેકેટ પ્રોસેસિંગ કરવા માટે, કર્નલના નેટવર્ક લેયરને છોડી દેવાની મંજૂરી આપે છે. કર્નલને બાયપાસ કરવાથી નેટવર્ક કાર્ડનું સંચાલન પણ થાય છે વપરાશકર્તા જગ્યા. બીજા શબ્દોમાં કહીએ તો, નેટવર્ક કાર્ડ સાથે કામ કરતી વખતે, અમે ડ્રાઇવર પર આધાર રાખીએ છીએ વપરાશકર્તા જગ્યા.

નેટવર્ક કાર્ડના સંપૂર્ણ નિયંત્રણને વપરાશકર્તા-સ્પેસ પ્રોગ્રામમાં સ્થાનાંતરિત કરીને, અમે કર્નલના ઓવરહેડ (સંદર્ભ સ્વીચો, નેટવર્ક લેયર પ્રોસેસિંગ, ઇન્ટરપ્ટ્સ, વગેરે) ને ઘટાડીએ છીએ, જે 10 Gb/s ની ઝડપે ચાલતી વખતે ખૂબ જ મહત્વપૂર્ણ છે અથવા ઉચ્ચ કર્નલને બાયપાસ કરીને વત્તા અન્ય લક્ષણોનું સંયોજન (બેચ પ્રક્રિયા) અને સાવચેત પ્રદર્શન ટ્યુનિંગ (NUMA એકાઉન્ટિંગ, CPU અલગતા, વગેરે) ઉચ્ચ-પ્રદર્શન યુઝર-સ્પેસ નેટવર્કિંગની મૂળભૂત બાબતોમાં ફિટ છે. કદાચ પેકેટ પ્રોસેસિંગ માટેના આ નવા અભિગમનું અનુકરણીય ઉદાહરણ છે ડી.પી.ડી.કે. ઇન્ટેલ તરફથી (ડેટા પ્લેન ડેવલપમેન્ટ કિટ), જોકે સિસ્કો (વેક્ટર પેકેટ પ્રોસેસિંગ), નેટમેપ અને અલબત્ત, VPP સહિત અન્ય જાણીતા સાધનો અને તકનીકો છે. સ્નેબ.

વપરાશકર્તા જગ્યામાં નેટવર્ક ક્રિયાપ્રતિક્રિયાઓના સંગઠનમાં સંખ્યાબંધ ગેરફાયદા છે:

• OS કર્નલ એ હાર્ડવેર સંસાધનો માટે એબ્સ્ટ્રેક્શન લેયર છે. કારણ કે યુઝર-સ્પેસ પ્રોગ્રામ્સે તેમના સંસાધનોનું સીધું સંચાલન કરવું પડે છે, તેઓએ તેમના પોતાના હાર્ડવેરનું પણ સંચાલન કરવું પડશે. આનો અર્થ ઘણીવાર તમારા પોતાના ડ્રાઇવરોને પ્રોગ્રામ કરવો.
• અમે કર્નલ સ્પેસ સંપૂર્ણપણે છોડી રહ્યા હોવાથી, અમે કર્નલ દ્વારા પૂરી પાડવામાં આવતી તમામ નેટવર્કિંગ કાર્યક્ષમતા પણ છોડી દઈએ છીએ. યુઝર-સ્પેસ પ્રોગ્રામે એવી સુવિધાઓને ફરીથી અમલમાં મૂકવાની હોય છે જે કર્નલ અથવા ઓપરેટિંગ સિસ્ટમ દ્વારા પહેલાથી જ પ્રદાન કરવામાં આવી હોય.
• પ્રોગ્રામ્સ સેન્ડબોક્સ મોડમાં કાર્ય કરે છે, જે તેમની ક્રિયાપ્રતિક્રિયાને ગંભીરતાથી મર્યાદિત કરે છે અને તેમને ઓપરેટિંગ સિસ્ટમના અન્ય ભાગો સાથે એકીકૃત થવાથી અટકાવે છે.

સારમાં, જ્યારે યુઝર સ્પેસમાં નેટવર્કિંગ કરવામાં આવે છે, ત્યારે પેકેટ પ્રોસેસિંગને કર્નલમાંથી યુઝર સ્પેસમાં ખસેડીને પરફોર્મન્સ ગેઇન્સ પ્રાપ્ત થાય છે. XDP બરાબર વિરુદ્ધ કરે છે: તે નેટવર્ક પ્રોગ્રામ્સને યુઝર સ્પેસ (ફિલ્ટર્સ, કન્વર્ટર, રૂટીંગ વગેરે)માંથી કર્નલ વિસ્તારમાં ખસેડે છે. XDP અમને પેકેટ નેટવર્ક ઈન્ટરફેસ સાથે હિટ થતાં જ અને તે કર્નલના નેટવર્ક સબસિસ્ટમ સુધી મુસાફરી કરવાનું શરૂ કરે તે પહેલાં નેટવર્ક ફંક્શનને એક્ઝિક્યુટ કરવાની પરવાનગી આપે છે. પરિણામે, પેકેટ પ્રોસેસિંગ ઝડપ નોંધપાત્ર રીતે વધી છે. જો કે, કર્નલ કેવી રીતે વપરાશકર્તાને કર્નલ સ્પેસમાં તેમના પ્રોગ્રામ્સ ચલાવવાની મંજૂરી આપે છે? આ પ્રશ્નનો જવાબ આપતા પહેલા, ચાલો જોઈએ કે BPF શું છે.

BPF અને eBPF

સંપૂર્ણપણે સ્પષ્ટ નામ ન હોવા છતાં, BPF (પેકેટ ફિલ્ટરિંગ, બર્કલે) એ હકીકતમાં વર્ચ્યુઅલ મશીન મોડલ છે. આ વર્ચ્યુઅલ મશીન મૂળરૂપે પેકેટ ફિલ્ટરિંગને હેન્ડલ કરવા માટે બનાવવામાં આવ્યું હતું, તેથી તેનું નામ.

BPF નો ઉપયોગ કરતા વધુ જાણીતા સાધનો પૈકી એક છે tcpdump. સાથે પેકેટો કબજે કરતી વખતે tcpdump વપરાશકર્તા પેકેટ ફિલ્ટરિંગ માટે અભિવ્યક્તિનો ઉલ્લેખ કરી શકે છે. આ અભિવ્યક્તિ સાથે મેળ ખાતા પેકેટો જ કેપ્ચર કરવામાં આવશે. ઉદાહરણ તરીકે, અભિવ્યક્તિ "tcp dst port 80” પોર્ટ 80 પર આવતા તમામ TCP પેકેટોને લાગુ પડે છે. કમ્પાઈલર આ અભિવ્યક્તિને BPF બાઈટકોડમાં કન્વર્ટ કરીને ટૂંકી કરી શકે છે.

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

આ મૂળભૂત રીતે ઉપરોક્ત પ્રોગ્રામ શું કરે છે તે છે:

• સૂચના (000): ઑફસેટ 12 પર પેકેટને 16-બીટ શબ્દ તરીકે, એક્યુમ્યુલેટરમાં લોડ કરો. ઓફસેટ 12 પેકેટના ઈથરટાઈપને અનુરૂપ છે.
• સૂચના (001): 0x86dd સાથે સંચયકમાં મૂલ્યની તુલના કરે છે, એટલે કે, IPv6 માટે ઇથરટાઇપ મૂલ્ય સાથે. જો પરિણામ સાચું હોય, તો પ્રોગ્રામ કાઉન્ટર સૂચના (002) પર જાય છે, અને જો નહીં, તો પછી (006) પર જાય છે.
• સૂચના (006): 0x800 (IPv4 માટે ઇથરટાઇપ મૂલ્ય) સાથે મૂલ્યની તુલના કરે છે. જો જવાબ સાચો હોય, તો પ્રોગ્રામ (007) પર જાય છે, જો નહીં, તો પછી (015) પર જાય છે.

અને તેથી, જ્યાં સુધી પેકેટ ફિલ્ટરિંગ પ્રોગ્રામ પરિણામ આપે ત્યાં સુધી. સામાન્ય રીતે તે બુલિયન હોય છે. બિન-શૂન્ય મૂલ્ય (સૂચના (014)) પરત કરવાનો અર્થ એ છે કે પેકેટ મેળ ખાય છે, અને શૂન્ય (સૂચના (015)) પરત કરવાનો અર્થ છે કે પેકેટ મેળ ખાતું નથી.

BPF વર્ચ્યુઅલ મશીન અને તેના બાઈટકોડને સ્ટીવ મેકકેન અને વેન જેકોબસન દ્વારા 1992ના અંતમાં જ્યારે તેમના પેપર બહાર આવ્યા ત્યારે પ્રસ્તાવિત કરવામાં આવ્યા હતા. BSD પેકેટ ફિલ્ટર: યુઝર-લેવલ પેકેટ કેપ્ચર માટે નવું આર્કિટેક્ચર, 1993 ના શિયાળામાં યુઝનિક્સ કોન્ફરન્સમાં પ્રથમ વખત આ ટેકનોલોજી રજૂ કરવામાં આવી હતી.

કારણ કે BPF એ વર્ચ્યુઅલ મશીન છે, તે પર્યાવરણને વ્યાખ્યાયિત કરે છે જેમાં પ્રોગ્રામ ચાલે છે. બાઈટકોડ ઉપરાંત, તે પેકેટ મેમરી મોડલ (લોડ સૂચનાઓ સ્પષ્ટપણે પેકેટ પર લાગુ કરવામાં આવે છે), રજિસ્ટર (A અને X; સંચયક અને અનુક્રમણિકા રજિસ્ટર), સ્ક્રેચ મેમરી સ્ટોરેજ અને ગર્ભિત પ્રોગ્રામ કાઉન્ટર પણ વ્યાખ્યાયિત કરે છે. રસપ્રદ વાત એ છે કે, BPF બાઈટકોડને Motorola 6502 ISA પછી મોડલ કરવામાં આવ્યું હતું. જેમ કે સ્ટીવ મેકકેને તેનામાં યાદ કર્યું સંપૂર્ણ અહેવાલ શાર્કફેસ્ટ '11માં, Apple II પર પ્રોગ્રામિંગ કરતી વખતે તે હાઈસ્કૂલમાંથી બિલ્ડ 6502 થી પરિચિત હતો, અને આ જ્ઞાને BPF બાઈટકોડ ડિઝાઇન કરવાના તેમના કાર્યને પ્રભાવિત કર્યું.

BPF સપોર્ટ Linux કર્નલમાં v2.5 અને પછીના સંસ્કરણમાં લાગુ કરવામાં આવ્યો છે, જે મુખ્યત્વે જય શુલિસ્ટ દ્વારા ઉમેરવામાં આવ્યો છે. BPF કોડ 2011 સુધી યથાવત રહ્યો, જ્યારે એરિક ડુમાસેટે BPF દુભાષિયાને JIT મોડમાં કામ કરવા માટે ફરીથી ડિઝાઇન કર્યો (સ્રોત: પેકેટ ફિલ્ટર્સ માટે JIT). તે પછી, BPF બાઇટકોડનું અર્થઘટન કરવાને બદલે, કર્નલ સીધા BPF પ્રોગ્રામ્સને લક્ષ્ય આર્કિટેક્ચરમાં કન્વર્ટ કરી શકે છે: x86, ARM, MIPS, વગેરે.

પાછળથી, 2014 માં, એલેક્સી સ્ટારોવોઇટોવે BPF માટે નવી JIT મિકેનિઝમનો પ્રસ્તાવ મૂક્યો. વાસ્તવમાં, આ નવી JIT BPF પર આધારિત નવી આર્કિટેક્ચર બની હતી અને તેને eBPF કહેવામાં આવતું હતું. મને લાગે છે કે બંને VM થોડા સમય માટે સહઅસ્તિત્વ ધરાવે છે, પરંતુ પેકેટ ફિલ્ટરિંગ હાલમાં eBPF ની ટોચ પર અમલમાં છે. હકીકતમાં, ઘણા આધુનિક દસ્તાવેજીકરણ ઉદાહરણોમાં, BPF ને eBPF તરીકે ઓળખવામાં આવે છે, અને ક્લાસિકલ BPF આજે cBPF તરીકે ઓળખાય છે.

eBPF ક્લાસિક BPF વર્ચ્યુઅલ મશીનને ઘણી રીતે વિસ્તૃત કરે છે:

• આધુનિક 64-બીટ આર્કિટેક્ચર પર આધાર રાખે છે. eBPF 64-બીટ રજિસ્ટરનો ઉપયોગ કરે છે અને ઉપલબ્ધ રજિસ્ટરની સંખ્યા 2 (એક્યુમ્યુલેટર અને X) થી વધારીને 10 કરે છે. eBPF વધારાના opcodes (BPF_MOV, BPF_JNE, BPF_CALL…) પણ પ્રદાન કરે છે.
• નેટવર્ક લેયર સબસિસ્ટમથી અલગ. BPF બેચ ડેટા મોડેલ સાથે જોડાયેલું હતું. તેનો ઉપયોગ પેકેટોને ફિલ્ટર કરવા માટે થતો હોવાથી, તેનો કોડ સબસિસ્ટમમાં હતો જે નેટવર્ક ક્રિયાપ્રતિક્રિયાઓ પ્રદાન કરે છે. જો કે, eBPF વર્ચ્યુઅલ મશીન હવે ડેટા મોડેલ સાથે બંધાયેલ નથી અને તેનો ઉપયોગ કોઈપણ હેતુ માટે થઈ શકે છે. તેથી, હવે eBPF પ્રોગ્રામને ટ્રેસપોઇન્ટ અથવા kprobe સાથે કનેક્ટ કરી શકાય છે. આ અન્ય કર્નલ સબસિસ્ટમના સંદર્ભમાં eBPF ઇન્સ્ટ્રુમેન્ટેશન, પર્ફોર્મન્સ એનાલિસિસ અને અન્ય ઘણા ઉપયોગના કેસોના દરવાજા ખોલે છે. હવે eBPF કોડ તેના પોતાના પાથમાં સ્થિત છે: kernel/bpf.
• નકશા તરીકે ઓળખાતા વૈશ્વિક ડેટા સ્ટોર્સ. નકશા એ કી-વેલ્યુ સ્ટોર્સ છે જે યુઝર સ્પેસ અને કર્નલ સ્પેસ વચ્ચે ડેટા એક્સચેન્જ પ્રદાન કરે છે. eBPF અનેક પ્રકારના કાર્ડ પ્રદાન કરે છે.
• ગૌણ કાર્યો. ખાસ કરીને, પેકેજ પર ફરીથી લખવા માટે, ચેકસમની ગણતરી કરો, અથવા પેકેજને ક્લોન કરો. આ ફંક્શન કર્નલની અંદર ચાલે છે અને તે યુઝર-સ્પેસ પ્રોગ્રામ સાથે સંબંધિત નથી. વધુમાં, eBPF પ્રોગ્રામ્સમાંથી સિસ્ટમ કૉલ્સ કરી શકાય છે.
• કૉલ્સ સમાપ્ત કરો. eBPF માં પ્રોગ્રામનું કદ 4096 બાઇટ્સ સુધી મર્યાદિત છે. એન્ડ કોલ ફીચર eBPF પ્રોગ્રામને નવા eBPF પ્રોગ્રામમાં કંટ્રોલ ટ્રાન્સફર કરવાની પરવાનગી આપે છે અને આ રીતે આ મર્યાદાને બાયપાસ કરી શકે છે (32 પ્રોગ્રામ્સ સુધી આ રીતે સાંકળી શકાય છે).

eBPF ઉદાહરણ

Linux કર્નલ સ્ત્રોતોમાં eBPF માટે ઘણા ઉદાહરણો છે. તેઓ નમૂનાઓ/bpf/ પર ઉપલબ્ધ છે. આ ઉદાહરણોનું સંકલન કરવા માટે, ફક્ત ટાઇપ કરો:

$ sudo make samples/bpf/

હું મારી જાતે eBPF માટે નવું ઉદાહરણ લખીશ નહીં, પરંતુ નમૂનાઓ/bpf/માં ઉપલબ્ધ નમૂનાઓમાંથી એકનો ઉપયોગ કરીશ. હું કોડના કેટલાક ભાગો જોઈશ અને તે કેવી રીતે કાર્ય કરે છે તે સમજાવીશ. ઉદાહરણ તરીકે, મેં પ્રોગ્રામ પસંદ કર્યો tracex4.

સામાન્ય રીતે, નમૂનાઓ/bpf/માંના દરેક ઉદાહરણોમાં બે ફાઇલો હોય છે. આ બાબતે:

• tracex4_kern.c, કર્નલમાં eBPF બાઇટકોડ તરીકે એક્ઝિક્યુટ કરવા માટેનો સ્રોત કોડ ધરાવે છે.
• tracex4_user.c, વપરાશકર્તા સ્પેસમાંથી પ્રોગ્રામ ધરાવે છે.

આ કિસ્સામાં, આપણે કમ્પાઇલ કરવાની જરૂર છે tracex4_kern.c eBPF બાઇટકોડ પર. આ ક્ષણે માં gcc eBPF માટે કોઈ સર્વર ભાગ નથી. સદનસીબે, clang eBPF બાઈટકોડ પેદા કરી શકે છે. Makefile ઉપયોગ કરે છે clang સંકલન કરવું tracex4_kern.c ઑબ્જેક્ટ ફાઇલમાં.

મેં ઉપર ઉલ્લેખ કર્યો છે કે eBPF ની સૌથી રસપ્રદ વિશેષતાઓમાંની એક નકશા છે. tracex4_kern એક નકશો વ્યાખ્યાયિત કરે છે:

struct pair {
    u64 val;
    u64 ip;
};  

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

BPF_MAP_TYPE_HASH eBPF દ્વારા ઓફર કરાયેલા ઘણા કાર્ડ પ્રકારોમાંથી એક છે. આ કિસ્સામાં, તે માત્ર એક હેશ છે. તમે જાહેરાત પણ જોઈ હશે SEC("maps"). SEC એ એક મેક્રો છે જેનો ઉપયોગ બાઈનરી ફાઇલનો નવો વિભાગ બનાવવા માટે થાય છે. ખરેખર, ઉદાહરણમાં tracex4_kern બે વધુ વિભાગો વ્યાખ્યાયિત થયેલ છે:

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

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

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

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

આ બે કાર્યો તમને નકશામાંથી એન્ટ્રી દૂર કરવાની પરવાનગી આપે છે (kprobe/kmem_cache_free) અને નકશામાં નવી એન્ટ્રી ઉમેરો (kretprobe/kmem_cache_alloc_node). મોટા અક્ષરોમાં લખેલા બધા ફંક્શન નામો માં વ્યાખ્યાયિત મેક્રોને અનુરૂપ છે bpf_helpers.h.

જો હું ઑબ્જેક્ટ ફાઇલના વિભાગોને ડમ્પ કરું, તો મારે જોવું જોઈએ કે આ નવા વિભાગો પહેલેથી જ વ્યાખ્યાયિત છે:

$ objdump -h tracex4_kern.o

tracex4_kern.o: file format elf64-little

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

ત્યાં પણ છે tracex4_user.c, મુખ્ય કાર્યક્રમ. મૂળભૂત રીતે, આ પ્રોગ્રામ ઇવેન્ટ્સ માટે સાંભળે છે kmem_cache_alloc_node. જ્યારે આવી ઘટના બને છે, ત્યારે સંબંધિત eBPF કોડ એક્ઝિક્યુટ થાય છે. કોડ ઑબ્જેક્ટના IP એટ્રિબ્યુટને નકશામાં સાચવે છે, અને પછી ઑબ્જેક્ટને મુખ્ય પ્રોગ્રામ દ્વારા લૂપ કરવામાં આવે છે. ઉદાહરણ:

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

યુઝર સ્પેસ પ્રોગ્રામ અને eBPF પ્રોગ્રામ કેવી રીતે સંબંધિત છે? આરંભ સમયે tracex4_user.c ઑબ્જેક્ટ ફાઇલ લોડ કરે છે tracex4_kern.o ફંક્શનનો ઉપયોગ કરીને load_bpf_file.

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

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

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

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

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

    return 0;
}

કરતી વખતે load_bpf_file eBPF ફાઇલમાં વ્યાખ્યાયિત થયેલ ચકાસણીઓ ઉમેરવામાં આવે છે /sys/kernel/debug/tracing/kprobe_events. હવે અમે આ ઘટનાઓ સાંભળીએ છીએ અને જ્યારે તે થાય છે ત્યારે અમારો પ્રોગ્રામ કંઈક કરી શકે છે.

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

નમૂના/bpf/ માં અન્ય તમામ કાર્યક્રમો સમાન રીતે રચાયેલ છે. તેઓ હંમેશા બે ફાઇલો ધરાવે છે:

• XXX_kern.c: eBPF કાર્યક્રમ.
• XXX_user.c: મુખ્ય કાર્યક્રમ.

eBPF પ્રોગ્રામ વિભાગ સાથે સંકળાયેલા નકશા અને કાર્યોને વ્યાખ્યાયિત કરે છે. જ્યારે કર્નલ ચોક્કસ પ્રકારની ઘટના બહાર કાઢે છે (ઉદાહરણ તરીકે, tracepoint), બંધાયેલ કાર્યો ચલાવવામાં આવે છે. નકશા કર્નલ પ્રોગ્રામ અને યુઝર-સ્પેસ પ્રોગ્રામ વચ્ચે સંચાર પૂરો પાડે છે.

નિષ્કર્ષ

આ લેખમાં, BPF અને eBPF સામાન્ય શબ્દોમાં ચર્ચા કરવામાં આવી હતી. હું જાણું છું કે આજે eBPF વિશે ઘણી બધી માહિતી અને સંસાધનો છે, તેથી હું વધુ અભ્યાસ માટે થોડી વધુ સામગ્રીની ભલામણ કરીશ.

હું વાંચવાની ભલામણ કરું છું:

• BPF: સાર્વત્રિક ઇન-કર્નલ વર્ચ્યુઅલ મશીન જોનાથન કોર્બેટ. BPF નો પરિચય અને તે eBPF માં કેવી રીતે વિકસિત થયું છે.
• eBPF નો સંપૂર્ણ પરિચય બ્રેન્ડન ગ્રેગ. LWN.net તરફથી લેખ. બ્રેન્ડન વારંવાર eBPF વિશે ટ્વીટ કરે છે અને તેની વેબસાઇટ પર વિષય પરના સંસાધનોની સૂચિ જાળવી રાખે છે. બ્લોગ પોસ્ટ.
• BPF અને eBPF પર નોંધો જુલિયા ઇવાન્સ. સુચક્ર શર્માની પ્રસ્તુતિ “ધ BSD પેકેટ ફિલ્ટર: એ ન્યુ આર્કિટેક્ચર ફોર યુઝર-લેવલ પેકેટ કેપ્ચર” પરની ટિપ્પણીઓ. ટિપ્પણીઓ સારી છે અને ખરેખર સ્લાઇડ્સ સમજવામાં મદદ કરે છે.
• eBPF, ભાગ 1: ભૂતકાળ, વર્તમાન અને ભવિષ્ય ફેરિસ એલિસ. સાથે લોન્ગરીડ ચાલુપરંતુ વાંચવા યોગ્ય. શ્રેષ્ઠ eBPF લેખોમાંથી એક જે મેં આખ્યો છે.

સોર્સ: www.habr.com