*
* 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
- *
- * 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.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2015, Intel Corporation.
+ * Copyright (c) 2011, 2016, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include "llite_internal.h"
static int ll_create_it(struct inode *dir, struct dentry *dentry,
- struct lookup_intent *it);
+ struct lookup_intent *it,
+ void *secctx, __u32 secctxlen);
/* called from iget5_locked->find_inode() under inode_lock spinlock */
static int ll_test_inode(struct inode *inode, void *opaque)
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",
+ "valid = %#llx\n",
PFID(&lli->lli_fid), body->mbo_valid);
return -EINVAL;
}
iput(inode);
inode = ERR_PTR(rc);
} else {
+ inode_has_no_xattr(inode);
unlock_new_inode(inode);
}
+ } else if (is_bad_inode(inode)) {
+ iput(inode);
+ inode = ERR_PTR(-ESTALE);
} 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(ll_inode2fid(inode)), rc);
}
+ if (bits & MDS_INODELOCK_UPDATE) {
+ struct ll_inode_info *lli = ll_i2info(inode);
+ lli->lli_update_atime = 1;
+ }
+
if ((bits & MDS_INODELOCK_UPDATE) && S_ISDIR(inode->i_mode)) {
struct ll_inode_info *lli = ll_i2info(inode);
master_inode = ilookup5_nowait(inode->i_sb,
hash, ll_test_inode_by_fid,
(void *)&lli->lli_pfid);
- if (master_inode != NULL &&
- !IS_ERR(master_inode)) {
+ if (master_inode) {
ll_invalidate_negative_children(
master_inode);
iput(master_inode);
}
static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
- struct lookup_intent *it)
+ struct lookup_intent *it,
+ void **secctx, __u32 *secctxlen)
{
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
struct dentry *save = dentry, *retval;
&op_data->op_file_secctx_size);
if (rc < 0)
GOTO(out, retval = ERR_PTR(rc));
+ if (secctx != NULL)
+ *secctx = op_data->op_file_secctx;
+ if (secctxlen != NULL)
+ *secctxlen = op_data->op_file_secctx_size;
}
rc = md_intent_lock(ll_i2mdexp(parent), op_data, it, &req,
GOTO(out, retval = (dentry == save) ? NULL : dentry);
out:
- if (op_data != NULL && !IS_ERR(op_data))
+ if (op_data != NULL && !IS_ERR(op_data)) {
+ if (secctx != NULL && secctxlen != NULL) {
+ /* caller needs sec ctx info, so reset it in op_data to
+ * prevent it from being freed */
+ op_data->op_file_secctx = NULL;
+ op_data->op_file_secctx_size = 0;
+ }
ll_finish_md_op_data(op_data);
+ }
ptlrpc_req_finished(req);
return retval;
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))
+ /*
+ * Optimize away (CREATE && !OPEN). Let .create handle the race.
+ * but only if we have write permissions there, otherwise we need
+ * to proceed with lookup. LU-4185
+ */
+ if ((flags & LOOKUP_CREATE) && !(flags & LOOKUP_OPEN) &&
+ (inode_permission(parent, MAY_WRITE | MAY_EXEC) == 0))
return NULL;
if (flags & (LOOKUP_PARENT|LOOKUP_OPEN|LOOKUP_CREATE))
itp = NULL;
else
itp = ⁢
- de = ll_lookup_it(parent, dentry, itp);
+ de = ll_lookup_it(parent, dentry, itp, NULL, NULL);
if (itp != NULL)
ll_intent_release(itp);
struct lookup_intent *it;
struct dentry *de;
long long lookup_flags = LOOKUP_OPEN;
+ void *secctx = NULL;
+ __u32 secctxlen = 0;
int rc = 0;
ENTRY;
it->it_flags &= ~MDS_OPEN_FL_INTERNAL;
/* Dentry added to dcache tree in ll_lookup_it */
- de = ll_lookup_it(dir, dentry, it);
+ de = ll_lookup_it(dir, dentry, it, &secctx, &secctxlen);
if (IS_ERR(de))
rc = PTR_ERR(de);
else if (de != NULL)
if (!rc) {
if (it_disposition(it, DISP_OPEN_CREATE)) {
/* Dentry instantiated in ll_create_it. */
- rc = ll_create_it(dir, dentry, it);
+ rc = ll_create_it(dir, dentry, it, secctx, secctxlen);
+ security_release_secctx(secctx, secctxlen);
if (rc) {
/* We dget in ll_splice_alias. */
if (de != NULL)
#else /* !HAVE_IOP_ATOMIC_OPEN */
static struct lookup_intent *
-ll_convert_intent(struct open_intent *oit, int lookup_flags)
+ll_convert_intent(struct open_intent *oit, int lookup_flags, bool is_readonly)
{
struct lookup_intent *it;
if (lookup_flags & LOOKUP_OPEN) {
it->it_op = IT_OPEN;
- if (lookup_flags & LOOKUP_CREATE)
+ /* Avoid file creation for ro bind mount point(is_readonly) */
+ if ((lookup_flags & LOOKUP_CREATE) && !is_readonly)
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 = ll_namei_to_lookup_intent_flag(oit->flags &
+ ~(is_readonly ? O_CREAT : 0));
it->it_flags &= ~MDS_OPEN_FL_INTERNAL;
} else {
it->it_op = IT_GETATTR;
static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
struct nameidata *nd)
{
- struct dentry *de;
- ENTRY;
+ struct dentry *de;
+ ENTRY;
- if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) {
- struct lookup_intent *it;
+ if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) {
+ struct lookup_intent *it;
- if (ll_d2d(dentry) && ll_d2d(dentry)->lld_it) {
- it = ll_d2d(dentry)->lld_it;
- ll_d2d(dentry)->lld_it = NULL;
- } else {
+ if (ll_d2d(dentry) && ll_d2d(dentry)->lld_it) {
+ it = ll_d2d(dentry)->lld_it;
+ ll_d2d(dentry)->lld_it = NULL;
+ } else {
+ /*
+ * Optimize away (CREATE && !OPEN). Let .create handle
+ * the race. But only if we have write permissions
+ * there, otherwise we need to proceed with lookup.
+ * LU-4185
+ */
if ((nd->flags & LOOKUP_CREATE) &&
- !(nd->flags & LOOKUP_OPEN))
- RETURN(NULL);
-
- it = ll_convert_intent(&nd->intent.open, nd->flags);
- if (IS_ERR(it))
- RETURN((struct dentry *)it);
- }
-
- de = ll_lookup_it(parent, dentry, it);
- if (de)
- dentry = de;
- if ((nd->flags & LOOKUP_OPEN) && !IS_ERR(dentry)) { /* Open */
- if (dentry->d_inode &&
- it_disposition(it, DISP_OPEN_OPEN)) { /* nocreate */
- if (S_ISFIFO(dentry->d_inode->i_mode)) {
+ !(nd->flags & LOOKUP_OPEN) &&
+ (inode_permission(parent,
+ MAY_WRITE | MAY_EXEC) == 0))
+ RETURN(NULL);
+
+ it = ll_convert_intent(&nd->intent.open, nd->flags,
+ (nd->path.mnt->mnt_flags & MNT_READONLY) ||
+ (nd->path.mnt->mnt_sb->s_flags & MS_RDONLY));
+ if (IS_ERR(it))
+ RETURN((struct dentry *)it);
+ }
+
+ de = ll_lookup_it(parent, dentry, it, NULL, NULL);
+ if (de)
+ dentry = de;
+ if ((nd->flags & LOOKUP_OPEN) && !IS_ERR(dentry)) { /* Open */
+ if (dentry->d_inode &&
+ it_disposition(it, DISP_OPEN_OPEN)) { /* nocreate */
+ if (S_ISFIFO(dentry->d_inode->i_mode)) {
/* We cannot call open here as it might
* deadlock. This case is unreachable in
* practice because of
* OBD_CONNECT_NODEVOH. */
- } else {
+ } else {
struct file *filp;
nd->intent.open.file->private_data = it;
dput(de);
de = (struct dentry *)filp;
}
- }
- } 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);
+ }
+ } 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, NULL, NULL);
}
RETURN(de);
if (rc)
GOTO(out, inode = ERR_PTR(rc));
- LASSERT(ll_d_hlist_empty(&inode->i_dentry));
+ /* Pause to allow for a race with concurrent access by fid */
+ OBD_FAIL_TIMEOUT(OBD_FAIL_LLITE_CREATE_NODE_PAUSE, cfs_fail_val);
/* We asked for a lock on the directory, but were granted a
* lock on the inode. Since we finally have an inode pointer,
* with d_instantiate().
*/
static int ll_create_it(struct inode *dir, struct dentry *dentry,
- struct lookup_intent *it)
+ struct lookup_intent *it,
+ void *secctx, __u32 secctxlen)
{
struct inode *inode;
int rc = 0;
if (IS_ERR(inode))
RETURN(PTR_ERR(inode));
+ if ((ll_i2sbi(inode)->ll_flags & LL_SBI_FILE_SECCTX) &&
+ secctx != NULL) {
+ inode_lock(inode);
+ /* must be done before d_instantiate, because it calls
+ * security_d_instantiate, which means a getxattr if security
+ * context is not set yet */
+ rc = security_inode_notifysecctx(inode, secctx, secctxlen);
+ inode_unlock(inode);
+ if (rc)
+ RETURN(rc);
+ }
+
d_instantiate(dentry, inode);
if (!(ll_i2sbi(inode)->ll_flags & LL_SBI_FILE_SECCTX)) {
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
+ CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to %llu"
"\n", PFID(ll_inode2fid(inode)),
LTIME_S(inode->i_mtime), body->mbo_mtime);
LTIME_S(inode->i_mtime) = body->mbo_mtime;
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);
- op_data = NULL;
if (err < 0 && err != -EREMOTE)
GOTO(err_exit, err);
ptlrpc_req_finished(request);
request = NULL;
+ ll_finish_md_op_data(op_data);
goto again;
}
if (err)
GOTO(err_exit, err);
+ if (sbi->ll_flags & LL_SBI_FILE_SECCTX) {
+ inode_lock(inode);
+ /* must be done before d_instantiate, because it calls
+ * security_d_instantiate, which means a getxattr if security
+ * context is not set yet */
+ err = security_inode_notifysecctx(inode,
+ op_data->op_file_secctx,
+ op_data->op_file_secctx_size);
+ inode_unlock(inode);
+ if (err)
+ GOTO(err_exit, err);
+ }
+
d_instantiate(dchild, inode);
if (!(sbi->ll_flags & LL_SBI_FILE_SECCTX)) {
dentry->d_name.name, PFID(ll_inode2fid(dir)),
dir, mode, want_excl);
+ /* Using mknod(2) to create a regular file is designed to not recognize
+ * volatile file name, so we use ll_mknod() here. */
rc = ll_mknod(dir, dentry, mode, 0);
ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE, 1);
if (lld != NULL)
it = lld->lld_it;
- if (!it)
- return ll_mknod(dir, dentry, mode, 0);
+ if (!it) {
+ /* LU-8559: use LUSTRE_OPC_CREATE for non atomic open case
+ * so that volatile file name is recoginized.
+ * Mknod(2), however, is designed to not recognize volatile
+ * file name to avoid inode leak under orphan directory until
+ * MDT reboot */
+ return ll_new_node(dir, dentry, NULL, mode, 0,
+ LUSTRE_OPC_CREATE);
+ }
lld->lld_it = NULL;
- /* Was there an error? Propagate it! */
+ /* Was there an error? Propagate it! */
if (it->it_status) {
rc = it->it_status;
- goto out;
- }
+ goto out;
+ }
- rc = ll_create_it(dir, dentry, it);
- if (nd && (nd->flags & LOOKUP_OPEN) && dentry->d_inode) { /* Open */
+ rc = ll_create_it(dir, dentry, it, NULL, 0);
+ if (nd && (nd->flags & LOOKUP_OPEN) && dentry->d_inode) { /* Open */
struct file *filp;
nd->intent.open.file->private_data = it;
}
static int ll_rename(struct inode *src, struct dentry *src_dchild,
- struct inode *tgt, struct dentry *tgt_dchild)
+ struct inode *tgt, struct dentry *tgt_dchild
+#ifdef HAVE_IOPS_RENAME_WITH_FLAGS
+ , unsigned int flags
+#endif
+ )
{
struct qstr *src_name = &src_dchild->d_name;
struct qstr *tgt_name = &tgt_dchild->d_name;
- struct ptlrpc_request *request = NULL;
- struct ll_sb_info *sbi = ll_i2sbi(src);
- struct md_op_data *op_data;
- int err;
- ENTRY;
+ struct ptlrpc_request *request = NULL;
+ struct ll_sb_info *sbi = ll_i2sbi(src);
+ struct md_op_data *op_data;
+ int err;
+ ENTRY;
+
+#ifdef HAVE_IOPS_RENAME_WITH_FLAGS
+ if (flags)
+ return -EINVAL;
+#endif
+
CDEBUG(D_VFSTRACE, "VFS Op:oldname=%.*s, src_dir="DFID
"(%p), newname=%.*s, tgt_dir="DFID"(%p)\n",
src_name->len, src_name->name,
}
const struct inode_operations ll_dir_inode_operations = {
- .mknod = ll_mknod,
+ .mknod = ll_mknod,
#ifdef HAVE_IOP_ATOMIC_OPEN
- .atomic_open = ll_atomic_open,
+ .atomic_open = ll_atomic_open,
#endif
- .lookup = ll_lookup_nd,
- .create = ll_create_nd,
+ .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,
- .permission = ll_inode_permission,
- .setxattr = ll_setxattr,
- .getxattr = ll_getxattr,
- .listxattr = ll_listxattr,
- .removexattr = ll_removexattr,
+ .unlink = ll_unlink,
+ .mkdir = ll_mkdir,
+ .rmdir = ll_rmdir,
+ .symlink = ll_symlink,
+ .link = ll_link,
+ .rename = ll_rename,
+ .setattr = ll_setattr,
+ .getattr = ll_getattr,
+ .permission = ll_inode_permission,
+#ifdef HAVE_IOP_XATTR
+ .setxattr = ll_setxattr,
+ .getxattr = ll_getxattr,
+ .removexattr = ll_removexattr,
+#endif
+ .listxattr = ll_listxattr,
#ifdef HAVE_IOP_GET_ACL
- .get_acl = ll_get_acl,
+ .get_acl = ll_get_acl,
+#endif
+#ifdef HAVE_IOP_SET_ACL
+ .set_acl = ll_set_acl,
#endif
};
.setattr = ll_setattr,
.getattr = ll_getattr,
.permission = ll_inode_permission,
- .setxattr = ll_setxattr,
- .getxattr = ll_getxattr,
- .listxattr = ll_listxattr,
+#ifdef HAVE_IOP_XATTR
+ .setxattr = ll_setxattr,
+ .getxattr = ll_getxattr,
.removexattr = ll_removexattr,
+#endif
+ .listxattr = ll_listxattr,
#ifdef HAVE_IOP_GET_ACL
- .get_acl = ll_get_acl,
+ .get_acl = ll_get_acl,
+#endif
+#ifdef HAVE_IOP_SET_ACL
+ .set_acl = ll_set_acl,
#endif
};