---

Jeg har et problem med async io (glibc versionen). Programmet som i kan finde
senere kommer med en segfault når jeg kalder lio_listio. Hvis jeg kalder
lio_listio med parameteren FILE_COUNT (som er størrelsen af arrayet den får
med), så får jeg en segfault. Aha tænker man så, jeg er 'off by one'. Så kalder
man funktionen med FILE_COUNT-1. Ganske rigtigt går segfaulten væk, med
programmet udfører kun en af io-operationerne. Altså der står data i fil1, men
ikke i fil2.

Er der nogen der har et bud?

==================================================
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

#include <aio.h>

#define FILE_COUNT 2
int files[FILE_COUNT];
char *fnames[] = {"fil1", "fil2"};

char *fishdata;

void open_files()
{
   int i;
   for (i = 0; i < FILE_COUNT; i++) {
      files[i] = open(fnames[i], O_CREAT | O_TRUNC | O_RDWR, S_IRUSR|S_IWUSR);
      printf("Open files %d\n", files[i]);
      if (files[i] < 0) {
         perror("open");
         exit(1);
      }
   }
}

void close_files()
{
   int i;
   for (i = 0; i < FILE_COUNT; i++) {
      if (close(files[i]) < 0) {
         perror("close");
         exit(1);
      }
      printf("Closed files %d\n", files[i]);
   }
}

void get_signal(int hat)
{
   printf("asdfasdfasdf\n");
   return;
}

void do_write()
{
   int i;
   struct aiocb *aios;
   struct sigevent sigev;
   aios = (struct aiocb *) malloc(sizeof(struct aiocb) * FILE_COUNT);

   sigev.sigev_notify = SIGEV_NONE;

   for (i=0; i < FILE_COUNT; i++) {
      int size = strlen(fishdata);
      aios[i].aio_fildes = files[i];
      aios[i].aio_offset = 0;
      aios[i].aio_buf = fishdata;
      aios[i].aio_nbytes = size;
      aios[i].aio_sigevent = sigev;
      aios[i].aio_lio_opcode = LIO_WRITE;
   }


   printf("Starting write\n");
   if (lio_listio(LIO_NOWAIT, ((struct aiocb **) &aios),
             FILE_COUNT, NULL) < 0) {
      perror("lio_listio");
      exit(1);
   }

   for(i =0; i < FILE_COUNT; i++) {
      int ret;
      do {
         ret = aio_error(&aios[i]) ;
         switch(ret) {
            case EINPROGRESS:
               printf("Juhuuuuuu!\n");
               usleep(100);
               break;
            default:
               if (ret < 0) {
                  perror("aio_error");
                  exit(1);
               }   
         }
      } while (ret == EINPROGRESS);
   }
}

int main()
{
   int i;

   fishdata = (char *) malloc(1024);

   for (i=0; i < 40; i++) {
      strcat(fishdata, "asdfasdfasdfasdfasdfasdfs");
   }

   signal(SIGUSR1, get_signal);

   /* Open files */
   open_files();
   do_write();
   close_files();
   return 0;
}
==================================================

--
   Christoffer

---

Christoffer H.-Frederiksen <hall@diku.dk> skrev:
> Jeg har et problem med async io (glibc versionen). Programmet som i kan
> finde senere kommer med en segfault når jeg kalder lio_listio.

Jeg kan ikke umiddelbart se hvad der er galt, men programmet
indeholder i hvert fald en alvorlig bufferoverløbsfejl.

> char *fishdata;

> int main()
> {
>    int i;
>
>    fishdata = (char *) malloc(1024);
>
>    for (i=0; i < 40; i++) {
>       strcat(fishdata, "asdfasdfasdfasdfasdfasdfs");
>    }

Indholdet af den allokerede buffer er udefineret efter brug af
malloc(). Ved at tilføje 1000 tegn til en udefineret startstreng
risikerer du nemt at overskride bufferstørrelsen på 1024 bytes og
skrive hvor der ikke burde skrives.