비 차단 fd에 write()를 할 수 있습니까? select를 쓸 때 쓸 수 있습니까?

Question

OS X (10.8.2)에서 이상한 동작을 추적하려고합니다. 기본적으로 필자는 파이프를 열어서 쓰기가 불가능해질 때까지 데이터로 채 웁니다. 그러나 내가 쓰려고 시도한 청크의 크기에 따라 select() 파이프가 여전히 쓰기 가능하다고 주장하더라도 write() 호출에서 EAGAIN을 얻을 것입니다. 여기

#include <unistd.h> 
#include <errno.h> 
#include <stdio.h> 
#include <fcntl.h> 
#include <sys/select.h> 

#define START 1 
#define END 16 

int is_writeable(int fd) { 
    struct timeval timeout; 
    timeout.tv_sec = 0; 
    timeout.tv_usec = 0; 

    fd_set ws; 

    FD_ZERO(&ws); 
    FD_SET(fd, &ws); 

    if(select(fd+1, NULL, &ws, NULL, &timeout) < 0) { 
     return -1; 
    } 

    if(FD_ISSET(fd, &ws)) 
     return 1; 
    else 
     return 0; 
} 

int main(int argc, char *argv[]) { 

    int pipes[2]; 
    int rp, wp, i, errval, fails, tmp; 

    char testbuf[END]; 
    char destbuf[128000]; 

    for(i = START; i < END; i++) { 
     int byte_count = 0; 
     printf("%i: ", i); 
     fails = 0; 

     pipes[0] = 0; 
     pipes[1] = 0; 

     if(pipe(pipes) < 0) { 
      printf("PIPE FAIL\n"); 
      break; 
     } 
     rp = pipes[0]; 
     wp = pipes[1]; 

     int flags = fcntl(wp, F_GETFL, 0); 
     if(fcntl(wp, F_SETFL, flags | O_NONBLOCK) == -1) { 
      fails = 4; 
     } 

     if(is_writeable(wp) != 1) { 
      fails = 1; 
     } 

     while(!fails) { 
      // printf("."); 
      if(is_writeable(wp) < 1) { 
       break; 
      } 

      tmp = write(wp, testbuf, i); 
      //No bytes written, fail 
      if(tmp < 0) { 
       if(errno == EAGAIN) { 
        if(is_writeable(wp) == 1) { 
         fails = 3; 
         break; 
        } 
       } else { 
        fails = 2; 
        perror("During write"); 

        break; 
       } 

      } else { 
       byte_count += tmp; 
      } 
      //Errno is eagain, fail 
     } 
     printf("byte count %i, ", byte_count); 

     if(fails) 
      printf("FAIL, %i\n", fails); 
     else 
      printf("PASS\n"); 

     if(close(wp) != 0) 
      printf("WP CLOSE FAIL\n"); 
     if(close(rp) != 0) 
      printf("RP CLOSE FAIL\n"); 
    } 

} 

출력됩니다 : 여기에 몇 가지 테스트 코드는 실패 케이스 (3)은 쓰기()가 호출이 -1 반환하지만 선택 경우 여전히 파일 핸들이 쓰기 가능한 것으로보고

1: byte count 16384, PASS 
2: byte count 16384, PASS 
3: byte count 65535, FAIL 3 
4: byte count 16384, PASS 
5: byte count 65535, FAIL 3 
6: byte count 65532, FAIL 3 
7: byte count 65534, FAIL 3 
8: byte count 16384, PASS 
9: byte count 65529, FAIL 3 
10: byte count 65530, FAIL 3 
11: byte count 65527, FAIL 3 
12: byte count 65532, FAIL 3 
13: byte count 65533, FAIL 3 
14: byte count 65534, FAIL 3 
15: byte count 65535, FAIL 3 

하는 것으로 .

(1..10).each do |i| 
    passes = true 
    begin 
    (rp, wp) = IO.pipe 
    wp.write_nonblock ("F" * i) while(select [], [wp], [], 0) 
    rescue Errno::EAGAIN 
    puts "#{i}: FAIL" 
    passes = false 
    ensure 
    rp.close 
    wp.close 
    end 
    puts "#{i}: PASS" if passes 
end 

이 버그 사양의 오해 인 경우 내가 확실히 말할 수 없다 :

여기에 같은 실패를 보여줍니다 루비의 짧은 예이다. 생각?

Answer 1

여기에 파이프를 사용하고 있습니다. 파이프는 재미있는 원자 쓰기 특성을 가지고 있습니다. PIPE_BUF (여기 4096) 바이트보다 작게 작성하면 바이트가 원자적일 수 있습니다. 따라서 파이프에 더 적은 수의 바이트를 쓸 수있는 경우에도 EAGAIN을 사용하여 파이프에 쓰는 것이 실패 할 수 있습니다.

내가 여기에 뛰어 다니고 있는지 (나는 너무 가깝게 보지 못했다) 확실하지는 않지만이 행동은 사람 7 파이프에 기록되어있다.