lustre/llite/namei.c

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