ਛੋਟੇ ਬੱਚਿਆਂ ਲਈ BPF, ਭਾਗ ਪਹਿਲਾ: ਵਿਸਤ੍ਰਿਤ BPF

ਸ਼ੁਰੂ ਵਿੱਚ ਇੱਕ ਤਕਨੀਕ ਸੀ ਅਤੇ ਇਸਨੂੰ ਬੀ.ਪੀ.ਐਫ. ਅਸੀਂ ਉਸ ਵੱਲ ਦੇਖਿਆ ਪਿਛਲਾ, ਇਸ ਲੜੀ ਦੇ ਪੁਰਾਣੇ ਨੇਮ ਲੇਖ. 2013 ਵਿੱਚ, ਅਲੈਕਸੀ ਸਟਾਰੋਵੋਇਟੋਵ ਅਤੇ ਡੈਨੀਅਲ ਬੋਰਕਮੈਨ ਦੇ ਯਤਨਾਂ ਦੁਆਰਾ, ਇਸਦਾ ਇੱਕ ਸੁਧਾਰਿਆ ਸੰਸਕਰਣ, ਆਧੁਨਿਕ 64-ਬਿੱਟ ਮਸ਼ੀਨਾਂ ਲਈ ਅਨੁਕੂਲਿਤ, ਵਿਕਸਿਤ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਸ ਨਵੀਂ ਤਕਨੀਕ ਨੂੰ ਸੰਖੇਪ ਵਿੱਚ ਅੰਦਰੂਨੀ BPF ਕਿਹਾ ਜਾਂਦਾ ਸੀ, ਫਿਰ ਇਸਦਾ ਨਾਮ ਐਕਸਟੈਂਡਡ BPF ਰੱਖਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਹੁਣ, ਕਈ ਸਾਲਾਂ ਬਾਅਦ, ਹਰ ਕੋਈ ਇਸਨੂੰ ਬਸ BPF ਕਹਿੰਦਾ ਹੈ।

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

ਇਹ ਲੇਖ BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੀ ਬਣਤਰ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ, BPF ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਰਨਲ ਇੰਟਰਫੇਸ, ਵਿਕਾਸ ਸਾਧਨ, ਅਤੇ ਨਾਲ ਹੀ ਮੌਜੂਦਾ ਸਮਰੱਥਾਵਾਂ ਦਾ ਇੱਕ ਸੰਖੇਪ, ਬਹੁਤ ਸੰਖੇਪ ਸੰਖੇਪ ਜਾਣਕਾਰੀ, ਜਿਵੇਂ ਕਿ. BPF ਦੇ ਵਿਹਾਰਕ ਕਾਰਜਾਂ ਦੇ ਡੂੰਘੇ ਅਧਿਐਨ ਲਈ ਸਾਨੂੰ ਭਵਿੱਖ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਦੀ ਲੋੜ ਪਵੇਗੀ।

ਲੇਖ ਦਾ ਸੰਖੇਪ

ਬੀਪੀਐਫ ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਜਾਣ-ਪਛਾਣ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ BPF ਆਰਕੀਟੈਕਚਰ ਦਾ ਪੰਛੀਆਂ ਦਾ ਦ੍ਰਿਸ਼ ਲੈ ਕੇ ਮੁੱਖ ਭਾਗਾਂ ਦੀ ਰੂਪਰੇਖਾ ਦੇਵਾਂਗੇ।

BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ ਰਜਿਸਟਰ ਅਤੇ ਕਮਾਂਡ ਸਿਸਟਮ। ਪਹਿਲਾਂ ਹੀ ਸਮੁੱਚੇ ਰੂਪ ਵਿੱਚ ਆਰਕੀਟੈਕਚਰ ਦਾ ਇੱਕ ਵਿਚਾਰ ਹੋਣ ਕਰਕੇ, ਅਸੀਂ BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੀ ਬਣਤਰ ਦਾ ਵਰਣਨ ਕਰਾਂਗੇ।

ਬੀਪੀਐਫ ਵਸਤੂਆਂ ਦਾ ਜੀਵਨ ਚੱਕਰ, ਬੀਪੀਐਫਐਸ ਫਾਈਲ ਸਿਸਟਮ। ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ BPF ਵਸਤੂਆਂ - ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਨਕਸ਼ਿਆਂ ਦੇ ਜੀਵਨ ਚੱਕਰ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰਾਂਗੇ।

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

Пишем программы BPF с помощью libbpf. ਬੇਸ਼ੱਕ, ਤੁਸੀਂ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ। ਪਰ ਇਹ ਔਖਾ ਹੈ। ਵਧੇਰੇ ਯਥਾਰਥਵਾਦੀ ਦ੍ਰਿਸ਼ ਲਈ, ਪਰਮਾਣੂ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੇ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਿਕਸਤ ਕੀਤੀ libbpf. ਅਸੀਂ ਇੱਕ ਬੁਨਿਆਦੀ BPF ਐਪਲੀਕੇਸ਼ਨ ਪਿੰਜਰ ਬਣਾਵਾਂਗੇ ਜੋ ਅਸੀਂ ਅਗਲੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਵਰਤਾਂਗੇ।

ਕਰਨਲ ਸਹਾਇਕ। ਇੱਥੇ ਅਸੀਂ ਸਿਖਾਂਗੇ ਕਿ BPF ਪ੍ਰੋਗਰਾਮ ਕਰਨਲ ਹੈਲਪਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਐਕਸੈਸ ਕਰ ਸਕਦੇ ਹਨ - ਇੱਕ ਟੂਲ ਜੋ ਨਕਸ਼ਿਆਂ ਦੇ ਨਾਲ, ਕਲਾਸਿਕ ਦੇ ਮੁਕਾਬਲੇ ਨਵੇਂ BPF ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਫੈਲਾਉਂਦਾ ਹੈ।

BPF ਪ੍ਰੋਗਰਾਮਾਂ ਤੋਂ ਨਕਸ਼ਿਆਂ ਤੱਕ ਪਹੁੰਚ। ਇਸ ਬਿੰਦੂ ਤੱਕ, ਅਸੀਂ ਇਹ ਸਮਝਣ ਲਈ ਕਾਫ਼ੀ ਜਾਣਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਨਕਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹਾਂ। ਅਤੇ ਆਓ ਮਹਾਨ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਮਾਣੀਕਰਣ ਵਿੱਚ ਇੱਕ ਤੇਜ਼ ਝਾਤ ਮਾਰੀਏ।

ਵਿਕਾਸ ਸਾਧਨ। ਪ੍ਰਯੋਗਾਂ ਲਈ ਲੋੜੀਂਦੀਆਂ ਉਪਯੋਗਤਾਵਾਂ ਅਤੇ ਕਰਨਲ ਨੂੰ ਕਿਵੇਂ ਇਕੱਠਾ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਸਹਾਇਤਾ ਭਾਗ।

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

ਬੀਪੀਐਫ ਆਰਕੀਟੈਕਚਰ ਦੀ ਜਾਣ-ਪਛਾਣ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ BPF ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੀਏ, ਅਸੀਂ ਇੱਕ ਆਖਰੀ ਵਾਰ (ਓਹ) ਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗੇ ਕਲਾਸਿਕ BPF, ਜਿਸ ਨੂੰ RISC ਮਸ਼ੀਨਾਂ ਦੇ ਆਗਮਨ ਦੇ ਜਵਾਬ ਵਜੋਂ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਕੁਸ਼ਲ ਪੈਕੇਟ ਫਿਲਟਰਿੰਗ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕੀਤਾ ਗਿਆ ਸੀ। ਆਰਕੀਟੈਕਚਰ ਇੰਨਾ ਸਫਲ ਸਾਬਤ ਹੋਇਆ ਕਿ, ਬਰਕਲੇ UNIX ਵਿੱਚ ਨੱਬੇ ਦੇ ਦਹਾਕੇ ਵਿੱਚ ਪੈਦਾ ਹੋਏ, ਇਸ ਨੂੰ ਜ਼ਿਆਦਾਤਰ ਮੌਜੂਦਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਪੋਰਟ ਕੀਤਾ ਗਿਆ, ਪਾਗਲ ਵੀਹਵਿਆਂ ਵਿੱਚ ਬਚਿਆ ਅਤੇ ਅਜੇ ਵੀ ਨਵੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲੱਭ ਰਿਹਾ ਹੈ।

