lustre/llite/namei.c

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