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 == id_ino(&md->body->id1) &&
  64             last_gen == id_gen(&md->body->id1) &&
  65             last_count < 500) {
  66                 last_count++;
  67         } else {
  68                 if (last_count > 1)
  69                         CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
  70                                last_ino, last_gen, last_count);
  71                 last_count = 0;
  72                 last_ino = id_ino(&md->body->id1);
  73                 last_gen = id_gen(&md->body->id1);
  74                 CDEBUG(D_VFSTRACE,
  75                        "comparing inode %p ino "DLID4" to body "DLID4"\n",
  76                        inode, OLID4(&ll_i2info(inode)->lli_id),
  77                        OLID4(&md->body->id1));
  78         }
  79
  80 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  81         if (inode->i_ino != id_ino(&md->body->id1))
  82                 return 0;
  83 #endif
  84         if (inode->i_generation != id_gen(&md->body->id1))
  85                 return 0;
  86
  87         if (id_group(&ll_i2info(inode)->lli_id) != id_group(&md->body->id1))
  88                 return 0;
  89
  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 /*
 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                 struct ll_inode_info *li = ll_i2info(inode);
 167                 __u64 bits = lock->l_policy_data.l_inodebits.bits;
 168
 169                 /* For lookup locks: Invalidate all dentries associated with
 170                    this inode, for UPDATE locks - invalidate directory pages */
 171                 if (inode == NULL)
 172                         break;
 173
 174                 if (bits & MDS_INODELOCK_UPDATE)
 175                         clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
 176                                   &(ll_i2info(inode)->lli_flags));
 177
 178
 179                 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
 180                     lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
 181                         LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
 182                                    (unsigned long)id_fid(&li->lli_id),
 183                                    (unsigned long)id_group(&li->lli_id));
 184                 }
 185
 186                 /* If lookup lock is cancelled, we just drop the dentry and
 187                    this will cause us to reget data from MDS when we'd want to
 188                    access this dentry/inode again. If this is lock on
 189                    other parts of inode that is cancelled, we do not need to do
 190                    much (but need to discard data from readdir, if any), since
 191                    abscence of lock will cause ll_revalidate_it (called from
 192                    stat() and similar functions) to renew the data anyway */
 193                 if (S_ISDIR(inode->i_mode) &&
 194                     (bits & MDS_INODELOCK_UPDATE)) {
 195                         CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
 196                                inode->i_ino, inode->i_generation, inode);
 197                         truncate_inode_pages(inode->i_mapping, 0);
 198                 }
 199
 200                 if (inode->i_sb->s_root &&
 201                     inode != inode->i_sb->s_root->d_inode &&
 202                     (bits & MDS_INODELOCK_LOOKUP))
 203                         ll_unhash_aliases(inode);
 204                 iput(inode);
 205                 break;
 206         }
 207         default:
 208                 LBUG();
 209         }
 210
 211         RETURN(0);
 212 }
 213
 214 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
 215                          int flags, void *opaque)
 216 {
 217         struct ll_inode_info *li = ll_i2info(inode);
 218         struct ldlm_res_id res_id =
 219                 { .name = {id_fid(&li->lli_id), id_group(&li->lli_id)} };
 220         struct obd_device *obddev = class_conn2obd(conn);
 221         ENTRY;
 222
 223         RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
 224                                       opaque));
 225 }
 226
 227 /* Search "inode"'s alias list for a dentry that has the same name and parent as
 228  * de.  If found, return it.  If not found, return de. */
 229 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
 230 {
 231         struct list_head *tmp;
 232
 233         spin_lock(&dcache_lock);
 234         list_for_each(tmp, &inode->i_dentry) {
 235                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 236
 237                 /* We are called here with 'de' already on the aliases list. */
 238                 if (dentry == de) {
 239                         CERROR("whoops\n");
 240                         continue;
 241                 }
 242
 243                 if (dentry->d_parent != de->d_parent)
 244                         continue;
 245
 246                 if (dentry->d_name.len != de->d_name.len)
 247                         continue;
 248
 249                 if (memcmp(dentry->d_name.name, de->d_name.name,
 250                            de->d_name.len) != 0)
 251                         continue;
 252
 253                 if (!list_empty(&dentry->d_lru))
 254                         list_del_init(&dentry->d_lru);
 255
 256                 hlist_del_init(&dentry->d_hash);
 257                 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
 258                 spin_unlock(&dcache_lock);
 259                 atomic_inc(&dentry->d_count);
 260                 iput(inode);
 261                 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
 262                 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
 263                        "refc %d\n", de->d_name.len, de->d_name.name, de,
 264                        de->d_parent, de->d_inode, atomic_read(&de->d_count));
 265                 return dentry;
 266         }
 267
 268         spin_unlock(&dcache_lock);
 269
 270         return de;
 271 }
 272
 273 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
 274                             struct lookup_intent *it, void *data)
 275 {
 276         struct it_cb_data *icbd = data;
 277         struct dentry **de = icbd->icbd_childp;
 278         struct inode *parent = icbd->icbd_parent;
 279         struct ll_sb_info *sbi = ll_i2sbi(parent);
 280         struct dentry *dentry = *de, *saved = *de;
 281         struct inode *inode = NULL;
 282         int rc;
 283
 284         /* NB 1 request reference will be taken away by ll_intent_lock()
 285          * when I return */
 286         if (!it_disposition(it, DISP_LOOKUP_NEG)) {
 287                 ENTRY;
 288
 289                 rc = ll_prep_inode(sbi->ll_lov_exp, sbi->ll_lmv_exp,
 290                                    &inode, request, offset, dentry->d_sb);
 291                 if (rc)
 292                         RETURN(rc);
 293
 294                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 295                        inode, inode->i_ino, inode->i_generation);
 296                 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
 297
 298                 /* If this is a stat, get the authoritative file size */
 299                 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
 300                     ll_i2info(inode)->lli_smd != NULL) {
 301                         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
 302                         ldlm_error_t rc;
 303
 304                         LASSERT(lsm->lsm_object_id != 0);
 305
 306                         /* bug 2334: drop MDS lock before acquiring OST lock */
 307                         ll_intent_drop_lock(it);
 308
 309                         rc = ll_glimpse_size(inode);
 310                         if (rc) {
 311                                 iput(inode);
 312                                 RETURN(rc);
 313                         }
 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         RETURN(0);
 328 }
 329
 330 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 331                                    struct nameidata *nd, struct lookup_intent *it,
 332                                    int flags)
 333 {
 334         struct dentry *save = dentry, *retval;
 335         struct lustre_id pid;
 336         struct it_cb_data icbd;
 337         struct ptlrpc_request *req = NULL;
 338         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 339         int rc;
 340         ENTRY;
 341
 342         if (dentry->d_name.len > EXT3_NAME_LEN)
 343                 RETURN(ERR_PTR(-ENAMETOOLONG));
 344
 345         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 346                dentry->d_name.name, parent->i_ino, parent->i_generation,
 347                parent, LL_IT2STR(it));
 348
 349         if (d_mountpoint(dentry))
 350                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
 351
 352         if (nd != NULL)
 353                 nd->mnt->mnt_last_used = jiffies;
 354
 355         ll_frob_intent(&it, &lookup_it);
 356
 357         icbd.icbd_childp = &dentry;
 358         icbd.icbd_parent = parent;
 359         ll_inode2id(&pid, parent);
 360
 361         rc = md_intent_lock(ll_i2lmvexp(parent), &pid,
 362                             dentry->d_name.name, dentry->d_name.len, NULL, 0,
 363                             NULL, it, flags, &req, ll_mdc_blocking_ast);
 364         if (rc < 0)
 365                 GOTO(out, retval = ERR_PTR(rc));
 366
 367         rc = lookup_it_finish(req, 1, it, &icbd);
 368         if (rc != 0) {
 369                 ll_intent_release(it);
 370                 GOTO(out, retval = ERR_PTR(rc));
 371         }
 372
 373         ll_lookup_finish_locks(it, dentry);
 374
 375         if (nd &&
 376             dentry->d_inode != NULL && dentry->d_inode->i_mode & S_ISUID &&
 377             S_ISDIR(dentry->d_inode->i_mode) &&
 378             (flags & LOOKUP_CONTINUE || (it->it_op & (IT_CHDIR | IT_OPEN))))
 379                 ll_dir_process_mount_object(dentry, nd->mnt);
 380
 381         if (dentry == save)
 382                 GOTO(out, retval = NULL);
 383         else
 384                 GOTO(out, retval = dentry);
 385  out:
 386         if (req)
 387                 ptlrpc_req_finished(req);
 388         if (dentry->d_inode)
 389                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
 390                        dentry,
 391                        (unsigned long) parent->i_ino,
 392                        (unsigned long) parent->i_generation,
 393                        dentry->d_name.len, dentry->d_name.name,
 394                        (unsigned long) dentry->d_inode->i_ino,
 395                        (unsigned long) dentry->d_inode->i_generation);
 396         else
 397                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
 398                        dentry,
 399                        (unsigned long) parent->i_ino,
 400                        (unsigned long) parent->i_generation,
 401                        dentry->d_name.len, dentry->d_name.name);
 402         return retval;
 403 }
 404
 405 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 406 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 407                                    struct nameidata *nd)
 408 {
 409         struct dentry *de;
 410         ENTRY;
 411
 412         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 413                 de = ll_lookup_it(parent, dentry, nd, &nd->intent, nd->flags);
 414         else
 415                 de = ll_lookup_it(parent, dentry, nd, NULL, 0);
 416
 417         RETURN(de);
 418 }
 419 #endif
 420
 421 /* We depend on "mode" being set with the proper file type/umask by now */
 422 static struct inode *ll_create_node(struct inode *dir, const char *name,
 423                                     int namelen, const void *data, int datalen,
 424                                     int mode, __u64 extra,
 425                                     struct lookup_intent *it)
 426 {
 427         struct inode *inode = NULL;
 428         struct ptlrpc_request *request = NULL;
 429         struct ll_sb_info *sbi = ll_i2sbi(dir);
 430         int rc;
 431         ENTRY;
 432
 433         LASSERT(it && it->d.lustre.it_disposition);
 434
 435         request = it->d.lustre.it_data;
 436         rc = ll_prep_inode(sbi->ll_lov_exp, sbi->ll_lmv_exp,
 437                            &inode, request, 1, dir->i_sb);
 438         if (rc)
 439                 GOTO(out, inode = ERR_PTR(rc));
 440
 441         LASSERT(list_empty(&inode->i_dentry));
 442
 443         /* We asked for a lock on the directory, but were granted a
 444          * lock on the inode.  Since we finally have an inode pointer,
 445          * stuff it in the lock. */
 446         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 447                inode, inode->i_ino, inode->i_generation);
 448         mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
 449         EXIT;
 450  out:
 451         ptlrpc_req_finished(request);
 452         return inode;
 453 }
 454
 455 /*
 456  * By the time this is called, we already have created the directory cache
 457  * entry for the new file, but it is so far negative - it has no inode.
 458  *
 459  * We defer creating the OBD object(s) until open, to keep the intent and
 460  * non-intent code paths similar, and also because we do not have the MDS
 461  * inode number before calling ll_create_node() (which is needed for LOV),
 462  * so we would need to do yet another RPC to the MDS to store the LOV EA
 463  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 464  * lmm_size in datalen (the MDS still has code which will handle that).
 465  *
 466  * If the create succeeds, we fill in the inode information
 467  * with d_instantiate().
 468  */
 469 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 470                         struct lookup_intent *it)
 471 {
 472         struct inode *inode;
 473         struct ptlrpc_request *request = it->d.lustre.it_data;
 474         struct obd_export *lmv_exp = ll_i2lmvexp(dir);
 475         int rc = 0;
 476         ENTRY;
 477
 478         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
 479                dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
 480                LL_IT2STR(it));
 481
 482         rc = it_open_error(DISP_OPEN_CREATE, it);
 483         if (rc)
 484                 RETURN(rc);
 485
 486         mdc_store_inode_generation(lmv_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
 487         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 488                                NULL, 0, mode, 0, it);
 489         if (IS_ERR(inode))
 490                 RETURN(PTR_ERR(inode));
 491
 492         d_instantiate(dentry, inode);
 493         RETURN(0);
 494 }
 495
 496 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 497 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 498 {
 499         return ll_create_it(dir, dentry, mode, &nd->intent);
 500 }
 501 #endif
 502
 503 static void ll_update_times(struct ptlrpc_request *request, int offset,
 504                             struct inode *inode)
 505 {
 506         struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
 507                                                sizeof(*body));
 508         LASSERT(body);
 509
 510         if (body->valid & OBD_MD_FLMTIME &&
 511             body->mtime > LTIME_S(inode->i_mtime)) {
 512                 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
 513                        inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
 514                 LTIME_S(inode->i_mtime) = body->mtime;
 515         }
 516         if (body->valid & OBD_MD_FLCTIME &&
 517             body->ctime > LTIME_S(inode->i_ctime))
 518                 LTIME_S(inode->i_ctime) = body->ctime;
 519 }
 520
 521 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 522 {
 523         struct ptlrpc_request *request = NULL;
 524         struct inode *dir = nd->dentry->d_inode;
 525         const char *name = nd->last.name;
 526         int len = nd->last.len;
 527         struct ll_sb_info *sbi = ll_i2sbi(dir);
 528         struct mdc_op_data op_data;
 529         int err = -EMLINK;
 530         ENTRY;
 531
 532         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 533                name, dir->i_ino, dir->i_generation, dir);
 534
 535         if (dir->i_nlink >= EXT3_LINK_MAX)
 536                 RETURN(err);
 537
 538         mode &= ~current->fs->umask;
 539
 540         switch (mode & S_IFMT) {
 541         case 0:
 542         case S_IFREG:
 543                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 544         case S_IFCHR:
 545         case S_IFBLK:
 546         case S_IFIFO:
 547         case S_IFSOCK:
 548                 ll_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
 549                 err = md_create(sbi->ll_lmv_exp, &op_data, NULL, 0, mode,
 550                                 current->fsuid, current->fsgid, rdev, &request);
 551                 if (err == 0)
 552                         ll_update_times(request, 0, dir);
 553                 ptlrpc_req_finished(request);
 554                 break;
 555         case S_IFDIR:
 556                 err = -EPERM;
 557                 break;
 558         default:
 559                 err = -EINVAL;
 560         }
 561         RETURN(err);
 562 }
 563
 564 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
 565                     ll_dev_t rdev)
 566 {
 567         struct ptlrpc_request *request = NULL;
 568         struct inode *inode = NULL;
 569         const char *name = child->d_name.name;
 570         int len = child->d_name.len;
 571         struct ll_sb_info *sbi = ll_i2sbi(dir);
 572         struct mdc_op_data op_data;
 573         int err = -EMLINK;
 574         ENTRY;
 575
 576         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 577                name, dir->i_ino, dir->i_generation, dir);
 578
 579         if (dir->i_nlink >= EXT3_LINK_MAX)
 580                 RETURN(err);
 581
 582         mode &= ~current->fs->umask;
 583
 584         switch (mode & S_IFMT) {
 585         case 0:
 586         case S_IFREG:
 587                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 588         case S_IFCHR:
 589         case S_IFBLK:
 590         case S_IFIFO:
 591         case S_IFSOCK:
 592                 ll_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
 593                 err = md_create(sbi->ll_lmv_exp, &op_data, NULL, 0, mode,
 594                                 current->fsuid, current->fsgid, rdev, &request);
 595                 if (err)
 596                         GOTO(out_err, err);
 597
 598                 ll_update_times(request, 0, dir);
 599
 600                 err = ll_prep_inode(sbi->ll_lov_exp, sbi->ll_lmv_exp,
 601                                     &inode, request, 0, child->d_sb);
 602                 if (err)
 603                         GOTO(out_err, err);
 604                 break;
 605         case S_IFDIR:
 606                 RETURN(-EPERM);
 607                 break;
 608         default:
 609                 RETURN(-EINVAL);
 610         }
 611
 612         d_instantiate(child, inode);
 613  out_err:
 614         ptlrpc_req_finished(request);
 615         RETURN(err);
 616 }
 617
 618 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 619 {
 620         struct inode *dir = nd->dentry->d_inode;
 621         const char *name = nd->last.name;
 622         int len = nd->last.len;
 623         struct ptlrpc_request *request = NULL;
 624         struct ll_sb_info *sbi = ll_i2sbi(dir);
 625         struct mdc_op_data op_data;
 626         int err = -EMLINK;
 627         ENTRY;
 628
 629         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
 630                name, dir->i_ino, dir->i_generation, dir, tgt);
 631
 632         if (dir->i_nlink >= EXT3_LINK_MAX)
 633                 RETURN(err);
 634
 635         ll_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
 636         err = md_create(sbi->ll_lmv_exp, &op_data,
 637                         tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 638                         current->fsuid, current->fsgid, 0, &request);
 639         if (err == 0)
 640                 ll_update_times(request, 0, dir);
 641
 642         ptlrpc_req_finished(request);
 643         RETURN(err);
 644 }
 645
 646 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 647 {
 648         struct inode *src = srcnd->dentry->d_inode;
 649         struct inode *dir = tgtnd->dentry->d_inode;
 650         const char *name = tgtnd->last.name;
 651         int len = tgtnd->last.len;
 652         struct ptlrpc_request *request = NULL;
 653         struct mdc_op_data op_data;
 654         int err;
 655         struct ll_sb_info *sbi = ll_i2sbi(dir);
 656
 657         ENTRY;
 658         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
 659                src->i_ino, src->i_generation, src,
 660                dir->i_ino, dir->i_generation, dir, name);
 661
 662         ll_prepare_mdc_data(&op_data, src, dir, name, len, 0);
 663         err = md_link(sbi->ll_lmv_exp, &op_data, &request);
 664         if (err == 0)
 665                 ll_update_times(request, 0, dir);
 666         ptlrpc_req_finished(request);
 667         RETURN(err);
 668 }
 669
 670
 671 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 672 {
 673         struct inode *dir = nd->dentry->d_inode;
 674         const char *name = nd->last.name;
 675         int len = nd->last.len;
 676         struct ptlrpc_request *request = NULL;
 677         struct ll_sb_info *sbi = ll_i2sbi(dir);
 678         struct mdc_op_data op_data;
 679         int err = -EMLINK;
 680         ENTRY;
 681         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 682                name, dir->i_ino, dir->i_generation, dir);
 683
 684         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 685         ll_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
 686         err = md_create(sbi->ll_lmv_exp, &op_data, NULL, 0, mode,
 687                         current->fsuid, current->fsgid, 0, &request);
 688         if (err == 0)
 689                 ll_update_times(request, 0, dir);
 690         ptlrpc_req_finished(request);
 691         RETURN(err);
 692 }
 693
 694 static int ll_rmdir_raw(struct nameidata *nd)
 695 {
 696         struct inode *dir = nd->dentry->d_inode;
 697         const char *name = nd->last.name;
 698         int len = nd->last.len;
 699         struct ptlrpc_request *request = NULL;
 700         struct mdc_op_data op_data;
 701         int rc;
 702         ENTRY;
 703         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 704                name, dir->i_ino, dir->i_generation, dir);
 705
 706         ll_prepare_mdc_data(&op_data, dir, NULL, name, len, S_IFDIR);
 707         rc = md_unlink(ll_i2sbi(dir)->ll_lmv_exp, &op_data, &request);
 708         if (rc == 0)
 709                 ll_update_times(request, 0, dir);
 710         ptlrpc_req_finished(request);
 711         RETURN(rc);
 712 }
 713
 714 int ll_objects_destroy(struct ptlrpc_request *request,
 715                        struct inode *dir, int offset)
 716 {
 717         struct mds_body *body;
 718         struct lov_mds_md *eadata;
 719         struct lov_stripe_md *lsm = NULL;
 720         struct obd_trans_info oti = { 0 };
 721         struct obdo *oa;
 722         int rc;
 723         ENTRY;
 724
 725         /* req is swabbed so this is safe */
 726         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 727
 728         if (!(body->valid & OBD_MD_FLEASIZE))
 729                 RETURN(0);
 730
 731         if (body->eadatasize == 0) {
 732                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 733                 GOTO(out, rc = -EPROTO);
 734         }
 735
 736         /* The MDS sent back the EA because we unlinked the last reference
 737          * to this file. Use this EA to unlink the objects on the OST.
 738          * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
 739          * check it is complete and sensible. */
 740         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 741         LASSERT(eadata != NULL);
 742         if (eadata == NULL) {
 743                 CERROR("Can't unpack MDS EA data\n");
 744                 GOTO(out, rc = -EPROTO);
 745         }
 746
 747         rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
 748         if (rc < 0) {
 749                 CERROR("obd_unpackmd: %d\n", rc);
 750                 GOTO(out, rc);
 751         }
 752         LASSERT(rc >= sizeof(*lsm));
 753
 754         oa = obdo_alloc();
 755         if (oa == NULL)
 756                 GOTO(out_free_memmd, rc = -ENOMEM);
 757
 758         oa->o_id = lsm->lsm_object_id;
 759         oa->o_gr = lsm->lsm_object_gr;
 760         oa->o_mode = body->mode & S_IFMT;
 761         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
 762
 763         if (body->valid & OBD_MD_FLCOOKIE) {
 764                 int length = sizeof(struct llog_cookie) *
 765                                 lsm->lsm_stripe_count;
 766                 oa->o_valid |= OBD_MD_FLCOOKIE;
 767                 oti.oti_logcookies =
 768                         lustre_msg_buf(request->rq_repmsg, 2, length);
 769                 if (oti.oti_logcookies == NULL) {
 770                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 771                         body->valid &= ~OBD_MD_FLCOOKIE;
 772                 } else {
 773                         /* copy llog cookies to request to replay unlink
 774                          * so that the same llog file and records as those created
 775                          * during fail can be re-created while doing replay
 776                          */
 777                         if (offset >= 0)
 778                                 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
 779                                        oti.oti_logcookies, length);
 780                 }
 781         }
 782
 783         rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
 784         obdo_free(oa);
 785         if (rc)
 786                 CERROR("obd destroy objid "LPX64" error %d\n",
 787                        lsm->lsm_object_id, rc);
 788  out_free_memmd:
 789         obd_free_memmd(ll_i2obdexp(dir), &lsm);
 790  out:
 791         return rc;
 792 }
 793
 794 static int ll_unlink_raw(struct nameidata *nd)
 795 {
 796         struct inode *dir = nd->dentry->d_inode;
 797         const char *name = nd->last.name;
 798         int len = nd->last.len;
 799         struct ptlrpc_request *request = NULL;
 800         struct mdc_op_data op_data;
 801         int rc;
 802         ENTRY;
 803         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
 804                name, dir->i_ino, dir->i_generation, dir);
 805
 806         ll_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
 807         rc = md_unlink(ll_i2sbi(dir)->ll_lmv_exp, &op_data, &request);
 808         if (rc)
 809                 GOTO(out, rc);
 810         ll_update_times(request, 0, dir);
 811
 812         rc = ll_objects_destroy(request, dir, 2);
 813 out:
 814         ptlrpc_req_finished(request);
 815         RETURN(rc);
 816 }
 817
 818 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
 819 {
 820         struct inode *src = oldnd->dentry->d_inode;
 821         struct inode *tgt = newnd->dentry->d_inode;
 822         const char *oldname = oldnd->last.name;
 823         int oldlen  = oldnd->last.len;
 824         const char *newname = newnd->last.name;
 825         int newlen  = newnd->last.len;
 826         struct ptlrpc_request *request = NULL;
 827         struct ll_sb_info *sbi = ll_i2sbi(src);
 828         struct mdc_op_data op_data;
 829         int err;
 830         ENTRY;
 831         CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
 832                "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
 833                src, newname, tgt->i_ino, tgt->i_generation, tgt);
 834
 835         ll_prepare_mdc_data(&op_data, src, tgt, NULL, 0, 0);
 836         err = md_rename(sbi->ll_lmv_exp, &op_data,
 837                         oldname, oldlen, newname, newlen, &request);
 838         if (!err) {
 839                 ll_update_times(request, 0, src);
 840                 ll_update_times(request, 0, tgt);
 841                 err = ll_objects_destroy(request, src, 3);
 842         }
 843
 844         ptlrpc_req_finished(request);
 845
 846         RETURN(err);
 847 }
 848
 849 struct inode_operations ll_dir_inode_operations = {
 850         .link_raw           = ll_link_raw,
 851         .unlink_raw         = ll_unlink_raw,
 852         .symlink_raw        = ll_symlink_raw,
 853         .mkdir_raw          = ll_mkdir_raw,
 854         .rmdir_raw          = ll_rmdir_raw,
 855         .mknod_raw          = ll_mknod_raw,
 856         .mknod              = ll_mknod,
 857         .rename_raw         = ll_rename_raw,
 858         .setattr            = ll_setattr,
 859         .setattr_raw        = ll_setattr_raw,
 860 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 861         .create_it          = ll_create_it,
 862         .lookup_it          = ll_lookup_it,
 863         .revalidate_it      = ll_inode_revalidate_it,
 864 #else
 865         .lookup             = ll_lookup_nd,
 866         .create             = ll_create_nd,
 867         .getattr_it         = ll_getattr,
 868 #endif
 869 };