ਨਵਾਂ BPF 64-ਬਿੱਟ ਮਸ਼ੀਨਾਂ, ਕਲਾਉਡ ਸੇਵਾਵਾਂ ਅਤੇ SDN (SDN) ਬਣਾਉਣ ਲਈ ਸਾਧਨਾਂ ਦੀ ਵਧਦੀ ਲੋੜ ਦੀ ਸਰਵਵਿਆਪਕਤਾ ਦੇ ਜਵਾਬ ਵਜੋਂ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ।Sਸਾਮਾਨ-dਪ੍ਰਭਾਸ਼ਿਤ networking). ਕਲਾਸਿਕ BPF ਲਈ ਇੱਕ ਬਿਹਤਰ ਬਦਲ ਵਜੋਂ ਕਰਨਲ ਨੈਟਵਰਕ ਇੰਜੀਨੀਅਰਾਂ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ, ਨਵੇਂ BPF ਨੇ ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਛੇ ਮਹੀਨਿਆਂ ਬਾਅਦ ਲੀਨਕਸ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਟਰੇਸ ਕਰਨ ਦੇ ਮੁਸ਼ਕਲ ਕੰਮ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲੱਭੀਆਂ, ਅਤੇ ਹੁਣ, ਇਸਦੀ ਦਿੱਖ ਦੇ ਛੇ ਸਾਲਾਂ ਬਾਅਦ, ਸਾਨੂੰ ਇੱਕ ਪੂਰੇ ਅਗਲੇ ਲੇਖ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ. ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ।

ਮਜ਼ਾਕੀਆ ਤਸਵੀਰਾਂ

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

ਆਓ ਇਸ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ. ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਆਉ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਤੋਂ ਪਹਿਲੇ ਅੰਤਰ ਬਾਰੇ ਗੱਲ ਕਰੀਏ, ਪ੍ਰੋਗਰਾਮ ਜਿਨ੍ਹਾਂ ਲਈ ਅਸੈਂਬਲਰ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਸੀ. ਨਵੇਂ ਸੰਸਕਰਣ ਵਿੱਚ, ਆਰਕੀਟੈਕਚਰ ਦਾ ਵਿਸਤਾਰ ਕੀਤਾ ਗਿਆ ਸੀ ਤਾਂ ਜੋ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਉੱਚ-ਪੱਧਰੀ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕੇ, ਮੁੱਖ ਤੌਰ 'ਤੇ, ਬੇਸ਼ਕ, C ਵਿੱਚ, ਇਸਦੇ ਲਈ, llvm ਲਈ ਇੱਕ ਬੈਕਐਂਡ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਜੋ ਤੁਹਾਨੂੰ BPF ਆਰਕੀਟੈਕਚਰ ਲਈ ਬਾਈਟਕੋਡ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

BPF ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਆਧੁਨਿਕ ਮਸ਼ੀਨਾਂ 'ਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਚਲਾਉਣ ਲਈ, ਕੁਝ ਹੱਦ ਤੱਕ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਸ ਕੰਮ ਨੂੰ ਅਭਿਆਸ ਵਿੱਚ ਬਣਾਉਣ ਲਈ, BPF ਬਾਈਟਕੋਡ, ਇੱਕ ਵਾਰ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਹੋਣ ਤੋਂ ਬਾਅਦ, JIT ਕੰਪਾਈਲਰ (ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ) ਨਾਮਕ ਇੱਕ ਹਿੱਸੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੂਲ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।Just In Time). ਅੱਗੇ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਯਾਦ ਹੈ, ਕਲਾਸਿਕ BPF ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਈਵੈਂਟ ਸਰੋਤ ਨਾਲ ਪ੍ਰਮਾਣੂ ਰੂਪ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਸੀ - ਇੱਕ ਸਿੰਗਲ ਸਿਸਟਮ ਕਾਲ ਦੇ ਸੰਦਰਭ ਵਿੱਚ। ਨਵੇਂ ਢਾਂਚੇ ਵਿੱਚ, ਇਹ ਦੋ ਪੜਾਵਾਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ - ਪਹਿਲਾਂ, ਕੋਡ ਨੂੰ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। bpf(2)ਅਤੇ ਫਿਰ, ਬਾਅਦ ਵਿੱਚ, ਹੋਰ ਵਿਧੀਆਂ ਦੁਆਰਾ ਜੋ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਿਸਮ ਦੇ ਅਧਾਰ ਤੇ ਵੱਖ-ਵੱਖ ਹੁੰਦੇ ਹਨ, ਪ੍ਰੋਗਰਾਮ ਘਟਨਾ ਸਰੋਤ ਨਾਲ ਜੁੜਦਾ ਹੈ।

ਇੱਥੇ ਪਾਠਕ ਨੂੰ ਇੱਕ ਸਵਾਲ ਹੋ ਸਕਦਾ ਹੈ: ਕੀ ਇਹ ਸੰਭਵ ਸੀ? ਅਜਿਹੇ ਕੋਡ ਦੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸੁਰੱਖਿਆ ਦੀ ਗਾਰੰਟੀ ਕਿਵੇਂ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ? ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸੁਰੱਖਿਆ ਦੀ ਗਾਰੰਟੀ ਸਾਡੇ ਲਈ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਦੇ ਪੜਾਅ ਦੁਆਰਾ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸਨੂੰ ਵੈਰੀਫਾਇਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ ਇਸ ਪੜਾਅ ਨੂੰ ਵੈਰੀਫਾਇਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੈਂ ਅੰਗਰੇਜ਼ੀ ਸ਼ਬਦ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਾਂਗਾ):

ਵੈਰੀਫਾਇਰ ਇੱਕ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਕ ਹੈ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਕਰਨਲ ਦੇ ਆਮ ਕੰਮ ਵਿੱਚ ਵਿਘਨ ਨਹੀਂ ਪਾਉਂਦਾ ਹੈ। ਵੈਸੇ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਿਸਟਮ ਦੇ ਸੰਚਾਲਨ ਵਿੱਚ ਦਖਲ ਨਹੀਂ ਦੇ ਸਕਦਾ - BPF ਪ੍ਰੋਗਰਾਮ, ਕਿਸਮ ਦੇ ਅਧਾਰ ਤੇ, ਕਰਨਲ ਮੈਮੋਰੀ ਦੇ ਭਾਗਾਂ ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦੇ ਹਨ, ਫੰਕਸ਼ਨਾਂ ਦੇ ਮੁੱਲ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹਨ, ਟ੍ਰਿਮ, ਜੋੜ, ਮੁੜ ਲਿਖ ਸਕਦੇ ਹਨ ਅਤੇ ਨੈੱਟਵਰਕ ਪੈਕੇਟ ਵੀ ਅੱਗੇ ਭੇਜੋ। ਵੈਰੀਫਾਇਰ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਇੱਕ BPF ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਣ ਨਾਲ ਕਰਨਲ ਕ੍ਰੈਸ਼ ਨਹੀਂ ਹੋਵੇਗਾ ਅਤੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜਿਸ ਵਿੱਚ, ਨਿਯਮਾਂ ਦੇ ਅਨੁਸਾਰ, ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਆਊਟਗੋਇੰਗ ਪੈਕੇਟ ਦਾ ਡੇਟਾ, ਪੈਕੇਟ ਦੇ ਬਾਹਰ ਕਰਨਲ ਮੈਮੋਰੀ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗਾ। ਅਸੀਂ BPF ਦੇ ਬਾਕੀ ਸਾਰੇ ਹਿੱਸਿਆਂ ਤੋਂ ਜਾਣੂ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸੰਬੰਧਿਤ ਭਾਗ ਵਿੱਚ ਥੋੜੇ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਪ੍ਰਮਾਣਕ ਨੂੰ ਦੇਖਾਂਗੇ।

