Commit 428c5705 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Stop VM on ENOSPC error. (Gleb Natapov) 



This version of the patch adds new option "werror" to -drive flag.
Possible values are:

report    - report errors to a guest as IO errors
ignore    - continue as if nothing happened
stop      - stop VM on any error and retry last command on resume
enospc    - stop vm on ENOSPC error and retry last command on resume
            all other errors are reported to a guest.

Default is "report" to maintain current behaviour.

Signed-off-by: default avatarGleb Natapov <gleb@redhat.com>
Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6388 c046a42c-6fe2-441c-8c8c-71466251a162
parent 7da03b1d

hw/ide.c

+75 −8
Original line number Diff line number Diff line
@@ -457,6 +457,8 @@ static inline int media_is_cd(IDEState *s) 
#define BM_STATUS_DMAING 0x01

#define BM_STATUS_ERROR  0x02

#define BM_STATUS_INT    0x04

#define BM_STATUS_DMA_RETRY  0x08

#define BM_STATUS_PIO_RETRY  0x10



#define BM_CMD_START     0x01

#define BM_CMD_READ      0x08
@@ -488,6 +490,8 @@ typedef struct BMDMAState { 
    IDEState *ide_if;

    BlockDriverCompletionFunc *dma_cb;

    BlockDriverAIOCB *aiocb;

    int64_t sector_num;

    uint32_t nsector;

} BMDMAState;



typedef struct PCIIDEState {
@@ -498,6 +502,7 @@ typedef struct PCIIDEState { 
} PCIIDEState;



static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb);

static void ide_dma_restart(IDEState *s);

static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);



static void padstr(char *str, const char *src, int len)
@@ -865,6 +870,28 @@ static void ide_dma_error(IDEState *s) 
    ide_set_irq(s);

}



static int ide_handle_write_error(IDEState *s, int error, int op)

{

    BlockInterfaceErrorAction action = drive_get_onerror(s->bs);



    if (action == BLOCK_ERR_IGNORE)

        return 0;



    if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)

            || action == BLOCK_ERR_STOP_ANY) {

        s->bmdma->ide_if = s;

        s->bmdma->status |= op;

        vm_stop(0);

    } else {

        if (op == BM_STATUS_DMA_RETRY)

            ide_dma_error(s);

        else

            ide_rw_error(s);

    }



    return 1;

}



/* return 0 if buffer completed */

static int dma_buf_rw(BMDMAState *bm, int is_write)

{
@@ -990,8 +1017,9 @@ static void ide_sector_write(IDEState *s) 
    if (n > s->req_nb_sectors)

        n = s->req_nb_sectors;

    ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);



    if (ret != 0) {

	ide_rw_error(s);

        if (ide_handle_write_error(s, -ret, BM_STATUS_PIO_RETRY))

            return;

    }
@@ -1024,6 +1052,20 @@ static void ide_sector_write(IDEState *s) 
    }

}



static void ide_dma_restart_cb(void *opaque, int running)

{

    BMDMAState *bm = opaque;

    if (!running)

        return;

    if (bm->status & BM_STATUS_DMA_RETRY) {

        bm->status &= ~BM_STATUS_DMA_RETRY;

        ide_dma_restart(bm->ide_if);

    } else if (bm->status & BM_STATUS_PIO_RETRY) {

        bm->status &= ~BM_STATUS_PIO_RETRY;

        ide_sector_write(bm->ide_if);

    }

}



static void ide_write_dma_cb(void *opaque, int ret)

{

    BMDMAState *bm = opaque;
@@ -1032,7 +1074,7 @@ static void ide_write_dma_cb(void *opaque, int ret) 
    int64_t sector_num;



    if (ret < 0) {

	ide_dma_error(s);

        if (ide_handle_write_error(s, -ret,  BM_STATUS_DMA_RETRY))

            return;

    }
@@ -2849,11 +2891,25 @@ static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb) 
    bm->cur_prd_last = 0;

    bm->cur_prd_addr = 0;

    bm->cur_prd_len = 0;

    bm->sector_num = ide_get_sector(s);

    bm->nsector = s->nsector;

    if (bm->status & BM_STATUS_DMAING) {

        bm->dma_cb(bm, 0);

    }

}



static void ide_dma_restart(IDEState *s)

{

    BMDMAState *bm = s->bmdma;

    ide_set_sector(s, bm->sector_num);

    s->io_buffer_index = 0;

    s->io_buffer_size = 0;

    s->nsector = bm->nsector;

    bm->cur_addr = bm->addr;

    bm->dma_cb = ide_write_dma_cb;

    ide_dma_start(s, bm->dma_cb);

}



static void ide_dma_cancel(BMDMAState *bm)

