git.sesse.net Git - bcachefs-tools-debian/blob - linux/blkdev.c

   1
   2 #include <alloca.h>
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <sys/ioctl.h>
   6 #include <sys/stat.h>
   7 #include <sys/types.h>
   8 #include <sys/uio.h>
   9 #include <unistd.h>
  10
  11 #include <libaio.h>
  12
  13 #include <linux/bio.h>
  14 #include <linux/blkdev.h>
  15 #include <linux/completion.h>
  16 #include <linux/fs.h>
  17 #include <linux/kthread.h>
  18
  19 #include "tools-util.h"
  20
  21 static io_context_t aio_ctx;
  22
  23 void generic_make_request(struct bio *bio)
  24 {
  25         struct iovec *iov;
  26         struct bvec_iter iter;
  27         struct bio_vec bv;
  28         ssize_t ret;
  29         unsigned i;
  30
  31         if (bio->bi_opf & REQ_PREFLUSH) {
  32                 ret = fdatasync(bio->bi_bdev->bd_fd);
  33                 if (ret) {
  34                         fprintf(stderr, "fsync error: %m\n");
  35                         bio->bi_error = -EIO;
  36                         bio_endio(bio);
  37                         return;
  38                 }
  39         }
  40
  41         i = 0;
  42         bio_for_each_segment(bv, bio, iter)
  43                 i++;
  44
  45         iov = alloca(sizeof(*iov) * i);
  46
  47         i = 0;
  48         bio_for_each_segment(bv, bio, iter)
  49                 iov[i++] = (struct iovec) {
  50                         .iov_base = page_address(bv.bv_page) + bv.bv_offset,
  51                         .iov_len = bv.bv_len,
  52                 };
  53
  54         struct iocb iocb = {
  55                 .data           = bio,
  56                 .aio_fildes     = bio->bi_opf & REQ_FUA
  57                         ? bio->bi_bdev->bd_sync_fd
  58                         : bio->bi_bdev->bd_fd,
  59         }, *iocbp = &iocb;
  60
  61         switch (bio_op(bio)) {
  62         case REQ_OP_READ:
  63                 iocb.aio_lio_opcode     = IO_CMD_PREADV;
  64                 iocb.u.v.vec            = iov;
  65                 iocb.u.v.nr             = i;
  66                 iocb.u.v.offset         = bio->bi_iter.bi_sector << 9;
  67
  68                 ret = io_submit(aio_ctx, 1, &iocbp);
  69                 if (ret != 1)
  70                         die("io_submit err: %s", strerror(-ret));
  71                 break;
  72         case REQ_OP_WRITE:
  73                 iocb.aio_lio_opcode     = IO_CMD_PWRITEV;
  74                 iocb.u.v.vec            = iov;
  75                 iocb.u.v.nr             = i;
  76                 iocb.u.v.offset         = bio->bi_iter.bi_sector << 9;
  77
  78                 ret = io_submit(aio_ctx, 1, &iocbp);
  79                 if (ret != 1)
  80                         die("io_submit err: %s", strerror(-ret));
  81                 break;
  82         default:
  83                 BUG();
  84         }
  85 }
  86
  87 static void submit_bio_wait_endio(struct bio *bio)
  88 {
  89         complete(bio->bi_private);
  90 }
  91
  92 int submit_bio_wait(struct bio *bio)
  93 {
  94         struct completion done;
  95
  96         init_completion(&done);
  97         bio->bi_private = &done;
  98         bio->bi_end_io = submit_bio_wait_endio;
  99         bio->bi_opf |= REQ_SYNC;
 100         submit_bio(bio);
 101         wait_for_completion(&done);
 102
 103         return bio->bi_error;
 104 }
 105
 106 int blkdev_issue_discard(struct block_device *bdev,
 107                          sector_t sector, sector_t nr_sects,
 108                          gfp_t gfp_mask, unsigned long flags)
 109 {
 110         return 0;
 111 }
 112
 113 unsigned bdev_logical_block_size(struct block_device *bdev)
 114 {
 115         struct stat statbuf;
 116         unsigned blksize;
 117         int ret;
 118
 119         ret = fstat(bdev->bd_fd, &statbuf);
 120         BUG_ON(ret);
 121
 122         if (!S_ISBLK(statbuf.st_mode))
 123                 return statbuf.st_blksize >> 9;
 124
 125         ret = ioctl(bdev->bd_fd, BLKPBSZGET, &blksize);
 126         BUG_ON(ret);
 127
 128         return blksize >> 9;
 129 }
 130
 131 sector_t get_capacity(struct gendisk *disk)
 132 {
 133         struct block_device *bdev =
 134                 container_of(disk, struct block_device, __bd_disk);
 135         struct stat statbuf;
 136         u64 bytes;
 137         int ret;
 138
 139         ret = fstat(bdev->bd_fd, &statbuf);
 140         BUG_ON(ret);
 141
 142         if (!S_ISBLK(statbuf.st_mode))
 143                 return statbuf.st_size >> 9;
 144
 145         ret = ioctl(bdev->bd_fd, BLKGETSIZE64, &bytes);
 146         BUG_ON(ret);
 147
 148         return bytes >> 9;
 149 }
 150
 151 void blkdev_put(struct block_device *bdev, fmode_t mode)
 152 {
 153         fdatasync(bdev->bd_fd);
 154         close(bdev->bd_sync_fd);
 155         close(bdev->bd_fd);
 156         free(bdev);
 157 }
 158
 159 struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
 160                                         void *holder)
 161 {
 162         struct block_device *bdev;
 163         int fd, sync_fd, flags = O_DIRECT;
 164
 165         if ((mode & (FMODE_READ|FMODE_WRITE)) == (FMODE_READ|FMODE_WRITE))
 166                 flags = O_RDWR;
 167         else if (mode & FMODE_READ)
 168                 flags = O_RDONLY;
 169         else if (mode & FMODE_WRITE)
 170                 flags = O_WRONLY;
 171
 172 #if 0
 173         /* using O_EXCL doesn't work with opening twice for an O_SYNC fd: */
 174         if (mode & FMODE_EXCL)
 175                 flags |= O_EXCL;
 176 #endif
 177
 178         fd = open(path, flags);
 179         if (fd < 0)
 180                 return ERR_PTR(-errno);
 181
 182         sync_fd = open(path, flags|O_SYNC);
 183         if (sync_fd < 0) {
 184                 assert(0);
 185                 close(fd);
 186                 return ERR_PTR(-errno);
 187         }
 188
 189         bdev = malloc(sizeof(*bdev));
 190         memset(bdev, 0, sizeof(*bdev));
 191
 192         strncpy(bdev->name, path, sizeof(bdev->name));
 193         bdev->name[sizeof(bdev->name) - 1] = '\0';
 194
 195         bdev->bd_fd             = fd;
 196         bdev->bd_sync_fd        = sync_fd;
 197         bdev->bd_holder         = holder;
 198         bdev->bd_disk           = &bdev->__bd_disk;
 199         bdev->bd_bdi            = &bdev->__bd_bdi;
 200         bdev->queue.backing_dev_info = bdev->bd_bdi;
 201
 202         return bdev;
 203 }
 204
 205 void bdput(struct block_device *bdev)
 206 {
 207         BUG();
 208 }
 209
 210 struct block_device *lookup_bdev(const char *path)
 211 {
 212         return ERR_PTR(-EINVAL);
 213 }
 214
 215 static int aio_completion_thread(void *arg)
 216 {
 217         struct io_event events[8], *ev;
 218         int ret;
 219
 220         while (1) {
 221                 ret = io_getevents(aio_ctx, 1, ARRAY_SIZE(events),
 222                                    events, NULL);
 223
 224                 if (ret < 0 && ret == -EINTR)
 225                         continue;
 226                 if (ret < 0)
 227                         die("io_getevents() error: %s", strerror(-ret));
 228
 229                 for (ev = events; ev < events + ret; ev++) {
 230                         struct bio *bio = (struct bio *) ev->data;
 231
 232                         if (ev->res < 0)
 233                                 bio->bi_error = ev->res;
 234                         else if (ev->res != bio->bi_iter.bi_size)
 235                                 bio->bi_error = -EIO;
 236
 237                         bio_endio(bio);
 238                 }
 239         }
 240
 241         return 0;
 242 }
 243
 244 __attribute__((constructor(102)))
 245 static void blkdev_init(void)
 246 {
 247         struct task_struct *p;
 248
 249         if (io_setup(256, &aio_ctx))
 250                 die("io_setup() error: %m");
 251
 252         p = kthread_run(aio_completion_thread, NULL, "aio_completion");
 253         BUG_ON(IS_ERR(p));
 254 }