ਤਾਂ ਅਸੀਂ ਹੁਣ ਤੱਕ ਕੀ ਸਿੱਖਿਆ ਹੈ? ਉਪਭੋਗਤਾ C ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖਦਾ ਹੈ, ਇਸਨੂੰ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਕਰਦਾ ਹੈ bpf(2), ਜਿੱਥੇ ਇਸਨੂੰ ਇੱਕ ਤਸਦੀਕਕਰਤਾ ਦੁਆਰਾ ਜਾਂਚਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੂਲ ਬਾਈਟਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਉਹੀ ਜਾਂ ਕੋਈ ਹੋਰ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਵੈਂਟ ਸਰੋਤ ਨਾਲ ਜੋੜਦਾ ਹੈ ਅਤੇ ਇਹ ਚਲਾਉਣਾ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ. ਬੂਟ ਅਤੇ ਕੁਨੈਕਸ਼ਨ ਨੂੰ ਵੱਖ ਕਰਨਾ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ ਜ਼ਰੂਰੀ ਹੈ। ਪਹਿਲਾਂ, ਇੱਕ ਵੈਰੀਫਾਇਰ ਚਲਾਉਣਾ ਮੁਕਾਬਲਤਨ ਮਹਿੰਗਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਉਸੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਈ ਵਾਰ ਡਾਊਨਲੋਡ ਕਰਕੇ ਅਸੀਂ ਕੰਪਿਊਟਰ ਦਾ ਸਮਾਂ ਬਰਬਾਦ ਕਰਦੇ ਹਾਂ। ਦੂਜਾ, ਬਿਲਕੁਲ ਕਿਵੇਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜੁੜਿਆ ਹੈ ਇਸਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਸਾਲ ਪਹਿਲਾਂ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਇੱਕ "ਯੂਨੀਵਰਸਲ" ਇੰਟਰਫੇਸ ਨਵੀਂ ਕਿਸਮ ਦੇ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। (ਹਾਲਾਂਕਿ ਹੁਣ ਆਰਕੀਟੈਕਚਰ ਹੋਰ ਪਰਿਪੱਕ ਹੋ ਰਿਹਾ ਹੈ, ਇਸ ਇੰਟਰਫੇਸ ਨੂੰ ਪੱਧਰ 'ਤੇ ਇਕਜੁੱਟ ਕਰਨ ਦਾ ਵਿਚਾਰ ਹੈ। libbpf.)

ਧਿਆਨ ਦੇਣ ਵਾਲੇ ਪਾਠਕ ਸ਼ਾਇਦ ਧਿਆਨ ਦੇਣ ਕਿ ਅਸੀਂ ਅਜੇ ਤਸਵੀਰਾਂ ਨਾਲ ਖਤਮ ਨਹੀਂ ਹੋਏ ਹਾਂ. ਦਰਅਸਲ, ਉਪਰੋਕਤ ਸਾਰੇ ਇਹ ਨਹੀਂ ਦੱਸਦੇ ਹਨ ਕਿ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਮੁਕਾਬਲੇ BPF ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਤਸਵੀਰ ਨੂੰ ਕਿਉਂ ਬਦਲਦਾ ਹੈ। ਦੋ ਨਵੀਨਤਾਵਾਂ ਜੋ ਲਾਗੂ ਹੋਣ ਦੇ ਦਾਇਰੇ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਾਉਂਦੀਆਂ ਹਨ ਸ਼ੇਅਰਡ ਮੈਮੋਰੀ ਅਤੇ ਕਰਨਲ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਯੋਗਤਾ ਹਨ। ਬੀਪੀਐਫ ਵਿੱਚ, ਸ਼ੇਅਰਡ ਮੈਮੋਰੀ ਨੂੰ ਅਖੌਤੀ ਨਕਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ - ਇੱਕ ਖਾਸ API ਦੇ ਨਾਲ ਸਾਂਝੇ ਕੀਤੇ ਡੇਟਾ ਢਾਂਚੇ। ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਇਦ ਇਹ ਨਾਮ ਇਸ ਲਈ ਮਿਲਿਆ ਕਿਉਂਕਿ ਦਿਖਾਈ ਦੇਣ ਵਾਲੀ ਪਹਿਲੀ ਕਿਸਮ ਦਾ ਨਕਸ਼ਾ ਹੈਸ਼ ਟੇਬਲ ਸੀ। ਫਿਰ ਐਰੇ ਦਿਖਾਈ ਦਿੱਤੇ, ਲੋਕਲ (ਪ੍ਰਤੀ-ਸੀਪੀਯੂ) ਹੈਸ਼ ਟੇਬਲ ਅਤੇ ਲੋਕਲ ਐਰੇ, ਸਰਚ ਟ੍ਰੀ, ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਪੁਆਇੰਟਰ ਵਾਲੇ ਨਕਸ਼ੇ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ। ਹੁਣ ਸਾਡੇ ਲਈ ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਹੁਣ ਕਾਲਾਂ ਦੇ ਵਿਚਕਾਰ ਸਥਿਤੀ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਅਤੇ ਇਸਨੂੰ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਸਪੇਸ ਨਾਲ ਸਾਂਝਾ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੈ।

ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਪਭੋਗਤਾ ਪ੍ਰਕਿਰਿਆਵਾਂ ਤੋਂ ਨਕਸ਼ੇ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ bpf(2), ਅਤੇ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰਨਲ ਵਿੱਚ ਚੱਲ ਰਹੇ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਤੋਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਹਾਇਕ ਸਿਰਫ਼ ਨਕਸ਼ਿਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਹੋਰ ਕਰਨਲ ਸਮਰੱਥਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਵੀ ਮੌਜੂਦ ਹਨ। ਉਦਾਹਰਨ ਲਈ, BPF ਪ੍ਰੋਗਰਾਮ ਪੈਕੇਟਾਂ ਨੂੰ ਦੂਜੇ ਇੰਟਰਫੇਸਾਂ 'ਤੇ ਅੱਗੇ ਭੇਜਣ, ਪਰਫ ਇਵੈਂਟਸ ਬਣਾਉਣ, ਕਰਨਲ ਢਾਂਚੇ ਨੂੰ ਐਕਸੈਸ ਕਰਨ, ਆਦਿ ਲਈ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

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

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

ਅਜਿਹੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦੀ ਮੌਜੂਦਗੀ ਬੀਪੀਐਫ ਨੂੰ ਕਰਨਲ ਦੇ ਵਿਸਤਾਰ ਲਈ ਇੱਕ ਸਰਵਵਿਆਪੀ ਸਾਧਨ ਬਣਾਉਂਦੀ ਹੈ, ਜਿਸਦੀ ਅਭਿਆਸ ਵਿੱਚ ਪੁਸ਼ਟੀ ਹੁੰਦੀ ਹੈ: ਬੀਪੀਐਫ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਨਵੇਂ ਕਿਸਮ ਦੇ ਪ੍ਰੋਗਰਾਮ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਵੱਧ ਤੋਂ ਵੱਧ ਵੱਡੀਆਂ ਕੰਪਨੀਆਂ ਲੜਾਈ ਸਰਵਰਾਂ 24 × 7 ਤੇ ਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਵੱਧ ਤੋਂ ਵੱਧ ਸਟਾਰਟਅੱਪ ਆਪਣੇ ਕਾਰੋਬਾਰ ਨੂੰ ਉਹਨਾਂ ਹੱਲਾਂ 'ਤੇ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਬੀਪੀਐਫ 'ਤੇ ਆਧਾਰਿਤ ਹੁੰਦੇ ਹਨ। BPF ਦੀ ਵਰਤੋਂ ਹਰ ਥਾਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: DDoS ਹਮਲਿਆਂ ਤੋਂ ਸੁਰੱਖਿਆ ਲਈ, SDN ਬਣਾਉਣਾ (ਉਦਾਹਰਨ ਲਈ, ਕੁਬਰਨੇਟਸ ਲਈ ਨੈਟਵਰਕ ਲਾਗੂ ਕਰਨਾ), ਮੁੱਖ ਸਿਸਟਮ ਟਰੇਸਿੰਗ ਟੂਲ ਅਤੇ ਅੰਕੜਾ ਕੁਲੈਕਟਰ ਦੇ ਤੌਰ 'ਤੇ, ਘੁਸਪੈਠ ਖੋਜ ਪ੍ਰਣਾਲੀਆਂ ਅਤੇ ਸੈਂਡਬੌਕਸ ਪ੍ਰਣਾਲੀਆਂ ਆਦਿ ਵਿੱਚ।

ਆਉ ਲੇਖ ਦੇ ਸੰਖੇਪ ਭਾਗ ਨੂੰ ਇੱਥੇ ਖਤਮ ਕਰੀਏ ਅਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਅਤੇ BPF ਈਕੋਸਿਸਟਮ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ।

ਡਿਗ੍ਰੇਸ਼ਨ: ਉਪਯੋਗਤਾਵਾਂ

ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਵਿੱਚ ਉਦਾਹਰਨਾਂ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਤੁਹਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਕਈ ਉਪਯੋਗਤਾਵਾਂ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ llvm/clang bpf ਸਹਿਯੋਗ ਨਾਲ ਅਤੇ bpftool. ਭਾਗ ਵਿੱਚ ਵਿਕਾਸ ਸਾਧਨ ਤੁਸੀਂ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਤੁਹਾਡੇ ਕਰਨਲ ਨੂੰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ। ਇਹ ਭਾਗ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ ਤਾਂ ਜੋ ਸਾਡੀ ਪੇਸ਼ਕਾਰੀ ਦੀ ਇਕਸੁਰਤਾ ਨੂੰ ਵਿਗਾੜ ਨਾ ਸਕੇ।

ਬੀਪੀਐਫ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਰਜਿਸਟਰ ਅਤੇ ਹਦਾਇਤ ਪ੍ਰਣਾਲੀ

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

BPF ਕੋਲ ਗਿਆਰਾਂ ਉਪਭੋਗਤਾ-ਪਹੁੰਚਯੋਗ 64-ਬਿੱਟ ਰਜਿਸਟਰ ਹਨ r0-r10 ਅਤੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਕਾਊਂਟਰ। ਰਜਿਸਟਰ r10 ਇੱਕ ਫਰੇਮ ਪੁਆਇੰਟਰ ਰੱਖਦਾ ਹੈ ਅਤੇ ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਹੈ। ਪ੍ਰੋਗਰਾਮਾਂ ਕੋਲ ਰਨਟਾਈਮ 'ਤੇ 512-ਬਾਈਟ ਸਟੈਕ ਅਤੇ ਨਕਸ਼ਿਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸ਼ੇਅਰਡ ਮੈਮੋਰੀ ਦੀ ਅਸੀਮਿਤ ਮਾਤਰਾ ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ।

BPF ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮ-ਕਿਸਮ ਦੇ ਕਰਨਲ ਸਹਾਇਕਾਂ ਦੇ ਇੱਕ ਖਾਸ ਸੈੱਟ ਅਤੇ, ਹਾਲ ਹੀ ਵਿੱਚ, ਨਿਯਮਤ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਹਰੇਕ ਕਹਿੰਦੇ ਹੋਏ ਫੰਕਸ਼ਨ ਪੰਜ ਆਰਗੂਮੈਂਟ ਲੈ ਸਕਦਾ ਹੈ, ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਗਿਆ ਹੈ r1-r5, ਅਤੇ ਵਾਪਸੀ ਮੁੱਲ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ r0. ਇਹ ਗਾਰੰਟੀ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਤੋਂ ਵਾਪਸ ਆਉਣ ਤੋਂ ਬਾਅਦ, ਰਜਿਸਟਰਾਂ ਦੀ ਸਮੱਗਰੀ r6-r9 ਨਹੀਂ ਬਦਲੇਗਾ।

ਕੁਸ਼ਲ ਪ੍ਰੋਗਰਾਮ ਅਨੁਵਾਦ ਲਈ, ਰਜਿਸਟਰ r0-r11 ਮੌਜੂਦਾ ਆਰਕੀਟੈਕਚਰ ਦੀਆਂ ABI ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਸਾਰੇ ਸਮਰਥਿਤ ਢਾਂਚਿਆਂ ਨੂੰ ਅਸਲ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਵਿਲੱਖਣ ਰੂਪ ਵਿੱਚ ਮੈਪ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਲਈ 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 ਲਈ ਕਿਸੇ ਵੀ ਬਾਈਨਰੀ ਫਾਈਲ ਨੂੰ ਹੱਥੀਂ ਵੱਖ ਕਰੋ। ਲੇਖ ਵਿਚ ਬਾਅਦ ਵਿਚ ਸਮੱਗਰੀ ਨੂੰ ਇਕਸਾਰ ਕਰਨ ਲਈ, ਅਸੀਂ ਵੈਰੀਫਾਇਰ, ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ, ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਅਨੁਵਾਦ ਦੇ ਨਾਲ-ਨਾਲ ਨਕਸ਼ਿਆਂ ਦਾ ਅਧਿਐਨ ਕਰਦੇ ਸਮੇਂ, ਕਾਲਿੰਗ ਫੰਕਸ਼ਨਾਂ ਆਦਿ ਬਾਰੇ ਭਾਗਾਂ ਵਿਚ ਵਿਅਕਤੀਗਤ ਹਦਾਇਤਾਂ ਨਾਲ ਵੀ ਮੁਲਾਕਾਤ ਕਰਾਂਗੇ।

ਜਦੋਂ ਅਸੀਂ ਵਿਅਕਤੀਗਤ ਨਿਰਦੇਸ਼ਾਂ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਕੋਰ ਫਾਈਲਾਂ ਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗੇ bpf.h и bpf_common.h, ਜੋ BPF ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਸੰਖਿਆਤਮਕ ਕੋਡਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਆਰਕੀਟੈਕਚਰ ਦਾ ਅਧਿਐਨ ਕਰਦੇ ਹੋ ਅਤੇ/ਜਾਂ ਬਾਈਨਰੀਆਂ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹੇਠਲੇ ਸਰੋਤਾਂ ਵਿੱਚ ਅਰਥ ਵਿਗਿਆਨ ਲੱਭ ਸਕਦੇ ਹੋ, ਜਟਿਲਤਾ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ: ਅਣਅਧਿਕਾਰਤ eBPF ਸਪੇਕ, BPF ਅਤੇ XDP ਸੰਦਰਭ ਗਾਈਡ, ਹਦਾਇਤ ਸੈੱਟ, Documentation/networking/filter.txt ਅਤੇ, ਬੇਸ਼ੱਕ, ਲੀਨਕਸ ਸਰੋਤ ਕੋਡ ਵਿੱਚ - ਵੈਰੀਫਾਇਰ, ਜੇਆਈਟੀ, ਬੀਪੀਐਫ ਦੁਭਾਸ਼ੀਏ।

ਉਦਾਹਰਨ: ਤੁਹਾਡੇ ਸਿਰ ਵਿੱਚ 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, ਆਮ ਵਾਂਗ, ਅਗਲੀ ਹਦਾਇਤ ਦਾ ਪਤਾ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਜੇਐਮਪੀ ਕਲਾਸ 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 ਨੂੰ ਵੱਖ ਕਰਨਾ

ਇਸ ਲਈ, ਅਸੀਂ 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 ਬਲੌਗ.)

