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                         /*
 410                          * making system to restart syscall as currently GNS is
 411                          * in mounting progress.
 412                          */
 413                         GOTO(out, retval = rc);
 414                 }
 415         }
 416
 417         if (dentry == save)
 418                 GOTO(out, retval = NULL);
 419         else
 420                 GOTO(out, retval = dentry);
 421  out:
 422         if (req)
 423                 ptlrpc_req_finished(req);
 424         if (it == &lookup_it)
 425                 ll_intent_release(it);
 426         if (dentry->d_inode)
 427                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
 428                        dentry,
 429                        (unsigned long) parent->i_ino,
 430                        (unsigned long) parent->i_generation,
 431                        dentry->d_name.len, dentry->d_name.name,
 432                        (unsigned long) dentry->d_inode->i_ino,
 433                        (unsigned long) dentry->d_inode->i_generation);
 434         else
 435                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
 436                        dentry,
 437                        (unsigned long) parent->i_ino,
 438                        (unsigned long) parent->i_generation,
 439                        dentry->d_name.len, dentry->d_name.name);
 440         return retval;
 441 }
 442
 443 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 444 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 445                                    struct nameidata *nd)
 446 {
 447         struct dentry *de;
 448         ENTRY;
 449
 450         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 451                 de = ll_lookup_it(parent, dentry, nd, nd->flags);
 452         else
 453                 de = ll_lookup_it(parent, dentry, nd, 0);
 454
 455         RETURN(de);
 456 }
 457 #endif
 458
 459 /* We depend on "mode" being set with the proper file type/umask by now */
 460 static struct inode *ll_create_node(struct inode *dir, const char *name,
 461                                     int namelen, const void *data, int datalen,
 462                                     int mode, __u64 extra,
 463                                     struct lookup_intent *it)
 464 {
 465         struct inode *inode = NULL;
 466         struct ptlrpc_request *request = NULL;
 467         struct ll_sb_info *sbi = ll_i2sbi(dir);
 468         int rc;
 469         ENTRY;
 470
 471
 472         LASSERT(it && LUSTRE_IT(it)->it_disposition);
 473
 474         request = LUSTRE_IT(it)->it_data;
 475         rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 476                            &inode, request, 1, dir->i_sb);
 477         if (rc)
 478                 GOTO(out, inode = ERR_PTR(rc));
 479
 480         LASSERT(list_empty(&inode->i_dentry));
 481
 482         /* We asked for a lock on the directory, but were granted a
 483          * lock on the inode.  Since we finally have an inode pointer,
 484          * stuff it in the lock. */
 485         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 486                inode, inode->i_ino, inode->i_generation);
 487         mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 488         EXIT;
 489  out:
 490         ptlrpc_req_finished(request);
 491         return inode;
 492 }
 493
 494 /*
 495  * By the time this is called, we already have created the directory cache
 496  * entry for the new file, but it is so far negative - it has no inode.
 497  *
 498  * We defer creating the OBD object(s) until open, to keep the intent and
 499  * non-intent code paths similar, and also because we do not have the MDS
 500  * inode number before calling ll_create_node() (which is needed for LOV),
 501  * so we would need to do yet another RPC to the MDS to store the LOV EA
 502  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 503  * lmm_size in datalen (the MDS still has code which will handle that).
 504  *
 505  * If the create succeeds, we fill in the inode information
 506  * with d_instantiate().
 507  */
 508 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 509                         struct lookup_intent *it)
 510 {
 511         struct inode *inode;
 512         struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
 513         struct obd_export *md_exp = ll_i2mdexp(dir);
 514         int rc = 0;
 515         ENTRY;
 516
 517         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
 518                dentry->d_name.len, dentry->d_name.name, dir->i_ino,
 519                dir->i_generation, dir, LL_IT2STR(it));
 520
 521         rc = it_open_error(DISP_OPEN_CREATE, it);
 522         if (rc)
 523                 RETURN(rc);
 524
 525         mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
 526         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 527                                NULL, 0, mode, 0, it);
 528         if (IS_ERR(inode))
 529                 RETURN(PTR_ERR(inode));
 530
 531         d_instantiate(dentry, inode);
 532         RETURN(0);
 533 }
 534
 535 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 536 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 537 {
 538         return ll_create_it(dir, dentry, mode, &nd->intent.open);
 539 }
 540 #endif
 541
 542 static void ll_update_times(struct ptlrpc_request *request, int offset,
 543                             struct inode *inode)
 544 {
 545         struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
 546                                                sizeof(*body));
 547         LASSERT(body);
 548
 549         if (body->valid & OBD_MD_FLMTIME &&
 550             body->mtime > LTIME_S(inode->i_mtime)) {
 551                 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
 552                        inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
 553                 LTIME_S(inode->i_mtime) = body->mtime;
 554         }
 555         if (body->valid & OBD_MD_FLCTIME &&
 556             body->ctime > LTIME_S(inode->i_ctime))
 557                 LTIME_S(inode->i_ctime) = body->ctime;
 558 }
 559
 560 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 561 {
 562         struct ptlrpc_request *request = NULL;
 563         struct inode *dir = nd->dentry->d_inode;
 564         struct ll_sb_info *sbi = ll_i2sbi(dir);
 565         struct mdc_op_data *op_data;
 566         int err = -EMLINK;
 567         ENTRY;
 568
 569         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 570                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 571
 572         mode &= ~current->fs->umask;
 573
 574         switch (mode & S_IFMT) {
 575         case 0:
 576         case S_IFREG:
 577                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 578         case S_IFCHR:
 579         case S_IFBLK:
 580         case S_IFIFO:
 581         case S_IFSOCK:
 582                 OBD_ALLOC(op_data, sizeof(*op_data));
 583                 if (op_data == NULL)
 584                         RETURN(-ENOMEM);
 585                 ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 586                                     nd->last.len, 0);
 587                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 588                                 current->fsuid, current->fsgid, rdev,
 589                                 &request);
 590                 OBD_FREE(op_data, sizeof(*op_data));
 591                 if (err == 0)
 592                         ll_update_times(request, 0, dir);
 593                 ptlrpc_req_finished(request);
 594                 break;
 595         case S_IFDIR:
 596                 err = -EPERM;
 597                 break;
 598         default:
 599                 err = -EINVAL;
 600         }
 601         RETURN(err);
 602 }
 603
 604 static int ll_mknod(struct inode *dir, struct dentry *dchild,
 605                     int mode, ll_dev_t rdev)
 606 {
 607         struct ptlrpc_request *request = NULL;
 608         struct inode *inode = NULL;
 609         struct ll_sb_info *sbi = ll_i2sbi(dir);
 610         struct mdc_op_data *op_data;
 611         int err = -EMLINK;
 612         ENTRY;
 613
 614         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 615                dchild->d_name.len, dchild->d_name.name,
 616                dir->i_ino, dir->i_generation, dir);
 617
 618         mode &= ~current->fs->umask;
 619
 620         switch (mode & S_IFMT) {
 621         case 0:
 622         case S_IFREG:
 623                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 624         case S_IFCHR:
 625         case S_IFBLK:
 626         case S_IFIFO:
 627         case S_IFSOCK:
 628                 OBD_ALLOC(op_data, sizeof(*op_data));
 629                 if (op_data == NULL)
 630                         RETURN(-ENOMEM);
 631                 ll_prepare_mdc_data(op_data, dir, NULL, dchild->d_name.name,
 632                                     dchild->d_name.len, 0);
 633                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 634                                 current->fsuid, current->fsgid, rdev,
 635                                 &request);
 636                 OBD_FREE(op_data, sizeof(*op_data));
 637                 if (err)
 638                         GOTO(out_err, err);
 639
 640                 ll_update_times(request, 0, dir);
 641                 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 642                                     &inode, request, 0, dchild->d_sb);
 643                 if (err)
 644                         GOTO(out_err, err);
 645                 break;
 646         case S_IFDIR:
 647                 RETURN(-EPERM);
 648                 break;
 649         default:
 650                 RETURN(-EINVAL);
 651         }
 652
 653         d_instantiate(dchild, inode);
 654         EXIT;
 655  out_err:
 656         ptlrpc_req_finished(request);
 657         return err;
 658 }
 659
 660 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 661 {
 662         struct inode *dir = nd->dentry->d_inode;
 663         struct ptlrpc_request *request = NULL;
 664         struct ll_sb_info *sbi = ll_i2sbi(dir);
 665         const char *name = nd->last.name;
 666         struct mdc_op_data *op_data;
 667         int len = nd->last.len;
 668         int err = -EMLINK;
 669         ENTRY;
 670
 671         CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
 672                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
 673                dir, tgt);
 674
 675         if (dir->i_nlink >= EXT3_LINK_MAX)
 676                 RETURN(err);
 677
 678         OBD_ALLOC(op_data, sizeof(*op_data));
 679         if (op_data == NULL)
 680                 RETURN(-ENOMEM);
 681         ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
 682         LASSERT(tgt);
 683         err = md_create(sbi->ll_md_exp, op_data,
 684                         tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 685                         current->fsuid, current->fsgid, 0, &request);
 686         OBD_FREE(op_data, sizeof(*op_data));
 687         if (err == 0)
 688                 ll_update_times(request, 0, dir);
 689
 690         ptlrpc_req_finished(request);
 691         RETURN(err);
 692 }
 693
 694 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 695 {
 696         struct inode *src = srcnd->dentry->d_inode;
 697         struct inode *dir = tgtnd->dentry->d_inode;
 698         struct ptlrpc_request *request = NULL;
 699         struct mdc_op_data *op_data;
 700         int err;
 701         struct ll_sb_info *sbi = ll_i2sbi(dir);
 702         ENTRY;
 703
 704         CDEBUG(D_VFSTRACE,
 705                "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
 706                src->i_ino, src->i_generation, src, dir->i_ino,
 707                dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
 708
 709         OBD_ALLOC(op_data, sizeof(*op_data));
 710         if (op_data == NULL)
 711                 RETURN(-ENOMEM);
 712         ll_prepare_mdc_data(op_data, src, dir, tgtnd->last.name,
 713                             tgtnd->last.len, 0);
 714         err = md_link(sbi->ll_md_exp, op_data, &request);
 715         OBD_FREE(op_data, sizeof(*op_data));
 716         if (err == 0)
 717                 ll_update_times(request, 0, dir);
 718         ptlrpc_req_finished(request);
 719         RETURN(err);
 720 }
 721
 722
 723 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 724 {
 725         struct inode *dir = nd->dentry->d_inode;
 726         struct ptlrpc_request *request = NULL;
 727         struct ll_sb_info *sbi = ll_i2sbi(dir);
 728         struct mdc_op_data *op_data;
 729         int err = -EMLINK;
 730         ENTRY;
 731         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 732                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 733
 734         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 735         OBD_ALLOC(op_data, sizeof(*op_data));
 736         if (op_data == NULL)
 737                 RETURN(-ENOMEM);
 738         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 739                             nd->last.len, 0);
 740         err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 741                         current->fsuid, current->fsgid, 0, &request);
 742         OBD_FREE(op_data, sizeof(*op_data));
 743         if (err == 0)
 744                 ll_update_times(request, 0, dir);
 745         ptlrpc_req_finished(request);
 746         RETURN(err);
 747 }
 748
 749 static int ll_rmdir_raw(struct nameidata *nd)
 750 {
 751         struct inode *dir = nd->dentry->d_inode;
 752         struct ptlrpc_request *request = NULL;
 753         struct mdc_op_data *op_data;
 754         int rc;
 755
 756         ENTRY;
 757         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 758                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 759
 760         OBD_ALLOC(op_data, sizeof(*op_data));
 761         if (op_data == NULL)
 762                 RETURN(-ENOMEM);
 763         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 764                             nd->last.len, S_IFDIR);
 765         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 766         OBD_FREE(op_data, sizeof(*op_data));
 767         if (rc == 0)
 768                 ll_update_times(request, 0, dir);
 769         ptlrpc_req_finished(request);
 770         RETURN(rc);
 771 }
 772
 773 int ll_objects_destroy(struct ptlrpc_request *request,
 774                        struct inode *dir, int offset)
 775 {
 776         struct mds_body *body;
 777         struct lov_mds_md *eadata;
 778         struct lov_stripe_md *lsm = NULL;
 779         struct obd_trans_info oti = { 0 };
 780         struct obdo *oa;
 781         int rc;
 782         ENTRY;
 783
 784         /* req is swabbed so this is safe */
 785         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 786
 787         if (!(body->valid & OBD_MD_FLEASIZE))
 788                 RETURN(0);
 789
 790         if (body->eadatasize == 0) {
 791                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 792                 GOTO(out, rc = -EPROTO);
 793         }
 794
 795         /*
 796          * the MDS sent back the EA because we unlinked the last reference to
 797          * this file. Use this EA to unlink the objects on the OST. It's opaque
 798          * so we don't swab here; we leave it to obd_unpackmd() to check it is
 799          * complete and sensible.
 800          */
 801         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 802         LASSERT(eadata != NULL);
 803         if (eadata == NULL) {
 804                 CERROR("Can't unpack MDS EA data\n");
 805                 GOTO(out, rc = -EPROTO);
 806         }
 807
 808         rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize);
 809         if (rc < 0) {
 810                 CERROR("obd_unpackmd: %d\n", rc);
 811                 GOTO(out, rc);
 812         }
 813         LASSERT(rc >= sizeof(*lsm));
 814
 815         oa = obdo_alloc();
 816         if (oa == NULL)
 817                 GOTO(out_free_memmd, rc = -ENOMEM);
 818
 819         oa->o_id = lsm->lsm_object_id;
 820         oa->o_gr = lsm->lsm_object_gr;
 821         oa->o_mode = body->mode & S_IFMT;
 822         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
 823
 824         if (body->valid & OBD_MD_FLCOOKIE) {
 825                 int length = sizeof(struct llog_cookie) *
 826                                 lsm->lsm_stripe_count;
 827                 oa->o_valid |= OBD_MD_FLCOOKIE;
 828                 oti.oti_logcookies =
 829                         lustre_msg_buf(request->rq_repmsg, 2, length);
 830                 if (oti.oti_logcookies == NULL) {
 831                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 832                         body->valid &= ~OBD_MD_FLCOOKIE;
 833                 } else {
 834                         /* copy llog cookies to request to replay unlink
 835                          * so that the same llog file and records as those created
 836                          * during fail can be re-created while doing replay
 837                          */
 838                         if (offset >= 0)
 839                                 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
 840                                        oti.oti_logcookies, length);
 841                 }
 842         }
 843
 844         rc = obd_destroy(ll_i2dtexp(dir), oa, lsm, &oti);
 845         obdo_free(oa);
 846         if (rc)
 847                 CERROR("obd destroy objid "LPX64" error %d\n",
 848                        lsm->lsm_object_id, rc);
 849         EXIT;
 850  out_free_memmd:
 851         obd_free_memmd(ll_i2dtexp(dir), &lsm);
 852  out:
 853         return rc;
 854 }
 855
 856 static int ll_unlink_raw(struct nameidata *nd)
 857 {
 858         struct inode *dir = nd->dentry->d_inode;
 859         struct ptlrpc_request *request = NULL;
 860         struct mdc_op_data *op_data;
 861         int rc;
 862         ENTRY;
 863         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 864                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 865
 866         OBD_ALLOC(op_data, sizeof(*op_data));
 867         if (op_data == NULL)
 868                 RETURN(-ENOMEM);
 869         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name, nd->last.len, 0);
 870         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 871         OBD_FREE(op_data, sizeof(*op_data));
 872         if (rc)
 873                 GOTO(out, rc);
 874         ll_update_times(request, 0, dir);
 875
 876         rc = ll_objects_destroy(request, dir, 2);
 877         EXIT;
 878 out:
 879         ptlrpc_req_finished(request);
 880         return rc;
 881 }
 882
 883 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 884 {
 885         struct inode *src = srcnd->dentry->d_inode;
 886         struct inode *tgt = tgtnd->dentry->d_inode;
 887         struct ptlrpc_request *request = NULL;
 888         struct ll_sb_info *sbi = ll_i2sbi(src);
 889         struct mdc_op_data *op_data;
 890         int err;
 891         ENTRY;
 892
 893         CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
 894                "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
 895                src->i_ino, src->i_generation, src, tgtnd->last.len,
 896                tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
 897
 898         OBD_ALLOC(op_data, sizeof(*op_data));
 899         if (op_data == NULL)
 900                 RETURN(-ENOMEM);
 901         ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
 902         err = md_rename(sbi->ll_md_exp, op_data, srcnd->last.name,
 903                         srcnd->last.len, tgtnd->last.name, tgtnd->last.len,
 904                         &request);
 905         OBD_FREE(op_data, sizeof(*op_data));
 906         if (!err) {
 907                 ll_update_times(request, 0, src);
 908                 ll_update_times(request, 0, tgt);
 909                 err = ll_objects_destroy(request, src, 3);
 910         }
 911
 912         ptlrpc_req_finished(request);
 913         RETURN(err);
 914 }
 915
 916 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 917 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
 918 static int ll_rawop_from_intent(struct nameidata *nd)
 919 {
 920         int error = 0;
 921
 922         if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
 923                 return 0;
 924
 925         switch (nd->intent.open.op) {
 926         case IT_MKNOD:
 927                 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
 928                                      nd->intent.open.create.dev);
 929                 break;
 930         case IT_MKDIR:
 931                 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
 932                 break;
 933         case IT_RMDIR:
 934                 error = ll_rmdir_raw(nd);
 935                 break;
 936         case IT_UNLINK:
 937                 error = ll_unlink_raw(nd);
 938                 break;
 939         case IT_SYMLINK:
 940                 LASSERT(nd->intent.open.create.link);
 941                 error = ll_symlink_raw(nd, nd->intent.open.create.link);
 942                 break;
 943         case IT_LINK:
 944                 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
 945                 break;
 946         case IT_RENAME:
 947                 LASSERT(nd->intent.open.create.source_nd);
 948                 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
 949                 break;
 950         default:
 951                 LBUG();
 952         }
 953         if (error != -EOPNOTSUPP)
 954                 nd->intent.open.flags |= IT_STATUS_RAW;
 955
 956         return error;
 957 }
 958 #endif
 959
 960 struct inode_operations ll_dir_inode_operations = {
 961         .mknod              = ll_mknod,
 962         .setattr            = ll_setattr,
 963 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 964         .create_it          = ll_create_it,
 965         .lookup_it          = ll_lookup_it,
 966         .revalidate_it      = ll_inode_revalidate_it,
 967 #else
 968         .lookup             = ll_lookup_nd,
 969         .create             = ll_create_nd,
 970         .getattr            = ll_getattr,
 971         .endparentlookup    = ll_rawop_from_intent,
 972 #endif
 973         .setxattr           = ll_setxattr,
 974         .getxattr           = ll_getxattr,
 975         .listxattr          = ll_listxattr,
 976         .removexattr        = ll_removexattr,
 977         .permission         = ll_inode_permission,
 978 };