Revision c16b5a2c block/raw-posix.c

b/block/raw-posix.c
599 599
    return 0;
600 600
}
601 601

  
602
static void raw_aio_remove(RawAIOCB *acb)
603
{
604
    RawAIOCB **pacb;
605

  
606
    /* remove the callback from the queue */
607
    pacb = &posix_aio_state->first_aio;
608
    for(;;) {
609
        if (*pacb == NULL) {
610
            fprintf(stderr, "raw_aio_remove: aio request not found!\n");
611
            break;
612
        } else if (*pacb == acb) {
613
            *pacb = acb->next;
614
            qemu_aio_release(acb);
615
            break;
616
        }
617
        pacb = &(*pacb)->next;
618
    }
619
}
620

  
621
static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
622
{
623
    int ret;
624
    RawAIOCB *acb = (RawAIOCB *)blockacb;
625

  
626
    ret = qemu_paio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
627
    if (ret == QEMU_PAIO_NOTCANCELED) {
628
        /* fail safe: if the aio could not be canceled, we wait for
629
           it */
630
        while (qemu_paio_error(&acb->aiocb) == EINPROGRESS);
631
    }
632

  
633
    raw_aio_remove(acb);
634
}
635

  
636
static AIOPool raw_aio_pool = {
637
    .aiocb_size         = sizeof(RawAIOCB),
638
    .cancel             = raw_aio_cancel,
639
};
640

  
602 641
static RawAIOCB *raw_aio_setup(BlockDriverState *bs, int64_t sector_num,
603 642
        QEMUIOVector *qiov, int nb_sectors,
604 643
        BlockDriverCompletionFunc *cb, void *opaque)
......
609 648
    if (fd_open(bs) < 0)
610 649
        return NULL;
611 650

  
612
    acb = qemu_aio_get(bs, cb, opaque);
651
    acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
613 652
    if (!acb)
614 653
        return NULL;
615 654
    acb->aiocb.aio_fildes = s->fd;
......
633 672
    return acb;
634 673
}
635 674

  
636
static void raw_aio_remove(RawAIOCB *acb)
637
{
638
    RawAIOCB **pacb;
639

  
640
    /* remove the callback from the queue */
641
    pacb = &posix_aio_state->first_aio;
642
    for(;;) {
643
        if (*pacb == NULL) {
644
            fprintf(stderr, "raw_aio_remove: aio request not found!\n");
645
            break;
646
        } else if (*pacb == acb) {
647
            *pacb = acb->next;
648
            qemu_aio_release(acb);
649
            break;
650
        }
651
        pacb = &(*pacb)->next;
652
    }
653
}
654

  
655 675
static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
656 676
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
657 677
        BlockDriverCompletionFunc *cb, void *opaque)
......
683 703
    }
684 704
    return &acb->common;
685 705
}
686

  
687
static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
688
{
689
    int ret;
690
    RawAIOCB *acb = (RawAIOCB *)blockacb;
691

  
692
    ret = qemu_paio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
693
    if (ret == QEMU_PAIO_NOTCANCELED) {
694
        /* fail safe: if the aio could not be canceled, we wait for
695
           it */
696
        while (qemu_paio_error(&acb->aiocb) == EINPROGRESS);
697
    }
698

  
699
    raw_aio_remove(acb);
700
}
701 706
#else /* CONFIG_AIO */
702 707
static int posix_aio_init(void)
703 708
{
......
871 876
#ifdef CONFIG_AIO
872 877
    .bdrv_aio_readv = raw_aio_readv,
873 878
    .bdrv_aio_writev = raw_aio_writev,
874
    .bdrv_aio_cancel = raw_aio_cancel,
875
    .aiocb_size = sizeof(RawAIOCB),
876 879
#endif
877 880

  
878 881
    .bdrv_truncate = raw_truncate,
......
1205 1208
    if (fd_open(bs) < 0)
1206 1209
        return NULL;
1207 1210

  
1208
    acb = qemu_aio_get(bs, cb, opaque);
1211
    acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
1209 1212
    if (!acb)
1210 1213
        return NULL;
1211 1214
    acb->aiocb.aio_fildes = s->fd;
......
1417 1420
#ifdef CONFIG_AIO
1418 1421
    .bdrv_aio_readv	= raw_aio_readv,
1419 1422
    .bdrv_aio_writev	= raw_aio_writev,
1420
    .bdrv_aio_cancel	= raw_aio_cancel,
1421
    .aiocb_size		= sizeof(RawAIOCB),
1422 1423
#endif
1423 1424

  
1424 1425
    .bdrv_read          = raw_read,

Also available in: Unified diff