BPF ਵਸਤੂਆਂ - ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਨਕਸ਼ੇ - ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਪਭੋਗਤਾ ਸਪੇਸ ਤੋਂ ਬਣਾਏ ਗਏ ਹਨ BPF_PROG_LOAD и BPF_MAP_CREATE ਸਿਸਟਮ ਕਾਲ bpf(2), ਅਸੀਂ ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ ਕਿ ਇਹ ਕਿਵੇਂ ਵਾਪਰਦਾ ਹੈ। ਇਹ ਕਰਨਲ ਡਾਟਾ ਬਣਤਰ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਲਈ refcount (ਹਵਾਲਾ ਗਿਣਤੀ) ਨੂੰ ਇੱਕ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਆਬਜੈਕਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਉਪਭੋਗਤਾ ਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਹੈਂਡਲ ਬੰਦ ਹੋਣ ਤੋਂ ਬਾਅਦ refcount ਵਸਤੂ ਨੂੰ ਇੱਕ ਦੁਆਰਾ ਘਟਾਇਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਇਹ ਜ਼ੀਰੋ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ, ਤਾਂ ਵਸਤੂ ਨਸ਼ਟ ਹੋ ਜਾਂਦੀ ਹੈ।

ਜੇ ਪ੍ਰੋਗਰਾਮ ਨਕਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ refcount ਇਹ ਨਕਸ਼ੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ ਇੱਕ ਦੁਆਰਾ ਵਧਾਏ ਜਾਂਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ. ਉਹਨਾਂ ਦੇ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰਾਂ ਨੂੰ ਉਪਭੋਗਤਾ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਬੰਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਅਜੇ ਵੀ refcount ਜ਼ੀਰੋ ਨਹੀਂ ਬਣੇਗਾ:

ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇਸਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਕਿਸੇ ਕਿਸਮ ਦੇ ਇਵੈਂਟ ਜਨਰੇਟਰ ਨਾਲ ਜੋੜਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਪੈਕੇਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਇਸਨੂੰ ਇੱਕ ਨੈਟਵਰਕ ਇੰਟਰਫੇਸ ਤੇ ਰੱਖ ਸਕਦੇ ਹਾਂ ਜਾਂ ਇਸਨੂੰ ਕੁਝ ਨਾਲ ਜੋੜ ਸਕਦੇ ਹਾਂ tracepoint ਕੋਰ ਵਿੱਚ. ਇਸ ਬਿੰਦੂ 'ਤੇ, ਹਵਾਲਾ ਕਾਊਂਟਰ ਵੀ ਇੱਕ ਤੋਂ ਵੱਧ ਜਾਵੇਗਾ ਅਤੇ ਅਸੀਂ ਲੋਡਰ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਨੂੰ ਬੰਦ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ।

