- Nagdadala ang Rust ng kaligtasan sa memorya sa Linux kernel, ngunit nagpapakilala ito ng mga bagong dependency at pinapataas ang pagiging kumplikado ng toolchain.
- Ang integrasyon ng Rust ay nagdulot ng matinding pagkakawatak-watak sa komunidad, kasama ang mga pagbibitiw at mga akusasyon ng pagsabotahe sa pagitan ng mga tagapagtanggol ng C at mga pro-Rust.
- Nanatili ang mga teknikal at organisasyonal na disbentaha: ang pangangailangang sundin ang mga bagong compiler, mga salungatan sa mga patakaran sa mga duplicate na driver, at mga hamon sa pagpapanatili sa isang higante, karamihan ay nakabatay sa C-kernel.

Ang pagdating ng Rust sa Linux kernel ay hindi naging mapayapa. Sa loob ng ilang buwan, ang komunidad ng kernel ay nasa gitna ng isang tunay na bagyo , na may mga pampublikong argumento, mga kilalang pagbibitiw, at mga akusasyon ng isang boycott na mas maituturing na isang serye ng drama kaysa isang libreng proyekto ng software. Ang nagsimula bilang isang "eksperimento" upang ipakilala ang isang wikang ligtas sa memorya sa puso ng Linux ay nauwi sa pagbubukas ng malalim na agwat sa pagitan ng mga nagtatanggol sa monolinggwalismo sa C at ng mga nakakita sa paglukso sa isang mas modernong wika bilang mahalaga.
Ibang-iba na ang sitwasyon ngayon: Opisyal nang tumigil sa pagiging eksperimental ang Rust at itinuturing na ngayong pangunahing bahagi ng kernel . Gayunpaman, ang pagkapanalo sa labanang ito ay hindi nangangahulugang puro kalamangan na lang. Ang integrasyon ng Rust sa Linux 6.x ay nagbunyag ng mga teknikal na hamon, tensyong pampulitika sa loob ng proyekto, at mga pagdududa tungkol sa pangmatagalang epekto nito, lalo na tungkol sa mga aspeto tulad ng katatagan, pagiging tugma, at ang tradisyonal na pamamaraan sa pagbuo ng kernel.
Mula sa kontrobersyal na eksperimento hanggang sa opisyal na wika ng kernel
Ang mahalagang punto ay dumating sa Maintainers Summit , ang taunang pagpupulong kung saan nagtitipon ang mga pangunahing developer ng kernel upang magpasya sa teknikal na direksyon ng proyekto. Doon, pagkatapos ng ilang buwan ng mainit na debate, napagkasunduan na tanggalin ang "eksperimentong" label ng Rust mula sa pangunahing Linux kernel, na ginagawa itong isang primera klaseng wika kasama ng C. Ang desisyong ito ay nagsasara ng pinto, kahit man lang sa maikli at katamtamang termino, sa mga humihiling ng pag-alis ng Rust at ng isang kernel na eksklusibong nakabatay sa C.
Ang mga unang hakbang patungo sa pagsuporta sa Rust sa kernel ay nagsimula mga tatlong taon na ang nakalilipas . Simula noon, ang maliliit na bloke ng code ay isinama, pangunahin na sa anyo ng mga bagong driver at medyo nakahiwalay na mga bahagi. Sa panahong iyon, ang label na "pang-eksperimento" ay nagsilbing isang uri ng lambat ng kaligtasan: pinapayagan nito ang pagsubok sa Rust nang hindi lubos na nangangakong panatilihin ito nang walang hanggan, isang bagay na itinaguyod ng ilang beteranong developer bilang maingat.
Gayunpaman, ang komunidad ay nahati sa dalawang malinaw na magkasalungat na kampo : sa isang banda, iyong mga nakakita sa Rust bilang banta sa katatagan, pagkakapare-pareho ng code, at konserbatibong pilosopiya ng kernel; sa kabilang banda, iyong mga iginiit na ang kinabukasan ng seguridad ay nakasalalay sa pag-abandona sa eksklusibong paggamit ng mga wikang walang seguridad sa memorya tulad ng C at C++. Ang pagkakahating ito ay umabot sa isang personal na antas kaya inilarawan ng ilang kasangkot ang kapaligiran bilang "halos relihiyoso."
Si Linus Torvalds, na tradisyonal na maingat sa mga radikal na pagbabago , ay nagpakita ng ilang pag-aalinlangan sa simula, lalo na tungkol sa mga pangako ng Rust sa seguridad at mga potensyal na epekto sa pagganap. Gayunpaman, kalaunan ay binigyan niya ng berdeng ilaw ang integrasyon sa ilalim ng isang serye ng mga patakaran at limitasyon, na may ideya na subukan sa pagsasagawa kung gaano kalayo ang maaari nitong maabot nang hindi nakompromiso ang pag-uugali ng kernel.

