Neden / dev / null bir dosyadır? Neden işlevi basit bir program olarak uygulanmıyor?

Linux'taki özel dosyalar kavramını anlamaya çalışıyorum. Bununla birlikte, özel bir dosyaya sahip /devolmak, işlevi C'deki bir dizi satır tarafından bilgime göre uygulanabileceği zaman aptalca görünüyor.

Üstelik hemen hemen aynı şekilde kullanabilirsiniz, yani nullyönlendirmek yerine boruya kullanabilirsiniz /dev/null. Dosya olarak sahip olmanın belirli bir nedeni var mı? Dosya yapmak, aynı dosyaya erişen çok fazla program gibi birçok soruna neden olmaz mı?

Karaktere özel bir cihaz kullanmanın performans yararlarına ek olarak, birincil yarar modülerliktir . / dev / null, sadece kabuk boru hatlarında değil, bir dosyanın beklendiği hemen her bağlamda kullanılabilir. Dosyaları komut satırı parametreleri olarak kabul eden programları göz önünde bulundurun.

# We don't care about log output.
$ frobify --log-file=/dev/null

# We are not interested in the compiled binary, just seeing if there are errors.
$ gcc foo.c -o /dev/null  || echo "foo.c does not compile!".

# Easy way to force an empty list of exceptions.
$ start_firewall --exception_list=/dev/null

Tüm bunlar, bir programın kaynak veya lavabo olarak kullanılmasının çok hantal olacağı durumlardır. Kabuk boru hattı durumunda bile, stdout ve stderr dosyalara bağımsız olarak yönlendirilebilir, bu da çalıştırılabilirlerle batarya olarak yapılması zor bir şeydir:

# Suppress errors, but print output.
$ grep foo * 2>/dev/null

Adalet içinde, normal bir dosya değildir; Bir var bir karakter özel bir cihaz :

$ file /dev/null
/dev/null: character special (3/2)

Bir dosya veya programdan ziyade bir cihaz olarak işlev görür, standart girdi / çıktı / hata da dahil olmak üzere herhangi bir dosya tanımlayıcısına eklenebileceği için girişi doğrudan ona yönlendirmek veya çıktı almak anlamına gelir.

Sanıyorum neden Unix (ve dolayısıyla Linux) şeklindeki vizyon / tasarım ile ne çok şey vardır ve avantajları ondan kaynaklanan.

Hiç şüphe yok ki, fazladan bir süreci döndürmemek için ihmal edilemez bir performans avantajı var, ama bence daha fazlası var: Early Unix, bakarsanız bariz olmayan ama zarif bir avantaja sahip olan "her şey bir dosyadır" metaforuna sahipti. kabuk komut dosyası perspektifi yerine sistem açısından.

nullKomut satırı programınız ve /dev/nullcihaz düğümünüz olduğunu söyleyin . Kabuk-komut dosyası bakış açısına göre, foo | nullprogram aslında gerçekten yararlı ve kullanışlı ve yazmak foo >/dev/nullbiraz daha uzun sürüyor ve garip görünebilir.

Ama işte iki alıştırma:

1. Programını uygulamak edelim nullmevcut Unix araçları ve kullanma /dev/null- kolay: cat >/dev/null. Bitti.

2. /dev/nullAçısından uygulayabilir misiniz null?

Girdiyi atmak için C kodunun önemsiz olduğu konusunda kesinlikle haklısınız, bu nedenle görev için uygun bir sanal dosya bulundurmanın neden yararlı olduğu henüz belli olmayabilir .

Şunu düşünün: hemen hemen her programlama dili zaten dosyalarla, dosya tanımlayıcılarıyla ve dosya yollarıyla çalışmak zorunda, çünkü bunlar Unix'in “her şey bir dosyadır” paradigmasının bir parçasıydı.

Eğer sahip olduğunuz tek şey stdout'a yazılan programlarsa, program onları tüm yazarları yutan sanal bir dosyaya ya da tüm yazarları yutan bir programa yöneltecek şekilde umursamaz.

Şimdi, veri okumak veya yazmak için dosya yollarına sahip programlarınız varsa (çoğu programın yaptığı) - ve bu programlara "boş girdi" veya "bu çıktıyı at" işlevini eklemek istiyorsanız, bununla birlikte /dev/nullücretsiz gelir.

Bunun zerafetinin, ilgili tüm programların kod karmaşıklığını azalttığına dikkat edin - sisteminizin gerçek bir "dosya adı" ile "dosya" olarak sağlayabileceği her genel ancak özel kullanım için, kodunuz özel komut eklemekten kaçınabilir -line seçenekleri ve işlemek için özel kod yolları.

