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 lustre_handle *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_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
  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 lustre_handle *conn,
  84                 obd_id 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_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
  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 lustre_handle *lockh,
 128                              struct ldlm_lock_desc *desc, void *data,
 129                              int data_len, struct ptlrpc_request **req)
 130 {
 131         int rc;
 132         struct inode *inode = data;
 133         ENTRY;
 134
 135         if (desc == NULL) {
 136                 /* Completion AST.  Do nothing. */
 137                 RETURN(0);
 138         }
 139
 140         if (data_len != sizeof(*inode)) {
 141                 CERROR("data_len should be %d, but is %d\n", sizeof(*inode),
 142                        data_len);
 143                 LBUG();
 144         }
 145
 146         /* FIXME: do something better than throwing away everything */
 147         if (inode == NULL)
 148                 LBUG();
 149         if (S_ISDIR(inode->i_mode)) {
 150                 CDEBUG(D_INODE, "invalidating inode %ld\n", inode->i_ino);
 151                 invalidate_inode_pages(inode);
 152         }
 153
 154         rc = ldlm_cli_cancel(lockh, NULL);
 155         if (rc < 0) {
 156                 CERROR("ldlm_cli_cancel: %d\n", rc);
 157                 LBUG();
 158         }
 159         RETURN(0);
 160 }
 161
 162 int mdc_enqueue(struct lustre_handle *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)
 166 {
 167         struct ptlrpc_request *req;
 168         struct obd_device *obddev = class_conn2obd(conn);
 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)};
 172         int rc, flags;
 173         struct ldlm_reply *dlm_rep;
 174         struct ldlm_intent *lit;
 175         ENTRY;
 176
 177 #warning FIXME: Andreas, the sgid directory stuff also goes here, but check again on mds
 178
 179         LDLM_DEBUG_NOLOCK("mdsintent %d dir %ld", it->it_op, dir->i_ino);
 180
 181         switch (it->it_op) {
 182         case IT_MKDIR:
 183                 it->it_mode = (it->it_mode | S_IFDIR) & ~current->fs->umask;
 184                 break;
 185         case IT_SETATTR:
 186                 it->it_op = IT_GETATTR;
 187                 break;
 188         case (IT_CREAT|IT_OPEN):
 189         case IT_CREAT:
 190         case IT_MKNOD:
 191                 it->it_mode = (it->it_mode | S_IFREG) & ~current->fs->umask;
 192                 break;
 193         case IT_SYMLINK:
 194                 it->it_mode = (it->it_mode | S_IFLNK) & ~current->fs->umask;
 195                 break;
 196         }
 197
 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_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 203                                        &mdc->mdc_connh,
 204                                        LDLM_ENQUEUE, 5, size, NULL);
 205                 if (!req)
 206                         RETURN(-ENOMEM);
 207
 208                 /* pack the intent */
 209                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 210                 lit->opc = NTOH__u64((__u64)it->it_op);
 211
 212                 /* pack the intended request */
 213                 mds_create_pack(req, 2, dir, it->it_mode, id, current->fsuid,
 214                                 current->fsgid, CURRENT_TIME, de->d_name.name,
 215                                 de->d_name.len, tgt, tgtlen);
 216
 217                 size[0] = sizeof(struct ldlm_reply);
 218                 size[1] = sizeof(struct mds_body);
 219                 size[2] = sizeof(struct obdo);
 220                 req->rq_replen = lustre_msg_size(3, size);
 221         } else if ( it->it_op == IT_RENAME2 ) {
 222                 struct dentry *old_de = it->it_data;
 223
 224                 size[2] = sizeof(struct mds_rec_rename);
 225                 size[3] = old_de->d_name.len + 1;
 226                 size[4] = de->d_name.len + 1;
 227                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 228                                       &mdc->mdc_connh, LDLM_ENQUEUE, 5, size, NULL);
 229                 if (!req)
 230                         RETURN(-ENOMEM);
 231
 232                 /* pack the intent */
 233                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 234                 lit->opc = NTOH__u64((__u64)it->it_op);
 235
 236                 /* pack the intended request */
 237                 mds_rename_pack(req, 2, old_de->d_inode, dir,
 238                                 old_de->d_parent->d_name.name,
 239                                 old_de->d_parent->d_name.len,
 240                                 de->d_name.name, de->d_name.len);
 241
 242                 size[0] = sizeof(struct ldlm_reply);
 243                 size[1] = sizeof(struct mds_body);
 244                 req->rq_replen = lustre_msg_size(2, size);
 245         } else if ( it->it_op == IT_UNLINK ) {
 246                 size[2] = sizeof(struct mds_rec_unlink);
 247                 size[3] = de->d_name.len + 1;
 248                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 249                                 &mdc->mdc_connh, LDLM_ENQUEUE, 4, size, NULL);
 250                 if (!req)
 251                         RETURN(-ENOMEM);
 252
 253                 /* pack the intent */
 254                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 255                 lit->opc = NTOH__u64((__u64)it->it_op);
 256
 257                 /* pack the intended request */
 258                 mds_unlink_pack(req, 2, dir, NULL, de->d_name.name,
 259                                 de->d_name.len);
 260                 size[0] = sizeof(struct ldlm_reply);
 261                 size[1] = sizeof(struct obdo);
 262                 req->rq_replen = lustre_msg_size(2, size);
 263         } else if ( it->it_op == IT_RMDIR ) {
 264                 size[2] = sizeof(struct mds_rec_unlink);
 265                 size[3] = de->d_name.len + 1;
 266                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 267                                       &mdc->mdc_connh, LDLM_ENQUEUE, 4, size, NULL);
 268                 if (!req)
 269                         RETURN(-ENOMEM);
 270
 271                 /* pack the intent */
 272                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 273                 lit->opc = NTOH__u64((__u64)it->it_op);
 274
 275                 /* pack the intended request */
 276                 mds_unlink_pack(req, 2, dir, NULL, de->d_name.name,
 277                                 de->d_name.len);
 278                 size[0] = sizeof(struct ldlm_reply);
 279                 req->rq_replen = lustre_msg_size(1, size);
 280         } else if ( it->it_op == IT_GETATTR || it->it_op == IT_RENAME ||
 281                     it->it_op == IT_OPEN ) {
 282                 size[2] = sizeof(struct mds_body);
 283                 size[3] = de->d_name.len + 1;
 284
 285                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 286                                        &mdc->mdc_connh, LDLM_ENQUEUE, 4, size,
 287                                        NULL);
 288                 if (!req)
 289                         RETURN(-ENOMEM);
 290
 291                 /* pack the intent */
 292                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 293                 lit->opc = NTOH__u64((__u64)it->it_op);
 294
 295                 /* pack the intended request */
 296                 mds_getattr_pack(req, 2, dir, de->d_name.name, de->d_name.len);
 297
 298                 /* get ready for the reply */
 299                 size[0] = sizeof(struct ldlm_reply);
 300                 size[1] = sizeof(struct mds_body);
 301                 size[2] = sizeof(struct obdo);
 302                 req->rq_replen = lustre_msg_size(3, size);
 303         } else if ( it->it_op == IT_SETATTR) {
 304                 size[2] = sizeof(struct mds_rec_setattr);
 305                 size[3] = de->d_name.len + 1;
 306                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 307                                 &mdc->mdc_connh, LDLM_ENQUEUE, 5, size, NULL);
 308                 if (!req)
 309                         RETURN(-ENOMEM);
 310
 311                 lit = lustre_msg_buf(req->rq_reqmsg, 1);
 312                 lit->opc = NTOH__u64((__u64)it->it_op);
 313
 314                 if (!it->it_iattr)
 315                         LBUG();
 316
 317                 mds_setattr_pack(req, 2, dir, it->it_iattr,
 318                                 de->d_name.name, de->d_name.len);
 319                 size[0] = sizeof(struct ldlm_reply);
 320                 size[1] = sizeof(struct mds_body);
 321                 req->rq_replen = lustre_msg_size(2, size);
 322         } else if ( it->it_op == IT_READDIR ) {
 323                 req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
 324                                 &mdc->mdc_connh, LDLM_ENQUEUE, 1, size, NULL);
 325                 if (!req)
 326                         RETURN(-ENOMEM);
 327
 328                 /* get ready for the reply */
 329                 size[0] = sizeof(struct ldlm_reply);
 330                 req->rq_replen = lustre_msg_size(1, size);
 331         } else {
 332                 LBUG();
 333                 RETURN(-1);
 334         }
 335 #warning FIXME: the data here needs to be different if a lock was granted for a different inode
 336         rc = ldlm_cli_enqueue(mdc->mdc_ldlm_client, mdc->mdc_conn,
 337                               NULL, req,
 338                               obddev->obd_namespace, NULL, res_id, lock_type,
 339                               NULL, 0, lock_mode, &flags,
 340                               (void *)mdc_lock_callback, data, datalen, lockh);
 341         if (rc == -ENOENT || rc == ELDLM_LOCK_ABORTED) {
 342                 lock_mode = 0;
 343                 memset(lockh, 0, sizeof(*lockh));
 344         } else if (rc != 0) {
 345                 CERROR("ldlm_cli_enqueue: %d\n", rc);
 346                 RETURN(rc);
 347         }
 348
 349         dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
 350         it->it_disposition = (int) dlm_rep->lock_policy_res1;
 351         it->it_status = (int) dlm_rep->lock_policy_res2;
 352         it->it_lock_mode = lock_mode;
 353         it->it_data = req;
 354
 355         RETURN(0);
 356 }
 357
 358 int mdc_open(struct lustre_handle *conn, obd_id ino, int type, int flags,
 359              struct obdo *obdo,
 360              __u64 cookie, __u64 *fh, struct ptlrpc_request **request)
 361 {
 362         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 363         struct mds_body *body;
 364         int rc, size[2] = {sizeof(*body)}, bufcount = 1;
 365         struct ptlrpc_request *req;
 366         ENTRY;
 367
 368         if (obdo != NULL) {
 369                 bufcount = 2;
 370                 size[1] = sizeof(*obdo);
 371         }
 372
 373         req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
 374                               MDS_OPEN, bufcount, size, NULL);
 375         if (!req)
 376                 GOTO(out, rc = -ENOMEM);
 377
 378         req->rq_flags |= PTL_RPC_FL_REPLAY;
 379         req->rq_level = LUSTRE_CONN_FULL;
 380         body = lustre_msg_buf(req->rq_reqmsg, 0);
 381
 382         ll_ino2fid(&body->fid1, ino, 0, type);
 383         body->flags = HTON__u32(flags);
 384         body->extra = cookie;
 385
 386         if (obdo != NULL)
 387                 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), obdo, sizeof(*obdo));
 388
 389         req->rq_replen = lustre_msg_size(1, size);
 390
 391         rc = ptlrpc_queue_wait(req);
 392         rc = ptlrpc_check_status(req, rc);
 393
 394         if (!rc) {
 395                 body = lustre_msg_buf(req->rq_repmsg, 0);
 396                 mds_unpack_body(body);
 397                 *fh = body->extra;
 398         }
 399
 400         EXIT;
 401  out:
 402         *request = req;
 403         return rc;
 404 }
 405
 406 int mdc_close(struct lustre_handle *conn,
 407               obd_id ino, int type, __u64 fh, struct ptlrpc_request **request)
 408 {
 409         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 410         struct mds_body *body;
 411         int rc, size = sizeof(*body);
 412         struct ptlrpc_request *req;
 413
 414         req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
 415                               MDS_CLOSE, 1, &size, NULL);
 416         if (!req)
 417                 GOTO(out, rc = -ENOMEM);
 418
 419         body = lustre_msg_buf(req->rq_reqmsg, 0);
 420         ll_ino2fid(&body->fid1, ino, 0, type);
 421         body->extra = fh;
 422
 423         req->rq_level = LUSTRE_CONN_FULL;
 424         req->rq_replen = lustre_msg_size(0, NULL);
 425
 426         rc = ptlrpc_queue_wait(req);
 427         rc = ptlrpc_check_status(req, rc);
 428
 429         EXIT;
 430  out:
 431         *request = req;
 432         return rc;
 433 }
 434
 435 int mdc_readpage(struct lustre_handle *conn, obd_id ino, int type, __u64 offset,
 436                  char *addr, struct ptlrpc_request **request)
 437 {
 438         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 439         struct ptlrpc_request *req = NULL;
 440         struct ptlrpc_bulk_desc *desc = NULL;
 441         struct ptlrpc_bulk_page *bulk = NULL;
 442         struct mds_body *body;
 443         int rc, size = sizeof(*body);
 444         ENTRY;
 445
 446         CDEBUG(D_INODE, "inode: %ld\n", (long)ino);
 447
 448         desc = ptlrpc_prep_bulk(mdc->mdc_conn);
 449         if (desc == NULL)
 450                 GOTO(out, rc = -ENOMEM);
 451
 452         req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
 453                               MDS_READPAGE, 1, &size, NULL);
 454         if (!req)
 455                 GOTO(out2, rc = -ENOMEM);
 456
 457         bulk = ptlrpc_prep_bulk_page(desc);
 458         bulk->b_buflen = PAGE_SIZE;
 459         bulk->b_buf = addr;
 460         bulk->b_xid = req->rq_xid;
 461         desc->b_portal = MDS_BULK_PORTAL;
 462
 463         rc = ptlrpc_register_bulk(desc);
 464         if (rc) {
 465                 CERROR("couldn't setup bulk sink: error %d.\n", rc);
 466                 GOTO(out2, rc);
 467         }
 468
 469         body = lustre_msg_buf(req->rq_reqmsg, 0);
 470         body->fid1.id = ino;
 471         body->fid1.f_type = type;
 472         body->size = offset;
 473
 474         req->rq_replen = lustre_msg_size(1, &size);
 475         req->rq_level = LUSTRE_CONN_FULL;
 476         rc = ptlrpc_queue_wait(req);
 477         rc = ptlrpc_check_status(req, rc);
 478         if (rc) {
 479                 ptlrpc_abort_bulk(desc);
 480                 GOTO(out2, rc);
 481         } else {
 482                 body = lustre_msg_buf(req->rq_repmsg, 0);
 483                 mds_unpack_body(body);
 484         }
 485
 486         EXIT;
 487  out2:
 488         ptlrpc_free_bulk(desc);
 489  out:
 490         *request = req;
 491         return rc;
 492 }
 493
 494 int mdc_statfs(struct lustre_handle *conn, struct statfs *sfs,
 495                struct ptlrpc_request **request)
 496 {
 497         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 498         struct obd_statfs *osfs;
 499         struct ptlrpc_request *req;
 500         int rc, size = sizeof(*osfs);
 501         ENTRY;
 502
 503         req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
 504                               MDS_STATFS, 0, NULL, NULL);
 505         if (!req)
 506                 GOTO(out, rc = -ENOMEM);
 507         req->rq_replen = lustre_msg_size(1, &size);
 508         req->rq_level = LUSTRE_CONN_FULL;
 509
 510         rc = ptlrpc_queue_wait(req);
 511         rc = ptlrpc_check_status(req, rc);
 512
 513         if (rc)
 514                 GOTO(out, rc);
 515
 516         osfs = lustre_msg_buf(req->rq_repmsg, 0);
 517         obd_statfs_unpack(osfs, sfs);
 518
 519         EXIT;
 520 out:
 521         *request = req;
 522
 523         return rc;
 524 }
 525
 526 static int mdc_ioctl(long cmd, struct lustre_handle *conn, int len, void *karg,
 527                      void *uarg)
 528 {
 529 #if 0
 530         /* FIXME XXX : This should use the new ioc_data to pass args in */
 531         int err = 0;
 532         struct ptlrpc_client cl;
 533         struct ptlrpc_connection *conn;
 534         struct ptlrpc_request *request;
 535
 536         ENTRY;
 537
 538         if (_IOC_TYPE(cmd) != IOC_REQUEST_TYPE ||
 539             _IOC_NR(cmd) < IOC_REQUEST_MIN_NR  ||
 540             _IOC_NR(cmd) > IOC_REQUEST_MAX_NR ) {
 541                 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
 542                        _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
 543                 RETURN(-EINVAL);
 544         }
 545
 546         ptlrpc_init_client(NULL, NULL,
 547                            MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
 548         connection = ptlrpc_uuid_to_connection("mds");
 549         if (!connection) {
 550                 CERROR("cannot create client\n");
 551                 RETURN(-EINVAL);
 552         }
 553
 554         switch (cmd) {
 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,
 558                                   &request);
 559                 CERROR("-- done err %d\n", err);
 560
 561                 GOTO(out, err);
 562         }
 563
 564         case IOC_REQUEST_READPAGE: {
 565                 char *buf;
 566                 OBD_ALLOC(buf, PAGE_SIZE);
 567                 if (!buf) {
 568                         err = -ENOMEM;
 569                         GOTO(out, err);
 570                 }
 571                 CERROR("-- readpage 0 for ino %lu\n", arg);
 572                 err = mdc_readpage(&cl, connection, arg, S_IFDIR, 0, buf,
 573                                    &request);
 574                 CERROR("-- done err %d\n", err);
 575                 OBD_FREE(buf, PAGE_SIZE);
 576
 577                 GOTO(out, err);
 578         }
 579
 580         case IOC_REQUEST_SETATTR: {
 581                 struct inode inode;
 582                 struct iattr iattr;
 583
 584                 inode.i_ino = arg;
 585                 inode.i_generation = 0;
 586                 iattr.ia_mode = 040777;
 587                 iattr.ia_atime = 0;
 588                 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
 589
 590                 err = mdc_setattr(&cl, connection, &inode, &iattr, &request);
 591                 CERROR("-- done err %d\n", err);
 592
 593                 GOTO(out, err);
 594         }
 595
 596         case IOC_REQUEST_CREATE: {
 597                 struct inode inode;
 598                 struct iattr iattr;
 599
 600                 inode.i_ino = arg;
 601                 inode.i_generation = 0;
 602                 iattr.ia_mode = 040777;
 603                 iattr.ia_atime = 0;
 604                 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
 605
 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);
 611
 612                 GOTO(out, err);
 613         }
 614
 615         case IOC_REQUEST_OPEN: {
 616                 __u64 fh, ino;
 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,
 620                                &fh, &request);
 621                 copy_to_user((__u64 *)arg, &fh, sizeof(fh));
 622                 CERROR("-- done err %d (fh=%Lu)\n", err,
 623                        (unsigned long long)fh);
 624
 625                 GOTO(out, err);
 626         }
 627
 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);
 632
 633                 GOTO(out, err);
 634         }
 635
 636         default:
 637                 GOTO(out, err = -EINVAL);
 638         }
 639
 640  out:
 641         ptlrpc_free_req(request);
 642         ptlrpc_put_connection(connection);
 643         ptlrpc_cleanup_client(&cl);
 644
 645         RETURN(err);
 646 #endif
 647         return 0;
 648 }
 649
 650 static int mdc_setup(struct obd_device *obddev, obd_count len, void *buf)
 651 {
 652         struct obd_ioctl_data* data = buf;
 653         struct mdc_obd *mdc = &obddev->u.mdc;
 654         char server_uuid[37];
 655         int rc;
 656         ENTRY;
 657
 658         if (data->ioc_inllen1 < 1) {
 659                 CERROR("osc setup requires a TARGET UUID\n");
 660                 RETURN(-EINVAL);
 661         }
 662
 663         if (data->ioc_inllen1 > 37) {
 664                 CERROR("mdc UUID must be less than 38 characters\n");
 665                 RETURN(-EINVAL);
 666         }
 667
 668         if (data->ioc_inllen2 < 1) {
 669                 CERROR("mdc setup requires a SERVER UUID\n");
 670                RETURN(-EINVAL);
 671         }
 672
 673         if (data->ioc_inllen2 > 37) {
 674                 CERROR("mdc UUID must be less than 38 characters\n");
 675                 RETURN(-EINVAL);
 676         }
 677
 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)));
 681
 682         mdc->mdc_conn = ptlrpc_uuid_to_connection(server_uuid);
 683         if (!mdc->mdc_conn)
 684                 RETURN(-ENOENT);
 685
 686         OBD_ALLOC(mdc->mdc_client, sizeof(*mdc->mdc_client));
 687         if (mdc->mdc_client == NULL)
 688                 GOTO(out_conn, rc = -ENOMEM);
 689
 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);
 693
 694         ptlrpc_init_client(NULL, NULL, MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
 695                            mdc->mdc_client);
 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         /* XXX get recovery hooked in here again */
 701         //ptlrpc_init_client(ptlrpc_connmgr, ll_recover,...
 702
 703         ptlrpc_init_client(ptlrpc_connmgr, NULL,
 704                            MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
 705                            mdc->mdc_client);
 706
 707         MOD_INC_USE_COUNT;
 708         RETURN(0);
 709
 710  out_client:
 711         OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
 712  out_conn:
 713         ptlrpc_put_connection(mdc->mdc_conn);
 714         return rc;
 715 }
 716
 717 static int mdc_cleanup(struct obd_device * obddev)
 718 {
 719         struct mdc_obd *mdc = &obddev->u.mdc;
 720
 721         ptlrpc_cleanup_client(mdc->mdc_client);
 722         OBD_FREE(mdc->mdc_client, sizeof(*mdc->mdc_client));
 723         ptlrpc_cleanup_client(mdc->mdc_ldlm_client);
 724         OBD_FREE(mdc->mdc_ldlm_client, sizeof(*mdc->mdc_ldlm_client));
 725         ptlrpc_put_connection(mdc->mdc_conn);
 726
 727         MOD_DEC_USE_COUNT;
 728         return 0;
 729 }
 730
 731 static int mdc_connect(struct lustre_handle *conn, struct obd_device *obd)
 732 {
 733         struct mdc_obd *mdc = &obd->u.mdc;
 734         struct ptlrpc_request *request;
 735         int rc, size = sizeof(mdc->mdc_target_uuid);
 736         char *tmp = mdc->mdc_target_uuid;
 737
 738         ENTRY;
 739
 740         obd->obd_namespace =
 741                 ldlm_namespace_new("mdc", LDLM_NAMESPACE_CLIENT);
 742         if (obd->obd_namespace == NULL)
 743                 RETURN(-ENOMEM);
 744
 745         MOD_INC_USE_COUNT;
 746         rc = class_connect(conn, obd);
 747         if (rc)
 748                 RETURN(rc);
 749
 750         request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
 751                                   MDS_CONNECT, 1, &size, &tmp);
 752         if (!request)
 753                 GOTO(out_disco, -ENOMEM);
 754
 755         request->rq_replen = lustre_msg_size(0, NULL);
 756
 757         rc = ptlrpc_queue_wait(request);
 758         rc = ptlrpc_check_status(request, rc);
 759         if (rc)
 760                 GOTO(out, rc);
 761
 762         mdc->mdc_connh.addr = request->rq_repmsg->addr;
 763         mdc->mdc_connh.cookie = request->rq_repmsg->cookie;
 764
 765         EXIT;
 766  out:
 767         ptlrpc_free_req(request);
 768  out_disco:
 769         if (rc) {
 770                 class_disconnect(conn);
 771                 MOD_DEC_USE_COUNT;
 772         }
 773         return rc;
 774 }
 775
 776 static int mdc_disconnect(struct lustre_handle *conn)
 777 {
 778         struct mdc_obd *mdc = mdc_conn2mdc(conn);
 779         struct obd_device *obd = class_conn2obd(conn);
 780         struct ptlrpc_request *request;
 781         int rc;
 782         ENTRY;
 783
 784         ldlm_namespace_free(obd->obd_namespace);
 785         request = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn,
 786                                    &mdc->mdc_connh, MDS_DISCONNECT, 0, NULL, NULL);
 787         if (!request)
 788                 RETURN(-ENOMEM);
 789
 790         request->rq_replen = lustre_msg_size(0, NULL);
 791
 792         rc = ptlrpc_queue_wait(request);
 793         if (rc)
 794                 GOTO(out, rc);
 795         rc = class_disconnect(conn);
 796         if (!rc)
 797                 MOD_DEC_USE_COUNT;
 798  out:
 799         ptlrpc_free_req(request);
 800         return rc;
 801 }
 802
 803 struct obd_ops mdc_obd_ops = {
 804         o_setup:   mdc_setup,
 805         o_cleanup: mdc_cleanup,
 806         o_connect: mdc_connect,
 807         o_disconnect: mdc_disconnect,
 808         o_iocontrol: mdc_ioctl
 809 };
 810
 811 static int __init ptlrpc_request_init(void)
 812 {
 813         return class_register_type(&mdc_obd_ops, LUSTRE_MDC_NAME);
 814 }
 815
 816 static void __exit ptlrpc_request_exit(void)
 817 {
 818         class_unregister_type(LUSTRE_MDC_NAME);
 819 }
 820
 821 MODULE_AUTHOR("Cluster File Systems <info@clusterfs.com>");
 822 MODULE_DESCRIPTION("Lustre Metadata Client v1.0");
 823 MODULE_LICENSE("GPL");
 824
 825 EXPORT_SYMBOL(mdc_getstatus);
 826 EXPORT_SYMBOL(mdc_enqueue);
 827 EXPORT_SYMBOL(mdc_getattr);
 828 EXPORT_SYMBOL(mdc_statfs);
 829 EXPORT_SYMBOL(mdc_create);
 830 EXPORT_SYMBOL(mdc_unlink);
 831 EXPORT_SYMBOL(mdc_rename);
 832 EXPORT_SYMBOL(mdc_link);
 833 EXPORT_SYMBOL(mdc_readpage);
 834 EXPORT_SYMBOL(mdc_setattr);
 835 EXPORT_SYMBOL(mdc_close);
 836 EXPORT_SYMBOL(mdc_open);
 837
 838 module_init(ptlrpc_request_init);
 839 module_exit(ptlrpc_request_exit);