*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/osd/osd_compat.c
*
OBD_SET_CTXT_MAGIC(newctxt);
newctxt->pwdmnt = dev->od_mnt;
newctxt->pwd = dev->od_mnt->mnt_root;
- newctxt->fs = get_ds();
newctxt->umask = current_umask();
newctxt->dt = NULL;
push_ctxt(save, newctxt);
}
+struct dentry *osd_lookup_one_len_common(struct osd_device *dev,
+ const char *name,
+ struct dentry *base, int len,
+ enum oi_check_flags flags)
+{
+ struct dentry *dchild;
+
+ /*
+ * We can't use inode_is_locked() directly since we can't know
+ * if the current thread context took the lock earlier or if
+ * another thread context took the lock. OI_LOCKED tells us
+ * if the current thread context has already taken the lock.
+ */
+ if (!(flags & OI_LOCKED)) {
+ /* If another thread took this lock already we will
+ * just have to wait until the other thread is done.
+ */
+ inode_lock(base->d_inode);
+ dchild = lookup_one_len(name, base, len);
+ inode_unlock(base->d_inode);
+ } else {
+ /* This thread context already has taken the lock.
+ * Other threads will have to wait until we are done.
+ */
+ dchild = lookup_one_len(name, base, len);
+ }
+ if (IS_ERR(dchild))
+ return dchild;
+
+ if (dchild->d_inode && unlikely(is_bad_inode(dchild->d_inode))) {
+ CERROR("%s: bad inode returned %lu/%u: rc = -ENOENT\n",
+ osd_name(dev), dchild->d_inode->i_ino,
+ dchild->d_inode->i_generation);
+ dput(dchild);
+ dchild = ERR_PTR(-ENOENT);
+ }
+
+ return dchild;
+}
+
+/**
+ * osd_lookup_one_len_unlocked
+ *
+ * @dev: obd device we are searching
+ * @name: pathname component to lookup
+ * @base: base directory to lookup from
+ * @len: maximum length @len should be interpreted to
+ *
+ * Unlike osd_lookup_one_len, this should be called without the parent
+ * i_mutex held, and will take the i_mutex itself.
+ */
+struct dentry *osd_lookup_one_len_unlocked(struct osd_device *dev,
+ const char *name,
+ struct dentry *base, int len)
+{
+ return osd_lookup_one_len_common(dev, name, base, len, ~OI_LOCKED);
+}
+
+/**
+ * osd_lookup_one_len - lookup single pathname component
+ *
+ * @dev: obd device we are searching
+ * @name: pathname component to lookup
+ * @base: base directory to lookup from
+ * @len: maximum length @len should be interpreted to
+ *
+ * The caller must hold inode lock
+ */
+struct dentry *osd_lookup_one_len(struct osd_device *dev, const char *name,
+ struct dentry *base, int len)
+{
+ return osd_lookup_one_len_common(dev, name, base, len, OI_LOCKED);
+}
+
/* utility to make a directory */
static struct dentry *
simple_mkdir(const struct lu_env *env, struct osd_device *osd,
// ASSERT_KERNEL_CTXT("kernel doing mkdir outside kernel context\n");
CDEBUG(D_INODE, "creating directory %.*s\n", (int)strlen(name), name);
- dchild = ll_lookup_one_len(name, dir, strlen(name));
+ dchild = osd_lookup_one_len_unlocked(osd, name, dir, strlen(name));
if (IS_ERR(dchild))
RETURN(dchild);
RETURN(dchild);
}
- err = vfs_mkdir(dir->d_inode, dchild, mode);
+ err = vfs_mkdir(&init_user_ns, dir->d_inode, dchild, mode);
if (err)
GOTO(out_err, err);
ENTRY;
- dlast = ll_lookup_one_len(LAST_RCVD, osd_sb(osd)->s_root,
- strlen(LAST_RCVD));
+ dlast = osd_lookup_one_len_unlocked(osd, LAST_RCVD, osd_sb(osd)->s_root,
+ strlen(LAST_RCVD));
if (IS_ERR(dlast))
return PTR_ERR(dlast);
else if (dlast->d_inode == NULL)
if (osd_seq->oos_dirs[j])
dput(osd_seq->oos_dirs[j]);
}
- OBD_FREE(osd_seq->oos_dirs,
- sizeof(struct dentry *) * osd_seq->oos_subdir_count);
+ OBD_FREE_PTR_ARRAY(osd_seq->oos_dirs,
+ osd_seq->oos_subdir_count);
}
if (osd_seq->oos_root)
static void osd_index_backup_dir_fini(struct osd_device *dev)
{
- if (dev->od_index_backup_inode) {
- iput(dev->od_index_backup_inode);
- dev->od_index_backup_inode = NULL;
- }
+ iput(dev->od_index_backup_inode);
+ dev->od_index_backup_inode = NULL;
}
int osd_obj_map_init(const struct lu_env *env, struct osd_device *dev)
child->d_name.name = name;
child->d_name.len = strlen(name);
- ll_vfs_dq_init(parent);
+ dquot_initialize(parent);
inode_lock(parent);
bh = osd_ldiskfs_find_entry(parent, &child->d_name, &de, NULL, NULL);
if (IS_ERR(bh))
return rc;
}
-static int osd_obj_del_entry(struct osd_thread_info *info,
- struct osd_device *osd,
- struct dentry *dird, char *name,
- handle_t *th)
+int osd_obj_del_entry(struct osd_thread_info *info, struct osd_device *osd,
+ struct dentry *dird, char *name, int namelen,
+ handle_t *th)
{
struct ldiskfs_dir_entry_2 *de;
struct buffer_head *bh;
child = &info->oti_child_dentry;
child->d_name.hash = 0;
child->d_name.name = name;
- child->d_name.len = strlen(name);
+ child->d_name.len = namelen;
child->d_parent = dird;
child->d_inode = NULL;
- ll_vfs_dq_init(dir);
+ dquot_initialize(dir);
inode_lock(dir);
bh = osd_ldiskfs_find_entry(dir, &child->d_name, &de, NULL, NULL);
if (IS_ERR(bh)) {
if (OBD_FAIL_CHECK(OBD_FAIL_OSD_COMPAT_INVALID_ENTRY))
inode->i_ino++;
- ll_vfs_dq_init(dir->d_inode);
+ dquot_initialize(dir->d_inode);
inode_lock(dir->d_inode);
rc = osd_ldiskfs_add_entry(info, osd, th, child, inode, NULL);
inode_unlock(dir->d_inode);
fid_seq_is_idif(seq) ? 0 : seq);
}
-static inline void osd_oid_name(char *name, size_t name_size,
- const struct lu_fid *fid, u64 id)
-{
- snprintf(name, name_size,
- (fid_seq_is_rsvd(fid_seq(fid)) ||
- fid_seq_is_mdt0(fid_seq(fid)) ||
- fid_seq_is_idif(fid_seq(fid))) ? "%llu" : "%llx", id);
-}
-
/* external locking is required */
static int osd_seq_load_locked(struct osd_thread_info *info,
struct osd_device *osd,
osd_seq->oos_root = seq_dir;
LASSERT(osd_seq->oos_dirs == NULL);
- OBD_ALLOC(osd_seq->oos_dirs,
- sizeof(seq_dir) * osd_seq->oos_subdir_count);
+ OBD_ALLOC_PTR_ARRAY(osd_seq->oos_dirs, osd_seq->oos_subdir_count);
if (osd_seq->oos_dirs == NULL)
GOTO(out_put, rc = -ENOMEM);
if (osd_seq->oos_dirs[i] != NULL)
dput(osd_seq->oos_dirs[i]);
}
- OBD_FREE(osd_seq->oos_dirs,
- sizeof(seq_dir) * osd_seq->oos_subdir_count);
+ OBD_FREE_PTR_ARRAY(osd_seq->oos_dirs,
+ osd_seq->oos_subdir_count);
out_put:
dput(seq_dir);
osd_seq->oos_root = NULL;
RETURN(rc);
}
-static struct osd_obj_seq *osd_seq_load(struct osd_thread_info *info,
- struct osd_device *osd, u64 seq)
+struct osd_obj_seq *osd_seq_load(struct osd_thread_info *info,
+ struct osd_device *osd, u64 seq)
{
struct osd_obj_map *map;
struct osd_obj_seq *osd_seq;
LASSERT(d);
osd_oid_name(name, sizeof(name), fid, ostid_id(ostid));
- rc = osd_obj_del_entry(info, osd, d, name, th);
+ rc = osd_obj_del_entry(info, osd, d, name, strlen(name), th);
cleanup:
RETURN(rc);
}
if (IS_ERR(jh))
RETURN(PTR_ERR(jh));
- ll_vfs_dq_init(src_parent);
- ll_vfs_dq_init(dir);
+ dquot_initialize(src_parent);
+ dquot_initialize(dir);
- inode_lock(src_parent);
inode_lock(dir);
bh = osd_ldiskfs_find_entry(dir, &tgt_child->d_name, &de, NULL, NULL);
if (!IS_ERR(bh)) {
*/
brelse(bh);
inode_unlock(dir);
- inode_unlock(src_parent);
ldiskfs_journal_stop(jh);
rc = -EEXIST;
/* If the src object has never been modified, then remove it. */
if (inode->i_size == 0 && inode->i_mode & S_ISUID &&
inode->i_mode & S_ISGID) {
- rc = ll_vfs_unlink(src_parent, src_child);
+ rc = vfs_unlink(&init_user_ns, src_parent, src_child);
if (unlikely(rc == -ENOENT))
rc = 0;
}
- RETURN(rc);
+ if (rc)
+ RETURN(rc);
}
bh = osd_ldiskfs_find_entry(src_parent, &src_child->d_name, &de,
unlock:
inode_unlock(dir);
- inode_unlock(src_parent);
ldiskfs_journal_stop(jh);
return rc;
}
}
int osd_obj_spec_lookup(struct osd_thread_info *info, struct osd_device *osd,
- const struct lu_fid *fid, struct osd_inode_id *id)
+ const struct lu_fid *fid, struct osd_inode_id *id,
+ enum oi_check_flags flags)
{
struct dentry *root;
struct dentry *dentry;
RETURN(-ENOENT);
}
- dentry = ll_lookup_one_len(name, root, strlen(name));
+ dentry = osd_lookup_one_len_common(osd, name, root, strlen(name),
+ flags);
if (!IS_ERR(dentry)) {
inode = dentry->d_inode;
if (inode) {
#ifndef HAVE_BIO_INTEGRITY_ENABLED
bool bio_integrity_enabled(struct bio *bio)
{
-# ifdef HAVE_BI_BDEV
- struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
-# else
- struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);
-# endif
+ struct blk_integrity *bi = blk_get_integrity(bio_get_disk(bio));
if (bio_op(bio) != REQ_OP_READ && bio_op(bio) != REQ_OP_WRITE)
return false;