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