lustre/llite/namei.c

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