X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fnamei.c;h=5795c406bae946eedc728f152fe270367d47fbdb;hb=138544d2c4b5332902d8141c0d119074123e072b;hp=8b504594a8c8ae8e5875bc065412639bc076306b;hpb=4d6b0dbdc7d12e31fa2567e3546d982d3eb9cc20;p=fs%2Flustre-release.git diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index 8b50459..5795c40 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -1,31 +1,37 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (c) 2002, 2003 Cluster File Systems, Inc. + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * derived in small part from linux/fs/ext2/namei.c + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. * - * Copyright (C) 1991, 1992 Linus Torvalds - * - * Big-endian to little-endian byte-swapping/bitmaps by - * David S. Miller (davem@caip.rutgers.edu), 1995 - * Directory entry file type support and forward compatibility hooks - * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998 + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ #include @@ -35,65 +41,40 @@ #include #include #include +#include +#include #define DEBUG_SUBSYSTEM S_LLITE -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include "llite_internal.h" -/* methods */ - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque) -#else -static int ll_test_inode(struct inode *inode, void *opaque) -#endif +/* + * Check if we have something mounted at the named dchild. + * In such a case there would always be dentry present. + */ +static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild, + struct qstr *name) { - static int last_ino, last_gen, last_count; - struct lustre_md *md = opaque; - - if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) { - CERROR("MDS body missing inum or generation\n"); - return 0; + int mounted = 0; + + if (unlikely(dchild)) { + mounted = d_mountpoint(dchild); + } else if (dparent) { + dchild = d_lookup(dparent, name); + if (dchild) { + mounted = d_mountpoint(dchild); + dput(dchild); + } } - - if (last_ino == id_ino(&md->body->id1) && - last_gen == id_gen(&md->body->id1) && - last_count < 500) { - last_count++; - } else { - if (last_count > 1) - CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n", - last_ino, last_gen, last_count); - last_count = 0; - last_ino = id_ino(&md->body->id1); - last_gen = id_gen(&md->body->id1); - CDEBUG(D_VFSTRACE, - "comparing inode %p ino "DLID4" to body "DLID4"\n", - inode, OLID4(&ll_i2info(inode)->lli_id), - OLID4(&md->body->id1)); - } - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) - if (inode->i_ino != id_ino(&md->body->id1)) - return 0; -#endif - if (inode->i_generation != id_gen(&md->body->id1)) - return 0; - - if (id_group(&ll_i2info(inode)->lli_id) != id_group(&md->body->id1)) - return 0; - - /* apply the attributes in 'opaque' to this inode. */ - ll_update_inode(inode, md); - return 1; + return mounted; } -extern struct dentry_operations ll_d_ops; - int ll_unlock(__u32 mode, struct lustre_handle *lockh) { ENTRY; @@ -103,50 +84,98 @@ int ll_unlock(__u32 mode, struct lustre_handle *lockh) RETURN(0); } -/* - * get an inode by inode number (already instantiated by the intent lookup). - * Returns inode or NULL. - */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) -int ll_set_inode(struct inode *inode, void *opaque) + +/* called from iget5_locked->find_inode() under inode_lock spinlock */ +static int ll_test_inode(struct inode *inode, void *opaque) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct lustre_md *md = opaque; + + if (unlikely(!(md->body->valid & OBD_MD_FLID))) { + CERROR("MDS body missing FID\n"); + return 0; + } + + if (!lu_fid_eq(&lli->lli_fid, &md->body->fid1)) + return 0; + + return 1; +} + +static int ll_set_inode(struct inode *inode, void *opaque) { - ll_read_inode2(inode, opaque); return 0; } + +/* + * Get an inode by inode number (already instantiated by the intent lookup). + * Returns inode or NULL + */ struct inode *ll_iget(struct super_block *sb, ino_t hash, struct lustre_md *md) { - struct inode *inode; + struct ll_inode_info *lli; + struct inode *inode; + ENTRY; LASSERT(hash != 0); inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md); if (inode) { - if (inode->i_state & I_NEW) - unlock_new_inode(inode); - CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino, - inode->i_generation, inode); + lli = ll_i2info(inode); + if (inode->i_state & I_NEW) { + int rc; + + ll_read_inode2(inode, md); + rc = cl_inode_init(inode, md); + if (rc != 0) { + md->lsm = NULL; + make_bad_inode(inode); + unlock_new_inode(inode); + iput(inode); + inode = ERR_PTR(rc); + } else + unlock_new_inode(inode); + } else if (!(inode->i_state & (I_FREEING | I_CLEAR))) + ll_update_inode(inode, md); + CDEBUG(D_VFSTRACE, "got inode: %p for "DFID"\n", + inode, PFID(&md->body->fid1)); } - - return inode; + RETURN(inode); } -#else -struct inode *ll_iget(struct super_block *sb, ino_t hash, - struct lustre_md *md) + +static void ll_drop_negative_dentry(struct inode *dir) { - struct inode *inode; - LASSERT(hash != 0); - inode = iget4(sb, hash, ll_test_inode, md); - if (inode) - CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino, - inode->i_generation, inode); - return inode; + struct dentry *dentry, *tmp_alias, *tmp_subdir; + + spin_lock(&ll_lookup_lock); + spin_lock(&dcache_lock); +restart: + list_for_each_entry_safe(dentry, tmp_alias, + &dir->i_dentry,d_alias) { + if (!list_empty(&dentry->d_subdirs)) { + struct dentry *child; + list_for_each_entry_safe(child, tmp_subdir, + &dentry->d_subdirs, + d_child) { + /* XXX Print some debug here? */ + if (!child->d_inode) + /* Negative dentry. If we were + dropping dcache lock, go + throught the list again */ + if (ll_drop_dentry(child)) + goto restart; + } + } + } + spin_unlock(&dcache_lock); + spin_unlock(&ll_lookup_lock); } -#endif -int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, - void *data, int flag) + +int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, + void *data, int flag) { int rc; struct lustre_handle lockh; @@ -163,19 +192,30 @@ int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, break; case LDLM_CB_CANCELING: { struct inode *inode = ll_inode_from_lock(lock); - struct ll_inode_info *li = ll_i2info(inode); __u64 bits = lock->l_policy_data.l_inodebits.bits; + struct lu_fid *fid; - /* For lookup locks: Invalidate all dentries associated with - this inode, for UPDATE locks - invalidate directory pages */ + /* Invalidate all dentries associated with this inode */ if (inode == NULL) break; - if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) || - lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) { - LDLM_ERROR(lock, "data mismatch with object %lu/%lu", - (unsigned long)id_fid(&li->lli_id), - (unsigned long)id_group(&li->lli_id)); + LASSERT(lock->l_flags & LDLM_FL_CANCELING); + if ((bits & MDS_INODELOCK_LOOKUP) && + ll_have_md_lock(inode, MDS_INODELOCK_LOOKUP)) + bits &= ~MDS_INODELOCK_LOOKUP; + if ((bits & MDS_INODELOCK_UPDATE) && + ll_have_md_lock(inode, MDS_INODELOCK_UPDATE)) + bits &= ~MDS_INODELOCK_UPDATE; + if ((bits & MDS_INODELOCK_OPEN) && + ll_have_md_lock(inode, MDS_INODELOCK_OPEN)) + bits &= ~MDS_INODELOCK_OPEN; + + fid = ll_inode2fid(inode); + if (lock->l_resource->lr_name.name[0] != fid_seq(fid) || + lock->l_resource->lr_name.name[1] != fid_oid(fid) || + lock->l_resource->lr_name.name[2] != fid_ver(fid)) { + LDLM_ERROR(lock, "data mismatch with object " + DFID" (%p)", PFID(fid), inode); } if (bits & MDS_INODELOCK_OPEN) { @@ -195,34 +235,20 @@ int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, "%d, inode %ld\n", lock->l_req_mode, inode->i_ino); } - ll_md_real_close(ll_i2mdexp(inode), inode, flags); - } - - if ((bits & MDS_INODELOCK_UPDATE) && LLI_HAVE_FLSIZE(inode)) { - CDEBUG(D_OTHER, "isize for %lu/%u(%p) from mds " - "is not actual\n", inode->i_ino, - inode->i_generation, inode); - clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, - &(ll_i2info(inode)->lli_flags)); + ll_md_real_close(inode, flags); } + if (bits & MDS_INODELOCK_UPDATE) + ll_i2info(inode)->lli_flags &= ~LLIF_MDS_SIZE_LOCK; - /* If lookup lock is cancelled, we just drop the dentry and - this will cause us to reget data from MDS when we'd want to - access this dentry/inode again. If this is lock on - other parts of inode that is cancelled, we do not need to do - much (but need to discard data from readdir, if any), since - abscence of lock will cause ll_revalidate_it (called from - stat() and similar functions) to renew the data anyway */ if (S_ISDIR(inode->i_mode) && - (bits & MDS_INODELOCK_UPDATE)) { - CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n", - inode->i_ino, inode->i_generation, inode); + (bits & MDS_INODELOCK_UPDATE)) { + CDEBUG(D_INODE, "invalidating inode %lu\n", + inode->i_ino); truncate_inode_pages(inode->i_mapping, 0); + ll_drop_negative_dentry(inode); } - ll_inode_invalidate_acl(inode); - if (inode->i_sb->s_root && inode != inode->i_sb->s_root->d_inode && (bits & MDS_INODELOCK_LOOKUP)) @@ -237,25 +263,111 @@ int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, RETURN(0); } -/* Search "inode"'s alias list for a dentry that has the same name and parent as - * de. If found, return it. If not found, return de. */ -struct dentry *ll_find_alias(struct inode *inode, struct dentry *de) +__u32 ll_i2suppgid(struct inode *i) +{ + if (in_group_p(i->i_gid)) + return (__u32)i->i_gid; + else + return (__u32)(-1); +} + +/* Pack the required supplementary groups into the supplied groups array. + * If we don't need to use the groups from the target inode(s) then we + * instead pack one or more groups from the user's supplementary group + * array in case it might be useful. Not needed if doing an MDS-side upcall. */ +void ll_i2gids(__u32 *suppgids, struct inode *i1, struct inode *i2) +{ +#if 0 + int i; +#endif + + LASSERT(i1 != NULL); + LASSERT(suppgids != NULL); + + suppgids[0] = ll_i2suppgid(i1); + + if (i2) + suppgids[1] = ll_i2suppgid(i2); + else + suppgids[1] = -1; + +#if 0 + for (i = 0; i < current_ngroups; i++) { + if (suppgids[0] == -1) { + if (current_groups[i] != suppgids[1]) + suppgids[0] = current_groups[i]; + continue; + } + if (suppgids[1] == -1) { + if (current_groups[i] != suppgids[0]) + suppgids[1] = current_groups[i]; + continue; + } + break; + } +#endif +} + +static void ll_d_add(struct dentry *de, struct inode *inode) +{ + CDEBUG(D_DENTRY, "adding inode %p to dentry %p\n", inode, de); + /* d_instantiate */ + if (!list_empty(&de->d_alias)) { + spin_unlock(&dcache_lock); + CERROR("dentry %.*s %p alias next %p, prev %p\n", + de->d_name.len, de->d_name.name, de, + de->d_alias.next, de->d_alias.prev); + LBUG(); + } + if (inode) + list_add(&de->d_alias, &inode->i_dentry); + de->d_inode = inode; + + /* d_rehash */ + if (!d_unhashed(de)) { + spin_unlock(&dcache_lock); + CERROR("dentry %.*s %p hash next %p\n", + de->d_name.len, de->d_name.name, de, de->d_hash.next); + LBUG(); + } + d_rehash_cond(de, 0); +} + +/* Search "inode"'s alias list for a dentry that has the same name and parent + * as de. If found, return it. If not found, return de. + * Lustre can't use d_add_unique because don't unhash aliases for directory + * in ll_revalidate_it. After revaliadate inode will be have hashed aliases + * and it triggers BUG_ON in d_instantiate_unique (bug #10954). + */ +static struct dentry *ll_find_alias(struct inode *inode, struct dentry *de) { struct list_head *tmp; + struct dentry *dentry; + struct dentry *last_discon = NULL; + spin_lock(&ll_lookup_lock); spin_lock(&dcache_lock); list_for_each(tmp, &inode->i_dentry) { - struct dentry *dentry = list_entry(tmp, struct dentry, d_alias); + dentry = list_entry(tmp, struct dentry, d_alias); /* We are called here with 'de' already on the aliases list. */ - if (dentry == de) { + if (unlikely(dentry == de)) { CERROR("whoops\n"); continue; } + if (dentry->d_flags & DCACHE_DISCONNECTED) { + LASSERT(last_discon == NULL); + last_discon = dentry; + continue; + } + if (dentry->d_parent != de->d_parent) continue; + if (dentry->d_name.hash != de->d_name.hash) + continue; + if (dentry->d_name.len != de->d_name.len) continue; @@ -263,100 +375,130 @@ struct dentry *ll_find_alias(struct inode *inode, struct dentry *de) de->d_name.len) != 0) continue; - if (!list_empty(&dentry->d_lru)) - list_del_init(&dentry->d_lru); - - hlist_del_init(&dentry->d_hash); - __d_rehash(dentry); /* avoid taking dcache_lock inside */ + dget_locked(dentry); + lock_dentry(dentry); + __d_drop(dentry); +#ifdef DCACHE_LUSTRE_INVALID + dentry->d_flags &= ~DCACHE_LUSTRE_INVALID; +#endif + unlock_dentry(dentry); + ll_dops_init(dentry, 0); + d_rehash_cond(dentry, 0); /* avoid taking dcache_lock inside */ spin_unlock(&dcache_lock); - atomic_inc(&dentry->d_count); + spin_unlock(&ll_lookup_lock); iput(inode); - dentry->d_flags &= ~DCACHE_LUSTRE_INVALID; - CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p " + CDEBUG(D_DENTRY, "alias dentry %.*s (%p) parent %p inode %p " "refc %d\n", de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode, atomic_read(&de->d_count)); return dentry; } + if (last_discon) { + CDEBUG(D_DENTRY, "Reuse disconnected dentry %p inode %p " + "refc %d\n", last_discon, last_discon->d_inode, + atomic_read(&last_discon->d_count)); + dget_locked(last_discon); + spin_unlock(&dcache_lock); + spin_unlock(&ll_lookup_lock); + ll_dops_init(last_discon, 1); + d_rehash(de); + d_move(last_discon, de); + iput(inode); + return last_discon; + } + + ll_d_add(de, inode); + spin_unlock(&dcache_lock); + spin_unlock(&ll_lookup_lock); return de; } -static int lookup_it_finish(struct ptlrpc_request *request, int offset, - struct lookup_intent *it, void *data) +int ll_lookup_it_finish(struct ptlrpc_request *request, + struct lookup_intent *it, void *data) { struct it_cb_data *icbd = data; struct dentry **de = icbd->icbd_childp; struct inode *parent = icbd->icbd_parent; struct ll_sb_info *sbi = ll_i2sbi(parent); - struct dentry *dentry = *de, *saved = *de; struct inode *inode = NULL; int rc; + ENTRY; /* NB 1 request reference will be taken away by ll_intent_lock() * when I return */ if (!it_disposition(it, DISP_LOOKUP_NEG)) { - ENTRY; + struct dentry *save = *de; - rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp, - &inode, request, offset, dentry->d_sb); + rc = ll_prep_inode(&inode, request, (*de)->d_sb); if (rc) RETURN(rc); CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n", inode, inode->i_ino, inode->i_generation); - - mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode); - - /* If this is a stat, get the authoritative file size */ - if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) && - ll_i2info(inode)->lli_smd != NULL) { - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; - ldlm_error_t rc; - - LASSERT(lsm->lsm_object_id != 0); - - /* bug 2334: drop MDS lock before acquiring OST lock */ - ll_intent_drop_lock(it); - - if (!LLI_HAVE_FLSIZE(inode)) { - CDEBUG(D_INODE, "retrieve size from OSS\n"); - rc = ll_glimpse_size(inode); - if (rc) { - iput(inode); - RETURN(rc); - } + md_set_lock_data(sbi->ll_md_exp, + &it->d.lustre.it_lock_handle, inode); + + /* We used to query real size from OSTs here, but actually + this is not needed. For stat() calls size would be updated + from subsequent do_revalidate()->ll_inode_revalidate_it() in + 2.4 and + vfs_getattr_it->ll_getattr()->ll_inode_revalidate_it() in 2.6 + Everybody else who needs correct file size would call + cl_glimpse_size or some equivalent themselves anyway. + Also see bug 7198. */ + + ll_dops_init(*de, 1); + *de = ll_find_alias(inode, *de); + if (*de != save) { + struct ll_dentry_data *lld = ll_d2d(*de); + + /* just make sure the ll_dentry_data is ready */ + if (unlikely(lld == NULL)) { + ll_set_dd(*de); + lld = ll_d2d(*de); + if (likely(lld != NULL)) + lld->lld_sa_generation = 0; } } - - dentry = *de = ll_find_alias(inode, dentry); } else { - ENTRY; + ll_dops_init(*de, 1); + /* Check that parent has UPDATE lock. If there is none, we + cannot afford to hash this dentry (done by ll_d_add) as it + might get picked up later when UPDATE lock will appear */ + if (ll_have_md_lock(parent, MDS_INODELOCK_UPDATE)) { + spin_lock(&dcache_lock); + ll_d_add(*de, NULL); + spin_unlock(&dcache_lock); + } else { + (*de)->d_inode = NULL; + /* We do not want to hash the dentry if don`t have a + * lock, but if this dentry is later used in d_move, + * we'd hit uninitialised list head d_hash, so we just + * do this to init d_hash field but leave dentry + * unhashed. (bug 10796). */ + d_rehash(*de); + d_drop(*de); + } } - dentry->d_op = &ll_d_ops; - ll_set_dd(dentry); - - if (dentry == saved) - d_add(dentry, inode); - RETURN(0); } static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, - struct nameidata *nd, int flags) + struct lookup_intent *it, int lookup_flags) { - struct lookup_intent *it = flags ? &nd->intent.open : NULL; struct lookup_intent lookup_it = { .it_op = IT_LOOKUP }; struct dentry *save = dentry, *retval; struct ptlrpc_request *req = NULL; - int rc, gns_it, gns_flags; + struct md_op_data *op_data; struct it_cb_data icbd; - struct lustre_id pid; + __u32 opc; + int rc, first = 0; ENTRY; - if (dentry->d_name.len > EXT3_NAME_LEN) + if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen) RETURN(ERR_PTR(-ENAMETOOLONG)); CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n", @@ -366,65 +508,65 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, if (d_mountpoint(dentry)) CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it)); - if (nd != NULL) - nd->mnt->mnt_last_used = jiffies; - - gns_it = nd ? nd->intent.open.it_op : IT_OPEN; - gns_flags = nd ? nd->flags : LOOKUP_CONTINUE; ll_frob_intent(&it, &lookup_it); + /* As do_lookup is called before follow_mount, root dentry may be left + * not valid, revalidate it here. */ + if (parent->i_sb->s_root && (parent->i_sb->s_root->d_inode == parent) && + (it->it_op & (IT_OPEN | IT_CREAT))) { + rc = ll_inode_revalidate_it(parent->i_sb->s_root, it); + if (rc) + RETURN(ERR_PTR(rc)); + } + + if (it->it_op == IT_GETATTR) { + first = ll_statahead_enter(parent, &dentry, 1); + if (first >= 0) { + ll_statahead_exit(dentry, first); + if (first == 1) + RETURN(retval = dentry); + } + } + icbd.icbd_childp = &dentry; icbd.icbd_parent = parent; - ll_inode2id(&pid, parent); - - /*ONLY need key for open_create file*/ - rc = ll_crypto_init_it_key(parent, it); - if (rc != 0) - GOTO(out, retval = ERR_PTR(rc)); - - rc = md_intent_lock(ll_i2mdexp(parent), &pid, (char *)dentry->d_name.name, - dentry->d_name.len, NULL, 0, NULL, it, flags, &req, - ll_mdc_blocking_ast); + + if (it->it_op & IT_CREAT || + (it->it_op & IT_OPEN && it->it_create_mode & O_CREAT)) + opc = LUSTRE_OPC_CREATE; + else + opc = LUSTRE_OPC_ANY; + + op_data = ll_prep_md_op_data(NULL, parent, NULL, dentry->d_name.name, + dentry->d_name.len, lookup_flags, opc, + NULL); + if (IS_ERR(op_data)) + RETURN((void *)op_data); + + it->it_create_mode &= ~current->fs->umask; + + rc = md_intent_lock(ll_i2mdexp(parent), op_data, NULL, 0, it, + lookup_flags, &req, ll_md_blocking_ast, 0); + ll_finish_md_op_data(op_data); if (rc < 0) GOTO(out, retval = ERR_PTR(rc)); - rc = lookup_it_finish(req, 1, it, &icbd); + rc = ll_lookup_it_finish(req, it, &icbd); if (rc != 0) { ll_intent_release(it); GOTO(out, retval = ERR_PTR(rc)); } - ll_lookup_finish_locks(it, dentry); + if (first == -EEXIST) + ll_statahead_mark(dentry); - if (nd && dentry->d_inode != NULL && - dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) && - ((gns_flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN)))) - { - CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, " - "mounting it\n", (int)dentry->d_name.len, - dentry->d_name.name, dentry); - - rc = ll_gns_mount_object(dentry, nd->mnt); - if (rc) { - /* - * just reporting about GNS failures, lookup() is - * successful, do not stop it. - * - * GNS failure may be that object is found in SUID bit - * marked dir but it is not regular file and we should - * lookup further until we find correct mount - * object. This will allow to perform GNS mount is the - * following case for instance: - * - * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo - * where all ".mntinfo" are dirs and only last one is - * reg file. - */ - CDEBUG(D_DENTRY, "failed to mount %*s, err %d\n", - (int)dentry->d_name.len, dentry->d_name.name, rc); - } + if ((it->it_op & IT_OPEN) && dentry->d_inode && + !S_ISREG(dentry->d_inode->i_mode) && + !S_ISDIR(dentry->d_inode->i_mode)) { + ll_release_openhandle(dentry, it); } - + ll_lookup_finish_locks(it, dentry); + if (dentry == save) GOTO(out, retval = NULL); else @@ -432,26 +574,10 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, out: if (req) ptlrpc_req_finished(req); - if (it == &lookup_it) - ll_intent_release(it); - if (dentry->d_inode) - CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n", - dentry, - (unsigned long) parent->i_ino, - (unsigned long) parent->i_generation, - dentry->d_name.len, dentry->d_name.name, - (unsigned long) dentry->d_inode->i_ino, - (unsigned long) dentry->d_inode->i_generation); - else - CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n", - dentry, - (unsigned long) parent->i_ino, - (unsigned long) parent->i_generation, - dentry->d_name.len, dentry->d_name.name); return retval; } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +#ifdef HAVE_VFS_INTENT_PATCHES static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, struct nameidata *nd) { @@ -459,14 +585,167 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, ENTRY; if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST)) - de = ll_lookup_it(parent, dentry, nd, nd->flags); + de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags); else - de = ll_lookup_it(parent, dentry, nd, 0); + de = ll_lookup_it(parent, dentry, NULL, 0); RETURN(de); } +#else +struct lookup_intent *ll_convert_intent(struct open_intent *oit, + int lookup_flags) +{ + struct lookup_intent *it; + + OBD_ALLOC(it, sizeof(*it)); + if (!it) + return ERR_PTR(-ENOMEM); + + if (lookup_flags & LOOKUP_OPEN) { + it->it_op = IT_OPEN; + if (lookup_flags & LOOKUP_CREATE) + it->it_op |= IT_CREAT; + it->it_create_mode = oit->create_mode; + it->it_flags = oit->flags; + } else { + it->it_op = IT_GETATTR; + } + +#ifndef HAVE_FILE_IN_STRUCT_INTENT + /* Since there is no way to pass our intent to ll_file_open, + * just check the file is there. Actual open will be done + * in ll_file_open */ + if (it->it_op & IT_OPEN) + it->it_op = IT_LOOKUP; #endif + return it; +} + +static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, + struct nameidata *nd) +{ + struct dentry *de; + ENTRY; + + if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) { + struct lookup_intent *it; + +#if defined(HAVE_FILE_IN_STRUCT_INTENT) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)) + /* Did we came here from failed revalidate just to propagate + * its error? */ + if (nd->flags & LOOKUP_OPEN) + if (IS_ERR(nd->intent.open.file)) + RETURN((struct dentry *)nd->intent.open.file); +#endif + + if (ll_d2d(dentry) && ll_d2d(dentry)->lld_it) { + it = ll_d2d(dentry)->lld_it; + ll_d2d(dentry)->lld_it = NULL; + } else { + it = ll_convert_intent(&nd->intent.open, nd->flags); + if (IS_ERR(it)) + RETURN((struct dentry *)it); + } + + de = ll_lookup_it(parent, dentry, it, nd->flags); + if (de) + dentry = de; + if ((nd->flags & LOOKUP_OPEN) && !IS_ERR(dentry)) { /* Open */ + if (dentry->d_inode && + it_disposition(it, DISP_OPEN_OPEN)) { /* nocreate */ +#ifdef HAVE_FILE_IN_STRUCT_INTENT + if (S_ISFIFO(dentry->d_inode->i_mode)) { + // We cannot call open here as it would + // deadlock. + ptlrpc_req_finished( + (struct ptlrpc_request *) + it->d.lustre.it_data); + } else { +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)) +/* 2.6.1[456] have a bug in open_namei() that forgets to check + * nd->intent.open.file for error, so we need to return it as lookup's result + * instead */ + struct file *filp; + nd->intent.open.file->private_data = it; + filp =lookup_instantiate_filp(nd,dentry, + NULL); + if (IS_ERR(filp)) { + if (de) + dput(de); + de = (struct dentry *) filp; + } +#else + nd->intent.open.file->private_data = it; + (void)lookup_instantiate_filp(nd,dentry, + NULL); +#endif + + } +#else /* HAVE_FILE_IN_STRUCT_INTENT */ + /* Release open handle as we have no way to + * pass it to ll_file_open */ + ll_release_openhandle(dentry, it); +#endif /* HAVE_FILE_IN_STRUCT_INTENT */ + } else if (it_disposition(it, DISP_OPEN_CREATE)) { + // XXX This can only reliably work on assumption + // that there are NO hashed negative dentries. + ll_d2d(dentry)->lld_it = it; + it = NULL; /* Will be freed in ll_create_nd */ + /* We absolutely depend on ll_create_nd to be + * called to not leak this intent and possible + * data attached to it */ + } + } + + if (it) { + ll_intent_release(it); + OBD_FREE(it, sizeof(*it)); + } + } else { + de = ll_lookup_it(parent, dentry, NULL, 0); + } + + RETURN(de); +} +#endif + +/** + * check new allocated inode, new inode shld not have any valid alias + */ +static void ll_validate_new_inode(struct inode *new) +{ + struct list_head *lp; + struct dentry * dentry; + int need_inval = 0; + int in_recheck = 0; + + if (list_empty(&new->i_dentry)) + return; +recheck: + spin_lock(&dcache_lock); + list_for_each(lp, &new->i_dentry) { + dentry = list_entry(lp, struct dentry, d_alias); + if (!d_unhashed(dentry) && !(dentry->d_flags & DCACHE_LUSTRE_INVALID)){ + ll_dump_inode(new); + if (in_recheck) + LBUG(); + } + need_inval = 1; + } + spin_unlock(&dcache_lock); + + if (need_inval && !in_recheck) { + /* kill all old inode's data pages */ + truncate_inode_pages(new->i_mapping, 0); + + /* invalidate all dirent and recheck inode */ + ll_unhash_aliases(new); + in_recheck = 1; + goto recheck; + } +} + /* We depend on "mode" being set with the proper file type/umask by now */ static struct inode *ll_create_node(struct inode *dir, const char *name, int namelen, const void *data, int datalen, @@ -479,23 +758,24 @@ static struct inode *ll_create_node(struct inode *dir, const char *name, int rc; ENTRY; + LASSERT(it && it->d.lustre.it_disposition); - LASSERT(it && LUSTRE_IT(it)->it_disposition); - - request = LUSTRE_IT(it)->it_data; - rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp, - &inode, request, 1, dir->i_sb); + LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF)); + request = it->d.lustre.it_data; + it_clear_disposition(it, DISP_ENQ_CREATE_REF); + rc = ll_prep_inode(&inode, request, dir->i_sb); if (rc) GOTO(out, inode = ERR_PTR(rc)); - LASSERT(list_empty(&inode->i_dentry)); + ll_validate_new_inode(inode); /* We asked for a lock on the directory, but were granted a * lock on the inode. Since we finally have an inode pointer, * stuff it in the lock. */ CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n", inode, inode->i_ino, inode->i_generation); - mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode); + md_set_lock_data(sbi->ll_md_exp, + &it->d.lustre.it_lock_handle, inode); EXIT; out: ptlrpc_req_finished(request); @@ -520,8 +800,6 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, struct lookup_intent *it) { struct inode *inode; - struct ptlrpc_request *request = LUSTRE_IT(it)->it_data; - struct obd_export *md_exp = ll_i2mdexp(dir); int rc = 0; ENTRY; @@ -533,79 +811,115 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, if (rc) RETURN(rc); - mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1); - inode = ll_create_node(dir, (char *)dentry->d_name.name, - dentry->d_name.len, NULL, 0, mode, 0, it); - if (IS_ERR(inode)) + inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, + NULL, 0, mode, 0, it); + if (IS_ERR(inode)) { RETURN(PTR_ERR(inode)); + } + /* it might been set during parent dir revalidation */ + dentry->d_flags &= ~DCACHE_LUSTRE_INVALID; d_instantiate(dentry, inode); + /* Negative dentry may be unhashed if parent does not have UPDATE lock, + * but some callers, e.g. do_coredump, expect dentry to be hashed after + * successful create. Hash it here. */ + spin_lock(&dcache_lock); + if (d_unhashed(dentry)) + d_rehash_cond(dentry, 0); + spin_unlock(&dcache_lock); RETURN(0); } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) -static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) -{ - return ll_create_it(dir, dentry, mode, &nd->intent.open); -} -#endif - -static void ll_update_times(struct ptlrpc_request *request, int offset, +static void ll_update_times(struct ptlrpc_request *request, struct inode *inode) { - struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset, - sizeof(*body)); - LASSERT(body); + struct mdt_body *body = req_capsule_server_get(&request->rq_pill, + &RMF_MDT_BODY); - if (body->valid & OBD_MD_FLMTIME && - body->mtime > LTIME_S(inode->i_mtime)) { - CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n", - inode->i_ino, LTIME_S(inode->i_mtime), body->mtime); - LTIME_S(inode->i_mtime) = body->mtime; - } + LASSERT(body); + /* mtime is always updated with ctime, but can be set in past. + As write and utime(2) may happen within 1 second, and utime's + mtime has a priority over write's one, so take mtime from mds + for the same ctimes. */ if (body->valid & OBD_MD_FLCTIME && - body->ctime > LTIME_S(inode->i_ctime)) + body->ctime >= LTIME_S(inode->i_ctime)) { LTIME_S(inode->i_ctime) = body->ctime; + + if (body->valid & OBD_MD_FLMTIME) { + CDEBUG(D_INODE, "setting ino %lu mtime from %lu " + "to "LPU64"\n", inode->i_ino, + LTIME_S(inode->i_mtime), body->mtime); + LTIME_S(inode->i_mtime) = body->mtime; + } + } } -static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev) +static int ll_new_node(struct inode *dir, struct qstr *name, + const char *tgt, int mode, int rdev, + struct dentry *dchild, __u32 opc) { struct ptlrpc_request *request = NULL; - struct inode *dir = nd->dentry->d_inode; + struct md_op_data *op_data; + struct inode *inode = NULL; struct ll_sb_info *sbi = ll_i2sbi(dir); - struct mdc_op_data *op_data; - int err = -EMLINK, key_size = 0; - void *key = NULL; + int tgt_len = 0; + int err; + ENTRY; + if (unlikely(tgt != NULL)) + tgt_len = strlen(tgt) + 1; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - nd->last.len, nd->last.name, dir->i_ino, - dir->i_generation, dir); + op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, + name->len, 0, opc, NULL); + if (IS_ERR(op_data)) + GOTO(err_exit, err = PTR_ERR(op_data)); + + err = md_create(sbi->ll_md_exp, op_data, tgt, tgt_len, mode, + current->fsuid, current->fsgid, + cfs_curproc_cap_pack(), rdev, &request); + ll_finish_md_op_data(op_data); + if (err) + GOTO(err_exit, err); + + ll_update_times(request, dir); + + if (dchild) { + err = ll_prep_inode(&inode, request, dchild->d_sb); + if (err) + GOTO(err_exit, err); + + d_drop(dchild); + d_instantiate(dchild, inode); + EXIT; + } +err_exit: + ptlrpc_req_finished(request); + + return err; +} + +static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode, + unsigned rdev, struct dentry *dchild) +{ + int err; + ENTRY; + + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n", + name->len, name->name, dir->i_ino, dir->i_generation, dir, + mode, rdev); mode &= ~current->fs->umask; switch (mode & S_IFMT) { case 0: - case S_IFREG: mode |= S_IFREG; /* for mode = 0 case, fallthrough */ - ll_crypto_create_key(dir, mode, &key, &key_size); + case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - ll_prepare_mdc_data(op_data, dir, NULL, - (char *)nd->last.name, - nd->last.len, 0); - err = md_create(sbi->ll_md_exp, op_data, key, key_size, mode, - current->fsuid, current->fsgid, rdev, - &request); - OBD_FREE(op_data, sizeof(*op_data)); - if (err == 0) - ll_update_times(request, 0, dir); - ptlrpc_req_finished(request); + err = ll_new_node(dir, name, NULL, mode, rdev, dchild, + LUSTRE_OPC_MKNOD); break; case S_IFDIR: err = -EPERM; @@ -613,316 +927,444 @@ static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev) default: err = -EINVAL; } - if (key && key_size) - OBD_FREE(key, key_size); RETURN(err); } -static int ll_mknod(struct inode *dir, struct dentry *dchild, - int mode, ll_dev_t rdev) +#ifndef HAVE_VFS_INTENT_PATCHES +static int ll_create_nd(struct inode *dir, struct dentry *dentry, + int mode, struct nameidata *nd) { - struct ptlrpc_request *request = NULL; - struct inode *inode = NULL; - struct ll_sb_info *sbi = ll_i2sbi(dir); - struct mdc_op_data *op_data; - int err = -EMLINK; - ENTRY; + struct lookup_intent *it = ll_d2d(dentry)->lld_it; + int rc; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - dchild->d_name.len, dchild->d_name.name, - dir->i_ino, dir->i_generation, dir); + if (!it) + return ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry); - mode &= ~current->fs->umask; + ll_d2d(dentry)->lld_it = NULL; - switch (mode & S_IFMT) { - case 0: - case S_IFREG: - mode |= S_IFREG; /* for mode = 0 case, fallthrough */ - - case S_IFCHR: - case S_IFBLK: - case S_IFIFO: - case S_IFSOCK: - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - - ll_prepare_mdc_data(op_data, dir, NULL, - (char *)dchild->d_name.name, - dchild->d_name.len, 0); - - err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode, - current->fsuid, current->fsgid, rdev, - &request); - OBD_FREE(op_data, sizeof(*op_data)); - if (err) - GOTO(out_err, err); + /* Was there an error? Propagate it! */ + if (it->d.lustre.it_status) { + rc = it->d.lustre.it_status; + goto out; + } - ll_update_times(request, 0, dir); - err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp, - &inode, request, 0, dchild->d_sb); - if (err) - GOTO(out_err, err); - break; - case S_IFDIR: - RETURN(-EPERM); - break; - default: - RETURN(-EINVAL); + rc = ll_create_it(dir, dentry, mode, it); +#ifdef HAVE_FILE_IN_STRUCT_INTENT + if (nd && (nd->flags & LOOKUP_OPEN) && dentry->d_inode) { /* Open */ + nd->intent.open.file->private_data = it; + lookup_instantiate_filp(nd, dentry, NULL); } +#else + ll_release_openhandle(dentry,it); +#endif - d_instantiate(dchild, inode); - EXIT; - out_err: - ptlrpc_req_finished(request); - return err; +out: + ll_intent_release(it); + OBD_FREE(it, sizeof(*it)); + + return rc; } +#else +static int ll_create_nd(struct inode *dir, struct dentry *dentry, + int mode, struct nameidata *nd) +{ + if (!nd || !nd->intent.d.lustre.it_disposition) + /* No saved request? Just mknod the file */ + return ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry); -static int ll_symlink_raw(struct nameidata *nd, const char *tgt) + return ll_create_it(dir, dentry, mode, &nd->intent); +} +#endif + +static int ll_symlink_generic(struct inode *dir, struct qstr *name, + const char *tgt, struct dentry *dchild) { - const char *name = (char *)nd->last.name; - struct inode *dir = nd->dentry->d_inode; - struct ptlrpc_request *request = NULL; - struct ll_sb_info *sbi = ll_i2sbi(dir); - struct mdc_op_data *op_data; - int len = nd->last.len; - int err = -EMLINK; + int err; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n", - nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, - dir, tgt); - - if (dir->i_nlink >= EXT3_LINK_MAX) - RETURN(err); - - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0); - LASSERT(tgt); - err = md_create(sbi->ll_md_exp, op_data, - tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO, - current->fsuid, current->fsgid, 0, &request); - OBD_FREE(op_data, sizeof(*op_data)); - if (err == 0) - ll_update_times(request, 0, dir); - - ptlrpc_req_finished(request); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%.*s\n", + name->len, name->name, dir->i_ino, dir->i_generation, + dir, 3000, tgt); + + err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO, + 0, dchild, LUSTRE_OPC_SYMLINK); RETURN(err); } -static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd) +static int ll_link_generic(struct inode *src, struct inode *dir, + struct qstr *name, struct dentry *dchild) { - struct inode *src = srcnd->dentry->d_inode; - struct inode *dir = tgtnd->dentry->d_inode; - struct ptlrpc_request *request = NULL; struct ll_sb_info *sbi = ll_i2sbi(dir); - struct mdc_op_data *op_data; + struct ptlrpc_request *request = NULL; + struct md_op_data *op_data; int err; - ENTRY; + ENTRY; CDEBUG(D_VFSTRACE, "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n", src->i_ino, src->i_generation, src, dir->i_ino, - dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name); + dir->i_generation, dir, name->len, name->name); - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); + op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len, + 0, LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) + RETURN(PTR_ERR(op_data)); - ll_prepare_mdc_data(op_data, src, dir, - (char *)tgtnd->last.name, - tgtnd->last.len, 0); - err = md_link(sbi->ll_md_exp, op_data, &request); - OBD_FREE(op_data, sizeof(*op_data)); - if (err == 0) - ll_update_times(request, 0, dir); + ll_finish_md_op_data(op_data); + if (err) + GOTO(out, err); + if (dchild) + d_drop(dchild); + + ll_update_times(request, dir); + EXIT; +out: ptlrpc_req_finished(request); RETURN(err); } +static int ll_mkdir_generic(struct inode *dir, struct qstr *name, + int mode, struct dentry *dchild) -static int ll_mkdir_raw(struct nameidata *nd, int mode) { - struct inode *dir = nd->dentry->d_inode; - struct ptlrpc_request *request = NULL; - struct ll_sb_info *sbi = ll_i2sbi(dir); - struct mdc_op_data *op_data; - int err = -EMLINK; + int err; ENTRY; + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir); + name->len, name->name, dir->i_ino, dir->i_generation, dir); mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR; - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - - ll_prepare_mdc_data(op_data, dir, NULL, - (char *)nd->last.name, - nd->last.len, 0); - - err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode, - current->fsuid, current->fsgid, 0, &request); - OBD_FREE(op_data, sizeof(*op_data)); - if (err == 0) - ll_update_times(request, 0, dir); - ptlrpc_req_finished(request); + err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR); + RETURN(err); } -static int ll_rmdir_raw(struct nameidata *nd) +/* Try to find the child dentry by its name. + If found, put the result fid into @fid. */ +static void ll_get_child_fid(struct inode * dir, struct qstr *name, + struct lu_fid *fid) +{ + struct dentry *parent, *child; + + parent = list_entry(dir->i_dentry.next, struct dentry, d_alias); + child = d_lookup(parent, name); + if (child) { + if (child->d_inode) + *fid = *ll_inode2fid(child->d_inode); + dput(child); + } +} + +static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent, + struct dentry *dchild, struct qstr *name) { - struct inode *dir = nd->dentry->d_inode; struct ptlrpc_request *request = NULL; - struct mdc_op_data *op_data; + struct md_op_data *op_data; int rc; - ENTRY; + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - nd->last.len, nd->last.name, dir->i_ino, - dir->i_generation, dir); + name->len, name->name, dir->i_ino, dir->i_generation, dir); + + if (unlikely(ll_d_mountpoint(dparent, dchild, name))) + RETURN(-EBUSY); - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); + op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len, + S_IFDIR, LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) + RETURN(PTR_ERR(op_data)); - ll_prepare_mdc_data(op_data, dir, NULL, - (char *)nd->last.name, - nd->last.len, S_IFDIR); - + ll_get_child_fid(dir, name, &op_data->op_fid3); rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request); - OBD_FREE(op_data, sizeof(*op_data)); + ll_finish_md_op_data(op_data); if (rc == 0) - ll_update_times(request, 0, dir); + ll_update_times(request, dir); ptlrpc_req_finished(request); RETURN(rc); } -static int ll_unlink_raw(struct nameidata *nd) +int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) +{ + struct mdt_body *body; + struct lov_mds_md *eadata; + struct lov_stripe_md *lsm = NULL; + struct obd_trans_info oti = { 0 }; + struct obdo *oa; + struct obd_capa *oc = NULL; + int rc; + ENTRY; + + /* req is swabbed so this is safe */ + body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); + if (!(body->valid & OBD_MD_FLEASIZE)) + RETURN(0); + + if (body->eadatasize == 0) { + CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n"); + GOTO(out, rc = -EPROTO); + } + + /* The MDS sent back the EA because we unlinked the last reference + * to this file. Use this EA to unlink the objects on the OST. + * It's opaque so we don't swab here; we leave it to obd_unpackmd() to + * check it is complete and sensible. */ + eadata = req_capsule_server_sized_get(&request->rq_pill, &RMF_MDT_MD, + body->eadatasize); + LASSERT(eadata != NULL); + + rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize); + if (rc < 0) { + CERROR("obd_unpackmd: %d\n", rc); + GOTO(out, rc); + } + LASSERT(rc >= sizeof(*lsm)); + + rc = obd_checkmd(ll_i2dtexp(dir), ll_i2mdexp(dir), lsm); + if (rc) + GOTO(out_free_memmd, rc); + + OBDO_ALLOC(oa); + if (oa == NULL) + GOTO(out_free_memmd, rc = -ENOMEM); + + oa->o_id = lsm->lsm_object_id; + oa->o_gr = lsm->lsm_object_gr; + oa->o_mode = body->mode & S_IFMT; + oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP; + + if (body->valid & OBD_MD_FLCOOKIE) { + oa->o_valid |= OBD_MD_FLCOOKIE; + oti.oti_logcookies = + req_capsule_server_sized_get(&request->rq_pill, + &RMF_LOGCOOKIES, + sizeof(struct llog_cookie) * + lsm->lsm_stripe_count); + if (oti.oti_logcookies == NULL) { + oa->o_valid &= ~OBD_MD_FLCOOKIE; + body->valid &= ~OBD_MD_FLCOOKIE; + } + } + + if (body->valid & OBD_MD_FLOSSCAPA) { + rc = md_unpack_capa(ll_i2mdexp(dir), request, &RMF_CAPA2, &oc); + if (rc) + GOTO(out_free_memmd, rc); + } + + rc = obd_destroy(ll_i2dtexp(dir), oa, lsm, &oti, ll_i2mdexp(dir), oc); + capa_put(oc); + OBDO_FREE(oa); + if (rc) + CERROR("obd destroy objid "LPX64" error %d\n", + lsm->lsm_object_id, rc); + out_free_memmd: + obd_free_memmd(ll_i2dtexp(dir), &lsm); + out: + return rc; +} + +static int ll_unlink_generic(struct inode *dir, struct dentry *dparent, + struct dentry *dchild, struct qstr *name) { - struct inode *dir = nd->dentry->d_inode; struct ptlrpc_request *request = NULL; - struct mdc_op_data *op_data; + struct md_op_data *op_data; int rc; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - nd->last.len, nd->last.name, dir->i_ino, - dir->i_generation, dir); - - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - ll_prepare_mdc_data(op_data, dir, NULL, - (char *)nd->last.name, nd->last.len, 0); + name->len, name->name, dir->i_ino, dir->i_generation, dir); + + /* + * XXX: unlink bind mountpoint maybe call to here, + * just check it as vfs_unlink does. + */ + if (unlikely(ll_d_mountpoint(dparent, dchild, name))) + RETURN(-EBUSY); + + op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, + name->len, 0, LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) + RETURN(PTR_ERR(op_data)); + + ll_get_child_fid(dir, name, &op_data->op_fid3); rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request); - OBD_FREE(op_data, sizeof(*op_data)); + ll_finish_md_op_data(op_data); if (rc) GOTO(out, rc); - ll_update_times(request, 0, dir); - EXIT; -out: + + ll_update_times(request, dir); + + rc = ll_objects_destroy(request, dir); + out: ptlrpc_req_finished(request); - return rc; + RETURN(rc); } -static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd) +static int ll_rename_generic(struct inode *src, struct dentry *src_dparent, + struct dentry *src_dchild, struct qstr *src_name, + struct inode *tgt, struct dentry *tgt_dparent, + struct dentry *tgt_dchild, struct qstr *tgt_name) { - struct inode *src = srcnd->dentry->d_inode; - struct inode *tgt = tgtnd->dentry->d_inode; struct ptlrpc_request *request = NULL; struct ll_sb_info *sbi = ll_i2sbi(src); - struct mdc_op_data *op_data; + struct md_op_data *op_data; int err; ENTRY; - - if (srcnd->mnt != tgtnd->mnt) - RETURN(-EXDEV); - CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s," - "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name, - src->i_ino, src->i_generation, src, tgtnd->last.len, - tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt); - - OBD_ALLOC(op_data, sizeof(*op_data)); - if (op_data == NULL) - RETURN(-ENOMEM); - ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0); - err = md_rename(sbi->ll_md_exp, op_data, (char *)srcnd->last.name, - srcnd->last.len, (char *)tgtnd->last.name, - tgtnd->last.len, &request); - OBD_FREE(op_data, sizeof(*op_data)); + "tgt_dir=%lu/%u(%p)\n", src_name->len, src_name->name, + src->i_ino, src->i_generation, src, tgt_name->len, + tgt_name->name, tgt->i_ino, tgt->i_generation, tgt); + + if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) || + ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name))) + RETURN(-EBUSY); + + op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0, + LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) + RETURN(PTR_ERR(op_data)); + + ll_get_child_fid(src, src_name, &op_data->op_fid3); + ll_get_child_fid(tgt, tgt_name, &op_data->op_fid4); + err = md_rename(sbi->ll_md_exp, op_data, + src_name->name, src_name->len, + tgt_name->name, tgt_name->len, &request); + ll_finish_md_op_data(op_data); if (!err) { - ll_update_times(request, 0, src); - ll_update_times(request, 0, tgt); + ll_update_times(request, src); + ll_update_times(request, tgt); + err = ll_objects_destroy(request, src); } ptlrpc_req_finished(request); + RETURN(err); } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) -#define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME) -static int ll_rawop_from_intent(struct nameidata *nd) +#ifdef HAVE_VFS_INTENT_PATCHES +static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev) { - int error = 0; - - if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS)) - return 0; + return ll_mknod_generic(nd->dentry->d_inode, &nd->last, mode,rdev,NULL); +} +static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd) +{ + return ll_rename_generic(srcnd->dentry->d_inode, srcnd->dentry, + NULL, &srcnd->last, + tgtnd->dentry->d_inode, tgtnd->dentry, + NULL, &tgtnd->last); +} +static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd) +{ + return ll_link_generic(srcnd->dentry->d_inode, tgtnd->dentry->d_inode, + &tgtnd->last, NULL); +} +static int ll_symlink_raw(struct nameidata *nd, const char *tgt) +{ + return ll_symlink_generic(nd->dentry->d_inode, &nd->last, tgt, NULL); +} +static int ll_rmdir_raw(struct nameidata *nd) +{ + return ll_rmdir_generic(nd->dentry->d_inode, nd->dentry, NULL, + &nd->last); +} +static int ll_mkdir_raw(struct nameidata *nd, int mode) +{ + return ll_mkdir_generic(nd->dentry->d_inode, &nd->last, mode, NULL); +} +static int ll_unlink_raw(struct nameidata *nd) +{ + return ll_unlink_generic(nd->dentry->d_inode, nd->dentry, NULL, + &nd->last); +} +#endif - switch (nd->intent.open.op) { - case IT_MKNOD: - error = ll_mknod_raw(nd, nd->intent.open.create_mode, - nd->intent.open.create.dev); - break; - case IT_MKDIR: - error = ll_mkdir_raw(nd, nd->intent.open.create_mode); - break; - case IT_RMDIR: - error = ll_rmdir_raw(nd); - break; - case IT_UNLINK: - error = ll_unlink_raw(nd); - break; - case IT_SYMLINK: - LASSERT(nd->intent.open.create.link); - error = ll_symlink_raw(nd, nd->intent.open.create.link); - break; - case IT_LINK: - error = ll_link_raw(nd->intent.open.create.source_nd, nd); - break; - case IT_RENAME: - LASSERT(nd->intent.open.create.source_nd); - error = ll_rename_raw(nd->intent.open.create.source_nd, nd); - break; - default: - LBUG(); - } - if (error != -EOPNOTSUPP) - nd->intent.open.flags |= IT_STATUS_RAW; +static int ll_mknod(struct inode *dir, struct dentry *dchild, int mode, + ll_dev_t rdev) +{ + return ll_mknod_generic(dir, &dchild->d_name, mode, + old_encode_dev(rdev), dchild); +} - return error; +static int ll_unlink(struct inode * dir, struct dentry *dentry) +{ + return ll_unlink_generic(dir, NULL, dentry, &dentry->d_name); +} +static int ll_mkdir(struct inode *dir, struct dentry *dentry, int mode) +{ + return ll_mkdir_generic(dir, &dentry->d_name, mode, dentry); } +static int ll_rmdir(struct inode *dir, struct dentry *dentry) +{ + return ll_rmdir_generic(dir, NULL, dentry, &dentry->d_name); +} +static int ll_symlink(struct inode *dir, struct dentry *dentry, + const char *oldname) +{ + return ll_symlink_generic(dir, &dentry->d_name, oldname, dentry); +} +static int ll_link(struct dentry *old_dentry, struct inode *dir, + struct dentry *new_dentry) +{ + return ll_link_generic(old_dentry->d_inode, dir, &new_dentry->d_name, + new_dentry); +} +static int ll_rename(struct inode *old_dir, struct dentry *old_dentry, + struct inode *new_dir, struct dentry *new_dentry) +{ + int err; + err = ll_rename_generic(old_dir, NULL, + old_dentry, &old_dentry->d_name, + new_dir, NULL, new_dentry, + &new_dentry->d_name); + if (!err) { +#ifndef HAVE_FS_RENAME_DOES_D_MOVE + if (!S_ISDIR(old_dentry->d_inode->i_mode)) #endif + d_move(old_dentry, new_dentry); + } + return err; +} struct inode_operations ll_dir_inode_operations = { - .mknod = ll_mknod, +#ifdef HAVE_VFS_INTENT_PATCHES + .link_raw = ll_link_raw, + .unlink_raw = ll_unlink_raw, + .symlink_raw = ll_symlink_raw, + .mkdir_raw = ll_mkdir_raw, + .rmdir_raw = ll_rmdir_raw, + .mknod_raw = ll_mknod_raw, + .rename_raw = ll_rename_raw, .setattr = ll_setattr, -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) - .create_it = ll_create_it, - .lookup_it = ll_lookup_it, - .revalidate_it = ll_inode_revalidate_it, -#else + .setattr_raw = ll_setattr_raw, +#endif + .mknod = ll_mknod, .lookup = ll_lookup_nd, .create = ll_create_nd, + /* We need all these non-raw things for NFSD, to not patch it. */ + .unlink = ll_unlink, + .mkdir = ll_mkdir, + .rmdir = ll_rmdir, + .symlink = ll_symlink, + .link = ll_link, + .rename = ll_rename, + .setattr = ll_setattr, .getattr = ll_getattr, - .endparentlookup = ll_rawop_from_intent, -#endif + .permission = ll_inode_permission, .setxattr = ll_setxattr, .getxattr = ll_getxattr, .listxattr = ll_listxattr, .removexattr = ll_removexattr, - .permission = ll_inode_permission, +}; + +struct inode_operations ll_special_inode_operations = { +#ifdef HAVE_VFS_INTENT_PATCHES + .setattr_raw = ll_setattr_raw, +#endif + .setattr = ll_setattr, + .getattr = ll_getattr, + .permission = ll_inode_permission, + .setxattr = ll_setxattr, + .getxattr = ll_getxattr, + .listxattr = ll_listxattr, + .removexattr = ll_removexattr, };