1 /* 2 * Copyright 2006-2007, François Revol. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 /* 7 * nbd driver for Haiku 8 * 9 * Maps a Network Block Device as virtual partitions. 10 */ 11 12 13 #include <ByteOrder.h> 14 #include <KernelExport.h> 15 #include <Drivers.h> 16 #include <driver_settings.h> 17 #include <Errors.h> 18 #include <errno.h> 19 #include <stdio.h> 20 #include <stdlib.h> 21 #include <string.h> 22 #include <unistd.h> 23 #include <ksocket.h> 24 #include <netinet/in.h> 25 26 //#define DEBUG 1 27 28 /* on the first open(), open ourselves for some seconds, 29 * to avoid trying to reconnect and failing on a 2nd open, 30 * as it happens with the python server. 31 */ 32 //#define MOUNT_KLUDGE 33 34 35 /* names, ohh names... */ 36 #ifndef SHUT_RDWR 37 #define SHUT_RDWR SHUTDOWN_BOTH 38 #endif 39 40 /* locking support */ 41 #ifdef __HAIKU__ 42 #include <kernel/lock.h> 43 #else 44 /* wrappers for R5 */ 45 #ifndef _IMPEXP_KERNEL 46 #define _IMPEXP_KERNEL 47 #endif 48 #include "lock.h" 49 #define mutex lock 50 #define mutex_init new_lock 51 #define mutex_destroy free_lock 52 #define mutex_lock LOCK 53 #define mutex_unlock UNLOCK 54 #endif 55 56 #include "nbd.h" 57 58 #define DRV "nbd" 59 #define DP "nbd:" 60 #define MAX_NBDS 4 61 #define DEVICE_PREFIX "disk/virtual/nbd/" 62 #define DEVICE_FMT DEVICE_PREFIX "%d/raw" 63 #define DEVICE_NAME_MAX 32 64 #define MAX_REQ_SIZE (32*1024*1024) 65 #define BLKSIZE 512 66 67 /* debugging */ 68 #if DEBUG 69 #define PRINT(a) dprintf a 70 #define WHICH(dev) ((int)(dev - nbd_devices)) 71 #else 72 #define PRINT(a) 73 #endif 74 75 struct nbd_request_entry { 76 struct nbd_request_entry *next; 77 struct nbd_request req; /* net byte order */ 78 struct nbd_reply reply; /* net byte order */ 79 sem_id sem; 80 bool replied; 81 bool discard; 82 uint64 handle; 83 uint32 type; 84 uint64 from; 85 size_t len; 86 void *buffer; /* write: ptr to passed buffer; read: ptr to malloc()ed extra */ 87 }; 88 89 struct nbd_device { 90 bool valid; 91 bool readonly; 92 struct sockaddr_in server; 93 mutex ben; 94 vint32 refcnt; 95 uint64 req; /* next ID for requests */ 96 int sock; 97 thread_id postoffice; 98 uint64 size; 99 struct nbd_request_entry *reqs; 100 #ifdef MOUNT_KLUDGE 101 int kludge; 102 #endif 103 }; 104 105 typedef struct cookie { 106 struct nbd_device *dev; 107 108 } cookie_t; 109 110 /* data=NULL on read */ 111 status_t nbd_alloc_request(struct nbd_device *dev, struct nbd_request_entry **req, uint32 type, off_t from, size_t len, const char *data); 112 status_t nbd_queue_request(struct nbd_device *dev, struct nbd_request_entry *req); 113 status_t nbd_dequeue_request(struct nbd_device *dev, uint64 handle, struct nbd_request_entry **req); 114 status_t nbd_free_request(struct nbd_device *dev, struct nbd_request_entry *req); 115 116 struct nbd_device *nbd_find_device(const char* name); 117 118 int32 nbd_postoffice(void *arg); 119 status_t nbd_connect(struct nbd_device *dev); 120 status_t nbd_teardown(struct nbd_device *dev); 121 status_t nbd_post_request(struct nbd_device *dev, struct nbd_request_entry *req); 122 123 status_t nbd_open(const char *name, uint32 flags, cookie_t **cookie); 124 status_t nbd_close(cookie_t *cookie); 125 status_t nbd_free(cookie_t *cookie); 126 status_t nbd_control(cookie_t *cookie, uint32 op, void *data, size_t len); 127 status_t nbd_read(cookie_t *cookie, off_t position, void *data, size_t *numbytes); 128 status_t nbd_write(cookie_t *cookie, off_t position, const void *data, size_t *numbytes); 129 130 KSOCKET_MODULE_DECL; 131 132 /* HACK: 133 * In BONE at least, if connect() fails (EINTR or ETIMEDOUT) 134 * keeps locked pages around (likely a bone_data, 135 * until TCP gets the last ACK). If that happens, we snooze() 136 * in unload_driver() to let TCP timeout before the kernel 137 * tries to delete the image. */ 138 bool gDelayUnload = false; 139 #define BONE_TEARDOWN_DELAY 60000000 140 141 #if 0 142 #pragma mark ==== support ==== 143 #endif 144 145 // move that to ksocket inlined 146 static int kinet_aton(const char *in, struct in_addr *addr) 147 { 148 int i; 149 unsigned long a; 150 uint32 inaddr = 0L; 151 char *p = (char *)in; 152 for (i = 0; i < 4; i++) { 153 a = strtoul(p, &p, 10); 154 if (!p) 155 return -1; 156 inaddr = (inaddr >> 8) | ((a & 0x0ff) << 24); 157 *(uint32 *)addr = inaddr; 158 if (!*p) 159 return 0; 160 p++; 161 } 162 return 0; 163 } 164 165 #if 0 166 #pragma mark ==== request manager ==== 167 #endif 168 169 status_t nbd_alloc_request(struct nbd_device *dev, struct nbd_request_entry **req, uint32 type, off_t from, size_t len, const char *data) 170 { 171 bool w = (type == NBD_CMD_WRITE); 172 struct nbd_request_entry *r; 173 status_t err = EINVAL; 174 uint64 handle; 175 PRINT((DP ">%s(%" B_PRIu32 ", %" B_PRIdOFF ", %ld)\n", __FUNCTION__, type, 176 from, len)); 177 178 if (type != NBD_CMD_READ && type != NBD_CMD_WRITE && type != NBD_CMD_DISC) 179 return err; 180 if (!dev || !req || from < 0) 181 return err; 182 183 //LOCK 184 err = mutex_lock(&dev->ben); 185 if (err) 186 return err; 187 188 // atomic 189 handle = dev->req++; 190 191 192 //UNLOCK 193 mutex_unlock(&dev->ben); 194 195 err = ENOMEM; 196 r = malloc(sizeof(struct nbd_request_entry) + (w ? 0 : len)); 197 if (r == NULL) 198 goto err0; 199 r->next = NULL; 200 err = r->sem = create_sem(0, "nbd request sem"); 201 if (err < 0) 202 goto err1; 203 204 r->replied = false; 205 r->discard = false; 206 r->handle = handle; 207 r->type = type; 208 r->from = from; 209 r->len = len; 210 211 r->req.magic = B_HOST_TO_BENDIAN_INT32(NBD_REQUEST_MAGIC); 212 r->req.type = B_HOST_TO_BENDIAN_INT32(type); 213 r->req.handle = B_HOST_TO_BENDIAN_INT64(r->handle); 214 r->req.from = B_HOST_TO_BENDIAN_INT64(r->from); 215 r->req.len = B_HOST_TO_BENDIAN_INT32(len); 216 217 r->buffer = (void *)(w ? data : (((char *)r) + sizeof(struct nbd_request_entry))); 218 219 *req = r; 220 return B_OK; 221 222 err1: 223 free(r); 224 err0: 225 dprintf(DP " %s: error 0x%08" B_PRIx32 "\n", __FUNCTION__, err); 226 return err; 227 } 228 229 230 status_t nbd_queue_request(struct nbd_device *dev, struct nbd_request_entry *req) 231 { 232 PRINT((DP ">%s(handle:%" B_PRIu64 ")\n", __FUNCTION__, req->handle)); 233 req->next = dev->reqs; 234 dev->reqs = req; 235 return B_OK; 236 } 237 238 239 status_t nbd_dequeue_request(struct nbd_device *dev, uint64 handle, struct nbd_request_entry **req) 240 { 241 struct nbd_request_entry *r, *prev; 242 PRINT((DP ">%s(handle:%" B_PRIu64 ")\n", __FUNCTION__, handle)); 243 r = dev->reqs; 244 prev = NULL; 245 while (r && r->handle != handle) { 246 prev = r; 247 r = r->next; 248 } 249 if (!r) 250 return ENOENT; 251 252 if (prev) 253 prev->next = r->next; 254 else 255 dev->reqs = r->next; 256 257 *req = r; 258 return B_OK; 259 } 260 261 262 status_t nbd_free_request(struct nbd_device *dev, struct nbd_request_entry *req) 263 { 264 PRINT((DP ">%s(handle:%" B_PRIu64 ")\n", __FUNCTION__, req->handle)); 265 delete_sem(req->sem); 266 free(req); 267 return B_OK; 268 } 269 270 271 #if 0 272 #pragma mark ==== nbd handler ==== 273 #endif 274 275 int32 nbd_postoffice(void *arg) 276 { 277 struct nbd_device *dev = (struct nbd_device *)arg; 278 struct nbd_request_entry *req = NULL; 279 struct nbd_reply reply; 280 status_t err; 281 const char *reason; 282 PRINT((DP ">%s()\n", __FUNCTION__)); 283 284 for (;;) { 285 reason = "recv"; 286 err = krecv(dev->sock, &reply, sizeof(reply), 0); 287 if (err == -1 && errno < 0) 288 err = errno; 289 if (err < 0) 290 goto err; 291 reason = "recv:size"; 292 if (err < sizeof(reply)) 293 err = EINVAL; 294 if (err < 0) 295 goto err; 296 reason = "magic"; 297 err = EINVAL; 298 if (B_BENDIAN_TO_HOST_INT32(reply.magic) != NBD_REPLY_MAGIC) 299 goto err; 300 301 reason = "lock"; 302 //LOCK 303 err = mutex_lock(&dev->ben); 304 if (err) 305 goto err; 306 307 reason = "dequeue_request"; 308 err = nbd_dequeue_request(dev, B_BENDIAN_TO_HOST_INT64(reply.handle), &req); 309 310 //UNLOCK 311 mutex_unlock(&dev->ben); 312 313 if (!err && !req) { 314 dprintf(DP "nbd_dequeue_rquest found NULL!\n"); 315 err = ENOENT; 316 } 317 318 if (err == B_OK) { 319 memcpy(&req->reply, &reply, sizeof(reply)); 320 if (req->type == NBD_CMD_READ) { 321 err = 0; 322 reason = "recv(data)"; 323 if (reply.error == 0) 324 err = krecv(dev->sock, req->buffer, req->len, 0); 325 if (err < 0) 326 goto err; 327 /* tell back how much we've got (?) */ 328 req->len = err; 329 } else { 330 if (reply.error) 331 req->len = 0; 332 } 333 334 reason = "lock"; 335 //LOCK 336 err = mutex_lock(&dev->ben); 337 if (err) 338 goto err; 339 340 // this also must be atomic! 341 release_sem(req->sem); 342 req->replied = true; 343 if (req->discard) 344 nbd_free_request(dev, req); 345 346 //UNLOCK 347 mutex_unlock(&dev->ben); 348 } 349 350 } 351 352 PRINT((DP "<%s\n", __FUNCTION__)); 353 return 0; 354 355 err: 356 dprintf(DP "%s: %s: error 0x%08" B_PRIx32 "\n", __FUNCTION__, reason, err); 357 return err; 358 } 359 360 361 status_t nbd_connect(struct nbd_device *dev) 362 { 363 struct nbd_init_packet initpkt; 364 status_t err; 365 PRINT((DP ">%s()\n", __FUNCTION__)); 366 367 PRINT((DP " %s: socket()\n", __FUNCTION__)); 368 err = dev->sock = ksocket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 369 if (err == -1 && errno < 0) 370 err = errno; 371 if (err < 0) 372 goto err0; 373 374 PRINT((DP " %s: connect()\n", __FUNCTION__)); 375 err = kconnect(dev->sock, (struct sockaddr *)&dev->server, sizeof(dev->server)); 376 //err = ENOSYS; 377 if (err == -1 && errno < 0) 378 err = errno; 379 /* HACK: avoid the kernel unloading us with locked pages from TCP */ 380 if (err) 381 gDelayUnload = true; 382 if (err) 383 goto err1; 384 385 PRINT((DP " %s: recv(initpkt)\n", __FUNCTION__)); 386 err = krecv(dev->sock, &initpkt, sizeof(initpkt), 0); 387 if (err == -1 && errno < 0) 388 err = errno; 389 if (err < sizeof(initpkt)) 390 goto err2; 391 err = EINVAL;//EPROTO; 392 if (memcmp(initpkt.passwd, NBD_INIT_PASSWD, sizeof(initpkt.passwd))) 393 goto err3; 394 if (B_BENDIAN_TO_HOST_INT64(initpkt.magic) != NBD_INIT_MAGIC) 395 goto err3; 396 397 dev->size = B_BENDIAN_TO_HOST_INT64(initpkt.device_size); 398 399 dprintf(DP " %s: connected, device size %" B_PRIu64 " bytes.\n", 400 __FUNCTION__, dev->size); 401 402 err = dev->postoffice = spawn_kernel_thread(nbd_postoffice, "nbd postoffice", B_REAL_TIME_PRIORITY, dev); 403 if (err < B_OK) 404 goto err4; 405 resume_thread(dev->postoffice); 406 407 PRINT((DP "<%s\n", __FUNCTION__)); 408 return B_OK; 409 410 err4: 411 dev->postoffice = -1; 412 err3: 413 err2: 414 err1: 415 kclosesocket(dev->sock); 416 dev->sock = -1; 417 err0: 418 dprintf(DP "<%s: error 0x%08" B_PRIx32 "\n", __FUNCTION__, err); 419 return err; 420 } 421 422 423 status_t nbd_teardown(struct nbd_device *dev) 424 { 425 status_t ret; 426 PRINT((DP ">%s()\n", __FUNCTION__)); 427 kshutdown(dev->sock, SHUT_RDWR); 428 kclosesocket(dev->sock); 429 dev->sock = -1; 430 wait_for_thread(dev->postoffice, &ret); 431 return B_OK; 432 } 433 434 435 status_t nbd_post_request(struct nbd_device *dev, struct nbd_request_entry *req) 436 { 437 status_t err; 438 PRINT((DP ">%s(handle:%" B_PRIu64 ")\n", __FUNCTION__, req->handle)); 439 440 err = ksend(dev->sock, &req->req, sizeof(req->req), 0); 441 if (err < 0) 442 return err; 443 444 if (req->type == NBD_CMD_WRITE) 445 err = ksend(dev->sock, req->buffer, req->len, 0); 446 if (err < 0) 447 return err; 448 else 449 req->len = err; 450 451 err = nbd_queue_request(dev, req); 452 return err; 453 } 454 455 456 #if 0 457 #pragma mark ==== device hooks ==== 458 #endif 459 460 static struct nbd_device nbd_devices[MAX_NBDS]; 461 462 status_t nbd_open(const char *name, uint32 flags, cookie_t **cookie) { 463 status_t err; 464 #ifdef MOUNT_KLUDGE 465 int32 refcnt; 466 int kfd; 467 #endif 468 struct nbd_device *dev = NULL; 469 PRINT((DP ">%s(%s, %" B_PRIx32 ", )\n", __FUNCTION__, name, flags)); 470 (void)name; (void)flags; 471 dev = nbd_find_device(name); 472 if (!dev || !dev->valid) 473 return ENOENT; 474 err = ENOMEM; 475 *cookie = (void*)malloc(sizeof(cookie_t)); 476 if (*cookie == NULL) 477 goto err0; 478 memset(*cookie, 0, sizeof(cookie_t)); 479 (*cookie)->dev = dev; 480 err = mutex_lock(&dev->ben); 481 if (err) 482 goto err1; 483 /* */ 484 if (dev->sock < 0) 485 err = nbd_connect(dev); 486 if (err) 487 goto err2; 488 #ifdef MOUNT_KLUDGE 489 refcnt = dev->refcnt++; 490 kfd = dev->kludge; 491 dev->kludge = -1; 492 #endif 493 mutex_unlock(&dev->ben); 494 495 #ifdef MOUNT_KLUDGE 496 if (refcnt == 0) { 497 char buf[32]; 498 sprintf(buf, "/dev/%s", name); 499 dev->kludge = open(buf, O_RDONLY); 500 } else if (kfd) { 501 close(kfd); 502 } 503 #endif 504 505 return B_OK; 506 507 err2: 508 mutex_unlock(&dev->ben); 509 err1: 510 free(*cookie); 511 err0: 512 dprintf(DP " %s: error 0x%08" B_PRIx32 "\n", __FUNCTION__, err); 513 return err; 514 } 515 516 517 status_t nbd_close(cookie_t *cookie) { 518 struct nbd_device *dev = cookie->dev; 519 status_t err; 520 #ifdef MOUNT_KLUDGE 521 int kfd = -1; 522 #endif 523 PRINT((DP ">%s(%d)\n", __FUNCTION__, WHICH(cookie->dev))); 524 525 err = mutex_lock(&dev->ben); 526 if (err) 527 return err; 528 529 // XXX: do something ? 530 #ifdef MOUNT_KLUDGE 531 kfd = dev->kludge; 532 dev->kludge = -1; 533 #endif 534 535 mutex_unlock(&dev->ben); 536 537 #ifdef MOUNT_KLUDGE 538 if (kfd > -1) { 539 close(kfd); 540 } 541 #endif 542 return B_OK; 543 } 544 545 546 status_t nbd_free(cookie_t *cookie) { 547 struct nbd_device *dev = cookie->dev; 548 status_t err; 549 PRINT((DP ">%s(%d)\n", __FUNCTION__, WHICH(cookie->dev))); 550 551 err = mutex_lock(&dev->ben); 552 if (err) 553 return err; 554 555 if (--dev->refcnt == 0) { 556 err = nbd_teardown(dev); 557 } 558 559 mutex_unlock(&dev->ben); 560 561 free(cookie); 562 return err; 563 } 564 565 566 status_t nbd_control(cookie_t *cookie, uint32 op, void *data, size_t len) { 567 PRINT((DP ">%s(%d, %" B_PRIu32 ", , %ld)\n", __FUNCTION__, 568 WHICH(cookie->dev), op, len)); 569 switch (op) { 570 case B_GET_DEVICE_SIZE: /* this one is broken anyway... */ 571 if (data) { 572 *(size_t *)data = (size_t)cookie->dev->size; 573 return B_OK; 574 } 575 return EINVAL; 576 case B_SET_DEVICE_SIZE: /* broken */ 577 return EINVAL; 578 case B_SET_NONBLOCKING_IO: 579 return EINVAL; 580 case B_SET_BLOCKING_IO: 581 return B_OK; 582 case B_GET_READ_STATUS: 583 case B_GET_WRITE_STATUS: 584 if (data) { 585 *(bool *)data = false; 586 return B_OK; 587 } 588 return EINVAL; 589 case B_GET_GEOMETRY: 590 case B_GET_BIOS_GEOMETRY: 591 if (data) { 592 device_geometry *geom = (device_geometry *)data; 593 geom->bytes_per_sector = BLKSIZE; 594 geom->sectors_per_track = 1; 595 geom->cylinder_count = cookie->dev->size / BLKSIZE; 596 geom->head_count = 1; 597 geom->device_type = B_DISK; 598 geom->removable = false; 599 geom->read_only = cookie->dev->readonly; 600 geom->write_once = false; 601 return B_OK; 602 } 603 return EINVAL; 604 case B_GET_MEDIA_STATUS: 605 if (data) { 606 *(status_t *)data = B_OK; 607 return B_OK; 608 } 609 return EINVAL; 610 611 case B_EJECT_DEVICE: 612 case B_LOAD_MEDIA: 613 return B_BAD_VALUE; 614 case B_FLUSH_DRIVE_CACHE: /* wait for request list to be empty ? */ 615 return B_OK; 616 default: 617 return B_BAD_VALUE; 618 } 619 return B_NOT_ALLOWED; 620 } 621 622 623 status_t nbd_read(cookie_t *cookie, off_t position, void *data, size_t *numbytes) { 624 struct nbd_device *dev = cookie->dev; 625 struct nbd_request_entry *req; 626 status_t err, semerr; 627 PRINT((DP ">%s(%d, %" B_PRIdOFF ", , )\n", __FUNCTION__, 628 WHICH(cookie->dev), position)); 629 630 if (position < 0) 631 return EINVAL; 632 if (!data) 633 return EINVAL; 634 635 err = nbd_alloc_request(dev, &req, NBD_CMD_READ, position, *numbytes, NULL); 636 if (err) 637 goto err0; 638 639 //LOCK 640 err = mutex_lock(&dev->ben); 641 if (err) 642 goto err1; 643 644 err = nbd_post_request(dev, req); 645 646 //UNLOCK 647 mutex_unlock(&dev->ben); 648 649 if (err) 650 goto err2; 651 652 653 semerr = acquire_sem(req->sem); 654 655 //LOCK 656 err = mutex_lock(&dev->ben); 657 if(err) 658 goto err3; 659 660 /* bad scenarii */ 661 if (!req->replied) 662 req->discard = true; 663 else if (semerr) 664 nbd_free_request(dev, req); 665 666 //UNLOCK 667 mutex_unlock(&dev->ben); 668 669 if (semerr == B_OK) { 670 *numbytes = req->len; 671 memcpy(data, req->buffer, req->len); 672 err = B_OK; 673 if (*numbytes == 0 && req->reply.error) 674 err = EIO; 675 nbd_free_request(dev, req); 676 return err; 677 } 678 679 *numbytes = 0; 680 return semerr; 681 682 683 err3: 684 err2: 685 err1: 686 nbd_free_request(dev, req); 687 err0: 688 *numbytes = 0; 689 return err; 690 } 691 692 693 status_t nbd_write(cookie_t *cookie, off_t position, const void *data, size_t *numbytes) { 694 struct nbd_device *dev = cookie->dev; 695 struct nbd_request_entry *req; 696 status_t err, semerr; 697 PRINT((DP ">%s(%d, %" B_PRIdOFF ", %ld, )\n", __FUNCTION__, 698 WHICH(cookie->dev), position, *numbytes)); 699 700 if (position < 0) 701 return EINVAL; 702 if (!data) 703 return EINVAL; 704 err = B_NOT_ALLOWED; 705 if (dev->readonly) 706 goto err0; 707 708 err = nbd_alloc_request(dev, &req, NBD_CMD_WRITE, position, *numbytes, data); 709 if (err) 710 goto err0; 711 712 //LOCK 713 err = mutex_lock(&dev->ben); 714 if (err) 715 goto err1; 716 717 /* sending request+data must be atomic */ 718 err = nbd_post_request(dev, req); 719 720 //UNLOCK 721 mutex_unlock(&dev->ben); 722 723 if (err) 724 goto err2; 725 726 727 semerr = acquire_sem(req->sem); 728 729 //LOCK 730 err = mutex_lock(&dev->ben); 731 if(err) 732 goto err3; 733 734 /* bad scenarii */ 735 if (!req->replied) 736 req->discard = true; 737 else if (semerr) 738 nbd_free_request(dev, req); 739 740 //UNLOCK 741 mutex_unlock(&dev->ben); 742 743 if (semerr == B_OK) { 744 *numbytes = req->len; 745 err = B_OK; 746 if (*numbytes == 0 && req->reply.error) 747 err = EIO; 748 nbd_free_request(dev, req); 749 return err; 750 } 751 752 *numbytes = 0; 753 return semerr; 754 755 756 err3: 757 err2: 758 err1: 759 nbd_free_request(dev, req); 760 err0: 761 *numbytes = 0; 762 return err; 763 } 764 765 766 device_hooks nbd_hooks={ 767 (device_open_hook)nbd_open, 768 (device_close_hook)nbd_close, 769 (device_free_hook)nbd_free, 770 (device_control_hook)nbd_control, 771 (device_read_hook)nbd_read, 772 (device_write_hook)nbd_write, 773 NULL, 774 NULL, 775 NULL, 776 NULL 777 }; 778 779 #if 0 780 #pragma mark ==== driver hooks ==== 781 #endif 782 783 int32 api_version = B_CUR_DRIVER_API_VERSION; 784 785 static char *nbd_name[MAX_NBDS+1] = { 786 NULL 787 }; 788 789 790 status_t 791 init_hardware (void) 792 { 793 PRINT((DP ">%s()\n", __FUNCTION__)); 794 return B_OK; 795 } 796 797 798 status_t 799 init_driver (void) 800 { 801 status_t err; 802 int i, j; 803 // XXX: load settings 804 void *handle; 805 char **names = nbd_name; 806 PRINT((DP ">%s()\n", __FUNCTION__)); 807 808 handle = load_driver_settings(DRV); 809 if (handle == NULL) 810 return ENOENT; 811 // XXX: test for boot args ? 812 813 814 err = ksocket_init(); 815 if (err < B_OK) 816 return err; 817 818 for (i = 0; i < MAX_NBDS; i++) { 819 nbd_devices[i].valid = false; 820 nbd_devices[i].readonly = false; 821 mutex_init(&nbd_devices[i].ben, "nbd lock"); 822 nbd_devices[i].refcnt = 0; 823 nbd_devices[i].req = 0LL; /* next ID for requests */ 824 nbd_devices[i].sock = -1; 825 nbd_devices[i].postoffice = -1; 826 nbd_devices[i].size = 0LL; 827 nbd_devices[i].reqs = NULL; 828 #ifdef MOUNT_KLUDGE 829 nbd_devices[i].kludge = -1; 830 #endif 831 nbd_name[i] = NULL; 832 } 833 834 for (i = 0; i < MAX_NBDS; i++) { 835 const driver_settings *settings = get_driver_settings(handle); 836 driver_parameter *p = NULL; 837 char keyname[10]; 838 sprintf(keyname, "%d", i); 839 for (j = 0; j < settings->parameter_count; j++) 840 if (!strcmp(settings->parameters[j].name, keyname)) 841 p = &settings->parameters[j]; 842 if (!p) 843 continue; 844 for (j = 0; j < p->parameter_count; j++) { 845 if (!strcmp(p->parameters[j].name, "readonly")) 846 nbd_devices[i].readonly = true; 847 if (!strcmp(p->parameters[j].name, "server")) { 848 if (p->parameters[j].value_count < 2) 849 continue; 850 nbd_devices[i].server.sin_len = sizeof(struct sockaddr_in); 851 nbd_devices[i].server.sin_family = AF_INET; 852 kinet_aton(p->parameters[j].values[0], &nbd_devices[i].server.sin_addr); 853 nbd_devices[i].server.sin_port = htons(atoi(p->parameters[j].values[1])); 854 dprintf(DP " configured [%d]\n", i); 855 *(names) = malloc(DEVICE_NAME_MAX); 856 if (*(names) == NULL) 857 return ENOMEM; 858 sprintf(*(names++), DEVICE_FMT, i); 859 nbd_devices[i].valid = true; 860 } 861 } 862 } 863 *names = NULL; 864 865 unload_driver_settings(handle); 866 return B_OK; 867 } 868 869 870 void 871 uninit_driver (void) 872 { 873 int i; 874 PRINT((DP ">%s()\n", __FUNCTION__)); 875 for (i = 0; i < MAX_NBDS; i++) { 876 free(nbd_name[i]); 877 mutex_destroy(&nbd_devices[i].ben); 878 } 879 ksocket_cleanup(); 880 /* HACK */ 881 if (gDelayUnload) 882 snooze(BONE_TEARDOWN_DELAY); 883 } 884 885 886 const char** 887 publish_devices() 888 { 889 PRINT((DP ">%s()\n", __FUNCTION__)); 890 return (const char **)nbd_name; 891 } 892 893 894 device_hooks* 895 find_device(const char* name) 896 { 897 PRINT((DP ">%s(%s)\n", __FUNCTION__, name)); 898 return &nbd_hooks; 899 } 900 901 902 struct nbd_device* 903 nbd_find_device(const char* name) 904 { 905 int i; 906 PRINT((DP ">%s(%s)\n", __FUNCTION__, name)); 907 for (i = 0; i < MAX_NBDS; i++) { 908 char buf[DEVICE_NAME_MAX]; 909 sprintf(buf, DEVICE_FMT, i); 910 if (!strcmp(buf, name)) 911 return &nbd_devices[i]; 912 } 913 return NULL; 914 } 915 916