BPF ਅਤੇ eBPF ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣ-ਪਛਾਣ

ਹੈਲੋ, ਹੈਬਰ! ਅਸੀਂ ਤੁਹਾਨੂੰ ਦੱਸਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਰਿਲੀਜ਼ ਲਈ ਇੱਕ ਕਿਤਾਬ ਤਿਆਰ ਕਰ ਰਹੇ ਹਾਂ।"BPF ਨਾਲ ਲੀਨਕਸ ਨਿਰੀਖਣਯੋਗਤਾ".

ਕਿਉਂਕਿ BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ ਵਿਕਾਸ ਕਰਨਾ ਜਾਰੀ ਹੈ ਅਤੇ ਅਭਿਆਸ ਵਿੱਚ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਅਸੀਂ ਤੁਹਾਡੇ ਲਈ ਇਸ ਦੀਆਂ ਮੁੱਖ ਸਮਰੱਥਾਵਾਂ ਅਤੇ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੇ ਇੱਕ ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਕੀਤਾ ਹੈ।

ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ, ਲੀਨਕਸ ਕਰਨਲ ਦੀਆਂ ਕਮੀਆਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਟੂਲ ਅਤੇ ਤਕਨੀਕਾਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪ੍ਰਸਿੱਧ ਹੋ ਗਈਆਂ ਹਨ ਜਿੱਥੇ ਉੱਚ-ਕਾਰਗੁਜ਼ਾਰੀ ਵਾਲੇ ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਕਿਸਮ ਦੀ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਤਕਨੀਕਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਰਨਲ ਬਾਈਪਾਸ (ਕਰਨਲ ਬਾਈਪਾਸ) ਅਤੇ ਕਰਨਲ ਨੈੱਟਵਰਕ ਲੇਅਰ ਨੂੰ ਬਾਈਪਾਸ ਕਰਕੇ, ਯੂਜ਼ਰ ਸਪੇਸ ਤੋਂ ਸਾਰੇ ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਕਰਨਲ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨ ਵਿੱਚ ਨੈੱਟਵਰਕ ਕਾਰਡ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨਾ ਵੀ ਸ਼ਾਮਲ ਹੈ ਉਪਭੋਗਤਾ ਸਪੇਸ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਜਦੋਂ ਨੈਟਵਰਕ ਕਾਰਡ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਡਰਾਈਵਰ 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹਾਂ ਉਪਭੋਗਤਾ ਸਪੇਸ.

ਇੱਕ ਉਪਭੋਗਤਾ-ਸਪੇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਨੈਟਵਰਕ ਕਾਰਡ ਦੇ ਪੂਰੇ ਨਿਯੰਤਰਣ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਕੇ, ਅਸੀਂ ਕਰਨਲ ਓਵਰਹੈੱਡ (ਸੰਦਰਭ ਸਵਿਚਿੰਗ, ਨੈਟਵਰਕ ਲੇਅਰ ਪ੍ਰੋਸੈਸਿੰਗ, ਇੰਟਰੱਪਟਸ, ਆਦਿ) ਨੂੰ ਘਟਾਉਂਦੇ ਹਾਂ, ਜੋ ਕਿ 10Gb/s ਜਾਂ ਵੱਧ ਦੀ ਸਪੀਡ 'ਤੇ ਚੱਲਣ ਵੇਲੇ ਕਾਫ਼ੀ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਕਰਨਲ ਬਾਈਪਾਸ ਅਤੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਸੁਮੇਲ (ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ) ਅਤੇ ਧਿਆਨ ਨਾਲ ਪ੍ਰਦਰਸ਼ਨ ਟਿਊਨਿੰਗ (NUMA ਲੇਖਾਕਾਰੀ, CPU ਆਈਸੋਲੇਸ਼ਨ, ਆਦਿ) ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੇ ਨੈਟਵਰਕ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਬੁਨਿਆਦੀ ਸਿਧਾਂਤਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਸ਼ਾਇਦ ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਇਸ ਨਵੀਂ ਪਹੁੰਚ ਦੀ ਇੱਕ ਮਿਸਾਲੀ ਉਦਾਹਰਣ ਹੈ ਡੀ.ਪੀ.ਡੀ.ਕੇ. Intel ਤੋਂ (ਡਾਟਾ ਪਲੇਨ ਡਿਵੈਲਪਮੈਂਟ ਕਿੱਟ), ਹਾਲਾਂਕਿ ਸਿਸਕੋ ਦੇ ਵੀਪੀਪੀ (ਵੈਕਟਰ ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ), ਨੈੱਟਮੈਪ ਅਤੇ, ਬੇਸ਼ੱਕ, ਸਮੇਤ ਹੋਰ ਮਸ਼ਹੂਰ ਟੂਲ ਅਤੇ ਤਕਨੀਕਾਂ ਹਨ। ਸਨੈਬ.

ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਨੈਟਵਰਕ ਇੰਟਰੈਕਸ਼ਨਾਂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੇ ਕਈ ਨੁਕਸਾਨ ਹਨ:

