lustre/mdc/mdc_request.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.sf.net/projects/lustre/
   7  *
   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.
  11  *
  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.
  16  *
  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.
  20  *
  21  */
  22
  23 #define EXPORT_SYMTAB
  24 #define DEBUG_SUBSYSTEM S_MDC
  25
  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>
  31
  32 #define REQUEST_MINOR 244
  33
  34 extern int mds_queue_req(struct ptlrpc_request *);
  35
  36
  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)
  40 {
  41         struct ptlrpc_request *req;
  42         struct mds_body *body;
  43         struct mdc_obd *mdc = mdc_conn2mdc(conn);
  44         int rc, size = sizeof(*body);
  45         ENTRY;
  46
  47         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
  48                               MDS_GETSTATUS, 1, &size, NULL);
  49         if (!req)
  50                 GOTO(out, rc = -ENOMEM);
  51
  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);
  55
  56         mds_pack_req_body(req);
  57         rc = ptlrpc_queue_wait(req);
  58         rc = ptlrpc_check_status(req, rc);
  59
  60         if (!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;
  67
  68                 CDEBUG(D_NET, "root ino=%ld, last_committed=%Lu, last_rcvd=%Lu,"
  69                        " last_xid=%d\n",
  70                        (unsigned long)rootfid->id,
  71                        (unsigned long long)*last_committed,
  72                        (unsigned long long)*last_rcvd,
  73                        body->last_xid);
  74         }
  75
  76         EXIT;
  77  out:
  78         ptlrpc_free_req(req);
  79         return rc;
  80 }
  81
  82
  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)
  86 {
  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;
  91         ENTRY;
  92
  93         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
  94                               MDS_GETATTR, 1, size, NULL);
  95         if (!req)
  96                 GOTO(out, rc = -ENOMEM);
  97
  98         body = lustre_msg_buf(req->rq_reqmsg, 0);
  99         ll_ino2fid(&body->fid1, ino, 0, type);
 100         body->valid = valid;
 101
 102         if (S_ISREG(type)) {
 103                 bufcount = 2;
 104                 size[1] = sizeof(struct obdo);
 105         } else if (valid & OBD_MD_LINKNAME) {
 106                 bufcount = 2;
 107                 size[1] = ea_size;
 108         }
 109         req->rq_replen = lustre_msg_size(bufcount, size);
 110         req->rq_level = LUSTRE_CONN_FULL;
 111
 112         rc = ptlrpc_queue_wait(req);
 113         rc = ptlrpc_check_status(req, rc);
 114
 115         if (!rc) {
 116                 body = lustre_msg_buf(req->rq_repmsg, 0);
 117                 mds_unpack_body(body);
 118                 CDEBUG(D_NET, "mode: %o\n", body->mode);
 119         }
 120
 121         EXIT;
 122  out:
 123         *request = req;
 124         return rc;
 125 }
 126
 127 static int mdc_lock_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
 128                              void *data, int data_len)
 129 {
 130         int rc;
 131         struct inode *inode = data;
 132         ENTRY;
 133
 134         if (new == NULL) {
 135                 /* Completion AST.  Do nothing. */
 136                 RETURN(0);
 137         }
 138
 139         if (data_len != sizeof(*inode)) {
 140                 CERROR("data_len should be %d, but is %d\n", sizeof(*inode),
 141                        data_len);
 142                 LBUG();
 143         }
 144
 145         /* FIXME: do something better than throwing away everything */
 146         if (inode == NULL)
 147                 LBUG();
 148         invalidate_inode_pages(inode);
 149
 150         rc = ldlm_cli_cancel(lock->l_client, lock);
 151         if (rc < 0) {
 152                 CERROR("ldlm_cli_cancel: %d\n", rc);
 153                 LBUG();
 154         }
 155         RETURN(0);
 156 }
 157
 158 int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
 159                 int lock_mode, struct inode *dir, struct dentry *de,
 160                 struct lustre_handle *lockh, __u64 id, char *tgt, int tgtlen,
 161                 void *data, int datalen)
 162 {
 163         struct ptlrpc_request *req;
 164         struct obd_device *obddev = conn->oc_dev;
 165         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 166         __u64 res_id[RES_NAME_SIZE] = {dir->i_ino};
 167         int size[5] = {sizeof(struct ldlm_request), sizeof(struct ldlm_intent)};
 168         int rc, flags;
 169         struct ldlm_reply *dlm_rep;
 170         struct ldlm_intent *lit;
 171         ENTRY;
 172
 173         switch (it->it_op) {
 174         case IT_MKDIR:
 175                 it->it_mode = (it->it_mode | S_IFDIR) & ~current->fs->umask;
 176                 break;
 177         case IT_SETATTR:
 178                 it->it_op = IT_GETATTR;
 179                 break;
 180         case (IT_CREAT|IT_OPEN):
 181         case IT_CREAT:
 182                 it->it_mode = (it->it_mode | S_IFREG) & ~current->fs->umask;
 183                 break;
 184         case IT_SYMLINK:
 185                 it->it_mode = (it->it_mode | S_IFLNK) & ~current->fs->umask;
 186                 break;
 187         }
 188
 189         if (it->it_op & (IT_MKDIR | IT_CREAT | IT_SYMLINK | IT_MKNOD)) {
 190                 size[2] = sizeof(struct mds_rec_create);
 191                 size[3] = de->d_name.len + 1;
 192                 size[4] = tgtlen + 1;
 193                 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
 194                                       LDLM_ENQUEUE, 5, size, NULL);
 195                 if (!req)
 196                         RETURN(-ENOMEM);
 197
 198                 /* pack the intent */
 199                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 200                 lit->opc = NTOH__u64((__u64)it->it_op);
 201
 202                 /* pack the intended request */
 203                 mds_create_pack(req, 2, dir, it->it_mode, id, current->fsuid,
 204                                 current->fsgid, CURRENT_TIME,  de->d_name.name,
 205                                 de->d_name.len, tgt, tgtlen);
 206
 207                 size[0] = sizeof(struct ldlm_reply);
 208                 size[1] = sizeof(struct mds_body);
 209                 size[2] = sizeof(struct obdo);
 210                 req->rq_replen = lustre_msg_size(3, size);
 211         } else if ( it->it_op == IT_RENAME2 ) {
 212                 struct dentry *old_de = it->it_data;
 213
 214                 size[2] = sizeof(struct mds_rec_rename);
 215                 size[3] = old_de->d_name.len + 1;
 216                 size[4] = de->d_name.len + 1;
 217                 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
 218                                       LDLM_ENQUEUE, 5, size, NULL);
 219                 if (!req)
 220                         RETURN(-ENOMEM);
 221
 222                 /* pack the intent */
 223                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 224                 lit->opc = NTOH__u64((__u64)it->it_op);
 225
 226                 /* pack the intended request */
 227                 mds_rename_pack(req, 2, old_de->d_inode, dir,
 228                                 old_de->d_parent->d_name.name,
 229                                 old_de->d_parent->d_name.len,
 230                                 de->d_name.name, de->d_name.len);
 231
 232                 size[0] = sizeof(struct ldlm_reply);
 233                 size[1] = sizeof(struct mds_body);
 234                 req->rq_replen = lustre_msg_size(2, size);
 235         } else if ( it->it_op == IT_GETATTR || it->it_op == IT_RENAME ||
 236                     it->it_op == IT_OPEN ) {
 237                 size[2] = sizeof(struct mds_body);
 238                 size[3] = de->d_name.len + 1;
 239
 240                 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
 241                                       LDLM_ENQUEUE, 4, size, NULL);
 242                 if (!req)
 243                         RETURN(-ENOMEM);
 244
 245                 /* pack the intent */
 246                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 247                 lit->opc = NTOH__u64((__u64)it->it_op);
 248
 249                 /* pack the intended request */
 250                 mds_getattr_pack(req, 2, dir, de->d_name.name, de->d_name.len);
 251
 252                 /* get ready for the reply */
 253                 size[0] = sizeof(struct ldlm_reply);
 254                 size[1] = sizeof(struct mds_body);
 255                 size[2] = sizeof(struct obdo);
 256                 req->rq_replen = lustre_msg_size(3, size);
 257         } else if ( it->it_op == IT_SETATTR) {
 258                 size[2] = sizeof(struct mds_rec_setattr);
 259                 size[3] = de->d_name.len + 1;
 260                 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
 261                                       LDLM_ENQUEUE, 5, size, NULL);
 262                 if (!req)
 263                         RETURN(-ENOMEM);
 264
 265                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 266                 lit->opc = NTOH__u64((__u64)it->it_op);
 267
 268                 if (!it->it_iattr)
 269                         LBUG();
 270
 271                 mds_setattr_pack(req, 2, dir, it->it_iattr,
 272                                 de->d_name.name, de->d_name.len);
 273                 size[0] = sizeof(struct ldlm_reply);
 274                 size[1] = sizeof(struct mds_body);
 275                 req->rq_replen = lustre_msg_size(2, size);
 276         } else if ( it->it_op == IT_READDIR ) {
 277                 req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
 278                                       LDLM_ENQUEUE, 1, size, NULL);
 279                 if (!req)
 280                         RETURN(-ENOMEM);
 281
 282                 /* get ready for the reply */
 283                 size[0] = sizeof(struct ldlm_reply);
 284                 req->rq_replen = lustre_msg_size(1, size);
 285         } else {
 286                 LBUG();
 287         }
 288
 289         rc = ldlm_cli_enqueue(mdc->mdc_ldlm_client, mdc->mdc_conn, req,
 290                               obddev->obd_namespace, NULL, res_id, lock_type,
 291                               NULL, 0, lock_mode, &flags,
 292                               (void *)mdc_lock_callback, data, datalen, lockh);
 293
 294         if (rc != 0) {
 295                 CERROR("ldlm_cli_enqueue: %d\n", rc);
 296                 RETURN(rc);
 297         }
 298
 299         dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
 300         it->it_disposition = (int) dlm_rep->lock_policy_res1;
 301         it->it_status = (int) dlm_rep->lock_policy_res2;
 302         it->it_lock_mode = lock_mode;
 303         it->it_data = req;
 304
 305         RETURN(0);
 306 }
 307
 308 int mdc_open(struct obd_conn *conn, ino_t ino, int type, int flags, __u64 objid,
 309              __u64 cookie, __u64 *fh, struct ptlrpc_request **request)
 310 {
 311         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 312         struct mds_body *body;
 313         int rc, size = sizeof(*body);
 314         struct ptlrpc_request *req;
 315
 316         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 317                               MDS_OPEN, 1, &size, NULL);
 318         if (!req)
 319                 GOTO(out, rc = -ENOMEM);
 320
 321         req->rq_flags |= PTL_RPC_FL_REPLAY;
 322         req->rq_level = LUSTRE_CONN_FULL;
 323         body = lustre_msg_buf(req->rq_reqmsg, 0);
 324
 325         ll_ino2fid(&body->fid1, ino, 0, type);
 326         body->flags = HTON__u32(flags);
 327         body->extra = cookie;
 328
 329         req->rq_replen = lustre_msg_size(1, &size);
 330
 331         rc = ptlrpc_queue_wait(req);
 332         rc = ptlrpc_check_status(req, rc);
 333
 334         if (!rc) {
 335                 body = lustre_msg_buf(req->rq_repmsg, 0);
 336                 mds_unpack_body(body);
 337                 *fh = body->extra;
 338         }
 339
 340         EXIT;
 341  out:
 342         *request = req;
 343         return rc;
 344 }
 345
 346 int mdc_close(struct obd_conn *conn,
 347               ino_t ino, int type, __u64 fh, struct ptlrpc_request **request)
 348 {
 349         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 350         struct mds_body *body;
 351         int rc, size = sizeof(*body);
 352         struct ptlrpc_request *req;
 353
 354         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 355                               MDS_CLOSE, 1, &size, NULL);
 356         if (!req)
 357                 GOTO(out, rc = -ENOMEM);
 358
 359         body = lustre_msg_buf(req->rq_reqmsg, 0);
 360         ll_ino2fid(&body->fid1, ino, 0, type);
 361         body->extra = fh;
 362
 363         req->rq_level = LUSTRE_CONN_FULL;
 364         req->rq_replen = lustre_msg_size(0, NULL);
 365
 366         rc = ptlrpc_queue_wait(req);
 367         rc = ptlrpc_check_status(req, rc);
 368
 369         EXIT;
 370  out:
 371         *request = req;
 372         return rc;
 373 }
 374
 375 int mdc_readpage(struct obd_conn *conn, ino_t ino, int type, __u64 offset,
 376                  char *addr, struct ptlrpc_request **request)
 377 {
 378         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 379         struct ptlrpc_request *req = NULL;
 380         struct ptlrpc_bulk_desc *desc = NULL;
 381         struct ptlrpc_bulk_page *bulk = NULL;
 382         struct mds_body *body;
 383         int rc, size = sizeof(*body);
 384         ENTRY;
 385
 386         CDEBUG(D_INODE, "inode: %ld\n", (long)ino);
 387
 388         desc = ptlrpc_prep_bulk(mdc->mdc_conn);
 389         if (desc == NULL)
 390                 GOTO(out, rc = -ENOMEM);
 391
 392         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 393                               MDS_READPAGE, 1, &size, NULL);
 394         if (!req)
 395                 GOTO(out2, rc = -ENOMEM);
 396
 397         bulk = ptlrpc_prep_bulk_page(desc);
 398         bulk->b_buflen = PAGE_SIZE;
 399         bulk->b_buf = addr;
 400         bulk->b_xid = req->rq_xid;
 401         desc->b_portal = MDS_BULK_PORTAL;
 402
 403         rc = ptlrpc_register_bulk(desc);
 404         if (rc) {
 405                 CERROR("couldn't setup bulk sink: error %d.\n", rc);
 406                 GOTO(out2, rc);
 407         }
 408
 409         body = lustre_msg_buf(req->rq_reqmsg, 0);
 410         body->fid1.id = ino;
 411         body->fid1.f_type = type;
 412         body->size = offset;
 413
 414         req->rq_replen = lustre_msg_size(1, &size);
 415         req->rq_level = LUSTRE_CONN_FULL;
 416         rc = ptlrpc_queue_wait(req);
 417         rc = ptlrpc_check_status(req, rc);
 418         if (rc) {
 419                 ptlrpc_abort_bulk(desc);
 420                 GOTO(out2, rc);
 421         } else {
 422                 body = lustre_msg_buf(req->rq_repmsg, 0);
 423                 mds_unpack_body(body);
 424         }
 425
 426         EXIT;
 427  out2:
 428         ptlrpc_free_bulk(desc);
 429  out:
 430         *request = req;
 431         return rc;
 432 }
 433
 434 #if 0
 435 int mdc_statfs(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
 436                struct statfs *statfs,
 437                struct ptlrpc_request **request)
 438 {
 439         struct mds_rec_setattr *rec;
 440         struct ptlrpc_request *req;
 441         int rc, size = sizeof(*rec);
 442         ENTRY;
 443
 444         req = ptlrpc_prep_req(cl, conn, MDS_STATFS, 1, &size, NULL);
 445         if (!req)
 446                 RETURN(-ENOMEM);
 447
 448         rec = lustre_msg_buf(req->rq_reqmsg, 0);
 449         mds_setattr_pack(rec, inode, iattr);
 450
 451         size = sizeof(struct mds_body);
 452         req->rq_replen = lustre_msg_size(1, &size);
 453
 454         rc = mdc_reint(cl, req, LUSTRE_CONN_FULL);
 455         *request = req;
 456         if (rc == -ERESTARTSYS )
 457                 rc = 0;
 458
 459         RETURN(rc);
 460 }
 461 #endif
 462
 463 static int mdc_ioctl(long cmd, struct obd_conn *conn, int len, void *karg,
 464                      void *uarg)
 465 {
 466 #if 0
 467         /* FIXME XXX : This should use the new ioc_data to pass args in */
 468         int err = 0;
 469         struct ptlrpc_client cl;
 470         struct ptlrpc_connection *conn;
 471         struct ptlrpc_request *request;
 472
 473         ENTRY;
 474
 475         if (_IOC_TYPE(cmd) != IOC_REQUEST_TYPE ||
 476             _IOC_NR(cmd) < IOC_REQUEST_MIN_NR  ||
 477             _IOC_NR(cmd) > IOC_REQUEST_MAX_NR ) {
 478                 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
 479                        _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
 480                 RETURN(-EINVAL);
 481         }
 482
 483         ptlrpc_init_client(NULL, NULL,
 484                            MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
 485         connection = ptlrpc_uuid_to_connection("mds");
 486         if (!connection) {
 487                 CERROR("cannot create client\n");
 488                 RETURN(-EINVAL);
 489         }
 490
 491         switch (cmd) {
 492         case IOC_REQUEST_GETATTR: {
 493                 CERROR("-- getting attr for ino %lu\n", arg);
 494                 err = mdc_getattr(&cl, connection, arg, S_IFDIR, ~0, 0,
 495                                   &request);
 496                 CERROR("-- done err %d\n", err);
 497
 498                 GOTO(out, err);
 499         }
 500
 501         case IOC_REQUEST_READPAGE: {
 502                 char *buf;
 503                 OBD_ALLOC(buf, PAGE_SIZE);
 504                 if (!buf) {
 505                         err = -ENOMEM;
 506                         GOTO(out, err);
 507                 }
 508                 CERROR("-- readpage 0 for ino %lu\n", arg);
 509                 err = mdc_readpage(&cl, connection, arg, S_IFDIR, 0, buf,
 510                                    &request);
 511                 CERROR("-- done err %d\n", err);
 512                 OBD_FREE(buf, PAGE_SIZE);
 513
 514                 GOTO(out, err);
 515         }
 516
 517         case IOC_REQUEST_SETATTR: {
 518                 struct inode inode;
 519                 struct iattr iattr;
 520
 521                 inode.i_ino = arg;
 522                 inode.i_generation = 0;
 523                 iattr.ia_mode = 040777;
 524                 iattr.ia_atime = 0;
 525                 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
 526
 527                 err = mdc_setattr(&cl, connection, &inode, &iattr, &request);
 528                 CERROR("-- done err %d\n", err);
 529
 530                 GOTO(out, err);
 531         }
 532
 533         case IOC_REQUEST_CREATE: {
 534                 struct inode inode;
 535                 struct iattr iattr;
 536
 537                 inode.i_ino = arg;
 538                 inode.i_generation = 0;
 539                 iattr.ia_mode = 040777;
 540                 iattr.ia_atime = 0;
 541                 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
 542
 543                 err = mdc_create(&cl, connection, &inode,
 544                                  "foofile", strlen("foofile"),
 545                                  NULL, 0, 0100707, 47114711,
 546                                  11, 47, 0, NULL, &request);
 547                 CERROR("-- done err %d\n", err);
 548
 549                 GOTO(out, err);
 550         }
 551
 552         case IOC_REQUEST_OPEN: {
 553                 __u64 fh, ino;
 554                 copy_from_user(&ino, (__u64 *)arg, sizeof(ino));
 555                 CERROR("-- opening ino %llu\n", (unsigned long long)ino);
 556                 err = mdc_open(&cl, connection, ino, S_IFDIR, O_RDONLY, 4711,
 557                                &fh, &request);
 558                 copy_to_user((__u64 *)arg, &fh, sizeof(fh));
 559                 CERROR("-- done err %d (fh=%Lu)\n", err,
 560                        (unsigned long long)fh);
 561
 562                 GOTO(out, err);
 563         }
 564
 565         case IOC_REQUEST_CLOSE: {
 566                 CERROR("-- closing ino 2, filehandle %lu\n", arg);
 567                 err = mdc_close(&cl, connection, 2, S_IFDIR, arg, &request);
 568                 CERROR("-- done err %d\n", err);
 569
 570                 GOTO(out, err);
 571         }
 572
 573         default:
 574                 GOTO(out, err = -EINVAL);
 575         }
 576
 577  out:
 578         ptlrpc_free_req(request);
 579         ptlrpc_put_connection(connection);
 580         ptlrpc_cleanup_client(&cl);
 581
 582         RETURN(err);
 583 #endif
 584         return 0;
 585 }
 586
 587 static int mdc_setup(struct obd_device *obddev, obd_count len, void *buf)
 588 {
 589         struct obd_ioctl_data* data = buf;
 590         struct mdc_obd *mdc = &obddev->u.mdc;
 591         char server_uuid[37];
 592         int rc;
 593         ENTRY;
 594
 595         if (data->ioc_inllen1 < 1) {
 596                 CERROR("osc setup requires a TARGET UUID\n");
 597                 RETURN(-EINVAL);
 598         }
 599
 600         if (data->ioc_inllen1 > 37) {
 601                 CERROR("mdc UUID must be less than 38 characters\n");
 602                 RETURN(-EINVAL);
 603         }
 604
 605         if (data->ioc_inllen2 < 1) {
 606                 CERROR("mdc setup requires a SERVER UUID\n");
 607                RETURN(-EINVAL);
 608         }
 609
 610         if (data->ioc_inllen2 > 37) {
 611                 CERROR("mdc UUID must be less than 38 characters\n");
 612                 RETURN(-EINVAL);
 613         }
 614
 615         memcpy(mdc->mdc_target_uuid, data->ioc_inlbuf1, data->ioc_inllen1);
 616         memcpy(server_uuid, data->ioc_inlbuf2, MIN(data->ioc_inllen2,
 617                                                    sizeof(server_uuid)));
 618
 619         mdc->mdc_conn = ptlrpc_uuid_to_connection(server_uuid);
 620         if (!mdc->mdc_conn)
 621                 RETURN(-ENOENT);
 622
 623         OBD_ALLOC(mdc->mdc_client, sizeof(*mdc->mdc_client));
 624         if (mdc->mdc_client == NULL)
 625                 GOTO(out_conn, rc = -ENOMEM);
 626
 627         OBD_ALLOC(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
 628         if (mdc->mdc_ldlm_client == NULL)
 629                 GOTO(out_client, rc = -ENOMEM);
 630
 631         ptlrpc_init_client(NULL, NULL, MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
 632                            mdc->mdc_client);
 633         ptlrpc_init_client(NULL, NULL, LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
 634                            mdc->mdc_ldlm_client);
 635         mdc->mdc_client->cli_name = "mdc";
 636         mdc->mdc_ldlm_client->cli_name = "ldlm";
 637         /* XXX get recovery hooked in here again */
 638         //ptlrpc_init_client(ptlrpc_connmgr, ll_recover,...
 639
 640         ptlrpc_init_client(ptlrpc_connmgr, NULL,
 641                            MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
 642                            mdc->mdc_client);
 643
 644         MOD_INC_USE_COUNT;
 645         RETURN(0);
 646
 647  out_client:
 648         OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
 649  out_conn:
 650         ptlrpc_put_connection(mdc->mdc_conn);
 651         return rc;
 652 }
 653
 654 static int mdc_cleanup(struct obd_device * obddev)
 655 {
 656         struct mdc_obd *mdc = &obddev->u.mdc;
 657
 658         ptlrpc_cleanup_client(mdc->mdc_client);
 659         OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
 660         ptlrpc_cleanup_client(mdc->mdc_ldlm_client);
 661         OBD_FREE(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
 662         ptlrpc_put_connection(mdc->mdc_conn);
 663
 664         MOD_DEC_USE_COUNT;
 665         return 0;
 666 }
 667
 668 static int mdc_connect(struct obd_conn *conn)
 669 {
 670         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 671         struct ptlrpc_request *request;
 672         int rc, size = sizeof(mdc->mdc_target_uuid);
 673         char *tmp = mdc->mdc_target_uuid;
 674
 675         ENTRY;
 676
 677         conn->oc_dev->obd_namespace = ldlm_namespace_new(LDLM_NAMESPACE_CLIENT);
 678         if (conn->oc_dev->obd_namespace == NULL)
 679                 RETURN(-ENOMEM);
 680
 681         request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 682                                   MDS_CONNECT, 1, &size, &tmp);
 683         if (!request)
 684                 RETURN(-ENOMEM);
 685
 686         request->rq_replen = lustre_msg_size(0, NULL);
 687
 688         rc = ptlrpc_queue_wait(request);
 689         if (rc)
 690                 GOTO(out, rc);
 691
 692         mdc->mdc_client->cli_target_devno = request->rq_repmsg->target_id;
 693         mdc->mdc_ldlm_client->cli_target_devno =
 694                 mdc->mdc_client->cli_target_devno;
 695         EXIT;
 696  out:
 697         ptlrpc_free_req(request);
 698         return rc;
 699 }
 700
 701 static int mdc_disconnect(struct obd_conn *conn)
 702 {
 703         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 704         struct ptlrpc_request *request;
 705         struct mds_body *body;
 706         int rc, size = sizeof(*body);
 707         ENTRY;
 708
 709         ldlm_namespace_free(conn->oc_dev->obd_namespace);
 710         request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 711                                   MDS_DISCONNECT, 1, &size,
 712                                   NULL);
 713         if (!request)
 714                 RETURN(-ENOMEM);
 715
 716         body = lustre_msg_buf(request->rq_reqmsg, 0);
 717         body->valid = conn->oc_id;
 718
 719         request->rq_replen = lustre_msg_size(0, NULL);
 720
 721         rc = ptlrpc_queue_wait(request);
 722         GOTO(out, rc);
 723  out:
 724         ptlrpc_free_req(request);
 725         return rc;
 726 }
 727
 728 struct obd_ops mdc_obd_ops = {
 729         o_setup:   mdc_setup,
 730         o_cleanup: mdc_cleanup,
 731         o_connect: mdc_connect,
 732         o_disconnect: mdc_disconnect,
 733         o_iocontrol: mdc_ioctl
 734 };
 735
 736 static int __init ptlrpc_request_init(void)
 737 {
 738         return obd_register_type(&mdc_obd_ops, LUSTRE_MDC_NAME);
 739 }
 740
 741 static void __exit ptlrpc_request_exit(void)
 742 {
 743         obd_unregister_type(LUSTRE_MDC_NAME);
 744 }
 745
 746 MODULE_AUTHOR("Cluster File Systems <info@clusterfs.com>");
 747 MODULE_DESCRIPTION("Lustre Metadata Client v1.0");
 748 MODULE_LICENSE("GPL");
 749
 750 EXPORT_SYMBOL(mdc_getstatus);
 751 EXPORT_SYMBOL(mdc_enqueue);
 752 EXPORT_SYMBOL(mdc_getattr);
 753 EXPORT_SYMBOL(mdc_create);
 754 EXPORT_SYMBOL(mdc_unlink);
 755 EXPORT_SYMBOL(mdc_rename);
 756 EXPORT_SYMBOL(mdc_link);
 757 EXPORT_SYMBOL(mdc_readpage);
 758 EXPORT_SYMBOL(mdc_setattr);
 759 EXPORT_SYMBOL(mdc_close);
 760 EXPORT_SYMBOL(mdc_open);
 761
 762 module_init(ptlrpc_request_init);
 763 module_exit(ptlrpc_request_exit);