lustre/ost/ost_handler.c

   1 /*
   2  *  ost/ost_handler.c
   3  *  Storage Target Handling functions
   4  *
   5  *  Lustre Object Server Module (OST)
   6  *
   7  *  Copyright (C) 2001  Cluster File Systems, Inc.
   8  *
   9  *  This code is issued under the GNU General Public License.
  10  *  See the file COPYING in this distribution
  11  *
  12  *  by Peter Braam <braam@clusterfs.com>
  13  *
  14  *  This server is single threaded at present (but can easily be multi threaded).
  15  *  For testing and management it is treated as an obd_device, although it does
  16  *  not export a full OBD method table (the requests are coming in over the wire,
  17  *  so object target modules do not have a full method table.)
  18  *
  19  */
  20
  21
  22 #define EXPORT_SYMTAB
  23
  24 #include <linux/version.h>
  25 #include <linux/module.h>
  26 #include <linux/fs.h>
  27 #include <linux/stat.h>
  28 #include <linux/locks.h>
  29 #include <linux/ext2_fs.h>
  30 #include <linux/quotaops.h>
  31 #include <asm/unistd.h>
  32 #include <linux/obd_support.h>
  33 #include <linux/obd.h>
  34 #include <linux/obd_class.h>
  35 #include <linux/lustre_lib.h>
  36 #include <linux/lustre_idl.h>
  37 #include <linux/lustre_mds.h>
  38 #include <linux/obd_class.h>
  39
  40 // for testing
  41 static int ost_queue_req(struct obd_device *obddev, struct ptlrpc_request *req)
  42 {
  43         struct ptlrpc_request *srv_req;
  44         struct ost_obd *ost = &obddev->u.ost;
  45
  46         if (!ost) {
  47                 EXIT;
  48                 return -1;
  49         }
  50
  51         srv_req = kmalloc(sizeof(*srv_req), GFP_KERNEL);
  52         if (!srv_req) {
  53                 EXIT;
  54                 return -ENOMEM;
  55         }
  56
  57         printk("---> OST at %d %p, incoming req %p, srv_req %p\n",
  58                __LINE__, ost, req, srv_req);
  59
  60         memset(srv_req, 0, sizeof(*req));
  61
  62         /* move the request buffer */
  63         srv_req->rq_reqbuf = req->rq_reqbuf;
  64         srv_req->rq_reqlen    = req->rq_reqlen;
  65         srv_req->rq_ost = ost;
  66
  67         /* remember where it came from */
  68         srv_req->rq_reply_handle = req;
  69
  70         list_add(&srv_req->rq_list, &ost->ost_reqs);
  71         wake_up(&ost->ost_waitq);
  72         return 0;
  73 }
  74
  75
  76 /* XXX replace with networking code */
  77 int ost_reply(struct obd_device *obddev, struct ptlrpc_request *req)
  78 {
  79         struct ptlrpc_request *clnt_req = req->rq_reply_handle;
  80
  81         ENTRY;
  82         printk("ost_reply: req %p clnt_req at %p\n", req, clnt_req);
  83
  84         /* free the request buffer */
  85         kfree(req->rq_reqbuf);
  86         req->rq_reqbuf = NULL;
  87
  88         /* move the reply to the client */
  89         clnt_req->rq_replen = req->rq_replen;
  90         clnt_req->rq_repbuf = req->rq_repbuf;
  91
  92         printk("---> client req %p repbuf %p len %d status %d\n",
  93                clnt_req, clnt_req->rq_repbuf, clnt_req->rq_replen,
  94                req->rq_rephdr->status);
  95
  96         req->rq_repbuf = NULL;
  97         req->rq_replen = 0;
  98
  99         /* free the server request */
 100         kfree(req);
 101         /* wake up the client */
 102         wake_up_interruptible(&clnt_req->rq_wait_for_rep);
 103         EXIT;
 104         return 0;
 105 }
 106
 107 int ost_error(struct obd_device *obddev, struct ptlrpc_request *req)
 108 {
 109         struct ptlrep_hdr *hdr;
 110
 111         ENTRY;
 112         hdr = kmalloc(sizeof(*hdr), GFP_KERNEL);
 113         if (!hdr) {
 114                 EXIT;
 115                 return -ENOMEM;
 116         }
 117
 118         memset(hdr, 0, sizeof(*hdr));
 119
 120         hdr->seqno = req->rq_reqhdr->seqno;
 121         hdr->status = req->rq_status;
 122         hdr->type = OST_TYPE_ERR;
 123
 124         req->rq_repbuf = (char *)hdr;
 125         req->rq_replen = sizeof(*hdr);
 126
 127         EXIT;
 128         return ost_reply(obddev, req);
 129 }
 130
 131 static int ost_destroy(struct ost_obd *ost, struct ptlrpc_request *req)
 132 {
 133         struct obd_conn conn;
 134         int rc;
 135
 136         ENTRY;
 137
 138         conn.oc_id = req->rq_req.ost->connid;
 139         conn.oc_dev = ost->ost_tgt;
 140
 141         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 142                           &req->rq_replen, &req->rq_repbuf);
 143         if (rc) {
 144                 printk("ost_destroy: cannot pack reply\n");
 145                 return rc;
 146         }
 147
 148         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_destroy
 149                 (&conn, &req->rq_req.ost->oa);
 150
 151         EXIT;
 152         return 0;
 153 }
 154
 155 static int ost_getattr(struct ost_obd *ost, struct ptlrpc_request *req)
 156 {
 157         struct obd_conn conn;
 158         int rc;
 159
 160         ENTRY;
 161         printk("ost getattr entered\n");
 162
 163         conn.oc_id = req->rq_req.ost->connid;
 164         conn.oc_dev = ost->ost_tgt;
 165
 166         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 167                           &req->rq_replen, &req->rq_repbuf);
 168         if (rc) {
 169                 printk("ost_getattr: cannot pack reply\n");
 170                 return rc;
 171         }
 172         req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id;
 173         req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid;
 174
 175         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_getattr
 176                 (&conn, &req->rq_rep.ost->oa);
 177
 178         EXIT;
 179         return 0;
 180 }
 181
 182 static int ost_create(struct ost_obd *ost, struct ptlrpc_request *req)
 183 {
 184         struct obd_conn conn;
 185         int rc;
 186
 187         ENTRY;
 188
 189         conn.oc_id = req->rq_req.ost->connid;
 190         conn.oc_dev = ost->ost_tgt;
 191
 192         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 193                           &req->rq_replen, &req->rq_repbuf);
 194         if (rc) {
 195                 printk("ost_create: cannot pack reply\n");
 196                 return rc;
 197         }
 198
 199         memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, sizeof(req->rq_req.ost->oa));
 200
 201         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_create
 202                 (&conn, &req->rq_rep.ost->oa);
 203
 204         EXIT;
 205         return 0;
 206 }
 207
 208
 209 static int ost_setattr(struct ost_obd *ost, struct ptlrpc_request *req)
 210 {
 211         struct obd_conn conn;
 212         int rc;
 213
 214         ENTRY;
 215
 216         conn.oc_id = req->rq_req.ost->connid;
 217         conn.oc_dev = ost->ost_tgt;
 218
 219         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 220                           &req->rq_replen, &req->rq_repbuf);
 221         if (rc) {
 222                 printk("ost_setattr: cannot pack reply\n");
 223                 return rc;
 224         }
 225
 226         memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, sizeof(req->rq_req.ost->oa));
 227
 228         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_setattr
 229                 (&conn, &req->rq_rep.ost->oa);
 230
 231         EXIT;
 232         return 0;
 233 }
 234
 235 static int ost_connect(struct ost_obd *ost, struct ptlrpc_request *req)
 236 {
 237         struct obd_conn conn;
 238         int rc;
 239
 240         ENTRY;
 241
 242         conn.oc_dev = ost->ost_tgt;
 243
 244         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 245                           &req->rq_replen, &req->rq_repbuf);
 246         if (rc) {
 247                 printk("ost_setattr: cannot pack reply\n");
 248                 return rc;
 249         }
 250
 251         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_connect(&conn);
 252
 253         printk("ost_connect: rep buffer %p, id %d\n", req->rq_repbuf,
 254                conn.oc_id);
 255         req->rq_rep.ost->connid = conn.oc_id;
 256         EXIT;
 257         return 0;
 258 }
 259
 260
 261 static int ost_disconnect(struct ost_obd *ost, struct ptlrpc_request *req)
 262 {
 263         struct obd_conn conn;
 264         int rc;
 265
 266         ENTRY;
 267
 268         conn.oc_dev = ost->ost_tgt;
 269         conn.oc_id = req->rq_req.ost->connid;
 270
 271         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 272                           &req->rq_replen, &req->rq_repbuf);
 273         if (rc) {
 274                 printk("ost_setattr: cannot pack reply\n");
 275                 return rc;
 276         }
 277
 278         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_disconnect(&conn);
 279
 280         EXIT;
 281         return 0;
 282 }
 283
 284 static int ost_get_info(struct ost_obd *ost, struct ptlrpc_request *req)
 285 {
 286         struct obd_conn conn;
 287         int rc;
 288         int vallen;
 289         void *val;
 290         char *ptr;
 291
 292         ENTRY;
 293
 294         conn.oc_id = req->rq_req.ost->connid;
 295         conn.oc_dev = ost->ost_tgt;
 296
 297         ptr = ost_req_buf1(req->rq_req.ost);
 298         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_get_info
 299                 (&conn, req->rq_req.ost->buflen1, ptr, &vallen, &val);
 300
 301         rc = ost_pack_rep(val, vallen, NULL, 0, &req->rq_rephdr, &req->rq_rep.ost,
 302                           &req->rq_replen, &req->rq_repbuf);
 303         if (rc) {
 304                 printk("ost_setattr: cannot pack reply\n");
 305                 return rc;
 306         }
 307
 308         EXIT;
 309         return 0;
 310 }
 311
 312
 313 static struct page * ext2_get_page(struct inode *dir, unsigned long n)
 314 {
 315         struct address_space *mapping = dir->i_mapping;
 316         struct page *page = read_cache_page(mapping, n,
 317                                 (filler_t*)mapping->a_ops->readpage, NULL);
 318         if (!IS_ERR(page)) {
 319                 wait_on_page(page);
 320                 kmap(page);
 321                 if (!Page_Uptodate(page))
 322                         goto fail;
 323                 if (!PageChecked(page))
 324                         ext2_check_page(page);
 325                 if (PageError(page))
 326                         goto fail;
 327         }
 328         return page;
 329
 330 fail:
 331         ext2_put_page(page);
 332         return ERR_PTR(-EIO);
 333 }
 334
 335 #if 0
 336
 337 static inline void ext2_put_page(struct page *page)
 338 {
 339         kunmap(page);
 340         page_cache_release(page);
 341 }
 342
 343 /* Releases the page */
 344 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
 345                         struct page *page, struct inode *inode)
 346 {
 347         unsigned from = (char *) de - (char *) page_address(page);
 348         unsigned to = from + le16_to_cpu(de->rec_len);
 349         int err;
 350
 351         lock_page(page);
 352         err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
 353         if (err)
 354                 BUG();
 355         de->inode = cpu_to_le32(inode->i_ino);
 356         ext2_set_de_type (de, inode);
 357         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 358         err = ext2_commit_chunk(page, from, to);
 359         UnlockPage(page);
 360         ext2_put_page(page);
 361 }
 362
 363 static int ext2_commit_chunk(struct page *page, unsigned from, unsigned to)
 364 {
 365         struct inode *dir = page->mapping->host;
 366         int err = 0;
 367         dir->i_version = ++event;
 368         SetPageUptodate(page);
 369         set_page_clean(page);
 370
 371         //page->mapping->a_ops->commit_write(NULL, page, from, to);
 372         //if (IS_SYNC(dir))
 373         //      err = waitfor_one_page(page);
 374         return err;
 375 }
 376
 377 #endif
 378
 379 int ost_prepw(struct ost_obd *obddev, struct ptlrpc_request *req)
 380 {
 381 #if 0
 382         struct obd_conn conn;
 383         int rc;
 384         int i, j, n;
 385         int objcount;
 386         void *tmp;
 387         struct niobuf **nb;
 388         struct obd_ioo **ioo;
 389
 390         ENTRY;
 391
 392         tmp1 = ost_req_buf1(req);
 393         tmp2 = ost_req_buf2(req);
 394         objcount = req->buflen1 / sizeof(**ioo);
 395
 396         n = 0;
 397         for (i=0 ; i<objcount ; i++) {
 398                 obd_unpack_ioo
 399
 400         conn.oc_id = req->rq_req.ost->connid;
 401         conn.oc_dev = ost->ost_tgt;
 402
 403         rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
 404                           &req->rq_replen, &req->rq_repbuf);
 405         if (rc) {
 406                 printk("ost_create: cannot pack reply\n");
 407                 return rc;
 408         }
 409
 410         memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, sizeof(req->rq_req.ost->oa));
 411
 412         req->rq_rep.ost->result =ost->ost_tgt->obd_type->typ_ops->o_create
 413                 (&conn, &req->rq_rep.ost->oa);
 414
 415         EXIT;
 416         return 0;
 417 #endif
 418         return -ENOTSUPP;
 419
 420 }
 421
 422
 423 int ost_handle(struct obd_device *obddev, struct ptlrpc_request *req)
 424 {
 425         int rc;
 426         struct ost_obd *ost = &obddev->u.ost;
 427         struct ptlreq_hdr *hdr;
 428
 429         ENTRY;
 430         printk("ost_handle: req at %p\n", req);
 431
 432         hdr = (struct ptlreq_hdr *)req->rq_reqbuf;
 433         if (NTOH__u32(hdr->type) != OST_TYPE_REQ) {
 434                 printk("lustre_ost: wrong packet type sent %d\n",
 435                        NTOH__u32(hdr->type));
 436                 rc = -EINVAL;
 437                 goto out;
 438         }
 439
 440         rc = ost_unpack_req(req->rq_reqbuf, req->rq_reqlen,
 441                             &req->rq_reqhdr, &req->rq_req.ost);
 442         if (rc) {
 443                 printk("lustre_ost: Invalid request\n");
 444                 EXIT;
 445                 goto out;
 446         }
 447
 448         switch (req->rq_reqhdr->opc) {
 449
 450         case OST_CONNECT:
 451                 CDEBUG(D_INODE, "connect\n");
 452                 printk("----> connect \n");
 453                 rc = ost_connect(ost, req);
 454                 break;
 455         case OST_DISCONNECT:
 456                 CDEBUG(D_INODE, "disconnect\n");
 457                 rc = ost_disconnect(ost, req);
 458                 break;
 459         case OST_GET_INFO:
 460                 CDEBUG(D_INODE, "get_info\n");
 461                 rc = ost_get_info(ost, req);
 462                 break;
 463         case OST_CREATE:
 464                 CDEBUG(D_INODE, "create\n");
 465                 rc = ost_create(ost, req);
 466                 break;
 467         case OST_DESTROY:
 468                 CDEBUG(D_INODE, "destroy\n");
 469                 rc = ost_destroy(ost, req);
 470                 break;
 471         case OST_GETATTR:
 472                 CDEBUG(D_INODE, "getattr\n");
 473                 rc = ost_getattr(ost, req);
 474                 break;
 475         case OST_SETATTR:
 476                 CDEBUG(D_INODE, "setattr\n");
 477                 rc = ost_setattr(ost, req);
 478                 break;
 479         case OST_PREPW:
 480                 CDEBUG(D_INODE, "prepw\n");
 481                 rc = ost_prepw(ost, req);
 482                 break;
 483         default:
 484                 req->rq_status = -ENOTSUPP;
 485                 return ost_error(obddev, req);
 486         }
 487
 488 out:
 489         req->rq_status = rc;
 490         if (rc) {
 491                 printk("ost: processing error %d\n", rc);
 492                 ost_error(obddev, req);
 493         } else {
 494                 CDEBUG(D_INODE, "sending reply\n");
 495                 ost_reply(obddev, req);
 496         }
 497
 498         return 0;
 499 }
 500
 501 int ost_main(void *arg)
 502 {
 503         struct obd_device *obddev = (struct obd_device *) arg;
 504         struct ost_obd *ost = &obddev->u.ost;
 505         ENTRY;
 506         printk("---> %d\n", __LINE__);
 507
 508
 509         lock_kernel();
 510         printk("---> %d\n", __LINE__);
 511         daemonize();
 512         printk("---> %d\n", __LINE__);
 513         spin_lock_irq(&current->sigmask_lock);
 514         printk("---> %d\n", __LINE__);
 515         sigfillset(&current->blocked);
 516         printk("---> %d\n", __LINE__);
 517         recalc_sigpending(current);
 518         printk("---> %d\n", __LINE__);
 519         spin_unlock_irq(&current->sigmask_lock);
 520         printk("---> %d\n", __LINE__);
 521
 522         printk("---> %d\n", __LINE__);
 523         sprintf(current->comm, "lustre_ost");
 524         printk("---> %d\n", __LINE__);
 525
 526         /* Record that the  thread is running */
 527         ost->ost_thread = current;
 528         printk("---> %d\n", __LINE__);
 529         wake_up(&ost->ost_done_waitq);
 530         printk("---> %d\n", __LINE__);
 531
 532         /* XXX maintain a list of all managed devices: insert here */
 533
 534         /* And now, wait forever for commit wakeup events. */
 535         while (1) {
 536                 struct ptlrpc_request *request;
 537                 int rc;
 538
 539                 if (ost->ost_flags & OST_EXIT)
 540                         break;
 541
 542
 543                 wake_up(&ost->ost_done_waitq);
 544                 interruptible_sleep_on(&ost->ost_waitq);
 545
 546                 CDEBUG(D_INODE, "lustre_ost wakes\n");
 547                 CDEBUG(D_INODE, "pick up req here and continue\n");
 548
 549                 if (list_empty(&ost->ost_reqs)) {
 550                         CDEBUG(D_INODE, "woke because of timer\n");
 551                 } else {
 552                         printk("---> %d\n", __LINE__);
 553                         request = list_entry(ost->ost_reqs.next,
 554                                              struct ptlrpc_request, rq_list);
 555                         printk("---> %d\n", __LINE__);
 556                         list_del(&request->rq_list);
 557                         rc = ost_handle(obddev, request);
 558                 }
 559         }
 560
 561         /* XXX maintain a list of all managed devices: cleanup here */
 562         printk("---> %d\n", __LINE__);
 563         ost->ost_thread = NULL;
 564         printk("---> %d\n", __LINE__);
 565         wake_up(&ost->ost_done_waitq);
 566         printk("lustre_ost: exiting\n");
 567         return 0;
 568 }
 569
 570 static void ost_stop_srv_thread(struct ost_obd *ost)
 571 {
 572         ost->ost_flags |= OST_EXIT;
 573
 574         while (ost->ost_thread) {
 575                 wake_up(&ost->ost_waitq);
 576                 sleep_on(&ost->ost_done_waitq);
 577         }
 578 }
 579
 580 static void ost_start_srv_thread(struct obd_device *obd)
 581 {
 582         struct ost_obd *ost = &obd->u.ost;
 583         ENTRY;
 584
 585         init_waitqueue_head(&ost->ost_waitq);
 586         printk("---> %d\n", __LINE__);
 587         init_waitqueue_head(&ost->ost_done_waitq);
 588         printk("---> %d\n", __LINE__);
 589         kernel_thread(ost_main, (void *)obd,
 590                       CLONE_VM | CLONE_FS | CLONE_FILES);
 591         printk("---> %d\n", __LINE__);
 592         while (!ost->ost_thread)
 593                 sleep_on(&ost->ost_done_waitq);
 594         printk("---> %d\n", __LINE__);
 595         EXIT;
 596 }
 597
 598 /* mount the file system (secretly) */
 599 static int ost_setup(struct obd_device *obddev, obd_count len,
 600                         void *buf)
 601
 602 {
 603         struct obd_ioctl_data* data = buf;
 604         struct ost_obd *ost = &obddev->u.ost;
 605         struct obd_device *tgt;
 606         int err;
 607         ENTRY;
 608
 609         if (data->ioc_dev  < 0 || data->ioc_dev > MAX_OBD_DEVICES) {
 610                 EXIT;
 611                 return -ENODEV;
 612         }
 613
 614         tgt = &obd_dev[data->ioc_dev];
 615         ost->ost_tgt = tgt;
 616         if ( ! (tgt->obd_flags & OBD_ATTACHED) ||
 617              ! (tgt->obd_flags & OBD_SET_UP) ){
 618                 printk("device not attached or not set up (%d)\n",
 619                        data->ioc_dev);
 620                 EXIT;
 621                 return -EINVAL;
 622         }
 623
 624         ost->ost_conn.oc_dev = tgt;
 625         err = tgt->obd_type->typ_ops->o_connect(&ost->ost_conn);
 626         if (err) {
 627                 printk("lustre ost: fail to connect to device %d\n",
 628                        data->ioc_dev);
 629                 return -EINVAL;
 630         }
 631
 632         INIT_LIST_HEAD(&ost->ost_reqs);
 633         ost->ost_thread = NULL;
 634         ost->ost_flags = 0;
 635
 636         spin_lock_init(&obddev->u.ost.ost_lock);
 637
 638         ost_start_srv_thread(obddev);
 639
 640         MOD_INC_USE_COUNT;
 641         EXIT;
 642         return 0;
 643 }
 644
 645 static int ost_cleanup(struct obd_device * obddev)
 646 {
 647         struct ost_obd *ost = &obddev->u.ost;
 648         struct obd_device *tgt;
 649         int err;
 650
 651         ENTRY;
 652
 653         if ( !(obddev->obd_flags & OBD_SET_UP) ) {
 654                 EXIT;
 655                 return 0;
 656         }
 657
 658         if ( !list_empty(&obddev->obd_gen_clients) ) {
 659                 printk(KERN_WARNING __FUNCTION__ ": still has clients!\n");
 660                 EXIT;
 661                 return -EBUSY;
 662         }
 663
 664         ost_stop_srv_thread(ost);
 665
 666         if (!list_empty(&ost->ost_reqs)) {
 667                 // XXX reply with errors and clean up
 668                 CDEBUG(D_INODE, "Request list not empty!\n");
 669         }
 670
 671         tgt = ost->ost_tgt;
 672         err = tgt->obd_type->typ_ops->o_disconnect(&ost->ost_conn);
 673         if (err) {
 674                 printk("lustre ost: fail to disconnect device\n");
 675                 return -EINVAL;
 676         }
 677
 678
 679         MOD_DEC_USE_COUNT;
 680         EXIT;
 681         return 0;
 682 }
 683
 684 /* use obd ops to offer management infrastructure */
 685 static struct obd_ops ost_obd_ops = {
 686         o_setup:       ost_setup,
 687         o_cleanup:     ost_cleanup,
 688 };
 689
 690 static int __init ost_init(void)
 691 {
 692         obd_register_type(&ost_obd_ops, LUSTRE_OST_NAME);
 693         return 0;
 694 }
 695
 696 static void __exit ost_exit(void)
 697 {
 698         obd_unregister_type(LUSTRE_OST_NAME);
 699 }
 700
 701 MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
 702 MODULE_DESCRIPTION("Lustre Object Storage Target (OST) v0.01");
 703 MODULE_LICENSE("GPL");
 704
 705 // for testing (maybe this stays)
 706 EXPORT_SYMBOL(ost_queue_req);
 707
 708 module_init(ost_init);
 709 module_exit(ost_exit);