/* * Block driver for RAW files (posix) * * Copyright (c) 2006 Fabrice Bellard * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */#include "qemu-common.h"#ifndef QEMU_IMG#include "qemu-timer.h"#include "exec-all.h"#endif#include "block_int.h"#include <assert.h>#include <aio.h>#ifdef CONFIG_COCOA#include <paths.h>#include <sys/param.h>#include <IOKit/IOKitLib.h>#include <IOKit/IOBSD.h>#include <IOKit/storage/IOMediaBSDClient.h>#include <IOKit/storage/IOMedia.h>#include <IOKit/storage/IOCDMedia.h>//#include <IOKit/storage/IOCDTypes.h>#include <CoreFoundation/CoreFoundation.h>#endif#ifdef __sun__#define _POSIX_PTHREAD_SEMANTICS 1#include <signal.h>#include <sys/dkio.h>#endif#ifdef __linux__#include <sys/ioctl.h>#include <linux/cdrom.h>#include <linux/fd.h>#endif#ifdef __FreeBSD__#include <sys/disk.h>#endif//#define DEBUG_FLOPPY//#define DEBUG_BLOCK#if defined(DEBUG_BLOCK) && !defined(QEMU_IMG)#define DEBUG_BLOCK_PRINT(formatCstr, args...) do { if (loglevel != 0)	\    { fprintf(logfile, formatCstr, ##args); fflush(logfile); } } while (0)#else#define DEBUG_BLOCK_PRINT(formatCstr, args...)#endif#define FTYPE_FILE   0#define FTYPE_CD     1#define FTYPE_FD     2/* if the FD is not accessed during that time (in ms), we try to   reopen it to see if the disk has been changed */#define FD_OPEN_TIMEOUT 1000typedef struct BDRVRawState {    int fd;    int type;    unsigned int lseek_err_cnt;#if defined(__linux__)    /* linux floppy specific */    int fd_open_flags;    int64_t fd_open_time;    int64_t fd_error_time;    int fd_got_error;    int fd_media_changed;#endif} BDRVRawState;static int fd_open(BlockDriverState *bs);static int raw_open(BlockDriverState *bs, const char *filename, int flags){    BDRVRawState *s = bs->opaque;    int fd, open_flags, ret;    s->lseek_err_cnt = 0;    open_flags = O_BINARY;    if ((flags & BDRV_O_ACCESS) == O_RDWR) {        open_flags |= O_RDWR;    } else {        open_flags |= O_RDONLY;        bs->read_only = 1;    }    if (flags & BDRV_O_CREAT)        open_flags |= O_CREAT | O_TRUNC;#ifdef O_DIRECT    if (flags & BDRV_O_DIRECT)        open_flags |= O_DIRECT;#endif    s->type = FTYPE_FILE;    fd = open(filename, open_flags, 0644);    if (fd < 0) {        ret = -errno;        if (ret == -EROFS)            ret = -EACCES;        return ret;    }    s->fd = fd;    return 0;}/* XXX: use host sector size if necessary with:#ifdef DIOCGSECTORSIZE        {            unsigned int sectorsize = 512;            if (!ioctl(fd, DIOCGSECTORSIZE, &sectorsize) &&                sectorsize > bufsize)                bufsize = sectorsize;        }#endif#ifdef CONFIG_COCOA        u_int32_t   blockSize = 512;        if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {            bufsize = blockSize;        }#endif*/static int raw_pread(BlockDriverState *bs, int64_t offset,                     uint8_t *buf, int count){    BDRVRawState *s = bs->opaque;    int ret;    ret = fd_open(bs);    if (ret < 0)        return ret;    if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) {        ++(s->lseek_err_cnt);        if(s->lseek_err_cnt <= 10) {            DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64                              "] lseek failed : %d = %s\n",                              s->fd, bs->filename, offset, buf, count,                              bs->total_sectors, errno, strerror(errno));        }        return -1;    }    s->lseek_err_cnt=0;    ret = read(s->fd, buf, count);    if (ret == count)        goto label__raw_read__success;    DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64                      "] read failed %d : %d = %s\n",                      s->fd, bs->filename, offset, buf, count,                      bs->total_sectors, ret, errno, strerror(errno));    /* Try harder for CDrom. */    if (bs->type == BDRV_TYPE_CDROM) {        lseek(s->fd, offset, SEEK_SET);        ret = read(s->fd, buf, count);        if (ret == count)            goto label__raw_read__success;        lseek(s->fd, offset, SEEK_SET);        ret = read(s->fd, buf, count);        if (ret == count)            goto label__raw_read__success;        DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64                          "] retry read failed %d : %d = %s\n",                          s->fd, bs->filename, offset, buf, count,                          bs->total_sectors, ret, errno, strerror(errno));    }label__raw_read__success:    return ret;}static int raw_pwrite(BlockDriverState *bs, int64_t offset,                      const uint8_t *buf, int count){    BDRVRawState *s = bs->opaque;    int ret;    ret = fd_open(bs);    if (ret < 0)        return ret;    if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) {        ++(s->lseek_err_cnt);        if(s->lseek_err_cnt) {            DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%"                              PRId64 "] lseek failed : %d = %s\n",                              s->fd, bs->filename, offset, buf, count,                              bs->total_sectors, errno, strerror(errno));        }        return -1;    }    s->lseek_err_cnt = 0;    ret = write(s->fd, buf, count);    if (ret == count)        goto label__raw_write__success;    DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%" PRId64                      "] write failed %d : %d = %s\n",                      s->fd, bs->filename, offset, buf, count,                      bs->total_sectors, ret, errno, strerror(errno));label__raw_write__success:    return ret;}/***********************************************************//* Unix AIO using POSIX AIO */typedef struct RawAIOCB {    BlockDriverAIOCB common;    struct aiocb aiocb;    struct RawAIOCB *next;} RawAIOCB;static int aio_sig_num = SIGUSR2;static RawAIOCB *first_aio; /* AIO issued */static int aio_initialized = 0;static void aio_signal_handler(int signum){#ifndef QEMU_IMG    CPUState *env = cpu_single_env;    if (env) {        /* stop the currently executing cpu because a timer occured */        cpu_interrupt(env, CPU_INTERRUPT_EXIT);#ifdef USE_KQEMU        if (env->kqemu_enabled) {            kqemu_cpu_interrupt(env);        }#endif    }#endif}void qemu_aio_init(void){    struct sigaction act;    aio_initialized = 1;    sigfillset(&act.sa_mask);    act.sa_flags = 0; /* do not restart syscalls to interrupt select() */    act.sa_handler = aio_signal_handler;    sigaction(aio_sig_num, &act, NULL);#if defined(__GLIBC__) && defined(__linux__)    {        /* XXX: aio thread exit seems to hang on RedHat 9 and this init           seems to fix the problem. */        struct aioinit ai;        memset(&ai, 0, sizeof(ai));        ai.aio_threads = 1;        ai.aio_num = 1;        ai.aio_idle_time = 365 * 100000;        aio_init(&ai);    }#endif}void qemu_aio_poll(void){    RawAIOCB *acb, **pacb;    int ret;    for(;;) {        pacb = &first_aio;        for(;;) {            acb = *pacb;            if (!acb)                goto the_end;            ret = aio_error(&acb->aiocb);            if (ret == ECANCELED) {                /* remove the request */                *pacb = acb->next;                qemu_aio_release(acb);            } else if (ret != EINPROGRESS) {                /* end of aio */                if (ret == 0) {                    ret = aio_return(&acb->aiocb);                    if (ret == acb->aiocb.aio_nbytes)                        ret = 0;                    else                        ret = -EINVAL;                } else {                    ret = -ret;                }                /* remove the request */                *pacb = acb->next;                /* call the callback */                acb->common.cb(acb->common.opaque, ret);                qemu_aio_release(acb);                break;            } else {                pacb = &acb->next;            }        }    } the_end: ;}/* Wait for all IO requests to complete.  */void qemu_aio_flush(void){    qemu_aio_wait_start();    qemu_aio_poll();    while (first_aio) {        qemu_aio_wait();    }    qemu_aio_wait_end();}/* wait until at least one AIO was handled */static sigset_t wait_oset;void qemu_aio_wait_start(void){    sigset_t set;    if (!aio_initialized)        qemu_aio_init();    sigemptyset(&set);    sigaddset(&set, aio_sig_num);    sigprocmask(SIG_BLOCK, &set, &wait_oset);}void qemu_aio_wait(void){    sigset_t set;    int nb_sigs;#ifndef QEMU_IMG    if (qemu_bh_poll())        return;#endif    sigemptyset(&set);    sigaddset(&set, aio_sig_num);    sigwait(&set, &nb_sigs);    qemu_aio_poll();}void qemu_aio_wait_end(void){    sigprocmask(SIG_SETMASK, &wait_oset, NULL);}static RawAIOCB *raw_aio_setup(BlockDriverState *bs,        int64_t sector_num, uint8_t *buf, int nb_sectors,        BlockDriverCompletionFunc *cb, void *opaque){    BDRVRawState *s = bs->opaque;    RawAIOCB *acb;    if (fd_open(bs) < 0)        return NULL;    acb = qemu_aio_get(bs, cb, opaque);    if (!acb)        return NULL;    acb->aiocb.aio_fildes = s->fd;    acb->aiocb.aio_sigevent.sigev_signo = aio_sig_num;    acb->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;    acb->aiocb.aio_buf = buf;    if (nb_sectors < 0)        acb->aiocb.aio_nbytes = -nb_sectors;    else        acb->aiocb.aio_nbytes = nb_sectors * 512;    acb->aiocb.aio_offset = sector_num * 512;    acb->next = first_aio;    first_aio = acb;    return acb;}static BlockDriverAIOCB *raw_aio_read(BlockDriverState *bs,        int64_t sector_num, uint8_t *buf, int nb_sectors,        BlockDriverCompletionFunc *cb, void *opaque){    RawAIOCB *acb;    acb = raw_aio_setup(bs, sector_num, buf, nb_sectors, cb, opaque);    if (!acb)        return NULL;    if (aio_read(&acb->aiocb) < 0) {        qemu_aio_release(acb);        return NULL;    }    return &acb->common;}static BlockDriverAIOCB *raw_aio_write(BlockDriverState *bs,        int64_t sector_num, const uint8_t *buf, int nb_sectors,        BlockDriverCompletionFunc *cb, void *opaque){    RawAIOCB *acb;    acb = raw_aio_setup(bs, sector_num, (uint8_t*)buf, nb_sectors, cb, opaque);    if (!acb)        return NULL;    if (aio_write(&acb->aiocb) < 0) {        qemu_aio_release(acb);        return NULL;    }    return &acb->common;}static void raw_aio_cancel(BlockDriverAIOCB *blockacb){    int ret;    RawAIOCB *acb = (RawAIOCB *)blockacb;    RawAIOCB **pacb;    ret = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);    if (ret == AIO_NOTCANCELED) {        /* fail safe: if the aio could not be canceled, we wait for           it */        while (aio_error(&acb->aiocb) == EINPROGRESS);    }    /* remove the callback from the queue */    pacb = &first_aio;    for(;;) {        if (*pacb == NULL) {            break;        } else if (*pacb == acb) {            *pacb = acb->next;            qemu_aio_release(acb);            break;        }        pacb = &acb->next;    }}static void raw_close(BlockDriverState *bs){    BDRVRawState *s = bs->opaque;    if (s->fd >= 0) {        close(s->fd);        s->fd = -1;