drivers/filter/driver.c

   1 /* Filter driver - lowest layer - disk driver management */
   2
   3 #include "inc.h"
   4
   5 /* Drivers. */
   6 static struct driverinfo driver[2];
   7
   8 /* State variables. */
   9 static endpoint_t self_ep;
  10 static asynmsg_t amsgtable[2];
  11
  12 static int size_known = 0;
  13 static u64_t disk_size;
  14
  15 static int problem_stats[BD_LAST] = { 0 };
  16
  17 /*===========================================================================*
  18  *                              driver_open                                  *
  19  *===========================================================================*/
  20 static int driver_open(int which)
  21 {
  22         /* Perform an open or close operation on the driver. This is
  23          * unfinished code: we should never be doing a blocking sendrec() to
  24          * the driver.
  25          */
  26         message msg;
  27         cp_grant_id_t gid;
  28         struct partition part;
  29         sector_t sectors;
  30         int r;
  31
  32         msg.m_type = DEV_OPEN;
  33         msg.DEVICE = driver[which].minor;
  34         msg.IO_ENDPT = self_ep;
  35         r = sendrec(driver[which].endpt, &msg);
  36
  37         if (r != OK) {
  38                 /* Should we restart the driver now? */
  39                 printf("Filter: driver_open: sendrec returned %d\n", r);
  40
  41                 return RET_REDO;
  42         }
  43
  44         if(msg.m_type != TASK_REPLY || msg.REP_STATUS != OK) {
  45                 printf("Filter: driver_open: sendrec returned %d, %d\n",
  46                         msg.m_type, msg.REP_STATUS);
  47
  48                 return RET_REDO;
  49         }
  50
  51         /* Take the opportunity to retrieve the hard disk size. */
  52         gid = cpf_grant_direct(driver[which].endpt,
  53                 (vir_bytes) &part, sizeof(part), CPF_WRITE);
  54         if(!GRANT_VALID(gid))
  55                 panic("invalid grant: %d", gid);
  56
  57         msg.m_type = DEV_IOCTL_S;
  58         msg.REQUEST = DIOCGETP;
  59         msg.DEVICE = driver[which].minor;
  60         msg.IO_ENDPT = self_ep;
  61         msg.IO_GRANT = (char *) gid;
  62
  63         r = sendrec(driver[which].endpt, &msg);
  64
  65         cpf_revoke(gid);
  66
  67         if (r != OK || msg.m_type != TASK_REPLY || msg.REP_STATUS != OK) {
  68                 /* Not sure what to do here, either. */
  69                 printf("Filter: ioctl(DIOCGETP) returned (%d, %d)\n",
  70                         r, msg.m_type);
  71
  72                 return RET_REDO;
  73         }
  74
  75         if(!size_known) {
  76                 disk_size = part.size;
  77                 size_known = 1;
  78                 sectors = div64u(disk_size, SECTOR_SIZE);
  79                 if(cmp64(mul64u(sectors, SECTOR_SIZE), disk_size)) {
  80                         printf("Filter: partition too large\n");
  81
  82                         return RET_REDO;
  83                 }
  84 #if DEBUG
  85                 printf("Filter: partition size: 0x%s / %lu sectors\n",
  86                         print64(disk_size), sectors);
  87 #endif
  88         } else {
  89                 if(cmp64(disk_size, part.size)) {
  90                         printf("Filter: partition size mismatch (%s != %s)\n",
  91                                 print64(part.size), print64(disk_size));
  92
  93                         return RET_REDO;
  94                 }
  95         }
  96
  97         return OK;
  98 }
  99
 100 /*===========================================================================*
 101  *                              driver_close                                 *
 102  *===========================================================================*/
 103 static int driver_close(int which)
 104 {
 105         message msg;
 106         int r;
 107
 108         msg.m_type = DEV_CLOSE;
 109         msg.DEVICE = driver[which].minor;
 110         msg.IO_ENDPT = self_ep;
 111         r = sendrec(driver[which].endpt, &msg);
 112
 113         if (r != OK) {
 114                 /* Should we restart the driver now? */
 115                 printf("Filter: driver_close: sendrec returned %d\n", r);
 116
 117                 return RET_REDO;
 118         }
 119
 120         if(msg.m_type != TASK_REPLY || msg.REP_STATUS != OK) {
 121                 printf("Filter: driver_close: sendrec returned %d, %d\n",
 122                         msg.m_type, msg.REP_STATUS);
 123
 124                 return RET_REDO;
 125         }
 126
 127         return OK;
 128 }
 129
 130 /*===========================================================================*
 131  *                              driver_init                                  *
 132  *===========================================================================*/
 133 void driver_init(void)
 134 {
 135         /* Initialize the driver layer. */
 136         int r;
 137
 138         self_ep = getprocnr();
 139
 140         memset(driver, 0, sizeof(driver));
 141
 142         /* Endpoints unknown. */
 143         driver[DRIVER_MAIN].endpt = NONE;
 144         driver[DRIVER_BACKUP].endpt = NONE;
 145
 146         /* Get disk driver's and this proc's endpoint. */
 147         driver[DRIVER_MAIN].label = MAIN_LABEL;
 148         driver[DRIVER_MAIN].minor = MAIN_MINOR;
 149
 150         /* No up received yet but expected when the driver starts. */
 151         driver[DRIVER_MAIN].up_event = UP_EXPECTED;
 152         driver[DRIVER_BACKUP].up_event = UP_EXPECTED;
 153
 154         r = ds_retrieve_label_endpt(driver[DRIVER_MAIN].label,
 155                 &driver[DRIVER_MAIN].endpt);
 156         if (r != OK) {
 157                 printf("Filter: failed to get main disk driver's endpoint: "
 158                         "%d\n", r);
 159                 bad_driver(DRIVER_MAIN, BD_DEAD, EFAULT);
 160                 check_driver(DRIVER_MAIN);
 161         }
 162         else if (driver_open(DRIVER_MAIN) != OK) {
 163                 panic("unhandled driver_open failure");
 164         }
 165
 166         if(USE_MIRROR) {
 167                 driver[DRIVER_BACKUP].label = BACKUP_LABEL;
 168                 driver[DRIVER_BACKUP].minor = BACKUP_MINOR;
 169
 170                 if(!strcmp(driver[DRIVER_MAIN].label,
 171                                 driver[DRIVER_BACKUP].label)) {
 172                         panic("same driver: not tested");
 173                 }
 174
 175                 r = ds_retrieve_label_endpt(driver[DRIVER_BACKUP].label,
 176                         &driver[DRIVER_BACKUP].endpt);
 177                 if (r != OK) {
 178                         printf("Filter: failed to get backup disk driver's "
 179                                 "endpoint: %d\n", r);
 180                         bad_driver(DRIVER_BACKUP, BD_DEAD, EFAULT);
 181                         check_driver(DRIVER_BACKUP);
 182                 }
 183                 else if (driver_open(DRIVER_BACKUP) != OK) {
 184                         panic("unhandled driver_open failure");
 185                 }
 186         }
 187 }
 188
 189 /*===========================================================================*
 190  *                              driver_shutdown                              *
 191  *===========================================================================*/
 192 void driver_shutdown(void)
 193 {
 194         /* Clean up. */
 195
 196 #if DEBUG
 197         printf("Filter: %u driver deaths, %u protocol errors, "
 198                 "%u data errors\n", problem_stats[BD_DEAD],
 199                 problem_stats[BD_PROTO], problem_stats[BD_DATA]);
 200 #endif
 201
 202         if(driver_close(DRIVER_MAIN) != OK)
 203                 printf("Filter: DEV_CLOSE failed on shutdown (1)\n");
 204
 205         if(USE_MIRROR)
 206                 if(driver_close(DRIVER_BACKUP) != OK)
 207                         printf("Filter: DEV_CLOSE failed on shutdown (2)\n");
 208 }
 209
 210 /*===========================================================================*
 211  *                              get_raw_size                                 *
 212  *===========================================================================*/
 213 u64_t get_raw_size(void)
 214 {
 215         /* Return the size of the raw disks as used by the filter driver.
 216          */
 217
 218         return disk_size;
 219 }
 220
 221 /*===========================================================================*
 222  *                              reset_kills                                  *
 223  *===========================================================================*/
 224 void reset_kills(void)
 225 {
 226         /* Reset kill and retry statistics. */
 227         driver[DRIVER_MAIN].kills = 0;
 228         driver[DRIVER_MAIN].retries = 0;
 229         driver[DRIVER_BACKUP].kills = 0;
 230         driver[DRIVER_BACKUP].retries = 0;
 231 }
 232
 233 /*===========================================================================*
 234  *                              bad_driver                                   *
 235  *===========================================================================*/
 236 int bad_driver(int which, int type, int error)
 237 {
 238         /* A disk driver has died or produced an error. Mark it so that we can
 239          * deal with it later, and return RET_REDO to indicate that the
 240          * current operation is to be retried. Also store an error code to
 241          * return to the user if the situation is unrecoverable.
 242          */
 243         driver[which].problem = type;
 244         driver[which].error = error;
 245
 246         return RET_REDO;
 247 }
 248
 249 /*===========================================================================*
 250  *                              new_driver_ep                                *
 251  *===========================================================================*/
 252 static int new_driver_ep(int which)
 253 {
 254         /* See if a new driver instance has already been started for the given
 255          * driver, by retrieving its entry from DS.
 256          */
 257         int r;
 258         endpoint_t endpt;
 259
 260         r = ds_retrieve_label_endpt(driver[which].label, &endpt);
 261
 262         if (r != OK) {
 263                 printf("Filter: DS query for %s failed\n",
 264                         driver[which].label);
 265
 266                 return 0;
 267         }
 268
 269         if (endpt == driver[which].endpt) {
 270 #if DEBUG
 271                 printf("Filter: same endpoint for %s\n", driver[which].label);
 272 #endif
 273                 return 0;
 274         }
 275
 276 #if DEBUG
 277         printf("Filter: new enpdoint for %s: %d -> %d\n", driver[which].label,
 278                 driver[which].endpt, endpt);
 279 #endif
 280
 281         driver[which].endpt = endpt;
 282
 283         return 1;
 284 }
 285
 286 /*===========================================================================*
 287  *                              check_problem                                *
 288  *===========================================================================*/
 289 static int check_problem(int which, int problem, int retries, int *tell_rs)
 290 {
 291         /* A problem has occurred with a driver. Update statistics, and decide
 292          * what to do. If EAGAIN is returned, the driver should be restarted;
 293          * any other result will be passed up.
 294          */
 295
 296 #if DEBUG
 297         printf("Filter: check_problem processing driver %d, problem %d\n",
 298                 which, problem);
 299 #endif
 300
 301         problem_stats[problem]++;
 302
 303         if(new_driver_ep(which)) {
 304 #if DEBUG
 305                 printf("Filter: check_problem: noticed a new driver\n");
 306 #endif
 307
 308                 if(driver_open(which) == OK) {
 309 #if DEBUG2
 310                         printf("Filter: open OK -> no recovery\n");
 311 #endif
 312                         return OK;
 313                 } else {
 314 #if DEBUG2
 315                         printf("Filter: open not OK -> recovery\n");
 316 #endif
 317                         problem = BD_PROTO;
 318                         problem_stats[problem]++;
 319                 }
 320         }
 321
 322         /* If the driver has died, we always need to restart it. If it has
 323          * been giving problems, we first retry the request, up to N times,
 324          * after which we kill and restart the driver. We restart the driver
 325          * up to M times, after which we remove the driver from the mirror
 326          * configuration. If we are not set up to do mirroring, we can only
 327          * do one thing, and that is continue to limp along with the bad
 328          * driver..
 329          */
 330         switch(problem) {
 331         case BD_PROTO:
 332         case BD_DATA:
 333                 driver[which].retries++;
 334
 335 #if DEBUG
 336                 printf("Filter: disk driver %d has had "
 337                         "%d/%d retry attempts, %d/%d kills\n", which,
 338                         driver[which].retries, NR_RETRIES,
 339                         driver[which].kills, NR_RESTARTS);
 340 #endif
 341
 342                 if (driver[which].retries < NR_RETRIES) {
 343                         if(retries == 1) {
 344 #if DEBUG
 345                                 printf("Filter: not restarting; retrying "
 346                                         "(retries %d/%d, kills %d/%d)\n",
 347                                         driver[which].retries, NR_RETRIES,
 348                                         driver[which].kills, NR_RESTARTS);
 349 #endif
 350                                 return OK;
 351                         }
 352 #if DEBUG
 353                         printf("Filter: restarting (retries %d/%d, "
 354                                 "kills %d/%d, internal retry %d)\n",
 355                                 driver[which].retries, NR_RETRIES,
 356                                 driver[which].kills, NR_RESTARTS, retries);
 357 #endif
 358                 }
 359
 360 #if DEBUG
 361                 printf("Filter: disk driver %d has reached error "
 362                         "threshold, restarting driver\n", which);
 363 #endif
 364
 365                 *tell_rs = (driver[which].up_event != UP_PENDING);
 366                 break;
 367
 368         case BD_DEAD:
 369                 /* Can't kill that which is already dead.. */
 370                 *tell_rs = 0;
 371                 break;
 372
 373         default:
 374                 panic("invalid problem: %d", problem);
 375         }
 376
 377         /* At this point, the driver will be restarted. */
 378         driver[which].retries = 0;
 379         driver[which].kills++;
 380
 381         if (driver[which].kills < NR_RESTARTS)
 382                 return EAGAIN;
 383
 384         /* We've reached the maximum number of restarts for this driver. */
 385         if (USE_MIRROR) {
 386                 printf("Filter: kill threshold reached, disabling mirroring\n");
 387
 388                 USE_MIRROR = 0;
 389
 390                 if (which == DRIVER_MAIN) {
 391                         driver[DRIVER_MAIN] = driver[DRIVER_BACKUP];
 392
 393                         /* This is not necessary. */
 394                         strcpy(MAIN_LABEL, BACKUP_LABEL);
 395                         MAIN_MINOR = BACKUP_MINOR;
 396                 }
 397
 398                 driver[DRIVER_BACKUP].endpt = NONE;
 399
 400                 return OK;
 401         }
 402         else {
 403                 /* We tried, we really did. But now we give up. Tell the user.
 404                  */
 405                 printf("Filter: kill threshold reached, returning error\n");
 406
 407                 if (driver[which].error == EAGAIN) return EIO;
 408
 409                 return driver[which].error;
 410         }
 411 }
 412
 413 /*===========================================================================*
 414  *                              restart_driver                               *
 415  *===========================================================================*/
 416 static void restart_driver(int which, int tell_rs)
 417 {
 418         /* Restart the given driver. Block until the new instance is up.
 419          */
 420         message msg;
 421         int ipc_status;
 422         int r;
 423
 424         if (tell_rs) {
 425                 /* Tell RS to refresh or restart the driver */
 426                 msg.m_type = RS_REFRESH;
 427                 msg.RS_CMD_ADDR = driver[which].label;
 428                 msg.RS_CMD_LEN = strlen(driver[which].label);
 429
 430 #if DEBUG
 431                 printf("Filter: asking RS to refresh %s..\n",
 432                         driver[which].label);
 433 #endif
 434
 435                 r = sendrec(RS_PROC_NR, &msg);
 436
 437                 if (r != OK || msg.m_type != OK)
 438                         panic("RS request failed: %d", r);
 439
 440 #if DEBUG
 441                 printf("Filter: RS call succeeded\n");
 442 #endif
 443         }
 444
 445         /* Wait until the new driver instance is up, and get its endpoint. */
 446 #if DEBUG
 447         printf("Filter: endpoint update driver %d; old endpoint %d\n",
 448                 which, driver[which].endpt);
 449 #endif
 450
 451         if(driver[which].up_event == UP_EXPECTED) {
 452                 driver[which].up_event = UP_NONE;
 453         }
 454         while(driver[which].up_event != UP_PENDING) {
 455                 r = driver_receive(DS_PROC_NR, &msg, &ipc_status);
 456                 if(r != OK)
 457                         panic("driver_receive returned error: %d", r);
 458
 459                 ds_event();
 460         }
 461 }
 462
 463 /*===========================================================================*
 464  *                              check_driver                                 *
 465  *===========================================================================*/
 466 int check_driver(int which)
 467 {
 468         /* See if the given driver has been troublesome, and if so, deal with
 469          * it.
 470          */
 471         int problem, tell_rs;
 472         int r, retries = 0;
 473
 474         problem = driver[which].problem;
 475
 476         if (problem == BD_NONE)
 477                 return OK;
 478
 479         do {
 480                 if(retries) {
 481 #if DEBUG
 482                         printf("Filter: check_driver: retry number %d\n",
 483                                 retries);
 484 #endif
 485                         problem = BD_PROTO;
 486                 }
 487                 retries++;
 488                 driver[which].problem = BD_NONE;
 489
 490                 /* Decide what to do: continue operation, restart the driver,
 491                  * or return an error.
 492                  */
 493                 r = check_problem(which, problem, retries, &tell_rs);
 494                 if (r != EAGAIN)
 495                         return r;
 496
 497                 /* Restarting the driver it is. First tell RS (if necessary),
 498                  * then wait for the new driver instance to come up.
 499                  */
 500                 restart_driver(which, tell_rs);
 501
 502                 /* Finally, open the device on the new driver */
 503         } while (driver_open(which) != OK);
 504
 505 #if DEBUG
 506         printf("Filter: check_driver restarted driver %d, endpoint %d\n",
 507                 which, driver[which].endpt);
 508 #endif
 509
 510         return OK;
 511 }
 512
 513 /*===========================================================================*
 514  *                              flt_senda                                    *
 515  *===========================================================================*/
 516 static int flt_senda(message *mess, int which)
 517 {
 518         /* Send a message to one driver. Can only return OK at the moment. */
 519         int r;
 520         asynmsg_t *amp;
 521
 522         /* Fill in the last bits of the message. */
 523         mess->DEVICE = driver[which].minor;
 524         mess->IO_ENDPT = self_ep;
 525
 526         /* Send the message asynchronously. */
 527         amp = &amsgtable[which];
 528         amp->dst = driver[which].endpt;
 529         amp->msg = *mess;
 530         amp->flags = AMF_VALID;
 531         r = senda(amsgtable, 2);
 532
 533         if(r != OK)
 534                 panic("senda returned error: %d", r);
 535
 536         return r;
 537 }
 538
 539 /*===========================================================================*
 540  *                              check_senda                                  *
 541  *===========================================================================*/
 542 static int check_senda(int which)
 543 {
 544         /* Check whether an earlier senda resulted in an error indicating the
 545          * message never got delivered. Only in that case can we reliably say
 546          * that the driver died. Return BD_DEAD in this case, and BD_PROTO
 547          * otherwise.
 548          */
 549         asynmsg_t *amp;
 550
 551         amp = &amsgtable[which];
 552
 553         if ((amp->flags & AMF_DONE) && (amp->result == EDEADSRCDST)) {
 554
 555                 return BD_DEAD;
 556         }
 557
 558         return BD_PROTO;
 559 }
 560
 561 /*===========================================================================*
 562  *                              flt_receive                                  *
 563  *===========================================================================*/
 564 static int flt_receive(message *mess, int which)
 565 {
 566         /* Receive a message from one or either driver, unless a timeout
 567          * occurs. Can only return OK or RET_REDO.
 568          */
 569         int r;
 570         int ipc_status;
 571
 572         for (;;) {
 573                 r = driver_receive(ANY, mess, &ipc_status);
 574                 if(r != OK)
 575                         panic("driver_receive returned error: %d", r);
 576
 577                 if(mess->m_source == DS_PROC_NR && is_ipc_notify(ipc_status)) {
 578                         ds_event();
 579                         continue;
 580                 }
 581
 582                 if(mess->m_source == CLOCK && is_ipc_notify(ipc_status)) {
 583                         if (mess->NOTIFY_TIMESTAMP < flt_alarm(-1)) {
 584 #if DEBUG
 585                                 printf("Filter: SKIPPING old alarm "
 586                                         "notification\n");
 587 #endif
 588                                 continue;
 589                         }
 590
 591 #if DEBUG
 592                         printf("Filter: timeout waiting for disk driver %d "
 593                                 "reply!\n", which);
 594 #endif
 595
 596                         /* If we're waiting for either driver,
 597                          * both are at fault.
 598                          */
 599                         if (which < 0) {
 600                                 bad_driver(DRIVER_MAIN,
 601                                         check_senda(DRIVER_MAIN), EFAULT);
 602
 603                                 return bad_driver(DRIVER_BACKUP,
 604                                         check_senda(DRIVER_BACKUP), EFAULT);
 605                         }
 606
 607                         /* Otherwise, just report the one not replying as dead.
 608                          */
 609                         return bad_driver(which, check_senda(which), EFAULT);
 610                 }
 611
 612                 if (mess->m_source != driver[DRIVER_MAIN].endpt &&
 613                                 mess->m_source != driver[DRIVER_BACKUP].endpt) {
 614 #if DEBUG
 615                         printf("Filter: got STRAY message %d from %d\n",
 616                                 mess->m_type, mess->m_source);
 617 #endif
 618
 619                         continue;
 620                 }
 621
 622                 /* We are waiting for a reply from one specific driver. */
 623                 if (which >= 0) {
 624                         /* If the message source is that driver, good. */
 625                         if (mess->m_source == driver[which].endpt)
 626                                 break;
 627
 628                         /* This should probably be treated as a real protocol
 629                          * error. We do not abort any receives (not even paired
 630                          * receives) except because of timeouts. Getting here
 631                          * means a driver replied at least the timeout period
 632                          * later than expected, which should be enough reason
 633                          * to kill it really. The other explanation is that it
 634                          * is actually violating the protocol and sending bogus
 635                          * messages...
 636                          */
 637 #if DEBUG
 638                         printf("Filter: got UNEXPECTED reply from %d\n",
 639                                 mess->m_source);
 640 #endif
 641
 642                         continue;
 643                 }
 644
 645                 /* We got a message from one of the drivers, and we didn't
 646                  * care which one we wanted to receive from. A-OK.
 647                  */
 648                 break;
 649         }
 650
 651         return OK;
 652 }
 653
 654 /*===========================================================================*
 655  *                              flt_sendrec                                  *
 656  *===========================================================================*/
 657 static int flt_sendrec(message *mess, int which)
 658 {
 659         int r;
 660
 661         r = flt_senda(mess, which);
 662         if(r != OK)
 663                 return r;
 664
 665         if(check_senda(which) == BD_DEAD) {
 666                 return bad_driver(which, BD_DEAD, EFAULT);
 667         }
 668
 669         /* Set alarm. */
 670         flt_alarm(DRIVER_TIMEOUT);
 671
 672         r = flt_receive(mess, which);
 673
 674         /* Clear the alarm. */
 675         flt_alarm(0);
 676         return r;
 677 }
 678
 679 /*===========================================================================*
 680  *                              do_sendrec_both                              *
 681  *===========================================================================*/
 682 static int do_sendrec_both(message *m1, message *m2)
 683 {
 684         /* If USEE_MIRROR is set, call flt_sendrec() to both drivers.
 685          * Otherwise, only call flt_sendrec() to the main driver.
 686          * This function will only return either OK or RET_REDO.
 687          */
 688         int r, which = -1;
 689         message ma, mb;
 690
 691         /* If the two disks use the same driver, call flt_sendrec() twice
 692          * sequentially. Such a setup is not very useful though.
 693          */
 694         if (!strcmp(driver[DRIVER_MAIN].label, driver[DRIVER_BACKUP].label)) {
 695                 if ((r = flt_sendrec(m1, DRIVER_MAIN)) != OK) return r;
 696                 return flt_sendrec(m2, DRIVER_BACKUP);
 697         }
 698
 699         /* If the two disks use different drivers, call flt_senda()
 700          * twice, and then flt_receive(), and distinguish the return
 701          * messages by means of m_source.
 702          */
 703         if ((r = flt_senda(m1, DRIVER_MAIN)) != OK) return r;
 704         if ((r = flt_senda(m2, DRIVER_BACKUP)) != OK) return r;
 705
 706         /* Set alarm. */
 707         flt_alarm(DRIVER_TIMEOUT);
 708
 709         /* The message received by the 1st flt_receive() may not be
 710          * from DRIVER_MAIN.
 711          */
 712         if ((r = flt_receive(&ma, -1)) != OK) {
 713                 flt_alarm(0);
 714                 return r;
 715         }
 716
 717         if (ma.m_source == driver[DRIVER_MAIN].endpt) {
 718                 which = DRIVER_BACKUP;
 719         } else if (ma.m_source == driver[DRIVER_BACKUP].endpt) {
 720                 which = DRIVER_MAIN;
 721         } else {
 722                 panic("message from unexpected source: %d",
 723                         ma.m_source);
 724         }
 725
 726         r = flt_receive(&mb, which);
 727
 728         /* Clear the alarm. */
 729         flt_alarm(0);
 730
 731         if(r != OK)
 732                 return r;
 733
 734         if (ma.m_source == driver[DRIVER_MAIN].endpt) {
 735                 *m1 = ma;
 736                 *m2 = mb;
 737         } else {
 738                 *m1 = mb;
 739                 *m2 = ma;
 740         }
 741
 742         return OK;
 743 }
 744
 745 /*===========================================================================*
 746  *                              do_sendrec_one                               *
 747  *===========================================================================*/
 748 static int do_sendrec_one(message *m1, const message *m2)
 749 {
 750         /* Only talk to the main driver. If something goes wrong, it will
 751          * be fixed elsewhere.
 752          * This function will only return either OK or RET_REDO.
 753          */
 754
 755         return flt_sendrec(m1, DRIVER_MAIN);
 756 }
 757
 758 /*===========================================================================*
 759  *                              paired_sendrec                               *
 760  *===========================================================================*/
 761 static int paired_sendrec(message *m1, message *m2, int both)
 762 {
 763         /* Sendrec with the disk driver. If the disk driver is down, and was
 764          * restarted, redo the request, until the driver works fine, or can't
 765          * be restarted again.
 766          */
 767         int r;
 768
 769 #if DEBUG2
 770         printf("paired_sendrec(%d) - <%d,%x:%x,%d> - %x,%x\n",
 771                 both, m1->m_type, m1->HIGHPOS, m1->POSITION, m1->COUNT,
 772                 m1->IO_GRANT, m2->IO_GRANT);
 773 #endif
 774
 775         if (both)
 776                 r = do_sendrec_both(m1, m2);
 777         else
 778                 r = do_sendrec_one(m1, m2);
 779
 780 #if DEBUG2
 781         if (r != OK)
 782                 printf("paired_sendrec about to return %d\n", r);
 783 #endif
 784
 785         return r;
 786 }
 787
 788 /*===========================================================================*
 789  *                              single_grant                                 *
 790  *===========================================================================*/
 791 static int single_grant(endpoint_t endpt, vir_bytes buf, int access,
 792         cp_grant_id_t *gid, iovec_s_t vector[NR_IOREQS], const size_t *sizep)
 793 {
 794         /* Create grants for a vectored request to a single driver.
 795          */
 796         cp_grant_id_t grant;
 797         size_t size, chunk;
 798         int count;
 799
 800         size = *sizep;
 801
 802         /* Split up the request into chunks, if requested. This makes no
 803          * difference at all, except that this works around a weird performance
 804          * bug with large DMA PRDs on some machines.
 805          */
 806         if (CHUNK_SIZE > 0) chunk = CHUNK_SIZE;
 807         else chunk = size;
 808
 809         /* Fill in the vector, creating a grant for each item. */
 810         for (count = 0; size > 0 && count < NR_IOREQS; count++) {
 811                 /* The last chunk will contain all the remaining data. */
 812                 if (chunk > size || count == NR_IOREQS - 1)
 813                         chunk = size;
 814
 815                 grant = cpf_grant_direct(endpt, buf, chunk, access);
 816                 if (!GRANT_VALID(grant))
 817                         panic("invalid grant: %d", grant);
 818
 819                 vector[count].iov_grant = grant;
 820                 vector[count].iov_size = chunk;
 821
 822                 buf += chunk;
 823                 size -= chunk;
 824         }
 825
 826         /* Then create a grant for the vector itself. */
 827         *gid = cpf_grant_direct(endpt, (vir_bytes) vector,
 828                 sizeof(vector[0]) * count, CPF_READ | CPF_WRITE);
 829
 830         if (!GRANT_VALID(*gid))
 831                 panic("invalid grant: %d", *gid);
 832
 833         return count;
 834 }
 835
 836 /*===========================================================================*
 837  *                              paired_grant                                 *
 838  *===========================================================================*/
 839 static int paired_grant(char *buf1, char *buf2, int request,
 840         cp_grant_id_t *gids, iovec_s_t vectors[2][NR_IOREQS], size_t *sizes,
 841         int both)
 842 {
 843         /* Create memory grants, either to one or to both drivers.
 844          */
 845         int count, access;
 846
 847         count = 0;
 848         access = (request == FLT_WRITE) ? CPF_READ : CPF_WRITE;
 849
 850         if(driver[DRIVER_MAIN].endpt > 0) {
 851                 count = single_grant(driver[DRIVER_MAIN].endpt,
 852                         (vir_bytes) buf1, access, &gids[0], vectors[0],
 853                         &sizes[0]);
 854         }
 855
 856         if (both) {
 857                 if(driver[DRIVER_BACKUP].endpt > 0) {
 858                         count = single_grant(driver[DRIVER_BACKUP].endpt,
 859                                 (vir_bytes) buf2, access, &gids[1],
 860                                 vectors[1], &sizes[1]);
 861                 }
 862         }
 863         return count;
 864 }
 865
 866 /*===========================================================================*
 867  *                              single_revoke                                *
 868  *===========================================================================*/
 869 PRIVATE void single_revoke(cp_grant_id_t gid, const iovec_s_t vector[NR_IOREQS],
 870         size_t *sizep, int count)
 871 {
 872         /* Revoke all grants associated with a request to a single driver.
 873          * Modify the given size to reflect the actual I/O performed.
 874          */
 875         int i;
 876
 877         /* Revoke the grants for all the elements of the vector. */
 878         for (i = 0; i < count; i++) {
 879                 cpf_revoke(vector[i].iov_grant);
 880                 *sizep -= vector[i].iov_size;
 881         }
 882
 883         /* Then revoke the grant for the vector itself. */
 884         cpf_revoke(gid);
 885 }
 886
 887 /*===========================================================================*
 888  *                              paired_revoke                                *
 889  *===========================================================================*/
 890 static void paired_revoke(const cp_grant_id_t *gids,
 891         iovec_s_t vectors[2][NR_IOREQS],
 892         size_t *sizes, int count, int both)
 893 {
 894         /* Revoke grants to drivers for a single request.
 895          */
 896
 897         single_revoke(gids[0], vectors[0], &sizes[0], count);
 898
 899         if (both)
 900                 single_revoke(gids[1], vectors[1], &sizes[1], count);
 901 }
 902
 903 /*===========================================================================*
 904  *                              read_write                                   *
 905  *===========================================================================*/
 906 int read_write(u64_t pos, char *bufa, char *bufb, size_t *sizep, int request)
 907 {
 908         iovec_s_t vectors[2][NR_IOREQS];
 909         message m1, m2;
 910         cp_grant_id_t gids[2];
 911         size_t sizes[2];
 912         int r, both, count;
 913
 914         gids[0] = gids[1] = GRANT_INVALID;
 915         sizes[0] = sizes[1] = *sizep;
 916
 917         /* Send two requests only if mirroring is enabled and the given request
 918          * is either FLT_READ2 or FLT_WRITE.
 919          */
 920         both = (USE_MIRROR && request != FLT_READ);
 921
 922         count = paired_grant(bufa, bufb, request, gids, vectors, sizes, both);
 923
 924         m1.m_type = (request == FLT_WRITE) ? DEV_SCATTER_S : DEV_GATHER_S;
 925         m1.COUNT = count;
 926         m1.POSITION = ex64lo(pos);
 927         m1.HIGHPOS = ex64hi(pos);
 928
 929         m2 = m1;
 930
 931         m1.IO_GRANT = (char *) gids[0];
 932         m2.IO_GRANT = (char *) gids[1];
 933
 934         r = paired_sendrec(&m1, &m2, both);
 935
 936         paired_revoke(gids, vectors, sizes, count, both);
 937
 938         if(r != OK) {
 939 #if DEBUG
 940                 if (r != RET_REDO)
 941                         printf("Filter: paired_sendrec returned %d\n", r);
 942 #endif
 943                 return r;
 944         }
 945
 946         if (m1.m_type != TASK_REPLY || m1.REP_STATUS != OK) {
 947                 printf("Filter: unexpected/invalid reply from main driver: "
 948                         "(%x, %d)\n", m1.m_type, m1.REP_STATUS);
 949
 950                 return bad_driver(DRIVER_MAIN, BD_PROTO,
 951                         (m1.m_type == TASK_REPLY) ? m1.REP_STATUS : EFAULT);
 952         }
 953
 954         if (sizes[0] != *sizep) {
 955                 printf("Filter: truncated reply from main driver\n");
 956
 957                 /* If the driver returned a value *larger* than we requested,
 958                  * OR if we did NOT exceed the disk size, then we should
 959                  * report the driver for acting strangely!
 960                  */
 961                 if (sizes[0] < 0 || sizes[0] > *sizep ||
 962                         cmp64(add64u(pos, sizes[0]), disk_size) < 0)
 963                         return bad_driver(DRIVER_MAIN, BD_PROTO, EFAULT);
 964
 965                 /* Return the actual size. */
 966                 *sizep = sizes[0];
 967         }
 968
 969         if (both) {
 970                 if (m2.m_type != TASK_REPLY || m2.REP_STATUS != OK) {
 971                         printf("Filter: unexpected/invalid reply from "
 972                                 "backup driver (%x, %d)\n",
 973                                 m2.m_type, m2.REP_STATUS);
 974
 975                         return bad_driver(DRIVER_BACKUP, BD_PROTO,
 976                                 m2.m_type == TASK_REPLY ? m2.REP_STATUS :
 977                                 EFAULT);
 978                 }
 979                 if (sizes[1] != *sizep) {
 980                         printf("Filter: truncated reply from backup driver\n");
 981
 982                         /* As above */
 983                         if (sizes[1] < 0 || sizes[1] > *sizep ||
 984                                 cmp64(add64u(pos, sizes[1]), disk_size) < 0)
 985                                 return bad_driver(DRIVER_BACKUP, BD_PROTO,
 986                                         EFAULT);
 987
 988                         /* Return the actual size. */
 989                         if (*sizep >= sizes[1])
 990                                 *sizep = sizes[1];
 991                 }
 992         }
 993
 994         return OK;
 995 }
 996
 997 /*===========================================================================*
 998  *                               ds_event                                    *
 999  *===========================================================================*/
