lustre/llite/namei.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2002, 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   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  *  derived in small part from linux/fs/ext2/namei.c
  22  *
  23  *  Copyright (C) 1991, 1992  Linus Torvalds
  24  *
  25  *  Big-endian to little-endian byte-swapping/bitmaps by
  26  *        David S. Miller (davem@caip.rutgers.edu), 1995
  27  *  Directory entry file type support and forward compatibility hooks
  28  *      for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
  29  */
  30
  31 #include <linux/fs.h>
  32 #include <linux/sched.h>
  33 #include <linux/mm.h>
  34 #include <linux/smp_lock.h>
  35 #include <linux/quotaops.h>
  36 #include <linux/highmem.h>
  37 #include <linux/pagemap.h>
  38
  39 #define DEBUG_SUBSYSTEM S_LLITE
  40
  41 #include <linux/obd_support.h>
  42 #include <linux/lustre_lite.h>
  43 #include <linux/lustre_dlm.h>
  44 #include <linux/lustre_version.h>
  45 #include "llite_internal.h"
  46
  47 /* methods */
  48
  49 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  50 static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque)
  51 #else
  52 static int ll_test_inode(struct inode *inode, void *opaque)
  53 #endif
  54 {
  55         static int last_ino, last_gen, last_count;
  56         struct lustre_md *md = opaque;
  57
  58         if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) {
  59                 CERROR("MDS body missing inum or generation\n");
  60                 return 0;
  61         }
  62
  63         if (last_ino == md->body->ino && last_gen == md->body->generation &&
  64             last_count < 500) {
  65                 last_count++;
  66         } else {
  67                 if (last_count > 1)
  68                         CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
  69                                last_ino, last_gen, last_count);
  70                 last_count = 0;
  71                 last_ino = md->body->ino;
  72                 last_gen = md->body->generation;
  73                 CDEBUG(D_VFSTRACE,
  74                        "comparing inode %p ino %lu/%u to body %u/%u\n",
  75                        inode, inode->i_ino, inode->i_generation,
  76                        md->body->ino, md->body->generation);
  77         }
  78
  79 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  80         if (inode->i_ino != md->body->ino)
  81                 return 0;
  82 #endif
  83         if (inode->i_generation != md->body->generation)
  84                 return 0;
  85
  86         /* Apply the attributes in 'opaque' to this inode */
  87         ll_update_inode(inode, md->body, md->lsm);
  88         return 1;
  89 }
  90
  91 extern struct dentry_operations ll_d_ops;
  92
  93 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
  94 {
  95         ENTRY;
  96
  97         ldlm_lock_decref(lockh, mode);
  98
  99         RETURN(0);
 100 }
 101
 102 /* Get an inode by inode number (already instantiated by the intent lookup).
 103  * Returns inode or NULL
 104  */
 105 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 106 int ll_set_inode(struct inode *inode, void *opaque)
 107 {
 108         ll_read_inode2(inode, opaque);
 109         return 0;
 110 }
 111
 112 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 113                       struct lustre_md *md)
 114 {
 115         struct inode *inode;
 116
 117         LASSERT(hash != 0);
 118         inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
 119
 120         if (inode) {
 121                 if (inode->i_state & I_NEW)
 122                         unlock_new_inode(inode);
 123                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 124                        inode->i_generation, inode);
 125         }
 126
 127         return inode;
 128 }
 129 #else
 130 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 131                       struct lustre_md *md)
 132 {
 133         struct inode *inode;
 134         LASSERT(hash != 0);
 135         inode = iget4(sb, hash, ll_test_inode, md);
 136         if (inode)
 137                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 138                        inode->i_generation, inode);
 139         return inode;
 140 }
 141 #endif
 142
 143 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 144                         void *data, int flag)
 145 {
 146         int rc;
 147         struct lustre_handle lockh;
 148         ENTRY;
 149
 150         switch (flag) {
 151         case LDLM_CB_BLOCKING:
 152                 ldlm_lock2handle(lock, &lockh);
 153                 rc = ldlm_cli_cancel(&lockh);
 154                 if (rc < 0) {
 155                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 156                         RETURN(rc);
 157                 }
 158                 break;
 159         case LDLM_CB_CANCELING: {
 160                 struct inode *inode = ll_inode_from_lock(lock);
 161                 __u64 bits = lock->l_policy_data.l_inodebits.bits;
 162
 163                 /* For lookup locks: Invalidate all dentries associated with
 164                    this inode, for UPDATE locks - invalidate directory pages */
 165                 if (inode == NULL)
 166                         break;
 167
 168                 if (bits & MDS_INODELOCK_UPDATE)
 169                         clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
 170                                   &(ll_i2info(inode)->lli_flags));
 171
 172
 173                 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
 174                     lock->l_resource->lr_name.name[1] != inode->i_generation) {
 175                         LDLM_ERROR(lock, "data mismatch with ino %lu/%u",
 176                                    inode->i_ino, inode->i_generation);
 177                 }
 178
 179                 /* If lookup lock is cancelled, we just drop the dentry and
 180                    this will cause us to reget data from MDS when we'd want to
 181                    access this dentry/inode again. If this is lock on
 182                    other parts of inode that is cancelled, we do not need to do
 183                    much (but need to discard data from readdir, if any), since
 184                    abscence of lock will cause ll_revalidate_it (called from
 185                    stat() and similar functions) to renew the data anyway */
 186                 if (S_ISDIR(inode->i_mode) &&
 187                     (bits & MDS_INODELOCK_UPDATE)) {
 188                         CDEBUG(D_INODE, "invalidating inode %lu\n",
 189                                inode->i_ino);
 190
 191                         truncate_inode_pages(inode->i_mapping, 0);
 192                 }
 193
 194                 if (inode->i_sb->s_root &&
 195                     inode != inode->i_sb->s_root->d_inode &&
 196                     (bits & MDS_INODELOCK_LOOKUP))
 197                         ll_unhash_aliases(inode);
 198                 iput(inode);
 199                 break;
 200         }
 201         default:
 202                 LBUG();
 203         }
 204
 205         RETURN(0);
 206 }
 207
 208 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
 209                          int flags, void *opaque)
 210 {
 211         struct ldlm_res_id res_id =
 212                 { .name = {inode->i_ino, inode->i_generation} };
 213         struct obd_device *obddev = class_conn2obd(conn);
 214         ENTRY;
 215
 216         RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
 217                                       opaque));
 218 }
 219
 220
 221 void ll_prepare_mdc_op_data(struct mdc_op_data *data, struct inode *i1,
 222                             struct inode *i2, const char *name, int namelen,
 223                             int mode)
 224 {
 225         LASSERT(i1);
 226
 227         ll_i2uctxt(&data->ctxt, i1, i2);
 228         ll_inode2fid(&data->fid1, i1);
 229
 230         if (i2)
 231                 ll_inode2fid(&data->fid2, i2);
 232
 233         data->name = name;
 234         data->namelen = namelen;
 235         data->create_mode = mode;
 236         data->mod_time = LTIME_S(CURRENT_TIME);
 237 }
 238
 239 /* Search "inode"'s alias list for a dentry that has the same name and parent as
 240  * de.  If found, return it.  If not found, return de. */
 241 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
 242 {
 243         struct list_head *tmp;
 244
 245         spin_lock(&dcache_lock);
 246         list_for_each(tmp, &inode->i_dentry) {
 247                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 248
 249                 /* We are called here with 'de' already on the aliases list. */
 250                 if (dentry == de) {
 251                         CERROR("whoops\n");
 252                         continue;
 253                 }
 254
 255                 if (dentry->d_parent != de->d_parent)
 256                         continue;
 257
 258                 if (dentry->d_name.len != de->d_name.len)
 259                         continue;
 260
 261                 if (memcmp(dentry->d_name.name, de->d_name.name,
 262                            de->d_name.len) != 0)
 263                         continue;
 264
 265                 if (!list_empty(&dentry->d_lru))
 266                         list_del_init(&dentry->d_lru);
 267
 268                 hlist_del_init(&dentry->d_hash);
 269                 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
 270                 spin_unlock(&dcache_lock);
 271                 atomic_inc(&dentry->d_count);
 272                 iput(inode);
 273                 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
 274                 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
 275                        "refc %d\n", de->d_name.len, de->d_name.name, de,
 276                        de->d_parent, de->d_inode, atomic_read(&de->d_count));
 277                 return dentry;
 278         }
 279
 280         spin_unlock(&dcache_lock);
 281
 282         return de;
 283 }
 284
 285 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
 286                             struct lookup_intent *it, void *data)
 287 {
 288         struct it_cb_data *icbd = data;
 289         struct dentry **de = icbd->icbd_childp;
 290         struct inode *parent = icbd->icbd_parent;
 291         struct ll_sb_info *sbi = ll_i2sbi(parent);
 292         struct dentry *dentry = *de, *saved = *de;
 293         struct inode *inode = NULL;
 294         int rc;
 295
 296         /* NB 1 request reference will be taken away by ll_intent_lock()
 297          * when I return */
 298         if (!it_disposition(it, DISP_LOOKUP_NEG)) {
 299                 ENTRY;
 300
 301                 rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, offset,
 302                                    dentry->d_sb);
 303                 if (rc)
 304                         RETURN(rc);
 305
 306                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 307                        inode, inode->i_ino, inode->i_generation);
 308                 mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
 309
 310                 /* If this is a stat, get the authoritative file size */
 311                 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
 312                     ll_i2info(inode)->lli_smd != NULL) {
 313                         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
 314                         struct ost_lvb lvb;
 315                         ldlm_error_t rc;
 316
 317                         LASSERT(lsm->lsm_object_id != 0);
 318
 319                         /* bug 2334: drop MDS lock before acquiring OST lock */
 320                         ll_intent_drop_lock(it);
 321
 322                         rc = ll_glimpse_size(inode, &lvb);
 323                         if (rc) {
 324                                 iput(inode);
 325                                 RETURN(rc);
 326                         }
 327                         inode->i_size = lvb.lvb_size;
 328                 }
 329
 330                 dentry = *de = ll_find_alias(inode, dentry);
 331         } else {
 332                 ENTRY;
 333         }
 334
 335         dentry->d_op = &ll_d_ops;
 336         ll_set_dd(dentry);
 337
 338         if (dentry == saved) {
 339                 d_add(dentry, inode);
 340         }
 341
 342         RETURN(0);
 343 }
 344
 345
 346 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 347                                    struct lookup_intent *it, int flags)
 348 {
 349         struct dentry *save = dentry, *retval;
 350         struct ll_fid pfid;
 351         struct ll_uctxt ctxt;
 352         struct it_cb_data icbd;
 353         struct ptlrpc_request *req = NULL;
 354         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 355         int rc;
 356         ENTRY;
 357
 358         if (dentry->d_name.len > EXT3_NAME_LEN)
 359                 RETURN(ERR_PTR(-ENAMETOOLONG));
 360
 361         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 362                dentry->d_name.name, parent->i_ino, parent->i_generation,
 363                parent, LL_IT2STR(it));
 364
 365         if (d_mountpoint(dentry))
 366                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
 367
 368         ll_frob_intent(&it, &lookup_it);
 369
 370         icbd.icbd_childp = &dentry;
 371         icbd.icbd_parent = parent;
 372         ll_inode2fid(&pfid, parent);
 373         ll_i2uctxt(&ctxt, parent, NULL);
 374
 375         rc = mdc_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
 376                              dentry->d_name.name, dentry->d_name.len, NULL, 0,
 377                              NULL, it, flags, &req, ll_mdc_blocking_ast);
 378         if (rc < 0)
 379                 GOTO(out, retval = ERR_PTR(rc));
 380
 381         rc = lookup_it_finish(req, 1, it, &icbd);
 382         if (rc != 0) {
 383                 ll_intent_release(it);
 384                 GOTO(out, retval = ERR_PTR(rc));
 385         }
 386
 387         ll_lookup_finish_locks(it, dentry);
 388
 389         if (dentry == save)
 390                 GOTO(out, retval = NULL);
 391         else
 392                 GOTO(out, retval = dentry);
 393  out:
 394         if (req)
 395                 ptlrpc_req_finished(req);
 396         return retval;
 397 }
 398
 399 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 400 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 401                                    struct nameidata *nd)
 402 {
 403         struct dentry *de;
 404         ENTRY;
 405
 406         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 407                 de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags);
 408         else
 409                 de = ll_lookup_it(parent, dentry, NULL, 0);
 410
 411         RETURN(de);
 412 }
 413 #endif
 414
 415 /* We depend on "mode" being set with the proper file type/umask by now */
 416 static struct inode *ll_create_node(struct inode *dir, const char *name,
 417                                     int namelen, const void *data, int datalen,
 418                                     int mode, __u64 extra,
 419                                     struct lookup_intent *it)
 420 {
 421         struct inode *inode = NULL;
 422         struct ptlrpc_request *request = NULL;
 423         struct ll_sb_info *sbi = ll_i2sbi(dir);
 424         int rc;
 425         ENTRY;
 426
 427         LASSERT(it && it->d.lustre.it_disposition);
 428
 429         request = it->d.lustre.it_data;
 430         rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 1, dir->i_sb);
 431         if (rc)
 432                 GOTO(out, inode = ERR_PTR(rc));
 433
 434         LASSERT(list_empty(&inode->i_dentry));
 435
 436         /* We asked for a lock on the directory, but were granted a
 437          * lock on the inode.  Since we finally have an inode pointer,
 438          * stuff it in the lock. */
 439         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 440                inode, inode->i_ino, inode->i_generation);
 441         mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
 442         EXIT;
 443  out:
 444         ptlrpc_req_finished(request);
 445         return inode;
 446 }
 447
 448 /*
 449  * By the time this is called, we already have created the directory cache
 450  * entry for the new file, but it is so far negative - it has no inode.
 451  *
 452  * We defer creating the OBD object(s) until open, to keep the intent and
 453  * non-intent code paths similar, and also because we do not have the MDS
 454  * inode number before calling ll_create_node() (which is needed for LOV),
 455  * so we would need to do yet another RPC to the MDS to store the LOV EA
 456  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 457  * lmm_size in datalen (the MDS still has code which will handle that).
 458  *
 459  * If the create succeeds, we fill in the inode information
 460  * with d_instantiate().
 461  */
 462 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 463                         struct lookup_intent *it)
 464 {
 465         struct inode *inode;
 466         struct ptlrpc_request *request = it->d.lustre.it_data;
 467         int rc = 0;
 468         ENTRY;
 469
 470         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 471                dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
 472                LL_IT2STR(it));
 473
 474         rc = it_open_error(DISP_OPEN_CREATE, it);
 475         if (rc)
 476                 RETURN(rc);
 477
 478         mdc_store_inode_generation(request, 2, 1);
 479         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 480                                NULL, 0, mode, 0, it);
 481         if (IS_ERR(inode)) {
 482                 RETURN(PTR_ERR(inode));
 483         }
 484
 485         d_instantiate(dentry, inode);
 486         RETURN(0);
 487 }
 488
 489 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 490 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 491 {
 492         return ll_create_it(dir, dentry, mode, &nd->intent);
 493 }
 494 #endif
 495
 496 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 497 {
 498         struct ptlrpc_request *request = NULL;
 499         struct inode *dir = nd->dentry->d_inode;
 500         const char *name = nd->last.name;
 501         int len = nd->last.len;
 502         struct ll_sb_info *sbi = ll_i2sbi(dir);
 503         struct mdc_op_data op_data;
 504         int err = -EMLINK;
 505         ENTRY;
 506
 507         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 508                name, dir->i_ino, dir->i_generation, dir);
 509
 510         if (dir->i_nlink >= EXT3_LINK_MAX)
 511                 RETURN(err);
 512
 513         mode &= ~current->fs->umask;
 514
 515         switch (mode & S_IFMT) {
 516         case 0:
 517         case S_IFREG:
 518                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 519         case S_IFCHR:
 520         case S_IFBLK:
 521         case S_IFIFO:
 522         case S_IFSOCK:
 523                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 524                 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 525                                  current->fsuid, current->fsgid,
 526                                  rdev, &request);
 527                 ptlrpc_req_finished(request);
 528                 break;
 529         case S_IFDIR:
 530                 err = -EPERM;
 531                 break;
 532         default:
 533                 err = -EINVAL;
 534         }
 535         RETURN(err);
 536 }
 537
 538 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
 539                     ll_dev_t rdev)
 540 {
 541         struct ptlrpc_request *request = NULL;
 542         struct inode *inode = NULL;
 543         const char *name = child->d_name.name;
 544         int len = child->d_name.len;
 545         struct ll_sb_info *sbi = ll_i2sbi(dir);
 546         struct mdc_op_data op_data;
 547         int err = -EMLINK;
 548         ENTRY;
 549
 550         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 551                name, dir->i_ino, dir->i_generation, dir);
 552
 553         if (dir->i_nlink >= EXT3_LINK_MAX)
 554                 RETURN(err);
 555
 556         mode &= ~current->fs->umask;
 557
 558         switch (mode & S_IFMT) {
 559         case 0:
 560         case S_IFREG:
 561                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 562         case S_IFCHR:
 563         case S_IFBLK:
 564         case S_IFIFO:
 565         case S_IFSOCK:
 566                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 567                 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 568                                  current->fsuid, current->fsgid,
 569                                  rdev, &request);
 570                 err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 0,
 571                                     child->d_sb);
 572                 if (err)
 573                         GOTO(out_err, err);
 574                 break;
 575         case S_IFDIR:
 576                 RETURN(-EPERM);
 577                 break;
 578         default:
 579                 RETURN(-EINVAL);
 580         }
 581
 582         d_instantiate(child, inode);
 583  out_err:
 584         ptlrpc_req_finished(request);
 585         RETURN(err);
 586 }
 587
 588 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 589 {
 590         struct inode *dir = nd->dentry->d_inode;
 591         const char *name = nd->last.name;
 592         int len = nd->last.len;
 593         struct ptlrpc_request *request = NULL;
 594         struct ll_sb_info *sbi = ll_i2sbi(dir);
 595         struct mdc_op_data op_data;
 596         int err = -EMLINK;
 597         ENTRY;
 598
 599         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
 600                name, dir->i_ino, dir->i_generation, dir, tgt);
 601
 602         if (dir->i_nlink >= EXT3_LINK_MAX)
 603                 RETURN(err);
 604
 605         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 606         err = mdc_create(sbi->ll_mdc_exp, &op_data,
 607                          tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 608                          current->fsuid, current->fsgid, 0, &request);
 609         ptlrpc_req_finished(request);
 610         RETURN(err);
 611 }
 612
 613 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 614 {
 615         struct inode *src = srcnd->dentry->d_inode;
 616         struct inode *dir = tgtnd->dentry->d_inode;
 617         const char *name = tgtnd->last.name;
 618         int len = tgtnd->last.len;
 619         struct ptlrpc_request *request = NULL;
 620         struct mdc_op_data op_data;
 621         int err;
 622         struct ll_sb_info *sbi = ll_i2sbi(dir);
 623
 624         ENTRY;
 625         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
 626                src->i_ino, src->i_generation, src,
 627                dir->i_ino, dir->i_generation, dir, name);
 628
 629         ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
 630         err = mdc_link(sbi->ll_mdc_exp, &op_data, &request);
 631         ptlrpc_req_finished(request);
 632
 633         RETURN(err);
 634 }
 635
 636
 637 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 638 {
 639         struct inode *dir = nd->dentry->d_inode;
 640         const char *name = nd->last.name;
 641         int len = nd->last.len;
 642         struct ptlrpc_request *request = NULL;
 643         struct ll_sb_info *sbi = ll_i2sbi(dir);
 644         struct mdc_op_data op_data;
 645         int err = -EMLINK;
 646         ENTRY;
 647         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 648                name, dir->i_ino, dir->i_generation, dir);
 649
 650         if (dir->i_nlink >= EXT3_LINK_MAX)
 651                 RETURN(err);
 652
 653         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 654         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 655         err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 656                          current->fsuid, current->fsgid, 0, &request);
 657         ptlrpc_req_finished(request);
 658         RETURN(err);
 659 }
 660
 661 static int ll_rmdir_raw(struct nameidata *nd)
 662 {
 663         struct inode *dir = nd->dentry->d_inode;
 664         const char *name = nd->last.name;
 665         int len = nd->last.len;
 666         struct ptlrpc_request *request = NULL;
 667         struct mdc_op_data op_data;
 668         int rc;
 669         ENTRY;
 670         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 671                name, dir->i_ino, dir->i_generation, dir);
 672
 673         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
 674         rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 675         ptlrpc_req_finished(request);
 676         RETURN(rc);
 677 }
 678
 679 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
 680 {
 681         struct mds_body *body;
 682         struct lov_mds_md *eadata;
 683         struct lov_stripe_md *lsm = NULL;
 684         struct obd_trans_info oti = { 0 };
 685         struct obdo *oa;
 686         int rc;
 687         ENTRY;
 688
 689         /* req is swabbed so this is safe */
 690         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 691
 692         if (!(body->valid & OBD_MD_FLEASIZE))
 693                 RETURN(0);
 694
 695         if (body->eadatasize == 0) {
 696                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 697                 GOTO(out, rc = -EPROTO);
 698         }
 699
 700         /* The MDS sent back the EA because we unlinked the last reference
 701          * to this file. Use this EA to unlink the objects on the OST.
 702          * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
 703          * check it is complete and sensible. */
 704         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 705         LASSERT(eadata != NULL);
 706         if (eadata == NULL) {
 707                 CERROR("Can't unpack MDS EA data\n");
 708                 GOTO(out, rc = -EPROTO);
 709         }
 710
 711         rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
 712         if (rc < 0) {
 713                 CERROR("obd_unpackmd: %d\n", rc);
 714                 GOTO(out, rc);
 715         }
 716         LASSERT(rc >= sizeof(*lsm));
 717
 718         oa = obdo_alloc();
 719         if (oa == NULL)
 720                 GOTO(out_free_memmd, rc = -ENOMEM);
 721
 722         oa->o_id = lsm->lsm_object_id;
 723         oa->o_mode = body->mode & S_IFMT;
 724         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
 725
 726         if (body->valid & OBD_MD_FLCOOKIE) {
 727                 oa->o_valid |= OBD_MD_FLCOOKIE;
 728                 oti.oti_logcookies =
 729                         lustre_msg_buf(request->rq_repmsg, 2,
 730                                        sizeof(struct llog_cookie) *
 731                                        lsm->lsm_stripe_count);
 732                 if (oti.oti_logcookies == NULL) {
 733                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 734                         body->valid &= ~OBD_MD_FLCOOKIE;
 735                 }
 736         }
 737
 738         rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
 739         obdo_free(oa);
 740         if (rc)
 741                 CERROR("obd destroy objid "LPX64" error %d\n",
 742                        lsm->lsm_object_id, rc);
 743  out_free_memmd:
 744         obd_free_memmd(ll_i2obdexp(dir), &lsm);
 745  out:
 746         return rc;
 747 }
 748
 749 static int ll_unlink_raw(struct nameidata *nd)
 750 {
 751         struct inode *dir = nd->dentry->d_inode;
 752         const char *name = nd->last.name;
 753         int len = nd->last.len;
 754         struct ptlrpc_request *request = NULL;
 755         struct mdc_op_data op_data;
 756         int rc;
 757         ENTRY;
 758         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 759                name, dir->i_ino, dir->i_generation, dir);
 760
 761         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 762         rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 763         if (rc)
 764                 GOTO(out, rc);
 765
 766         rc = ll_objects_destroy(request, dir);
 767  out:
 768         ptlrpc_req_finished(request);
 769         RETURN(rc);
 770 }
 771
 772 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
 773 {
 774         struct inode *src = oldnd->dentry->d_inode;
 775         struct inode *tgt = newnd->dentry->d_inode;
 776         const char *oldname = oldnd->last.name;
 777         int oldlen  = oldnd->last.len;
 778         const char *newname = newnd->last.name;
 779         int newlen  = newnd->last.len;
 780         struct ptlrpc_request *request = NULL;
 781         struct ll_sb_info *sbi = ll_i2sbi(src);
 782         struct mdc_op_data op_data;
 783         int err;
 784         ENTRY;
 785         CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
 786                "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
 787                src, newname, tgt->i_ino, tgt->i_generation, tgt);
 788
 789         ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
 790         err = mdc_rename(sbi->ll_mdc_exp, &op_data,
 791                          oldname, oldlen, newname, newlen, &request);
 792         if (!err) {
 793                 err = ll_objects_destroy(request, src);
 794         }
 795
 796         ptlrpc_req_finished(request);
 797
 798         RETURN(err);
 799 }
 800
 801 struct inode_operations ll_dir_inode_operations = {
 802         .link_raw           = ll_link_raw,
 803         .unlink_raw         = ll_unlink_raw,
 804         .symlink_raw        = ll_symlink_raw,
 805         .mkdir_raw          = ll_mkdir_raw,
 806         .rmdir_raw          = ll_rmdir_raw,
 807         .mknod_raw          = ll_mknod_raw,
 808         .mknod              = ll_mknod,
 809         .rename_raw         = ll_rename_raw,
 810         .setattr            = ll_setattr,
 811         .setattr_raw        = ll_setattr_raw,
 812 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 813         .create_it          = ll_create_it,
 814         .lookup_it          = ll_lookup_it,
 815         .revalidate_it      = ll_inode_revalidate_it,
 816 #else
 817         .lookup             = ll_lookup_nd,
 818         .create             = ll_create_nd,
 819         .getattr_it         = ll_getattr,
 820 #endif
 821 };