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