1000 void ds_event()
1001 {
1002         char key[DS_MAX_KEYLEN];
1003         char *driver_prefix = "drv.vfs.";
1004         u32_t value;
1005         int type;
1006         endpoint_t owner_endpoint;
1007         int r;
1008         int which;
1009
1010         /* Get the event and the owner from DS. */
1011         r = ds_check(key, &type, &owner_endpoint);
1012         if(r != OK) {
1013                 if(r != ENOENT)
1014                         printf("Filter: ds_event: ds_check failed: %d\n", r);
1015                 return;
1016         }
1017         r = ds_retrieve_u32(key, &value);
1018         if(r != OK) {
1019                 printf("Filter: ds_event: ds_retrieve_u32 failed\n");
1020                 return;
1021         }
1022
1023         /* Only check for VFS driver up events. */
1024         if(strncmp(key, driver_prefix, sizeof(driver_prefix))
1025            || value != DS_DRIVER_UP) {
1026                 return;
1027         }
1028
1029         /* See if this is a driver we are responsible for. */
1030         if(driver[DRIVER_MAIN].endpt == owner_endpoint) {
1031                 which = DRIVER_MAIN;
1032         }
1033         else if(driver[DRIVER_BACKUP].endpt == owner_endpoint) {
1034                 which = DRIVER_BACKUP;
1035         }
1036         else {
1037                 return;
1038         }
1039
1040         /* Mark the driver as (re)started. */
1041         driver[which].up_event = driver[which].up_event == UP_EXPECTED ?
1042                 UP_NONE : UP_PENDING;
1043 }
1044