İyi yazılım mühendisliği genellikle, bir problemin bazı öğelerini düşünmek daha kolay ancak esnek bir şekilde soyutlamak için iyi veya "doğal" metaforlar bulmaya dayanır , böylece temelde aynı yüksek seviye problemleri çözmeden çözebilirsiniz. zaman ve zihinsel enerjiyi sürekli olarak aynı alt seviye problemlere yeniden uygulama çözümlerine harcarlar.

"Her şey bir dosyadır" kaynaklara erişmek için böyle bir metafor gibi görünmektedir: openHeirarchical bir ad alanında belirli bir yolu çağırıyorsunuz , nesneye referans (dosya tanımlayıcısı) alıyorsunuz readve writedosya tanımlayıcılarına vb. Stdin / stdout / stderr, ayrıca sizin için önceden açılmış olan dosya tanımlayıcılarıdır. Borularınız sadece dosya ve dosya tanımlayıcılarıdır ve dosya yeniden yönlendirmesi tüm bu parçaları birbirine yapıştırmanıza izin verir.

Unix, bu soyutlamaların birlikte çalışmasının iyi olmasından dolayı, kısmen olduğu kadar başarılı oldu ve /dev/nullen iyisi, bütünün bir parçası olarak anlaşıldı.

Not: "Her şey bir dosyadır" un Unix sürümüne ve /dev/nullizleyen birçok sistemde uygulanan metaforun daha esnek ve güçlü bir genellemesine doğru atılan ilk adımlar gibi şeylere bakmaya değer .

Örneğin, Unix'te, özel dosya benzeri nesnelerin /dev/nullçekirdeğin kendisinde uygulanması gerekiyordu, ancak dosya / klasör biçiminde işlevselliği ortaya koymanın, o zamandan bu yana programlar için bir yol sağlayan çok sayıda sistem yapılmış olması yeterince yararlı olduğu ortaya çıktı. bunu yapmak için.

Bunlardan birincisi, Unix'i yapan aynı kişiler tarafından yapılan Plan 9 işletim sistemi idi. Daha sonra GNU Hurd, "çevirmenleri" ile benzer bir şey yaptı. Bu arada, Linux (şimdiye dek diğer ana sistemlere yayılmış olan) FUSE yazılımını almaya başladı.

Performans nedeniyle bir program yerine /dev/nullbir karakter aygıtı (sıradan bir dosya gibi davranır) olduğunu düşünüyorum .

Eğer bir program olsaydı, yükleme, çalıştırma, programlama, çalıştırma ve sonrasında programı durdurma ve boşaltmayı gerektirir. Açıkladığınız basit C programı elbette çok fazla kaynak tüketmez, ancak süreç yönetimi işlemleri çok büyük ölçüde maliyetli olduğu için çok sayıda (milyonlarca) yönlendirme / borulama işlemi dikkate alındığında önemli bir fark yarattığını düşünüyorum . bağlam anahtarları içerirler.

Bir başka varsayım: Bir programa bağlanmak , alıcının program tarafından tahsis edilmesini gerektirir (daha sonra doğrudan atılsa bile). Bu nedenle, alete bağlarsanız, bir kez gönderme programında ve bir kez de alıcı programda çift bellek tüketimine sahip olursunuz.

"Her şey bir dosyadır" ve dolayısıyla diğer çoğu yanıtın dayandığı her yerde kullanım kolaylığı yanında, @ user5626466'nın belirttiği gibi performans sorunu da vardır.

Uygulamada göstermek için, basit bir program yaratacağız nullread.c:

#include <unistd.h>
char buf[1024*1024];
int main() {
        while (read(0, buf, sizeof(buf)) > 0);
}

ve ile derleyin gcc -O2 -Wall -W nullread.c -o nullread

