aio_write для больших файлов

Я пытаюсь по существу имитировать функциональность sendfile(2) в асинхронном режиме с использованием aio_read(3) а также aio_write(3),

Кажется, все работает нормально, за исключением тестирования больших (> 150 КБ) файлов.

У меня простой struct io_request Я использую, чтобы отслеживать переводы:

struct io_request {
    int status;
    struct aiocb *aiocbp;
    int sfd;
};

Во-первых, я строю aio_read() вызов:

struct io_request * ioreq = malloc(sizeof(struct io_request));
ioreq->status = EINPROGRESS;
ioreq->sfd = sfd;

struct aiocb * aiocbreq = malloc(sizeof(struct aiocb));
memset(aiocbreq, 0, sizeof(struct aiocb));

ioreq->aiocbp = aiocbreq;

ioreq->aiocbp->aio_fildes = ffd;

if (ioreq->aiocbp->aio_fildes == -1) {
    perror("aio_fildes");
}

ioreq->aiocbp->aio_buf = malloc(st.st_size);
if (ioreq->aiocbp->aio_buf == NULL) {
    perror("aio_buf malloc");
}

ioreq->aiocbp->aio_nbytes = st.st_size;
ioreq->aiocbp->aio_reqprio = 0;
ioreq->aiocbp->aio_offset = 0;
ioreq->aiocbp->aio_sigevent.sigev_signo = IO_READ_SIGNAL;
ioreq->aiocbp->aio_sigevent.sigev_value.sival_ptr = ioreq;
if (aio_read(ioreq->aiocbp) == -1) {
    perror("aio_read");
}

Который позже захватывается в IO_READ_SIGNAL обработчик:

static void
aio_read_handler(int sig, siginfo_t *si, void *ucontext)
{
    if (si->si_code == SI_ASYNCIO) {
        struct io_request *ioreq = si->si_value.sival_ptr;

        // Build the AIO write request
        struct aiocb aiocbreq;
        memset(&aiocbreq, 0, sizeof(struct aiocb));
        aiocbreq.aio_fildes = ioreq->sfd;
        aiocbreq.aio_buf = ioreq->aiocbp->aio_buf;
        aiocbreq.aio_nbytes = ioreq->aiocbp->aio_nbytes;
        aiocbreq.aio_sigevent.sigev_signo = IO_WRITE_SIGNAL;
        aiocbreq.aio_sigevent.sigev_value.sival_ptr = ioreq;

        if (aio_write((void *) &aiocbreq) == -1) {
            perror("aio_write");
        }
    }
}

Я могу подтвердить, что внутри обработчика, даже для больших файлов, содержимое ioreq->aiocbp->aio_buf полон и завершен.

Позже aio_write() захвачен в IO_WRITE_SIGNAL обработчик:

static void
aio_write_handler(int sig, siginfo_t *si, void *ucontext)
{
    if (si->si_code == SI_ASYNCIO) {
        struct io_request *ioreq = si->si_value.sival_ptr;

        ssize_t bytes_written = aio_return(ioreq->aiocbp);
        printf("Wrote %zu of %zu bytes\n", bytes_written, ioreq->aiocbp->aio_nbytes);
        //free(ioreq->aiocbp);
        //free(ioreq);

        if (aio_error(ioreq->aiocbp) != 0) {
            perror("aio_write_handler");
        }
    }
}

С этой точки зрения aio_write() должен был быть завершен. Я проверяю возвращаемые значения и действую соответственно. Оба вызова сообщают, что записано соответствующее количество байтов, и при записи не возникло ошибок.

Большим приложением является HTTP-сервер. Я предполагаю, что эта проблема возникает, потому что удаленный клиент не может читать достаточно быстро, чтобы не отставать от aio_write(), Когда у меня был sendfile() Реализация этого мне пришлось позвонить sendfile() несколько раз, чтобы завершить передачу файла.

Несколько прямых вопросов:

  • Почему aio_return() а также aio_error() не сообщать о каких-либо проблемах?
  • Как я могу исправить это поведение?
  • Есть ли способы для буферизации aio_write()? Я думал об ограничении n_bytes внутри struct aiocb перешел к aio_write() и просто звонит aio_write() несколько раз изнутри aio_write_handler(),

Спасибо за вашу помощь!

1 ответ

Решение

Если я правильно понимаю, вы используете aio_return до aio_error, aio_return страница руководства говорит,

Эта функция должна вызываться только один раз для любого данного запроса, после того как aio_error(3) вернет что-то отличное от EINPROGRESS.

Другие вопросы по тегам