ਜੇਕਰ ਅਸੀਂ ਹੁਣ ਬੂਟਲੋਡਰ ਨੂੰ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹਾਂ ਤਾਂ ਕੀ ਹੋਵੇਗਾ? ਇਹ ਇਵੈਂਟ ਜਨਰੇਟਰ (ਹੁੱਕ) ਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਲੋਡਰ ਦੇ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ ਸਾਰੇ ਨੈੱਟਵਰਕ ਹੁੱਕ ਮੌਜੂਦ ਹੋਣਗੇ, ਇਹ ਅਖੌਤੀ ਗਲੋਬਲ ਹੁੱਕ ਹਨ। ਅਤੇ, ਉਦਾਹਰਨ ਲਈ, ਟਰੇਸ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਉਸ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਬਾਅਦ ਜਾਰੀ ਕੀਤਾ ਜਾਵੇਗਾ ਜਿਸ ਨੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾਇਆ ਹੈ (ਅਤੇ ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਲੋਕਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, "ਸਥਾਨਕ ਤੋਂ ਪ੍ਰਕਿਰਿਆ ਤੱਕ")। ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, ਸਥਾਨਕ ਹੁੱਕਾਂ ਕੋਲ ਹਮੇਸ਼ਾ ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਇੱਕ ਅਨੁਸਾਰੀ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਲਈ ਪ੍ਰਕਿਰਿਆ ਬੰਦ ਹੋਣ 'ਤੇ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ, ਪਰ ਗਲੋਬਲ ਹੁੱਕ ਨਹੀਂ ਹੁੰਦੇ। ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ, ਲਾਲ ਕਰਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਇਹ ਦਿਖਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ ਕਿ ਕਿਵੇਂ ਲੋਡਰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਸਮਾਪਤੀ ਸਥਾਨਕ ਅਤੇ ਗਲੋਬਲ ਹੁੱਕਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਵਸਤੂਆਂ ਦੇ ਜੀਵਨ ਕਾਲ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦੀ ਹੈ।

ਸਥਾਨਕ ਅਤੇ ਗਲੋਬਲ ਹੁੱਕ ਵਿਚਕਾਰ ਅੰਤਰ ਕਿਉਂ ਹੈ? ਕੁਝ ਕਿਸਮਾਂ ਦੇ ਨੈਟਵਰਕ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਣਾ ਉਪਭੋਗਤਾ-ਸਪੇਸ ਤੋਂ ਬਿਨਾਂ ਅਰਥ ਰੱਖਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, DDoS ਸੁਰੱਖਿਆ ਦੀ ਕਲਪਨਾ ਕਰੋ - ਬੂਟਲੋਡਰ ਨਿਯਮ ਲਿਖਦਾ ਹੈ ਅਤੇ BPF ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਨੈੱਟਵਰਕ ਇੰਟਰਫੇਸ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਬੂਟਲੋਡਰ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਮਾਰ ਸਕਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ਇੱਕ ਡੀਬੱਗਿੰਗ ਟਰੇਸ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜੋ ਤੁਸੀਂ ਦਸ ਮਿੰਟਾਂ ਵਿੱਚ ਆਪਣੇ ਗੋਡਿਆਂ 'ਤੇ ਲਿਖਿਆ ਸੀ - ਜਦੋਂ ਇਹ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਸਿਸਟਮ ਵਿੱਚ ਕੋਈ ਕੂੜਾ ਨਾ ਬਚੇ, ਅਤੇ ਸਥਾਨਕ ਹੁੱਕ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਗੇ।

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

bpffs ਵਿੱਚ ਫਾਈਲਾਂ ਬਣਾਉਣਾ ਜੋ BPF ਵਸਤੂਆਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ ਨੂੰ "ਪਿਨਿੰਗ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਵਾਕਾਂਸ਼ ਵਿੱਚ: "ਪ੍ਰਕਿਰਿਆ ਇੱਕ 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 ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਕਰਦਾ ਹੈ। ਲੋਡ ਹੋਣ ਦੇ ਸਮੇਂ, ਵੈਰੀਫਾਇਰ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ ਅਤੇ, ਸਫਲਤਾਪੂਰਵਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਪ੍ਰੋਗਰਾਮ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਉਪਭੋਗਤਾ ਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਦੇਖਿਆ ਹੈ ਕਿ ਉਸ ਨਾਲ ਅੱਗੇ ਕੀ ਹੁੰਦਾ ਹੈ ਬੀਪੀਐਫ ਵਸਤੂਆਂ ਦੇ ਜੀਵਨ ਚੱਕਰ ਬਾਰੇ.

ਅਸੀਂ ਹੁਣ ਇੱਕ ਕਸਟਮ ਪ੍ਰੋਗਰਾਮ ਲਿਖਾਂਗੇ ਜੋ ਇੱਕ ਸਧਾਰਨ 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 ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਮੂਲ ਕੋਡ ਵਿੱਚ ਲਿਖਣਾ ਸਿਰਫ਼ ਕਰਨਲ ਵਿੱਚ ਟੈਸਟਾਂ ਅਤੇ BPF ਬਾਰੇ ਲੇਖਾਂ ਨੂੰ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਇਹਨਾਂ ਮੈਕਰੋ ਦੀ ਅਣਹੋਂਦ ਅਸਲ ਵਿੱਚ ਡਿਵੈਲਪਰ ਦੇ ਜੀਵਨ ਨੂੰ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਕਰਦੀ ਹੈ।

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), ਪਰ ਨਿਰਪੱਖਤਾ ਵਿੱਚ, ਸਾਡਾ ਪ੍ਰੋਗਰਾਮ ਬਹੁਤ ਸਧਾਰਨ ਹੈ, ਅਤੇ ਗੈਰ-ਮਾਮੂਲੀ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ ਦੁਆਰਾ ਜੋੜਿਆ ਗਿਆ ਪ੍ਰੋਲੋਗ ਅਤੇ ਐਪੀਲੋਗ, ਬੇਸ਼ਕ, ਲੋੜੀਂਦਾ ਹੈ।

ਨਕਸ਼ੇ

BPF ਪ੍ਰੋਗਰਾਮ ਢਾਂਚਾਗਤ ਮੈਮੋਰੀ ਖੇਤਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ ਜੋ ਦੂਜੇ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਸਪੇਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਪਹੁੰਚਯੋਗ ਹਨ। ਇਹਨਾਂ ਵਸਤੂਆਂ ਨੂੰ ਨਕਸ਼ੇ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਦਿਖਾਵਾਂਗੇ ਕਿ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ bpf.