• OS ਕਰਨਲ ਹਾਰਡਵੇਅਰ ਸਰੋਤਾਂ ਲਈ ਇੱਕ ਐਬਸਟਰੈਕਸ਼ਨ ਲੇਅਰ ਹੈ। ਕਿਉਂਕਿ ਉਪਭੋਗਤਾ ਸਪੇਸ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਆਪਣੇ ਸਰੋਤਾਂ ਦਾ ਸਿੱਧਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਆਪਣੇ ਹਾਰਡਵੇਅਰ ਦਾ ਪ੍ਰਬੰਧਨ ਵੀ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਇਸਦਾ ਅਕਸਰ ਮਤਲਬ ਹੁੰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਆਪਣੇ ਡਰਾਈਵਰਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਨਾ ਹੈ।
• ਕਿਉਂਕਿ ਅਸੀਂ ਕਰਨਲ ਸਪੇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੱਡ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਕਰਨਲ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀ ਸਾਰੀ ਨੈੱਟਵਰਕਿੰਗ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਵੀ ਛੱਡ ਰਹੇ ਹਾਂ। ਯੂਜ਼ਰ ਸਪੇਸ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਉਹ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੁਬਾਰਾ ਲਾਗੂ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ ਜੋ ਪਹਿਲਾਂ ਹੀ ਕਰਨਲ ਜਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।
• ਪ੍ਰੋਗਰਾਮ ਸੈਂਡਬੌਕਸ ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ, ਜੋ ਉਹਨਾਂ ਦੇ ਆਪਸੀ ਤਾਲਮੇਲ ਨੂੰ ਗੰਭੀਰਤਾ ਨਾਲ ਸੀਮਤ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਦੂਜੇ ਹਿੱਸਿਆਂ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ।

ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ, ਜਦੋਂ ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਨੈੱਟਵਰਕਿੰਗ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਰਨਲ ਤੋਂ ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਮੂਵ ਕਰਕੇ ਕਾਰਗੁਜ਼ਾਰੀ ਲਾਭ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। XDP ਬਿਲਕੁਲ ਉਲਟ ਕਰਦਾ ਹੈ: ਇਹ ਨੈੱਟਵਰਕਿੰਗ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਉਪਭੋਗਤਾ ਸਪੇਸ (ਫਿਲਟਰ, ਰੈਜ਼ੋਲਵਰ, ਰੂਟਿੰਗ, ਆਦਿ) ਤੋਂ ਕਰਨਲ ਸਪੇਸ ਵਿੱਚ ਭੇਜਦਾ ਹੈ। XDP ਸਾਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਫੰਕਸ਼ਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਿਵੇਂ ਹੀ ਇੱਕ ਪੈਕੇਟ ਇੱਕ ਨੈੱਟਵਰਕ ਇੰਟਰਫੇਸ ਨੂੰ ਹਿੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਇਹ ਕਰਨਲ ਨੈੱਟਵਰਕ ਸਬ-ਸਿਸਟਮ ਵਿੱਚ ਜਾਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਪੈਕੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਗਤੀ ਕਾਫ਼ੀ ਵੱਧ ਜਾਂਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਕਰਨਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕਰਨਲ ਸਪੇਸ ਵਿੱਚ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਕਿਵੇਂ ਦਿੰਦਾ ਹੈ? ਇਸ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਦੇਖੀਏ ਕਿ ਬੀਪੀਐਫ ਕੀ ਹੈ।