Isang panloob na tunggalian na may kasamang pagbibitiw, pag-alis sa trabaho, at mga akusasyon ng sabotahe
Ang kontrobersiya na nakapalibot sa Rust in the kernel ay hindi nanatiling isang magalang na teknikal na hindi pagkakasundo . Ilang mahahalagang tao sa proyekto, lalo na ang mga nasa panig ng pro-Rust, ay nabigla sa kanilang inilarawan bilang isang patuloy na digmaan laban sa kritisismo na walang kinalaman sa mismong kodigo, kundi sa mga ideolohikal na posisyon o sa historikal na inersiya ng proyekto.
Si Miguel Ojeda, isang Espanyol na inhinyero at pangunahing puwersang nagtutulak sa likod ng Rust for Linux , ang siyang pinakanakikitang mukha ng pagsisikap na ito. Mula sa simula ng proyekto, pinangunahan niya ang integrasyon, pinag-ugnay ang mga patch, at tinalakay ang mga panukala kasama ang iba pang mga tagapanatili. Sa kasalukuyan, siya lamang ang pormal na tagapanatili ng Rust for Linux, na sinusuportahan ng mga tagasuri, matapos magpasya ang iba pang mahahalagang kontribyutor na huminto dahil sa pagkapagod at pagkadismaya.
Si Wedson Almeida Filho, isang inhinyero ng Microsoft at isa sa mga pinakamalaking tagapagtaguyod ng Rust para sa kernel , ay nagbitiw sa proyekto noong 2023. Sa kanyang pamamaalam na mensahe sa mailing list ng kernel, ipinaliwanag niya na pagkatapos ng halos apat na taon ng paglahok, wala na siyang lakas o pagnanais na patuloy na harapin ang tinatawag niyang "hindi teknikal na ingay" at "kalokohan" na walang kaugnayan sa merito ng code. Mas pinili niyang ipasa ang sulo sa iba na mayroon pa ring sigasig na patuloy na lumaban.
Itinampok ng kanyang pag-alis kung gaano naging nakakalason ang kapaligiran para sa ilan sa kampo ng mga pro-Rust . Iginiit ni Wedson na ang mga kernel sa hinaharap ay dapat na isulat sa mga wikang ligtas sa memorya, at nagbabala na kung hindi gagawin ng Linux ang transisyon na ito, maaaring palitan ito ng ibang kernel, tulad ng dating pag-alis ng Linux sa Unix sa maraming lugar.
Nakadagdag pa sa emosyonal na pasanin ng mga pagbibitiw ang isang mas maselang pangyayari : mga akusasyon ng panloob na pagsabotahe. Ang mga developer tulad ni Hector Martin (kilala sa kanyang trabaho sa Asahi Linux, ang proyektong nagpo-port ng Linux sa mga chip ng Apple) ay hayagang itinuro ang ilang beteranong tagapangalaga, tulad ni Christoph Hellwig, bilang sadyang humahadlang sa integrasyon ng Rust. May mga paratang ng pagtanggi sa mga kritikal na patch, patuloy na paglikha ng mga balakid, at pagsisikap na hayaang matapos ang pagsisikap dahil sa pagkapagod.
Tinawag pa nga ni Hellwig ang inisyatibo ni Rust sa kernel bilang isang "kanser ," isang pahayag na lalong nagpaalab ng mga damdamin at sumisimbolo sa umiiral na polarisasyon. Para sa ilan, ang Rust ay isang hindi kinakailangang panghihimasok sa isang ecosystem na, sa kabila ng mga pagkukulang nito, ay gumagana na sa loob ng mga dekada; para sa iba, ang paglaban na ito ay katumbas ng pagtanggi sa isang ebolusyon na itinuturing nilang mahalaga sa pagpapalakas ng seguridad ng isang kritikal na bahagi tulad ng kernel.
Bakit nanalo ang Rust: maaasahang memorya, modernidad, at apela sa mga bagong developer
Sa kabila ng unang kontrobersiya, sa huli ay nanaig ang Rust dahil sa mga teknikal na katangian nito . Ang pangunahing kalakasan nito ay nakasalalay sa kaligtasan ng memorya na nakapaloob sa disenyo ng wika mismo: ang sistema ng paghiram, kontrol sa pagmamay-ari, at mahigpit na compiler ay nagpapahirap sa pagpapakilala ng mga buffer overflow, dobleng paglabas ng memorya, o pag-access sa mga nakalawit na pointer—pawang mga karaniwang panganib sa C.
Pinatitibay ng datos na iniharap sa mga kumperensya tulad ng 2019 Linux Security Summit ang argumentong ito: ipinahiwatig ng mga pagsusuring isinagawa ng mga developer tulad nina Alex Gaynor at Geoffrey Thomas na halos dalawang-katlo ng mga kahinaan sa seguridad ng Linux ay nagmumula sa mga error sa pamamahala ng memorya, na nagmumula sa mga likas na kahinaan ng C at C++. Nangangako ang Rust na lubos na mababawasan ang mga ganitong uri ng depekto sa pamamagitan ng pagpapatupad ng mas ligtas na mga pattern ng pag-access mula sa loob mismo ng API at sa oras ng pag-compile.
Maikling binuod ni Wedson Almeida Filho ang argumento pabor sa Rust sa pamamagitan ng pagsasabing handa na ang wikang ito na makibahagi sa atensyon ng C sa pagbuo ng kernel, na nakakatulong upang mabawasan ang bilang ng mga bug at kahinaan sa seguridad sa privileged code nang hindi isinasakripisyo ang pagganap. Ang ideya ay hindi ang muling isulat ang lahat ng Linux, kundi ang pagsasama ng mga bagong kritikal na bahagi sa Rust upang mabawasan ang mga pag-atake sa hinaharap.
Higit pa sa seguridad, ang Rust ay nag-aalok ng estratehikong apela sa ecosystem ng Linux . Maraming mga kumpanya ng teknolohiya ang nakikita ito bilang isang moderno, produktibo, at mas madaling gamitin na wika para sa mga mas batang developer. Ang pagsasama nito sa kernel ay ginagawang mas kaakit-akit na proyekto ang Linux para sa mga nagprograma na sa Rust o gustong matutunan ito sa isang high-impact na kapaligiran, na makakatulong na mabago ang base ng mga kontribyutor gamit ang mas magkakaibang mga profile. Upang mas maunawaan ang kaugnayan ng proyekto sa loob ng landscape na ito, matuto nang higit pa tungkol sa ecosystem ng Linux.
Ang mga kompanyang tulad ng Cisco, Samsung, at Canonical ay tahasang nagpahayag ng kanilang suporta para sa pagkahinog ng Rust sa kernel. Para sa mga manlalarong ito, ang posibilidad ng pagsasama-sama ng pagganap at kalapitan ng hardware ng C kasama ang pagiging maaasahan ng Rust ay nagbubukas ng isang kaakit-akit na landas sa pagbuo ng mga driver at subsystem na hindi gaanong madaling kapitan ng mga mapaminsalang error, nang hindi kinakailangang iwanan ang Linux bilang kanilang pangunahing plataporma.
Ang mga teknikal na kawalan ng Rust sa Linux kernel
Ang pangako ng Rust ng pinahusay na seguridad ay hindi nangangahulugang walang mga disbentaha ang pag-aampon nito sa kernel . Sa katunayan, karamihan sa panloob na pagtutol ay nagmumula sa mga lehitimong teknikal na alalahanin at sa paraan ng pakikipag-ugnayan ng Rust sa isang napakalaking codebase, na karamihan ay nakasulat sa C, na may halos tatlo at kalahating dekada ng kasaysayan at sampu-sampung milyong linya.
Isa sa mga pinakamaselang punto ay ang pagdepende sa mga pinakabagong bersyon ng Rust compiler . Mabilis na umuunlad ang proyektong Rust, na may agresibong release cadence at mga tampok na kadalasang nagsisimula bilang hindi matatag ("gabi-gabi") bago maging ganap na gumagana. Ang integrasyon sa kernel ay nagtutulak sa maraming developer na mahigpit na sundan ang kasalukuyang bersyon ng compiler, isang bagay na sumasalungat sa tradisyonal na pilosopiya ng Linux, na mas gustong umasa sa mga lubos na mature at konserbatibong tool.
Ang pangangailangang ito na makasabay sa compiler ay nagtataas ng mga alalahanin tungkol sa katatagan at backward compatibility . Nag-aalala ang ilang miyembro ng kernel team na ang mga feature ng language o standard library na ang availability sa hinaharap ay hindi ganap na ginagarantiyahan ay gagamitin, na posibleng magkompromiso sa pangmatagalang pagpapanatili. Sa isang proyekto na ang code ay maaaring mabuhay nang mga dekada, ang pag-asa sa mga kritikal na bahagi na may mga elementong maaaring magbago ay tinitingnan nang may hinala, kung tutuusin.
Isa pang punto ng pagtatalo ay ang kahilingan na palawigin ang suporta ng Rust sa mga bersyon ng kernel ng LTS . Maraming kumpanya ang umaasa sa mga pinalawak na sangay ng suporta at labis na maingat sa pagpapakilala ng mga bagong teknolohiya sa kanilang mga codebase. Ang patakaran ng Kernel sa pangkalahatan ay hindi hinihikayat ang napakalaking backport ng mga bagong tampok, at ang Rust ay hindi eksepsiyon. Gayunpaman, may ilang mga tinig na nagtutulak na palawigin din ang suportang ito sa mga bersyong ito, na nagdaragdag ng karagdagang organisasyonal at teknikal na pagiging kumplikado.
Sa purong teknikal na antas sa loob ng kernel, lumitaw din ang mga partikular na hamon . Isa sa mga pinakamadalas na nabanggit ay may kaugnayan sa mga deadlock: mga sitwasyon kung saan dalawa o higit pang mga proseso ang natigil sa paghihintay sa isa't isa, na pumipigil sa sistema na umunlad. Bagama't maaaring ituring ng Rust ang ilang mga pattern na ligtas mula sa isang pananaw ng wika (nang walang hindi natukoy na pag-uugali), hindi ito nagpapahiwatig ng kanilang katanggap-tanggap sa loob ng konteksto ng pag-synchronize ng Linux kernel. Nangangailangan ito ng masusing pagsusuri kung paano idinisenyo ang mga concurrency primitive at abstraction.
Pagsalungat sa mga patakaran sa pagbuo ng kernel: mga dobleng driver at hindi kumpletong mga abstraksyon
Ang integrasyon ng Rust ay nagpahirap din sa ilang hindi nakasulat—at ilang mahusay na nakasulat—na mga tuntunin ng proyekto . Isa sa mga tradisyunal na tuntunin ng pagbuo ng kernel ay ang pag-iwas sa mga duplikadong driver na halos pareho lang ang ginagawa, maliban sa mga makatwirang pambihirang kaso. Nilalayon ng patakarang ito na mabawasan ang paulit-ulit na pagpapanatili at mabawasan ang kalituhan para sa mga gumagamit at distributor.
Gayunpaman, maraming developer na interesado sa pag-eksperimento sa Rust ang nagpakita ng kahandaang bahagyang lumabag sa panuntunang ito . Ang kanilang ideya ay magpatupad ng mga bagong driver sa Rust, kahit na mayroon nang mga mature na katumbas ng C, na may layuning subukan ang mga pattern, sukatin ang pagganap, patunayan ang mga abstraksyon, at tuklasin ang mga potensyal na problema sa integrasyon. Ang eksperimental na pamamaraang ito ay kinabibilangan ng pagharap sa mga kaso kung saan mayroong dalawang magkaibang driver para sa parehong hardware o functionality, isang bagay na itinuturing ng maraming maintainer na hindi kanais-nais.
Bahagi ng tensyong ito ay nagmumula sa katotohanang ang abstraction layer na kailangan para magsulat ng mga Rust driver ay hindi pa ganap na natukoy . Kulang ang mga matatag at mahusay na dokumentadong API na magpapahintulot sa mga developer na magtrabaho sa Rust nang direkta at may parehong kontrol na mayroon sila sa C sa loob ng mga dekada. Hanggang sa maging ganap na maayos ang mga abstraksyong ito, malamang na patuloy na kakailanganin ang mga eksepsiyon o ad hoc na solusyon, na sumasalungat sa karaniwang disiplina ng proyekto.
Ang sitwasyong ito ang nagtulak sa pangkat ng Rust for Linux, sa pangunguna ni Miguel Ojeda , na humiling ng mga tahasang eksepsiyon sa mga patakaran laban sa pagdoble ng mga driver. Bagama't mauunawaan ang motibasyon—ang paggalugad sa mga kakayahan ng wika sa isang totoong kapaligiran—ang bawat naturang eksepsiyon ay nagdaragdag ng presyon sa proseso ng pagsusuri ng kernel at mga pangmatagalang pagsisikap sa pagpapanatili, na isa sa mga puntong pinakakinababahala ng mga kritiko nito.
Ang resulta ay isang walang katiyakang balanse sa pagitan ng inobasyon at konserbatismo : sa isang banda, mayroong malinaw na pagnanais na gamitin ang Rust upang subukan ang mga bagong ideya at pagbutihin ang seguridad; sa kabilang banda, mayroong takot na masira ang mga prinsipyong nagpapahintulot sa kernel na manatiling mapapamahalaan sa kabila ng kasalukuyang laki at kasalimuotan nito.
Toolchain at karagdagang teknolohikal na pagdepende
Isa pang hanay ng mga disbentaha ang nagmumula sa dagdag na pagiging kumplikado sa toolchain . Ang kernel ay palaging mayroong napakalakas na pagdepende sa GCC, ngunit sa paglipas ng panahon ay nabuksan ito sa Clang/LLVM. Ang pagdating ng Rust ay nagpapakilala ng mga bagong bahagi na kailangan ding isaalang-alang, mapanatili, at ma-audit, na nagpapataas ng potensyal na pagkabigo sa imprastraktura ng pagbuo.
Sa kontekstong ito, maraming komplementaryong proyekto ang namumukod-tangi , tulad ng GCC code generator para sa rustc, isang GCC frontend para sa Rust na nasa alpha pa rin, at isang port ng Coccinelle—ang tool na ginagamit upang magsagawa ng awtomatikong pagbabago ng C code sa kernel—na inangkop sa katutubong wika ng Mozilla. Ang bawat isa sa mga piyesang ito ay may kanya-kanyang development cycle at mga potensyal na bug, na nagdaragdag sa kawalan ng katiyakan.
Ang pag-asa sa mga medyo bagong bahagi ay maaaring maging abala para sa isang proyekto na karaniwang mas gustong umasa sa mga tool na napatunayan na sa loob ng maraming taon o kahit dekada. Anumang mga pagbabago sa rustc, sa mga karaniwang library, o sa mga integrasyon sa GCC at Clang ay maaaring direktang makaapekto sa kakayahang i-compile ang kernel o sa kalidad ng nabuong code, na mangangailangan ng patuloy na pagsubaybay.
Kasabay nito, dapat isaalang-alang ang dami ng kaalamang kaakibat nito . Hindi lahat ng kernel developer ay handang maging pamilyar sa mga masalimuot na detalye ng Rust compiler, mga flag nito, mga support cycle nito, o mga kaugnay na tool. Ang kakulangan sa kaalamang ito ay maaaring maging isang praktikal na balakid kapag sinusuri ang mga patch, nag-diagnose ng mga bug, o nagpapanatili ng code na, sa maraming pagkakataon, ay isinulat ng iba.
Mga limitasyon sa istruktura: isang napakalaking kernel na karamihan ay nasa C
Kahit ang pinakamasigasig na tagapagtaguyod ng Rust ay kinikilala na ang muling pagsusulat ng kernel sa wikang ito ay hindi makatotohanan sa maikli hanggang katamtamang termino . Pagsapit ng 2022, ang kernel code ay tinatayang nasa humigit-kumulang 28 milyong linya, ang karamihan ay nakasulat sa C. Ang malawakang pagbabago sa teknolohikal na pundasyong iyon ay hindi lamang mangangailangan ng napakalaking pagsisikap kundi magdudulot din ng napakalaking panganib.
Sa pagsasagawa, ang Rust ay ipinakikilala nang paunti-unti at sa medyo limitadong mga lugar , lalo na sa mga bagong driver at component kung saan mas malaki ang isolation. Nangangahulugan ito na sa loob ng maraming taon, marahil mga dekada, ang kernel ay magiging bilingguwal, kung saan ang mga bahagi ay nakasulat sa C at ang iba ay sa Rust ay magkakasamang magkakasama at magtutulungan. Ang pagkakasamang ito ay may sariling mga komplikasyon: dapat tukuyin ang malinaw na mga interface, dapat tiyakin ang mga matatag na ABI, at dapat bigyang-pansin ang interaksyon sa pagitan ng code mula sa parehong wika.
Mula sa perspektibo ng pagpapanatili, ang bilingguwalismong ito ay nagdudulot ng mga bagong pangangailangan . Kakailanganing magpasya ng mga tagasuri at tagapanatili kung aling mga snippet ng code ang katanggap-tanggap sa Rust, kung sino ang mananagot para sa mga ito kapag umalis ang kanilang mga orihinal na may-akda, at kung paano hahawakan ang mga refactoring na nakakaapekto sa mga hybrid na lugar. Sa isang proyekto na may patuloy na pagpapalit ng mga kontribyutor, ang labis na pag-asa sa mga partikular na espesyalista ay maaaring maging isang mapagkukunan ng kahinaan.
Bukod pa rito, ang laki ng kernel ay nagpapabagal sa anumang paradigm shift . Bagama't lubos na pinapabuti ng Rust ang seguridad ng bagong code na isinulat para dito, ang karamihan sa mga kahinaan ay mananatili sa umiiral na C code sa mahabang panahon. Medyo nililimitahan nito ang aktwal na epekto ng Rust sa pangkalahatang seguridad ng sistema, kahit man lang sa maikling panahon.
Mayroon ding mga hindi direktang implikasyon para sa ecosystem . Kakailanganing tiyakin ng mga distribution, tagagawa ng hardware, at mga proyektong may kaugnayan sa kernel na handa na ang kanilang imprastraktura upang mag-compile at sumubok ng mga variant ng kernel gamit ang Rust. Ang lahat ng ito ay nagdaragdag ng trabaho sa isang komplikado nang value chain.
Epekto sa komunidad at kultura: mula sa digmaang C vs Rust hanggang sa kinabukasan ng kernel
Higit pa sa mga teknikal na aspeto, ang kasaysayan ng Rust sa Linux ay isang pag-aaway ng kultura sa loob ng komunidad . Sa loob ng maraming taon, maraming tao ang nakiisa sa tradisyonal na paraan ng pagbuo ng kernel: C, mga pangunahing kagamitan, isang konserbatibong kaisipan, at mahigpit na mga tuntunin sa pagsusuri. Ang pagpapakilala ng isang modernong wika, na may ibang pilosopiya, ay nagdulot ng mga pangamba sa pagkawala ng pagkakakilanlan at pagpapahina ng disiplina na nagtaguyod sa proyekto.
Ang tinaguriang "digmaang sibil" sa pagitan ng purong paksyong C at ng paksyong pro-Rust ay nag-iwan ng mga personal na sugat: mga pagbibitiw, mga pampublikong alitan, masasakit na email sa mga mailing list, at mga seryosong akusasyon. Kinailangang makialam si Linus Torvalds upang magtatag ng ilang pangunahing alituntunin at payagan ang pagsasama ng Rust sa mga kondisyon, na medyo nagpagaan ng mga tensyon, kahit pansamantala lamang.
Sa kabila ng alitan, ang kernel ay pumasok na sa isang yugto ng opisyal na bilingguwalismo : Ang C ay nananatili, at magpapatuloy na maging sa loob ng maraming taon, ang pangunahing wika, ngunit ang Rust ay nakaukit na ng sarili nitong lehitimong angkop na lugar. Ang mga bagong driver at pangunahing bahagi ay maaaring isulat sa Rust na may pormal na suporta sa proyekto, na nagbubukas ng daan para sa isang bagong henerasyon ng mga maintainer na lumitaw gamit ang wikang ito bilang kanilang pangunahing kagamitan.
Kasabay nito, nagkaroon ng malay na pagsisikap na gawing mas kaakit-akit ang Linux sa mga nakababatang developer o sa mga hindi gaanong pamilyar sa mga masalimuot na detalye ng low-level na C. Ang Rust, kasama ang modernong ecosystem, mga tool sa pamamahala ng dependency, at aktibong komunidad, ay maaaring magsilbing tulay para sa mga maaaring mag-atubiling sumisid sa kernel code.
Sa huli, ang pakikisama ng C at Rust sa kernel ay magiging isang patuloy na pagbabalanse : paggamit ng mga bentahe sa seguridad at modernidad nang hindi isinasakripisyo ang katatagan, pagganap, o ang mga kasanayan na naging dahilan upang ang Linux kernel ang maging puso ng pinakamalawak na ginagamit na operating system sa planeta, sa mga server, mobile device, at lahat ng uri ng iba pang kagamitan. Ang mga kasalukuyang disbentaha—pagdepende sa mga mas bagong tool, alitan sa mga panloob na pamantayan, karagdagang pasanin sa pagpapanatili, at mga salungatan sa kultura—ang siyang kapalit ng paggalugad sa landas na ito, at nananatiling makikita kung hanggang saan ang balanse ay malinaw na hahantong sa isang modelo kung saan ang mga wikang ligtas sa memorya ay tunay na magiging sentro ng atensyon.
Kung isasaalang-alang ang lahat ng kontekstong ito, ang pag-aampon ng Rust sa Linux kernel ay pinakamahusay na mauunawaan bilang isang mahaba at kumplikadong transisyon na pinagsasama ang mga halatang benepisyo sa seguridad na may nasasalat na mga gastos sa pagiging kumplikado, pamamahala, at kultura ng proyekto; isang sugal na, bagama't mula sa eksperimento ay naging opisyal na realidad, ay patuloy na lilikha ng talakayan habang lumalaki ang Rust code sa loob ng dagat ng C na nangingibabaw pa rin sa puso ng Linux.
Talatuntunan
- 1 Mula sa kontrobersyal na eksperimento hanggang sa opisyal na wika ng kernel
- 2 Isang panloob na tunggalian na may kasamang pagbibitiw, pag-alis sa trabaho, at mga akusasyon ng sabotahe
- 3 Bakit nanalo ang Rust: maaasahang memorya, modernidad, at apela sa mga bagong developer
- 4 Ang mga teknikal na kawalan ng Rust sa Linux kernel
- 5 Pagsalungat sa mga patakaran sa pagbuo ng kernel: mga dobleng driver at hindi kumpletong mga abstraksyon
- 6 Toolchain at karagdagang teknolohikal na pagdepende
- 7 Mga limitasyon sa istruktura: isang napakalaking kernel na karamihan ay nasa C
- 8 Epekto sa komunidad at kultura: mula sa digmaang C vs Rust hanggang sa kinabukasan ng kernel