1: /*
    2:  * QEMU System Emulator block driver
    3:  *
    4:  * Copyright (c) 2003 Fabrice Bellard
    5:  *
    6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    7:  * of this software and associated documentation files (the "Software"), to deal
    8:  * in the Software without restriction, including without limitation the rights
    9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   10:  * copies of the Software, and to permit persons to whom the Software is
   11:  * furnished to do so, subject to the following conditions:
   12:  *
   13:  * The above copyright notice and this permission notice shall be included in
   14:  * all copies or substantial portions of the Software.
   15:  *
   16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   22:  * THE SOFTWARE.
   23:  */
   24: #ifndef BLOCK_INT_H
   25: #define BLOCK_INT_H
   26: 
   27: #include "block.h"
   28: 
   29: #define BLOCK_FLAG_ENCRYPT      1
   30: #define BLOCK_FLAG_COMPRESS     2
   31: #define BLOCK_FLAG_COMPAT6      4
   32: 
   33: struct BlockDriver {
   34:     const char *format_name;
   35:     int instance_size;
   36:     int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
   37:     int (*bdrv_open)(BlockDriverState *bs, const char *filename, int flags);
   38:     int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
   39:                      uint8_t *buf, int nb_sectors);
   40:     int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
   41:                       const uint8_t *buf, int nb_sectors);
   42:     void (*bdrv_close)(BlockDriverState *bs);
   43:     int (*bdrv_create)(const char *filename, int64_t total_sectors,
   44:                        const char *backing_file, int flags);
   45:     void (*bdrv_flush)(BlockDriverState *bs);
   46:     int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num,
   47:                              int nb_sectors, int *pnum);
   48:     int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
   49:     int (*bdrv_make_empty)(BlockDriverState *bs);
   50:     /* aio */
   51:     BlockDriverAIOCB *(*bdrv_aio_read)(BlockDriverState *bs,
   52:         int64_t sector_num, uint8_t *buf, int nb_sectors,
   53:         BlockDriverCompletionFunc *cb, void *opaque);
   54:     BlockDriverAIOCB *(*bdrv_aio_write)(BlockDriverState *bs,
   55:         int64_t sector_num, const uint8_t *buf, int nb_sectors,
   56:         BlockDriverCompletionFunc *cb, void *opaque);
   57:     void (*bdrv_aio_cancel)(BlockDriverAIOCB *acb);
   58:     int aiocb_size;
   59: 
   60:     const char *protocol_name;
   61:     int (*bdrv_pread)(BlockDriverState *bs, int64_t offset,
   62:                       uint8_t *buf, int count);
   63:     int (*bdrv_pwrite)(BlockDriverState *bs, int64_t offset,
   64:                        const uint8_t *buf, int count);
   65:     int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
   66:     int64_t (*bdrv_getlength)(BlockDriverState *bs);
   67:     int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
   68:                                  const uint8_t *buf, int nb_sectors);
   69: 
   70:     int (*bdrv_snapshot_create)(BlockDriverState *bs,
   71:                                 QEMUSnapshotInfo *sn_info);
   72:     int (*bdrv_snapshot_goto)(BlockDriverState *bs,
   73:                               const char *snapshot_id);
   74:     int (*bdrv_snapshot_delete)(BlockDriverState *bs, const char *snapshot_id);
   75:     int (*bdrv_snapshot_list)(BlockDriverState *bs,
   76:                               QEMUSnapshotInfo **psn_info);
   77:     int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
   78: 
   79:     /* removable device specific */
   80:     int (*bdrv_is_inserted)(BlockDriverState *bs);
   81:     int (*bdrv_media_changed)(BlockDriverState *bs);
   82:     int (*bdrv_eject)(BlockDriverState *bs, int eject_flag);
   83:     int (*bdrv_set_locked)(BlockDriverState *bs, int locked);
   84: 
   85:     /* to control generic scsi devices */
   86:     int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf);
   87: 
   88:     BlockDriverAIOCB *free_aiocb;
   89:     struct BlockDriver *next;
   90: };
   91: 
   92: struct BlockDriverState {
   93:     int64_t total_sectors; /* if we are reading a disk image, give its
   94:                               size in sectors */
   95:     int read_only; /* if true, the media is read only */
   96:     int removable; /* if true, the media can be removed */
   97:     int locked;    /* if true, the media cannot temporarily be ejected */
   98:     int encrypted; /* if true, the media is encrypted */
   99:     int sg;        /* if true, the device is a /dev/sg* */
  100:     /* event callback when inserting/removing */
  101:     void (*change_cb)(void *opaque);
  102:     void *change_opaque;
  103: 
  104:     BlockDriver *drv; /* NULL means no media */
  105:     void *opaque;
  106: 
  107:     int boot_sector_enabled;
  108:     uint8_t boot_sector_data[512];
  109: 
  110:     char filename[1024];
  111:     char backing_file[1024]; /* if non zero, the image is a diff of
  112:                                 this file image */
  113:     int is_temporary;
  114:     int media_changed;
  115: 
  116:     BlockDriverState *backing_hd;
  117:     /* async read/write emulation */
  118: 
  119:     void *sync_aiocb;
  120: 
  121:     /* I/O stats (display with "info blockstats"). */
  122:     uint64_t rd_bytes;
  123:     uint64_t wr_bytes;
  124:     uint64_t rd_ops;
  125:     uint64_t wr_ops;
  126: 
  127:     /* NOTE: the following infos are only hints for real hardware
  128:        drivers. They are not used by the block driver */
  129:     int cyls, heads, secs, translation;
  130:     int type;
  131:     char device_name[32];
  132:     BlockDriverState *next;
  133: };
  134: 
  135: struct BlockDriverAIOCB {
  136:     BlockDriverState *bs;
  137:     BlockDriverCompletionFunc *cb;
  138:     void *opaque;
  139:     BlockDriverAIOCB *next;
  140: };
  141: 
  142: void get_tmp_filename(char *filename, int size);
  143: 
  144: void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
  145:                    void *opaque);
  146: void qemu_aio_release(void *p);
  147: 
  148: BlockDriverState *bdrv_first;
  149: 
  150: #endif /* BLOCK_INT_H */