1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
6 * This code is issued under the GNU General Public License.
7 * See the file COPYING in this distribution
9 * Author Peter Braam <braam@clusterfs.com>
11 * This server is single threaded at present (but can easily be multi
12 * threaded). For testing and management it is treated as an
13 * obd_device, although it does not export a full OBD method table
14 * (the requests are coming in over the wire, so object target
15 * modules do not have a full method table.)
20 #define DEBUG_SUBSYSTEM S_OSC
22 #include <linux/version.h>
23 #include <linux/module.h>
25 #include <linux/highmem.h>
26 #include <linux/lustre_dlm.h>
27 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
28 #include <linux/workqueue.h>
30 #include <linux/kp30.h>
31 #include <linux/lustre_mds.h> /* for mds_objid */
32 #include <linux/obd_ost.h>
33 #include <linux/obd_lov.h>
34 #include <linux/ctype.h>
35 #include <linux/init.h>
36 #include <linux/lustre_ha.h>
37 #include <linux/obd_support.h> /* for OBD_FAIL_CHECK */
38 #include <linux/lustre_lite.h> /* for ll_i2info */
40 static int osc_getattr(struct lustre_handle *conn, struct obdo *oa,
41 struct lov_stripe_md *md)
43 struct ptlrpc_request *request;
44 struct ost_body *body;
45 int rc, size = sizeof(*body);
48 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_GETATTR, 1,
53 body = lustre_msg_buf(request->rq_reqmsg, 0);
54 #warning FIXME: pack only valid fields instead of memcpy, endianness
55 memcpy(&body->oa, oa, sizeof(*oa));
57 request->rq_replen = lustre_msg_size(1, &size);
59 rc = ptlrpc_queue_wait(request);
60 rc = ptlrpc_check_status(request, rc);
62 CERROR("%s failed: rc = %d\n", __FUNCTION__, rc);
66 body = lustre_msg_buf(request->rq_repmsg, 0);
67 CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
69 memcpy(oa, &body->oa, sizeof(*oa));
73 ptlrpc_req_finished(request);
77 static int osc_open(struct lustre_handle *conn, struct obdo *oa,
78 struct lov_stripe_md *md)
80 struct ptlrpc_request *request;
81 struct ost_body *body;
82 int rc, size = sizeof(*body);
85 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_OPEN, 1, &size,
90 body = lustre_msg_buf(request->rq_reqmsg, 0);
91 #warning FIXME: pack only valid fields instead of memcpy, endianness
92 memcpy(&body->oa, oa, sizeof(*oa));
94 request->rq_replen = lustre_msg_size(1, &size);
96 rc = ptlrpc_queue_wait(request);
97 rc = ptlrpc_check_status(request, rc);
101 body = lustre_msg_buf(request->rq_repmsg, 0);
102 CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
104 memcpy(oa, &body->oa, sizeof(*oa));
108 ptlrpc_req_finished(request);
112 static int osc_close(struct lustre_handle *conn, struct obdo *oa,
113 struct lov_stripe_md *md)
115 struct ptlrpc_request *request;
116 struct ost_body *body;
117 int rc, size = sizeof(*body);
120 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_CLOSE, 1, &size,
125 body = lustre_msg_buf(request->rq_reqmsg, 0);
126 #warning FIXME: pack only valid fields instead of memcpy, endianness
127 memcpy(&body->oa, oa, sizeof(*oa));
129 request->rq_replen = lustre_msg_size(1, &size);
131 rc = ptlrpc_queue_wait(request);
132 rc = ptlrpc_check_status(request, rc);
136 body = lustre_msg_buf(request->rq_repmsg, 0);
137 CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
139 memcpy(oa, &body->oa, sizeof(*oa));
143 ptlrpc_req_finished(request);
147 static int osc_setattr(struct lustre_handle *conn, struct obdo *oa,
148 struct lov_stripe_md *md)
150 struct ptlrpc_request *request;
151 struct ost_body *body;
152 int rc, size = sizeof(*body);
155 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_SETATTR, 1,
160 body = lustre_msg_buf(request->rq_reqmsg, 0);
161 memcpy(&body->oa, oa, sizeof(*oa));
163 request->rq_replen = lustre_msg_size(1, &size);
165 rc = ptlrpc_queue_wait(request);
166 rc = ptlrpc_check_status(request, rc);
168 ptlrpc_req_finished(request);
172 static int osc_create(struct lustre_handle *conn, struct obdo *oa,
173 struct lov_stripe_md **ea)
175 struct ptlrpc_request *request;
176 struct ost_body *body;
177 struct lov_stripe_md *lsm;
178 int rc, size = sizeof(*body);
186 // XXX check oa->o_valid & OBD_MD_FLEASIZE first...
187 OBD_ALLOC(lsm, oa->o_easize);
190 lsm->lsm_mds_easize = oa->o_easize;
193 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_CREATE, 1, &size,
196 GOTO(out, rc = -ENOMEM);
198 body = lustre_msg_buf(request->rq_reqmsg, 0);
199 memcpy(&body->oa, oa, sizeof(*oa));
201 request->rq_replen = lustre_msg_size(1, &size);
203 rc = ptlrpc_queue_wait(request);
204 rc = ptlrpc_check_status(request, rc);
208 body = lustre_msg_buf(request->rq_repmsg, 0);
209 memcpy(oa, &body->oa, sizeof(*oa));
211 lsm->lsm_object_id = oa->o_id;
212 lsm->lsm_stripe_count = 0;
216 ptlrpc_req_finished(request);
219 OBD_FREE(lsm, oa->o_easize);
223 static int osc_punch(struct lustre_handle *conn, struct obdo *oa,
224 struct lov_stripe_md *md, obd_size start,
227 struct ptlrpc_request *request;
228 struct ost_body *body;
229 int rc, size = sizeof(*body);
237 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_PUNCH, 1, &size,
242 body = lustre_msg_buf(request->rq_reqmsg, 0);
243 #warning FIXME: pack only valid fields instead of memcpy, endianness, valid
244 memcpy(&body->oa, oa, sizeof(*oa));
246 /* overload the blocks and size fields in the oa with start/end */
247 #warning FIXME: endianness, size=start, blocks=end?
248 body->oa.o_blocks = start;
249 body->oa.o_size = end;
250 body->oa.o_valid |= OBD_MD_FLBLOCKS | OBD_MD_FLSIZE;
252 request->rq_replen = lustre_msg_size(1, &size);
254 rc = ptlrpc_queue_wait(request);
255 rc = ptlrpc_check_status(request, rc);
259 body = lustre_msg_buf(request->rq_repmsg, 0);
260 memcpy(oa, &body->oa, sizeof(*oa));
264 ptlrpc_req_finished(request);
268 static int osc_destroy(struct lustre_handle *conn, struct obdo *oa,
269 struct lov_stripe_md *ea)
271 struct ptlrpc_request *request;
272 struct ost_body *body;
273 int rc, size = sizeof(*body);
280 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_DESTROY, 1,
285 body = lustre_msg_buf(request->rq_reqmsg, 0);
286 #warning FIXME: pack only valid fields instead of memcpy, endianness
287 memcpy(&body->oa, oa, sizeof(*oa));
289 request->rq_replen = lustre_msg_size(1, &size);
291 rc = ptlrpc_queue_wait(request);
292 rc = ptlrpc_check_status(request, rc);
296 body = lustre_msg_buf(request->rq_repmsg, 0);
297 memcpy(oa, &body->oa, sizeof(*oa));
301 ptlrpc_req_finished(request);
305 struct osc_brw_cb_data {
306 brw_callback_t callback;
312 /* Our bulk-unmapping bottom half. */
313 static void unmap_and_decref_bulk_desc(void *data)
315 struct ptlrpc_bulk_desc *desc = data;
316 struct list_head *tmp;
319 /* This feels wrong to me. */
320 list_for_each(tmp, &desc->bd_page_list) {
321 struct ptlrpc_bulk_page *bulk;
322 bulk = list_entry(tmp, struct ptlrpc_bulk_page, bp_link);
324 kunmap(bulk->bp_page);
327 ptlrpc_bulk_decref(desc);
331 static void brw_finish(struct ptlrpc_bulk_desc *desc, void *data)
333 struct osc_brw_cb_data *cb_data = data;
337 if (desc->bd_flags & PTL_RPC_FL_TIMEOUT) {
338 err = (desc->bd_flags & PTL_RPC_FL_INTR ? -ERESTARTSYS :
342 if (cb_data->callback)
343 cb_data->callback(cb_data->cb_data, err, CB_PHASE_FINISH);
345 if (cb_data->obd_data)
346 OBD_FREE(cb_data->obd_data, cb_data->obd_size);
347 OBD_FREE(cb_data, sizeof(*cb_data));
349 /* We can't kunmap the desc from interrupt context, so we do it from
350 * the bottom half above. */
351 prepare_work(&desc->bd_queue, unmap_and_decref_bulk_desc, desc);
352 schedule_work(&desc->bd_queue);
357 static int osc_brw_read(struct lustre_handle *conn, struct lov_stripe_md *lsm,
358 obd_count page_count, struct brw_page *pga,
359 brw_callback_t callback, struct io_cb_data *data)
361 struct ptlrpc_connection *connection =
362 client_conn2cli(conn)->cl_import.imp_connection;
363 struct ptlrpc_request *request = NULL;
364 struct ptlrpc_bulk_desc *desc = NULL;
365 struct ost_body *body;
366 struct osc_brw_cb_data *cb_data = NULL;
367 int rc, size[3] = {sizeof(*body)};
368 void *iooptr, *nioptr;
373 size[1] = sizeof(struct obd_ioobj);
374 size[2] = page_count * sizeof(struct niobuf_remote);
376 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_READ, 3, size,
381 body = lustre_msg_buf(request->rq_reqmsg, 0);
383 desc = ptlrpc_prep_bulk(connection);
385 GOTO(out_req, rc = -ENOMEM);
386 desc->bd_portal = OST_BULK_PORTAL;
387 desc->bd_cb = brw_finish;
388 OBD_ALLOC(cb_data, sizeof(*cb_data));
390 GOTO(out_desc, rc = -ENOMEM);
392 cb_data->callback = callback;
393 cb_data->cb_data = data;
395 desc->bd_cb_data = cb_data;
397 iooptr = lustre_msg_buf(request->rq_reqmsg, 1);
398 nioptr = lustre_msg_buf(request->rq_reqmsg, 2);
399 ost_pack_ioo(&iooptr, lsm, page_count);
400 /* end almost identical to brw_write case */
402 spin_lock(&connection->c_lock);
403 xid = ++connection->c_xid_out; /* single xid for all pages */
404 spin_unlock(&connection->c_lock);
406 for (mapped = 0; mapped < page_count; mapped++) {
407 struct ptlrpc_bulk_page *bulk = ptlrpc_prep_bulk_page(desc);
409 GOTO(out_unmap, rc = -ENOMEM);
411 bulk->bp_xid = xid; /* single xid for all pages */
413 bulk->bp_buf = kmap(pga[mapped].pg);
414 bulk->bp_page = pga[mapped].pg;
415 bulk->bp_buflen = PAGE_SIZE;
416 ost_pack_niobuf(&nioptr, pga[mapped].off, pga[mapped].count,
417 pga[mapped].flag, bulk->bp_xid);
421 * Register the bulk first, because the reply could arrive out of order,
422 * and we want to be ready for the bulk data.
424 * The reference is released when brw_finish is complete.
426 * On error, we never do the brw_finish, so we handle all decrefs.
428 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_BRW_READ_BULK)) {
429 CERROR("obd_fail_loc=%x, skipping register_bulk\n",
430 OBD_FAIL_OSC_BRW_READ_BULK);
432 rc = ptlrpc_register_bulk(desc);
437 request->rq_replen = lustre_msg_size(1, size);
438 rc = ptlrpc_queue_wait(request);
439 rc = ptlrpc_check_status(request, rc);
442 * XXX: If there is an error during the processing of the callback,
443 * such as a timeout in a sleep that it performs, brw_finish
444 * will never get called, and we'll leak the desc, fail to kunmap
445 * things, cats will live with dogs. One solution would be to
446 * export brw_finish as osc_brw_finish, so that the timeout case
447 * and its kin could call it for proper cleanup. An alternative
448 * would be for an error return from the callback to cause us to
449 * clean up, but that doesn't help the truly async cases (like
450 * LOV), which will immediately return from their PHASE_START
451 * callback, before any such cleanup-requiring error condition can
457 /* Callbacks cause asynchronous handling. */
458 rc = callback(data, 0, CB_PHASE_START);
461 ptlrpc_req_finished(request);
464 /* Clean up on error. */
467 kunmap(pga[mapped].pg);
468 OBD_FREE(cb_data, sizeof(*cb_data));
470 ptlrpc_bulk_decref(desc);
474 static int osc_brw_write(struct lustre_handle *conn, struct lov_stripe_md *md,
475 obd_count page_count, struct brw_page *pga,
476 brw_callback_t callback, struct io_cb_data *data)
478 struct ptlrpc_connection *connection =
479 client_conn2cli(conn)->cl_import.imp_connection;
480 struct ptlrpc_request *request = NULL;
481 struct ptlrpc_bulk_desc *desc = NULL;
482 struct ost_body *body;
483 struct niobuf_local *local = NULL;
484 struct niobuf_remote *remote;
485 struct osc_brw_cb_data *cb_data = NULL;
486 int rc, j, size[3] = {sizeof(*body)};
487 void *iooptr, *nioptr;
491 size[1] = sizeof(struct obd_ioobj);
492 size[2] = page_count * sizeof(*remote);
494 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_WRITE, 3, size,
499 body = lustre_msg_buf(request->rq_reqmsg, 0);
501 desc = ptlrpc_prep_bulk(connection);
503 GOTO(out_req, rc = -ENOMEM);
504 desc->bd_portal = OSC_BULK_PORTAL;
505 desc->bd_cb = brw_finish;
506 OBD_ALLOC(cb_data, sizeof(*cb_data));
508 GOTO(out_desc, rc = -ENOMEM);
510 cb_data->callback = callback;
511 cb_data->cb_data = data;
513 desc->bd_cb_data = cb_data;
515 iooptr = lustre_msg_buf(request->rq_reqmsg, 1);
516 nioptr = lustre_msg_buf(request->rq_reqmsg, 2);
517 ost_pack_ioo(&iooptr, md, page_count);
518 /* end almost identical to brw_read case */
520 OBD_ALLOC(local, page_count * sizeof(*local));
522 GOTO(out_cb, rc = -ENOMEM);
524 cb_data->obd_data = local;
525 cb_data->obd_size = page_count * sizeof(*local);
527 for (mapped = 0; mapped < page_count; mapped++) {
528 local[mapped].addr = kmap(pga[mapped].pg);
530 CDEBUG(D_INFO, "kmap(pg) = %p ; pg->flags = %lx ; pg->count = "
531 "%d ; page %d of %d\n",
532 local[mapped].addr, pga[mapped].pg->flags,
533 page_count(pga[mapped].pg),
534 mapped, page_count - 1);
536 local[mapped].offset = pga[mapped].off;
537 local[mapped].len = pga[mapped].count;
538 ost_pack_niobuf(&nioptr, pga[mapped].off, pga[mapped].count,
539 pga[mapped].flag, 0);
542 size[1] = page_count * sizeof(*remote);
543 request->rq_replen = lustre_msg_size(2, size);
544 rc = ptlrpc_queue_wait(request);
545 rc = ptlrpc_check_status(request, rc);
549 nioptr = lustre_msg_buf(request->rq_repmsg, 1);
551 GOTO(out_unmap, rc = -EINVAL);
553 if (request->rq_repmsg->buflens[1] != size[1]) {
554 CERROR("buffer length wrong (%d vs. %d)\n",
555 request->rq_repmsg->buflens[1], size[1]);
556 GOTO(out_unmap, rc = -EINVAL);
559 for (j = 0; j < page_count; j++) {
560 struct ptlrpc_bulk_page *bulk;
562 ost_unpack_niobuf(&nioptr, &remote);
564 bulk = ptlrpc_prep_bulk_page(desc);
566 GOTO(out_unmap, rc = -ENOMEM);
568 bulk->bp_buf = (void *)(unsigned long)local[j].addr;
569 bulk->bp_buflen = local[j].len;
570 bulk->bp_xid = remote->xid;
571 bulk->bp_page = pga[j].pg;
574 if (desc->bd_page_count != page_count)
577 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_BRW_WRITE_BULK))
578 GOTO(out_unmap, rc = 0);
580 /* Our reference is released when brw_finish is complete. */
581 rc = ptlrpc_send_bulk(desc);
583 /* XXX: Mike, same question as in osc_brw_read. */
587 /* Callbacks cause asynchronous handling. */
588 rc = callback(data, 0, CB_PHASE_START);
591 ptlrpc_req_finished(request);
594 /* Clean up on error. */
597 kunmap(pga[mapped].pg);
599 OBD_FREE(local, page_count * sizeof(*local));
601 OBD_FREE(cb_data, sizeof(*cb_data));
603 ptlrpc_bulk_decref(desc);
607 static int osc_brw(int cmd, struct lustre_handle *conn,
608 struct lov_stripe_md *md, obd_count page_count,
609 struct brw_page *pga, brw_callback_t callback,
610 struct io_cb_data *data)
612 if (cmd & OBD_BRW_WRITE)
613 return osc_brw_write(conn, md, page_count, pga, callback, data);
615 return osc_brw_read(conn, md, page_count, pga, callback, data);
618 static int osc_enqueue(struct lustre_handle *connh, struct lov_stripe_md *lsm,
619 struct lustre_handle *parent_lock,
620 __u32 type, void *extentp, int extent_len, __u32 mode,
621 int *flags, void *callback, void *data, int datalen,
622 struct lustre_handle *lockh)
624 __u64 res_id[RES_NAME_SIZE] = { lsm->lsm_object_id };
625 struct obd_device *obddev = class_conn2obd(connh);
626 struct ldlm_extent *extent = extentp;
630 /* Filesystem locks are given a bit of special treatment: if
631 * this is not a file size lock (which has end == -1), we
632 * fixup the lock to start and end on page boundaries. */
633 if (extent->end != OBD_OBJECT_EOF) {
634 extent->start &= PAGE_MASK;
635 extent->end = (extent->end + PAGE_SIZE - 1) & PAGE_MASK;
638 /* Next, search for already existing extent locks that will cover us */
639 rc = ldlm_lock_match(obddev->obd_namespace, res_id, type, extent,
640 sizeof(extent), mode, lockh);
642 RETURN(0); /* We already have a lock, and it's referenced */
644 /* If we're trying to read, we also search for an existing PW lock. The
645 * VFS and page cache already protect us locally, so lots of readers/
646 * writers can share a single PW lock.
648 * There are problems with conversion deadlocks, so instead of
649 * converting a read lock to a write lock, we'll just enqueue a new
652 * At some point we should cancel the read lock instead of making them
653 * send us a blocking callback, but there are problems with canceling
654 * locks out from other users right now, too. */
656 if (mode == LCK_PR) {
657 rc = ldlm_lock_match(obddev->obd_namespace, res_id, type,
658 extent, sizeof(extent), LCK_PW, lockh);
660 /* FIXME: This is not incredibly elegant, but it might
661 * be more elegant than adding another parameter to
662 * lock_match. I want a second opinion. */
663 ldlm_lock_addref(lockh, LCK_PR);
664 ldlm_lock_decref(lockh, LCK_PW);
670 rc = ldlm_cli_enqueue(connh, NULL, obddev->obd_namespace, parent_lock,
671 res_id, type, extent, sizeof(extent), mode, flags,
672 ldlm_completion_ast, callback, data, datalen,
677 static int osc_cancel(struct lustre_handle *oconn, struct lov_stripe_md *md,
678 __u32 mode, struct lustre_handle *lockh)
682 ldlm_lock_decref(lockh, mode);
687 static int osc_cancel_unused(struct lustre_handle *connh,
688 struct lov_stripe_md *lsm, int local)
690 struct obd_device *obddev = class_conn2obd(connh);
691 __u64 res_id[RES_NAME_SIZE] = { lsm->lsm_object_id };
693 return ldlm_cli_cancel_unused(obddev->obd_namespace, res_id, local);
696 static int osc_statfs(struct lustre_handle *conn, struct obd_statfs *osfs)
698 struct ptlrpc_request *request;
699 int rc, size = sizeof(*osfs);
702 request = ptlrpc_prep_req(class_conn2cliimp(conn), OST_STATFS, 0, NULL,
707 request->rq_replen = lustre_msg_size(1, &size);
709 rc = ptlrpc_queue_wait(request);
710 rc = ptlrpc_check_status(request, rc);
712 CERROR("%s failed: rc = %d\n", __FUNCTION__, rc);
716 obd_statfs_unpack(osfs, lustre_msg_buf(request->rq_repmsg, 0));
720 ptlrpc_req_finished(request);
724 static int osc_iocontrol(long cmd, struct lustre_handle *conn, int len,
725 void *karg, void *uarg)
727 struct obd_device *obddev = class_conn2obd(conn);
728 struct obd_ioctl_data *data = karg;
733 case IOC_LDLM_TEST: {
734 err = ldlm_test(obddev, conn);
735 CERROR("-- done err %d\n", err);
738 case IOC_LDLM_REGRESS_START: {
739 unsigned int numthreads = 1;
740 unsigned int numheld = 10;
741 unsigned int numres = 10;
742 unsigned int numext = 10;
745 if (data->ioc_inllen1) {
746 parse = data->ioc_inlbuf1;
747 if (*parse != '\0') {
748 while(isspace(*parse)) parse++;
749 numthreads = simple_strtoul(parse, &parse, 0);
750 while(isspace(*parse)) parse++;
752 if (*parse != '\0') {
753 while(isspace(*parse)) parse++;
754 numheld = simple_strtoul(parse, &parse, 0);
755 while(isspace(*parse)) parse++;
757 if (*parse != '\0') {
758 while(isspace(*parse)) parse++;
759 numres = simple_strtoul(parse, &parse, 0);
760 while(isspace(*parse)) parse++;
762 if (*parse != '\0') {
763 while(isspace(*parse)) parse++;
764 numext = simple_strtoul(parse, &parse, 0);
765 while(isspace(*parse)) parse++;
769 err = ldlm_regression_start(obddev, conn, numthreads,
770 numheld, numres, numext);
772 CERROR("-- done err %d\n", err);
775 case IOC_LDLM_REGRESS_STOP: {
776 err = ldlm_regression_stop();
777 CERROR("-- done err %d\n", err);
780 case IOC_OSC_REGISTER_LOV: {
781 if (obddev->u.cli.cl_containing_lov)
782 GOTO(out, err = -EALREADY);
783 obddev->u.cli.cl_containing_lov = (struct obd_device *)karg;
788 GOTO(out, err = -ENOTTY);
794 struct obd_ops osc_obd_ops = {
795 o_setup: client_obd_setup,
796 o_cleanup: client_obd_cleanup,
797 o_statfs: osc_statfs,
798 o_create: osc_create,
799 o_destroy: osc_destroy,
800 o_getattr: osc_getattr,
801 o_setattr: osc_setattr,
804 o_connect: client_obd_connect,
805 o_disconnect: client_obd_disconnect,
808 o_enqueue: osc_enqueue,
809 o_cancel: osc_cancel,
810 o_cancel_unused: osc_cancel_unused,
811 o_iocontrol: osc_iocontrol
814 static int __init osc_init(void)
816 return class_register_type(&osc_obd_ops, LUSTRE_OSC_NAME);
819 static void __exit osc_exit(void)
821 class_unregister_type(LUSTRE_OSC_NAME);
824 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
825 MODULE_DESCRIPTION("Lustre Object Storage Client (OSC) v1.0");
826 MODULE_LICENSE("GPL");
828 module_init(osc_init);
829 module_exit(osc_exit);