• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/block.h"
28  #include "qemu/option.h"
29  #include "qemu/queue.h"
30  
31  #define BLOCK_FLAG_ENCRYPT	1
32  #define BLOCK_FLAG_COMPRESS	2
33  #define BLOCK_FLAG_COMPAT6	4
34  
35  #define BLOCK_OPT_SIZE          "size"
36  #define BLOCK_OPT_ENCRYPT       "encryption"
37  #define BLOCK_OPT_COMPAT6       "compat6"
38  #define BLOCK_OPT_BACKING_FILE  "backing_file"
39  #define BLOCK_OPT_BACKING_FMT   "backing_fmt"
40  #define BLOCK_OPT_CLUSTER_SIZE  "cluster_size"
41  #define BLOCK_OPT_PREALLOC      "preallocation"
42  
43  typedef struct AIOPool {
44      void (*cancel)(BlockDriverAIOCB *acb);
45      int aiocb_size;
46      BlockDriverAIOCB *free_aiocb;
47  } AIOPool;
48  
49  struct BlockDriver {
50      const char *format_name;
51      int instance_size;
52      int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
53      int (*bdrv_probe_device)(const char *filename);
54      int (*bdrv_open)(BlockDriverState *bs, int flags);
55      int (*bdrv_file_open)(BlockDriverState *bs, const char *filename, int flags);
56      int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
57                       uint8_t *buf, int nb_sectors);
58      int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
59                        const uint8_t *buf, int nb_sectors);
60      void (*bdrv_close)(BlockDriverState *bs);
61      int (*bdrv_create)(const char *filename, QEMUOptionParameter *options);
62      void (*bdrv_flush)(BlockDriverState *bs);
63      int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num,
64                               int nb_sectors, int *pnum);
65      int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
66      int (*bdrv_make_empty)(BlockDriverState *bs);
67      /* aio */
68      BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
69          int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
70          BlockDriverCompletionFunc *cb, void *opaque);
71      BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
72          int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
73          BlockDriverCompletionFunc *cb, void *opaque);
74      BlockDriverAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
75          BlockDriverCompletionFunc *cb, void *opaque);
76  
77      int (*bdrv_aio_multiwrite)(BlockDriverState *bs, BlockRequest *reqs,
78          int num_reqs);
79      int (*bdrv_merge_requests)(BlockDriverState *bs, BlockRequest* a,
80          BlockRequest *b);
81  
82  
83      const char *protocol_name;
84      int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
85      int64_t (*bdrv_getlength)(BlockDriverState *bs);
86      int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
87                                   const uint8_t *buf, int nb_sectors);
88  
89      int (*bdrv_snapshot_create)(BlockDriverState *bs,
90                                  QEMUSnapshotInfo *sn_info);
91      int (*bdrv_snapshot_goto)(BlockDriverState *bs,
92                                const char *snapshot_id);
93      int (*bdrv_snapshot_delete)(BlockDriverState *bs, const char *snapshot_id);
94      int (*bdrv_snapshot_list)(BlockDriverState *bs,
95                                QEMUSnapshotInfo **psn_info);
96      int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
97  
98      int (*bdrv_save_vmstate)(BlockDriverState *bs, const uint8_t *buf,
99                               int64_t pos, int size);
100      int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf,
101                               int64_t pos, int size);
102  
103      int (*bdrv_change_backing_file)(BlockDriverState *bs,
104          const char *backing_file, const char *backing_fmt);
105  
106      /* removable device specific */
107      int (*bdrv_is_inserted)(BlockDriverState *bs);
108      int (*bdrv_media_changed)(BlockDriverState *bs);
109      int (*bdrv_eject)(BlockDriverState *bs, int eject_flag);
110      int (*bdrv_set_locked)(BlockDriverState *bs, int locked);
111  
112      /* to control generic scsi devices */
113      int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf);
114      BlockDriverAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
115          unsigned long int req, void *buf,
116          BlockDriverCompletionFunc *cb, void *opaque);
117  
118      /* List of options for creating images, terminated by name == NULL */
119      QEMUOptionParameter *create_options;
120  
121  
122      /*
123       * Returns 0 for completed check, -errno for internal errors.
124       * The check results are stored in result.
125       */
126      int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result);
127  
128      void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);
129  
130      /*
131       * Returns 1 if newly created images are guaranteed to contain only
132       * zeros, 0 otherwise.
133       */
134      int (*bdrv_has_zero_init)(BlockDriverState *bs);
135  
136      QLIST_ENTRY(BlockDriver) list;
137  };
138  
139  struct BlockDriverState {
140      int64_t total_sectors; /* if we are reading a disk image, give its
141                                size in sectors */
142      int read_only; /* if true, the media is read only */
143      int keep_read_only; /* if true, the media was requested to stay read only */
144      int open_flags; /* flags used to open the file, re-used for re-open */
145      int removable; /* if true, the media can be removed */
146      int locked;    /* if true, the media cannot temporarily be ejected */
147      int tray_open; /* if true, the virtual tray is open */
148      int encrypted; /* if true, the media is encrypted */
149      int valid_key; /* if true, a valid encryption key has been set */
150      int sg;        /* if true, the device is a /dev/sg* */
151      int probed;    /* if true, format was probed automatically */
152      /* event callback when inserting/removing */
153      void (*change_cb)(void *opaque);
154      void *change_opaque;
155  
156      BlockDriver *drv; /* NULL means no media */
157      void *opaque;
158  
159      DeviceState *peer;
160  
161      char filename[1024];
162      char backing_file[1024]; /* if non zero, the image is a diff of
163                                  this file image */
164      char backing_format[16]; /* if non-zero and backing_file exists */
165      int is_temporary;
166      int media_changed;
167  
168      BlockDriverState *backing_hd;
169      BlockDriverState *file;
170  
171      /* async read/write emulation */
172  
173      void *sync_aiocb;
174  
175      /* I/O stats (display with "info blockstats"). */
176      uint64_t rd_bytes;
177      uint64_t wr_bytes;
178      uint64_t rd_ops;
179      uint64_t wr_ops;
180      uint64_t wr_highest_sector;
181  
182      /* Whether the disk can expand beyond total_sectors */
183      int growable;
184  
185      /* the memory alignment required for the buffers handled by this driver */
186      int buffer_alignment;
187  
188      /* do we need to tell the quest if we have a volatile write cache? */
189      int enable_write_cache;
190  
191      /* NOTE: the following infos are only hints for real hardware
192         drivers. They are not used by the block driver */
193      int cyls, heads, secs, translation;
194      int type;
195      BlockErrorAction on_read_error, on_write_error;
196      char device_name[32];
197      unsigned long *dirty_bitmap;
198      int64_t dirty_count;
199      QTAILQ_ENTRY(BlockDriverState) list;
200      void *private;
201  };
202  
203  struct BlockDriverAIOCB {
204      AIOPool *pool;
205      BlockDriverState *bs;
206      BlockDriverCompletionFunc *cb;
207      void *opaque;
208      BlockDriverAIOCB *next;
209  };
210  
211  void get_tmp_filename(char *filename, int size);
212  
213  void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
214                     BlockDriverCompletionFunc *cb, void *opaque);
215  void qemu_aio_release(void *p);
216  
217  void *qemu_blockalign(BlockDriverState *bs, size_t size);
218  
219  #ifdef _WIN32
220  int is_windows_drive(const char *filename);
221  #endif
222  
223  typedef struct BlockConf {
224      BlockDriverState *bs;
225      uint16_t physical_block_size;
226      uint16_t logical_block_size;
227      uint16_t min_io_size;
228      uint32_t opt_io_size;
229  } BlockConf;
230  
get_physical_block_exp(BlockConf * conf)231  static inline unsigned int get_physical_block_exp(BlockConf *conf)
232  {
233      unsigned int exp = 0, size;
234  
235      for (size = conf->physical_block_size;
236          size > conf->logical_block_size;
237          size >>= 1) {
238          exp++;
239      }
240  
241      return exp;
242  }
243  
244  #define DEFINE_BLOCK_PROPERTIES(_state, _conf)                          \
245      DEFINE_PROP_DRIVE("drive", _state, _conf.bs),                       \
246      DEFINE_PROP_UINT16("logical_block_size", _state,                    \
247                         _conf.logical_block_size, 512),                  \
248      DEFINE_PROP_UINT16("physical_block_size", _state,                   \
249                         _conf.physical_block_size, 512),                 \
250      DEFINE_PROP_UINT16("min_io_size", _state, _conf.min_io_size, 0),  \
251      DEFINE_PROP_UINT32("opt_io_size", _state, _conf.opt_io_size, 0)
252  
253  #endif /* BLOCK_INT_H */
254