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