lib/libbdev/bdev.c

   1 /* libbdev - block device interfacing library, by D.C. van Moolenbroek */
   2
   3 #include <minix/drivers.h>
   4 #include <minix/bdev.h>
   5 #include <minix/ioctl.h>
   6 #include <assert.h>
   7
   8 #include "const.h"
   9 #include "type.h"
  10 #include "proto.h"
  11
  12 void bdev_driver(dev_t dev, char *label)
  13 {
  14 /* Associate a driver with the given (major) device, using its endpoint.
  15  * File system usage note: typically called from mount and newdriver.
  16  */
  17   static int first = TRUE;
  18
  19   if (first) {
  20         /* Initialize the driver endpoint array. */
  21         bdev_driver_init();
  22
  23         first = FALSE;
  24   }
  25
  26   bdev_update(dev, label);
  27 }
  28
  29 static int bdev_retry(int *driver_tries, int *transfer_tries, int *result)
  30 {
  31 /* Return TRUE iff the call result implies that we should retry the operation.
  32  */
  33
  34   switch (*result) {
  35   case ERESTART:
  36         /* We get this error internally if the driver has restarted and the
  37          * current operation may now go through. Check the retry count for
  38          * driver restarts first, as we don't want to keep trying forever.
  39          */
  40         if (++*driver_tries < DRIVER_TRIES)
  41                 return TRUE;
  42
  43         *result = EDEADSRCDST;
  44
  45         break;
  46
  47   case EIO:
  48         /* The 'transfer_tries' pointer is non-NULL if this was a transfer
  49          * request. If we get back an I/O failure, keep retrying the request
  50          * until we hit the transfer retry limit.
  51          */
  52         if (transfer_tries != NULL && ++*transfer_tries < TRANSFER_TRIES)
  53                 return TRUE;
  54
  55         break;
  56   }
  57
  58   return FALSE;
  59 }
  60
  61 static int bdev_opcl(int req, dev_t dev, int access)
  62 {
  63 /* Open or close the given minor device.
  64  */
  65   message m;
  66   int r, driver_tries = 0;
  67
  68   do {
  69         memset(&m, 0, sizeof(m));
  70         m.m_type = req;
  71         m.BDEV_MINOR = minor(dev);
  72         m.BDEV_ACCESS = access;
  73
  74         r = bdev_sendrec(dev, &m);
  75   } while (bdev_retry(&driver_tries, NULL, &r));
  76
  77   return r;
  78 }
  79
  80 int bdev_open(dev_t dev, int access)
  81 {
  82 /* Open the given minor device.
  83  * File system usage note: typically called from mount, after bdev_driver.
  84  */
  85   int r;
  86
  87   r = bdev_opcl(BDEV_OPEN, dev, access);
  88
  89   if (r == OK)
  90         bdev_minor_add(dev, access);
  91
  92   return r;
  93 }
  94
  95 int bdev_close(dev_t dev)
  96 {
  97 /* Close the given minor device.
  98  * File system usage note: typically called from unmount.
  99  */
 100   int r;
 101
 102   bdev_flush_asyn(dev);
 103
 104   r = bdev_opcl(BDEV_CLOSE, dev, 0);
 105
 106   if (r == OK)
 107         bdev_minor_del(dev);
 108
 109   return r;
 110 }
 111
 112 static int bdev_rdwt_setup(int req, dev_t dev, u64_t pos, char *buf,
 113   size_t count, int flags, message *m)
 114 {
 115 /* Set up a single-buffer read/write request.
 116  */
 117   endpoint_t endpt;
 118   cp_grant_id_t grant;
 119   int access;
 120
 121   assert((ssize_t) count >= 0);
 122
 123   if ((endpt = bdev_driver_get(dev)) == NONE)
 124         return EDEADSRCDST;
 125
 126   access = (req == BDEV_READ) ? CPF_WRITE : CPF_READ;
 127
 128   grant = cpf_grant_direct(endpt, (vir_bytes) buf, count, access);
 129
 130   if (!GRANT_VALID(grant)) {
 131         printf("bdev: unable to allocate grant!\n");
 132         return EINVAL;
 133   }
 134
 135   memset(m, 0, sizeof(*m));
 136   m->m_type = req;
 137   m->BDEV_MINOR = minor(dev);
 138   m->BDEV_POS_LO = ex64lo(pos);
 139   m->BDEV_POS_HI = ex64hi(pos);
 140   m->BDEV_COUNT = count;
 141   m->BDEV_GRANT = grant;
 142   m->BDEV_FLAGS = flags;
 143
 144   return OK;
 145 }
 146
 147 static void bdev_rdwt_cleanup(const message *m)
 148 {
 149 /* Clean up a single-buffer read/write request.
 150  */
 151
 152   cpf_revoke(m->BDEV_GRANT);
 153 }
 154
 155 static ssize_t bdev_rdwt(int req, dev_t dev, u64_t pos, char *buf,
 156   size_t count, int flags)
 157 {
 158 /* Perform a synchronous read or write call using a single buffer.
 159  */
 160   message m;
 161   int r, driver_tries = 0, transfer_tries = 0;
 162
 163   do {
 164         if ((r = bdev_rdwt_setup(req, dev, pos, buf, count, flags, &m)) != OK)
 165                 break;
 166
 167         r = bdev_sendrec(dev, &m);
 168
 169         bdev_rdwt_cleanup(&m);
 170   } while (bdev_retry(&driver_tries, &transfer_tries, &r));
 171
 172   return r;
 173 }
 174
 175 static int bdev_vrdwt_setup(int req, dev_t dev, u64_t pos, iovec_t *vec,
 176   int count, int flags, message *m, iovec_s_t *gvec)
 177 {
 178 /* Set up a vectored read/write request.
 179  */
 180   ssize_t size;
 181   endpoint_t endpt;
 182   cp_grant_id_t grant;
 183   int i, access;
 184
 185   assert(count <= NR_IOREQS);
 186
 187   if ((endpt = bdev_driver_get(dev)) == NONE)
 188         return EDEADSRCDST;
 189
 190   access = (req == BDEV_GATHER) ? CPF_WRITE : CPF_READ;
 191   size = 0;
 192
 193   for (i = 0; i < count; i++) {
 194         grant = cpf_grant_direct(endpt, vec[i].iov_addr, vec[i].iov_size,
 195                 access);
 196
 197         if (!GRANT_VALID(grant)) {
 198                 printf("bdev: unable to allocate grant!\n");
 199
 200                 for (i--; i >= 0; i--)
 201                         cpf_revoke(gvec[i].iov_grant);
 202
 203                 return EINVAL;
 204         }
 205
 206         gvec[i].iov_grant = grant;
 207         gvec[i].iov_size = vec[i].iov_size;
 208
 209         assert((ssize_t) (size + vec[i].iov_size) > size);
 210
 211         size += vec[i].iov_size;
 212   }
 213
 214   grant = cpf_grant_direct(endpt, (vir_bytes) gvec, sizeof(gvec[0]) * count,
 215         CPF_READ);
 216
 217   if (!GRANT_VALID(grant)) {
 218         printf("bdev: unable to allocate grant!\n");
 219
 220         for (i = count - 1; i >= 0; i--)
 221                 cpf_revoke(gvec[i].iov_grant);
 222
 223         return EINVAL;
 224   }
 225
 226   memset(m, 0, sizeof(*m));
 227   m->m_type = req;
 228   m->BDEV_MINOR = minor(dev);
 229   m->BDEV_POS_LO = ex64lo(pos);
 230   m->BDEV_POS_HI = ex64hi(pos);
 231   m->BDEV_COUNT = count;
 232   m->BDEV_GRANT = grant;
 233   m->BDEV_FLAGS = flags;
 234
 235   return OK;
 236 }
 237
 238 static void bdev_vrdwt_cleanup(const message *m, iovec_s_t *gvec)
 239 {
 240 /* Clean up a vectored read/write request.
 241  */
 242   cp_grant_id_t grant;
 243   int i;
 244
 245   grant = m->BDEV_GRANT;
 246
 247   cpf_revoke(grant);
 248
 249   for (i = m->BDEV_COUNT - 1; i >= 0; i--)
 250         cpf_revoke(gvec[i].iov_grant);
 251 }
 252
 253 static ssize_t bdev_vrdwt(int req, dev_t dev, u64_t pos, iovec_t *vec,
 254   int count, int flags)
 255 {
 256 /* Perform a synchronous read or write call using a vector of buffers.
 257  */
 258   iovec_s_t gvec[NR_IOREQS];
 259   message m;
 260   int r, driver_tries = 0, transfer_tries = 0;
 261
 262   do {
 263         if ((r = bdev_vrdwt_setup(req, dev, pos, vec, count, flags, &m,
 264                         gvec)) != OK)
 265                 break;
 266
 267         r = bdev_sendrec(dev, &m);
 268
 269         bdev_vrdwt_cleanup(&m, gvec);
 270   } while (bdev_retry(&driver_tries, &transfer_tries, &r));
 271
 272   return r;
 273 }
 274
 275 ssize_t bdev_read(dev_t dev, u64_t pos, char *buf, size_t count, int flags)
 276 {
 277 /* Perform a synchronous read call into a single buffer.
 278  */
 279
 280   return bdev_rdwt(BDEV_READ, dev, pos, buf, count, flags);
 281 }
 282
 283 ssize_t bdev_write(dev_t dev, u64_t pos, char *buf, size_t count, int flags)
 284 {
 285 /* Perform a synchronous write call from a single buffer.
 286  */
 287
 288   return bdev_rdwt(BDEV_WRITE, dev, pos, buf, count, flags);
 289 }
 290
 291 ssize_t bdev_gather(dev_t dev, u64_t pos, iovec_t *vec, int count, int flags)
 292 {
 293 /* Perform a synchronous read call into a vector of buffers.
 294  */
 295
 296   return bdev_vrdwt(BDEV_GATHER, dev, pos, vec, count, flags);
 297 }
 298
 299 ssize_t bdev_scatter(dev_t dev, u64_t pos, iovec_t *vec, int count, int flags)
 300 {
 301 /* Perform a synchronous write call from a vector of buffers.
 302  */
 303
 304   return bdev_vrdwt(BDEV_SCATTER, dev, pos, vec, count, flags);
 305 }
 306
 307 static int bdev_ioctl_setup(dev_t dev, int request, void *buf, message *m)
 308 {
 309 /* Set up an I/O control request.
 310  */
 311   endpoint_t endpt;
 312   size_t size;
 313   cp_grant_id_t grant;
 314   int access;
 315
 316   if ((endpt = bdev_driver_get(dev)) == NONE)
 317         return EDEADSRCDST;
 318
 319   if (_MINIX_IOCTL_BIG(request))
 320         size = _MINIX_IOCTL_SIZE_BIG(request);
 321   else
 322         size = _MINIX_IOCTL_SIZE(request);
 323
 324   access = 0;
 325   if (_MINIX_IOCTL_IOR(access)) access |= CPF_WRITE;
 326   if (_MINIX_IOCTL_IOW(access)) access |= CPF_READ;
 327
 328   /* The size may be 0, in which case 'buf' need not be a valid pointer. */
 329   grant = cpf_grant_direct(endpt, (vir_bytes) buf, size, access);
 330
 331   if (!GRANT_VALID(grant)) {
 332         printf("bdev: unable to allocate grant!\n");
 333         return EINVAL;
 334   }
 335
 336   memset(m, 0, sizeof(*m));
 337   m->m_type = BDEV_IOCTL;
 338   m->BDEV_MINOR = minor(dev);
 339   m->BDEV_REQUEST = request;
 340   m->BDEV_GRANT = grant;
 341
 342   return OK;
 343 }
 344
 345 static void bdev_ioctl_cleanup(const message *m)
 346 {
 347 /* Clean up an I/O control request.
 348  */
 349
 350   cpf_revoke(m->BDEV_GRANT);
 351 }
 352
 353 int bdev_ioctl(dev_t dev, int request, void *buf)
 354 {
 355 /* Perform a synchronous I/O control request.
 356  */
 357   message m;
 358   int r, driver_tries = 0;
 359
 360   do {
 361         if ((r = bdev_ioctl_setup(dev, request, buf, &m)) != OK)
 362                 break;
 363
 364         r = bdev_sendrec(dev, &m);
 365
 366         bdev_ioctl_cleanup(&m);
 367   } while (bdev_retry(&driver_tries, NULL, &r));
 368
 369   return r;
 370 }
 371
 372 void bdev_flush_asyn(dev_t dev)
 373 {
 374 /* Flush all ongoing asynchronous requests to the given minor device. This
 375  * involves blocking until all I/O for it has completed.
 376  * File system usage note: typically called from flush.
 377  */
 378   bdev_call_t *call;
 379
 380   while ((call = bdev_call_find(dev)) != NULL)
 381         (void) bdev_wait_asyn(call->id);
 382 }
 383
 384 static bdev_id_t bdev_rdwt_asyn(int req, dev_t dev, u64_t pos, char *buf,
 385         size_t count, int flags, bdev_callback_t callback, bdev_param_t param)
 386 {
 387 /* Perform an asynchronous read or write call using a single buffer.
 388  */
 389   bdev_call_t *call;
 390   int r;
 391
 392   if ((call = bdev_call_alloc(1)) == NULL)
 393         return ENOMEM;
 394
 395   if ((r = bdev_rdwt_setup(req, dev, pos, buf, count, flags, &call->msg)) !=
 396                 OK) {
 397         bdev_call_free(call);
 398
 399         return r;
 400   }
 401
 402   if ((r = bdev_senda(dev, &call->msg, call->id)) != OK) {
 403         bdev_rdwt_cleanup(&call->msg);
 404
 405         bdev_call_free(call);
 406
 407         return r;
 408   }
 409
 410   call->dev = dev;
 411   call->callback = callback;
 412   call->param = param;
 413   call->driver_tries = 0;
 414   call->transfer_tries = 0;
 415   call->vec[0].iov_addr = (vir_bytes) buf;
 416   call->vec[0].iov_size = count;
 417
 418   return call->id;
 419 }
 420
 421 static bdev_id_t bdev_vrdwt_asyn(int req, dev_t dev, u64_t pos, iovec_t *vec,
 422         int count, int flags, bdev_callback_t callback, bdev_param_t param)
 423 {
 424 /* Perform an asynchronous read or write call using a vector of buffers.
 425  */
 426   bdev_call_t *call;
 427   int r;
 428
 429   if ((call = bdev_call_alloc(count)) == NULL)
 430         return ENOMEM;
 431
 432   if ((r = bdev_vrdwt_setup(req, dev, pos, vec, count, flags, &call->msg,
 433                 call->gvec)) != OK) {
 434         bdev_call_free(call);
 435
 436         return r;
 437   }
 438
 439   if ((r = bdev_senda(dev, &call->msg, call->id)) != OK) {
 440         bdev_vrdwt_cleanup(&call->msg, call->gvec);
 441
 442         bdev_call_free(call);
 443
 444         return r;
 445   }
 446
 447   call->dev = dev;
 448   call->callback = callback;
 449   call->param = param;
 450   call->driver_tries = 0;
 451   call->transfer_tries = 0;
 452   memcpy(call->vec, vec, sizeof(vec[0]) * count);
 453
 454   return call->id;
 455 }
 456
 457 bdev_id_t bdev_read_asyn(dev_t dev, u64_t pos, char *buf, size_t count,
 458         int flags, bdev_callback_t callback, bdev_param_t param)
 459 {
 460 /* Perform an asynchronous read call into a single buffer.
 461  */
 462
 463   return bdev_rdwt_asyn(BDEV_READ, dev, pos, buf, count, flags, callback,
 464         param);
 465 }
 466
 467 bdev_id_t bdev_write_asyn(dev_t dev, u64_t pos, char *buf, size_t count,
 468         int flags, bdev_callback_t callback, bdev_param_t param)
 469 {
 470 /* Perform an asynchronous write call from a single buffer.
 471  */
 472
 473   return bdev_rdwt_asyn(BDEV_WRITE, dev, pos, buf, count, flags, callback,
 474         param);
 475 }
 476
 477 bdev_id_t bdev_gather_asyn(dev_t dev, u64_t pos, iovec_t *vec, int count,
 478         int flags, bdev_callback_t callback, bdev_param_t param)
 479 {
 480 /* Perform an asynchronous read call into a vector of buffers.
 481  */
 482
 483   return bdev_vrdwt_asyn(BDEV_GATHER, dev, pos, vec, count, flags, callback,
 484         param);
 485 }
 486
 487 bdev_id_t bdev_scatter_asyn(dev_t dev, u64_t pos, iovec_t *vec, int count,
 488         int flags, bdev_callback_t callback, bdev_param_t param)
 489 {
 490 /* Perform an asynchronous write call into a vector of buffers.
 491  */
 492
 493   return bdev_vrdwt_asyn(BDEV_SCATTER, dev, pos, vec, count, flags, callback,
 494         param);
 495 }
 496
 497 bdev_id_t bdev_ioctl_asyn(dev_t dev, int request, void *buf,
 498         bdev_callback_t callback, bdev_param_t param)
 499 {
 500 /* Perform an asynchronous I/O control request.
 501  */
 502   bdev_call_t *call;
 503   int r;
 504
 505   if ((call = bdev_call_alloc(1)) == NULL)
 506         return ENOMEM;
 507
 508   if ((r = bdev_ioctl_setup(dev, request, buf, &call->msg)) != OK) {
 509         bdev_call_free(call);
 510
 511         return r;
 512   }
 513
 514   if ((r = bdev_senda(dev, &call->msg, call->id)) != OK) {
 515         bdev_ioctl_cleanup(&call->msg);
 516
 517         bdev_call_free(call);
 518
 519         return r;
 520   }
 521
 522   call->dev = dev;
 523   call->callback = callback;
 524   call->param = param;
 525   call->driver_tries = 0;
 526   call->vec[0].iov_addr = (vir_bytes) buf;
 527
 528   return call->id;
 529 }
 530
 531 void bdev_callback_asyn(bdev_call_t *call, int result)
 532 {
 533 /* Perform the callback for an asynchronous request, with the given result.
 534  * Clean up the call structure afterwards.
 535  */
 536
 537   /* If this was a transfer request and the result is EIO, we may want to retry
 538    * the request first.
 539    */
 540   switch (call->msg.m_type) {
 541   case BDEV_READ:
 542   case BDEV_WRITE:
 543   case BDEV_GATHER:
 544   case BDEV_SCATTER:
 545         if (result == EIO && ++call->transfer_tries < TRANSFER_TRIES) {
 546                 result = bdev_senda(call->dev, &call->msg, call->id);
 547
 548                 if (result == OK)
 549                         return;
 550         }
 551   }
 552
 553   /* Clean up. */
 554   switch (call->msg.m_type) {
 555   case BDEV_READ:
 556   case BDEV_WRITE:
 557         bdev_rdwt_cleanup(&call->msg);
 558
 559         break;
 560
 561   case BDEV_GATHER:
 562   case BDEV_SCATTER:
 563         bdev_vrdwt_cleanup(&call->msg, call->gvec);
 564
 565         break;
 566
 567   case BDEV_IOCTL:
 568         bdev_ioctl_cleanup(&call->msg);
 569
 570         break;
 571
 572   default:
 573         assert(0);
 574   }
 575
 576   /* Call the callback function. */
 577   /* FIXME: we assume all reasonable ssize_t values can be stored in an int. */
 578   call->callback(call->dev, call->id, call->param, result);
 579
 580   /* Free up the call structure. */
 581   bdev_call_free(call);
 582 }
 583
 584 int bdev_restart_asyn(bdev_call_t *call)
 585 {
 586 /* The driver for the given call has restarted, and may now have a new
 587  * endpoint. Recreate and resend the request for the given call.
 588  */
 589   int type, r = OK;
 590
 591   /* Update and check the retry limit for driver restarts first. */
 592   if (++call->driver_tries >= DRIVER_TRIES)
 593         return EDEADSRCDST;
 594
 595   /* Recreate all grants for the new endpoint. */
 596   type = call->msg.m_type;
 597
 598   switch (type) {
 599   case BDEV_READ:
 600   case BDEV_WRITE:
 601         bdev_rdwt_cleanup(&call->msg);
 602
 603         r = bdev_rdwt_setup(type, call->dev,
 604                 make64(call->msg.BDEV_POS_LO, call->msg.BDEV_POS_HI),
 605                 (char *) call->vec[0].iov_addr, call->msg.BDEV_COUNT,
 606                 call->msg.BDEV_FLAGS, &call->msg);
 607
 608         break;
 609
 610   case BDEV_GATHER:
 611   case BDEV_SCATTER:
 612         bdev_vrdwt_cleanup(&call->msg, call->gvec);
 613
 614         r = bdev_vrdwt_setup(type, call->dev,
 615                 make64(call->msg.BDEV_POS_LO, call->msg.BDEV_POS_HI),
 616                 call->vec, call->msg.BDEV_COUNT, call->msg.BDEV_FLAGS,
 617                 &call->msg, call->gvec);
 618
 619         break;
 620
 621   case BDEV_IOCTL:
 622         bdev_ioctl_cleanup(&call->msg);
 623
 624         r = bdev_ioctl_setup(call->dev, call->msg.BDEV_REQUEST,
 625                 (char *) call->vec[0].iov_addr, &call->msg);
 626
 627         break;
 628
 629   default:
 630         assert(0);
 631   }
 632
 633   if (r != OK)
 634         return r;
 635
 636   /* Try to resend the request. */
 637   return bdev_senda(call->dev, &call->msg, call->id);
 638 }