ਚਲੋ ਹੁਣੇ ਦੱਸ ਦੇਈਏ ਕਿ ਨਕਸ਼ਿਆਂ ਦੀ ਸਮਰੱਥਾ ਸਿਰਫ ਸ਼ੇਅਰਡ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ ਹੈ. ਇੱਥੇ ਵਿਸ਼ੇਸ਼-ਉਦੇਸ਼ ਵਾਲੇ ਨਕਸ਼ੇ ਹੁੰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ, BPF ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਪੁਆਇੰਟਰ ਜਾਂ ਨੈੱਟਵਰਕ ਇੰਟਰਫੇਸ ਲਈ ਪੁਆਇੰਟਰ, ਪਰਫ ਇਵੈਂਟਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਨਕਸ਼ੇ ਆਦਿ। ਅਸੀਂ ਇੱਥੇ ਉਹਨਾਂ ਬਾਰੇ ਗੱਲ ਨਹੀਂ ਕਰਾਂਗੇ, ਤਾਂ ਜੋ ਪਾਠਕ ਨੂੰ ਉਲਝਣ ਵਿੱਚ ਨਾ ਪਵੇ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਮੁੱਦਿਆਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦੇ ਹਾਂ, ਕਿਉਂਕਿ ਇਹ ਸਾਡੀਆਂ ਉਦਾਹਰਣਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ। ਉਪਲਬਧ ਨਕਸ਼ੇ ਦੀਆਂ ਕਿਸਮਾਂ ਦੀ ਇੱਕ ਪੂਰੀ ਸੂਚੀ ਵਿੱਚ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ <linux/bpf.h>, ਅਤੇ ਇਸ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਇਤਿਹਾਸਕ ਤੌਰ 'ਤੇ ਪਹਿਲੀ ਕਿਸਮ, ਹੈਸ਼ ਟੇਬਲ ਨੂੰ ਇੱਕ ਉਦਾਹਰਨ ਵਜੋਂ ਲਵਾਂਗੇ BPF_MAP_TYPE_HASH.

ਜੇ ਤੁਸੀਂ ਇੱਕ ਹੈਸ਼ ਟੇਬਲ ਬਣਾਉਂਦੇ ਹੋ, ਕਹੋ, C++, ਤੁਸੀਂ ਕਹੋਗੇ unordered_map<int,long> woo, ਜਿਸਦਾ ਰੂਸੀ ਵਿੱਚ ਅਰਥ ਹੈ “ਮੈਨੂੰ ਇੱਕ ਮੇਜ਼ ਦੀ ਲੋੜ ਹੈ woo ਅਸੀਮਤ ਆਕਾਰ, ਜਿਸ ਦੀਆਂ ਕੁੰਜੀਆਂ ਕਿਸਮ ਦੀਆਂ ਹਨ int, ਅਤੇ ਮੁੱਲ ਕਿਸਮ ਹਨ long" ਇੱਕ BPF ਹੈਸ਼ ਟੇਬਲ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਬਹੁਤ ਕੁਝ ਉਹੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਸਿਵਾਏ ਇਸ ਤੋਂ ਇਲਾਵਾ ਕਿ ਸਾਨੂੰ ਟੇਬਲ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਆਕਾਰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਪਏਗਾ, ਅਤੇ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਸਾਨੂੰ ਉਹਨਾਂ ਦੇ ਆਕਾਰ ਨੂੰ ਬਾਈਟ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। . ਨਕਸ਼ੇ ਬਣਾਉਣ ਲਈ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ BPF_MAP_CREATE ਸਿਸਟਮ ਕਾਲ 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 ਸਾਡੀ ਵਸਤੂ ਦੀ ਗਲੋਬਲ ਆਈਡੀ ਹੈ। ਸਿਸਟਮ ਤੇ ਕੋਈ ਵੀ ਪ੍ਰੋਗਰਾਮ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਜੂਦਾ ਨਕਸ਼ੇ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਇਸ ID ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ 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

ਪਹਿਲਾਂ ਅਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਕਸ਼ੇ ਨੂੰ ਇਸਦੇ ਗਲੋਬਲ ID ਦੁਆਰਾ ਖੋਲ੍ਹਿਆ 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 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 (ਇੱਕ ਵਾਰ ਕੰਪਾਈਲ ਕਰੋ, ਹਰ ਥਾਂ ਚਲਾਓ) - ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਜੋ ਤੁਹਾਨੂੰ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਲਿਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਇੱਕ ਕਰਨਲ ਤੋਂ ਦੂਜੇ ਕਰਨਲ ਵਿੱਚ ਪੋਰਟੇਬਲ ਹਨ, ਵੱਖ-ਵੱਖ API 'ਤੇ ਚੱਲਣ ਦੀ ਯੋਗਤਾ ਦੇ ਨਾਲ (ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਕਰਨਲ ਬਣਤਰ ਵਰਜਨ ਤੋਂ ਬਦਲਦਾ ਹੈ। ਸੰਸਕਰਣ ਤੱਕ). 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, ਆਓ ਕਈ (ਵੱਧ ਜਾਂ ਘੱਟ ਅਰਥਹੀਣ) ਟੈਸਟ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਲਿਖੀਏ ਅਤੇ ਵਿਸਥਾਰ ਵਿੱਚ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ ਕਿ ਇਹ ਸਭ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਵਿੱਚ ਹੋਰ ਆਸਾਨੀ ਨਾਲ ਸਮਝਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ ਕਿ ਕਿਵੇਂ BPF ਪ੍ਰੋਗਰਾਮ ਨਕਸ਼ਿਆਂ, ਕਰਨਲ ਸਹਾਇਕ, BTF, ਆਦਿ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੇ ਹਨ।

ਆਮ ਤੌਰ 'ਤੇ ਪ੍ਰੋਜੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ libbpf ਇੱਕ GitHub ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਇੱਕ git ਸਬਮੋਡਿਊਲ ਵਜੋਂ ਸ਼ਾਮਲ ਕਰੋ, ਅਸੀਂ ਉਹੀ ਕਰਾਂਗੇ:

$ 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, ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਾਂਗ ਹੀ, ਪਰ C ਵਿੱਚ, ਅਸੀਂ ਇਸਨੂੰ ਵਰਤ ਕੇ ਕੰਪਾਇਲ ਕਰਦੇ ਹਾਂ 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). ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮ ਆਪਣੇ ਆਪ ਹੈ 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 - BPF ਸੰਸਾਰ ਦਾ ਸਵਿਸ ਚਾਕੂ (ਜਿਸ ਨੂੰ ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਡੈਨੀਅਲ ਬੋਰਕਮੈਨ, BPF ਦੇ ਸਿਰਜਣਹਾਰਾਂ ਵਿੱਚੋਂ ਇੱਕ, ਸਵਿਸ ਹੈ):

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

ਫਾਈਲ ਵਿੱਚ xdp-simple.skel.h ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦਾ ਬਾਈਨਰੀ ਕੋਡ ਅਤੇ ਪ੍ਰਬੰਧਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ - ਸਾਡੇ ਆਬਜੈਕਟ ਨੂੰ ਲੋਡ ਕਰਨਾ, ਅਟੈਚ ਕਰਨਾ, ਮਿਟਾਉਣਾ। ਸਾਡੇ ਸਧਾਰਨ ਕੇਸ ਵਿੱਚ ਇਹ ਓਵਰਕਿੱਲ ਵਰਗਾ ਲੱਗਦਾ ਹੈ, ਪਰ ਇਹ ਉਸ ਕੇਸ ਵਿੱਚ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਆਬਜੈਕਟ ਫਾਈਲ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ BPF ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਨਕਸ਼ੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਅਤੇ ਇਸ ਵਿਸ਼ਾਲ 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

