lustre/llite/namei.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2002, 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *  derived in small part from linux/fs/ext2/namei.c
  22  *
  23  *  Copyright (C) 1991, 1992  Linus Torvalds
  24  *
  25  *  Big-endian to little-endian byte-swapping/bitmaps by
  26  *        David S. Miller (davem@caip.rutgers.edu), 1995
  27  *  Directory entry file type support and forward compatibility hooks
  28  *      for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
  29  */
  30
  31 #include <linux/fs.h>
  32 #include <linux/sched.h>
  33 #include <linux/mm.h>
  34 #include <linux/smp_lock.h>
  35 #include <linux/quotaops.h>
  36 #include <linux/highmem.h>
  37 #include <linux/pagemap.h>
  38
  39 #define DEBUG_SUBSYSTEM S_LLITE
  40
  41 #include <linux/obd_support.h>
  42 #include <linux/lustre_lite.h>
  43 #include <linux/lustre_dlm.h>
  44 #include <linux/lustre_version.h>
  45 #include "llite_internal.h"
  46
  47 /* methods */
  48
  49 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  50 static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque)
  51 #else
  52 static int ll_test_inode(struct inode *inode, void *opaque)
  53 #endif
  54 {
  55         static int last_ino, last_gen, last_count;
  56         struct lustre_md *md = opaque;
  57
  58         if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) {
  59                 CERROR("MDS body missing inum or generation\n");
  60                 return 0;
  61         }
  62
  63         if (last_ino == id_ino(&md->body->id1) &&
  64             last_gen == id_gen(&md->body->id1) &&
  65             last_count < 500) {
  66                 last_count++;
  67         } else {
  68                 if (last_count > 1)
  69                         CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
  70                                last_ino, last_gen, last_count);
  71                 last_count = 0;
  72                 last_ino = id_ino(&md->body->id1);
  73                 last_gen = id_gen(&md->body->id1);
  74                 CDEBUG(D_VFSTRACE,
  75                        "comparing inode %p ino "DLID4" to body "DLID4"\n",
  76                        inode, OLID4(&ll_i2info(inode)->lli_id),
  77                        OLID4(&md->body->id1));
  78         }
  79
  80 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  81         if (inode->i_ino != id_ino(&md->body->id1))
  82                 return 0;
  83 #endif
  84         if (inode->i_generation != id_gen(&md->body->id1))
  85                 return 0;
  86
  87         if (id_group(&ll_i2info(inode)->lli_id) != id_group(&md->body->id1))
  88                 return 0;
  89
  90         /* apply the attributes in 'opaque' to this inode. */
  91         ll_update_inode(inode, md);
  92         return 1;
  93 }
  94
  95 extern struct dentry_operations ll_d_ops;
  96
  97 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
  98 {
  99         ENTRY;
 100
 101         ldlm_lock_decref(lockh, mode);
 102
 103         RETURN(0);
 104 }
 105
 106 /*
 107  * get an inode by inode number (already instantiated by the intent lookup).
 108  * Returns inode or NULL.
 109  */
 110 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 111 int ll_set_inode(struct inode *inode, void *opaque)
 112 {
 113         ll_read_inode2(inode, opaque);
 114         return 0;
 115 }
 116
 117 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 118                       struct lustre_md *md)
 119 {
 120         struct inode *inode;
 121
 122         LASSERT(hash != 0);
 123         inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
 124
 125         if (inode) {
 126                 if (inode->i_state & I_NEW)
 127                         unlock_new_inode(inode);
 128                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 129                        inode->i_generation, inode);
 130         }
 131
 132         return inode;
 133 }
 134 #else
 135 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 136                       struct lustre_md *md)
 137 {
 138         struct inode *inode;
 139         LASSERT(hash != 0);
 140         inode = iget4(sb, hash, ll_test_inode, md);
 141         if (inode)
 142                 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
 143                        inode->i_generation, inode);
 144         return inode;
 145 }
 146 #endif
 147
 148 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 149                         void *data, int flag)
 150 {
 151         int rc;
 152         struct lustre_handle lockh;
 153         ENTRY;
 154
 155         switch (flag) {
 156         case LDLM_CB_BLOCKING:
 157                 ldlm_lock2handle(lock, &lockh);
 158                 rc = ldlm_cli_cancel(&lockh);
 159                 if (rc < 0) {
 160                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 161                         RETURN(rc);
 162                 }
 163                 break;
 164         case LDLM_CB_CANCELING: {
 165                 struct inode *inode = ll_inode_from_lock(lock);
 166                 struct ll_inode_info *li = ll_i2info(inode);
 167                 __u64 bits = lock->l_policy_data.l_inodebits.bits;
 168
 169                 /* For lookup locks: Invalidate all dentries associated with
 170                    this inode, for UPDATE locks - invalidate directory pages */
 171                 if (inode == NULL)
 172                         break;
 173
 174                 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
 175                     lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
 176                         LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
 177                                    (unsigned long)id_fid(&li->lli_id),
 178                                    (unsigned long)id_group(&li->lli_id));
 179                 }
 180
 181                 if (bits & MDS_INODELOCK_OPEN) {
 182                         int flags = 0;
 183                         switch (lock->l_req_mode) {
 184                         case LCK_CW:
 185                                 flags = FMODE_WRITE;
 186                                 break;
 187                         case LCK_PR:
 188                                 flags = FMODE_EXEC;
 189                                 break;
 190                         case LCK_CR:
 191                                 flags = FMODE_READ;
 192                                 break;
 193                         default:
 194                                 CERROR("Unexpected lock mode for OPEN lock "
 195                                        "%d, inode %ld\n", lock->l_req_mode,
 196                                        inode->i_ino);
 197                         }
 198                         ll_md_real_close(ll_i2mdexp(inode), inode, flags);
 199                 }
 200
 201                 if (bits & MDS_INODELOCK_UPDATE)
 202                         clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
 203                                   &(ll_i2info(inode)->lli_flags));
 204
 205
 206                 /* If lookup lock is cancelled, we just drop the dentry and
 207                    this will cause us to reget data from MDS when we'd want to
 208                    access this dentry/inode again. If this is lock on
 209                    other parts of inode that is cancelled, we do not need to do
 210                    much (but need to discard data from readdir, if any), since
 211                    abscence of lock will cause ll_revalidate_it (called from
 212                    stat() and similar functions) to renew the data anyway */
 213                 if (S_ISDIR(inode->i_mode) &&
 214                     (bits & MDS_INODELOCK_UPDATE)) {
 215                         CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
 216                                inode->i_ino, inode->i_generation, inode);
 217                         truncate_inode_pages(inode->i_mapping, 0);
 218                 }
 219
 220                 if (inode->i_sb->s_root &&
 221                     inode != inode->i_sb->s_root->d_inode &&
 222                     (bits & MDS_INODELOCK_LOOKUP))
 223                         ll_unhash_aliases(inode);
 224                 iput(inode);
 225                 break;
 226         }
 227         default:
 228                 LBUG();
 229         }
 230
 231         RETURN(0);
 232 }
 233
 234 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
 235                          int flags, void *opaque)
 236 {
 237         struct ll_inode_info *li = ll_i2info(inode);
 238         struct ldlm_res_id res_id =
 239                 { .name = {id_fid(&li->lli_id), id_group(&li->lli_id)} };
 240         struct obd_device *obddev = class_conn2obd(conn);
 241         ENTRY;
 242
 243         RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
 244                                       opaque));
 245 }
 246
 247 /* Search "inode"'s alias list for a dentry that has the same name and parent as
 248  * de.  If found, return it.  If not found, return de. */
 249 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
 250 {
 251         struct list_head *tmp;
 252
 253         spin_lock(&dcache_lock);
 254         list_for_each(tmp, &inode->i_dentry) {
 255                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 256
 257                 /* We are called here with 'de' already on the aliases list. */
 258                 if (dentry == de) {
 259                         CERROR("whoops\n");
 260                         continue;
 261                 }
 262
 263                 if (dentry->d_parent != de->d_parent)
 264                         continue;
 265
 266                 if (dentry->d_name.len != de->d_name.len)
 267                         continue;
 268
 269                 if (memcmp(dentry->d_name.name, de->d_name.name,
 270                            de->d_name.len) != 0)
 271                         continue;
 272
 273                 if (!list_empty(&dentry->d_lru))
 274                         list_del_init(&dentry->d_lru);
 275
 276                 hlist_del_init(&dentry->d_hash);
 277                 __d_rehash(dentry); /* avoid taking dcache_lock inside */
 278                 spin_unlock(&dcache_lock);
 279                 atomic_inc(&dentry->d_count);
 280                 iput(inode);
 281                 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
 282                 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
 283                        "refc %d\n", de->d_name.len, de->d_name.name, de,
 284                        de->d_parent, de->d_inode, atomic_read(&de->d_count));
 285                 return dentry;
 286         }
 287
 288         spin_unlock(&dcache_lock);
 289
 290         return de;
 291 }
 292
 293 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
 294                             struct lookup_intent *it, void *data)
 295 {
 296         struct it_cb_data *icbd = data;
 297         struct dentry **de = icbd->icbd_childp;
 298         struct inode *parent = icbd->icbd_parent;
 299         struct ll_sb_info *sbi = ll_i2sbi(parent);
 300         struct dentry *dentry = *de, *saved = *de;
 301         struct inode *inode = NULL;
 302         int rc;
 303
 304         /* NB 1 request reference will be taken away by ll_intent_lock()
 305          * when I return */
 306         if (!it_disposition(it, DISP_LOOKUP_NEG)) {
 307                 ENTRY;
 308
 309                 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 310                                    &inode, request, offset, dentry->d_sb);
 311                 if (rc)
 312                         RETURN(rc);
 313
 314                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 315                        inode, inode->i_ino, inode->i_generation);
 316
 317                 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 318
 319                 /* If this is a stat, get the authoritative file size */
 320                 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
 321                     ll_i2info(inode)->lli_smd != NULL) {
 322                         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
 323                         ldlm_error_t rc;
 324
 325                         LASSERT(lsm->lsm_object_id != 0);
 326
 327                         /* bug 2334: drop MDS lock before acquiring OST lock */
 328                         ll_intent_drop_lock(it);
 329
 330                         rc = ll_glimpse_size(inode);
 331                         if (rc) {
 332                                 iput(inode);
 333                                 RETURN(rc);
 334                         }
 335                 }
 336
 337                 dentry = *de = ll_find_alias(inode, dentry);
 338         } else {
 339                 ENTRY;
 340         }
 341
 342         dentry->d_op = &ll_d_ops;
 343         ll_set_dd(dentry);
 344
 345         if (dentry == saved)
 346                 d_add(dentry, inode);
 347
 348         RETURN(0);
 349 }
 350
 351 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 352                                    struct nameidata *nd, int flags)
 353 {
 354         struct dentry *save = dentry, *retval;
 355         struct lookup_intent *it = flags ? &nd->intent.open : NULL;
 356         struct lustre_id pid;
 357         struct it_cb_data icbd;
 358         struct ptlrpc_request *req = NULL;
 359         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 360         int rc, gns_it;
 361         ENTRY;
 362
 363         if (dentry->d_name.len > EXT3_NAME_LEN)
 364                 RETURN(ERR_PTR(-ENAMETOOLONG));
 365
 366         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
 367                dentry->d_name.len, dentry->d_name.name, parent->i_ino,
 368                parent->i_generation, parent, LL_IT2STR(it));
 369
 370         if (d_mountpoint(dentry))
 371                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
 372
 373         if (nd != NULL)
 374                 nd->mnt->mnt_last_used = jiffies;
 375
 376         gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
 377         ll_frob_intent(&it, &lookup_it);
 378
 379         icbd.icbd_childp = &dentry;
 380         icbd.icbd_parent = parent;
 381         ll_inode2id(&pid, parent);
 382
 383         rc = md_intent_lock(ll_i2mdexp(parent), &pid,
 384                             dentry->d_name.name, dentry->d_name.len, NULL, 0,
 385                             NULL, it, flags, &req, ll_mdc_blocking_ast);
 386         if (rc < 0)
 387                 GOTO(out, retval = ERR_PTR(rc));
 388
 389         rc = lookup_it_finish(req, 1, it, &icbd);
 390         if (rc != 0) {
 391                 ll_intent_release(it);
 392                 GOTO(out, retval = ERR_PTR(rc));
 393         }
 394
 395         ll_lookup_finish_locks(it, dentry);
 396
 397         if (nd && dentry->d_inode != NULL &&
 398             dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) &&
 399             ((flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN))))
 400         {
 401                 rc = ll_gns_mount_object(dentry, nd->mnt);
 402                 if (rc == -ERESTARTSYS) {
 403                         /* causing syscall restart */
 404                         GOTO(out, retval = ERR_PTR(-ERESTARTSYS));
 405                 }
 406
 407                 if (rc) {
 408                         /*
 409                          * just reporting about GNS failures, lookup() is
 410                          * successful, do not stop it.
 411                          *
 412                          * GNS failure may be that object is found in SUID bit
 413                          * marked dir but it is not regular file and we should
 414                          * lookup further until we find correct mount
 415                          * object. This will allow to perform GNS mount is the
 416                          * following case for instance:
 417                          *
 418                          * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo
 419                          * where all ".mntinfo" are dirs and only last one is
 420                          * reg file.
 421                          */
 422                         CDEBUG(D_INODE, "failed to mount %*s, err %d\n",
 423                                (int)dentry->d_name.len, dentry->d_name.name, rc);
 424                 }
 425         }
 426
 427         if (dentry == save)
 428                 GOTO(out, retval = NULL);
 429         else
 430                 GOTO(out, retval = dentry);
 431  out:
 432         if (req)
 433                 ptlrpc_req_finished(req);
 434         if (it == &lookup_it)
 435                 ll_intent_release(it);
 436         if (dentry->d_inode)
 437                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
 438                        dentry,
 439                        (unsigned long) parent->i_ino,
 440                        (unsigned long) parent->i_generation,
 441                        dentry->d_name.len, dentry->d_name.name,
 442                        (unsigned long) dentry->d_inode->i_ino,
 443                        (unsigned long) dentry->d_inode->i_generation);
 444         else
 445                 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
 446                        dentry,
 447                        (unsigned long) parent->i_ino,
 448                        (unsigned long) parent->i_generation,
 449                        dentry->d_name.len, dentry->d_name.name);
 450         return retval;
 451 }
 452
 453 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 454 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 455                                    struct nameidata *nd)
 456 {
 457         struct dentry *de;
 458         ENTRY;
 459
 460         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 461                 de = ll_lookup_it(parent, dentry, nd, nd->flags);
 462         else
 463                 de = ll_lookup_it(parent, dentry, nd, 0);
 464
 465         RETURN(de);
 466 }
 467 #endif
 468
 469 /* We depend on "mode" being set with the proper file type/umask by now */
 470 static struct inode *ll_create_node(struct inode *dir, const char *name,
 471                                     int namelen, const void *data, int datalen,
 472                                     int mode, __u64 extra,
 473                                     struct lookup_intent *it)
 474 {
 475         struct inode *inode = NULL;
 476         struct ptlrpc_request *request = NULL;
 477         struct ll_sb_info *sbi = ll_i2sbi(dir);
 478         int rc;
 479         ENTRY;
 480
 481
 482         LASSERT(it && LUSTRE_IT(it)->it_disposition);
 483
 484         request = LUSTRE_IT(it)->it_data;
 485         rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 486                            &inode, request, 1, dir->i_sb);
 487         if (rc)
 488                 GOTO(out, inode = ERR_PTR(rc));
 489
 490         LASSERT(list_empty(&inode->i_dentry));
 491
 492         /* We asked for a lock on the directory, but were granted a
 493          * lock on the inode.  Since we finally have an inode pointer,
 494          * stuff it in the lock. */
 495         CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
 496                inode, inode->i_ino, inode->i_generation);
 497         mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 498         EXIT;
 499  out:
 500         ptlrpc_req_finished(request);
 501         return inode;
 502 }
 503
 504 /*
 505  * By the time this is called, we already have created the directory cache
 506  * entry for the new file, but it is so far negative - it has no inode.
 507  *
 508  * We defer creating the OBD object(s) until open, to keep the intent and
 509  * non-intent code paths similar, and also because we do not have the MDS
 510  * inode number before calling ll_create_node() (which is needed for LOV),
 511  * so we would need to do yet another RPC to the MDS to store the LOV EA
 512  * data on the MDS.  If needed, we would pass the PACKED lmm as data and
 513  * lmm_size in datalen (the MDS still has code which will handle that).
 514  *
 515  * If the create succeeds, we fill in the inode information
 516  * with d_instantiate().
 517  */
 518 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 519                         struct lookup_intent *it)
 520 {
 521         struct inode *inode;
 522         struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
 523         struct obd_export *md_exp = ll_i2mdexp(dir);
 524         int rc = 0;
 525         ENTRY;
 526
 527         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
 528                dentry->d_name.len, dentry->d_name.name, dir->i_ino,
 529                dir->i_generation, dir, LL_IT2STR(it));
 530
 531         rc = it_open_error(DISP_OPEN_CREATE, it);
 532         if (rc)
 533                 RETURN(rc);
 534
 535         mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
 536         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
 537                                NULL, 0, mode, 0, it);
 538         if (IS_ERR(inode))
 539                 RETURN(PTR_ERR(inode));
 540
 541         d_instantiate(dentry, inode);
 542         RETURN(0);
 543 }
 544
 545 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 546 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 547 {
 548         return ll_create_it(dir, dentry, mode, &nd->intent.open);
 549 }
 550 #endif
 551
 552 static void ll_update_times(struct ptlrpc_request *request, int offset,
 553                             struct inode *inode)
 554 {
 555         struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
 556                                                sizeof(*body));
 557         LASSERT(body);
 558
 559         if (body->valid & OBD_MD_FLMTIME &&
 560             body->mtime > LTIME_S(inode->i_mtime)) {
 561                 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
 562                        inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
 563                 LTIME_S(inode->i_mtime) = body->mtime;
 564         }
 565         if (body->valid & OBD_MD_FLCTIME &&
 566             body->ctime > LTIME_S(inode->i_ctime))
 567                 LTIME_S(inode->i_ctime) = body->ctime;
 568 }
 569
 570 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
 571 {
 572         struct ptlrpc_request *request = NULL;
 573         struct inode *dir = nd->dentry->d_inode;
 574         struct ll_sb_info *sbi = ll_i2sbi(dir);
 575         struct mdc_op_data *op_data;
 576         int err = -EMLINK;
 577         ENTRY;
 578
 579         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 580                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 581
 582         mode &= ~current->fs->umask;
 583
 584         switch (mode & S_IFMT) {
 585         case 0:
 586         case S_IFREG:
 587                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 588         case S_IFCHR:
 589         case S_IFBLK:
 590         case S_IFIFO:
 591         case S_IFSOCK:
 592                 OBD_ALLOC(op_data, sizeof(*op_data));
 593                 if (op_data == NULL)
 594                         RETURN(-ENOMEM);
 595                 ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 596                                     nd->last.len, 0);
 597                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 598                                 current->fsuid, current->fsgid, rdev,
 599                                 &request);
 600                 OBD_FREE(op_data, sizeof(*op_data));
 601                 if (err == 0)
 602                         ll_update_times(request, 0, dir);
 603                 ptlrpc_req_finished(request);
 604                 break;
 605         case S_IFDIR:
 606                 err = -EPERM;
 607                 break;
 608         default:
 609                 err = -EINVAL;
 610         }
 611         RETURN(err);
 612 }
 613
 614 static int ll_mknod(struct inode *dir, struct dentry *dchild,
 615                     int mode, ll_dev_t rdev)
 616 {
 617         struct ptlrpc_request *request = NULL;
 618         struct inode *inode = NULL;
 619         struct ll_sb_info *sbi = ll_i2sbi(dir);
 620         struct mdc_op_data *op_data;
 621         int err = -EMLINK;
 622         ENTRY;
 623
 624         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 625                dchild->d_name.len, dchild->d_name.name,
 626                dir->i_ino, dir->i_generation, dir);
 627
 628         mode &= ~current->fs->umask;
 629
 630         switch (mode & S_IFMT) {
 631         case 0:
 632         case S_IFREG:
 633                 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
 634         case S_IFCHR:
 635         case S_IFBLK:
 636         case S_IFIFO:
 637         case S_IFSOCK:
 638                 OBD_ALLOC(op_data, sizeof(*op_data));
 639                 if (op_data == NULL)
 640                         RETURN(-ENOMEM);
 641                 ll_prepare_mdc_data(op_data, dir, NULL, dchild->d_name.name,
 642                                     dchild->d_name.len, 0);
 643                 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 644                                 current->fsuid, current->fsgid, rdev,
 645                                 &request);
 646                 OBD_FREE(op_data, sizeof(*op_data));
 647                 if (err)
 648                         GOTO(out_err, err);
 649
 650                 ll_update_times(request, 0, dir);
 651                 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 652                                     &inode, request, 0, dchild->d_sb);
 653                 if (err)
 654                         GOTO(out_err, err);
 655                 break;
 656         case S_IFDIR:
 657                 RETURN(-EPERM);
 658                 break;
 659         default:
 660                 RETURN(-EINVAL);
 661         }
 662
 663         d_instantiate(dchild, inode);
 664         EXIT;
 665  out_err:
 666         ptlrpc_req_finished(request);
 667         return err;
 668 }
 669
 670 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
 671 {
 672         struct inode *dir = nd->dentry->d_inode;
 673         struct ptlrpc_request *request = NULL;
 674         struct ll_sb_info *sbi = ll_i2sbi(dir);
 675         const char *name = nd->last.name;
 676         struct mdc_op_data *op_data;
 677         int len = nd->last.len;
 678         int err = -EMLINK;
 679         ENTRY;
 680
 681         CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
 682                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
 683                dir, tgt);
 684
 685         if (dir->i_nlink >= EXT3_LINK_MAX)
 686                 RETURN(err);
 687
 688         OBD_ALLOC(op_data, sizeof(*op_data));
 689         if (op_data == NULL)
 690                 RETURN(-ENOMEM);
 691         ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
 692         LASSERT(tgt);
 693         err = md_create(sbi->ll_md_exp, op_data,
 694                         tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
 695                         current->fsuid, current->fsgid, 0, &request);
 696         OBD_FREE(op_data, sizeof(*op_data));
 697         if (err == 0)
 698                 ll_update_times(request, 0, dir);
 699
 700         ptlrpc_req_finished(request);
 701         RETURN(err);
 702 }
 703
 704 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 705 {
 706         struct inode *src = srcnd->dentry->d_inode;
 707         struct inode *dir = tgtnd->dentry->d_inode;
 708         struct ptlrpc_request *request = NULL;
 709         struct mdc_op_data *op_data;
 710         int err;
 711         struct ll_sb_info *sbi = ll_i2sbi(dir);
 712         ENTRY;
 713
 714         CDEBUG(D_VFSTRACE,
 715                "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
 716                src->i_ino, src->i_generation, src, dir->i_ino,
 717                dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
 718
 719         OBD_ALLOC(op_data, sizeof(*op_data));
 720         if (op_data == NULL)
 721                 RETURN(-ENOMEM);
 722         ll_prepare_mdc_data(op_data, src, dir, tgtnd->last.name,
 723                             tgtnd->last.len, 0);
 724         err = md_link(sbi->ll_md_exp, op_data, &request);
 725         OBD_FREE(op_data, sizeof(*op_data));
 726         if (err == 0)
 727                 ll_update_times(request, 0, dir);
 728         ptlrpc_req_finished(request);
 729         RETURN(err);
 730 }
 731
 732
 733 static int ll_mkdir_raw(struct nameidata *nd, int mode)
 734 {
 735         struct inode *dir = nd->dentry->d_inode;
 736         struct ptlrpc_request *request = NULL;
 737         struct ll_sb_info *sbi = ll_i2sbi(dir);
 738         struct mdc_op_data *op_data;
 739         int err = -EMLINK;
 740         ENTRY;
 741         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 742                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 743
 744         mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
 745         OBD_ALLOC(op_data, sizeof(*op_data));
 746         if (op_data == NULL)
 747                 RETURN(-ENOMEM);
 748         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 749                             nd->last.len, 0);
 750         err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
 751                         current->fsuid, current->fsgid, 0, &request);
 752         OBD_FREE(op_data, sizeof(*op_data));
 753         if (err == 0)
 754                 ll_update_times(request, 0, dir);
 755         ptlrpc_req_finished(request);
 756         RETURN(err);
 757 }
 758
 759 static int ll_rmdir_raw(struct nameidata *nd)
 760 {
 761         struct inode *dir = nd->dentry->d_inode;
 762         struct ptlrpc_request *request = NULL;
 763         struct mdc_op_data *op_data;
 764         int rc;
 765
 766         ENTRY;
 767         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 768                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 769
 770         OBD_ALLOC(op_data, sizeof(*op_data));
 771         if (op_data == NULL)
 772                 RETURN(-ENOMEM);
 773         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name,
 774                             nd->last.len, S_IFDIR);
 775         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 776         OBD_FREE(op_data, sizeof(*op_data));
 777         if (rc == 0)
 778                 ll_update_times(request, 0, dir);
 779         ptlrpc_req_finished(request);
 780         RETURN(rc);
 781 }
 782
 783 int ll_objects_destroy(struct ptlrpc_request *request,
 784                        struct inode *dir, int offset)
 785 {
 786         struct mds_body *body;
 787         struct lov_mds_md *eadata;
 788         struct lov_stripe_md *lsm = NULL;
 789         struct obd_trans_info oti = { 0 };
 790         struct obdo *oa;
 791         int rc;
 792         ENTRY;
 793
 794         /* req is swabbed so this is safe */
 795         body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
 796
 797         if (!(body->valid & OBD_MD_FLEASIZE))
 798                 RETURN(0);
 799
 800         if (body->eadatasize == 0) {
 801                 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
 802                 GOTO(out, rc = -EPROTO);
 803         }
 804
 805         /*
 806          * the MDS sent back the EA because we unlinked the last reference to
 807          * this file. Use this EA to unlink the objects on the OST. It's opaque
 808          * so we don't swab here; we leave it to obd_unpackmd() to check it is
 809          * complete and sensible.
 810          */
 811         eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
 812         LASSERT(eadata != NULL);
 813         if (eadata == NULL) {
 814                 CERROR("Can't unpack MDS EA data\n");
 815                 GOTO(out, rc = -EPROTO);
 816         }
 817
 818         rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize);
 819         if (rc < 0) {
 820                 CERROR("obd_unpackmd: %d\n", rc);
 821                 GOTO(out, rc);
 822         }
 823         LASSERT(rc >= sizeof(*lsm));
 824
 825         oa = obdo_alloc();
 826         if (oa == NULL)
 827                 GOTO(out_free_memmd, rc = -ENOMEM);
 828
 829         oa->o_id = lsm->lsm_object_id;
 830         oa->o_gr = lsm->lsm_object_gr;
 831         oa->o_mode = body->mode & S_IFMT;
 832         oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
 833
 834         if (body->valid & OBD_MD_FLCOOKIE) {
 835                 int length = sizeof(struct llog_cookie) *
 836                                 lsm->lsm_stripe_count;
 837                 oa->o_valid |= OBD_MD_FLCOOKIE;
 838                 oti.oti_logcookies =
 839                         lustre_msg_buf(request->rq_repmsg, 2, length);
 840                 if (oti.oti_logcookies == NULL) {
 841                         oa->o_valid &= ~OBD_MD_FLCOOKIE;
 842                         body->valid &= ~OBD_MD_FLCOOKIE;
 843                 } else {
 844                         /* copy llog cookies to request to replay unlink
 845                          * so that the same llog file and records as those created
 846                          * during fail can be re-created while doing replay
 847                          */
 848                         if (offset >= 0)
 849                                 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
 850                                        oti.oti_logcookies, length);
 851                 }
 852         }
 853
 854         rc = obd_destroy(ll_i2dtexp(dir), oa, lsm, &oti);
 855         obdo_free(oa);
 856         if (rc)
 857                 CERROR("obd destroy objid "LPX64" error %d\n",
 858                        lsm->lsm_object_id, rc);
 859         EXIT;
 860  out_free_memmd:
 861         obd_free_memmd(ll_i2dtexp(dir), &lsm);
 862  out:
 863         return rc;
 864 }
 865
 866 static int ll_unlink_raw(struct nameidata *nd)
 867 {
 868         struct inode *dir = nd->dentry->d_inode;
 869         struct ptlrpc_request *request = NULL;
 870         struct mdc_op_data *op_data;
 871         int rc;
 872         ENTRY;
 873         CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
 874                nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
 875
 876         OBD_ALLOC(op_data, sizeof(*op_data));
 877         if (op_data == NULL)
 878                 RETURN(-ENOMEM);
 879         ll_prepare_mdc_data(op_data, dir, NULL, nd->last.name, nd->last.len, 0);
 880         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
 881         OBD_FREE(op_data, sizeof(*op_data));
 882         if (rc)
 883                 GOTO(out, rc);
 884         ll_update_times(request, 0, dir);
 885
 886         rc = ll_objects_destroy(request, dir, 2);
 887         EXIT;
 888 out:
 889         ptlrpc_req_finished(request);
 890         return rc;
 891 }
 892
 893 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
 894 {
 895         struct inode *src = srcnd->dentry->d_inode;
 896         struct inode *tgt = tgtnd->dentry->d_inode;
 897         struct ptlrpc_request *request = NULL;
 898         struct ll_sb_info *sbi = ll_i2sbi(src);
 899         struct mdc_op_data *op_data;
 900         int err;
 901         ENTRY;
 902
 903         if (srcnd->mnt != tgtnd->mnt)
 904                 RETURN(-EXDEV);
 905
 906         CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
 907                "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
 908                src->i_ino, src->i_generation, src, tgtnd->last.len,
 909                tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
 910
 911         OBD_ALLOC(op_data, sizeof(*op_data));
 912         if (op_data == NULL)
 913                 RETURN(-ENOMEM);
 914         ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
 915         err = md_rename(sbi->ll_md_exp, op_data, srcnd->last.name,
 916                         srcnd->last.len, tgtnd->last.name, tgtnd->last.len,
 917                         &request);
 918         OBD_FREE(op_data, sizeof(*op_data));
 919         if (!err) {
 920                 ll_update_times(request, 0, src);
 921                 ll_update_times(request, 0, tgt);
 922                 err = ll_objects_destroy(request, src, 3);
 923         }
 924
 925         ptlrpc_req_finished(request);
 926         RETURN(err);
 927 }
 928
 929 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 930 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
 931 static int ll_rawop_from_intent(struct nameidata *nd)
 932 {
 933         int error = 0;
 934
 935         if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
 936                 return 0;
 937
 938         switch (nd->intent.open.op) {
 939         case IT_MKNOD:
 940                 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
 941                                      nd->intent.open.create.dev);
 942                 break;
 943         case IT_MKDIR:
 944                 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
 945                 break;
 946         case IT_RMDIR:
 947                 error = ll_rmdir_raw(nd);
 948                 break;
 949         case IT_UNLINK:
 950                 error = ll_unlink_raw(nd);
 951                 break;
 952         case IT_SYMLINK:
 953                 LASSERT(nd->intent.open.create.link);
 954                 error = ll_symlink_raw(nd, nd->intent.open.create.link);
 955                 break;
 956         case IT_LINK:
 957                 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
 958                 break;
 959         case IT_RENAME:
 960                 LASSERT(nd->intent.open.create.source_nd);
 961                 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
 962                 break;
 963         default:
 964                 LBUG();
 965         }
 966         if (error != -EOPNOTSUPP)
 967                 nd->intent.open.flags |= IT_STATUS_RAW;
 968
 969         return error;
 970 }
 971 #endif
 972
 973 struct inode_operations ll_dir_inode_operations = {
 974         .mknod              = ll_mknod,
 975         .setattr            = ll_setattr,
 976 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 977         .create_it          = ll_create_it,
 978         .lookup_it          = ll_lookup_it,
 979         .revalidate_it      = ll_inode_revalidate_it,
 980 #else
 981         .lookup             = ll_lookup_nd,
 982         .create             = ll_create_nd,
 983         .getattr            = ll_getattr,
 984         .endparentlookup    = ll_rawop_from_intent,
 985 #endif
 986         .setxattr           = ll_setxattr,
 987         .getxattr           = ll_getxattr,
 988         .listxattr          = ll_listxattr,
 989         .removexattr        = ll_removexattr,
 990         .permission         = ll_inode_permission,
 991 };