แแแแแกแแแแแแแ แงแแแแแก, แฉแแแ แแแแแแแแ แแแ แแฃแแแแแแชแแแก แแแแ แ แแแฌแแแก "แแแ แขแฃแแแฃแ แ แคแแแแฃแ แ แกแแกแขแแแแแ Linux-แจแ: แ แแขแแ แแ แแก แกแแญแแ แ แแ แ แแแแ แแฃแจแแแแก แแกแแแ?" แจแแแแซแแแแ แฌแแแแแแฎแแ แแแ แแแแ แแแฌแแแ
แ แแแแ แแแแแแแแ แแแ VFS-แก eBPF แแ bcc แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแแ
แฃแแแ แขแแแแกแ แแแ แแแแก แแแกแแแแแแ, แแฃ แ แแแแ แแฃแจแแแแก แแแ แแแ แคแแแแแแแ sysfs
แแ แแก แแแกแ แแ แแฅแขแแแแจแ แแแแแฎแแ แแ ARM64-แแก แงแฃแ แแแแก แงแแแแแแ แแแ แขแแแ แแแ eBPF-แแก แแแแแงแแแแแแ. eBPF (แแแ แแแแก แแแแแขแแก แคแแแขแ แแก แจแแแแแแแแ) แจแแแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแกแแแ, แ แแแแแแช แแฃแจแแแแก query
) แแ แซแแแแแแก แฎแแแแแแ. แแแ แแแแก แฌแงแแ แแแแ แแฃแแแแแแแ แแแแแฎแแแแก, แ แ แจแแฃแซแแแ แแแ แแแก; แแแขแแแ แแฃแ แกแแกแขแแแแแ eBPF แแแกแขแ แฃแแแแขแแแแก แแแจแแแแ แแฉแแแแแแก, แแฃ แ แแก แแแแแแแก แกแแแแแแแแแแจแ แแแ แแแ.
แกแแแแแแแแ แแ, eBPF-แแก แแแแแงแแแแแแก แแแฌแงแแแ แกแแแแแแ แแแ แขแแแแ แแแกแขแ แฃแแแแขแแแแก แแแฎแแแ แแแแ bcc
แแ แแก แแแแแแแก แกแแ แแแขแแแ C แแแแแก แแชแแ แ แฉแแแแ แแแแแ, แ แแช แแแจแแแแก, แ แแ แแแแแกแแแแ แก, แแแแช แแ แแแ แแแแก แแชแแแแก, แแแแแแแ แจแแฃแซแแแ แแแแ แจแแชแแแ. IN bcc/tools
แแ แกแแแแแก 80 แแแแแแแก แกแแ แแแขแ, แ แแช แแแจแแแแก, แ แแ แแแแ แแแแแแแแแ แแแแแแแแแ แก แแ แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แก แจแแแซแแแแ แแแ แฉแแแก แ แแแแ แจแแกแแคแแ แแกแ แแ แแแแแแแก แแแแแกแแญแ แแแแ.
แแแแแแฃแ แแแแแแแ แฃแแ แฌแแ แแแแแแแแก แแแกแแฆแแแแ, แแฃ แ แแก แแแแแแแแ VFS-แแแ แแแจแแแแฃแ แกแแกแขแแแแแ, แกแชแแแแ vfscount
แแ vfsstat
. แแก แแฉแแแแแแก, แแแฅแแแ, แ แแ แแแแแแ แแแ แ vfs_open()
แแ "แแแกแ แแแแแแ แแแ" แฎแแแแ แคแแฅแขแแฃแ แแ แงแแแแ แฌแแแก.
vfsstat.py
แแ แแก แแแแแแแก แกแแ แแแขแ C แแแแแก แฉแแแแ แแแแแ, แ แแแแแแช แฃแแ แแแแ แแแแแแก VFS แคแฃแแฅแชแแแก แแแ แแแก.
แแแแแ แแแแแงแแแแแ แฃแคแ แ แขแ แแแแแแฃแ แ แแแแแแแแ แแ แแแแฎแแ, แ แ แฎแแแแ, แ แแแแกแแช USB แคแแแจ แแ แแแแก แฉแแแกแแแแ แแแแแแฃแขแแ แจแ แแ แกแแกแขแแแ แแฆแแแแฉแแแก แแแก.
eBPF-แแก แแแแแงแแแแแแ แจแแแแซแแแแ แแแฎแแ แ แ แฎแแแแ แแแกแจแ
/sys
แ แแแแกแแช แฉแแกแแฃแแแ USB แคแแแจ แแ แแแแ. แแฅ แแแชแแแฃแแแ แแแ แขแแแ แแ แ แแฃแแ แแแแแแแแ.
แแแแแ แแแงแแแแแ แแแแแแแแจแ, bcc
แแแกแขแ แฃแแแแขแ sysfs_create_files()
. แฉแแแ แแแแก แแฎแแแแแ sysfs_create_files()
แแแแแงแแแแแแ แแแแฌแงแ kworker
แแแแแแ แแแแก แกแแแแกแฃแฎแแ, แ แแ แคแแแจ แแ แแแแ แแงแ แฉแแกแแฃแแ, แแแแ แแ แ แ แคแแแแ แจแแแฅแแแ? แแแแ แ แแแแแแแแ แแแแฉแแแแแแก eBPF-แแก แซแแแแก. แฒแฅ trace.py
แแแญแแแแก kernel backtrace-แก (-K แแแ แแแแขแ) แแ แจแแฅแแแแแ แคแแแแแก แกแแฎแแแก sysfs_create_files()
. แแ แแ แแแแชแฎแแแแแแก แฉแแกแแ แแ แแก C แแแแ, แ แแแแแแช แแแแชแแแก แแแแแแแ แชแแแแแ แคแแ แแแขแแก แกแขแ แแฅแแแก, แ แแแแแแช แแแฌแแแแแฃแแแ Python แกแแ แแแขแแ, แ แแแแแแช แแฌแแ แแแแแก LLVM-แก. แแฎแแแแ แแ แแฃแแ แจแแแแแแแแแ. แแก แแแแแแก แแ แฎแแแก แแ แแฎแแ แชแแแแแแก แแแก แแแ แแแแก แจแแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแจแ. แกแ แฃแแ แคแฃแแฅแชแแแก แฎแแแแแฌแแ แ sysfs_create_files ()
แฃแแแ แแงแแก แ แแแ แแแฃแชแแ แแแฃแแ แแแแ แ แแ แซแแแแแแจแ แแกแ, แ แแ แคแแ แแแขแแก แกแขแ แแฅแแแ แจแแแซแแแแ แแแฃแแแแแแแแก แแ แ-แแ แ แแแ แแแแขแ แแ. C แแแแแก แแ แแแฌแแแจแ แจแแชแแแแแแ แแฌแแแแก C แจแแแแแแแแแก แชแแแแแ แจแแชแแแแแแก. แแแแแแแแแ, แแฃ -l แแแ แแแแขแ แ แแแแแขแแแแแฃแแแ, แแแฎแแแ "BPF แขแแฅแกแขแแก แจแแแแแแ แแแ แแแฎแแ แฎแแ". แแแแแแแแแ แแแ, แ แแแแแแแช แแชแแแแแ C แแ Python-แก, แแแแแแแ แแแกแขแ แฃแแแแขแแแก bcc
แแแแแแแ แแแคแแ แแแแแ แแ แจแแชแแแ.
แ แแแแกแแช USB แแ แแแแ แฉแแกแแฃแแแ, แแแ แแแแก แฃแแแ แแแฎแแแ แแฉแแแแแแก, แ แแ PID 7711 แแ แแก แซแแคแ kworker
แ แแแแแแแช แจแแฅแแแ แคแแแแ ยซeventsยป
ะฒ sysfs
. แจแแกแแแแแแกแแ, แแแ แ sysfs_remove_files()
แแฉแแแแแแก, แ แแ แแแกแแแก แฌแแจแแแก แจแแแแแแ แคแแแแ แฌแแแจแแแ events
, แ แแแแแแช แจแแแกแแแแแแแ แแแแแแแแแก แแแแแแแก แแแแแ แแแแชแแคแชแแแก. แแแแแ แแ แแก, แงแฃแ แแแ sysfs_create_link ()
eBPF-แแ USB แแแกแแแก แฉแแกแแแกแแก แแแแแฉแแแแแ, แ แแ แจแแแฅแแแ แแแแแแฃแ 48 แกแแแแแแฃแ แ แแแฃแแ.
แ แ แแแ แ แแฅแแก แแแแแแแแแแก แคแแแแก? แแแแแงแแแแแ disk_add_events ()
, แแ แแ แช "media_change"
แแ "eject_request"
แจแแแซแแแแ แฉแแแฌแแ แแก แแแแแแแแก แคแแแแจแ. แแฅ แแแ แแแแก แแแแแแก แคแแแ แแชแแแแแแก แแแแฎแแแ แแแแแก แกแแแ แชแแก, แ แแ "แแแกแแ" แแแแแฉแแแ แแ แแแแฆแแแฃแแ. แแแแแแแแแกแฌแแแแ, แ แแแแแแแ แแแคแแ แแแชแแฃแแแ แแแแแแแก แแก แแแแแแ USB แแแกแแแก แฉแแกแแแ, แแแแ แ แแแแก แแแ แแแแแแกแแแ แจแแแแ แแแแ, แแฃ แ แแแแ แแฃแจแแแแก แงแแแแแคแแ แ แแฎแแแแ แฌแงแแ แแแแ.
แแฎแแแแ แฌแแแแแฎแแแแ root แคแแแแฃแ แ แกแแกแขแแแแแ แ แแแแก แฉแแจแแแแแฃแ แแแฌแงแแแแแแแแแก
แ แ แแฅแแ แฃแแแ, แแ แแแแ แแแจแแแก แกแแ แแแ แก แแ แแแก แแแแแแฃแขแแ แก แจแขแแคแกแแแแแแ แแแแฆแแแแ. แฒแแแ แแ แ แแขแแ? แแก แแแแขแแ แฎแแแแ, แ แแ แคแแแแแฃแ แจแแกแแแแฎ แแแฌแงแแแแแแแแแแ แแแแแแขแแแแแฃแ แคแแแแฃแ แกแแกแขแแแแแก แจแแแซแแแแ แฐแฅแแแแแ แแแแแแแแแแฃแแ แฉแแฌแแ แ แแ แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแ, แ แแแแแแแช แฉแแฌแแ แแ แแแ แแแแแแแ แแแแแก, แจแแแซแแแแ แแ แแงแแก แกแแแฅแ แแแแแแแฃแแ แกแแชแแแจแ แฉแแฌแแ แแแแแ. แ แแแแกแแช แแก แแแฎแแแแ, แกแแกแขแแแแก แแคแแแแแแแแแ แฃแแแ แแแแแแแแ แจแแแแแ แฉแแขแแแ แแแแก แแ แแแ แแแแก แแแกแแจแแแแแ. fsck filesystem-recovery
แแ, แฃแแ แแก แจแแแแฎแแแแแจแ, แแแแแชแแแแแแก แแแแแ แแแ.
แแฃแแชแ, แฉแแแ แงแแแแแ แแแชแแ, แ แแ แแแแ แ IoT แแแฌแงแแแแแแแ, แแกแแแ แ แแแแ แช แแแ แจแ แฃแขแแแแขแแ แแแ, แแแ แแแกแขแแขแแแ แแ แแแแฅแแแแแ, แแฎแแ แแฃแจแแแแก Linux-แแ. แแแแ แแ แแแฌแงแแแแแแแแก แแฅแแก แแชแแ แ แแ แกแแแ แแแ แแ แแฅแแก แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแ แแ แแ แแ แกแแแแแก แแแแ "แกแฃแคแแ" แแแแแ แแแแก แกแแจแฃแแแแแ. แฌแแ แแแแแแแแแ, แแฌแแ แแแแแ แแแแฅแแแแก แแแแแแ แ แแแขแแ แแแ, แ แแแแกแแช แกแแแแแขแ แแแ แแแแงแแคแแแแแแก แแแแฌแแแแแ fsck
แ แแแแก แแฌแงแแแก แซแ แแแ แกแแแแแแแ แแฃแจแแแแแก? แแ แแแกแฃแฎแ แแแ แขแแแแ. แฉแแจแแแแแฃแแ แแแฌแงแแแแแแแแแ แแงแ แแแแแ root แคแแแแฃแ แกแแกแขแแแแก ro-rootfs
(แแฎแแแแ แฌแแแแแฎแแแแ root แคแแแแฃแ แ แกแแกแขแแแ)).
ro-rootfs
แแแแแแแแแ แแแแ แกแแ แแแแแแก, แ แแแแแแแช แแแแแแแแ แแจแแแ แแ, แแแแ แ แแแแแแขแฃแ แแแ. แแ แแ แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ แแแแแ แแ แแแ แแแแก แแ แจแแฃแซแแแ แแแฌแแ แแก /usr
แแ /lib
, แแฃ แแแแฃแฅแกแแก แแ แแชแแกแก แแ แจแแฃแซแแแ แแฅ แฉแแฌแแ แ. แแแแ แ แแก แแ แแก, แ แแ แแแแฌแแแแ แจแแฃแชแแแแแ แคแแแแฃแ แ แกแแกแขแแแ แแ แแขแแแฃแแแ แแแกแขแแแชแแฃแ แ แแแฌแงแแแแแแแแแแก แกแแแแแ แแฎแแ แแแญแแ แแกแแแแก, แ แแแแแ แแแแฎแแแ แ แแแ แกแแแแแ แแงแ แแแแแ แแแแแแแแ แแ แกแแกแขแแแแแก, แ แแแแแแแช แแแแแแแแฃแ แแ แแแแแขแฃแ แแ แกแแแแแ แกแแกแขแแแแแแกแแแแก. แแแแแ แงแแแแแแ แแแแจแแแแแแแแแ (แแแแ แแ แงแแแแแแ แแแแแแ แฃแแ) แกแแ แแแแแแ แแ แแก แแก, แ แแ ro-rootfs แแแซแฃแแแแก แแแแแแแแแ แแแก แแแแแฌแงแแแขแแ, แ แแแแแ แกแแกแขแแแแก แแแแแฅแขแแแ แแฅแแแแ แฃแชแแแแแ แกแแกแขแแแแก แแแแแแแแก แแขแแแแ. Ro-rootf-แแแแแ แแฃแจแแแแ แจแแแซแแแแ แแงแแก แฃแฎแแ แฎแฃแแ แแ แแขแแแแแแฃแแ, แ แแแแแ const แชแแแแแแแ แฎแจแแ แแ แแแฎแแแแแ แแ แแแ แแแแ แแแแก แแแแแจแ, แแแแ แแ แแแแ แกแแ แแแแแแ แแแแแแแ แแแแ แแแแแก แแแแแขแแแแ แฎแแ แฏแแแก.
แจแแฅแแแ rootfs
แแฎแแแแ แฌแแแแแฎแแ แแแแแฎแแแก แแแแแขแแแแ แซแแแแกแฎแแแแแก แฉแแจแแแแแฃแแ แแแแแแแแแ แแแแกแแแแก แแ แกแฌแแ แแ แแฅ แฉแแแแแ VFS. Linux แแแแแฎแแแก, แ แแ แคแแแแแแ แแงแแก แจแแงแแแแแแ /var
แแงแ แฉแแกแแฌแแ แ แแ แแแ แแ แแแแกแ, แแแแ แ แแแแฃแแแ แฃแแ แแแแแแแชแแ, แ แแแแแแช แแฃแจแแแแก แฉแแจแแแแแฃแ แกแแกแขแแแแแแ, แจแแแชแแแแ แจแแฅแแแแก แแแแคแแแฃแ แแชแแ dot-files
ะฒ $HOME
. แแแแแแ แ แแแ แแฅแขแแ แแแจแ แแ แกแแแฃแแ แแแแคแแแฃแ แแชแแแก แคแแแแแแแก แแ แ-แแ แแ แแแแแกแแแแแ แแ แแก แแแแ แฌแแแแกแฌแแ แแแแแ แแ แแแ แแ แฉแแจแแแแแ rootfs
. แแงแแแแแ /var
แแ แ-แแ แแ แจแแกแแซแแ แแแแแแแแ แแแกแ แแแแแแขแแแแแ แชแแแแ แแแกแแฌแแ แแแแแงแแคแแ, แฎแแแ /
แแแแแแขแแแแแฃแแแ แแฎแแแแ แฌแแกแแแแแฎแแ. แแแแแ แแ แแ แแแแฃแแแ แฃแแ แแแขแแ แแแขแแแ แแ แแก แจแแแแ แแก แแ แแแแแคแแ แแแก แกแแแแแ แแแแก แแแแแงแแแแแ.
แแแแแแแแจแแ แแแแแ แแ แแแกแแฌแงแแแ แกแแแแแ แแแ, แแแแ แแแแแงแแแแแ แแแแขแแแแแ แแแแ
แแ แซแแแแแแก แจแแกแ แฃแแแแ man mount
แแก แแ แแก แกแแฃแแแแแกแ แแแ แจแแแแกแฌแแแแแ แจแแกแแแ แแแ แแ แแแแแคแแ แแแแ แกแแแแแขแแแแแแ, แ แแแแแแแช แแแแแแแแแ แแแก แแ แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แแแก แแซแแแแก แจแแกแแซแแแแแแแแก แจแแฅแแแแ แคแแแแฃแ แ แกแแกแขแแแ แแ แ แแแแแ แแ แจแแแแแ แแแแแแแแแแแ แแแ แกแฎแแ แแแแแแแชแแแแจแ. แฉแแจแแแแแฃแแ แกแแกแขแแแแแแกแแแแก, แแก แแแจแแแแก แคแแแแแแแก แจแแแแฎแแแก แจแแกแแซแแแแแแแแก /var
แแฎแแแแ แฌแแแแแฎแแแแ แคแแแจ แแ แแแแแ, แแแแ แแ แแแแแคแแ แแแก แแ แแแกแแแแแ แแแแแ แแแแแแ แกแแแแแแแช tmpfs
ะฒ /var
แฉแแขแแแ แแแแกแแก แแก แแแแแแแชแแแแก แกแแจแฃแแแแแแก แแแกแชแแแก แแแฌแแ แแ แแฅ แฉแแแแฌแแ แแแ (แกแแ แแแ). แจแแแแแ แฏแแ แแ, แ แแชแ แฉแแ แแแแ แชแแแแแแแแแก /var
แแแแแแ แแแแ. แแแแแฎแฃแ แแแก แกแแแแแ แ แฅแแแแก แแแแจแแ แก แจแแ แแก tmpfs
แแ แคแฃแซแแแแแแแฃแ แ แคแแแแฃแ แ แกแแกแขแแแ แแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแแกแ แฃแแแ แแจแแแ แ แชแแแแแแแแแ แแ แกแแแฃแ แคแแแแแแจแ ro-tootf
แแแจแแ แ แแชแ แจแแกแแแ แแแ แกแแแแแขแแแ แจแแฃแซแแแ แแฎแแแก แแแชแแแก tmpfs
แกแแฅแแฆแแแแแแแ แฉแแแก แ แแแแ แช แฉแแกแแฌแแ แ ro-rootfs
แแแแแ. แฎแแแ overlayfs
แแก แแ แแก แกแฌแแ แ (proper
) แคแแแแฃแ แ แกแแกแขแแแแก แขแแแ, แจแแแแ แแแ แกแแแแแขแแแ แแแแแ แแแแแ
แแแแแคแแ แแแกแ แแ แแแแแแแแจแแ แแแแแ แกแแแแแ แแก แแฆแฌแแ แแแแแแแแ แแแแแแแแแแ แ, แแก แแ แแแแก แฃแแแแ แก mountsnoop
แกแแฌแงแแกแ bcc
.
แแแแแฌแแแแ system-nspawn
แแฌแงแแแก แแแแขแแแแแ แก แแแจแแแแแกแแก mountsnoop.py
.
แแแแฎแแ แ แ แแแฎแแ:
ะะฐะฟััะบ mountsnoop
แแแแขแแแแแ แแก "แฉแแขแแแ แแแแกแแก" แแแแฉแแแแแแก, แ แแ แแแแขแแแแแ แแก แแฃแจแแแแแก แแ แ แแแแแ แแ แแก แแแแแแแแแแฃแแ แแแแแแจแแ แแแฃแ แกแแแแแ แแ (แแแแแกแแฎแฃแแแ แแฎแแแแ แแ แซแแแ แแแแแแแแแแ แแแกแแฌแงแแกแ).
แแฅ systemd-nspawn
แฃแแ แฃแแแแแงแแคแก แจแแ แฉแแฃแ แคแแแแแแก procfs
ะธ sysfs
แแแกแแแแซแแแ แแแแขแแแแแ แ, แ แแแแ แช แแแแแแแแ แแแกแแแ rootfs
... แแแ แแ MS_BIND
แแ แแจแ, แ แแแแแแช แแแแแแก แกแแแแแแแแฃแแ แกแแแแแ แก, แแแแแแ แแ แกแฎแแ แแ แแจแแแ แแแแแ แแแแกแแแฆแแ แแแก แฃแ แแแแ แแแแแก แฐแแกแขแแกแ แแ แแแแขแแแแแ แแก แกแแฎแแแแแแก แกแแแ แชแแจแ แชแแแแแแแแแก แจแแ แแก. แแแแแแแแแ, แแแแแแจแแ แแแฃแ แกแแแแแ แก แจแแฃแซแแแ แแ แแแแแขแแแแก แชแแแแแแแแแ /proc
ะธ /sys
แแแแขแแแแแ แจแ, แแ แแแแแแแ แแกแแแ แแแ แแก แแแฎแแแแแ.
แแแกแแแแ
Linux-แแก แจแแแ แคแฃแแฅแชแแแแแ แแแแก แแแแแแ แจแแแซแแแแ แจแแฃแซแแแแแแ แฉแแแแแก, แ แแแแแ แแแ แแแ แจแแแชแแแก แฃแแแ แแแแแ แ แแแแแแแแแก แแแแก, แแแแ แแแ แขแแแแแก Linux-แแก แแแแฎแแแ แแแแแก แกแแแ แชแแก แแแแแแแชแแแแก แแ แกแแกแขแแแฃแ แ แแแ แแก แแแขแแ แคแแแกแแแก C แแแแแแแแแแแแจแ, แ แแแแ แแชแแ glibc
. แแ แแแ แแกแแก แแแฆแฌแแแแก แแ แ-แแ แแ แแแแ แแ แแ แแแ แแแแก แฅแแแกแแกแขแแแแก แกแแฌแงแแกแ แแแแแก แฌแแแแแฎแแ, แกแแกแขแแแฃแ แ แแแ แแแแก แแ แแแแฎแแแ แแแแแก แกแแแ แชแแก แกแแแแฃแ แแแแก แแแแแแแแ, แแกแแแ แ แแแแ แช แแแ แแแแก แซแแ แแแแแ แจแแแ แแแขแแ แคแแแกแแแแก, แ แแแแ แแชแแ แชแฎแ แแแ. file_operations
. แคแแแแฃแ แ แแแแ แแชแแแแ แแแแแแแกแฌแแแแแก "แงแแแแแคแแ แ แคแแแแแ" แแ แแแชแแแก, แ แแช แแแ แแแ แแแแก แแแแกแแแฃแแ แแแแ แกแแกแแแแแแแแก แฎแแแก. C แแแ แแแแก แฌแงแแ แแก แคแแแแแแ แแแแ แแแแแก แแแ แแฅแขแแ แแแจแ fs/
แฌแแ แแแแแแแแแ แแแ แขแฃแแแฃแ แ แคแแแแฃแ แ แกแแกแขแแแแแแก แแแแแแแแแขแแชแแแก, แ แแแแแแแช แฌแแ แแแแแแแแแ แจแแคแฃแแแแก แคแแแแก, แ แแแแแแช แฃแแ แฃแแแแแงแแคแก แคแแ แแ แแ แจแแแแ แแแแ แแแ แขแแ แแแแกแแแแแแแแก แแแแฃแแแ แฃแ แคแแแแฃแ แกแแกแขแแแแแกแ แแ แจแแกแแแแฎ แแแฌแงแแแแแแแแแก แจแแ แแก. แแแแฃแฅแกแแก แกแแฎแแแแแแก แกแแแ แชแแก แกแแจแฃแแแแแแ แแแแแแจแแ แแแ แแ แแแแแคแแ แแ แแ แแก VFS-แแก แฏแแแแกแแฃแ แ แแแแกแแแแแ, แ แแช แจแแกแแซแแแแแแก แฎแแแก แแฎแแแแ แฌแแแแแฎแแแแ แแแแขแแแแแ แแแแก แแ root แคแแแแฃแ แ แกแแกแขแแแแแแก แจแแฅแแแแก. แฌแงแแ แแก แแแแแก, eBPF แซแแ แแแแแ แฎแแแกแแฌแงแแก แแ แแแกแ แแแขแแ แคแแแกแแก แจแแกแฌแแแแแกแแแ แแ แแแ bcc
แแแแแแแแแก แแแ แแแแก แจแแกแฌแแแแแก, แแแแ แ แแแแกแแ.
แแแแแแ แแแ, แแแฌแแ แแ, แแก แกแขแแขแแ แแฅแแแแแแแก แกแแกแแ แแแแแ แแงแ? แแฅแแแ แแแฅแแ แ แแแแ แแแแแแขแแ แ แแ แจแแแแจแแแ? แแแแฃแฅแกแแก แแแแแแแกแขแ แแขแแ แแก แแฃแ แกแแ แแแแแขแแ แแกแแแฃแแแแ แแแฌแแแฃแแแ แแ แแแ
แฌแงแแ แ: www.habr.com