ਕੁਝ ਨਵਾਂ! ਪ੍ਰੋਗਰਾਮ ਨੇ ਸਾਡੀ C ਸਰੋਤ ਫਾਈਲ ਦੇ ਟੁਕੜੇ ਛਾਪੇ। ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਦੁਆਰਾ ਕੀਤਾ ਗਿਆ ਸੀ libbpf, ਜਿਸ ਨੇ ਬਾਈਨਰੀ ਵਿੱਚ ਡੀਬੱਗ ਸੈਕਸ਼ਨ ਲੱਭਿਆ, ਇਸਨੂੰ ਇੱਕ BTF ਆਬਜੈਕਟ ਵਿੱਚ ਕੰਪਾਇਲ ਕੀਤਾ, ਇਸਨੂੰ ਕਰਨਲ ਵਿੱਚ ਲੋਡ ਕੀਤਾ 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 ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾਵਾਂ ਲੀਨਕਸ ਸਿਸਟਮ ਕਾਲ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੇ ਸਮਾਨ ਹਨ। ਇੱਥੇ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਸਦਾ ਕੋਈ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਹੈ। (ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਲੈਂਦੀ ਹੈ, ਕਹੋ, ਤਿੰਨ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਮੈਕਰੋ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ 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, ਜੋ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ID ਤੋਂ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ 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. ਕੋਟਸ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਲਾਜ਼ੀਕਲ ਪਰਿਭਾਸ਼ਾ ਹੈ, ਅਤੇ C ਭਾਸ਼ਾ ਦੇ ਸ਼ਬਦਾਂ ਵਿੱਚ ਕੰਕਰੀਟ ਬਣਤਰਾਂ ਦੇ ਇੱਕ ਪੂਰੇ ਸਮੂਹ ਦੀ ਪਰਿਭਾਸ਼ਾ ਹੋਰ ਸਥਾਨਾਂ ਵਿੱਚ ਵਾਪਰਦੀ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਫਾਈਲ ਵਿੱਚ 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
};

ਭਾਵ, ਹਰੇਕ ਕਿਸਮ ਦੇ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮ ਲਈ, ਕਿਸਮ ਦੇ ਡੇਟਾ ਢਾਂਚੇ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ 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 - ਜ਼ੀਰੋ। ਵੈਰੀਫਾਇਰ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ABI ਸਮਝੌਤੇ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਨੰਬਰ ਅੱਠ ਲਈ ਇੱਕ ਕਾਲ ਹੈ। ਇੱਕ ਵਾਰ ਇਸਨੂੰ ਲਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤਰਕ ਸਧਾਰਨ ਹੈ। ਰਜਿਸਟਰ ਤੋਂ ਮੁੱਲ ਵਾਪਸ ਕਰੋ 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;
}

ਸਾਡਾ ਪ੍ਰੋਗਰਾਮ CPU ਦਾ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਚੱਲ ਰਿਹਾ ਹੈ। ਆਓ ਇਸਨੂੰ ਕੰਪਾਇਲ ਕਰੀਏ ਅਤੇ ਕੋਡ ਨੂੰ ਵੇਖੀਏ:

$ 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

ਸਾਡੇ ਦੁਆਰਾ ਡਾਊਨਲੋਡ ਕੀਤੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ID 669 ਹੈ ਅਤੇ ਅਸੀਂ ਇੰਟਰਫੇਸ 'ਤੇ ਉਹੀ ID ਦੇਖਦੇ ਹਾਂ 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 (C ਵਿੱਚ ਅਸੀਂ ਅਜਿਹੀ ਐਰੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇ ਜਿਵੇਂ ਕਿ u64 woo[8]). ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ "xdp/simple" ਅਸੀਂ ਮੌਜੂਦਾ ਪ੍ਰੋਸੈਸਰ ਨੰਬਰ ਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ key ਅਤੇ ਫਿਰ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ bpf_map_lookup_element ਸਾਨੂੰ ਐਰੇ ਵਿੱਚ ਸੰਬੰਧਿਤ ਐਂਟਰੀ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਮਿਲਦਾ ਹੈ, ਜਿਸਨੂੰ ਅਸੀਂ ਇੱਕ ਨਾਲ ਵਧਾਉਂਦੇ ਹਾਂ। ਰੂਸੀ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ: ਅਸੀਂ ਉਹਨਾਂ ਅੰਕੜਿਆਂ ਦੀ ਗਣਨਾ ਕਰਦੇ ਹਾਂ ਜਿਨ੍ਹਾਂ 'ਤੇ CPU ਨੇ ਆਉਣ ਵਾਲੇ ਪੈਕੇਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਹੈ। ਆਉ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

$ 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_*.

ਰਹੱਸਮਈ ਸੂਚਕਾਂਕ

ਇਸ ਲਈ, ਅਸੀਂ ਕਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮ ਤੋਂ ਨਕਸ਼ੇ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਾਂ

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, ਅਤੇ ID ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਖੋਲ੍ਹਿਆ ਗਿਆ 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[]. ਪਰ ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ ਜੋ ਸਾਡੇ ਕੋਲ C ਵਿੱਚ ਹੈ, ਅਸੀਂ ਥੋੜਾ ਜਿਹਾ ਧੋਖਾ ਦੇ ਸਕਦੇ ਹਾਂ:

$ 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 ਬਣਾਉਣ ਵਾਲੇ ਲੋਕ ਔਨਲਾਈਨ ਲੀਨਕਸ ਕਮਿਊਨਿਟੀ ਤੋਂ ਸਨ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਉਹਨਾਂ ਨੇ ਉਹਨਾਂ ਲਈ ਸਭ ਤੋਂ ਜਾਣੂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ (ਪਰ ਨਹੀਂ ਆਮ ਲੋਕ) ਕਰਨਲ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਲਈ ਇੰਟਰਫੇਸ: ਨੈੱਟਲਿੰਕ ਸਾਕਟ, ਇਹ ਵੀ ਵੇਖੋ ਆਰਐਫਸੀ 3549. ਲਾਗੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ 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

BPF LLVM ਨਾਲ ਦੋਸਤਾਨਾ ਹੈ ਅਤੇ, ਹਾਲਾਂਕਿ ਹਾਲ ਹੀ ਵਿੱਚ BPF ਲਈ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ gcc ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਸਾਰੇ ਮੌਜੂਦਾ ਵਿਕਾਸ LLVM ਲਈ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਲਈ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਬਣਾਵਾਂਗੇ 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 ਫਾਰਮੈਟ ਵਿੱਚ ਡੀਬੱਗਿੰਗ ਜਾਣਕਾਰੀ ਬਣਾਉਣ ਲਈ ਕਰਨਲ ਬਣਾਉਣ ਵੇਲੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਬੀਟੀਐਫ ਤਕਨਾਲੋਜੀ ਦੇ ਵੇਰਵਿਆਂ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗੇ, ਇਸ ਤੱਥ ਤੋਂ ਇਲਾਵਾ ਕਿ ਇਹ ਸੁਵਿਧਾਜਨਕ ਹੈ ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਆਪਣਾ ਕਰਨਲ ਬਣਾਉਣ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ ਬਣਾਓ 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 ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਮਹੀਨਿਆਂ ਵਿੱਚ ਤੁਹਾਡੀ ਵੰਡ ਵਿੱਚ ਸਭ ਤੋਂ ਵਧੀਆ ਦਿਖਾਈ ਦੇਣਗੀਆਂ। , ਜਾਂ, ਜਿਵੇਂ ਕਿ ਕੁਝ ਡੀਬੱਗਿੰਗ ਟੂਲਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਆਉਣ ਵਾਲੇ ਭਵਿੱਖ ਵਿੱਚ ਬਿਲਕੁਲ ਵੀ ਪੈਕ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਨਾਲ ਹੀ, ਇਸਦਾ ਆਪਣਾ ਕੋਰ ਕੋਡ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ।

