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 *);
37 int mdc_getstatus(struct obd_conn *conn, struct ll_fid *rootfid,
38 __u64 *last_committed, __u64 *last_rcvd,
39 __u32 *last_xid, struct ptlrpc_request **request)
41 struct ptlrpc_request *req;
42 struct mds_body *body;
43 struct mdc_obd *mdc = mdc_conn2mdc(conn);
44 int rc, size = sizeof(*body);
47 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
48 MDS_GETSTATUS, 1, &size, NULL);
50 GOTO(out, rc = -ENOMEM);
52 body = lustre_msg_buf(req->rq_reqmsg, 0);
53 req->rq_level = LUSTRE_CONN_CON;
54 req->rq_replen = lustre_msg_size(1, &size);
56 mds_pack_req_body(req);
57 rc = ptlrpc_queue_wait(req);
58 rc = ptlrpc_check_status(req, rc);
61 body = lustre_msg_buf(req->rq_repmsg, 0);
62 mds_unpack_body(body);
63 memcpy(rootfid, &body->fid1, sizeof(*rootfid));
64 *last_committed = req->rq_repmsg->last_committed;
65 *last_rcvd = req->rq_repmsg->last_rcvd;
66 *last_xid = body->last_xid;
68 CDEBUG(D_NET, "root ino=%ld, last_committed=%Lu, last_rcvd=%Lu,"
70 (unsigned long)rootfid->id,
71 (unsigned long long)*last_committed,
72 (unsigned long long)*last_rcvd,
83 int mdc_getattr(struct obd_conn *conn,
84 ino_t ino, int type, unsigned long valid, size_t ea_size,
85 struct ptlrpc_request **request)
87 struct mdc_obd *mdc = mdc_conn2mdc(conn);
88 struct ptlrpc_request *req;
89 struct mds_body *body;
90 int rc, size[2] = {sizeof(*body), 0}, bufcount = 1;
93 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
94 MDS_GETATTR, 1, size, NULL);
96 GOTO(out, rc = -ENOMEM);
98 body = lustre_msg_buf(req->rq_reqmsg, 0);
99 ll_ino2fid(&body->fid1, ino, 0, type);
104 size[1] = sizeof(struct obdo);
105 } else if (valid & OBD_MD_LINKNAME) {
109 req->rq_replen = lustre_msg_size(bufcount, size);
110 req->rq_level = LUSTRE_CONN_FULL;
112 rc = ptlrpc_queue_wait(req);
113 rc = ptlrpc_check_status(req, rc);
116 body = lustre_msg_buf(req->rq_repmsg, 0);
117 mds_unpack_body(body);
118 CDEBUG(D_NET, "mode: %o\n", body->mode);
127 static int mdc_lock_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
128 void *data, int data_len,
129 struct ptlrpc_request **req)
132 struct inode *inode = data;
136 /* Completion AST. Do nothing. */
140 if (data_len != sizeof(*inode)) {
141 CERROR("data_len should be %d, but is %d\n", sizeof(*inode),
146 /* FIXME: do something better than throwing away everything */
149 if (S_ISDIR(inode->i_mode)) {
150 CDEBUG(D_INODE, "invalidating inode %ld\n", inode->i_ino);
151 invalidate_inode_pages(inode);
154 rc = ldlm_cli_cancel(lock->l_client, lock);
156 CERROR("ldlm_cli_cancel: %d\n", rc);
162 int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
163 int lock_mode, struct inode *dir, struct dentry *de,
164 struct lustre_handle *lockh, __u64 id, char *tgt, int tgtlen,
165 void *data, int datalen)
167 struct ptlrpc_request *req;
168 struct obd_device *obddev = conn->oc_dev;
169 struct mdc_obd *mdc = mdc_conn2mdc(conn);
170 __u64 res_id[RES_NAME_SIZE] = {dir->i_ino};
171 int size[5] = {sizeof(struct ldlm_request), sizeof(struct ldlm_intent)};
173 struct ldlm_reply *dlm_rep;
174 struct ldlm_intent *lit;
177 #warning FIXME: Andreas, the sgid directory stuff also goes here, but check again on mds
179 LDLM_DEBUG_NOLOCK("mdsintent %d dir %ld", it->it_op, dir->i_ino);
183 it->it_mode = (it->it_mode | S_IFDIR) & ~current->fs->umask;
186 it->it_op = IT_GETATTR;
188 case (IT_CREAT|IT_OPEN):
191 it->it_mode = (it->it_mode | S_IFREG) & ~current->fs->umask;
194 it->it_mode = (it->it_mode | S_IFLNK) & ~current->fs->umask;
198 if (it->it_op & (IT_MKDIR | IT_CREAT | IT_SYMLINK | IT_MKNOD)) {
199 size[2] = sizeof(struct mds_rec_create);
200 size[3] = de->d_name.len + 1;
201 size[4] = tgtlen + 1;
202 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
203 LDLM_ENQUEUE, 5, size, NULL);
207 /* pack the intent */
208 lit = lustre_msg_buf(req->rq_reqmsg, 1);
209 lit->opc = NTOH__u64((__u64)it->it_op);
211 /* pack the intended request */
212 mds_create_pack(req, 2, dir, it->it_mode, id, current->fsuid,
213 current->fsgid, CURRENT_TIME, de->d_name.name,
214 de->d_name.len, tgt, tgtlen);
216 size[0] = sizeof(struct ldlm_reply);
217 size[1] = sizeof(struct mds_body);
218 size[2] = sizeof(struct obdo);
219 req->rq_replen = lustre_msg_size(3, size);
220 } else if ( it->it_op == IT_RENAME2 ) {
221 struct dentry *old_de = it->it_data;
223 size[2] = sizeof(struct mds_rec_rename);
224 size[3] = old_de->d_name.len + 1;
225 size[4] = de->d_name.len + 1;
226 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
227 LDLM_ENQUEUE, 5, size, NULL);
231 /* pack the intent */
232 lit = lustre_msg_buf(req->rq_reqmsg, 1);
233 lit->opc = NTOH__u64((__u64)it->it_op);
235 /* pack the intended request */
236 mds_rename_pack(req, 2, old_de->d_inode, dir,
237 old_de->d_parent->d_name.name,
238 old_de->d_parent->d_name.len,
239 de->d_name.name, de->d_name.len);
241 size[0] = sizeof(struct ldlm_reply);
242 size[1] = sizeof(struct mds_body);
243 req->rq_replen = lustre_msg_size(2, size);
244 } else if ( it->it_op == IT_UNLINK ) {
245 size[2] = sizeof(struct mds_rec_unlink);
246 size[3] = de->d_name.len + 1;
247 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
248 LDLM_ENQUEUE, 4, size, NULL);
252 /* pack the intent */
253 lit = lustre_msg_buf(req->rq_reqmsg, 1);
254 lit->opc = NTOH__u64((__u64)it->it_op);
256 /* pack the intended request */
257 mds_unlink_pack(req, 2, dir, NULL, de->d_name.name,
259 size[0] = sizeof(struct ldlm_reply);
260 size[1] = sizeof(struct obdo);
261 req->rq_replen = lustre_msg_size(2, size);
262 } else if ( it->it_op == IT_RMDIR ) {
263 size[2] = sizeof(struct mds_rec_unlink);
264 size[3] = de->d_name.len + 1;
265 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
266 LDLM_ENQUEUE, 4, size, NULL);
270 /* pack the intent */
271 lit = lustre_msg_buf(req->rq_reqmsg, 1);
272 lit->opc = NTOH__u64((__u64)it->it_op);
274 /* pack the intended request */
275 mds_unlink_pack(req, 2, dir, NULL, de->d_name.name,
277 size[0] = sizeof(struct ldlm_reply);
278 req->rq_replen = lustre_msg_size(1, size);
279 } else if ( it->it_op == IT_GETATTR || it->it_op == IT_RENAME ||
280 it->it_op == IT_OPEN ) {
281 size[2] = sizeof(struct mds_body);
282 size[3] = de->d_name.len + 1;
284 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
285 LDLM_ENQUEUE, 4, size, NULL);
289 /* pack the intent */
290 lit = lustre_msg_buf(req->rq_reqmsg, 1);
291 lit->opc = NTOH__u64((__u64)it->it_op);
293 /* pack the intended request */
294 mds_getattr_pack(req, 2, dir, de->d_name.name, de->d_name.len);
296 /* get ready for the reply */
297 size[0] = sizeof(struct ldlm_reply);
298 size[1] = sizeof(struct mds_body);
299 size[2] = sizeof(struct obdo);
300 req->rq_replen = lustre_msg_size(3, size);
301 } else if ( it->it_op == IT_SETATTR) {
302 size[2] = sizeof(struct mds_rec_setattr);
303 size[3] = de->d_name.len + 1;
304 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
305 LDLM_ENQUEUE, 5, size, NULL);
309 lit = lustre_msg_buf(req->rq_reqmsg, 1);
310 lit->opc = NTOH__u64((__u64)it->it_op);
315 mds_setattr_pack(req, 2, dir, it->it_iattr,
316 de->d_name.name, de->d_name.len);
317 size[0] = sizeof(struct ldlm_reply);
318 size[1] = sizeof(struct mds_body);
319 req->rq_replen = lustre_msg_size(2, size);
320 } else if ( it->it_op == IT_READDIR ) {
321 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
322 LDLM_ENQUEUE, 1, size, NULL);
326 /* get ready for the reply */
327 size[0] = sizeof(struct ldlm_reply);
328 req->rq_replen = lustre_msg_size(1, size);
333 #warning FIXME: the data here needs to be different if a lock was granted for a different inode
334 rc = ldlm_cli_enqueue(mdc->mdc_ldlm_client, mdc->mdc_conn, req,
335 obddev->obd_namespace, NULL, res_id, lock_type,
336 NULL, 0, lock_mode, &flags,
337 (void *)mdc_lock_callback, data, datalen, lockh);
340 memset(lockh, 0, sizeof(*lockh));
341 } else if (rc != 0) {
342 CERROR("ldlm_cli_enqueue: %d\n", rc);
346 dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
347 it->it_disposition = (int) dlm_rep->lock_policy_res1;
348 it->it_status = (int) dlm_rep->lock_policy_res2;
349 it->it_lock_mode = lock_mode;
355 int mdc_open(struct obd_conn *conn, ino_t ino, int type, int flags,
357 __u64 cookie, __u64 *fh, struct ptlrpc_request **request)
359 struct mdc_obd *mdc = mdc_conn2mdc(conn);
360 struct mds_body *body;
361 int rc, size[2] = {sizeof(*body)}, bufcount = 1;
362 struct ptlrpc_request *req;
367 size[1] = sizeof(*obdo);
370 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
371 MDS_OPEN, bufcount, size, NULL);
373 GOTO(out, rc = -ENOMEM);
375 req->rq_flags |= PTL_RPC_FL_REPLAY;
376 req->rq_level = LUSTRE_CONN_FULL;
377 body = lustre_msg_buf(req->rq_reqmsg, 0);
379 ll_ino2fid(&body->fid1, ino, 0, type);
380 body->flags = HTON__u32(flags);
381 body->extra = cookie;
384 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), obdo, sizeof(*obdo));
386 req->rq_replen = lustre_msg_size(1, size);
388 rc = ptlrpc_queue_wait(req);
389 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 obd_conn *conn,
404 ino_t ino, int type, __u64 fh, struct ptlrpc_request **request)
406 struct mdc_obd *mdc = mdc_conn2mdc(conn);
407 struct mds_body *body;
408 int rc, size = sizeof(*body);
409 struct ptlrpc_request *req;
411 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
412 MDS_CLOSE, 1, &size, NULL);
414 GOTO(out, rc = -ENOMEM);
416 body = lustre_msg_buf(req->rq_reqmsg, 0);
417 ll_ino2fid(&body->fid1, ino, 0, type);
420 req->rq_level = LUSTRE_CONN_FULL;
421 req->rq_replen = lustre_msg_size(0, NULL);
423 rc = ptlrpc_queue_wait(req);
424 rc = ptlrpc_check_status(req, rc);
432 int mdc_readpage(struct obd_conn *conn, ino_t ino, int type, __u64 offset,
433 char *addr, struct ptlrpc_request **request)
435 struct mdc_obd *mdc = mdc_conn2mdc(conn);
436 struct ptlrpc_request *req = NULL;
437 struct ptlrpc_bulk_desc *desc = NULL;
438 struct ptlrpc_bulk_page *bulk = NULL;
439 struct mds_body *body;
440 int rc, size = sizeof(*body);
443 CDEBUG(D_INODE, "inode: %ld\n", (long)ino);
445 desc = ptlrpc_prep_bulk(mdc->mdc_conn);
447 GOTO(out, rc = -ENOMEM);
449 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
450 MDS_READPAGE, 1, &size, NULL);
452 GOTO(out2, rc = -ENOMEM);
454 bulk = ptlrpc_prep_bulk_page(desc);
455 bulk->b_buflen = PAGE_SIZE;
457 bulk->b_xid = req->rq_xid;
458 desc->b_portal = MDS_BULK_PORTAL;
460 rc = ptlrpc_register_bulk(desc);
462 CERROR("couldn't setup bulk sink: error %d.\n", rc);
466 body = lustre_msg_buf(req->rq_reqmsg, 0);
468 body->fid1.f_type = type;
471 req->rq_replen = lustre_msg_size(1, &size);
472 req->rq_level = LUSTRE_CONN_FULL;
473 rc = ptlrpc_queue_wait(req);
474 rc = ptlrpc_check_status(req, rc);
476 ptlrpc_abort_bulk(desc);
479 body = lustre_msg_buf(req->rq_repmsg, 0);
480 mds_unpack_body(body);
485 ptlrpc_free_bulk(desc);
491 int mdc_statfs(struct obd_conn *conn, struct statfs *sfs,
492 struct ptlrpc_request **request)
494 struct mdc_obd *mdc = mdc_conn2mdc(conn);
495 struct obd_statfs *osfs;
496 struct ptlrpc_request *req;
497 int rc, size = sizeof(*osfs);
500 req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_STATFS,
503 GOTO(out, rc = -ENOMEM);
504 req->rq_replen = lustre_msg_size(1, &size);
505 req->rq_level = LUSTRE_CONN_FULL;
507 rc = ptlrpc_queue_wait(req);
508 rc = ptlrpc_check_status(req, rc);
513 osfs = lustre_msg_buf(req->rq_repmsg, 0);
514 obd_statfs_unpack(osfs, sfs);
523 static int mdc_ioctl(long cmd, struct obd_conn *conn, int len, void *karg,
527 /* FIXME XXX : This should use the new ioc_data to pass args in */
529 struct ptlrpc_client cl;
530 struct ptlrpc_connection *conn;
531 struct ptlrpc_request *request;
535 if (_IOC_TYPE(cmd) != IOC_REQUEST_TYPE ||
536 _IOC_NR(cmd) < IOC_REQUEST_MIN_NR ||
537 _IOC_NR(cmd) > IOC_REQUEST_MAX_NR ) {
538 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
539 _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
543 ptlrpc_init_client(NULL, NULL,
544 MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
545 connection = ptlrpc_uuid_to_connection("mds");
547 CERROR("cannot create client\n");
552 case IOC_REQUEST_GETATTR: {
553 CERROR("-- getting attr for ino %lu\n", arg);
554 err = mdc_getattr(&cl, connection, arg, S_IFDIR, ~0, 0,
556 CERROR("-- done err %d\n", err);
561 case IOC_REQUEST_READPAGE: {
563 OBD_ALLOC(buf, PAGE_SIZE);
568 CERROR("-- readpage 0 for ino %lu\n", arg);
569 err = mdc_readpage(&cl, connection, arg, S_IFDIR, 0, buf,
571 CERROR("-- done err %d\n", err);
572 OBD_FREE(buf, PAGE_SIZE);
577 case IOC_REQUEST_SETATTR: {
582 inode.i_generation = 0;
583 iattr.ia_mode = 040777;
585 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
587 err = mdc_setattr(&cl, connection, &inode, &iattr, &request);
588 CERROR("-- done err %d\n", err);
593 case IOC_REQUEST_CREATE: {
598 inode.i_generation = 0;
599 iattr.ia_mode = 040777;
601 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
603 err = mdc_create(&cl, connection, &inode,
604 "foofile", strlen("foofile"),
605 NULL, 0, 0100707, 47114711,
606 11, 47, 0, NULL, &request);
607 CERROR("-- done err %d\n", err);
612 case IOC_REQUEST_OPEN: {
614 copy_from_user(&ino, (__u64 *)arg, sizeof(ino));
615 CERROR("-- opening ino %llu\n", (unsigned long long)ino);
616 err = mdc_open(&cl, connection, ino, S_IFDIR, O_RDONLY, 4711,
618 copy_to_user((__u64 *)arg, &fh, sizeof(fh));
619 CERROR("-- done err %d (fh=%Lu)\n", err,
620 (unsigned long long)fh);
625 case IOC_REQUEST_CLOSE: {
626 CERROR("-- closing ino 2, filehandle %lu\n", arg);
627 err = mdc_close(&cl, connection, 2, S_IFDIR, arg, &request);
628 CERROR("-- done err %d\n", err);
634 GOTO(out, err = -EINVAL);
638 ptlrpc_free_req(request);
639 ptlrpc_put_connection(connection);
640 ptlrpc_cleanup_client(&cl);
647 static int mdc_setup(struct obd_device *obddev, obd_count len, void *buf)
649 struct obd_ioctl_data* data = buf;
650 struct mdc_obd *mdc = &obddev->u.mdc;
651 char server_uuid[37];
655 if (data->ioc_inllen1 < 1) {
656 CERROR("osc setup requires a TARGET UUID\n");
660 if (data->ioc_inllen1 > 37) {
661 CERROR("mdc UUID must be less than 38 characters\n");
665 if (data->ioc_inllen2 < 1) {
666 CERROR("mdc setup requires a SERVER UUID\n");
670 if (data->ioc_inllen2 > 37) {
671 CERROR("mdc UUID must be less than 38 characters\n");
675 memcpy(mdc->mdc_target_uuid, data->ioc_inlbuf1, data->ioc_inllen1);
676 memcpy(server_uuid, data->ioc_inlbuf2, MIN(data->ioc_inllen2,
677 sizeof(server_uuid)));
679 mdc->mdc_conn = ptlrpc_uuid_to_connection(server_uuid);
683 OBD_ALLOC(mdc->mdc_client, sizeof(*mdc->mdc_client));
684 if (mdc->mdc_client == NULL)
685 GOTO(out_conn, rc = -ENOMEM);
687 OBD_ALLOC(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
688 if (mdc->mdc_ldlm_client == NULL)
689 GOTO(out_client, rc = -ENOMEM);
691 ptlrpc_init_client(NULL, NULL, MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
693 ptlrpc_init_client(NULL, NULL, LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
694 mdc->mdc_ldlm_client);
695 mdc->mdc_client->cli_name = "mdc";
696 mdc->mdc_ldlm_client->cli_name = "ldlm";
697 /* XXX get recovery hooked in here again */
698 //ptlrpc_init_client(ptlrpc_connmgr, ll_recover,...
700 ptlrpc_init_client(ptlrpc_connmgr, NULL,
701 MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
708 OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
710 ptlrpc_put_connection(mdc->mdc_conn);
714 static int mdc_cleanup(struct obd_device * obddev)
716 struct mdc_obd *mdc = &obddev->u.mdc;
718 ptlrpc_cleanup_client(mdc->mdc_client);
719 OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
720 ptlrpc_cleanup_client(mdc->mdc_ldlm_client);
721 OBD_FREE(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
722 ptlrpc_put_connection(mdc->mdc_conn);
728 static int mdc_connect(struct obd_conn *conn)
730 struct mdc_obd *mdc = mdc_conn2mdc(conn);
731 struct ptlrpc_request *request;
732 int rc, size = sizeof(mdc->mdc_target_uuid);
733 char *tmp = mdc->mdc_target_uuid;
737 conn->oc_dev->obd_namespace =
738 ldlm_namespace_new("mdc", LDLM_NAMESPACE_CLIENT);
739 if (conn->oc_dev->obd_namespace == NULL)
742 request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
743 MDS_CONNECT, 1, &size, &tmp);
747 request->rq_replen = lustre_msg_size(0, NULL);
749 rc = ptlrpc_queue_wait(request);
753 mdc->mdc_client->cli_target_devno = request->rq_repmsg->target_id;
754 mdc->mdc_ldlm_client->cli_target_devno =
755 mdc->mdc_client->cli_target_devno;
758 ptlrpc_free_req(request);
762 static int mdc_disconnect(struct obd_conn *conn)
764 struct mdc_obd *mdc = mdc_conn2mdc(conn);
765 struct ptlrpc_request *request;
766 struct mds_body *body;
767 int rc, size = sizeof(*body);
770 ldlm_namespace_free(conn->oc_dev->obd_namespace);
771 request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
772 MDS_DISCONNECT, 1, &size,
777 body = lustre_msg_buf(request->rq_reqmsg, 0);
778 body->valid = conn->oc_id;
780 request->rq_replen = lustre_msg_size(0, NULL);
782 rc = ptlrpc_queue_wait(request);
785 ptlrpc_free_req(request);
789 struct obd_ops mdc_obd_ops = {
791 o_cleanup: mdc_cleanup,
792 o_connect: mdc_connect,
793 o_disconnect: mdc_disconnect,
794 o_iocontrol: mdc_ioctl
797 static int __init ptlrpc_request_init(void)
799 return obd_register_type(&mdc_obd_ops, LUSTRE_MDC_NAME);
802 static void __exit ptlrpc_request_exit(void)
804 obd_unregister_type(LUSTRE_MDC_NAME);
807 MODULE_AUTHOR("Cluster File Systems <info@clusterfs.com>");
808 MODULE_DESCRIPTION("Lustre Metadata Client v1.0");
809 MODULE_LICENSE("GPL");
811 EXPORT_SYMBOL(mdc_getstatus);
812 EXPORT_SYMBOL(mdc_enqueue);
813 EXPORT_SYMBOL(mdc_getattr);
814 EXPORT_SYMBOL(mdc_statfs);
815 EXPORT_SYMBOL(mdc_create);
816 EXPORT_SYMBOL(mdc_unlink);
817 EXPORT_SYMBOL(mdc_rename);
818 EXPORT_SYMBOL(mdc_link);
819 EXPORT_SYMBOL(mdc_readpage);
820 EXPORT_SYMBOL(mdc_setattr);
821 EXPORT_SYMBOL(mdc_close);
822 EXPORT_SYMBOL(mdc_open);
824 module_init(ptlrpc_request_init);
825 module_exit(ptlrpc_request_exit);