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 file is part of Lustre, http://www.sf.net/projects/lustre/
8 * Lustre is free software; you can redistribute it and/or
9 * modify it under the terms of version 2 of the GNU General Public
10 * License as published by the Free Software Foundation.
12 * Lustre is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Lustre; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define DEBUG_SUBSYSTEM S_MDC
26 #include <linux/module.h>
27 #include <linux/miscdevice.h>
28 #include <linux/lustre_mds.h>
29 #include <linux/lustre_lite.h>
30 #include <linux/lustre_dlm.h>
32 #define REQUEST_MINOR 244
34 extern int mds_queue_req(struct ptlrpc_request *);
36 int mdc_con2cl(struct lustre_handle *conn, struct ptlrpc_client **cl,
37 struct ptlrpc_connection **connection,
38 struct lustre_handle **rconn)
40 struct obd_export *export;
43 export = class_conn2export(conn);
47 mdc = &export->export_obd->u.mdc;
49 *cl = mdc->mdc_client;
50 *connection = mdc->mdc_conn;
51 *rconn = &export->export_import;
56 static int mdc_con2dlmcl(struct lustre_handle *conn, struct ptlrpc_client **cl,
57 struct ptlrpc_connection **connection,
58 struct lustre_handle **rconn)
60 struct obd_export *export;
63 export = class_conn2export(conn);
67 mdc = &export->export_obd->u.mdc;
69 *cl = mdc->mdc_ldlm_client;
70 *connection = mdc->mdc_conn;
71 *rconn = &export->export_import;
77 int mdc_getstatus(struct lustre_handle *conn, struct ll_fid *rootfid,
78 __u64 *last_committed, __u64 *last_rcvd,
79 __u32 *last_xid, struct ptlrpc_request **request)
81 struct ptlrpc_request *req;
82 struct mds_body *body;
83 struct ptlrpc_client *cl;
84 struct ptlrpc_connection *connection;
85 struct lustre_handle *rconn;
86 int rc, size = sizeof(*body);
89 mdc_con2cl(conn, &cl, &connection, &rconn);
90 req = ptlrpc_prep_req2(cl, connection, rconn,
91 MDS_GETSTATUS, 1, &size, NULL);
93 GOTO(out, rc = -ENOMEM);
95 body = lustre_msg_buf(req->rq_reqmsg, 0);
96 req->rq_level = LUSTRE_CONN_CON;
97 req->rq_replen = lustre_msg_size(1, &size);
99 mds_pack_req_body(req);
100 rc = ptlrpc_queue_wait(req);
101 rc = ptlrpc_check_status(req, rc);
104 body = lustre_msg_buf(req->rq_repmsg, 0);
105 mds_unpack_body(body);
106 memcpy(rootfid, &body->fid1, sizeof(*rootfid));
107 *last_committed = req->rq_repmsg->last_committed;
108 *last_rcvd = req->rq_repmsg->last_rcvd;
109 *last_xid = body->last_xid;
111 CDEBUG(D_NET, "root ino=%ld, last_committed=%Lu, last_rcvd=%Lu,"
113 (unsigned long)rootfid->id,
114 (unsigned long long)*last_committed,
115 (unsigned long long)*last_rcvd,
121 ptlrpc_free_req(req);
126 int mdc_getattr(struct lustre_handle *conn,
127 obd_id ino, int type, unsigned long valid, size_t ea_size,
128 struct ptlrpc_request **request)
130 struct ptlrpc_client *cl;
131 struct ptlrpc_connection *connection;
132 struct lustre_handle *rconn;
133 struct ptlrpc_request *req;
134 struct mds_body *body;
135 int rc, size[2] = {sizeof(*body), 0}, bufcount = 1;
138 mdc_con2cl(conn, &cl, &connection, &rconn);
139 req = ptlrpc_prep_req2(cl, connection, rconn,
140 MDS_GETATTR, 1, size, NULL);
142 GOTO(out, rc = -ENOMEM);
144 body = lustre_msg_buf(req->rq_reqmsg, 0);
145 ll_ino2fid(&body->fid1, ino, 0, type);
149 struct mdc_obd *mdc = &class_conn2obd(conn)->u.mdc;
151 size[1] = mdc->mdc_max_mdsize;
152 } else if (valid & OBD_MD_LINKNAME) {
156 req->rq_replen = lustre_msg_size(bufcount, size);
158 rc = ptlrpc_queue_wait(req);
159 rc = ptlrpc_check_status(req, rc);
162 body = lustre_msg_buf(req->rq_repmsg, 0);
163 mds_unpack_body(body);
164 CDEBUG(D_NET, "mode: %o\n", body->mode);
173 static int mdc_lock_callback(struct lustre_handle *lockh,
174 struct ldlm_lock_desc *desc, void *data,
175 int data_len, struct ptlrpc_request **req)
178 struct inode *inode = data;
182 /* Completion AST. Do nothing. */
186 if (data_len != sizeof(*inode)) {
187 CERROR("data_len should be %d, but is %d\n", sizeof(*inode),
192 /* FIXME: do something better than throwing away everything */
195 if (S_ISDIR(inode->i_mode)) {
196 CDEBUG(D_INODE, "invalidating inode %ld\n", inode->i_ino);
197 invalidate_inode_pages(inode);
200 rc = ldlm_cli_cancel(lockh);
202 CERROR("ldlm_cli_cancel: %d\n", rc);
208 int mdc_enqueue(struct lustre_handle *conn, int lock_type,
209 struct lookup_intent *it, int lock_mode, struct inode *dir,
210 struct dentry *de, struct lustre_handle *lockh, __u64 id,
211 char *tgt, int tgtlen, void *data, int datalen)
213 struct ptlrpc_request *req;
214 struct obd_device *obddev = class_conn2obd(conn);
215 struct ptlrpc_client *cl;
216 struct ptlrpc_connection *connection;
217 struct lustre_handle *rconn;
218 __u64 res_id[RES_NAME_SIZE] = {dir->i_ino};
219 int size[5] = {sizeof(struct ldlm_request), sizeof(struct ldlm_intent)};
221 int repsize[3] = {sizeof(struct ldlm_reply),
222 sizeof(struct mds_body),
223 obddev->u.mdc.mdc_max_mdsize};
224 struct ldlm_reply *dlm_rep;
225 struct ldlm_intent *lit;
228 LDLM_DEBUG_NOLOCK("mdsintent %d dir %ld", it->it_op, dir->i_ino);
232 it->it_mode = (it->it_mode | S_IFDIR) & ~current->fs->umask;
234 case (IT_CREAT|IT_OPEN):
237 it->it_mode = (it->it_mode | S_IFREG) & ~current->fs->umask;
240 it->it_mode = (it->it_mode | S_IFLNK) & ~current->fs->umask;
244 mdc_con2dlmcl(conn, &cl, &connection, &rconn);
245 if (it->it_op & (IT_MKDIR | IT_CREAT | IT_SYMLINK | IT_MKNOD)) {
246 size[2] = sizeof(struct mds_rec_create);
247 size[3] = de->d_name.len + 1;
248 size[4] = tgtlen + 1;
249 req = ptlrpc_prep_req2(cl, connection, rconn,
250 LDLM_ENQUEUE, 5, size, NULL);
254 /* pack the intent */
255 lit = lustre_msg_buf(req->rq_reqmsg, 1);
256 lit->opc = NTOH__u64((__u64)it->it_op);
258 /* pack the intended request */
259 mds_create_pack(req, 2, dir, it->it_mode, id, current->fsuid,
260 current->fsgid, CURRENT_TIME, de->d_name.name,
261 de->d_name.len, tgt, tgtlen);
262 req->rq_replen = lustre_msg_size(3, repsize);
263 } else if (it->it_op == IT_RENAME2) {
264 struct dentry *old_de = it->it_data;
266 size[2] = sizeof(struct mds_rec_rename);
267 size[3] = old_de->d_name.len + 1;
268 size[4] = de->d_name.len + 1;
269 req = ptlrpc_prep_req2(cl, connection, rconn,
270 LDLM_ENQUEUE, 5, size, NULL);
274 /* pack the intent */
275 lit = lustre_msg_buf(req->rq_reqmsg, 1);
276 lit->opc = NTOH__u64((__u64)it->it_op);
278 /* pack the intended request */
279 mds_rename_pack(req, 2, old_de->d_parent->d_inode, dir,
280 old_de->d_name.name, old_de->d_name.len,
281 de->d_name.name, de->d_name.len);
282 req->rq_replen = lustre_msg_size(1, repsize);
283 } else if (it->it_op == IT_UNLINK || it->it_op == IT_RMDIR) {
284 size[2] = sizeof(struct mds_rec_unlink);
285 size[3] = de->d_name.len + 1;
286 req = ptlrpc_prep_req2(cl, connection, rconn,
287 LDLM_ENQUEUE, 4, size, NULL);
291 /* pack the intent */
292 lit = lustre_msg_buf(req->rq_reqmsg, 1);
293 lit->opc = NTOH__u64((__u64)it->it_op);
295 /* pack the intended request */
296 mds_unlink_pack(req, 2, dir, NULL, de->d_name.name,
299 req->rq_replen = lustre_msg_size(3, repsize);
300 } else if (it->it_op == IT_GETATTR || it->it_op == IT_RENAME ||
301 it->it_op == IT_OPEN || it->it_op == IT_SETATTR ||
302 it->it_op == IT_LOOKUP) {
303 size[2] = sizeof(struct mds_body);
304 size[3] = de->d_name.len + 1;
306 req = ptlrpc_prep_req2(cl, connection, rconn,
307 LDLM_ENQUEUE, 4, size, NULL);
311 /* pack the intent */
312 lit = lustre_msg_buf(req->rq_reqmsg, 1);
313 lit->opc = NTOH__u64((__u64)it->it_op);
315 /* pack the intended request */
316 mds_getattr_pack(req, 2, dir, de->d_name.name, de->d_name.len);
318 /* get ready for the reply */
319 req->rq_replen = lustre_msg_size(3, repsize);
320 } else if (it->it_op == IT_READDIR) {
321 req = ptlrpc_prep_req2(cl, connection, rconn,
322 LDLM_ENQUEUE, 1, size, NULL);
326 /* get ready for the reply */
327 req->rq_replen = lustre_msg_size(1, repsize);
332 #warning FIXME: the data here needs to be different if a lock was granted for a different inode
333 rc = ldlm_cli_enqueue(cl, connection, NULL, req,
334 obddev->obd_namespace, NULL, res_id, lock_type,
335 NULL, 0, lock_mode, &flags,
336 (void *)mdc_lock_callback, data, datalen, lockh);
337 if (rc == -ENOENT || rc == ELDLM_LOCK_ABORTED) {
339 memset(lockh, 0, sizeof(*lockh));
340 } else if (rc != 0) {
341 CERROR("ldlm_cli_enqueue: %d\n", rc);
345 dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
346 it->it_disposition = (int) dlm_rep->lock_policy_res1;
347 it->it_status = (int) dlm_rep->lock_policy_res2;
348 it->it_lock_mode = lock_mode;
354 int mdc_open(struct lustre_handle *conn, obd_id ino, int type, int flags,
355 struct lov_stripe_md *smd, __u64 cookie, __u64 *fh,
356 struct ptlrpc_request **request)
358 struct ptlrpc_client *cl;
359 struct ptlrpc_connection *connection;
360 struct lustre_handle *rconn;
361 struct mds_body *body;
362 int rc, size[2] = {sizeof(*body)}, bufcount = 1;
363 struct ptlrpc_request *req;
368 size[1] = smd->lmd_size;
371 mdc_con2cl(conn, &cl, &connection, &rconn);
372 req = ptlrpc_prep_req2(cl, connection, rconn,
373 MDS_OPEN, bufcount, size, NULL);
375 GOTO(out, rc = -ENOMEM);
377 req->rq_flags |= PTL_RPC_FL_REPLAY;
378 body = lustre_msg_buf(req->rq_reqmsg, 0);
380 ll_ino2fid(&body->fid1, ino, 0, type);
381 body->flags = HTON__u32(flags);
382 body->extra = cookie;
385 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), smd, smd->lmd_size);
387 req->rq_replen = lustre_msg_size(1, size);
389 rc = ptlrpc_queue_wait(req);
390 rc = ptlrpc_check_status(req, rc);
392 body = lustre_msg_buf(req->rq_repmsg, 0);
393 mds_unpack_body(body);
403 int mdc_close(struct lustre_handle *conn,
404 obd_id ino, int type, __u64 fh, struct ptlrpc_request **request)
406 struct ptlrpc_client *cl;
407 struct ptlrpc_connection *connection;
408 struct lustre_handle *rconn;
409 struct mds_body *body;
410 int rc, size = sizeof(*body);
411 struct ptlrpc_request *req;
413 mdc_con2cl(conn, &cl, &connection, &rconn);
414 req = ptlrpc_prep_req2(cl, connection, rconn,
415 MDS_CLOSE, 1, &size, NULL);
417 GOTO(out, rc = -ENOMEM);
419 body = lustre_msg_buf(req->rq_reqmsg, 0);
420 ll_ino2fid(&body->fid1, ino, 0, type);
423 req->rq_replen = lustre_msg_size(0, NULL);
425 rc = ptlrpc_queue_wait(req);
426 rc = ptlrpc_check_status(req, rc);
434 int mdc_readpage(struct lustre_handle *conn, obd_id ino, int type, __u64 offset,
435 char *addr, struct ptlrpc_request **request)
437 struct ptlrpc_client *cl;
438 struct ptlrpc_connection *connection;
439 struct lustre_handle *rconn;
440 struct ptlrpc_request *req = NULL;
441 struct ptlrpc_bulk_desc *desc = NULL;
442 struct ptlrpc_bulk_page *bulk = NULL;
443 struct mds_body *body;
444 int rc, size = sizeof(*body);
447 CDEBUG(D_INODE, "inode: %ld\n", (long)ino);
449 mdc_con2cl(conn, &cl, &connection, &rconn);
450 desc = ptlrpc_prep_bulk(connection);
452 GOTO(out, rc = -ENOMEM);
454 req = ptlrpc_prep_req2(cl, connection, rconn,
455 MDS_READPAGE, 1, &size, NULL);
457 GOTO(out2, rc = -ENOMEM);
459 bulk = ptlrpc_prep_bulk_page(desc);
460 bulk->b_buflen = PAGE_SIZE;
462 bulk->b_xid = req->rq_xid;
463 desc->b_portal = MDS_BULK_PORTAL;
465 rc = ptlrpc_register_bulk(desc);
467 CERROR("couldn't setup bulk sink: error %d.\n", rc);
471 body = lustre_msg_buf(req->rq_reqmsg, 0);
473 body->fid1.f_type = type;
476 req->rq_replen = lustre_msg_size(1, &size);
477 rc = ptlrpc_queue_wait(req);
478 rc = ptlrpc_check_status(req, rc);
480 ptlrpc_abort_bulk(desc);
483 body = lustre_msg_buf(req->rq_repmsg, 0);
484 mds_unpack_body(body);
489 ptlrpc_free_bulk(desc);
495 int mdc_statfs(struct lustre_handle *conn, struct statfs *sfs,
496 struct ptlrpc_request **request)
498 struct ptlrpc_client *cl;
499 struct ptlrpc_connection *connection;
500 struct lustre_handle *rconn;
501 struct obd_statfs *osfs;
502 struct ptlrpc_request *req;
503 int rc, size = sizeof(*osfs);
506 mdc_con2cl(conn, &cl, &connection, &rconn);
507 req = ptlrpc_prep_req2(cl, connection, rconn,
508 MDS_STATFS, 0, NULL, NULL);
510 GOTO(out, rc = -ENOMEM);
511 req->rq_replen = lustre_msg_size(1, &size);
513 rc = ptlrpc_queue_wait(req);
514 rc = ptlrpc_check_status(req, rc);
519 osfs = lustre_msg_buf(req->rq_repmsg, 0);
520 obd_statfs_unpack(osfs, sfs);
529 static int mdc_ioctl(long cmd, struct lustre_handle *conn, int len, void *karg,
533 /* FIXME XXX : This should use the new ioc_data to pass args in */
535 struct ptlrpc_client *cl;
536 struct ptlrpc_connection *connection;
537 struct lustre_handle *rconn;
538 struct ptlrpc_request *request;
542 if (_IOC_TYPE(cmd) != IOC_REQUEST_TYPE ||
543 _IOC_NR(cmd) < IOC_REQUEST_MIN_NR ||
544 _IOC_NR(cmd) > IOC_REQUEST_MAX_NR ) {
545 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
546 _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
550 ptlrpc_init_client(NULL, NULL,
551 MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
553 mdc_con2cl(conn, &cl, &connection, &rconn);
555 case IOC_REQUEST_GETATTR: {
556 CERROR("-- getting attr for ino %lu\n", arg);
557 err = mdc_getattr(&cl, connection, (obd_id)arg, S_IFDIR, ~0, 0,
559 CERROR("-- done err %d\n", err);
564 case IOC_REQUEST_READPAGE: {
566 OBD_ALLOC(buf, PAGE_SIZE);
571 CERROR("-- readpage 0 for ino %lu\n", arg);
572 err = mdc_readpage(&cl, connection, arg, S_IFDIR, 0, buf,
574 CERROR("-- done err %d\n", err);
575 OBD_FREE(buf, PAGE_SIZE);
580 case IOC_REQUEST_SETATTR: {
585 inode.i_generation = 0;
586 iattr.ia_mode = 040777;
588 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
590 err = mdc_setattr(&cl, connection, &inode, &iattr, &request);
591 CERROR("-- done err %d\n", err);
596 case IOC_REQUEST_CREATE: {
601 inode.i_generation = 0;
602 iattr.ia_mode = 040777;
604 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
606 err = mdc_create(&cl, connection, &inode,
607 "foofile", strlen("foofile"),
608 NULL, 0, 0100707, 47114711,
609 11, 47, 0, NULL, &request);
610 CERROR("-- done err %d\n", err);
615 case IOC_REQUEST_OPEN: {
617 copy_from_user(&ino, (__u64 *)arg, sizeof(ino));
618 CERROR("-- opening ino %llu\n", (unsigned long long)ino);
619 err = mdc_open(&cl, connection, ino, S_IFDIR, O_RDONLY, 4711,
621 copy_to_user((__u64 *)arg, &fh, sizeof(fh));
622 CERROR("-- done err %d (fh=%Lu)\n", err,
623 (unsigned long long)fh);
628 case IOC_REQUEST_CLOSE: {
629 CERROR("-- closing ino 2, filehandle %lu\n", arg);
630 err = mdc_close(&cl, connection, 2, S_IFDIR, arg, &request);
631 CERROR("-- done err %d\n", err);
637 GOTO(out, err = -EINVAL);
641 ptlrpc_free_req(request);
642 ptlrpc_put_connection(connection);
643 ptlrpc_cleanup_client(&cl);
650 static int mdc_setup(struct obd_device *obddev, obd_count len, void *buf)
652 struct obd_ioctl_data* data = buf;
653 struct mdc_obd *mdc = &obddev->u.mdc;
654 char server_uuid[37];
658 if (data->ioc_inllen1 < 1) {
659 CERROR("osc setup requires a TARGET UUID\n");
663 if (data->ioc_inllen1 > 37) {
664 CERROR("mdc UUID must be less than 38 characters\n");
668 if (data->ioc_inllen2 < 1) {
669 CERROR("mdc setup requires a SERVER UUID\n");
673 if (data->ioc_inllen2 > 37) {
674 CERROR("mdc UUID must be less than 38 characters\n");
678 memcpy(mdc->mdc_target_uuid, data->ioc_inlbuf1, data->ioc_inllen1);
679 memcpy(server_uuid, data->ioc_inlbuf2, MIN(data->ioc_inllen2,
680 sizeof(server_uuid)));
682 mdc->mdc_conn = ptlrpc_uuid_to_connection(server_uuid);
686 OBD_ALLOC(mdc->mdc_client, sizeof(*mdc->mdc_client));
687 if (mdc->mdc_client == NULL)
688 GOTO(out_conn, rc = -ENOMEM);
690 OBD_ALLOC(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
691 if (mdc->mdc_ldlm_client == NULL)
692 GOTO(out_client, rc = -ENOMEM);
694 ptlrpc_init_client(NULL, NULL, MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
696 ptlrpc_init_client(NULL, NULL, LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
697 mdc->mdc_ldlm_client);
698 mdc->mdc_client->cli_name = "mdc";
699 mdc->mdc_ldlm_client->cli_name = "ldlm";
700 mdc->mdc_max_mdsize = sizeof(struct lov_stripe_md);
701 /* XXX get recovery hooked in here again */
702 //ptlrpc_init_client(ptlrpc_connmgr, ll_recover,...
704 ptlrpc_init_client(ptlrpc_connmgr, NULL,
705 MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
712 OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
714 ptlrpc_put_connection(mdc->mdc_conn);
718 static int mdc_cleanup(struct obd_device * obddev)
720 struct mdc_obd *mdc = &obddev->u.mdc;
722 ptlrpc_cleanup_client(mdc->mdc_client);
723 OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
724 ptlrpc_cleanup_client(mdc->mdc_ldlm_client);
725 OBD_FREE(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
726 ptlrpc_put_connection(mdc->mdc_conn);
732 static int mdc_connect(struct lustre_handle *conn, struct obd_device *obd)
734 struct mdc_obd *mdc = &obd->u.mdc;
735 struct ptlrpc_request *request;
736 int rc, size = sizeof(mdc->mdc_target_uuid);
737 char *tmp = mdc->mdc_target_uuid;
742 ldlm_namespace_new("mdc", LDLM_NAMESPACE_CLIENT);
743 if (obd->obd_namespace == NULL)
747 rc = class_connect(conn, obd);
751 request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
752 MDS_CONNECT, 1, &size, &tmp);
754 GOTO(out_disco, -ENOMEM);
756 request->rq_level = LUSTRE_CONN_NEW;
757 request->rq_replen = lustre_msg_size(0, NULL);
758 /* Sending our local connection info breaks for local connections
759 request->rq_reqmsg->addr = conn->addr;
760 request->rq_reqmsg->cookie = conn->cookie;
763 rc = ptlrpc_queue_wait(request);
764 rc = ptlrpc_check_status(request, rc);
768 class_import2export(conn, (struct lustre_handle *)request->rq_repmsg);
772 ptlrpc_free_req(request);
775 class_disconnect(conn);
781 static int mdc_disconnect(struct lustre_handle *conn)
783 struct ptlrpc_client *cl;
784 struct ptlrpc_connection *connection;
785 struct lustre_handle *rconn;
786 struct obd_device *obd = class_conn2obd(conn);
787 struct ptlrpc_request *request;
791 ldlm_namespace_free(obd->obd_namespace);
792 mdc_con2cl(conn, &cl, &connection, &rconn);
793 request = ptlrpc_prep_req2(cl, connection, rconn,
794 MDS_DISCONNECT, 0, NULL, NULL);
798 request->rq_replen = lustre_msg_size(0, NULL);
800 rc = ptlrpc_queue_wait(request);
803 rc = class_disconnect(conn);
807 ptlrpc_free_req(request);
811 struct obd_ops mdc_obd_ops = {
813 o_cleanup: mdc_cleanup,
814 o_connect: mdc_connect,
815 o_disconnect: mdc_disconnect,
816 o_iocontrol: mdc_ioctl
819 static int __init ptlrpc_request_init(void)
821 return class_register_type(&mdc_obd_ops, LUSTRE_MDC_NAME);
824 static void __exit ptlrpc_request_exit(void)
826 class_unregister_type(LUSTRE_MDC_NAME);
829 MODULE_AUTHOR("Cluster File Systems <info@clusterfs.com>");
830 MODULE_DESCRIPTION("Lustre Metadata Client v1.0");
831 MODULE_LICENSE("GPL");
833 EXPORT_SYMBOL(mdc_getstatus);
834 EXPORT_SYMBOL(mdc_enqueue);
835 EXPORT_SYMBOL(mdc_getattr);
836 EXPORT_SYMBOL(mdc_statfs);
837 EXPORT_SYMBOL(mdc_create);
838 EXPORT_SYMBOL(mdc_unlink);
839 EXPORT_SYMBOL(mdc_rename);
840 EXPORT_SYMBOL(mdc_link);
841 EXPORT_SYMBOL(mdc_readpage);
842 EXPORT_SYMBOL(mdc_setattr);
843 EXPORT_SYMBOL(mdc_close);
844 EXPORT_SYMBOL(mdc_open);
846 module_init(ptlrpc_request_init);
847 module_exit(ptlrpc_request_exit);