BPF ਅਤੇ eBPF

ਭੰਬਲਭੂਸੇ ਵਾਲੇ ਨਾਮ ਦੇ ਬਾਵਜੂਦ, 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)) ਵਾਪਸ ਕਰਨ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪੈਕੇਟ ਨੂੰ ਸਵੀਕਾਰ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ।

ਬੀਪੀਐਫ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਅਤੇ ਇਸਦਾ ਬਾਈਟਕੋਡ 1992 ਦੇ ਅਖੀਰ ਵਿੱਚ ਸਟੀਵ ਮੈਕਕੈਨ ਅਤੇ ਵੈਨ ਜੈਕਬਸਨ ਦੁਆਰਾ ਪ੍ਰਸਤਾਵਿਤ ਕੀਤਾ ਗਿਆ ਸੀ ਜਦੋਂ ਉਹਨਾਂ ਦਾ ਪੇਪਰ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। BSD ਪੈਕੇਟ ਫਿਲਟਰ: ਉਪਭੋਗਤਾ-ਪੱਧਰ ਦੇ ਪੈਕੇਟ ਕੈਪਚਰ ਲਈ ਨਵਾਂ ਆਰਕੀਟੈਕਚਰ, ਇਸ ਤਕਨਾਲੋਜੀ ਨੂੰ ਪਹਿਲੀ ਵਾਰ 1993 ਦੇ ਸਰਦੀਆਂ ਵਿੱਚ Usenix ਕਾਨਫਰੰਸ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