(Not: lseek'i (2) borularda kullanamayız, bu nedenle boruyu boşaltmanın tek yolu boşalıncaya kadar okumaktır).

% time dd if=/dev/zero bs=1M count=5000 |  ./nullread
5242880000 bytes (5,2 GB, 4,9 GiB) copied, 9,33127 s, 562 MB/s
dd if=/dev/zero bs=1M count=5000  0,06s user 5,66s system 61% cpu 9,340 total
./nullread  0,02s user 3,90s system 41% cpu 9,337 total

standart /dev/nulldosya yönlendirme ile çok daha iyi hızlar elde ediyoruz (belirtilen gerçekler nedeniyle: daha az bağlamda anahtarlama, çekirdek sadece kopyalamak yerine verileri yok sayma vb.):

% time dd if=/dev/zero bs=1M count=5000 > /dev/null
5242880000 bytes (5,2 GB, 4,9 GiB) copied, 1,08947 s, 4,8 GB/s
dd if=/dev/zero bs=1M count=5000 > /dev/null  0,01s user 1,08s system 99% cpu 1,094 total

(Bu orada bir yorum olmalı, ama bunun için çok büyük ve tamamen okunamaz olur)

Sorunuz, basit bir şekilde bir dosya yerine boş bir program kullanılarak basitçe bir şey kazanılmış gibi düşünülüyor. Belki de "sihirli dosyalar" kavramından kurtulabiliriz ve bunun yerine sadece "sıradan borular" olabilir.

Ancak, bir borunun da bir dosya olduğunu düşünün . Normalde adlandırılmazlar ve bu nedenle yalnızca dosya tanımlayıcıları aracılığıyla manipüle edilebilirler.

Bunu biraz tartışmalı bir örnek olarak düşünün:

$ echo -e 'foo\nbar\nbaz' | grep foo
foo

Bash'in işlem ikamesini kullanarak aynı şeyi daha dolambaçlı bir yolla gerçekleştirebiliriz:

$ grep foo <(echo -e 'foo\nbar\nbaz')
foo

Değiştir grepiçin echove biz kapakların altında görebilirsiniz:

$ echo foo <(echo -e 'foo\nbar\nbaz')
foo /dev/fd/63

<(...)Yapı sadece bir dosya adı ile değiştirildi ve grep herhangi eski bir dosya açıyor, sadece ismini vermek olur düşündüğü edilir /dev/fd/63. Burada, /dev/fddosyaya erişen her dosya tanımlayıcısı için adlandırılmış yöneltmeler yapan sihirli bir dizindir.

Sıradan bir dosya gibi, içinde görünen herşeyi mkfifogösteren bir boru oluşturmayı daha az sihirle yapabiliriz ls:

$ mkfifo foofifo
$ ls -l foofifo 
prw-rw-r-- 1 indigo indigo 0 Apr 19 22:01 foofifo
$ grep foo foofifo

Ayrıca:

$ echo -e 'foo\nbar\nbaz' > foofifo

ve işte, grep çıkacaktır foo.

Borular ve düzenli dosyalar ile / dev / null gibi özel dosyaların farkına varınca, sadece dosya olduklarını düşünüyorum, boş bir programın uygulanması daha karmaşıktır. Çekirdek bir dosyaya yazmayı her iki şekilde de işlemek zorundadır, ancak / dev / null olması durumunda, yazmaları zemine bırakabilir, bununla birlikte bir boru ile baytları gerçekte baytları başka bir programa aktarabilir. aslında onları okudum.

Tarihsel paradigmaların ve performansın ötesinde bir güvenlik sorunu olduğunu savunuyorum. Ayrıcalıklı yürütme kimlik bilgilerine sahip program sayısını sınırlamak, ne kadar basit olursa olsun, sistem güvenliğinin temel prensibidir. /dev/nullSistem servislerinin kullanması nedeniyle bu tür ayrıcalıklara sahip olmak için kesinlikle bir değişiklik yapmanız gerekecektir. Modern güvenlik çerçeveleri, istismarları önleyen mükemmel bir iş çıkarmaktadır, ancak kusursuz değildirler. Dosya olarak erişilen bir çekirdek çekirdek aygıttan yararlanmak çok daha zordur.

Diğerleri zaten belirttiği gibi, /dev/null bir satır kod bir avuç yapılmış bir programdır. Sadece bu kod satırları çekirdeğin bir parçası.

Daha açık hale getirmek için, işte Linux uygulaması: bir karakter cihazı okunduğunda veya yazıldığında işlevleri çağırır. Yazma /dev/nullçağrılar write_null okuma çağrılar yaparken, read_null , kayıtlı buraya .

Kelimenin tam anlamıyla bir avuç kod satırları: bu işlevler hiçbir şey yapmaz. Sadece okuma ve yazma dışındaki işlevleri sayıyorsanız, elinizde parmaklarınızdan daha fazla kod satırına ihtiyacınız olacaktır.

Umarım / dev / chargen / dev / zero ve / dev / null dahil onlar gibi diğerlerinin de farkındasınızdır.

LINUX / UNIX bunlardan birkaçına sahiptir - insanlar WELL WRITTEN CODE FrAGMEnTS'den daha iyi faydalanabilirler.

Chargen belirli ve yinelenen bir karakter örüntüsü oluşturmak için tasarlanmıştır - oldukça hızlıdır ve seri cihazların sınırlarını zorlar ve bazı testlerde veya diğer testlerde yazılan ve başarısız olan seri protokollerde hata ayıklamaya yardımcı olur.

Sıfır, mevcut bir dosyayı doldurmak veya çok fazla sıfır çıktısı almak için tasarlanmıştır.

/ dev / null, akılda aynı fikri olan başka bir araçtır.

Araç takımınızdaki bu araçların tümü, mevcut bir programın (özel gereksinimlerinize) aygıt veya dosya değişikliği olarak bakılmaksızın benzersiz bir şey yapmasını sağlama şansınız olduğunu gösterir.

LINUX sürümünüzde sadece birkaç karakter cihazı göz önüne alındığında en heyecan verici sonucu kimin üretebileceğini görmek için bir yarışma düzenleyelim.