lustre/llite/namei.c

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