FIFO, pipe e socket di dominio Unix sono la stessa cosa nel kernel Linux?

Ho sentito che i FIFO si chiamano pipe. E hanno esattamente la stessa semantica. D'altra parte, penso che il socket del dominio Unix sia abbastanza simile al pipe (anche se non l'ho mai usato). Quindi mi chiedo se si riferiscano tutti alla stessa implementazione nel kernel Linux. Qualche idea?

I socket di dominio UNIX e FIFO possono condividere una parte della loro implementazione, ma concettualmente sono molto diversi. FIFO funziona a un livello molto basso. Un processo scrive byte nel pipe e un altro legge da esso. Un socket di dominio UNIX ha lo stesso comportamento di un socket TCP / IP.

Un socket è bidirezionale e può essere utilizzato da molti processi contemporaneamente. Un processo può accettare molte connessioni sullo stesso socket e partecipare contemporaneamente a più client. Il kernel fornisce ogni volta un nuovo descrittore di file connect(2)o accept(2)viene chiamato sul socket. I pacchetti andranno sempre alla giusta procedura.
Su un FIFO, questo sarebbe impossibile. Per la comunicazione bidirezionale, hai bisogno di due FIFO e hai bisogno di una coppia di FIFO per ciascuno dei tuoi clienti. Non c'è modo di scrivere o leggere in modo selettivo, perché sono un modo molto più primitivo di comunicare.

Le pipe anonime e le FIFO sono molto simili. La differenza è che le pipe anonime non esistono come file nel filesystem, quindi nessun processo può open(2)farlo. Sono utilizzati da processi che li condividono con un altro metodo. Se un processo apre un FIFO e quindi esegue, ad esempio, a fork(2), il suo figlio erediterà i suoi descrittori di file e, tra questi, la pipe.

I socket di dominio UNIX, le pipe anonime e gli FIFO sono simili nel fatto che utilizzano segmenti di memoria condivisa. I dettagli dell'implementazione possono variare da un sistema all'altro, ma l'idea è sempre la stessa: collegare la stessa porzione di memoria in due processi distinti mappatura della memoria per farli condividere i dati
( modifica: sarebbe un modo ovvio per implementarlo ma è non come viene effettivamente eseguito in Linux, che utilizza semplicemente la memoria del kernel per i buffer, vedere la risposta di @ tjb63 di seguito).
Il kernel quindi gestisce le chiamate di sistema e estrae il meccanismo.

C'è una buona discussione di questo qui: http://www.slideshare.net/divyekapoor/linux-kernel-implementation-of-pipes-and-fifos

Per quanto posso vedere, sia dalle diapositive della presentazione, sia dalla fonte @ http://lxr.free-electrons.com/source/fs/pipe.c - i file FIFO sono implementati come un wrapper attorno a pipe, e gli stessi pipe sono implementato tramite il filesystem virtuale pipefs ..

@lgeorget - Le pipe sembrano usare la memoria del kernel per i buffer tra i lettori e gli autori - non usano la 'memoria condivisa' in quanto tale e copiano la memoria tra gli spazi degli indirizzi utente e del kernel (es. pipe_readchiamate pipe_iov_copy_to_user, che chiama __copy_to_user_inatomic(o copy_to_user) . __copy_to_user_inatomicchiamate copy_user_generic, che è uno tra diverse implementazioni ASM.

Una "FIFO" e una " named pipe" sono la stessa cosa, anche se è abbastanza diversa da come una shell gestisce una "pipe" (|) tra due comandi sulla riga di comando.

Una pipe denominata (FIFO) è un singolo "file" condiviso da due programmi, in cui uno scrive su di esso e l'altro letto da esso ... Un socket invece è una "connessione" tra due "file" - che può usare una rete ed essere su computer separati - dove un programma legge / scrive su un "file" e un altro programma legge / scrive sull'altro ... Non penso che siano così simili ... D'altra parte entrambi socket e named pipe - oltre a file, dispositivi, collegamenti simbolici - utilizzano tutti gli inode e implementano alcune funzionalità comuni (come lettura e scrittura).

Non penso proprio Justin. Se non sbaglio, e probabilmente lo sono, penso che i FIFO utilizzino un file su disco e che i socket del dominio Unix utilizzino la memoria del kernel.

Inoltre, come aggiunta al poster sopra che ha affermato che i socket di dominio Unix sono bidirezionali, questo è il caso solo quando si utilizza un socket SOCK_STREAM. SOCK_DGRAM I socket di dominio Unix sono, infatti, unidirezionali e possono solo inviare () dal codice che si chiama connect (), al codice che si chiama bind ().

Naturalmente, il codice che chiama connect () deve anche chiamare bind () per creare il proprio endpoint, ma ciò non ha nulla a che fare con la tua domanda.

I miei 2 centesimi ... I socket FIFO e UNIX sono entrambi bidirezionali (simili) ma i socket hanno una topologia a stella mentre un FIFO è solo una coda (e quindi non può sostituirsi), sì la loro implementazione può condividere il codice internamente.

**

char * myfifo = "/tmp/myfifo";
mkfifo(myfifo, 0666);
fd = open(myfifo, O_RDWR);   //so that you can read/write to it
 ...
write(fd, buff1, sizeof(buff1));  
getchar();//wait till some one reds this and writes something else
int sz=read(fd, buff1, sizeof(buff1));  //read that something**