ਕਿਉਂਕਿ BPF ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੈ, ਇਹ ਵਾਤਾਵਰਣ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਚੱਲਦੇ ਹਨ। ਬਾਈਟਕੋਡ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਬੈਚ ਮੈਮੋਰੀ ਮਾਡਲ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ (ਲੋਡ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਬੈਚ 'ਤੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ), ਰਜਿਸਟਰ (ਏ ਅਤੇ ਐਕਸ; ਐਕਯੂਮੂਲੇਟਰ ਅਤੇ ਇੰਡੈਕਸ ਰਜਿਸਟਰ), ਸਕ੍ਰੈਚ ਮੈਮੋਰੀ ਸਟੋਰੇਜ, ਅਤੇ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਪ੍ਰੋਗਰਾਮ ਕਾਊਂਟਰ। ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ, BPF ਬਾਈਟਕੋਡ ਨੂੰ Motorola 6502 ISA ਤੋਂ ਬਾਅਦ ਮਾਡਲ ਬਣਾਇਆ ਗਿਆ ਸੀ। ਜਿਵੇਂ ਕਿ ਸਟੀਵ ਮੈਕਕੈਨ ਨੇ ਆਪਣੇ ਵਿੱਚ ਯਾਦ ਕੀਤਾ ਪੂਰੀ ਰਿਪੋਰਟ ਸ਼ਾਰਕਫੈਸਟ '11 'ਤੇ, ਉਹ Apple II 'ਤੇ ਆਪਣੇ ਹਾਈ ਸਕੂਲ ਦੇ ਦਿਨਾਂ ਦੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਤੋਂ ਬਿਲਡ 6502 ਤੋਂ ਜਾਣੂ ਸੀ, ਅਤੇ ਇਸ ਗਿਆਨ ਨੇ BPF ਬਾਈਟਕੋਡ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੇ ਉਸਦੇ ਕੰਮ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤਾ।

BPF ਸਹਾਇਤਾ ਨੂੰ ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ v2.5 ਅਤੇ ਇਸ ਤੋਂ ਉੱਚੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਮੁੱਖ ਤੌਰ 'ਤੇ ਜੈ ਸ਼ੁਲਿਸਟ ਦੇ ਯਤਨਾਂ ਦੁਆਰਾ ਜੋੜਿਆ ਗਿਆ ਹੈ। ਬੀਪੀਐਫ ਕੋਡ 2011 ਤੱਕ ਬਦਲਿਆ ਨਹੀਂ ਰਿਹਾ, ਜਦੋਂ ਐਰਿਕ ਡੂਮਾਸੇਟ ਨੇ ਜੇਆਈਟੀ ਮੋਡ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਬੀਪੀਐਫ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਮੁੜ ਡਿਜ਼ਾਈਨ ਕੀਤਾ (ਸਰੋਤ: ਪੈਕੇਟ ਫਿਲਟਰਾਂ ਲਈ ਜੇ.ਆਈ.ਟੀ). ਇਸ ਤੋਂ ਬਾਅਦ, ਕਰਨਲ, BPF ਬਾਈਟਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਦੀ ਬਜਾਏ, BPF ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਟਾਰਗੇਟ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ: x86, ARM, MIPS, ਆਦਿ।

ਬਾਅਦ ਵਿੱਚ, 2014 ਵਿੱਚ, ਅਲੈਕਸੀ ਸਟਾਰੋਵੋਇਟੋਵ ਨੇ ਬੀਪੀਐਫ ਲਈ ਇੱਕ ਨਵੀਂ ਜੇਆਈਟੀ ਵਿਧੀ ਦਾ ਪ੍ਰਸਤਾਵ ਕੀਤਾ। ਵਾਸਤਵ ਵਿੱਚ, ਇਹ ਨਵੀਂ JIT ਇੱਕ ਨਵੀਂ BPF- ਅਧਾਰਤ ਆਰਕੀਟੈਕਚਰ ਬਣ ਗਈ ਅਤੇ ਇਸਨੂੰ eBPF ਕਿਹਾ ਗਿਆ। ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਦੋਵੇਂ VM ਕੁਝ ਸਮੇਂ ਲਈ ਇਕੱਠੇ ਸਨ, ਪਰ ਵਰਤਮਾਨ ਵਿੱਚ ਪੈਕੇਟ ਫਿਲਟਰਿੰਗ eBPF ਦੇ ਅਧਾਰ ਤੇ ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ। ਅਸਲ ਵਿੱਚ, ਆਧੁਨਿਕ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, ਬੀਪੀਐਫ ਨੂੰ ਈਬੀਪੀਐਫ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਕਲਾਸੀਕਲ ਬੀਪੀਐਫ ਨੂੰ ਅੱਜ ਸੀਬੀਪੀਐਫ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ।

eBPF ਕਲਾਸਿਕ BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਵਧਾਉਂਦਾ ਹੈ:

• ਆਧੁਨਿਕ 64-ਬਿੱਟ ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਆਧਾਰਿਤ। eBPF 64-ਬਿੱਟ ਰਜਿਸਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਲਬਧ ਰਜਿਸਟਰਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ 2 (ਐਕਯੂਮੂਲੇਟਰ ਅਤੇ X) ਤੋਂ ਵਧਾ ਕੇ 10 ਕਰ ਦਿੰਦਾ ਹੈ। eBPF ਵਾਧੂ ਓਪਕੋਡ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (BPF_MOV, BPF_JNE, BPF_CALL...)।
• ਨੈੱਟਵਰਕ ਲੇਅਰ ਸਬ-ਸਿਸਟਮ ਤੋਂ ਵੱਖ ਕੀਤਾ ਗਿਆ। BPF ਨੂੰ ਬੈਚ ਡੇਟਾ ਮਾਡਲ ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਕਿਉਂਕਿ ਇਸਦੀ ਵਰਤੋਂ ਪੈਕੇਟ ਫਿਲਟਰਿੰਗ ਲਈ ਕੀਤੀ ਗਈ ਸੀ, ਇਸਦਾ ਕੋਡ ਉਸ ਸਬਸਿਸਟਮ ਵਿੱਚ ਸਥਿਤ ਸੀ ਜੋ ਨੈੱਟਵਰਕ ਸੰਚਾਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, eBPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੁਣ ਡੇਟਾ ਮਾਡਲ ਨਾਲ ਜੁੜੀ ਨਹੀਂ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਉਦੇਸ਼ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਸ ਲਈ, ਹੁਣ eBPF ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਟਰੇਸਪੁਆਇੰਟ ਜਾਂ kprobe ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਹੋਰ ਕਰਨਲ ਸਬ-ਸਿਸਟਮ ਦੇ ਸੰਦਰਭ ਵਿੱਚ eBPF ਇੰਸਟਰੂਮੈਂਟੇਸ਼ਨ, ਕਾਰਗੁਜ਼ਾਰੀ ਵਿਸ਼ਲੇਸ਼ਣ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਰਾਹ ਖੋਲ੍ਹਦਾ ਹੈ। ਹੁਣ eBPF ਕੋਡ ਇਸਦੇ ਆਪਣੇ ਮਾਰਗ ਵਿੱਚ ਸਥਿਤ ਹੈ: kernel/bpf.
• ਗਲੋਬਲ ਡਾਟਾ ਸਟੋਰਾਂ ਨੂੰ ਨਕਸ਼ੇ ਕਹਿੰਦੇ ਹਨ। ਨਕਸ਼ੇ ਮੁੱਖ-ਮੁੱਲ ਵਾਲੇ ਸਟੋਰ ਹਨ ਜੋ ਉਪਭੋਗਤਾ ਸਪੇਸ ਅਤੇ ਕਰਨਲ ਸਪੇਸ ਵਿਚਕਾਰ ਡੇਟਾ ਐਕਸਚੇਂਜ ਨੂੰ ਸਮਰੱਥ ਕਰਦੇ ਹਨ। eBPF ਕਈ ਕਿਸਮ ਦੇ ਨਕਸ਼ੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
• ਸੈਕੰਡਰੀ ਫੰਕਸ਼ਨ. ਖਾਸ ਤੌਰ 'ਤੇ, ਇੱਕ ਪੈਕੇਜ ਨੂੰ ਮੁੜ ਲਿਖਣ ਲਈ, ਇੱਕ ਚੈੱਕਸਮ ਦੀ ਗਣਨਾ ਕਰੋ, ਜਾਂ ਇੱਕ ਪੈਕੇਜ ਨੂੰ ਕਲੋਨ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨ ਕਰਨਲ ਦੇ ਅੰਦਰ ਚੱਲਦੇ ਹਨ ਅਤੇ ਉਪਭੋਗਤਾ-ਸਪੇਸ ਪ੍ਰੋਗਰਾਮ ਨਹੀਂ ਹਨ। ਤੁਸੀਂ eBPF ਪ੍ਰੋਗਰਾਮਾਂ ਤੋਂ ਸਿਸਟਮ ਕਾਲਾਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।
• ਕਾਲਾਂ ਸਮਾਪਤ ਕਰੋ। eBPF ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਕਾਰ 4096 ਬਾਈਟਸ ਤੱਕ ਸੀਮਿਤ ਹੈ। ਟੇਲ ਕਾਲ ਵਿਸ਼ੇਸ਼ਤਾ ਇੱਕ eBPF ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਨਵੇਂ eBPF ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਨਿਯੰਤਰਣ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਇਸ ਸੀਮਾ ਨੂੰ ਬਾਈਪਾਸ ਕਰਦੀ ਹੈ (32 ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਲਿੰਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ)।

eBPF: ਉਦਾਹਰਨ

ਲੀਨਕਸ ਕਰਨਲ ਸਰੋਤਾਂ ਵਿੱਚ 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