Select() Posix: grattacapo

[LimiT-MaTz]

#include <stdio.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
    int fd = 0;
    char * value= (char *) malloc (sizeof(char) * 100);
    int retval;
    int len = 0;
   
    fd_set rfds;
    fd = open("/home/matz/fifo", O_RDONLY);
for(;;){
    FD_ZERO(&rfds);
        FD_SET(fd, &rfds);
        retval = select(fd + 1 , &rfds, NULL, NULL, NULL);
        printf("retval  %d\n",retval);
    if (retval == -1) {
                fprintf(stderr, "select failed:");
                return -1;
        }
    else{
            if (FD_ISSET(fd, &rfds)) {
                    len = read(fd, value, 100);
            value[len]='\0';
            printf("%s",value);
            }       
    }
}
    return 0;
}

/* dopo aver letto per la prima volta un dato dalla fifo ad ogni ciclo successivo continua a vedere retval = 1 e il fd registrato nell'insieme rfds */

/home/matz/fifo è una fifo.
Lancio il programmino lui entra nella select e rimane in attesa.
Un altro processo scrive sulla fifo a questo punto il "programmino" si sveglia e stampa su stdout il dato.

Fin qui tutto ok.

Ora vengono i problemi:
rinizia il ciclo riazzero l'insieme rfds inserisco fd nell'insieme entro nella select ma NON MI FERMO (nessun processo ci ha scritto sopra).

Non riesco a capire perchè cio' accada ...
Sapreste aiutarmi?

[ilsensine]

Hai raggiunto una condizione di EOF; puoi controllare che la read ritorna 0.

Fatti un favore, uccidi la select e usa la poll.

[LimiT-MaTz]

ok, accetto il tuo consiglio per quanto riguarda la poll.

int main()
{
	int fd = 0;
	char * value= (char *) malloc (sizeof(char) * 100);
	int retval;
	int len = 0;

	struct pollfd p;
	fd = open("/home/matz/fifo", O_RDONLY);
for(;;){
	p.fd = fd;
	p.events = POLLIN;
	retval = poll(&p, 1, 0);
        printf("retval  %d\n",retval);

	if (retval == -1) {
                fprintf(stderr, "select failed:");
                return -1;
        }
	else{
		if(p.revents == POLLIN)
        	        {
			printf("HERE");
			len = read(fd, value, 100);
			value[len]='\0';
			printf("%s",value);
        	}		
	}
}
	return 0;
}

in output avro':

HERE
"dato ricevuto"
retval  1
retval  1
retval  1
retval  1

se vado a controllare p.revents è != da POLLIN, cio' nonostante poll() ritorna 1, nonostante in events abbia specificato solo POLLIN.

questo nn mi torna:

RETURN VALUE
       On success, a positive number is returned; this is the number of structures which have non-zero revents fields  (in  other  words,  those
       descriptors  with  events  or  errors  reported).   A value of 0 indicates that the call timed out and no file descriptors were ready. On
       error, -1 is returned, and errno is set appropriately.

[ilsensine]

Torna, torna. Il pipe è stato chiuso dall'altro lato, e revents ritorna l'evento come POLLHUP. Gli eventi di errore vengono _sempre_ ritornati, anche se non li hai richiesti.

[LimiT-MaTz]

la situazione diventa problematica...
ti spiego quello che volevo fare:
un processo multitread che ascoltasse i comandi sulla pipe e in base a questi facesse delle operazioni.
La mia idea era quella di usare una fifo e leggere da questa quando si presentavano dei dati usando appunto un meccanismo (select).

Visti gli sviluppi ora non so come comportarmi.

[ilsensine]

Semplicemente, chiudi e riapri la pipe.

[LimiT-MaTz]

Originariamente inviato da ilsensine

Semplicemente, chiudi e riapri la pipe.

argh, non ci sono ancora...

int main()
{
	int fd = 0;
	char * value= (char *) malloc (sizeof(char) * 100);
	int retval;
	int len = 0;

	struct pollfd p;
	fd = open("/home/matz/fifo", O_RDONLY);
for(;;){
	p.fd = fd;
	p.events = POLLIN;
	retval = poll(&p, 1, 0);
        
	printf("retval  %d\n",retval);
	if (retval == -1) {
                fprintf(stderr, "select failed:");
                return -1;
        }
	else{
		if(p.revents == POLLIN){
			printf("POLLIN\n");
			len = read(fd, value, 100);
			value[len]='\0';
			printf("%s\n",value);
		}		
		if(p.revents == POLLHUP){
			printf("POLLHUP");
			close(fd);
			open("/home/matz/fifo", O_RDONLY);
		}

	}
	}
	return 0;
}

nulla da fare casualmente ogni tanto si looppa e spara in stdout una serie di retval 1.

[ilsensine]

Che casotto che hai fatto...

int main()
{
  int fd;
  char * value= malloc (sizeof(char) * 100);
  int retval;
  int len;

  struct pollfd p;
  p.events = POLLIN;

  fd = open("/home/matz/fifo", O_RDONLY);
  while(fd>=0){
    p.fd = fd;
    retval = poll(&p, 1, -1);
        
    printf("retval  %d\n",retval);
    if (retval == -1) {
      perror("poll");
      return -1;
    }
    if(p.revents & POLLIN){
      printf("POLLIN\n");
      len = read(fd, value, 99);
      if (len>=0) {
        value[len]='\0';
        printf("%s\n",value);
      } else
        perror("read");
    } else if(p.revents & POLLHUP){
      printf("POLLHUP\n");
      close(fd);
      fd = open("/home/matz/fifo", O_RDONLY);
    }
  }

  perror("open");
  return -1;
}

[LimiT-MaTz]

effettivamente ...

Grazie come al solito sei stato gentilissimo!

[ilsensine]

Volendo essere pignoli, c'è ancora un "piccolo" errore:

    if (retval == -1) {
      if (errno!=EINTR) {
        perror("poll");
        return -1;
      }
      continue;
    }

La poll ritorna EINTR anche in corrispondenza di SIGSTOP+SIGCONT

[trallallero]

Originariamente inviato da ilsensine

Fatti un favore, uccidi la select e usa la poll.

perché ? io l'ho usata per un progetto per la EdisonTel (2001) e sta ancora andando da quello che so

[ilsensine]

Originariamente inviato da trallallero

perché ?

Poco scalabile; interfaccia dubbia (limite di FD_SETSIZE "hardcoded" all'atto della compilazione).
La poll è pià semplice e compatta, e non è legata a quell'assurda idea degli FD_SET.

[trallallero]

Originariamente inviato da ilsensine

Poco scalabile; interfaccia dubbia (limite di FD_SETSIZE "hardcoded" all'atto della compilazione).
La poll è pià semplice e compatta, e non è legata a quell'assurda idea degli FD_SET.

ero convinto di aver usato la select ma in effetti non c'entra niente
Ho rivisto il codice, ho usato socket, accept, setsockopt...
Uff, non mi ricordo neanche piú questa roba a furia di pro*ciare e di burocrazia aziendale