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         case REQ_OP_FLUSH:
  83                 ret = fsync(bio->bi_bdev->bd_fd);
  84                 if (ret)
  85                         die("fsync error: %m");
  86                 bio_endio(bio);
  87                 break;
  88         default:
  89                 BUG();
  90         }
  91 }
  92
  93 static void submit_bio_wait_endio(struct bio *bio)
  94 {
  95         complete(bio->bi_private);
  96 }
  97
  98 int submit_bio_wait(struct bio *bio)
  99 {
 100         struct completion done;
 101
 102         init_completion(&done);
 103         bio->bi_private = &done;
 104         bio->bi_end_io = submit_bio_wait_endio;
 105         bio->bi_opf |= REQ_SYNC;
 106         submit_bio(bio);
 107         wait_for_completion(&done);
 108
 109         return bio->bi_error;
 110 }
 111
 112 int blkdev_issue_discard(struct block_device *bdev,
 113                          sector_t sector, sector_t nr_sects,
 114                          gfp_t gfp_mask, unsigned long flags)
 115 {
 116         return 0;
 117 }
 118
 119 unsigned bdev_logical_block_size(struct block_device *bdev)
 120 {
 121         struct stat statbuf;
 122         unsigned blksize;
 123         int ret;
 124
 125         ret = fstat(bdev->bd_fd, &statbuf);
 126         BUG_ON(ret);
 127
 128         if (!S_ISBLK(statbuf.st_mode))
 129                 return statbuf.st_blksize >> 9;
 130
 131         ret = ioctl(bdev->bd_fd, BLKPBSZGET, &blksize);
 132         BUG_ON(ret);
 133
 134         return blksize >> 9;
 135 }
 136
 137 sector_t get_capacity(struct gendisk *disk)
 138 {
 139         struct block_device *bdev =
 140                 container_of(disk, struct block_device, __bd_disk);
 141         struct stat statbuf;
 142         u64 bytes;
 143         int ret;
 144
 145         ret = fstat(bdev->bd_fd, &statbuf);
 146         BUG_ON(ret);
 147
 148         if (!S_ISBLK(statbuf.st_mode))
 149                 return statbuf.st_size >> 9;
 150
 151         ret = ioctl(bdev->bd_fd, BLKGETSIZE64, &bytes);
 152         BUG_ON(ret);
 153
 154         return bytes >> 9;
 155 }
 156
 157 void blkdev_put(struct block_device *bdev, fmode_t mode)
 158 {
 159         fdatasync(bdev->bd_fd);
 160         close(bdev->bd_sync_fd);
 161         close(bdev->bd_fd);
 162         free(bdev);
 163 }
 164
 165 struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
 166                                         void *holder)
 167 {
 168         struct block_device *bdev;
 169         int fd, sync_fd, flags = O_DIRECT;
 170
 171         if ((mode & (FMODE_READ|FMODE_WRITE)) == (FMODE_READ|FMODE_WRITE))
 172                 flags = O_RDWR;
 173         else if (mode & FMODE_READ)
 174                 flags = O_RDONLY;
 175         else if (mode & FMODE_WRITE)
 176                 flags = O_WRONLY;
 177
 178 #if 0
 179         /* using O_EXCL doesn't work with opening twice for an O_SYNC fd: */
 180         if (mode & FMODE_EXCL)
 181                 flags |= O_EXCL;
 182 #endif
 183
 184         fd = open(path, flags);
 185         if (fd < 0)
 186                 return ERR_PTR(-errno);
 187
 188         sync_fd = open(path, flags|O_SYNC);
 189         if (sync_fd < 0) {
 190                 assert(0);
 191                 close(fd);
 192                 return ERR_PTR(-errno);
 193         }
 194
 195         bdev = malloc(sizeof(*bdev));
 196         memset(bdev, 0, sizeof(*bdev));
 197
 198         strncpy(bdev->name, path, sizeof(bdev->name));
 199         bdev->name[sizeof(bdev->name) - 1] = '\0';
 200
 201         bdev->bd_fd             = fd;
 202         bdev->bd_sync_fd        = sync_fd;
 203         bdev->bd_holder         = holder;
 204         bdev->bd_disk           = &bdev->__bd_disk;
 205         bdev->bd_bdi            = &bdev->__bd_bdi;
 206         bdev->queue.backing_dev_info = bdev->bd_bdi;
 207
 208         return bdev;
 209 }
 210
 211 void bdput(struct block_device *bdev)
 212 {
 213         BUG();
 214 }
 215
 216 struct block_device *lookup_bdev(const char *path)
 217 {
 218         return ERR_PTR(-EINVAL);
 219 }
 220
 221 static int aio_completion_thread(void *arg)
 222 {
 223         struct io_event events[8], *ev;
 224         int ret;
 225
 226         while (1) {
 227                 ret = io_getevents(aio_ctx, 1, ARRAY_SIZE(events),
 228                                    events, NULL);
 229
 230                 if (ret < 0 && ret == -EINTR)
 231                         continue;
 232                 if (ret < 0)
 233                         die("io_getevents() error: %s", strerror(-ret));
 234
 235                 for (ev = events; ev < events + ret; ev++) {
 236                         struct bio *bio = (struct bio *) ev->data;
 237
 238                         if (ev->res < 0)
 239                                 bio->bi_error = ev->res;
 240                         else if (ev->res != bio->bi_iter.bi_size)
 241                                 bio->bi_error = -EIO;
 242
 243                         bio_endio(bio);
 244                 }
 245         }
 246
 247         return 0;
 248 }
 249
 250 __attribute__((constructor(102)))
 251 static void blkdev_init(void)
 252 {
 253         struct task_struct *p;
 254
 255         if (io_setup(256, &aio_ctx))
 256                 die("io_setup() error: %m");
 257
 258         p = kthread_run(aio_completion_thread, NULL, "aio_completion");
 259         BUG_ON(IS_ERR(p));
 260 }