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