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 (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  80         if (inode->i_ino != md->body->ino)
  81                 return 0;
  82 #endif
  83         if (inode->i_generation != md->body->generation)
  84                 return 0;
  85
  86         /* Apply the attributes in 'opaque' to this inode */
  87         ll_update_inode(inode, md->body, md->lsm);
  88         return 1;
  89 }
  90
  91 extern struct dentry_operations ll_d_ops;
  92
  93 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
  94 {
  95         ENTRY;
  96
  97         ldlm_lock_decref(lockh, mode);
  98
  99         RETURN(0);
 100 }
 101
 102 /* Get an inode by inode number (already instantiated by the intent lookup).
 103  * Returns inode or NULL
 104  */
 105 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 106 int ll_set_inode(struct inode *inode, void *opaque)
 107 {
 108         ll_read_inode2(inode, opaque);
 109         return 0;
 110 }
 111
 112 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 113                       struct lustre_md *md)
 114 {
 115         struct inode *inode;
 116
 117         LASSERT(hash != 0);
 118         inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
 119
 120         if (inode) {
 121                 if (inode->i_state & I_NEW)
 122                         unlock_new_inode(inode);
 123                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 124                        inode->i_generation, inode);
 125         }
 126
 127         return inode;
 128 }
 129 #else
 130 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 131                       struct lustre_md *md)
 132 {
 133         struct inode *inode;
 134         LASSERT(hash != 0);
 135         inode = iget4(sb, hash, ll_test_inode, md);
 136         if (inode)
 137                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 138                        inode->i_generation, inode);
 139         return inode;
 140 }
 141 #endif
 142
 143 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 144                         void *data, int flag)
 145 {
 146         int rc;
 147         struct lustre_handle lockh;
 148         ENTRY;
 149
 150         switch (flag) {
 151         case LDLM_CB_BLOCKING:
 152                 ldlm_lock2handle(lock, &lockh);
 153                 rc = ldlm_cli_cancel(&lockh);
 154                 if (rc < 0) {
 155                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 156                         RETURN(rc);
 157                 }
 158                 break;
 159         case LDLM_CB_CANCELING: {
 160                 struct inode *inode = ll_inode_from_lock(lock);
 161
 162                 /* Invalidate all dentries associated with this inode */
 163                 if (inode == NULL)
 164                         break;
 165
 166                 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
 167                           &(ll_i2info(inode)->lli_flags));
 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                 if (S_ISDIR(inode->i_mode)) {
 175                         CDEBUG(D_INODE, "invalidating inode %lu\n",
 176                                inode->i_ino);
 177
 178                         truncate_inode_pages(inode->i_mapping, 0);
 179                 }
 180
 181                 if (inode->i_sb->s_root &&
 182                     inode != inode->i_sb->s_root->d_inode)
 183                         ll_unhash_aliases(inode);
 184                 iput(inode);
 185                 break;
 186         }
 187         default:
 188                 LBUG();
 189         }
 190
 191         RETURN(0);
 192 }
 193
 194 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
 195                          int flags, void *opaque)
 196 {
 197         struct ldlm_res_id res_id =
 198                 { .name = {inode->i_ino, inode->i_generation} };
 199         struct obd_device *obddev = class_conn2obd(conn);
 200         ENTRY;
 201
 202         RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
 203                                       opaque));
 204 }
 205
 206
 207 void ll_prepare_mdc_op_data(struct mdc_op_data *data, struct inode *i1,
 208                             struct inode *i2, const char *name, int namelen,
 209                             int mode)
 210 {
 211         LASSERT(i1);
 212
 213         ll_i2uctxt(&data->ctxt, i1, i2);
 214         ll_inode2fid(&data->fid1, i1);
 215
 216         if (i2)
 217                 ll_inode2fid(&data->fid2, i2);
 218
 219         data->name = name;
 220         data->namelen = namelen;
 221         data->create_mode = mode;
 222         data->mod_time = LTIME_S(CURRENT_TIME);
 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, &inode, request, offset,
 288                                    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(&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                         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);
 308                         if (rc) {
 309                                 iput(inode);
 310                                 RETURN(rc);
 311                         }
 312                 }
 313
 314                 dentry = *de = ll_find_alias(inode, dentry);
 315         } else {
 316                 ENTRY;
 317         }
 318
 319         dentry->d_op = &ll_d_ops;
 320         ll_set_dd(dentry);
 321
 322         if (dentry == saved)
 323                 d_add(dentry, inode);
 324
 325         RETURN(0);
 326 }
 327
 328
 329 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 330                                    struct lookup_intent *it, int flags)
 331 {
 332         struct dentry *save = dentry, *retval;
 333         struct ll_fid pfid;
 334         struct ll_uctxt ctxt;
 335         struct it_cb_data icbd;
 336         struct ptlrpc_request *req = NULL;
 337         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 338         int rc;
 339         ENTRY;
 340
 341         if (dentry->d_name.len > EXT3_NAME_LEN)
 342                 RETURN(ERR_PTR(-ENAMETOOLONG));
 343
 344         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 345                dentry->d_name.name, parent->i_ino, parent->i_generation,
 346                parent, LL_IT2STR(it));
 347
 348         if (d_mountpoint(dentry))
 349                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
 350
 351         ll_frob_intent(&it, &lookup_it);
 352
 353         icbd.icbd_childp = &dentry;
 354         icbd.icbd_parent = parent;
 355         ll_inode2fid(&pfid, parent);
 356         ll_i2uctxt(&ctxt, parent, NULL);
 357
 358         rc = mdc_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
 359                              dentry->d_name.name, dentry->d_name.len, NULL, 0,
 360                              NULL, it, flags, &req, ll_mdc_blocking_ast);
 361         if (rc < 0)
 362                 GOTO(out, retval = ERR_PTR(rc));
 363
 364         rc = lookup_it_finish(req, 1, it, &icbd);
 365         if (rc != 0) {
 366                 ll_intent_release(it);
 367                 GOTO(out, retval = ERR_PTR(rc));
 368         }
 369
 370         ll_lookup_finish_locks(it, dentry);
 371
 372         if (dentry == save)
 373                 GOTO(out, retval = NULL);
 374         else
 375                 GOTO(out, retval = dentry);
 376  out:
 377         if (req)
 378                 ptlrpc_req_finished(req);
 379         return retval;
 380 }
 381
 382 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 383 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 384                                    struct nameidata *nd)
 385 {
 386         struct dentry *de;
 387         ENTRY;
 388
 389         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 390                 de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags);
 391         else
 392                 de = ll_lookup_it(parent, dentry, NULL, 0);
 393
 394         RETURN(de);
 395 }
 396 #endif
 397
 398 /* We depend on "mode" being set with the proper file type/umask by now */
 399 static struct inode *ll_create_node(struct inode *dir, const char *name,
 400                                     int namelen, const void *data, int datalen,
 401                                     int mode, __u64 extra,
 402                                     struct lookup_intent *it)
 403 {
 404         struct inode *inode = NULL;
 405         struct ptlrpc_request *request = NULL;
 406         struct ll_sb_info *sbi = ll_i2sbi(dir);
 407         int rc;
 408         ENTRY;
 409
 410         LASSERT(it && it->d.lustre.it_disposition);
 411
 412         request = it->d.lustre.it_data;
 413         rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 1, dir->i_sb);
 414         if (rc)
 415                 GOTO(out, inode = ERR_PTR(rc));
 416
 417         LASSERT(list_empty(&inode->i_dentry));
 418
 419         /* We asked for a lock on the directory, but were granted a
 420          * lock on the inode.  Since we finally have an inode pointer,
 421          * stuff it in the lock. */
 422         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 423                inode, inode->i_ino, inode->i_generation);
 424         mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
 425         EXIT;
 426  out:
 427         ptlrpc_req_finished(request);
 428         return inode;
 429 }
 430
 431 /*
 432  * By the time this is called, we already have created the directory cache
 433  * entry for the new file, but it is so far negative - it has no inode.
 434  *
 435  * We defer creating the OBD object(s) until open, to keep the intent and
 436  * non-intent code paths similar, and also because we do not have the MDS
 437  * inode number before calling ll_create_node() (which is needed for LOV),
 438  * so we would need to do yet another RPC to the MDS to store the LOV EA
 439  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 440  * lmm_size in datalen (the MDS still has code which will handle that).
 441  *
 442  * If the create succeeds, we fill in the inode information
 443  * with d_instantiate().
 444  */
 445 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 446                         struct lookup_intent *it)
 447 {
 448         struct inode *inode;
 449         struct ptlrpc_request *request = it->d.lustre.it_data;
 450         int rc = 0;
 451         ENTRY;
 452
 453         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 454                dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
 455                LL_IT2STR(it));
 456
 457         rc = it_open_error(DISP_OPEN_CREATE, it);
 458         if (rc)
 459                 RETURN(rc);
 460
 461         mdc_store_inode_generation(request, 2, 1);
 462         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 463                                NULL, 0, mode, 0, it);
 464         if (IS_ERR(inode)) {
 465                 RETURN(PTR_ERR(inode));
 466         }
 467
 468         d_instantiate(dentry, inode);
 469         RETURN(0);
 470 }
 471
 472 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 473 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 474 {
 475         return ll_create_it(dir, dentry, mode, &nd->intent);
 476 }
 477 #endif
 478
 479 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 480 {
 481         struct ptlrpc_request *request = NULL;
 482         struct inode *dir = nd->dentry->d_inode;
 483         const char *name = nd->last.name;
 484         int len = nd->last.len;
 485         struct ll_sb_info *sbi = ll_i2sbi(dir);
 486         struct mdc_op_data op_data;
 487         int err = -EMLINK;
 488         ENTRY;
 489
 490         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 491                name, dir->i_ino, dir->i_generation, dir);
 492
 493         if (dir->i_nlink >= EXT3_LINK_MAX)
 494                 RETURN(err);
 495
 496         mode &= ~current->fs->umask;
 497
 498         switch (mode & S_IFMT) {
 499         case 0:
 500         case S_IFREG:
 501                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 502         case S_IFCHR:
 503         case S_IFBLK:
 504         case S_IFIFO:
 505         case S_IFSOCK:
 506                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 507                 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 508                                  current->fsuid, current->fsgid,
 509                                  rdev, &request);
 510                 ptlrpc_req_finished(request);
 511                 break;
 512         case S_IFDIR:
 513                 err = -EPERM;
 514                 break;
 515         default:
 516                 err = -EINVAL;
 517         }
 518         RETURN(err);
 519 }
 520
 521 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
 522                     ll_dev_t rdev)
 523 {
 524         struct ptlrpc_request *request = NULL;
 525         struct inode *inode = NULL;
 526         const char *name = child->d_name.name;
 527         int len = child->d_name.len;
 528         struct ll_sb_info *sbi = ll_i2sbi(dir);
 529         struct mdc_op_data op_data;
 530         int err = -EMLINK;
 531         ENTRY;
 532
 533         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 534                name, dir->i_ino, dir->i_generation, dir);
 535
 536         if (dir->i_nlink >= EXT3_LINK_MAX)
 537                 RETURN(err);
 538
 539         mode &= ~current->fs->umask;
 540
 541         switch (mode & S_IFMT) {
 542         case 0:
 543         case S_IFREG:
 544                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 545         case S_IFCHR:
 546         case S_IFBLK:
 547         case S_IFIFO:
 548         case S_IFSOCK:
 549                 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 550                 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 551                                  current->fsuid, current->fsgid,
 552                                  rdev, &request);
 553                 err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 0,
 554                                     child->d_sb);
 555                 if (err)
 556                         GOTO(out_err, err);
 557                 break;
 558         case S_IFDIR:
 559                 RETURN(-EPERM);
 560                 break;
 561         default:
 562                 RETURN(-EINVAL);
 563         }
 564
 565         d_instantiate(child, inode);
 566  out_err:
 567         ptlrpc_req_finished(request);
 568         RETURN(err);
 569 }
 570
 571 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 572 {
 573         struct inode *dir = nd->dentry->d_inode;
 574         const char *name = nd->last.name;
 575         int len = nd->last.len;
 576         struct ptlrpc_request *request = NULL;
 577         struct ll_sb_info *sbi = ll_i2sbi(dir);
 578         struct mdc_op_data op_data;
 579         int err = -EMLINK;
 580         ENTRY;
 581
 582         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
 583                name, dir->i_ino, dir->i_generation, dir, tgt);
 584
 585         if (dir->i_nlink >= EXT3_LINK_MAX)
 586                 RETURN(err);
 587
 588         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 589         err = mdc_create(sbi->ll_mdc_exp, &op_data,
 590                          tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 591                          current->fsuid, current->fsgid, 0, &request);
 592         ptlrpc_req_finished(request);
 593         RETURN(err);
 594 }
 595
 596 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 597 {
 598         struct inode *src = srcnd->dentry->d_inode;
 599         struct inode *dir = tgtnd->dentry->d_inode;
 600         const char *name = tgtnd->last.name;
 601         int len = tgtnd->last.len;
 602         struct ptlrpc_request *request = NULL;
 603         struct mdc_op_data op_data;
 604         int err;
 605         struct ll_sb_info *sbi = ll_i2sbi(dir);
 606
 607         ENTRY;
 608         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
 609                src->i_ino, src->i_generation, src,
 610                dir->i_ino, dir->i_generation, dir, name);
 611
 612         ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
 613         err = mdc_link(sbi->ll_mdc_exp, &op_data, &request);
 614         ptlrpc_req_finished(request);
 615
 616         RETURN(err);
 617 }
 618
 619
 620 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 621 {
 622         struct inode *dir = nd->dentry->d_inode;
 623         const char *name = nd->last.name;
 624         int len = nd->last.len;
 625         struct ptlrpc_request *request = NULL;
 626         struct ll_sb_info *sbi = ll_i2sbi(dir);
 627         struct mdc_op_data op_data;
 628         int err = -EMLINK;
 629         ENTRY;
 630         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 631                name, dir->i_ino, dir->i_generation, dir);
 632
 633         if (dir->i_nlink >= EXT3_LINK_MAX)
 634                 RETURN(err);
 635
 636         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 637         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 638         err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
 639                          current->fsuid, current->fsgid, 0, &request);
 640         ptlrpc_req_finished(request);
 641         RETURN(err);
 642 }
 643
 644 static int ll_rmdir_raw(struct nameidata *nd)
 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 mdc_op_data op_data;
 651         int rc;
 652         ENTRY;
 653         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 654                name, dir->i_ino, dir->i_generation, dir);
 655
 656         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
 657         rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 658         ptlrpc_req_finished(request);
 659         RETURN(rc);
 660 }
 661
 662 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
 663 {
 664         struct mds_body *body;
 665         struct lov_mds_md *eadata;
 666         struct lov_stripe_md *lsm = NULL;
 667         struct obd_trans_info oti = { 0 };
 668         struct obdo *oa;
 669         int rc;
 670         ENTRY;
 671
 672         /* req is swabbed so this is safe */
 673         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 674
 675         if (!(body->valid & OBD_MD_FLEASIZE))
 676                 RETURN(0);
 677
 678         if (body->eadatasize == 0) {
 679                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 680                 GOTO(out, rc = -EPROTO);
 681         }
 682
 683         /* The MDS sent back the EA because we unlinked the last reference
 684          * to this file. Use this EA to unlink the objects on the OST.
 685          * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
 686          * check it is complete and sensible. */
 687         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 688         LASSERT(eadata != NULL);
 689         if (eadata == NULL) {
 690                 CERROR("Can't unpack MDS EA data\n");
 691                 GOTO(out, rc = -EPROTO);
 692         }
 693
 694         rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
 695         if (rc < 0) {
 696                 CERROR("obd_unpackmd: %d\n", rc);
 697                 GOTO(out, rc);
 698         }
 699         LASSERT(rc >= sizeof(*lsm));
 700
 701         oa = obdo_alloc();
 702         if (oa == NULL)
 703                 GOTO(out_free_memmd, rc = -ENOMEM);
 704
 705         oa->o_id = lsm->lsm_object_id;
 706         oa->o_mode = body->mode & S_IFMT;
 707         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
 708
 709         if (body->valid & OBD_MD_FLCOOKIE) {
 710                 oa->o_valid |= OBD_MD_FLCOOKIE;
 711                 oti.oti_logcookies =
 712                         lustre_msg_buf(request->rq_repmsg, 2,
 713                                        sizeof(struct llog_cookie) *
 714                                        lsm->lsm_stripe_count);
 715                 if (oti.oti_logcookies == NULL) {
 716                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 717                         body->valid &= ~OBD_MD_FLCOOKIE;
 718                 }
 719         }
 720
 721         rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
 722         obdo_free(oa);
 723         if (rc)
 724                 CERROR("obd destroy objid "LPX64" error %d\n",
 725                        lsm->lsm_object_id, rc);
 726  out_free_memmd:
 727         obd_free_memmd(ll_i2obdexp(dir), &lsm);
 728  out:
 729         return rc;
 730 }
 731
 732 static int ll_unlink_raw(struct nameidata *nd)
 733 {
 734         struct inode *dir = nd->dentry->d_inode;
 735         const char *name = nd->last.name;
 736         int len = nd->last.len;
 737         struct ptlrpc_request *request = NULL;
 738         struct mdc_op_data op_data;
 739         int rc;
 740         ENTRY;
 741         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 742                name, dir->i_ino, dir->i_generation, dir);
 743
 744         ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
 745         rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
 746         if (rc)
 747                 GOTO(out, rc);
 748
 749         rc = ll_objects_destroy(request, dir);
 750  out:
 751         ptlrpc_req_finished(request);
 752         RETURN(rc);
 753 }
 754
 755 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
 756 {
 757         struct inode *src = oldnd->dentry->d_inode;
 758         struct inode *tgt = newnd->dentry->d_inode;
 759         const char *oldname = oldnd->last.name;
 760         int oldlen  = oldnd->last.len;
 761         const char *newname = newnd->last.name;
 762         int newlen  = newnd->last.len;
 763         struct ptlrpc_request *request = NULL;
 764         struct ll_sb_info *sbi = ll_i2sbi(src);
 765         struct mdc_op_data op_data;
 766         int err;
 767         ENTRY;
 768         CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
 769                "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
 770                src, newname, tgt->i_ino, tgt->i_generation, tgt);
 771
 772         ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
 773         err = mdc_rename(sbi->ll_mdc_exp, &op_data,
 774                          oldname, oldlen, newname, newlen, &request);
 775         if (!err) {
 776                 err = ll_objects_destroy(request, src);
 777         }
 778
 779         ptlrpc_req_finished(request);
 780
 781         RETURN(err);
 782 }
 783
 784 struct inode_operations ll_dir_inode_operations = {
 785         .link_raw           = ll_link_raw,
 786         .unlink_raw         = ll_unlink_raw,
 787         .symlink_raw        = ll_symlink_raw,
 788         .mkdir_raw          = ll_mkdir_raw,
 789         .rmdir_raw          = ll_rmdir_raw,
 790         .mknod_raw          = ll_mknod_raw,
 791         .mknod              = ll_mknod,
 792         .rename_raw         = ll_rename_raw,
 793         .setattr            = ll_setattr,
 794         .setattr_raw        = ll_setattr_raw,
 795 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 796         .create_it          = ll_create_it,
 797         .lookup_it          = ll_lookup_it,
 798         .revalidate_it      = ll_inode_revalidate_it,
 799 #else
 800         .lookup             = ll_lookup_nd,
 801         .create             = ll_create_nd,
 802         .getattr_it         = ll_getattr,
 803 #endif
 804 };