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 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         ll_frob_intent(&it, &lookup_it);
 355
 356         icbd.icbd_childp = &dentry;
 357         icbd.icbd_parent = parent;
 358         ll_inode2fid(&pfid, parent);
 359         ll_i2uctxt(&ctxt, parent, NULL);
 360
 361         rc = md_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
 362                             dentry->d_name.name, dentry->d_name.len, NULL, 0,
 363                             NULL, it, flags, &req, ll_mdc_blocking_ast);
 364         if (rc < 0)
 365                 GOTO(out, retval = ERR_PTR(rc));
 366
 367         rc = lookup_it_finish(req, 1, it, &icbd);
 368         if (rc != 0) {
 369                 ll_intent_release(it);
 370                 GOTO(out, retval = ERR_PTR(rc));
 371         }
 372
 373         ll_lookup_finish_locks(it, dentry);
 374
 375         if (dentry == save)
 376                 GOTO(out, retval = NULL);
 377         else
 378                 GOTO(out, retval = dentry);
 379  out:
 380         if (req)
 381                 ptlrpc_req_finished(req);
 382         if (dentry->d_inode)
 383                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
 384                                 dentry,
 385                                 (unsigned long) parent->i_ino,
 386                                 (unsigned long) parent->i_generation,
 387                                 dentry->d_name.len, dentry->d_name.name,
 388                                 (unsigned long) dentry->d_inode->i_ino,
 389                                 (unsigned long) dentry->d_inode->i_generation);
 390         else
 391                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
 392                                 dentry,
 393                                 (unsigned long) parent->i_ino,
 394                                 (unsigned long) parent->i_generation,
 395                                 dentry->d_name.len, dentry->d_name.name);
 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, sbi->ll_mdc_exp,
 431                            &inode, request, 1, dir->i_sb);
 432         if (rc)
 433                 GOTO(out, inode = ERR_PTR(rc));
 434
 435         LASSERT(list_empty(&inode->i_dentry));
 436
 437         /* We asked for a lock on the directory, but were granted a
 438          * lock on the inode.  Since we finally have an inode pointer,
 439          * stuff it in the lock. */
 440         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 441                inode, inode->i_ino, inode->i_generation);
 442         mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
 443         EXIT;
 444  out:
 445         ptlrpc_req_finished(request);
 446         return inode;
 447 }
 448
 449 /*
 450  * By the time this is called, we already have created the directory cache
 451  * entry for the new file, but it is so far negative - it has no inode.
 452  *
 453  * We defer creating the OBD object(s) until open, to keep the intent and
 454  * non-intent code paths similar, and also because we do not have the MDS
 455  * inode number before calling ll_create_node() (which is needed for LOV),
 456  * so we would need to do yet another RPC to the MDS to store the LOV EA
 457  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 458  * lmm_size in datalen (the MDS still has code which will handle that).
 459  *
 460  * If the create succeeds, we fill in the inode information
 461  * with d_instantiate().
 462  */
 463 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 464                         struct lookup_intent *it)
 465 {
 466         struct inode *inode;
 467         struct ptlrpc_request *request = it->d.lustre.it_data;
 468         struct obd_export *mdc_exp = ll_i2mdcexp(dir);
 469         int rc = 0;
 470         ENTRY;
 471
 472         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 473                dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
 474                LL_IT2STR(it));
 475
 476         rc = it_open_error(DISP_OPEN_CREATE, it);
 477         if (rc)
 478                 RETURN(rc);
 479
 480         mdc_store_inode_generation(mdc_exp, request, 2, 1);
 481         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 482                                NULL, 0, mode, 0, it);
 483         if (IS_ERR(inode)) {
 484                 RETURN(PTR_ERR(inode));
 485         }
 486
 487         d_instantiate(dentry, inode);
 488         RETURN(0);
 489 }
 490
 491 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 492 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 493 {
 494         return ll_create_it(dir, dentry, mode, &nd->intent);
 495 }
 496 #endif
 497
 498 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 499 {
 500         struct ptlrpc_request *request = NULL;
 501         struct inode *dir = nd->dentry->d_inode;
 502         const char *name = nd->last.name;
 503         int len = nd->last.len;
 504         struct ll_sb_info *sbi = ll_i2sbi(dir);
 505         struct mdc_op_data op_data;
 506         int err = -EMLINK;
 507         ENTRY;
 508
 509         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 510                name, dir->i_ino, dir->i_generation, dir);
 511
 512         if (dir->i_nlink >= EXT3_LINK_MAX)
 513                 RETURN(err);
 514
 515         mode &= ~current->fs->umask;
 516
 517         switch (mode & S_IFMT) {
 518         case 0:
 519         case S_IFREG:
 520                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 521         case S_IFCHR:
 522         case S_IFBLK:
 523         case S_IFIFO:
 524         case S_IFSOCK:
 525                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 526                 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 527                                 current->fsuid, current->fsgid, rdev, &request);
 528                 ptlrpc_req_finished(request);
 529                 break;
 530         case S_IFDIR:
 531                 err = -EPERM;
 532                 break;
 533         default:
 534                 err = -EINVAL;
 535         }
 536         RETURN(err);
 537 }
 538
 539 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
 540                     ll_dev_t rdev)
 541 {
 542         struct ptlrpc_request *request = NULL;
 543         struct inode *inode = NULL;
 544         const char *name = child->d_name.name;
 545         int len = child->d_name.len;
 546         struct ll_sb_info *sbi = ll_i2sbi(dir);
 547         struct mdc_op_data op_data;
 548         int err = -EMLINK;
 549         ENTRY;
 550
 551         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 552                name, dir->i_ino, dir->i_generation, dir);
 553
 554         if (dir->i_nlink >= EXT3_LINK_MAX)
 555                 RETURN(err);
 556
 557         mode &= ~current->fs->umask;
 558
 559         switch (mode & S_IFMT) {
 560         case 0:
 561         case S_IFREG:
 562                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 563         case S_IFCHR:
 564         case S_IFBLK:
 565         case S_IFIFO:
 566         case S_IFSOCK:
 567                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 568                 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 569                                 current->fsuid, current->fsgid, rdev, &request);
 570                 err = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
 571                                     &inode, request, 0, 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 = md_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 = md_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         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 651         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 652         err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 653                         current->fsuid, current->fsgid, 0, &request);
 654         ptlrpc_req_finished(request);
 655         RETURN(err);
 656 }
 657
 658 static int ll_rmdir_raw(struct nameidata *nd)
 659 {
 660         struct inode *dir = nd->dentry->d_inode;
 661         const char *name = nd->last.name;
 662         int len = nd->last.len;
 663         struct ptlrpc_request *request = NULL;
 664         struct mdc_op_data op_data;
 665         int rc;
 666         ENTRY;
 667         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 668                name, dir->i_ino, dir->i_generation, dir);
 669
 670         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
 671         rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 672         ptlrpc_req_finished(request);
 673         RETURN(rc);
 674 }
 675
 676 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
 677 {
 678         struct mds_body *body;
 679         struct lov_mds_md *eadata;
 680         struct lov_stripe_md *lsm = NULL;
 681         struct obd_trans_info oti = { 0 };
 682         struct obdo *oa;
 683         int rc;
 684         ENTRY;
 685
 686         /* req is swabbed so this is safe */
 687         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 688
 689         if (!(body->valid & OBD_MD_FLEASIZE))
 690                 RETURN(0);
 691
 692         if (body->eadatasize == 0) {
 693                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 694                 GOTO(out, rc = -EPROTO);
 695         }
 696
 697         /* The MDS sent back the EA because we unlinked the last reference
 698          * to this file. Use this EA to unlink the objects on the OST.
 699          * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
 700          * check it is complete and sensible. */
 701         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 702         LASSERT(eadata != NULL);
 703         if (eadata == NULL) {
 704                 CERROR("Can't unpack MDS EA data\n");
 705                 GOTO(out, rc = -EPROTO);
 706         }
 707
 708         rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
 709         if (rc < 0) {
 710                 CERROR("obd_unpackmd: %d\n", rc);
 711                 GOTO(out, rc);
 712         }
 713         LASSERT(rc >= sizeof(*lsm));
 714
 715         oa = obdo_alloc();
 716         if (oa == NULL)
 717                 GOTO(out_free_memmd, rc = -ENOMEM);
 718
 719         oa->o_id = lsm->lsm_object_id;
 720         oa->o_gr = lsm->lsm_object_gr;
 721         oa->o_mode = body->mode & S_IFMT;
 722         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
 723
 724         if (body->valid & OBD_MD_FLCOOKIE) {
 725                 oa->o_valid |= OBD_MD_FLCOOKIE;
 726                 oti.oti_logcookies =
 727                         lustre_msg_buf(request->rq_repmsg, 2,
 728                                        sizeof(struct llog_cookie) *
 729                                        lsm->lsm_stripe_count);
 730                 if (oti.oti_logcookies == NULL) {
 731                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 732                         body->valid &= ~OBD_MD_FLCOOKIE;
 733                 }
 734         }
 735
 736         rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
 737         obdo_free(oa);
 738         if (rc)
 739                 CERROR("obd destroy objid "LPX64" error %d\n",
 740                        lsm->lsm_object_id, rc);
 741  out_free_memmd:
 742         obd_free_memmd(ll_i2obdexp(dir), &lsm);
 743  out:
 744         return rc;
 745 }
 746
 747 static int ll_unlink_raw(struct nameidata *nd)
 748 {
 749         struct inode *dir = nd->dentry->d_inode;
 750         const char *name = nd->last.name;
 751         int len = nd->last.len;
 752         struct ptlrpc_request *request = NULL;
 753         struct mdc_op_data op_data;
 754         int rc;
 755         ENTRY;
 756         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 757                name, dir->i_ino, dir->i_generation, dir);
 758
 759         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 760         rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 761         if (rc)
 762                 GOTO(out, rc);
 763
 764         rc = ll_objects_destroy(request, dir);
 765  out:
 766         ptlrpc_req_finished(request);
 767         RETURN(rc);
 768 }
 769
 770 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
 771 {
 772         struct inode *src = oldnd->dentry->d_inode;
 773         struct inode *tgt = newnd->dentry->d_inode;
 774         const char *oldname = oldnd->last.name;
 775         int oldlen  = oldnd->last.len;
 776         const char *newname = newnd->last.name;
 777         int newlen  = newnd->last.len;
 778         struct ptlrpc_request *request = NULL;
 779         struct ll_sb_info *sbi = ll_i2sbi(src);
 780         struct mdc_op_data op_data;
 781         int err;
 782         ENTRY;
 783         CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
 784                "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
 785                src, newname, tgt->i_ino, tgt->i_generation, tgt);
 786
 787         ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
 788         err = md_rename(sbi->ll_mdc_exp, &op_data,
 789                         oldname, oldlen, newname, newlen, &request);
 790         if (!err) {
 791                 err = ll_objects_destroy(request, src);
 792         }
 793
 794         ptlrpc_req_finished(request);
 795
 796         RETURN(err);
 797 }
 798
 799 struct inode_operations ll_dir_inode_operations = {
 800         .link_raw           = ll_link_raw,
 801         .unlink_raw         = ll_unlink_raw,
 802         .symlink_raw        = ll_symlink_raw,
 803         .mkdir_raw          = ll_mkdir_raw,
 804         .rmdir_raw          = ll_rmdir_raw,
 805         .mknod_raw          = ll_mknod_raw,
 806         .mknod              = ll_mknod,
 807         .rename_raw         = ll_rename_raw,
 808         .setattr            = ll_setattr,
 809         .setattr_raw        = ll_setattr_raw,
 810 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 811         .create_it          = ll_create_it,
 812         .lookup_it          = ll_lookup_it,
 813         .revalidate_it      = ll_inode_revalidate_it,
 814 #else
 815         .lookup             = ll_lookup_nd,
 816         .create             = ll_create_nd,
 817         .getattr_it         = ll_getattr,
 818 #endif
 819 };