ਇੱਕ ਕਰਨਲ ਬਣਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਕਰਨਲ ਖੁਦ, ਅਤੇ ਦੂਜਾ, ਇੱਕ ਕਰਨਲ ਸੰਰਚਨਾ ਫਾਇਲ ਦੀ ਲੋੜ ਹੈ। BPF ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਲਈ ਅਸੀਂ ਆਮ ਵਰਤ ਸਕਦੇ ਹਾਂ ਵਨੀਲਾ ਕਰਨਲ ਜਾਂ ਵਿਕਾਸ ਕਰਨਲ ਵਿੱਚੋਂ ਇੱਕ। ਇਤਿਹਾਸਕ ਤੌਰ 'ਤੇ, ਬੀਪੀਐਫ ਦਾ ਵਿਕਾਸ ਲੀਨਕਸ ਨੈਟਵਰਕਿੰਗ ਕਮਿਊਨਿਟੀ ਦੇ ਅੰਦਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਲਈ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਜਲਦੀ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਡੇਵਿਡ ਮਿਲਰ, ਲੀਨਕਸ ਨੈਟਵਰਕਿੰਗ ਮੇਨਟੇਨਰ ਦੁਆਰਾ ਹੁੰਦੀਆਂ ਹਨ। ਉਹਨਾਂ ਦੇ ਸੁਭਾਅ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ - ਸੰਪਾਦਨ ਜਾਂ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ - ਨੈਟਵਰਕ ਤਬਦੀਲੀਆਂ ਦੋ ਕੋਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਆਉਂਦੀਆਂ ਹਨ - net ਜ net-next. ਬੀਪੀਐਫ ਲਈ ਤਬਦੀਲੀਆਂ ਵਿਚਕਾਰ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਵੰਡੀਆਂ ਜਾਂਦੀਆਂ ਹਨ 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, ਲੀਨਕਸ ਕਰਨਲ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਸਪਲਾਈ ਕੀਤਾ ਗਿਆ। ਇਹ BPF ਡਿਵੈਲਪਰਾਂ ਲਈ BPF ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਲਿਖਿਆ ਅਤੇ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਦੀਆਂ BPF ਵਸਤੂਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ - ਪ੍ਰੋਗਰਾਮ ਲੋਡ ਕਰਨ, ਨਕਸ਼ੇ ਬਣਾਉਣ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਨ, BPF ਈਕੋਸਿਸਟਮ ਦੇ ਜੀਵਨ ਦੀ ਪੜਚੋਲ ਕਰਨ ਆਦਿ। ਮੈਨ ਪੇਜਾਂ ਲਈ ਸਰੋਤ ਕੋਡ ਦੇ ਰੂਪ ਵਿੱਚ ਦਸਤਾਵੇਜ਼ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ ਕੋਰ ਵਿੱਚ ਜਾਂ, ਪਹਿਲਾਂ ਹੀ ਸੰਕਲਿਤ, ਆਨਲਾਈਨ.

ਇਸ ਲਿਖਤ ਦੇ ਸਮੇਂ 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
...

ਜੋ ਦਿਖਾਏਗਾ ਕਿ ਤੁਹਾਡੇ ਕਰਨਲ ਵਿੱਚ ਕਿਹੜੀਆਂ BPF ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਯੋਗ ਹਨ।

ਤਰੀਕੇ ਨਾਲ, ਪਿਛਲੀ ਕਮਾਂਡ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ

# bpftool f p k

ਇਹ ਪੈਕੇਜ ਤੋਂ ਉਪਯੋਗਤਾਵਾਂ ਨਾਲ ਸਮਾਨਤਾ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ iproute2, ਜਿੱਥੇ ਅਸੀਂ, ਉਦਾਹਰਨ ਲਈ, ਕਹਿ ਸਕਦੇ ਹਾਂ ip a s eth0 ਦੀ ਬਜਾਏ ip addr show dev eth0.

ਸਿੱਟਾ

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

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

ਇਹ ਲੇਖ, ਹਾਲਾਂਕਿ ਖਾਸ ਤੌਰ 'ਤੇ ਛੋਟਾ ਨਹੀਂ ਹੈ, ਸਿਰਫ BPF ਦੀ ਦੁਨੀਆ ਦੀ ਇੱਕ ਜਾਣ-ਪਛਾਣ ਹੈ ਅਤੇ "ਉਨਤ" ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਦੇ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਿਆਂ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਅੱਗੇ ਜਾ ਰਹੀ ਯੋਜਨਾ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੈ: ਅਗਲਾ ਲੇਖ BPF ਪ੍ਰੋਗਰਾਮ ਕਿਸਮਾਂ (5.8 ਕਰਨਲ ਵਿੱਚ ਸਮਰਥਿਤ 30 ਪ੍ਰੋਗਰਾਮ ਕਿਸਮਾਂ ਹਨ) ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਹੋਵੇਗੀ, ਫਿਰ ਅਸੀਂ ਅੰਤ ਵਿੱਚ ਇਹ ਦੇਖਾਂਗੇ ਕਿ ਕਰਨਲ ਟਰੇਸਿੰਗ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸਲ BPF ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ। ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਫਿਰ BPF ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਇੱਕ ਹੋਰ ਡੂੰਘਾਈ ਵਾਲੇ ਕੋਰਸ ਦਾ ਸਮਾਂ ਆ ਗਿਆ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ BPF ਨੈੱਟਵਰਕਿੰਗ ਅਤੇ ਸੁਰੱਖਿਆ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਿੱਤੀਆਂ ਜਾਣਗੀਆਂ।

ਇਸ ਲੜੀ ਵਿੱਚ ਪਿਛਲੇ ਲੇਖ

1. ਛੋਟੇ ਬੱਚਿਆਂ ਲਈ BPF, ਭਾਗ ਜ਼ੀਰੋ: ਕਲਾਸਿਕ BPF

ਲਿੰਕ

1. BPF ਅਤੇ XDP ਸੰਦਰਭ ਗਾਈਡ — ਸੀਲੀਅਮ ਤੋਂ BPF 'ਤੇ ਦਸਤਾਵੇਜ਼, ਜਾਂ BPF ਦੇ ਸਿਰਜਣਹਾਰਾਂ ਅਤੇ ਰੱਖ-ਰਖਾਵ ਕਰਨ ਵਾਲਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਡੈਨੀਅਲ ਬੋਰਕਮੈਨ ਤੋਂ। ਇਹ ਪਹਿਲੇ ਗੰਭੀਰ ਵਰਣਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਜੋ ਕਿ ਦੂਜਿਆਂ ਤੋਂ ਵੱਖਰਾ ਹੈ ਕਿ ਡੈਨੀਅਲ ਬਿਲਕੁਲ ਜਾਣਦਾ ਹੈ ਕਿ ਉਹ ਕਿਸ ਬਾਰੇ ਲਿਖ ਰਿਹਾ ਹੈ ਅਤੇ ਉੱਥੇ ਕੋਈ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ। ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹ ਦਸਤਾਵੇਜ਼ ਦੱਸਦਾ ਹੈ ਕਿ ਮਸ਼ਹੂਰ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ XDP ਅਤੇ TC ਕਿਸਮਾਂ ਦੇ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ ip ਪੈਕੇਜ ਤੋਂ iproute2.

2. Documentation/networking/filter.txt - ਕਲਾਸਿਕ ਅਤੇ ਫਿਰ ਵਿਸਤ੍ਰਿਤ BPF ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਵਾਲੀ ਅਸਲ ਫਾਈਲ। ਜੇ ਤੁਸੀਂ ਅਸੈਂਬਲੀ ਭਾਸ਼ਾ ਅਤੇ ਤਕਨੀਕੀ ਆਰਕੀਟੈਕਚਰਲ ਵੇਰਵਿਆਂ ਵਿੱਚ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਇੱਕ ਚੰਗਾ ਪੜ੍ਹਨਾ।

3. ਫੇਸਬੁੱਕ ਤੋਂ BPF ਬਾਰੇ ਬਲੌਗ. ਇਹ ਬਹੁਤ ਘੱਟ ਹੀ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਢੁਕਵੇਂ ਤੌਰ 'ਤੇ, ਜਿਵੇਂ ਕਿ ਅਲੈਕਸੀ ਸਟਾਰੋਵੋਇਟੋਵ (ਈਬੀਪੀਐਫ ਦੇ ਲੇਖਕ) ਅਤੇ ਐਂਡਰੀ ਨਕਰੀਕੋ - (ਰੱਖ-ਰਖਾਅ ਕਰਨ ਵਾਲਾ) ਉੱਥੇ ਲਿਖਦੇ ਹਨ। libbpf).

4. bpftool ਦੇ ਰਾਜ਼. bpftool ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਉਦਾਹਰਨਾਂ ਅਤੇ ਰਾਜ਼ਾਂ ਦੇ ਨਾਲ Quentin Monnet ਤੋਂ ਇੱਕ ਮਨੋਰੰਜਕ ਟਵਿੱਟਰ ਥ੍ਰੈਡ।

5. BPF ਵਿੱਚ ਡੁਬਕੀ: ਪੜ੍ਹਨ ਸਮੱਗਰੀ ਦੀ ਇੱਕ ਸੂਚੀ. Quentin Monnet ਤੋਂ BPF ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਲਿੰਕਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ (ਅਤੇ ਅਜੇ ਵੀ ਬਣਾਈ ਰੱਖੀ ਗਈ) ਸੂਚੀ।

ਸਰੋਤ: www.habr.com