แกแแ แแแแ แแ แแแแแแแชแแแก แจแแฅแแแ, แ แแแแแแช แแฃแจแแแแก แแแแแกแแแแ แแแกแขแ แแแฃแชแแแแ, แแแแแแ แกแแฅแแ แแ แแ แแก. แแแแกแแแแแก, แ แแ แแแ แฌแแฃแแแแ, แ แแ Veeam Agent for Linux แแฃแจแแแแก แแแกแขแ แแแฃแชแแแแแ Red Hat 6-แแแ แแ Debian 6-แแแ, OpenSUSE 15.1-แแแ แแ Ubuntu 19.04-แแแ, แแฅแแแ แฃแแแ แแแแแแแ แแ แแแแแ แ แแแ แแ แแแแแแแแ, แแแแกแแแฃแแ แแแแ แแแแก แแแแแแแแกแฌแแแแแแ, แ แแ แแ แแแ แแแฃแแ แแ แแแฃแฅแขแ แจแแแชแแแก แแแ แแแแก แแแแฃแแก.
แกแขแแขแแ แจแแแฅแแแ แแแแคแแ แแแชแแแแ แแแแแกแฃแแ แแแกแแแแแแก แกแแคแฃแซแแแแแ
Linux แแ แแ แแก แแฎแแแแ แแ แ-แแ แแ แงแแแแแแ แแแแฃแแแ แฃแแ แแแแ แแชแแฃแแ แกแแกแขแแแ. แแ แกแแแแแแ, แแก แแ แแก แแแแขแคแแ แแ, แ แแแแแก แกแแคแฃแซแแแแแแช แจแแแแซแแแแ แแแแแแแแ แ แแฆแแช แฃแแแแแแฃแ แ, แ แแฆแแช แกแแแฃแแแ แ. แแแแก แฌแงแแแแแแ, Linux-แก แแฅแแก แแ แแแแแ แแแกแขแ แแแฃแชแแ, แ แแแแแแช แแแแกแฎแแแแแแแ แแ แแแ แแแฃแแ แแแแแแแแแขแแแแก แแแแแแแฅแขแจแ. แแ แแฅ แฉแแแแแ แแ แแแแแแ: แแแแกแแแแก, แ แแ แแ แแแ แแแฃแแแ แแ แแแฃแฅแขแแ แแแแแกแแแแ แแแกแขแ แแแฃแชแแแแ แแแฃแจแแแก, แแฅแแแ แฃแแแ แแแแแแแแแกแฌแแแแ แแแแแแฃแแแก แแแฎแแกแแแแแแแแแ.
แแแแแขแแก แแแแแฏแแ แแแ. .deb vs .rpm
แแแแแฌแงแแ แแ แแแฃแฅแขแแก แกแฎแแแแแกแฎแแ แแแกแขแ แแแฃแชแแแแ แแแแแฌแแแแแแก แแจแแแ แ แแ แแแแแแแ.
แแ แแแ แแแฃแแ แแ แแแฃแฅแขแแแแก แแแแ แชแแแแแแก แงแแแแแแ แขแแแแฃแ แ แแแแ แแแแแขแแก แกแแชแแแจแ แแแแแแแกแแแ, แ แแแ แกแแกแขแแแแจแ แฉแแจแแแแแฃแแแ แแแแแขแแแแก แแแแแฏแแ แแ แจแแซแแแก แแแกแ แแแกแขแแแแชแแ แแฅแแแแ.
แแฃแแชแ, แฉแแแ แแแแฅแแก แแ แ แแแแฃแแแ แฃแแ แแแแแขแแก แคแแ แแแขแ: rpm ะธ deb. แแก แแแจแแแแก, แ แแ แงแแแแแก แแแฃแฌแแแก แแฎแแ แแแญแแ แ.
Deb แแแแแขแแแแก แกแแแงแแ แแจแ, แแแแกแแแแแแแแก แแแแ แกแแแชแแ แแ. แแแแแ แแแแแขแ แแแกแขแแแแ แแแฃแแแ แแ แแฃแจแแแแก แแแแแแ แแ แแแ แแแ แ แแแแ แช Debian 6-แแ, แแกแแแ Ubuntu 19.04-แแ. แแแแแขแแแแก แจแแฅแแแแกแ แแ แแแแแแ แแฃแจแแแแแก แแ แแชแแกแแก แกแขแแแแแ แขแแแ, แ แแแแแแแช แแกแแฎแฃแแแ แซแแแ Debian แแแกแขแ แแแฃแชแแแแจแ, แ แฉแแแ แแฅแขแฃแแแฃแ แ แแฎแแ Linux Mint-แกแ แแ แแแแแแแขแแ แฃแ OS-แจแ. แแแแขแแ, Linux-แแกแแแแก Veeam Agent-แแก แจแแแแฎแแแแแจแ, แกแแแแแ แแกแแ แแ แแ แแแ แแแแแขแ แแแแแแฃแแ แแแแ แแขแฃแ แแก แแแแขแคแแ แแแกแแแแก.
แแแแ แแ rpm แแแแแขแแแแก แกแแแงแแ แแจแ, แแแแกแฎแแแแแแแแ แแแแแ. แแแ แแแ แ แแแจแ, แแแแก แแแแ, แ แแ แแ แกแแแแแก แแ แ แกแ แฃแแแแ แแแแแฃแแแแแแแแ แแแกแขแ แแแฃแขแแ แ, Red Hat แแ SUSE, แ แแแแแแ แแแแกแแแแแแแ แกแ แฃแแแแ แแ แแกแแญแแ แแ. แแแแ แแช, แแ แแแกแขแ แแแฃแขแแ แแแก แแฅแแ แกแแแแกแขแ แแแฃแชแแ แแแแ แแแ แแแแแแ. แแฎแแ แแแญแแ แ แแ แแฅแกแแแ แแแแแขแฃแแ. แแแ แจแแ แแก แแแแกแแแแแแแแช แแ แแ แแก แกแแญแแ แ. แแฆแแแฉแแแ, แ แแ el6, el7 แแ el8-แก แแฅแแ แกแแแฃแแแ แ แแแแแขแแแ. แชแแแแ แแแแแขแ Fedora-แกแแแแก. แแแแแขแแแ SLES11 แแ 12-แแกแแแแก แแ แชแแแแ openSUSE-แกแแแแก. แแแแแแ แ แแ แแแแแแ แแ แแก แแแแแแแแแแฃแแแแแแ แแ แแแแแขแแก แกแแฎแแแแแ.
แแแแแแแแแแฃแแแแแก แแ แแแแแแ
แกแแแฌแฃแฎแแ แแ, แแ แแ แแ แแแแแ แแแแแขแแแ แฎแจแแ แแ แแแแแ แแแแ แกแฎแแแแแกแฎแแ แกแแฎแแแแแแ แกแฎแแแแแกแฎแแ แแแแแฌแแแแแแจแ. แฅแแแแแ แแแชแแแฃแแแ veeam แแแแแขแแก แแแแแแแแแแฃแแแแแก แแแฌแแแแแ แแแ แกแแ.
EL7-แกแแแแก:
SLES 12-แแกแแแแก:
- libblkid
- libgcc
- libstdc++
- ncurses-libs
- แแแฃแแ แแแแ-libs
- แคแแแ-libs
- veeamsnap=3.0.2.1185
- libblkid1
- libgcc_s1
- libstdc++6
- libmagic1
- libfuse2
- veeamsnap-kmp=3.0.2.1185
แจแแแแแแ, แแแแแแแแแแฃแแแแแแแก แกแแ แฃแแแแแแฃแ แแ แแแแแฌแแแแแแกแแแแก.
แ แแช แฃแแ แแกแแแแ แแ แแก, แ แแแแกแแช แแแแแฎแแแแฃแแ แแแ แกแแ แแฌแงแแแก แแแแแแแแก แซแแแแ แแแแแขแแก แกแแฎแแแแ.
แแแแแแแแ:
แแแแแขแ แแแแแฎแแแแฃแแแ Fedora 24-แจแ แฌแงแแแแ แแ-5 แแแ แกแแแแแ 6 แแแ แกแแแแแ. แฉแแแแ แแ แแแฃแฅแขแ แจแแแฅแแแ แแ-5 แแแ แกแแแ, แ แแแ แฃแแ แฃแแแแแงแแคแแแแงแ แแแแกแแแแแแแ แซแแแ แแแกแขแ แแแฃแชแแแแแแ. Fedora 5-แแ แแแแแแแแแแแก แซแแแแ แแ-24 แแแ แกแแแก แแแแแกแแงแแแแแแแ, แแแแแฌแแ แแแแแขแแก แแแแแงแแแแแ ncurses-compat-libs.
แจแแแแแแ, Fedora-แกแแแแก แแ แแก แแ แ แแแแแขแ, แแแแกแฎแแแแแแฃแแ แแแแแแแแแแฃแแแแแ.
แฃแคแ แ แกแแแแขแแ แแกแ. แจแแแแแแ แแแแแฌแแแแแแก แแแแแฎแแแแแก แจแแแแแ, แแแแแขแ ncurses-compat-libs แแแแแแแแแแแก แแ-5 แแแ แกแแแ, แแก แแแฃแฌแแแแแแแแ. แแแกแขแ แแแฃแขแแ แแกแแแแก แซแแแ แแ แซแแแแ แแแแแแแแแแแแแก แแแแแฌแแแแแแก แแฎแแ แแแ แกแแแจแ แฉแแแ แแแ. แแแ แแแแฃแแ แแแ แแแแแก แจแแแแแ, แแ แแแแแแ แแแแแแแ แแ SUSE แแแกแขแ แแแฃแชแแแแจแ.
แจแแแแแแ, แแแแแแ แ แแแกแขแ แแแฃแชแแแก แฃแแแ แแแแขแแแแแแแ แแจแแแ แ แแแแแแแแแแฃแแแแ ncurses-libsแแ แแแแคแแฅแกแแ แแ แแ แแแฃแฅแขแ แแกแ, แ แแ แแแก แจแแแซแแแก แแแฃแจแแแก แแแแแแแแแแแก แแแแแกแแแแ แแแ แกแแแกแแแ.
แกแฎแแแแ แจแแ แแก, Red Hat-แแก แแ-8 แแแ แกแแแจแ แแฆแแ แแ แแก แแแขแ แแแแแขแ แแแแแแ, แ แแแแแแช แแแ แ แซแแแแก แแฎแแแแแ แแแแแแ 2.7. แแ แกแแแแแก python2 ะธ แแแแแแ3.
แแแแแขแแก แแแแแฏแแ แแแแก แแแขแแ แแแขแแแ
แแแแแแแแแแฃแแแแแก แแ แแแแแแ แซแแแแแ แแ แแแแ แฎแแแแ แแจแแแ แแ. แฃแแ แแแแ แแแแแแฎแกแแแ แ แแแแแแแแแแฃแแแแแก แฏแแฏแแฎแแแ.
แกแฎแแแแแกแฎแแ แแแแแแแแแแแแแกแ แแ แแแแแแแชแแแแแก แแแแ แแแแแแแ แแกแ, แ แแ แงแแแแแ แกแขแแแแแฃแ แแ แแแฃแจแแแก แแ แแแแคแแแฅแขแ แแ แแงแแก - แกแแแแแแแแแแจแ, แแก แแ แแก แแแแชแแแ, แ แแแแแก แแแแแญแ แแกแแช แแแแฃแฅแกแแก แแแแแกแแแแ แ แแแกแขแ แแแฃแขแแ แ แชแแแแแแก.
แแแแแขแแก แแแแแฏแแ แ แชแแแแแแก แแ แแ แแแแแแแก แแแแแญแ แแก แกแ แฃแแแแ แแแแกแฎแแแแแแฃแแ แแแแ. แแแ แแฃแแ Canonical-แแแ. แแแแแแ แ แแแแ: แแแแแแแชแแ แแฃแจแแแแก แฅแแแจแแก แงแฃแแจแ, แแแแแแ แแแฃแ แแ แแแชแฃแ แซแแ แแแแ แกแแกแขแแแแจแ. แแฃ แแแแแแแชแแ แแแแแฎแแแก แแแแแแแแแแแแก, แแแ แแแแฌแแแแแ แแแแแ แแแแแแแชแแ.
แแแแแแแแแขแ แแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแจแแแ แแแแแแแชแแแแ แกแแแแ แฏแแจแแจแ Linux แแแแขแแแแแ แแแแก แแแแแงแแแแแแ. แแกแแแ แแแแแแงแแแแแ แฅแแแจแแก แงแฃแแแก แแแแ AppImage.
แแก แแแแแฌแงแแแขแแแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแ แแ แแแแแขแ แแแแแกแแแแ แ แแแแแฌแแแแแแกแแแแก. แแ แจแแแแฎแแแแแจแ, แแฃ แแแแแแแแแขแ แแแแแแแชแแแก แแแกแขแแแแชแแ แแ แแแจแแแแ แจแแกแแซแแแแแแแ แแแแแแแกแขแ แแขแแ แแก แชแแแแแก แแแ แแจแแช.
แแแแแแ แ แแ แแแแแแ แแก แแ แแก, แ แแ แงแแแแ แแแแแแแชแแแก แแ แจแแฃแซแแแ แฅแแแจแแก แงแฃแแจแ แแแจแแแแ. แแแแแแ แ แแแแแแแแก แกแญแแ แแแแ แแแ แแแแแ แ แฌแแแแแ แแแแขแคแแ แแแแ. แแ แแ แช แแ แแกแแฃแแ แแ แแแ แแแแก แแแแฃแแแแแ, แ แแแแแแแช แแแแชแ แแ แแ แแแ แแแแแแแแแแฃแแแ แแแ แแแแแ แแ แแ แฏแแแแแแ แกแแแแแแฅแกแแก แแแแชแแคแชแแแจแ.
แแแแ แ แแ แแแแแแ แแก แแ แแก, แ แแ Red Hat-แแกแ แแ SUSE-แแแ แกแแฌแแ แแแก แแแ แแแแจแ แแแแฃแแแ แฃแแ แแแกแขแ แแแฃแชแแแแ แฏแแ แแ แจแแแชแแแก Snappy-แแกแ แแ Flatpak-แแก แแฎแแ แแแญแแ แแก.
แแแแกแแแ แแแแแแจแแ แแแแ, Veeam Agent Linux-แแกแแแแก แแแฃแฌแแแแแแแแ
แแแแแขแแก แแแแแฏแแ แแแแก แจแแกแแฎแแ แแแแฎแแแก แแแกแแกแ แฃแแแแแแ, แแแแแ แแฆแแแแจแแ, แ แแ แแ แกแแแแแก แจแแกแแซแแแแแแแ แแแแแแแแ แแแแขแแแแ แแแแแขแแก แแแแแฏแแ แแแ แแแแแ แฃแแ แคแแแแแแแก แแ แกแแ แแแขแแก แแ แ แแแแแขแจแ แแแแแกแขแแแแ แแแแก แแแแ.
แแกแแแ แแแแแขแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแ แแ แกแแแ แแ แแแแแขแ แกแฎแแแแแกแฎแแ แแแแแฌแแแแแแกแ แแ แแแแขแคแแ แแแแแกแแแแก, แแแแแฎแแ แชแแแแแ แแแขแแ แแฅแขแแฃแแ แแแกแขแแแแชแแแก แแ แแชแแกแ, แแแแแฎแแ แชแแแแแ แกแแญแแ แ แแแ แกแแแแแแแแชแแ. แแ แแฎแแแแ VMware-แแแ แจแแแฎแแแ Linux-แแกแแแแก แแกแแ แแแแแขแแแก.
แแแแแฎแแแแแก แแ แแแแแแ
แแแจแแแแช แแ, แแฃ แแแแแแแแแแฃแแแแแก แงแแแแ แแ แแแแแแ แแแแแแ แแแฃแแแ, แแ แแแ แแแ แจแแแซแแแแ แแแแกแฎแแแแแแฃแแแ แแแฃแจแแแก แแแแแ แแแแแฌแแแแแแแ. แแแแแฎแแแแแแแก แกแแแแแฎแแ.
แแแแแฎแแแแแก 3 แกแขแ แแขแแแแแ:
- แฃแแแ แขแแแแกแ แแกแแ, แ แแ แแ แแกแแแแก แแแแแแฎแแแ. แกแแ แแแ แ แแแแแงแแแ แแ แแแแแแแฌแงแแ. แ แแขแแ แแแแแฎแแแแ, แแฃ แงแแแแแคแแ แ แแฃแจแแแแก? แแ แแแแแแแแ แแฌแงแแแ แแแ แแแแแ แแแฃแแแแจแแ แแแ แแฎแแ แแแญแแ แแก. แแแกแขแ แแแฃแชแแแก แจแแแฅแแแแแ แแฎแแ แก แฃแญแแ แก แแฎแแแแ แแแแแฎแแแแฃแ แแแแแชแแแแก.
- แจแแแแซแแแแ แแแแแ แแแกแขแ แแแฃแขแแ แก แแ แแแแงแแแแ แแแขแแแแขแฃแ แ แแแแแฎแแแแแแ. แแ แจแแแแฎแแแแแจแ, แแฎแแ แแแญแแ แแก แแแ แ แกแแแแ แแฃแแแ แแแฃแงแแแแแแแแ แแฅแแแแ แฌแแ แฃแแแขแแแแแ แแแแแฎแแแแแก แจแแแแแ.
- แฎแแแแ แแแแแฎแแแแแก แแแ แแแแขแ แแฎแแแแ แกแแขแแกแขแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ แแแจแแแแแก แจแแแแแ แแ แแก แงแแแแแแ แกแแแแแแ, แแแแ แแ แซแแแ แ แแ แจแ แแแแขแแแแแ. แงแแแแแก แแ แจแแฃแซแแแ แแแแก แกแแจแฃแแแแแ.
แแแแแแแแ แกแฎแแแแแกแฎแแ แแแแฎแแแ แแแแแ แแงแแแแแก แแแแแฎแแแแแก แแแแกแฎแแแแแแฃแ แกแขแ แแขแแแแแก, แแฃแชแแแแแแแแ แ แแแแ แช แฃแแฎแแแกแ แแแแแจแแแแแก, แแกแ แงแแแแ แแแ แ แแแแแจแแแแฃแแแก แแฎแแ แแแญแแ แ. แแก แแ แแฃแแแแก แ แแแแ แช แแแแแแแแ แแแแก, แแกแ แขแแกแขแแ แแแแก แแ แแชแแกแก แแ แแแแแก แขแแแแแแก แแแแขแแแก แแแแฎแแแ แ แแฃแแแก.
แขแแฅแแแแแก แแแแขแคแแ แแแแแก แแ แแแแแคแแ แแแแแแ
แกแฎแแแแแกแฎแแ แขแแฅแแแแแก แแแแขแคแแ แแ แแ แแก แแ แแแแแแ, แ แแแแแแช แซแแ แแแแแแ แกแแแชแแคแแแฃแ แแ แแจแแแแแฃแ แ แแแแแกแแแแก. แแแแแแฃแ, แแฅแแแ แฃแแแ แจแแแแ แแแแ แแ แแแแแ แคแแแแแแ แแแแแแฃแแ แแฎแแ แแแญแแ แแแ แแแแขแคแแ แแแกแแแแก.
Veeam Agent for Linux แแ แแแฅแขแจแ, แฉแแแ แฏแแ แแแแแ แแ แจแแแแแซแแแ แ แแแแ แแกแแแแกแ RISC-แแก แแฎแแ แแแญแแ แ.
แแ แกแแแแแฎแแ แแแขแแแฃแ แแ แแ แจแแแฉแแ แแแแ. แแ แแฎแแแแ แซแแ แแแแ แแ แแแแแแแแก แแแแแแงแแค: แแแแขแคแแ แแแแ แแแแแแแแแแฃแแ แขแแแแแ, แแแ size_t
, แกแขแ แฃแฅแขแฃแ แแก แแแกแฌแแ แแแ แแ แแแแขแแแแก แแแแแแแแแแ แแแ.
แกแขแแขแแแฃแ แ แแ/แแ แแแแแแแฃแ แ แแแแจแแ แ
แแแแ แแ แแแแฎแแแ "แ แแแแ แแแแแแแแจแแ แแ แแแแแแแแแแแแ - แแแแแแแฃแ แแ แแฃ แกแขแแขแแแฃแ แแ?" แฆแแ แก แแแแฎแแแแ.
แ แแแแ แช แฌแแกแ, C/C++ แแแแแแแชแแแแ Linux-แจแ แแงแแแแแแ แแแแแแแฃแ แแแแจแแ แก. แแก แแจแแแแแแ แแ แแฃแจแแแแก, แแฃ แแแแแแแชแแ แจแแฅแแแแแแ แกแแแชแแแแฃแ แแ แแแแแ แแขแฃแแ แแแแแฌแแแแแแกแแแแก.
แแฃ แแแแชแแแแ แกแฎแแแแแกแฎแแ แแแกแขแ แแแฃแชแแแก แแแคแแ แแ แแ แแ แแ แแแแแ แคแแแแแ, แแแจแแ แงแฃแ แแแฆแแแ แฃแแแ แแแแแแฎแแแแแ แฃแซแแแแแก แแฎแแ แแแญแแ แแ แแแแแฌแแแแแแแ. แฉแแแแแแแก แแก แแ แแก Red Hat 6. แจแแแชแแแก gcc 4.4, แ แแแแแกแแช C++11 แกแขแแแแแ แขแแช แแ แแ แฃแญแแ แก แแฎแแ แก.
แฉแแแ แแแจแแแแแ แฉแแแแก แแ แแแฅแขแก gcc 6.3-แแก แแแแแงแแแแแแ, แ แแแแแแช แกแ แฃแแแ แฃแญแแ แก แแฎแแ แก C++14-แก. แแฃแแแแ แแแแ, แแ แจแแแแฎแแแแแจแ, Red Hat 6-แแ แแฅแแแ แฃแแแ แแขแแ แแ libstdc++ แแ แแแแแ แแแ แแแแแแแแแแแแ. แฃแแแ แขแแแแกแ แแแแ แแแแแแ แกแขแแขแแแฃแ แแ แแแแแ.
แกแแแฌแฃแฎแแ แแ, แงแแแแ แแแแแแแแแแ แแ แจแแแซแแแแ แกแขแแขแแแฃแ แแ แแงแแก แแแแแแจแแ แแแฃแแ.
แแแ แแแ แ แแแจแ, แกแแกแขแแแฃแ แ แแแแแแแแแแแแ, แ แแแแ แแชแแ libfuse, libblkid แแฃแชแแแแแแแแ แแแแแแแฃแ แแ แแแแแแจแแ แแแ แแแ แแแแแ แแ แแแก แแแแฃแแแแแแ แแแแ แแแแกแแแแแแแแก แฃแแ แฃแแแแแกแแงแแคแแ.
แแแแ แแช, แแ แแก แแแชแแแแแแแแก แแแฎแแแฌแแแแแ.
GPL แแแชแแแแแ แซแแ แแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแจแแ แแ แแแแแแแแแแแแ แแฎแแแแ แฆแแ แแแแแ. MIT แแ BSD แแซแแแแ แกแขแแขแแแฃแ แแแแจแแ แก แแ แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแแแแแแก แแ แแแฅแขแจแ แฉแแ แแแ. แแแแ แแ LGPL, แ แแแแ แช แฉแแแก, แแ แแฌแแแแแฆแแแแแแแ แกแขแแขแแแฃแ แแแแจแแ แก, แแแแ แแ แแแแแฎแแแก, แ แแ แแแฃแแแกแแแแก แกแแญแแ แ แคแแแแแแ แแแแแแ แแ.
แแแแแแแ, แแแแแแแฃแ แ แแแฃแแแก แแแแแงแแแแแ แฎแแแก แจแแแแจแแแ แ แแแแแก แแแฌแแแแแแกแแแ.
C/C++ แแแแแแแชแแแแแก แแแแแ
แกแฎแแแแแกแฎแแ แแแแขแคแแ แแแกแแแแก แแ แแแกแขแ แแแฃแชแแแกแแแแก C/C++ แแแแแแแชแแแแแก แแกแแแแแแ, แกแแแแแ แแกแแ แแแ แฉแแแ แแ แจแแฅแแแแ gcc-แแก แจแแกแแคแแ แแกแ แแแ แกแแ แแ แแแแแแงแแแแ แฏแแแ แแแแแ แจแแแแแแแแแแแ แแแแแ แแขแฃแแ แแ แฅแแขแแฅแขแฃแ แแกแแแแก แแ แจแแแ แแแแ แแแแแแแแแแแแแก แแแแแ แแแแ แแแ. แแก แกแแแฃแจแแ แกแแแแแแ แแแแฎแแ แชแแแแแแแแแ, แแแแ แแ แกแแแแแแ แแ แแแแแแฃแ แ. แแ แแ แแ แกแแแแแก แแแ แแแขแแ, แ แแ แจแแ แฉแแฃแแ แจแแแแแแแแแ แแ แแแแแแแแแแแแ แฃแแ แฃแแแแแงแแคแแ แจแแกแแกแ แฃแแแแแ แแแ แกแแแก.
แแจแแแ แ แฃแแแ แแขแแกแแแ: แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแแแจแแแแแแแแแ แแแแแ แขแแแแแฃแแแ, แ แแแแแ แแแแแ แแจแแแแแแแแแก แแ แแชแแกแ แจแแแซแแแแ แแแกแ แฃแแแแก แแ แ แแแแฅแแแแแ. แแแ แแ แแแแกแ, แกแแแแแ แแกแแ แจแแแแ แแแแ แแแแแ แแแแก แแ แแ แแแแ แแแ แแ แแ แแ แฅแแขแแฅแขแฃแ แแกแแแแก แแ แจแแแแซแแแแ แจแแคแฃแแแ แแกแแแ แแแแแขแแแจแ แกแฎแแแแแกแฎแแ แแแแแฌแแแแแแกแแแแก. แแกแ แแฅแแแแแ veeam แแแแแขแแแ Veeam Agent-แแกแแแแก Linux-แแกแแแแก.
แแ แแแ แแแแขแแกแแแ แแแแกแฎแแแแแแแ, แจแแแแซแแแแ แฃแแ แแแแ แแแแแแแแแ แกแแแจแแแแแแ แคแแ แแ, แแแฃ แ แแแแแแแแ แแแแฅแแแ แจแแแ แแแแกแแแแก. แแแแแแฃแแ แแกแแแ แแแแฅแแแ แฃแแ แฃแแแแแงแแคแก แแแแแชแฎแแแแก แจแแแแแแแก แแ แแแแแขแแก แจแแแ แแแแก แแแแแ แแขแฃแแ แแแแแฌแแแแแแกแ แแ แแแแแ แแขแฃแแ แแ แฅแแขแแฅแขแฃแ แแกแแแแก. แแ แจแแแแฎแแแแแจแ, แจแแแแแแ แฎแแแแ แแแกแขแ แแแฃแขแแ แแก แแแแ แแแแแแแแแฃแแ แกแแจแฃแแแแแแแแก แแแแแงแแแแแแ. แแแฃ แจแแแแแแแแแก แแแแแแแแแแกแ แแ แแแแแแแแแแแแแก แจแแ แฉแแแแก แแขแแแ แแฆแแแคแฎแแ แแแแ. แแแ แแ แแแแกแ, แแจแแแแแแแแแก แแ แแชแแกแแก แแแ แขแแแแ แแแ แแแแแแแแแ แจแแกแแซแแแแแแแ.
แแแแกแแแ, แแ แแแแแแแแก แแฅแแก แฃแแ แงแแคแแแ แแฎแแ แ: แแ แแ แแ แแแแแ แแ แฅแแขแแฅแขแฃแ แแก แคแแ แแแแแจแ แแแแแแฃแแ แแแแแฌแแแแแแกแแแแก, แแฅแแแ แแแแแฌแแแ แจแแแแ แแแแ แแแแแ แฃแแ แคแแแแแแแก แกแแแฃแแแ แ แแแแ แแแ. แแแแแ แแ แแ แแแแฃแกแ แแก แแ แแก, แ แแ แแแแฅแแแแแแก แแกแแแ แแแแ แ แแแแแแแแ แฃแแแ แแงแแก แจแแแแฎแฃแแ แแ แแแแ แ แแแแแแแแแ แแแแแแ แแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แฃแแแ แแงแแก แแแแแงแแคแแแ.
แแกแ แแ แแก แจแแแแแแแแ veeamsnap แแแ แแแแก แแแแฃแแแก KMOD แแแแแขแแแ Red Hat แแแกแขแ แแแฃแชแแแกแแแแก.
แแแฎแกแแแแ Build Service
SUSE-แก แแแแแแแแ แชแแแแแแแแแ แแแแแฎแแ แชแแแแแ แ แแแแ แกแแจแฃแแแ แแแ แกแแแชแแแแฃแ แ แกแแ แแแกแแก แกแแฎแแ แแแแแแแชแแแแแก แจแแแแแแแกแ แแ แแแแแขแแแแก แจแแแ แแแแกแแแแก -
แแ แกแแแแแแ, แแก แแ แแก แฐแแแแ แแแแแ แ, แ แแแแแแช แฅแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก, แแงแแแแแก แแแกแจแ แงแแแแ แกแแญแแ แ แแแแแขแก, แแแแแแก แแแแแแแชแแแก แแ แแจแแแแแก แแแแแขแก แแ แแแแแแ แแแฃแ แแแ แแแแจแ, แ แแก แจแแแแแแแช แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแฎแกแแแแ.
OpenBuildService-แจแ แแแแแ แแแแ แแ แแคแแแ แแแแกแแแฆแแ แแแก แ แแแแแแ แแแ แขแฃแแแฃแ แ แแแแ แแขแแก แแแจแแแแแก แจแแฃแซแแแ แแแแแขแแก แแจแแแแแแแแแก แแแขแแแแแฃแ แ แกแแฉแฅแแ แแกแแแแก. แฉแแจแแแแแฃแแ แฎแแแแแฌแแ แแก แแแฅแแแแแแ แฎแแแก แแแแฌแแ แก แแแแแขแแแก แแ แแขแแแ แแแแก แแแ แฉแแจแแแแแฃแ แกแแชแแแจแ. แฉแแจแแแแแฃแแ แแแ แกแแแก แแแแขแ แแแแก แกแแกแขแแแ แแแแแแแแก แชแแแแแแแแแแกแ แแ แแแแแแแแแแแก แแกแขแแ แแแก. แ แฉแแแ แแฎแแแแ แแฅแแแแ แฌแงแแ แแแแแก แแแแแขแแแ แแ แกแแกแขแแแแจแ. แแฅแแแ แแแแแแ แแ แแญแแ แแแแแ แกแแ แแแ แแก แแแงแแแแแ; แจแแแแซแแแแ แแแแแแงแแแแ แฆแแ.
แแฃแแชแ แแ แแก แแ แแแแแแ: แแกแแแ แแแแแแแแ แซแแแแแ แแขแแแ แแ แกแแแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ. แแแแแแแแแ, แแแ แกแแแก แแแแขแ แแแ แแ แแ แแก แกแแญแแ แ; แฉแแแ แฃแแแ แแแแฅแแก แกแแแฃแแแ แ แฌแงแแ แแก แแแแแแ. แฉแแแแ แฎแแแแแฌแแ แแก แแแฅแแแแแแ แแแแกแฎแแแแแแฃแแแ: แฉแแแ แแแงแแแแแ แกแแแชแแแแฃแ แกแแ แแแ แก. แกแแชแแแ แแกแแแ แแ แแ แแก แกแแญแแ แ.
แแแ แแ แแแแกแ, แกแฎแแ แแแกแขแ แแแฃแชแแแแแก แแฎแแ แแแญแแ แ - แแแแแแแแแ, Red Hat - แกแแแแแแ แชแฃแแแ แแ แแก แแแแฎแแ แชแแแแแแฃแแ, แ แแช แแแกแแแแแแ.
แแกแแแ แกแแ แแแกแแก แฃแแแ แแขแแกแแแ แแ แแก SUSE แแแกแขแ แแแฃแชแแแก แจแแแแแแ แแแ แกแแแก แกแฌแ แแคแ แแฎแแ แแแญแแ แ. แแแแแจแแแแแก แแคแแชแแแแฃแ แแแแแชแฎแแแแแแแแ, แจแแแ แแแแกแแแแก แกแแญแแ แ แแแแแขแแแ แแแแแแแกแแแฃแแแ แกแแฏแแ แ แกแแชแแแจแ. แแฎแแแ แแแแแฉแแแแแ OpenBuildService-แแ แแ แกแแแฃแแ แแแกแขแ แแแฃแชแแแแแก แกแแแจแ. แฉแแแ แแแแแฌแแแแ แแแแก แแ แแก แแแแขแแแ แแจแแแแแแแแแก แแแแแแก. แแแ แแแแ, แแแแแฌแแแแแแก แแฎแแแ แแแ แกแแแก แแแแแขแแแ แฎแแแแ แแแแฅแแแก แแ แแ แแแฌแแแแฃแแแแแ.
แฉแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ, OpenBuildService-แแก แแแแแงแแแแแแ, แแฌแงแแแแแแ veeamsnap แแแ แแแแก แแแแฃแแแก KMP แแแแแขแแแแก แแแแแ แแ แแแแแคแแ แแแแแแ SUSE แแแกแขแ แแแฃแชแแแกแแแแก.
แจแแแแแแ, แแกแฃแ แก แแแกแแฃแแ แ แแแ แแแแก แแแแฃแแแแแก แกแแแชแแคแแแฃแ แกแแแแแฎแแแแ.
แแแ แแแแก ABI
Linux-แแก แแแ แแแแก แแแแฃแแแแ แแกแขแแ แแฃแแแ แแแฌแแแแแแ แฌแงแแ แแก แกแแฎแแ. แคแแฅแขแแ, แ แแ แแแ แแแแก แจแแแฅแแแแแแแ แแแแก แแ แแขแแแ แแแแแ แแแ แแแแก แแแแฃแแแแแก แกแขแแแแแฃแ แ API-แก แแฎแแ แแแญแแ แแ แแ แแแแกแแแฃแแ แแแแ แแ แแแแ แแแแแแ, แ แแแแแกแแช แจแแแแแแแจแ kABI แแแแฎแกแแแแแแแ.
แแแแแแแก แแแ แแแแก แแแแฃแแแก แแกแแแแแแ, แแฃแชแแแแแแแ แแญแแ แแแแแ แแ แแแแแ แแขแฃแแ แแแ แแแแก แกแแแแฃแ แแแ แแ แแก แแแฃแจแแแแแก แแฎแแแแ แแ แแแ แแแแ.
DKMS แกแแจแฃแแแแแแก แแแซแแแแ แแแขแแแแขแแแแ แแ แแแแฃแแแแแก แแแแแแก แแ แแชแแกแ แแแ แแแแก แแแแแฎแแแแแกแแก. แจแแแแแแ, Debian แกแแชแแแแก แแแแฎแแแ แแแแแแ (แแ แแแกแ แแ แแแแแ แแแแแกแแแ) แแงแแแแแแ แแแ แแแแก แแแแฃแแแแก แแ แแแกแขแ แแแฃแขแแ แแก แกแแชแแแแแแ, แแ แจแแแแแแแ แฌแงแแ แแแแ DKMS-แแก แแแแแงแแแแแแ.
แแฃแแชแ, แแก แกแแขแฃแแชแแ แแแแกแแแฃแแ แแแแ แแ แฃแฎแแแแ Enterprise แกแแแแแแขแก. แกแแแฃแแ แแแแก แแแแแก แแแกแขแ แแแฃแขแแ แแแก แกแฃแ แ แแ แแแฃแฅแขแแก แแแแ แชแแแแแ แแแแแแแแ แแแฃแแ แแแแแ แแแแก แกแแฎแแ.
แแแแแแแกแขแ แแขแแ แแแก แแ แกแฃแ แ แแแแแแแแ แแแแก แแแกแขแ แฃแแแแขแแแแก แจแแแแ แฉแฃแแแแ แฌแแ แแแแแแก แกแแ แแแ แแแแ แฃแกแแคแ แแฎแแแแแก แแแแแแแแแก แแแแ. Enterprise Linux-แแก แแแกแขแ แแแฃแขแแ แแแแ, แ แแแแ แแชแแ Red Hat แแ SUSE, แแแแแฌแงแแแขแแก, แ แแ แแแ แจแแแซแแแ แกแขแแแแแฃแ แ kABI-แก แแฎแแ แแแญแแ แ แแแแ แแแแฎแแแ แแแแแแแกแแแแก. แจแแแแแ แแงแ KMOD แแแแแขแแแ Red Hat-แแกแแแแก แแ KMP แแแแแขแแแ SUSE-แกแแแแก.
แแ แแแแแฌแงแแแขแแก แแ แกแ แกแแแแแแ แแแ แขแแแแ. แแแแแฌแแแแแแก แแแแแ แแขแฃแแ แแแ แกแแแกแแแแก, แแแ แแแแก API แแแงแแแฃแแแ. แแแกแขแ แแแฃแขแแ แ แแชแฎแแแแแก, แ แแ แแก แแงแแแแแก แแแ แแแก, แแแแแแแแแ, 3.10, แแ แแแแแแแก แแฎแแแแ แจแแกแฌแแ แแแแแก แแ แแแฃแแฏแแแแกแแแแก, แ แแแแแแแช แแแแแแแแก แแ แแแแฎแแแแก แแแ แแแแก แแแขแแ แคแแแกแแแแ, แฎแแแ แแแ แแแแแแ แแแ แแแแกแแแแก แจแแแ แแแแแฃแแ แแแแฃแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แงแแแแ แจแแแแแแแจแ แฎแแแแฎแแแ แแแแแแแแชแแแก แแแ แแจแ.
Red Hat แแชแฎแแแแแก kABI แแแแกแแแแแแแแก แแแแแฌแแแแแแกแแแแก แแแแแ แแแกแ แกแแกแแชแแชแฎแแ แชแแแแแก แแแแแแแแแแแจแ. แแแฃ, rhel 6.0-แแก แแฌแงแแแแแ แแแแฃแแ (แแแแแจแแแแ 2010 แฌแแแก แแแแแแแ แ) แแกแแแ แฃแแแ แแฃแจแแแแแแก 6.10 แแแ แกแแแแ (แแแแแจแแแแ 2018 แฌแแแก แแแแแกแ). แแ แแก แแแแฅแแแก 8 แฌแแแแ. แแฃแแแแ แแแแ, แแก แแแแชแแแ แกแแแแแแ แ แแฃแแแ.
แฉแแแ แฉแแแฌแแ แแ แ แแแแแแแแ แจแแแแฎแแแแ, แ แแแแกแแช veeamsnap แแแแฃแแแ แจแแฌแงแแแขแ แแฃแจแแแแ kABI แแแแกแแแแแแแแก แแ แแแแแแแแแก แแแแ.
แแแก แจแแแแแ, แ แแช veeamsnap แแแแฃแแ, แจแแแแแแแแ RHEL 7.0-แแกแแแแก, แแฆแแแฉแแแ แจแแฃแแแแกแแแแแ RHEL 7.5-แแก แแแ แแแแแ, แแแแ แแ แแก แฉแแแขแแแ แแ แแ แแแ แแแขแแ แแแฃแแ แฐแฅแแแแ แกแแ แแแ แแก แแแแ แแ, แฉแแแ แกแแแ แแแ แฃแแ แ แแฅแแแ RHEL 7-แแกแแแแก kABI แแแแกแแแแแแแแก แแแแแงแแแแแแแ.
แแแแแแแ, KMOD แแแแแขแ RHEL 7-แแกแแแแก แจแแแชแแแก แแกแแแแแแแก แแแแแแฃแแ แแแแแจแแแแแก แแแ แกแแแกแแแแก แแ แกแแ แแแขแก, แ แแแแแแช แแขแแแ แแแแก แแแแฃแแก.
SUSE แฃแคแ แ แคแ แแฎแแแแ แแแฃแแฎแแแแแ kABI แแแแกแแแแแแแแก แแแแชแแแแก. แแกแแแ แฃแแ แฃแแแแแงแแคแแ kABI แแแแกแแแแแแแแก แแฎแแแแ แแ แ แกแแ แแแก แแแแแขแจแ.
แแแแแแแแแ, SLES 12-แแก แแแแแจแแแแ แแแฎแแ 2014 แฌแแแก แกแแฅแขแแแแแ แจแ. แฎแแแ SLES 12 SP1 แฃแแแ 2015 แฌแแแก แแแแแแแแ แจแ แแงแ, แแแฃ แฌแแแแฌแแแแ แชแแขแ แแแขแ แแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแ แแแ แแแแแชแแแ แแงแแแแแก 3.12 แแแ แแแก, แแกแแแ kABI แจแแฃแแแแกแแแแแแ. แชแฎแแแแ, kABI แแแแกแแแแแแแแก แจแแแแ แฉแฃแแแแ แแฎแแแแ แแ แแ แฌแแแก แแแแแแแแแแแจแ แแแแ แแ แฃแคแ แ แแแแแแแ. แแแ แแแแก แแแแฃแแแก แแแแแฎแแแแแก แฌแแแฃแ แแ แชแแแแแ แแ แฃแแแ แจแแฃแฅแแแแก แแ แแแแแแแแ แแแแฃแแแก แจแแแฅแแแแแแแก.
แแ SUSE แแแแแขแแแแก แจแแแแแแ, แฉแแแ แแ แแแแแแคแแฅแกแแ แแแแ kABI แแแแกแแแแแแแแก แแ แแแแแแ แฉแแแแก veeamsnap แแแแฃแแจแ. แแแ แแแแแ, SUSE-แกแแแแก แแแแแขแแแแก แ แแแแแแแแ แแแแฅแแแก แกแแแแแแก แแ แซแแแแแแ แแแขแแ.
แแแขแฉแแแ แแ แแฃแ แแฉแแแแแแ
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแกแขแ แแแฃแขแแ แแแ แชแแแแแแแ แฃแแ แฃแแแแแงแแ kABI แแแแกแแแแแแแ แแ แแแ แแแแก แกแขแแแแแฃแ แแแ, แแกแแแ แแกแแแ แชแแแแแแแ แแแแฃแแฏแแแแกแแ แจแแกแ แฃแแแแ แแ แแฆแแแคแฎแแ แแก แแ แกแขแแแแแฃแ แ แแแ แแแแก แแแคแแฅแขแแแ.
แแแแแแ แแฃแแแ, แกแแแฃแแแ แ โแจแแชแแแแแแแ แแฃแจแแแแแกโ แแแ แแ, แกแแฌแแ แแ Linux kernel-แแก แแแแแแแแแ แแแ แแแแแ แแแแแแ แชแแแแแแแแแก แแแแแแแก แแแ แแแจแ แแ แแแแแแฅแแ แแแ โแกแขแแแแแฃแ แแโ.
แแแแฏแแ แแก แแฌแแแแก แแฎแแแก
Red Hat 6-แแก แฃแแฎแแแก แแแแแจแแแแแจแ แจแแชแแแแ แแแฃแจแแ แแ แ-แแ แ แฃแแแแจแแแแแ แแแแแฎแแแแแจแ. แแแแ แแแแแแแ แแแ แแก แคแแฅแขแ, แ แแ veeamsnap แแแแฃแแก แแแ แแแขแแ แแแฃแแ แฐแฅแแแแ แกแแกแขแแแแก แแแแ แแ, แ แแแแกแแช แกแแแแจแแขแ แแแแแแแแ. แ แแแแกแแช แจแแแแแแ แแ แแแ แแแแก แฌแงแแ แแแแ แแแแแฎแแแแแแแ แแ แแแก แจแแแแแ, แแฆแแแแแฉแแแแ, แ แแ แฃแแแแ แแแ แขแ แแงแ แแแแแแจแแแ. แแกแแแแกแ แจแแกแฌแแ แแแ แแแแแแแ แแแแแแแก แแแ แแแแก แแแ แกแแแจแ 4.19. แฃแแ แแแแ, แแ แจแแกแฌแแ แแแแ แแแ แแแ แแแฃแจแแแ แแแแแแแก แแแ แแแจแ, แแแแ แแ "แกแขแแแแแฃแ " 2.6.32-แแ แแแแแขแแแแกแแก แแ แแแแแแ แแแฉแแแ spinlock-แแแ แแแแแแจแแ แแแแ.
แ แ แแฅแแ แฃแแแ, แจแแชแแแแแแ แงแแแแแก แแฅแแก แงแแแแแแแแก, แแแแ แแ แฆแแ แแ แแฃ แแ แ แแแแแก แแแแแขแแแ 4.19-แแแ 2.6.32-แแแ, แกแขแแแแแฃแ แแแแก แ แแกแแ?.. แแแ แฌแแฃแแแแฃแแ แแ แแแ ...
แงแแแแแแ แชแฃแแ แแก แแ แแก, แ แแชแ แแแ แแแขแแแแ แแ แแแแแ โแกแขแแแแแฃแ แแแแกโ แแ โแแแแแ แแแแแชแแแกโ แจแแ แแก แแ แซแแแแจแ. แแแ แแแขแแแแแก แแแแแ แขแแแแแขแก แกแญแแ แแแแ, แ แแ แแแแแฎแแแแฃแแ แแแกแขแ แแแฃแชแแแก แแแ แแแ แแงแแก แกแขแแแแแฃแ แ, แแ แแ แแฎแ แแ, แแ แแแแแ แแ แแก แแงแแก แฃแแแแแกแ แจแแกแ แฃแแแแแจแ แแ แฐแฅแแแแแก แแฎแแแ แคแฃแแฅแชแแแแ. แแก แแฌแแแแก แฃแชแแแฃแ แแแแแ แแแแกแแแก.
แ แแแแกแแช แแชแแแ แแแแฃแแแก แแแแแ แแแ แแแแ 4.4 SLES 12 SP3-แแแ, แแแแแแแแ แแ แแแกแจแ แแแแแแแก 4.8-แแก แคแฃแแฅแชแแแแแแแแ. แฉแแแ แแแ แแ, SLES 4.4 SP12-แแแ 3 แแแ แแแแก แแแแแแก I/O แแแแฎแแ แชแแแแแแ แฃแคแ แ แฐแแแแก 4.8 แแแ แแแก, แแแแ แ SLES4.4 SP12-แแแ แกแขแแแแแฃแ แ 2 แแแ แแแแก แฌแแแ แแแแแจแแแแ. แแ แแแ แแแแกแฏแแแแ, แแแแแก แ แ แแ แแชแแแขแ แแแแแแแแ 4.8-แแแ SLES 4.4-แแ SP3-แแกแแแแก, แแแแ แแ แแแ แแแก แแแ แช แแ แแฃแฌแแแแ แแแแแ แกแขแแแแแฃแ 4.4-แก.
แแแแจแ แงแแแแแแ แฃแกแแแแแแแ แแก แแ แแก, แ แแ แแแแฃแแแก แแแฌแแ แแกแแก, แ แแแแแแช แแ แแแแแ แแ แแแ แแแ แแแฃแจแแแแแก แกแฎแแแแแกแฎแแ แแแ แแแแ, แแแฆแแ แแแแงแ แแแแแแ แแแ แแแแก แแแ แกแแแก. แแฅแแแ แแกแแแ แฃแแแ แแแแแแแแแกแฌแแแแ แแแแแฌแแแแแ. แแแ แแแ, แ แแ แแแแฏแแ แจแแแแซแแแแ แฉแแแ แแแ แแแแกแแแฆแแ แแแแจแ, แ แแแแแแช แฉแแแแแ แแฎแแ แคแฃแแฅแชแแแแแ แแแแกแแแ แแ แแแ, แแแแ แแ แแก แจแแกแแซแแแแแแแ แงแแแแแแแแก แแ แฉแแแแแ.
แจแแแแแแ, แแแแ แแแแแขแแแ แแฃแแแ แฃแชแแแฃแ แ แแแ แแแแแ แแแแแแแแชแแแก แแแ แแฅแขแแแแแแ.
แแกแแแ แแ แแก แแแขแฉแแแ, แ แแแแแแแช แชแแแแก แแแแฃแแแแขแแ แแแฃแแ แแแ แแแแก API-แก.
แแแกแขแ แแแฃแชแแแก แฌแแแแฌแงแแ
แแแก แแแกแแแ แแแแแแ, แแแแแฌแแ แกแแ แแแขแแก แแแแแขแแแ makefile-แจแ, แ แแแแแแช แแแแฌแแแแก, แแฅแแก แแฃ แแ แ lookup_bdev แคแฃแแฅแชแแแก แแแฆแแแก แแแ แแแแขแ แ.
แแแ แแแแก แแแแฃแแแแแก แฎแแแแแฌแแ แ
แแแแ แแ แแแแฃแแ แฃแแแแ แแแแแขแแก แแแแแฌแแแแแแก แกแแแแแฎแก.
แกแขแแแแแฃแ แ kABI-แแก แแ แ-แแ แแ แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ แแแ แแแแก แแแแฃแแแแ แจแแแซแแแแ แแงแแก แฎแแแแแฌแแ แแแ, แ แแแแ แช แแแแแ แฃแแ แคแแแแ. แแ แจแแแแฎแแแแแจแ, แแแแแแแแแ แก แจแแฃแซแแแ แแแ แฌแแฃแแแแก, แ แแ แแแแฃแแ แแ แแ แแก แจแแแแฎแแแแแ แแแแแแแแแฃแแ แแ แแแแแ แแฎ แจแแชแแแแแ. แแแแก แจแแแแฌแแแแ แจแแแแซแแแแ modinfo แแ แซแแแแแแ.
Red Hat แแ SUSE แแแกแขแ แแแฃแชแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแแแแฌแแแ แแแแฃแแแก แฎแแแแแฌแแ แ แแ แฉแแขแแแ แแแ แแก แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แจแแกแแแแแแกแ แกแแ แขแแคแแแแขแ แ แแแแกแขแ แแ แแแฃแแแ แกแแกแขแแแแจแ. แกแแ แแแคแแแแขแ แแ แแก แกแแฏแแ แ แแแกแแฆแแแ, แ แแแแแแแช แแแแฃแแ แแแคแแ แแแแฃแแแ. แแแแแฌแแแแแ แชแแแแ แจแแคแฃแแแแ.
แแ แแแแแแ แแฅ แแ แแก แแก, แ แแ แกแแ แแแคแแแแขแแแ แจแแแซแแแแ แฉแแจแแแแแก แแแ แแแจแ (แแแกแขแ แแแฃแขแแ แแแ แแงแแแแแแ แแแ) แแ แฃแแแ แฉแแแฌแแ แแ EFI แแ แแกแขแแแแแฃแ แแแฎแกแแแ แแแแจแ แฃแขแแแแขแแก แแแแแงแแแแแแ. แแแแฃแขแแแ. แแแแฃแแแแฃแ แ แแแแฃแขแแแ แกแแ แแแคแแแแขแแก แแแกแขแแแแชแแแกแแก, แแก แแแแแฎแแแก แกแแกแขแแแแก แแแแแขแแแ แแแแก แแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแ แแแแก แฉแแขแแแ แแแแแแแช แแ, แแแแแแแกแขแ แแขแแ แก แกแแฎแแแก แแแฃแจแแแก แแฎแแแ แกแแ แขแแคแแแแขแแก แฉแแขแแแ แแแ.
แแแ แแแแ, แกแแ แขแแคแแแแขแแก แแแแแขแแแ แแแแแฎแแแก แคแแแแแฃแ แแแแแแแกแขแ แแขแแ แแก แฌแแแแแแก แกแแกแขแแแแจแ. แแฃ แแแแฅแแแ แแแแแแ แแแแก แกแแแแ แฆแ แฃแแแแจแ แแ แฃแแ แแแแ แกแแ แแแ แแก แแแกแขแแแชแแฃแ แแแแฎแจแ แแ แฌแแแแแ แแฎแแแแ แฅแกแแแแก แกแแจแฃแแแแแแ แแ แแก (แแแแแแแแแ, ssh-แแก แกแแจแฃแแแแแแ), แแแจแแ แจแแฃแซแแแแแแ แแฅแแแแ แกแแ แแแคแแแแขแแก แแแแแขแแแ.
EFI แแแ แขแฃแแแฃแ แแแแฅแแแแแแ
แแแแกแแ แแแฃแฎแแแแแแ, แ แแ EFI แแแแ แฎแแแแ แแฎแแ แก แฃแญแแ แก แแแแแแแแขแแแแก แแแแฅแแแก แงแแแแ แแฌแแ แแแแแแแก, แกแแกแขแแแแก แแแงแแแแแแกแแก แแแแแแแกแขแ แแขแแ แแ แจแแแซแแแแ แแ แแคแแฅแ แแก EFI-แก แกแแญแแ แแแแแแ แแ แแก แจแแแซแแแแ แแแแแ แแฃแแ แแงแแก.
แงแแแแ แฐแแแแ แแแแแ แก แแ แฃแญแแ แก แแฎแแ แก EFI. VMWare vSphere แแฎแแ แก แฃแญแแ แก EFI-แก 5 แแแ แกแแแแแ แแแฌแงแแแฃแแ.
Microsoft Hyper-V-แแ แแกแแแ แแแแแแแ EFI แแฎแแ แแแญแแ แ แแแฌแงแแแฃแแ Hyper-V-แแ Windows Server 2012R2-แแกแแแแก.
แแฃแแชแ, แแแแฃแแแกแฎแแแ แแแแคแแแฃแ แแชแแแจแ แแก แคแฃแแฅแชแแ แแแแแ แแฃแแแ Linux-แแก แแแแ แแขแแแแกแแแแก, แ แแช แแแจแแแแก, แ แแ แกแแ แขแแคแแแแขแแก แแแแแกแขแแแแ แแแ แจแแฃแซแแแแแแแ.
vSphere 6.5-แจแ แแแแงแแแแ แแแ แแแแขแ แฃแกแแคแ แแฎแ แฉแแขแแแ แแแแกแแก แจแแกแแซแแแแแแแ แแฎแแแแ แแแ แแแขแแ แคแแแกแแก แซแแแ แแแ แกแแแจแ, แ แแแแแแช แแฃแจแแแแก Flash-แแก แกแแจแฃแแแแแแ. แแแ UI HTML-5-แแ แฏแแ แแแแแ แฉแแแแ แฉแแแ.
แแฅแกแแแ แแแแแขแฃแแ แแแแแฌแแแแแแแ
แแ แแแแแก, แแแแแ แแแแแแฎแแแแ แแฅแกแแแ แแแแแขแฃแแ แแแแแฌแแแแแแกแ แแ แแแแแฌแแแแแแก แกแแแแแฎแ แแคแแชแแแแฃแ แ แแฎแแ แแแญแแ แแก แแแ แแจแ. แแ แแแก แแฎแ แแ, แแกแแแ แแแกแขแ แแแฃแชแแแแ แแแแแแแแ แกแแแแ แแฃแแแ, แ แแ แแแแซแแแแแก แกแแ แแแแฃแแ แแ แแแแแแแชแแแแแก แกแแ แแแ แแแแ. แแ แแ แกแแแแแก แแคแแชแแแแฃแ แ แแฎแแ แแแญแแ แ แแกแแแ แแแแแฌแแแแแแกแแแแก. แแแแขแแ, แแแแฌแแแแ แแกแแแ. แแ แแแฃแฅแขแ แแ แจแแแซแแแแ แแงแแก แแฎแแ แแแญแแ แแแ แแกแแ แแแแแฌแแแแแแแ.
แแฃแแชแ, แแกแแแ แแแกแขแ แแแฃแชแแแแ แฎแแแแ แแแกแแฎแแ แฎแแแแแ แแแแขแคแแ แแ แแฎแแแ แแฅแกแแแ แแแแแขแฃแแ แแแแแฌแงแแแขแแแแแแแแก แแแแแกแแชแแแแแ. แแแแแแแแแ, Fedora, OpenSUSE Tumbleweed แแ Debian-แแก แแ แแกแขแแแแแฃแ แ แแแ แกแแแแ. แแกแแแ แกแแแแแแ แกแขแแแแแฃแ แแแ แแ แแแ. แแแ แงแแแแแแแแก แแฅแแ แแ แแแ แแแแแแก แแฎแแแ แแแ แกแแแแ แแ แงแแแแแแแแก แแฎแแแ แแแ แแแ. แแ แแ แฌแแแก แจแแแแแ, แแก แแฅแกแแแ แแแแแขแฃแแ แคแฃแแฅแชแแ แจแแแซแแแแ แแแกแ แฃแแแแก แแแแแฎแแแแฃแ RHEL, SLES แแ Ubuntu-แจแ.
แแกแ แ แแ, แแฃ แ แแแ แแ แแฃแจแแแแก แแฅแกแแแ แแแแแขแฃแ แแแแแฌแแแแแแแ, แแก แแ แแก แแ แแแแแแแก แแแ แแแแแแกแ แแ แแแกแ แแแแแญแ แแก แแแแแแ. แแฅแแแ แฃแแแ แแแแแแแแแ แแแแกแแแแก, แ แแ แแก แคแฃแแฅแชแแ แแแแ แแแแแฉแแแแแ แแแแฎแแแ แแแแแแแก แฌแแ แแแแแแก แกแแ แแแ แแแแ.
แแฅแแแ แจแแแแซแแแแ แจแแแกแฌแแแแแ แแคแแชแแแแฃแ แแ แแฎแแ แแแญแแ แแแ แแแกแขแ แแแฃแชแแแแแก แกแแ 3.0 แแแ แกแแแกแแแแก
แแแ แแแแ แแ แแแแแขแแ แแกแแแแ Elbrus OS-แแก แแฅแกแแแ แแแแแขแ. Veeam-แแก แแแแแขแแก แแแกแ แฃแแแแแก แจแแแแแ แฉแแแแ แแ แแแฃแฅแขแ แแแแแแขแแแแ แแ แแฃแจแแแแแ. แแ แแแแฌแแ แ แแ แแฅแกแแแ แแแแแขแแก แจแแกแแฎแแ แฐแแแ แแแ
แแกแ, แแฎแแแ แแแกแขแ แแแฃแชแแแแแก แแฎแแ แแแญแแ แ แแ แซแแแแแแ. แแแแแแแแแ 4.0 แแแ แกแแแก แแแแแจแแแแแก. แแแขแ แแแแ แแแแแฉแแแแแ, แแกแ แ แแ แแแแแ แแแแแแแ
แฌแงแแ แ: www.habr.com