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