X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Fnamei.c;h=7770a6109fadc7c2b87e9fc5efe8e3ff6b54a3bd;hp=2ff3910b48751e63e609d14530c429ea4f849ba7;hb=cb85c0364fd8323f4bb03c481660805da66aaf85;hpb=6784a15c6ee32019237151a63755103c68ff51dd diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index 2ff3910..7770a61 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -59,7 +59,7 @@ static int ll_create_it(struct inode *, struct dentry *, * In such a case there would always be dentry present. */ static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild, - struct qstr *name) + struct qstr *name) { int mounted = 0; @@ -75,100 +75,98 @@ static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild, return mounted; } -int ll_unlock(__u32 mode, struct lustre_handle *lockh) -{ - ENTRY; - - ldlm_lock_decref(lockh, mode); - - RETURN(0); -} - - /* 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; + 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 (unlikely(!(md->body->mbo_valid & OBD_MD_FLID))) { + CERROR("MDS body missing FID\n"); + return 0; + } - if (!lu_fid_eq(&lli->lli_fid, &md->body->fid1)) - return 0; + if (!lu_fid_eq(&lli->lli_fid, &md->body->mbo_fid1)) + return 0; - return 1; + return 1; } static int ll_set_inode(struct inode *inode, void *opaque) { - struct ll_inode_info *lli = ll_i2info(inode); - struct mdt_body *body = ((struct lustre_md *)opaque)->body; + struct ll_inode_info *lli = ll_i2info(inode); + struct mdt_body *body = ((struct lustre_md *)opaque)->body; - if (unlikely(!(body->valid & OBD_MD_FLID))) { - CERROR("MDS body missing FID\n"); - return -EINVAL; - } + if (unlikely(!(body->mbo_valid & OBD_MD_FLID))) { + CERROR("MDS body missing FID\n"); + return -EINVAL; + } - lli->lli_fid = body->fid1; - if (unlikely(!(body->valid & OBD_MD_FLTYPE))) { - CERROR("Can not initialize inode "DFID" without object type: " - "valid = "LPX64"\n", PFID(&lli->lli_fid), body->valid); - return -EINVAL; - } + lli->lli_fid = body->mbo_fid1; + if (unlikely(!(body->mbo_valid & OBD_MD_FLTYPE))) { + CERROR("Can not initialize inode "DFID" without object type: " + "valid = "LPX64"\n", + PFID(&lli->lli_fid), body->mbo_valid); + return -EINVAL; + } - inode->i_mode = (inode->i_mode & ~S_IFMT) | (body->mode & S_IFMT); - if (unlikely(inode->i_mode == 0)) { - CERROR("Invalid inode "DFID" type\n", PFID(&lli->lli_fid)); - return -EINVAL; - } + inode->i_mode = (inode->i_mode & ~S_IFMT) | (body->mbo_mode & S_IFMT); + if (unlikely(inode->i_mode == 0)) { + CERROR("Invalid inode "DFID" type\n", PFID(&lli->lli_fid)); + return -EINVAL; + } - ll_lli_init(lli); + ll_lli_init(lli); - return 0; + return 0; } -/* - * Get an inode by inode number (already instantiated by the intent lookup). - * Returns inode or NULL +/** + * Get an inode by inode number(@hash), which is already instantiated by + * the intent lookup). */ struct inode *ll_iget(struct super_block *sb, ino_t hash, struct lustre_md *md) { - struct inode *inode; - ENTRY; + struct inode *inode; + int rc = 0; + + ENTRY; LASSERT(hash != 0); inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md); + if (inode == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + if (inode->i_state & I_NEW) { + rc = ll_read_inode2(inode, md); + if (rc == 0 && S_ISREG(inode->i_mode) && + ll_i2info(inode)->lli_clob == NULL) { + CDEBUG(D_INODE, "%s: apply lsm %p to inode "DFID"\n", + ll_get_fsname(sb, NULL, 0), md->lsm, + PFID(ll_inode2fid(inode))); + rc = cl_file_inode_init(inode, md); + } + if (rc != 0) { + 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))) { + rc = ll_update_inode(inode, md); + CDEBUG(D_VFSTRACE, "got inode: "DFID"(%p): rc = %d\n", + PFID(&md->body->mbo_fid1), inode, rc); + if (rc != 0) { + make_bad_inode(inode); + iput(inode); + inode = ERR_PTR(rc); + } + } - if (inode) { - if (inode->i_state & I_NEW) { - int rc = 0; - - ll_read_inode2(inode, md); - if (S_ISREG(inode->i_mode) && - ll_i2info(inode)->lli_clob == NULL) { - CDEBUG(D_INODE, - "%s: apply lsm %p to inode "DFID".\n", - ll_get_fsname(sb, NULL, 0), md->lsm, - PFID(ll_inode2fid(inode))); - rc = cl_file_inode_init(inode, md); - } - if (rc != 0) { - 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); } @@ -195,121 +193,164 @@ static void ll_invalidate_negative_children(struct inode *dir) ll_unlock_dcache(dir); } +int ll_test_inode_by_fid(struct inode *inode, void *opaque) +{ + return lu_fid_eq(&ll_i2info(inode)->lli_fid, opaque); +} + int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, - void *data, int flag) + void *data, int flag) { - int rc; - struct lustre_handle lockh; - ENTRY; + struct lustre_handle lockh; + int rc; + ENTRY; - switch (flag) { - case LDLM_CB_BLOCKING: - ldlm_lock2handle(lock, &lockh); + switch (flag) { + case LDLM_CB_BLOCKING: + ldlm_lock2handle(lock, &lockh); rc = ldlm_cli_cancel(&lockh, LCF_ASYNC); - if (rc < 0) { - CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc); - RETURN(rc); - } - break; - case LDLM_CB_CANCELING: { + if (rc < 0) { + CDEBUG(D_INODE, "ldlm_cli_cancel: rc = %d\n", rc); + RETURN(rc); + } + break; + case LDLM_CB_CANCELING: { struct inode *inode = ll_inode_from_resource_lock(lock); - struct ll_inode_info *lli; - __u64 bits = lock->l_policy_data.l_inodebits.bits; - struct lu_fid *fid; - ldlm_mode_t mode = lock->l_req_mode; + __u64 bits = lock->l_policy_data.l_inodebits.bits; /* Inode is set to lock->l_resource->lr_lvb_inode * for mdc - bug 24555 */ LASSERT(lock->l_ast_data == NULL); - /* Invalidate all dentries associated with this inode */ if (inode == NULL) break; - LASSERT(lock->l_flags & LDLM_FL_CANCELING); + /* Invalidate all dentries associated with this inode */ + LASSERT(ldlm_is_canceling(lock)); + + if (!fid_res_name_eq(ll_inode2fid(inode), + &lock->l_resource->lr_name)) { + LDLM_ERROR(lock, "data mismatch with object "DFID"(%p)", + PFID(ll_inode2fid(inode)), inode); + LBUG(); + } - if (bits & MDS_INODELOCK_XATTR) + if (bits & MDS_INODELOCK_XATTR) { ll_xattr_cache_destroy(inode); + bits &= ~MDS_INODELOCK_XATTR; + } /* For OPEN locks we differentiate between lock modes * LCK_CR, LCK_CW, LCK_PR - bug 22891 */ + if (bits & MDS_INODELOCK_OPEN) + ll_have_md_lock(inode, &bits, lock->l_req_mode); + + if (bits & MDS_INODELOCK_OPEN) { + fmode_t fmode; + + switch (lock->l_req_mode) { + case LCK_CW: + fmode = FMODE_WRITE; + break; + case LCK_PR: + fmode = FMODE_EXEC; + break; + case LCK_CR: + fmode = FMODE_READ; + break; + default: + LDLM_ERROR(lock, "bad lock mode for OPEN lock"); + LBUG(); + } + + ll_md_real_close(inode, fmode); + + bits &= ~MDS_INODELOCK_OPEN; + } + if (bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_UPDATE | MDS_INODELOCK_LAYOUT | MDS_INODELOCK_PERM)) - ll_have_md_lock(inode, &bits, LCK_MINMODE); - - if (bits & MDS_INODELOCK_OPEN) - ll_have_md_lock(inode, &bits, mode); - - fid = ll_inode2fid(inode); - if (!fid_res_name_eq(fid, &lock->l_resource->lr_name)) - LDLM_ERROR(lock, "data mismatch with object " - DFID" (%p)", PFID(fid), inode); - - if (bits & MDS_INODELOCK_OPEN) { - int flags = 0; - switch (lock->l_req_mode) { - case LCK_CW: - flags = FMODE_WRITE; - break; - case LCK_PR: - flags = FMODE_EXEC; - break; - case LCK_CR: - flags = FMODE_READ; - break; - default: - CERROR("Unexpected lock mode for OPEN lock " - "%d, inode %ld\n", lock->l_req_mode, - inode->i_ino); - } - ll_md_real_close(inode, flags); - } + ll_have_md_lock(inode, &bits, LCK_MINMODE); - lli = ll_i2info(inode); if (bits & MDS_INODELOCK_LAYOUT) { - struct cl_object_conf conf = { { 0 } }; + struct cl_object_conf conf = { + .coc_opc = OBJECT_CONF_INVALIDATE, + .coc_inode = inode, + }; - conf.coc_opc = OBJECT_CONF_INVALIDATE; - conf.coc_inode = inode; rc = ll_layout_conf(inode, &conf); - if (rc) - CDEBUG(D_INODE, "invaliding layout %d.\n", rc); + if (rc < 0) + CDEBUG(D_INODE, "cannot invalidate layout of " + DFID": rc = %d\n", + PFID(ll_inode2fid(inode)), rc); } if (bits & MDS_INODELOCK_UPDATE) { + struct ll_inode_info *lli = ll_i2info(inode); + spin_lock(&lli->lli_lock); - lli->lli_flags &= ~LLIF_MDS_SIZE_LOCK; + lli->lli_flags &= ~LLIF_MDS_SIZE_LOCK; spin_unlock(&lli->lli_lock); } - if (S_ISDIR(inode->i_mode) && - (bits & MDS_INODELOCK_UPDATE)) { - CDEBUG(D_INODE, "invalidating inode %lu\n", - inode->i_ino); - truncate_inode_pages(inode->i_mapping, 0); - ll_invalidate_negative_children(inode); + if ((bits & MDS_INODELOCK_UPDATE) && S_ISDIR(inode->i_mode)) { + struct ll_inode_info *lli = ll_i2info(inode); + + CDEBUG(D_INODE, "invalidating inode "DFID" lli = %p, " + "pfid = "DFID"\n", PFID(ll_inode2fid(inode)), + lli, PFID(&lli->lli_pfid)); + truncate_inode_pages(inode->i_mapping, 0); + + if (unlikely(!fid_is_zero(&lli->lli_pfid))) { + struct inode *master_inode = NULL; + unsigned long hash; + + /* This is slave inode, since all of the child + * dentry is connected on the master inode, so + * we have to invalidate the negative children + * on master inode */ + CDEBUG(D_INODE, "Invalidate s"DFID" m"DFID"\n", + PFID(ll_inode2fid(inode)), + PFID(&lli->lli_pfid)); + + hash = cl_fid_build_ino(&lli->lli_pfid, + ll_need_32bit_api(ll_i2sbi(inode))); + + master_inode = ilookup5(inode->i_sb, hash, + ll_test_inode_by_fid, + (void *)&lli->lli_pfid); + if (master_inode != NULL && + !IS_ERR(master_inode)) { + ll_invalidate_negative_children( + master_inode); + iput(master_inode); + } + } else { + ll_invalidate_negative_children(inode); + } } - if (inode->i_sb->s_root && - inode != inode->i_sb->s_root->d_inode && - (bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_PERM))) + if ((bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_PERM)) && + inode->i_sb->s_root != NULL && + inode != inode->i_sb->s_root->d_inode) ll_invalidate_aliases(inode); - iput(inode); - break; - } - default: - LBUG(); - } - RETURN(0); + iput(inode); + break; + } + default: + LBUG(); + } + + RETURN(0); } __u32 ll_i2suppgid(struct inode *i) { - if (cfs_curproc_is_in_groups(i->i_gid)) - return (__u32)i->i_gid; - else - return (__u32)(-1); + if (in_group_p(i->i_gid)) + return (__u32)from_kgid(&init_user_ns, i->i_gid); + else + return (__u32) __kgid_val(INVALID_GID); } /* Pack the required supplementary groups into the supplied groups array. @@ -318,35 +359,15 @@ __u32 ll_i2suppgid(struct inode *i) * 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); + LASSERT(i1 != NULL); + LASSERT(suppgids != NULL); - suppgids[0] = ll_i2suppgid(i1); + 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 + if (i2) + suppgids[1] = ll_i2suppgid(i2); + else + suppgids[1] = -1; } /* @@ -418,7 +439,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de) iput(inode); CDEBUG(D_DENTRY, "Reuse dentry %p inode %p refc %d flags %#x\n", - new, new->d_inode, d_refcount(new), new->d_flags); + new, new->d_inode, d_count(new), new->d_flags); return new; } } @@ -427,19 +448,17 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de) return ERR_PTR(rc); d_add(de, inode); CDEBUG(D_DENTRY, "Add dentry %p inode %p refc %d flags %#x\n", - de, de->d_inode, d_refcount(de), de->d_flags); + de, de->d_inode, d_count(de), de->d_flags); return de; } -int ll_lookup_it_finish(struct ptlrpc_request *request, - struct lookup_intent *it, void *data) +static int ll_lookup_it_finish(struct ptlrpc_request *request, + struct lookup_intent *it, + struct inode *parent, struct dentry **de) { - struct it_cb_data *icbd = data; - struct dentry **de = icbd->icbd_childp; - struct inode *parent = icbd->icbd_parent; - struct inode *inode = NULL; - __u64 bits = 0; - int rc; + struct inode *inode = NULL; + __u64 bits = 0; + int rc; ENTRY; /* NB 1 request reference will be taken away by ll_intent_lock() @@ -467,9 +486,18 @@ int ll_lookup_it_finish(struct ptlrpc_request *request, * Atoimc_open may passin hashed dentries for open. */ if (d_unhashed(*de)) { - *de = ll_splice_alias(inode, *de); - if (IS_ERR(*de)) - RETURN(PTR_ERR(*de)); + struct dentry *alias; + + alias = ll_splice_alias(inode, *de); + if (IS_ERR(alias)) + RETURN(PTR_ERR(alias)); + *de = alias; + } else if (!it_disposition(it, DISP_LOOKUP_NEG) && + !it_disposition(it, DISP_OPEN_CREATE)) { + /* With DISP_OPEN_CREATE dentry will + instantiated in ll_create_it. */ + LASSERT((*de)->d_inode == NULL); + d_instantiate(*de, inode); } if (!it_disposition(it, DISP_LOOKUP_NEG)) { @@ -485,9 +513,20 @@ int ll_lookup_it_finish(struct ptlrpc_request *request, struct lookup_intent parent_it = { .it_op = IT_GETATTR, .d.lustre.it_lock_handle = 0 }; + struct lu_fid fid = ll_i2info(parent)->lli_fid; + + /* If it is striped directory, get the real stripe parent */ + if (unlikely(ll_i2info(parent)->lli_lsm_md != NULL)) { + rc = md_get_fid_from_lsm(ll_i2mdexp(parent), + ll_i2info(parent)->lli_lsm_md, + (*de)->d_name.name, + (*de)->d_name.len, &fid); + if (rc != 0) + RETURN(rc); + } - if (md_revalidate_lock(ll_i2mdexp(parent), &parent_it, - &ll_i2info(parent)->lli_fid, NULL)) { + if (md_revalidate_lock(ll_i2mdexp(parent), &parent_it, &fid, + NULL)) { d_lustre_revalidate(*de); ll_intent_release(&parent_it); } @@ -503,7 +542,6 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, struct dentry *save = dentry, *retval; struct ptlrpc_request *req = NULL; struct md_op_data *op_data; - struct it_cb_data icbd; __u32 opc; int rc; ENTRY; @@ -511,14 +549,15 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, 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", - dentry->d_name.len, dentry->d_name.name, parent->i_ino, - parent->i_generation, parent, LL_IT2STR(it)); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), intent=%s\n", + dentry->d_name.len, dentry->d_name.name, + PFID(ll_inode2fid(parent)), parent, LL_IT2STR(it)); if (d_mountpoint(dentry)) CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it)); - ll_frob_intent(&it, &lookup_it); + if (it == NULL || it->it_op == IT_GETXATTR) + it = &lookup_it; if (it->it_op == IT_GETATTR) { rc = ll_statahead_enter(parent, &dentry, 0); @@ -529,9 +568,6 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, } } - icbd.icbd_childp = &dentry; - icbd.icbd_parent = parent; - if (it->it_op & IT_CREAT) opc = LUSTRE_OPC_CREATE; else @@ -545,15 +581,15 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, /* enforce umask if acl disabled or MDS doesn't support umask */ if (!IS_POSIXACL(parent) || !exp_connect_umask(ll_i2mdexp(parent))) - it->it_create_mode &= ~cfs_curproc_umask(); + it->it_create_mode &= ~current_umask(); - rc = md_intent_lock(ll_i2mdexp(parent), op_data, NULL, 0, it, - lookup_flags, &req, ll_md_blocking_ast, 0); + rc = md_intent_lock(ll_i2mdexp(parent), op_data, it, &req, + &ll_md_blocking_ast, 0); ll_finish_md_op_data(op_data); if (rc < 0) GOTO(out, retval = ERR_PTR(rc)); - rc = ll_lookup_it_finish(req, it, &icbd); + rc = ll_lookup_it_finish(req, it, parent, &dentry); if (rc != 0) { ll_intent_release(it); GOTO(out, retval = ERR_PTR(rc)); @@ -585,9 +621,9 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, struct lookup_intent *itp, it = { .it_op = IT_GETATTR }; struct dentry *de; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),flags=%u\n", - dentry->d_name.len, dentry->d_name.name, parent->i_ino, - parent->i_generation, parent, flags); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), flags=%u\n", + dentry->d_name.len, dentry->d_name.name, + PFID(ll_inode2fid(parent)), parent, flags); /* Optimize away (CREATE && !OPEN). Let .create handle the race. */ if ((flags & LOOKUP_CREATE) && !(flags & LOOKUP_OPEN)) @@ -619,10 +655,10 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry, int rc = 0; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),file %p," - "open_flags %x,mode %x opened %d\n", - dentry->d_name.len, dentry->d_name.name, dir->i_ino, - dir->i_generation, dir, file, open_flags, mode, *opened); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), file %p," + "open_flags %x, mode %x opened %d\n", + dentry->d_name.len, dentry->d_name.name, + PFID(ll_inode2fid(dir)), dir, file, open_flags, mode, *opened); OBD_ALLOC(it, sizeof(*it)); if (!it) @@ -635,6 +671,7 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry, } it->it_create_mode = (mode & S_IALLUGO) | S_IFREG; it->it_flags = (open_flags & ~O_ACCMODE) | OPEN_FMODE(open_flags); + it->it_flags &= ~MDS_OPEN_FL_INTERNAL; /* Dentry added to dcache tree in ll_lookup_it */ de = ll_lookup_it(dir, dentry, it, lookup_flags); @@ -689,12 +726,12 @@ out_release: } #else /* !HAVE_IOP_ATOMIC_OPEN */ -struct lookup_intent *ll_convert_intent(struct open_intent *oit, - int lookup_flags) +static struct lookup_intent * +ll_convert_intent(struct open_intent *oit, int lookup_flags) { struct lookup_intent *it; - OBD_ALLOC(it, sizeof(*it)); + OBD_ALLOC_PTR(it); if (!it) return ERR_PTR(-ENOMEM); @@ -704,6 +741,7 @@ struct lookup_intent *ll_convert_intent(struct open_intent *oit, it->it_op |= IT_CREAT; it->it_create_mode = (oit->create_mode & S_IALLUGO) | S_IFREG; it->it_flags = ll_namei_to_lookup_intent_flag(oit->flags); + it->it_flags &= ~MDS_OPEN_FL_INTERNAL; } else { it->it_op = IT_GETATTR; } @@ -782,10 +820,7 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, #endif /* HAVE_IOP_ATOMIC_OPEN */ /* 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, - int mode, __u64 extra, - struct lookup_intent *it) +static struct inode *ll_create_node(struct inode *dir, struct lookup_intent *it) { struct inode *inode = NULL; struct ptlrpc_request *request = NULL; @@ -807,8 +842,8 @@ static struct inode *ll_create_node(struct inode *dir, const char *name, /* 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); + CDEBUG(D_DLMTRACE, "setting l_ast_data to inode "DFID"(%p)\n", + PFID(ll_inode2fid(inode)), inode); ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL); EXIT; out: @@ -837,42 +872,39 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, int rc = 0; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n", - dentry->d_name.len, dentry->d_name.name, dir->i_ino, - dir->i_generation, dir, LL_IT2STR(it)); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), intent=%s\n", + dentry->d_name.len, dentry->d_name.name, + PFID(ll_inode2fid(dir)), dir, LL_IT2STR(it)); rc = it_open_error(DISP_OPEN_CREATE, it); if (rc) RETURN(rc); - inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, - NULL, 0, mode, 0, it); + inode = ll_create_node(dir, it); if (IS_ERR(inode)) RETURN(PTR_ERR(inode)); - if (filename_is_volatile(dentry->d_name.name, dentry->d_name.len, NULL)) - ll_i2info(inode)->lli_volatile = true; - d_instantiate(dentry, inode); RETURN(0); } -static void ll_update_times(struct ptlrpc_request *request, - struct inode *inode) +void ll_update_times(struct ptlrpc_request *request, struct inode *inode) { - struct mdt_body *body = req_capsule_server_get(&request->rq_pill, - &RMF_MDT_BODY); - - LASSERT(body); - if (body->valid & OBD_MD_FLMTIME && - body->mtime > LTIME_S(inode->i_mtime)) { - 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; - } - if (body->valid & OBD_MD_FLCTIME && - body->ctime > LTIME_S(inode->i_ctime)) - LTIME_S(inode->i_ctime) = body->ctime; + struct mdt_body *body = req_capsule_server_get(&request->rq_pill, + &RMF_MDT_BODY); + + LASSERT(body); + if (body->mbo_valid & OBD_MD_FLMTIME && + body->mbo_mtime > LTIME_S(inode->i_mtime)) { + CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to "LPU64 + "\n", PFID(ll_inode2fid(inode)), + LTIME_S(inode->i_mtime), body->mbo_mtime); + LTIME_S(inode->i_mtime) = body->mbo_mtime; + } + + if (body->mbo_valid & OBD_MD_FLCTIME && + body->mbo_ctime > LTIME_S(inode->i_ctime)) + LTIME_S(inode->i_ctime) = body->mbo_ctime; } static int ll_new_node(struct inode *dir, struct qstr *name, @@ -895,10 +927,11 @@ static int ll_new_node(struct inode *dir, struct qstr *name, 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, - cfs_curproc_fsuid(), cfs_curproc_fsgid(), - cfs_curproc_cap_pack(), rdev, &request); - ll_finish_md_op_data(op_data); + err = md_create(sbi->ll_md_exp, op_data, tgt, tgt_len, mode, + from_kuid(&init_user_ns, current_fsuid()), + from_kgid(&init_user_ns, current_fsgid()), + cfs_curproc_cap_pack(), rdev, &request); + ll_finish_md_op_data(op_data); if (err) GOTO(err_exit, err); @@ -924,12 +957,12 @@ static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode, 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, + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p) mode %o dev %x\n", + name->len, name->name, PFID(ll_inode2fid(dir)), dir, mode, rdev); - if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir))) - mode &= ~cfs_curproc_umask(); + if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir))) + mode &= ~current_umask(); switch (mode & S_IFMT) { case 0: @@ -964,10 +997,10 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry, { int rc; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)," - "flags=%u, excl=%d\n", - dentry->d_name.len, dentry->d_name.name, dir->i_ino, - dir->i_generation, dir, mode, want_excl); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), " + "flags=%u, excl=%d\n", dentry->d_name.len, + dentry->d_name.name, PFID(ll_inode2fid(dir)), + dir, mode, want_excl); rc = ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry); @@ -1027,9 +1060,9 @@ static int ll_symlink_generic(struct inode *dir, struct qstr *name, int err; ENTRY; - 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); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), target=%.*s\n", + name->len, name->name, PFID(ll_inode2fid(dir)), + dir, 3000, tgt); err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO, 0, dchild, LUSTRE_OPC_SYMLINK); @@ -1049,10 +1082,9 @@ static int ll_link_generic(struct inode *src, struct inode *dir, int err; 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, name->len, name->name); + CDEBUG(D_VFSTRACE, "VFS Op: inode="DFID"(%p), dir="DFID + "(%p), target=%.*s\n", PFID(ll_inode2fid(src)), src, + PFID(ll_inode2fid(dir)), dir, name->len, name->name); op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len, 0, LUSTRE_OPC_ANY, NULL); @@ -1079,13 +1111,13 @@ static int ll_mkdir_generic(struct inode *dir, struct qstr *name, int err; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - name->len, name->name, dir->i_ino, dir->i_generation, dir); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n", + name->len, name->name, PFID(ll_inode2fid(dir)), dir); - if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir))) - mode &= ~cfs_curproc_umask(); - mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR; - err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR); + if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir))) + mode &= ~current_umask(); + mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR; + err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR); if (!err) ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1); @@ -1093,22 +1125,6 @@ static int ll_mkdir_generic(struct inode *dir, struct qstr *name, RETURN(err); } -/* 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 = ll_d_hlist_entry(dir->i_dentry, 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) { @@ -1117,8 +1133,8 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent, int rc; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - name->len, name->name, dir->i_ino, dir->i_generation, dir); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n", + name->len, name->name, PFID(ll_inode2fid(dir)), dir); if (unlikely(ll_d_mountpoint(dparent, dchild, name))) RETURN(-EBUSY); @@ -1128,7 +1144,8 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent, if (IS_ERR(op_data)) RETURN(PTR_ERR(op_data)); - ll_get_child_fid(dir, name, &op_data->op_fid3); + if (dchild != NULL && dchild->d_inode != NULL) + op_data->op_fid3 = *ll_inode2fid(dchild->d_inode); op_data->op_fid2 = op_data->op_fid3; rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request); ll_finish_md_op_data(op_data); @@ -1151,8 +1168,8 @@ int ll_rmdir_entry(struct inode *dir, char *name, int namelen) int rc; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - namelen, name, dir->i_ino, dir->i_generation, dir); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n", + namelen, name, PFID(ll_inode2fid(dir)), dir); op_data = ll_prep_md_op_data(NULL, dir, NULL, name, strlen(name), S_IFDIR, LUSTRE_OPC_ANY, NULL); @@ -1182,11 +1199,11 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) 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); + body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); + if (!(body->mbo_valid & OBD_MD_FLEASIZE)) + RETURN(0); - if (body->eadatasize == 0) { + if (body->mbo_eadatasize == 0) { CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n"); GOTO(out, rc = -EPROTO); } @@ -1195,11 +1212,11 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) * 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); + eadata = req_capsule_server_sized_get(&request->rq_pill, &RMF_MDT_MD, + body->mbo_eadatasize); + LASSERT(eadata != NULL); - rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize); + rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->mbo_eadatasize); if (rc < 0) { CERROR("obd_unpackmd: %d\n", rc); GOTO(out, rc); @@ -1211,10 +1228,10 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) GOTO(out_free_memmd, rc = -ENOMEM); oa->o_oi = lsm->lsm_oi; - oa->o_mode = body->mode & S_IFMT; - oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP; + oa->o_mode = body->mbo_mode & S_IFMT; + oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP; - if (body->valid & OBD_MD_FLCOOKIE) { + if (body->mbo_valid & OBD_MD_FLCOOKIE) { oa->o_valid |= OBD_MD_FLCOOKIE; oti.oti_logcookies = req_capsule_server_sized_get(&request->rq_pill, @@ -1223,11 +1240,11 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) lsm->lsm_stripe_count); if (oti.oti_logcookies == NULL) { oa->o_valid &= ~OBD_MD_FLCOOKIE; - body->valid &= ~OBD_MD_FLCOOKIE; - } - } + body->mbo_valid &= ~OBD_MD_FLCOOKIE; + } + } - if (body->valid & OBD_MD_FLOSSCAPA) { + if (body->mbo_valid & OBD_MD_FLOSSCAPA) { rc = md_unpack_capa(ll_i2mdexp(dir), request, &RMF_CAPA2, &oc); if (rc) GOTO(out_free_memmd, rc); @@ -1257,8 +1274,8 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent, struct md_op_data *op_data; int rc; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", - name->len, name->name, dir->i_ino, dir->i_generation, dir); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n", + name->len, name->name, PFID(ll_inode2fid(dir)), dir); /* * XXX: unlink bind mountpoint maybe call to here, @@ -1272,7 +1289,9 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent, if (IS_ERR(op_data)) RETURN(PTR_ERR(op_data)); - ll_get_child_fid(dir, name, &op_data->op_fid3); + if (dchild != NULL && dchild->d_inode != NULL) + op_data->op_fid3 = *ll_inode2fid(dchild->d_inode); + op_data->op_fid2 = op_data->op_fid3; rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request); ll_finish_md_op_data(op_data); @@ -1298,10 +1317,11 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent, struct md_op_data *op_data; int err; ENTRY; - CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s," - "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); + CDEBUG(D_VFSTRACE, "VFS Op:oldname=%.*s, src_dir="DFID + "(%p), newname=%.*s, tgt_dir="DFID"(%p)\n", + src_name->len, src_name->name, + PFID(ll_inode2fid(src)), src, tgt_name->len, + tgt_name->name, PFID(ll_inode2fid(tgt)), tgt); if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) || ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name))) @@ -1312,8 +1332,11 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent, 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); + if (src_dchild != NULL && src_dchild->d_inode != NULL) + op_data->op_fid3 = *ll_inode2fid(src_dchild->d_inode); + if (tgt_dchild != NULL && tgt_dchild->d_inode != NULL) + op_data->op_fid4 = *ll_inode2fid(tgt_dchild->d_inode); + err = md_rename(sbi->ll_md_exp, op_data, src_name->name, src_name->len, tgt_name->name, tgt_name->len, &request); @@ -1373,16 +1396,12 @@ static int ll_rename(struct inode *old_dir, struct dentry *old_dentry, 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 + if (!err) d_move(old_dentry, new_dentry); - } return err; } -struct inode_operations ll_dir_inode_operations = { +const struct inode_operations ll_dir_inode_operations = { .mknod = ll_mknod, #ifdef HAVE_IOP_ATOMIC_OPEN .atomic_open = ll_atomic_open, @@ -1408,7 +1427,7 @@ struct inode_operations ll_dir_inode_operations = { #endif }; -struct inode_operations ll_special_inode_operations = { +const struct inode_operations ll_special_inode_operations = { .setattr = ll_setattr, .getattr = ll_getattr, .permission = ll_inode_permission,