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                         if (bits & MDS_INODELOCK_OPEN)
 173                                 LDLM_ERROR(lock, "null inode");
 174                         break;
 175                 }
 176
 177                 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
 178                     lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
 179                         LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
 180                                    (unsigned long)id_fid(&li->lli_id),
 181                                    (unsigned long)id_group(&li->lli_id));
 182                 }
 183
 184                 if (bits & MDS_INODELOCK_OPEN) {
 185                         int flags = 0;
 186                         switch (lock->l_req_mode) {
 187                         case LCK_CW:
 188                                 flags = FMODE_WRITE;
 189                                 break;
 190                         case LCK_PR:
 191                                 flags = FMODE_EXEC;
 192                                 break;
 193                         case LCK_CR:
 194                                 flags = FMODE_READ;
 195                                 break;
 196                         default:
 197                                 CERROR("Unexpected lock mode for OPEN lock "
 198                                        "%d, inode %ld\n", lock->l_req_mode,
 199                                        inode->i_ino);
 200                         }
 201                         ll_md_real_close(ll_i2mdexp(inode), inode, flags);
 202                 }
 203
 204                 if (bits & MDS_INODELOCK_UPDATE)
 205                         clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
 206                                   &(ll_i2info(inode)->lli_flags));
 207
 208
 209                 /* If lookup lock is cancelled, we just drop the dentry and
 210                    this will cause us to reget data from MDS when we'd want to
 211                    access this dentry/inode again. If this is lock on
 212                    other parts of inode that is cancelled, we do not need to do
 213                    much (but need to discard data from readdir, if any), since
 214                    abscence of lock will cause ll_revalidate_it (called from
 215                    stat() and similar functions) to renew the data anyway */
 216                 if (S_ISDIR(inode->i_mode) &&
 217                     (bits & MDS_INODELOCK_UPDATE)) {
 218                         CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
 219                                inode->i_ino, inode->i_generation, inode);
 220                         truncate_inode_pages(inode->i_mapping, 0);
 221                 }
 222
 223                 if (inode->i_sb->s_root &&
 224                     inode != inode->i_sb->s_root->d_inode &&
 225                     (bits & MDS_INODELOCK_LOOKUP))
 226                         ll_unhash_aliases(inode);
 227                 iput(inode);
 228                 break;
 229         }
 230         default:
 231                 LBUG();
 232         }
 233
 234         RETURN(0);
 235 }
 236
 237 /* Search "inode"'s alias list for a dentry that has the same name and parent as
 238  * de.  If found, return it.  If not found, return de. */
 239 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
 240 {
 241         struct list_head *tmp;
 242
 243         spin_lock(&dcache_lock);
 244         list_for_each(tmp, &inode->i_dentry) {
 245                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 246
 247                 /* We are called here with 'de' already on the aliases list. */
 248                 if (dentry == de) {
 249                         CERROR("whoops\n");
 250                         continue;
 251                 }
 252
 253                 if (dentry->d_parent != de->d_parent)
 254                         continue;
 255
 256                 if (dentry->d_name.len != de->d_name.len)
 257                         continue;
 258
 259                 if (memcmp(dentry->d_name.name, de->d_name.name,
 260                            de->d_name.len) != 0)
 261                         continue;
 262
 263                 if (!list_empty(&dentry->d_lru))
 264                         list_del_init(&dentry->d_lru);
 265
 266                 hlist_del_init(&dentry->d_hash);
 267                 __d_rehash(dentry); /* avoid taking dcache_lock inside */
 268                 spin_unlock(&dcache_lock);
 269                 atomic_inc(&dentry->d_count);
 270                 iput(inode);
 271                 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
 272                 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
 273                        "refc %d\n", de->d_name.len, de->d_name.name, de,
 274                        de->d_parent, de->d_inode, atomic_read(&de->d_count));
 275                 return dentry;
 276         }
 277
 278         spin_unlock(&dcache_lock);
 279
 280         return de;
 281 }
 282
 283 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
 284                             struct lookup_intent *it, void *data)
 285 {
 286         struct it_cb_data *icbd = data;
 287         struct dentry **de = icbd->icbd_childp;
 288         struct inode *parent = icbd->icbd_parent;
 289         struct ll_sb_info *sbi = ll_i2sbi(parent);
 290         struct dentry *dentry = *de, *saved = *de;
 291         struct inode *inode = NULL;
 292         int rc;
 293
 294         /* NB 1 request reference will be taken away by ll_intent_lock()
 295          * when I return */
 296         if (!it_disposition(it, DISP_LOOKUP_NEG)) {
 297                 ENTRY;
 298
 299                 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 300                                    &inode, request, offset, dentry->d_sb);
 301                 if (rc)
 302                         RETURN(rc);
 303
 304                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 305                        inode, inode->i_ino, inode->i_generation);
 306
 307                 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 308
 309                 /* If this is a stat, get the authoritative file size */
 310                 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
 311                     ll_i2info(inode)->lli_smd != NULL) {
 312                         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
 313                         ldlm_error_t rc;
 314
 315                         LASSERT(lsm->lsm_object_id != 0);
 316
 317                         /* bug 2334: drop MDS lock before acquiring OST lock */
 318                         ll_intent_drop_lock(it);
 319
 320                         rc = ll_glimpse_size(inode);
 321                         if (rc) {
 322                                 iput(inode);
 323                                 RETURN(rc);
 324                         }
 325                 }
 326
 327                 dentry = *de = ll_find_alias(inode, dentry);
 328         } else {
 329                 ENTRY;
 330         }
 331
 332         dentry->d_op = &ll_d_ops;
 333         ll_set_dd(dentry);
 334
 335         if (dentry == saved)
 336                 d_add(dentry, inode);
 337
 338         RETURN(0);
 339 }
 340
 341 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 342                                    struct nameidata *nd, int flags)
 343 {
 344         struct lookup_intent *it = flags ? &nd->intent.open : NULL;
 345         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 346         struct dentry *save = dentry, *retval;
 347         struct ptlrpc_request *req = NULL;
 348         int rc, gns_it, gns_flags;
 349         struct it_cb_data icbd;
 350         struct lustre_id pid;
 351         ENTRY;
 352
 353         if (dentry->d_name.len > EXT3_NAME_LEN)
 354                 RETURN(ERR_PTR(-ENAMETOOLONG));
 355
 356         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
 357                dentry->d_name.len, dentry->d_name.name, parent->i_ino,
 358                parent->i_generation, parent, LL_IT2STR(it));
 359
 360         if (d_mountpoint(dentry))
 361                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
 362
 363         if (nd != NULL)
 364                 nd->mnt->mnt_last_used = jiffies;
 365
 366         gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
 367         gns_flags = nd ? nd->flags : LOOKUP_CONTINUE;
 368         ll_frob_intent(&it, &lookup_it);
 369
 370         icbd.icbd_childp = &dentry;
 371         icbd.icbd_parent = parent;
 372         ll_inode2id(&pid, parent);
 373
 374         rc = md_intent_lock(ll_i2mdexp(parent), &pid, (char *)dentry->d_name.name,
 375                             dentry->d_name.len, NULL, 0, NULL, it, flags, &req,
 376                             ll_mdc_blocking_ast);
 377         if (rc < 0)
 378                 GOTO(out, retval = ERR_PTR(rc));
 379
 380         rc = lookup_it_finish(req, 1, it, &icbd);
 381         if (rc != 0) {
 382                 ll_intent_release(it);
 383                 GOTO(out, retval = ERR_PTR(rc));
 384         }
 385
 386         ll_lookup_finish_locks(it, dentry);
 387
 388         if (nd && dentry->d_inode != NULL &&
 389             dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) &&
 390             ((gns_flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN))))
 391         {
 392                 CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, "
 393                        "mounting it\n", (int)dentry->d_name.len,
 394                        dentry->d_name.name, dentry);
 395
 396                 rc = ll_gns_mount_object(dentry, nd->mnt);
 397                 if (rc) {
 398                         /*
 399                          * just reporting about GNS failures, lookup() is
 400                          * successful, do not stop it.
 401                          *
 402                          * GNS failure may be that object is found in SUID bit
 403                          * marked dir but it is not regular file and we should
 404                          * lookup further until we find correct mount
 405                          * object. This will allow to perform GNS mount is the
 406                          * following case for instance:
 407                          *
 408                          * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo
 409                          * where all ".mntinfo" are dirs and only last one is
 410                          * reg file.
 411                          */
 412                         CDEBUG(D_DENTRY, "failed to mount %*s, err %d\n",
 413                                (int)dentry->d_name.len, dentry->d_name.name, rc);
 414                 }
 415         }
 416
 417         if (dentry == save)
 418                 GOTO(out, retval = NULL);
 419         else
 420                 GOTO(out, retval = dentry);
 421  out:
 422         if (req)
 423                 ptlrpc_req_finished(req);
 424         if (it == &lookup_it)
 425                 ll_intent_release(it);
 426         if (dentry->d_inode)
 427                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
 428                        dentry,
 429                        (unsigned long) parent->i_ino,
 430                        (unsigned long) parent->i_generation,
 431                        dentry->d_name.len, dentry->d_name.name,
 432                        (unsigned long) dentry->d_inode->i_ino,
 433                        (unsigned long) dentry->d_inode->i_generation);
 434         else
 435                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
 436                        dentry,
 437                        (unsigned long) parent->i_ino,
 438                        (unsigned long) parent->i_generation,
 439                        dentry->d_name.len, dentry->d_name.name);
 440         return retval;
 441 }
 442
 443 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 444 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 445                                    struct nameidata *nd)
 446 {
 447         struct dentry *de;
 448         ENTRY;
 449
 450         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 451                 de = ll_lookup_it(parent, dentry, nd, nd->flags);
 452         else
 453                 de = ll_lookup_it(parent, dentry, nd, 0);
 454
 455         RETURN(de);
 456 }
 457 #endif
 458
 459 /* We depend on "mode" being set with the proper file type/umask by now */
 460 static struct inode *ll_create_node(struct inode *dir, const char *name,
 461                                     int namelen, const void *data, int datalen,
 462                                     int mode, __u64 extra,
 463                                     struct lookup_intent *it)
 464 {
 465         struct inode *inode = NULL;
 466         struct ptlrpc_request *request = NULL;
 467         struct ll_sb_info *sbi = ll_i2sbi(dir);
 468         int rc;
 469         ENTRY;
 470
 471
 472         LASSERT(it && LUSTRE_IT(it)->it_disposition);
 473
 474         request = LUSTRE_IT(it)->it_data;
 475         rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 476                            &inode, request, 1, dir->i_sb);
 477         if (rc)
 478                 GOTO(out, inode = ERR_PTR(rc));
 479
 480         LASSERT(list_empty(&inode->i_dentry));
 481
 482         /* We asked for a lock on the directory, but were granted a
 483          * lock on the inode.  Since we finally have an inode pointer,
 484          * stuff it in the lock. */
 485         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 486                inode, inode->i_ino, inode->i_generation);
 487         mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 488         EXIT;
 489  out:
 490         ptlrpc_req_finished(request);
 491         return inode;
 492 }
 493
 494 /*
 495  * By the time this is called, we already have created the directory cache
 496  * entry for the new file, but it is so far negative - it has no inode.
 497  *
 498  * We defer creating the OBD object(s) until open, to keep the intent and
 499  * non-intent code paths similar, and also because we do not have the MDS
 500  * inode number before calling ll_create_node() (which is needed for LOV),
 501  * so we would need to do yet another RPC to the MDS to store the LOV EA
 502  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 503  * lmm_size in datalen (the MDS still has code which will handle that).
 504  *
 505  * If the create succeeds, we fill in the inode information
 506  * with d_instantiate().
 507  */
 508 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 509                         struct lookup_intent *it)
 510 {
 511         struct inode *inode;
 512         struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
 513         struct obd_export *md_exp = ll_i2mdexp(dir);
 514         int rc = 0;
 515         ENTRY;
 516
 517         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
 518                dentry->d_name.len, dentry->d_name.name, dir->i_ino,
 519                dir->i_generation, dir, LL_IT2STR(it));
 520
 521         rc = it_open_error(DISP_OPEN_CREATE, it);
 522         if (rc)
 523                 RETURN(rc);
 524
 525         mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
 526         inode = ll_create_node(dir, (char *)dentry->d_name.name,
 527                                dentry->d_name.len, NULL, 0, mode, 0, it);
 528         if (IS_ERR(inode))
 529                 RETURN(PTR_ERR(inode));
 530
 531         d_instantiate(dentry, inode);
 532         RETURN(0);
 533 }
 534
 535 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 536 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 537 {
 538         return ll_create_it(dir, dentry, mode, &nd->intent.open);
 539 }
 540 #endif
 541
 542 static void ll_update_times(struct ptlrpc_request *request, int offset,
 543                             struct inode *inode)
 544 {
 545         struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
 546                                                sizeof(*body));
 547         LASSERT(body);
 548
 549         if (body->valid & OBD_MD_FLMTIME &&
 550             body->mtime > LTIME_S(inode->i_mtime)) {
 551                 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
 552                        inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
 553                 LTIME_S(inode->i_mtime) = body->mtime;
 554         }
 555         if (body->valid & OBD_MD_FLCTIME &&
 556             body->ctime > LTIME_S(inode->i_ctime))
 557                 LTIME_S(inode->i_ctime) = body->ctime;
 558 }
 559
 560 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 561 {
 562         struct ptlrpc_request *request = NULL;
 563         struct inode *dir = nd->dentry->d_inode;
 564         struct ll_sb_info *sbi = ll_i2sbi(dir);
 565         struct mdc_op_data *op_data;
 566         int err = -EMLINK;
 567         ENTRY;
 568
 569         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 570                nd->last.len, nd->last.name, dir->i_ino,
 571                dir->i_generation, dir);
 572
 573         mode &= ~current->fs->umask;
 574
 575         switch (mode & S_IFMT) {
 576         case 0:
 577         case S_IFREG:
 578                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 579         case S_IFCHR:
 580         case S_IFBLK:
 581         case S_IFIFO:
 582         case S_IFSOCK:
 583                 OBD_ALLOC(op_data, sizeof(*op_data));
 584                 if (op_data == NULL)
 585                         RETURN(-ENOMEM);
 586                 ll_prepare_mdc_data(op_data, dir, NULL,
 587                                     (char *)nd->last.name,
 588                                     nd->last.len, 0);
 589
 590                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 591                                 current->fsuid, current->fsgid, rdev,
 592                                 &request);
 593                 OBD_FREE(op_data, sizeof(*op_data));
 594                 if (err == 0)
 595                         ll_update_times(request, 0, dir);
 596                 ptlrpc_req_finished(request);
 597                 break;
 598         case S_IFDIR:
 599                 err = -EPERM;
 600                 break;
 601         default:
 602                 err = -EINVAL;
 603         }
 604         RETURN(err);
 605 }
 606
 607 static int ll_mknod(struct inode *dir, struct dentry *dchild,
 608                     int mode, ll_dev_t rdev)
 609 {
 610         struct ptlrpc_request *request = NULL;
 611         struct inode *inode = NULL;
 612         struct ll_sb_info *sbi = ll_i2sbi(dir);
 613         struct mdc_op_data *op_data;
 614         int err = -EMLINK;
 615         ENTRY;
 616
 617         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 618                dchild->d_name.len, dchild->d_name.name,
 619                dir->i_ino, dir->i_generation, dir);
 620
 621         mode &= ~current->fs->umask;
 622
 623         switch (mode & S_IFMT) {
 624         case 0:
 625         case S_IFREG:
 626                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 627         case S_IFCHR:
 628         case S_IFBLK:
 629         case S_IFIFO:
 630         case S_IFSOCK:
 631                 OBD_ALLOC(op_data, sizeof(*op_data));
 632                 if (op_data == NULL)
 633                         RETURN(-ENOMEM);
 634
 635                 ll_prepare_mdc_data(op_data, dir, NULL,
 636                                     (char *)dchild->d_name.name,
 637                                     dchild->d_name.len, 0);
 638
 639                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 640                                 current->fsuid, current->fsgid, rdev,
 641                                 &request);
 642                 OBD_FREE(op_data, sizeof(*op_data));
 643                 if (err)
 644                         GOTO(out_err, err);
 645
 646                 ll_update_times(request, 0, dir);
 647                 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 648                                     &inode, request, 0, dchild->d_sb);
 649                 if (err)
 650                         GOTO(out_err, err);
 651                 break;
 652         case S_IFDIR:
 653                 RETURN(-EPERM);
 654                 break;
 655         default:
 656                 RETURN(-EINVAL);
 657         }
 658
 659         d_instantiate(dchild, inode);
 660         EXIT;
 661  out_err:
 662         ptlrpc_req_finished(request);
 663         return err;
 664 }
 665
 666 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 667 {
 668         const char *name = (char *)nd->last.name;
 669         struct inode *dir = nd->dentry->d_inode;
 670         struct ptlrpc_request *request = NULL;
 671         struct ll_sb_info *sbi = ll_i2sbi(dir);
 672         struct mdc_op_data *op_data;
 673         int len = nd->last.len;
 674         int err = -EMLINK;
 675         ENTRY;
 676
 677         CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
 678                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
 679                dir, tgt);
 680
 681         if (dir->i_nlink >= EXT3_LINK_MAX)
 682                 RETURN(err);
 683
 684         OBD_ALLOC(op_data, sizeof(*op_data));
 685         if (op_data == NULL)
 686                 RETURN(-ENOMEM);
 687         ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
 688         LASSERT(tgt);
 689         err = md_create(sbi->ll_md_exp, op_data,
 690                         tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 691                         current->fsuid, current->fsgid, 0, &request);
 692         OBD_FREE(op_data, sizeof(*op_data));
 693         if (err == 0)
 694                 ll_update_times(request, 0, dir);
 695
 696         ptlrpc_req_finished(request);
 697         RETURN(err);
 698 }
 699
 700 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 701 {
 702         struct inode *src = srcnd->dentry->d_inode;
 703         struct inode *dir = tgtnd->dentry->d_inode;
 704         struct ptlrpc_request *request = NULL;
 705         struct ll_sb_info *sbi = ll_i2sbi(dir);
 706         struct mdc_op_data *op_data;
 707         int err;
 708         ENTRY;
 709
 710         CDEBUG(D_VFSTRACE,
 711                "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
 712                src->i_ino, src->i_generation, src, dir->i_ino,
 713                dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
 714
 715         OBD_ALLOC(op_data, sizeof(*op_data));
 716         if (op_data == NULL)
 717                 RETURN(-ENOMEM);
 718
 719         ll_prepare_mdc_data(op_data, src, dir,
 720                             (char *)tgtnd->last.name,
 721                             tgtnd->last.len, 0);
 722
 723         err = md_link(sbi->ll_md_exp, op_data, &request);
 724         OBD_FREE(op_data, sizeof(*op_data));
 725         if (err == 0)
 726                 ll_update_times(request, 0, dir);
 727         ptlrpc_req_finished(request);
 728         RETURN(err);
 729 }
 730
 731
 732 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 733 {
 734         struct inode *dir = nd->dentry->d_inode;
 735         struct ptlrpc_request *request = NULL;
 736         struct ll_sb_info *sbi = ll_i2sbi(dir);
 737         struct mdc_op_data *op_data;
 738         int err = -EMLINK;
 739         ENTRY;
 740         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 741                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 742
 743         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 744         OBD_ALLOC(op_data, sizeof(*op_data));
 745         if (op_data == NULL)
 746                 RETURN(-ENOMEM);
 747
 748         ll_prepare_mdc_data(op_data, dir, NULL,
 749                             (char *)nd->last.name,
 750                             nd->last.len, 0);
 751
 752         err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 753                         current->fsuid, current->fsgid, 0, &request);
 754         OBD_FREE(op_data, sizeof(*op_data));
 755         if (err == 0)
 756                 ll_update_times(request, 0, dir);
 757         ptlrpc_req_finished(request);
 758         RETURN(err);
 759 }
 760
 761 static int ll_rmdir_raw(struct nameidata *nd)
 762 {
 763         struct inode *dir = nd->dentry->d_inode;
 764         struct ptlrpc_request *request = NULL;
 765         struct mdc_op_data *op_data;
 766         int rc;
 767
 768         ENTRY;
 769         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 770                nd->last.len, nd->last.name, dir->i_ino,
 771                dir->i_generation, dir);
 772
 773         OBD_ALLOC(op_data, sizeof(*op_data));
 774         if (op_data == NULL)
 775                 RETURN(-ENOMEM);
 776
 777         ll_prepare_mdc_data(op_data, dir, NULL,
 778                             (char *)nd->last.name,
 779                             nd->last.len, S_IFDIR);
 780
 781         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 782         OBD_FREE(op_data, sizeof(*op_data));
 783         if (rc == 0)
 784                 ll_update_times(request, 0, dir);
 785         ptlrpc_req_finished(request);
 786         RETURN(rc);
 787 }
 788
 789 static int ll_unlink_raw(struct nameidata *nd)
 790 {
 791         struct inode *dir = nd->dentry->d_inode;
 792         struct ptlrpc_request *request = NULL;
 793         struct mdc_op_data *op_data;
 794         int rc;
 795         ENTRY;
 796         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 797                nd->last.len, nd->last.name, dir->i_ino,
 798                dir->i_generation, dir);
 799
 800         OBD_ALLOC(op_data, sizeof(*op_data));
 801         if (op_data == NULL)
 802                 RETURN(-ENOMEM);
 803         ll_prepare_mdc_data(op_data, dir, NULL,
 804                             (char *)nd->last.name, nd->last.len, 0);
 805         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 806         OBD_FREE(op_data, sizeof(*op_data));
 807         if (rc)
 808                 GOTO(out, rc);
 809         ll_update_times(request, 0, dir);
 810         EXIT;
 811 out:
 812         ptlrpc_req_finished(request);
 813         return rc;
 814 }
 815
 816 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 817 {
 818         struct inode *src = srcnd->dentry->d_inode;
 819         struct inode *tgt = tgtnd->dentry->d_inode;
 820         struct ptlrpc_request *request = NULL;
 821         struct ll_sb_info *sbi = ll_i2sbi(src);
 822         struct mdc_op_data *op_data;
 823         int err;
 824         ENTRY;
 825
 826         if (srcnd->mnt != tgtnd->mnt)
 827                 RETURN(-EXDEV);
 828
 829         CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
 830                "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
 831                src->i_ino, src->i_generation, src, tgtnd->last.len,
 832                tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
 833
 834         OBD_ALLOC(op_data, sizeof(*op_data));
 835         if (op_data == NULL)
 836                 RETURN(-ENOMEM);
 837         ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
 838         err = md_rename(sbi->ll_md_exp, op_data, (char *)srcnd->last.name,
 839                         srcnd->last.len, (char *)tgtnd->last.name,
 840                         tgtnd->last.len, &request);
 841         OBD_FREE(op_data, sizeof(*op_data));
 842         if (!err) {
 843                 ll_update_times(request, 0, src);
 844                 ll_update_times(request, 0, tgt);
 845         }
 846
 847         ptlrpc_req_finished(request);
 848         RETURN(err);
 849 }
 850
 851 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 852 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
 853 static int ll_rawop_from_intent(struct nameidata *nd)
 854 {
 855         int error = 0;
 856
 857         if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
 858                 return 0;
 859
 860         switch (nd->intent.open.op) {
 861         case IT_MKNOD:
 862                 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
 863                                      nd->intent.open.create.dev);
 864                 break;
 865         case IT_MKDIR:
 866                 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
 867                 break;
 868         case IT_RMDIR:
 869                 error = ll_rmdir_raw(nd);
 870                 break;
 871         case IT_UNLINK:
 872                 error = ll_unlink_raw(nd);
 873                 break;
 874         case IT_SYMLINK:
 875                 LASSERT(nd->intent.open.create.link);
 876                 error = ll_symlink_raw(nd, nd->intent.open.create.link);
 877                 break;
 878         case IT_LINK:
 879                 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
 880                 break;
 881         case IT_RENAME:
 882                 LASSERT(nd->intent.open.create.source_nd);
 883                 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
 884                 break;
 885         default:
 886                 LBUG();
 887         }
 888         if (error != -EOPNOTSUPP)
 889                 nd->intent.open.flags |= IT_STATUS_RAW;
 890
 891         return error;
 892 }
 893 #endif
 894
 895 struct inode_operations ll_dir_inode_operations = {
 896         .mknod              = ll_mknod,
 897         .setattr            = ll_setattr,
 898 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 899         .create_it          = ll_create_it,
 900         .lookup_it          = ll_lookup_it,
 901         .revalidate_it      = ll_inode_revalidate_it,
 902 #else
 903         .lookup             = ll_lookup_nd,
 904         .create             = ll_create_nd,
 905         .getattr            = ll_getattr,
 906         .endparentlookup    = ll_rawop_from_intent,
 907 #endif
 908         .setxattr           = ll_setxattr,
 909         .getxattr           = ll_getxattr,
 910         .listxattr          = ll_listxattr,
 911         .removexattr        = ll_removexattr,
 912         .permission         = ll_inode_permission,
 913 };