drivers/xen/blktap2/blktap.h

   1 #ifndef _BLKTAP_H_
   2 #define _BLKTAP_H_
   3
   4 #include <linux/slab.h>
   5 #include <linux/fs.h>
   6 #include <linux/poll.h>
   7 #include <linux/cdev.h>
   8 #include <linux/init.h>
   9 #include <linux/scatterlist.h>
  10 #include <xen/blkif.h>
  11 #include <xen/gnttab.h>
  12
  13 //#define ENABLE_PASSTHROUGH
  14
  15 extern int blktap_debug_level;
  16
  17 #define BTPRINTK(level, tag, force, _f, _a...)                          \
  18         do {                                                            \
  19                 if (blktap_debug_level > level &&                       \
  20                     (force || printk_ratelimit()))                      \
  21                         printk(tag "%s: " _f, __func__, ##_a);          \
  22         } while (0)
  23
  24 #define BTDBG(_f, _a...)             BTPRINTK(8, KERN_DEBUG, 1, _f, ##_a)
  25 #define BTINFO(_f, _a...)            BTPRINTK(0, KERN_INFO, 0, _f, ##_a)
  26 #define BTWARN(_f, _a...)            BTPRINTK(0, KERN_WARNING, 0, _f, ##_a)
  27 #define BTERR(_f, _a...)             BTPRINTK(0, KERN_ERR, 0, _f, ##_a)
  28
  29 #define BLKTAP2_DEV_DIR "xen/blktap-2/"
  30
  31 #define BLKTAP_CONTROL               1
  32 #define BLKTAP_RING_FD               2
  33 #define BLKTAP_RING_VMA              3
  34 #define BLKTAP_DEVICE                4
  35 #define BLKTAP_SYSFS                 5
  36 #define BLKTAP_PAUSE_REQUESTED       6
  37 #define BLKTAP_PAUSED                7
  38 #define BLKTAP_SHUTDOWN_REQUESTED    8
  39 #define BLKTAP_PASSTHROUGH           9
  40 #define BLKTAP_DEFERRED              10
  41
  42 /* blktap IOCTLs: */
  43 #define BLKTAP2_IOCTL_KICK_FE        1
  44 #define BLKTAP2_IOCTL_ALLOC_TAP      200
  45 #define BLKTAP2_IOCTL_FREE_TAP       201
  46 #define BLKTAP2_IOCTL_CREATE_DEVICE  202
  47 #define BLKTAP2_IOCTL_SET_PARAMS     203
  48 #define BLKTAP2_IOCTL_PAUSE          204
  49 #define BLKTAP2_IOCTL_REOPEN         205
  50 #define BLKTAP2_IOCTL_RESUME         206
  51
  52 #define BLKTAP2_MAX_MESSAGE_LEN      256
  53
  54 #define BLKTAP2_RING_MESSAGE_PAUSE   1
  55 #define BLKTAP2_RING_MESSAGE_RESUME  2
  56 #define BLKTAP2_RING_MESSAGE_CLOSE   3
  57
  58 #define BLKTAP_REQUEST_FREE          0
  59 #define BLKTAP_REQUEST_PENDING       1
  60
  61 /*
  62  * The maximum number of requests that can be outstanding at any time
  63  * is determined by
  64  *
  65  *   [mmap_alloc * MAX_PENDING_REQS * BLKIF_MAX_SEGMENTS_PER_REQUEST]
  66  *
  67  * where mmap_alloc < MAX_DYNAMIC_MEM.
  68  *
  69  * TODO:
  70  * mmap_alloc is initialised to 2 and should be adjustable on the fly via
  71  * sysfs.
  72  */
  73 #define BLK_RING_SIZE           __CONST_RING_SIZE(blkif, PAGE_SIZE)
  74 #define MAX_DYNAMIC_MEM         BLK_RING_SIZE
  75 #define MAX_PENDING_REQS        BLK_RING_SIZE
  76 #define MMAP_PAGES (MAX_PENDING_REQS * BLKIF_MAX_SEGMENTS_PER_REQUEST)
  77 #define MMAP_VADDR(_start, _req, _seg)                                  \
  78         (_start +                                                       \
  79          ((_req) * BLKIF_MAX_SEGMENTS_PER_REQUEST * PAGE_SIZE) +        \
  80          ((_seg) * PAGE_SIZE))
  81
  82 #define blktap_get(_b) (atomic_inc(&(_b)->refcnt))
  83 #define blktap_put(_b)                                  \
  84         do {                                            \
  85                 if (atomic_dec_and_test(&(_b)->refcnt)) \
  86                         wake_up(&(_b)->wq);             \
  87         } while (0)
  88
  89 struct blktap;
  90
  91 struct grant_handle_pair {
  92         grant_handle_t                 kernel;
  93         grant_handle_t                 user;
  94 };
  95 #define INVALID_GRANT_HANDLE           0xFFFF
  96
  97 struct blktap_handle {
  98         unsigned int                   ring;
  99         unsigned int                   device;
 100         unsigned int                   minor;
 101 };
 102
 103 struct blktap_params {
 104         char                           name[BLKTAP2_MAX_MESSAGE_LEN];
 105         unsigned long long             capacity;
 106         unsigned long                  sector_size;
 107 };
 108
 109 struct blktap_device {
 110         int                            users;
 111         spinlock_t                     lock;
 112         struct gendisk                *gd;
 113
 114 #ifdef ENABLE_PASSTHROUGH
 115         struct block_device           *bdev;
 116 #endif
 117 };
 118
 119 struct blktap_ring {
 120         struct vm_area_struct         *vma;
 121         blkif_front_ring_t             ring;
 122         struct vm_foreign_map          foreign_map;
 123         unsigned long                  ring_vstart;
 124         unsigned long                  user_vstart;
 125
 126         int                            response;
 127
 128         wait_queue_head_t              poll_wait;
 129
 130         dev_t                          devno;
 131         struct device                 *dev;
 132         atomic_t                       sysfs_refcnt;
 133         struct mutex                   sysfs_mutex;
 134 };
 135
 136 struct blktap_statistics {
 137         unsigned long                  st_print;
 138         int                            st_rd_req;
 139         int                            st_wr_req;
 140         int                            st_oo_req;
 141         int                            st_pk_req;
 142         int                            st_rd_sect;
 143         int                            st_wr_sect;
 144         s64                            st_rd_cnt;
 145         s64                            st_rd_sum_usecs;
 146         s64                            st_rd_max_usecs;
 147         s64                            st_wr_cnt;
 148         s64                            st_wr_sum_usecs;
 149         s64                            st_wr_max_usecs;
 150 };
 151
 152 struct blktap_request {
 153         uint64_t                       id;
 154         uint16_t                       usr_idx;
 155
 156         uint8_t                        status;
 157         atomic_t                       pendcnt;
 158         uint8_t                        nr_pages;
 159         unsigned short                 operation;
 160
 161         struct timeval                 time;
 162         struct grant_handle_pair       handles[BLKIF_MAX_SEGMENTS_PER_REQUEST];
 163         struct list_head               free_list;
 164 };
 165
 166 struct blktap {
 167         int                            minor;
 168         pid_t                          pid;
 169         atomic_t                       refcnt;
 170         unsigned long                  dev_inuse;
 171
 172         struct blktap_params           params;
 173
 174         struct rw_semaphore            tap_sem;
 175
 176         struct blktap_ring             ring;
 177         struct blktap_device           device;
 178
 179         int                            pending_cnt;
 180         struct blktap_request         *pending_requests[MAX_PENDING_REQS];
 181         struct scatterlist             sg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
 182
 183         wait_queue_head_t              wq;
 184         struct list_head               deferred_queue;
 185
 186         struct blktap_statistics       stats;
 187 };
 188
 189 extern struct blktap *blktaps[];
 190
 191 static inline int
 192 blktap_active(struct blktap *tap)
 193 {
 194         return test_bit(BLKTAP_RING_VMA, &tap->dev_inuse);
 195 }
 196
 197 static inline int
 198 blktap_validate_params(struct blktap *tap, struct blktap_params *params)
 199 {
 200         /* TODO: sanity check */
 201         params->name[sizeof(params->name) - 1] = '\0';
 202         BTINFO("%s: capacity: %llu, sector-size: %lu\n",
 203                params->name, params->capacity, params->sector_size);
 204         return 0;
 205 }
 206
 207 int blktap_control_destroy_device(struct blktap *);
 208 int blktap_control_finish_destroy(struct blktap *);
 209
 210 int blktap_ring_init(int *);
 211 int blktap_ring_free(void);
 212 int blktap_ring_create(struct blktap *);
 213 int blktap_ring_destroy(struct blktap *);
 214 int blktap_ring_pause(struct blktap *);
 215 int blktap_ring_resume(struct blktap *);
 216 void blktap_ring_kick_user(struct blktap *);
 217
 218 #ifdef CONFIG_SYSFS
 219 int blktap_sysfs_init(void);
 220 void blktap_sysfs_free(void);
 221 int blktap_sysfs_create(struct blktap *);
 222 int blktap_sysfs_destroy(struct blktap *);
 223 #else
 224 static inline int blktap_sysfs_init(void) { return 0; }
 225 static inline void blktap_sysfs_exit(void) {}
 226 static inline int blktap_sysfs_create(struct blktap *tapdev) { return 0; }
 227 static inline int blktap_sysfs_destroy(struct blktap *tapdev) { return 0; }
 228 #endif
 229
 230 int blktap_device_init(int *);
 231 void blktap_device_free(void);
 232 int blktap_device_create(struct blktap *);
 233 int blktap_device_destroy(struct blktap *);
 234 int blktap_device_pause(struct blktap *);
 235 int blktap_device_resume(struct blktap *);
 236 void blktap_device_restart(struct blktap *);
 237 void blktap_device_finish_request(struct blktap *,
 238                                   blkif_response_t *,
 239                                   struct blktap_request *);
 240 void blktap_device_fail_pending_requests(struct blktap *);
 241 #ifdef ENABLE_PASSTHROUGH
 242 int blktap_device_enable_passthrough(struct blktap *,
 243                                      unsigned, unsigned);
 244 #endif
 245
 246 void blktap_defer(struct blktap *);
 247 void blktap_run_deferred(void);
 248
 249 int blktap_request_pool_init(void);
 250 void blktap_request_pool_free(void);
 251 int blktap_request_pool_grow(void);
 252 int blktap_request_pool_shrink(void);
 253 struct blktap_request *blktap_request_allocate(struct blktap *);
 254 void blktap_request_free(struct blktap *, struct blktap_request *);
 255 struct page *request_to_page(struct blktap_request *, int);
 256
 257 static inline unsigned long
 258 request_to_kaddr(struct blktap_request *req, int seg)
 259 {
 260         unsigned long pfn = page_to_pfn(request_to_page(req, seg));
 261         return (unsigned long)pfn_to_kaddr(pfn);
 262 }
 263
 264 #endif