Nombre: Zhu Duxin
Identificación del estudiante: 201821121021
Clase: Calcular 1811

1. Escribe un programa

1. Denominación de la tubería (porque la lectura y escritura más adelante especifican el nombre de la tubería, por lo que el proceso de creación aquí también utiliza el método especificado en el programa).

  1 #include <stdio.h>
   2 #include <sys / types.h>
   3 #include <sys / stat.h>
   4  int main () {
   5      int temp = mkfifo ( " fifo " , 0777 ); // Crear Pipeline fifo
   6      if (temp == - 1 ) {// Devuelve 0 si tiene éxito, -1
   7          perror ( " derrota " );
   8          devuelve - 1 ;
   9      }
  10      devuelve  0 ;
  11 }

Dado que el modo de parámetro en int mkfifo ( const char * pathname, mode_t mode); se refiere a los permisos del archivo de canalización, simplemente organizaré los permisos, los siguientes son los contenidos representados por cada permiso:

Autoridad	Explicación	Autoridad	Explicación
r--	Solo lectura	-w-	Solo escribir
--X	Solo ejecutable	rw-	Legible y escribible
-wx	Ejecutable escribible	rx	Legible y ejecutable
rwx	Legible, escribible y ejecutable	---	Sin permiso

Y estos permisos generalmente se expresan en octal: (el binario también se puede usar, y el binario específico se puede convertir por sí mismo)

Autoridad	Octal
---	0 0
X	1
w	2
wx	3
r	4 4
rx	5 5
rw	6 6
rwx	7 7

Como se trata de un experimento, el modo se selecciona como 777, lo que es conveniente para el experimento.

Y crear una tubería famosa se puede crear directamente con el comando mkfifo name.

2.fifo_read.c

  1 #include <unistd.h>
   2 #include <stdlib.h>
   3 #include <errno.h>
   4 #include < string .h>
   5 #include <fcntl.h>
   6 #include <stdio.h>
   7  
  8  int main () {
   9      int fifo_read = abierto ( " fifo " , O_RDONLY);
 10      if (fifo_read == - 1 ) {
  11          perror ( " abierto " );
 12          regreso - 1 ;
 13      }
  14 
 15     while ( 1 ) {
  16          char buffer [ 128 ] = { 0 };
 17          int flag = read (fifo_read, buffer, 128 );
 18          if (flag == 0 ) {
  19              printf ( " está cerrado " );
 20              descanso ;
 21          }
  22          printf ( " lectura:% s de fifo \ n " , búfer);
 23      }
  24 
 25      cerrar (fifo_read);
 26      volver  0;
 27 }

3.fifo_write.c

  1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <signal.h>
   4 #include <unistd.h>
   5 #include < string .h>
   6 #include <fcntl.h>
   7  
  8  int main () {
   9      int fifo_write = abierto ( " fifo " , O_WRONLY);
 10      if (fifo_write == - 1 ) {
  11          perror ( " abierto " );
 12          regreso - 1 ;
 13      }
  14 
 15     while ( 1 ) {
  16          char buffer [ 128 ] = { 0 };
 17          char * find;
 18          fgets (buffer, 128 , stdin);
 19          find = strchr (buffer, ' \ n ' );
 20          if (find) {
  21              * find = ' \ 0 ' ;
 22          }
  23          if (strcmp (buffer, " end " ) == 0 ) {
  24              break ;
 25          }
  26          escribir (fifo_write, buffer, strlen (buffer));
 27      }
  28      close (fifo_write);
 29      devuelven  0 ;
 30 }

2. Analice los resultados de la operación.

fifo_write escribir:

Lectura de fifo_read:

3. Genere nuevas preguntas y respuestas a través de este experimento.

Durante la primera prueba, se descubrió que el lector había recibido la información, pero el resultado de la visualización no se podía emitir en una línea completa, y el contenido después de recibir la información no se podía mostrar, y no se mostraría hasta la próxima vez que se recibió el mensaje:

escribir:

leer:

Analice el código y descubra que el problema es que cuando fgets () lee el contenido de entrada, escribirá el carácter de nueva línea juntos, lo que hace que la figura anterior no se muestre después de hola, y el contenido original después de hola va a la siguiente línea, mirando el código El carácter de nueva línea y su reemplazo pueden resolver el problema de manera efectiva.

Informe del tercer experimento del sistema operativo: canalización