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