Nome: Zhu Duxin
ID do estudante: 201821121021
Classe: Calcular 1811

1. Escreva um programa

1. Nomeação de canal (porque a leitura e gravação posteriormente especifica o nome do canal, então o processo de criação aqui também usa o método especificado no programa.)

  1 #include <stdio.h>
   2 #include <sys / types.h>
   3 #include <sys / stat.h>
   4  int main () {
   5      int temp = mkfifo ( " fifo " , 0777 ); // Criar Pipeline fifo
   6      if (temp == - 1 ) {// Retorna 0 se for bem-sucedido, -1
   7          perror ( " derrota " );
   8          return - 1 ;
   9      }
  10      return  0 ;
  11 }

Como o modo de parâmetro no int mkfifo ( const char * nome do caminho, mode_t mode); refere-se às permissões do arquivo de pipeline, simplesmente organizarei as permissões, o seguinte é o conteúdo representado por cada permissão:

Autoridade	Explicação	Autoridade	Explicação
r--	Somente leitura	-W-	Somente gravação
--x	Apenas executável	rw-	Legível e gravável
-wx	Executável gravável	rx	Legível e executável
rwx	Legível, gravável e executável	---	Sem permissão

E essas permissões são geralmente expressas em octal: (o binário também pode ser usado e o binário específico pode ser convertido por si só)

Autoridade	Octal
---	0 0
x	1
W	2
wx	3
r	4
rx	5
rw	6
rwx	7

Como se trata de um experimento, o modo é selecionado como 777, o que é conveniente para o experimento.

E criar um pipe famoso pode ser criado diretamente usando o 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 = open ( " fifo " , O_RDONLY);
 10      if (fifo_read == - 1 ) {
  11          perror ( " aberto " );
 12          retorno - 1 ;
 13      }
  14 
 15     while ( 1 ) {
  16          char buffer [ 128 ] = { 0 };
 17          sinalizador int = leitura (fifo_read, buffer, 128 );
 18          if (flag == 0 ) {
  19              printf ( " está fechado " );
 20              pausas ;
 21          }
  22          printf ( " leia:% s de fifo \ n " , buffer);
 23      }
  24 
 25      close (fifo_read);
 26      retorno  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 = open ( " fifo " , O_WRONLY);
 10      if (fifo_write == - 1 ) {
  11          perror ( " aberto " );
 12          retorno - 1 ;
 13      }
  14 
 15     while ( 1 ) {
  16          char buffer [ 128 ] = { 0 };
 17          caracteres * encontrar;
 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          write (fifo_write, buffer, strlen (buffer));
 27      }
  28      close (fifo_write);
 29      retorno  0 ;
 30 }

2. Analise os resultados da operação

fifo_write write:

fifo_read leia:

3. Gere novas perguntas e respostas através deste experimento

Durante o primeiro teste, verificou-se que o leitor havia recebido as informações, mas o resultado da exibição não pôde ser exibido em uma linha completa, e o conteúdo após a recepção das informações não pôde ser exibido e não seria exibido até a próxima vez em que a mensagem foi recebida:

escrever:

ler:

Analise o código e descubra que o problema é que, quando fgets () lê o conteúdo de entrada, ele grava o caractere de nova linha, o que faz com que a figura acima não seja exibida após o hello e o conteúdo original após o hello vai para a próxima linha, procurando no código O caractere de nova linha e substituí-lo podem efetivamente resolver o problema.

Sistema operacional terceiro relatório de experimento: pipeline