{

    if (bm->status & BM_STATUS_DMAING) {
@@ -3043,6 +3099,7 @@ static void bmdma_map(PCIDevice *pci_dev, int region_num, 
        d->ide_if[2 * i].bmdma = bm;

        d->ide_if[2 * i + 1].bmdma = bm;

        bm->pci_dev = (PCIIDEState *)pci_dev;

        qemu_add_vm_change_state_handler(ide_dma_restart_cb, bm);



        register_ioport_write(addr, 1, 1, bmdma_cmd_writeb, bm);
@@ -3068,9 +3125,14 @@ static void pci_ide_save(QEMUFile* f, void *opaque) 


    for(i = 0; i < 2; i++) {

        BMDMAState *bm = &d->bmdma[i];

        uint8_t ifidx;

        qemu_put_8s(f, &bm->cmd);

        qemu_put_8s(f, &bm->status);

        qemu_put_be32s(f, &bm->addr);

        qemu_put_sbe64s(f, &bm->sector_num);

        qemu_put_be32s(f, &bm->nsector);

        ifidx = bm->ide_if ? bm->ide_if - d->ide_if : 0;

        qemu_put_8s(f, &ifidx);

        /* XXX: if a transfer is pending, we do not save it yet */

    }
@@ -3094,7 +3156,7 @@ static int pci_ide_load(QEMUFile* f, void *opaque, int version_id) 
    PCIIDEState *d = opaque;

    int ret, i;



    if (version_id != 1)

    if (version_id != 2)

        return -EINVAL;

    ret = pci_device_load(&d->dev, f);

    if (ret < 0)
@@ -3102,9 +3164,14 @@ static int pci_ide_load(QEMUFile* f, void *opaque, int version_id) 


    for(i = 0; i < 2; i++) {

        BMDMAState *bm = &d->bmdma[i];

        uint8_t ifidx;

        qemu_get_8s(f, &bm->cmd);

        qemu_get_8s(f, &bm->status);

        qemu_get_be32s(f, &bm->addr);

        qemu_get_sbe64s(f, &bm->sector_num);

        qemu_get_be32s(f, &bm->nsector);

        qemu_get_8s(f, &ifidx);

        bm->ide_if = &d->ide_if[ifidx];

        /* XXX: if a transfer is pending, we do not save it yet */

    }
@@ -3212,7 +3279,7 @@ void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table, 
    ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], irq[0]);

    ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], irq[1]);



    register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);

    register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);

    qemu_register_reset(cmd646_reset, d);

    cmd646_reset(d);

}
@@ -3269,7 +3336,7 @@ void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn, 
    ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);

    ide_init_ioport(&d->ide_if[2], 0x170, 0x376);



    register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);

    register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);

}



/* hd_table must contain 4 block drivers */
@@ -3308,7 +3375,7 @@ void pci_piix4_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn, 
    ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);

    ide_init_ioport(&d->ide_if[2], 0x170, 0x376);



    register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);

    register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);

}



/***********************************************************/

sysemu.h

+7 −0
Original line number Diff line number Diff line
@@ -128,11 +128,17 @@ typedef enum { 
    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO

} BlockInterfaceType;



typedef enum {

    BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,

    BLOCK_ERR_STOP_ANY

} BlockInterfaceErrorAction;



typedef struct DriveInfo {

    BlockDriverState *bdrv;

    BlockInterfaceType type;

    int bus;

    int unit;

    BlockInterfaceErrorAction onerror;

    char serial[21];

} DriveInfo;
@@ -146,6 +152,7 @@ extern DriveInfo drives_table[MAX_DRIVES+1]; 
extern int drive_get_index(BlockInterfaceType type, int bus, int unit);

extern int drive_get_max_bus(BlockInterfaceType type);

extern const char *drive_get_serial(BlockDriverState *bdrv);

extern BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv);



/* serial ports */

vl.c

+35 −2
Original line number Diff line number Diff line
@@ -2200,6 +2200,17 @@ const char *drive_get_serial(BlockDriverState *bdrv) 
    return "\0";

}



BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)

{

    int index;



    for (index = 0; index < nb_drives; index++)

        if (drives_table[index].bdrv == bdrv)

            return drives_table[index].onerror;



    return BLOCK_ERR_REPORT;

}



static void bdrv_format_print(void *opaque, const char *name)

{

    fprintf(stderr, " %s", name);
@@ -2222,12 +2233,13 @@ static int drive_init(struct drive_opt *arg, int snapshot, 
    int max_devs;

    int index;

    int cache;

    int bdrv_flags;

    int bdrv_flags, onerror;

    char *str = arg->opt;

    static const char * const params[] = { "bus", "unit", "if", "index",

                                           "cyls", "heads", "secs", "trans",

                                           "media", "snapshot", "file",

                                           "cache", "format", "serial", NULL };

                                           "cache", "format", "serial", "werror",

                                           NULL };



    if (check_params(buf, sizeof(buf), params, str) < 0) {

         fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
@@ -2417,6 +2429,26 @@ static int drive_init(struct drive_opt *arg, int snapshot, 
    if (!get_param_value(serial, sizeof(serial), "serial", str))

	    memset(serial, 0,  sizeof(serial));



    onerror = BLOCK_ERR_REPORT;

    if (get_param_value(buf, sizeof(serial), "werror", str)) {

        if (type != IF_IDE) {

            fprintf(stderr, "werror is supported only by IDE\n");

            return -1;

        }

        if (!strcmp(buf, "ignore"))

            onerror = BLOCK_ERR_IGNORE;

        else if (!strcmp(buf, "enospc"))

            onerror = BLOCK_ERR_STOP_ENOSPC;

        else if (!strcmp(buf, "stop"))

            onerror = BLOCK_ERR_STOP_ANY;

        else if (!strcmp(buf, "report"))

            onerror = BLOCK_ERR_REPORT;

        else {

            fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);

            return -1;

        }

    }



    /* compute bus and unit according index */



    if (index != -1) {
@@ -2480,6 +2512,7 @@ static int drive_init(struct drive_opt *arg, int snapshot, 
    drives_table[nb_drives].type = type;

    drives_table[nb_drives].bus = bus_id;

    drives_table[nb_drives].unit = unit_id;

    drives_table[nb_drives].onerror = onerror;

    strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));

    nb_drives++;