-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* Pravin Shelar <pravin.shelar@sun.com> : Added fid in dirent
*/
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
#define DEBUG_SUBSYSTEM S_MDS
#include <linux/module.h>
/* llo_* api support */
#include <md_object.h>
+/* dt_acct_features */
+#include <lquota.h>
#ifdef HAVE_LDISKFS_PDO
int ldiskfs_pdo = 1;
static const struct lu_object_operations osd_lu_obj_ops;
static const struct dt_object_operations osd_obj_ops;
static const struct dt_object_operations osd_obj_ea_ops;
+static const struct dt_object_operations osd_obj_otable_it_ops;
static const struct dt_index_operations osd_index_iam_ops;
static const struct dt_index_operations osd_index_ea_ops;
#ifdef HAVE_QUOTA_SUPPORT
static inline void
-osd_push_ctxt(const struct lu_env *env, struct osd_ctxt *save)
+osd_push_ctxt(const struct lu_env *env, struct osd_ctxt *save, bool is_md)
{
- struct md_ucred *uc = md_ucred(env);
+ struct md_ucred *uc;
struct cred *tc;
+ if (!is_md)
+ /* OFD support */
+ return;
+
+ uc = md_ucred(env);
+
LASSERT(uc != NULL);
save->oc_uid = current_fsuid();
}
static inline void
-osd_pop_ctxt(struct osd_ctxt *save)
+osd_pop_ctxt(struct osd_ctxt *save, bool is_md)
{
struct cred *tc;
+ if (!is_md)
+ /* OFD support */
+ return;
+
if ((tc = prepare_creds())) {
tc->fsuid = save->oc_uid;
tc->fsgid = save->oc_gid;
}
}
-/*
- * retrieve object from backend ext fs.
- **/
-struct inode *osd_iget(struct osd_thread_info *info,
- struct osd_device *dev,
- const struct osd_inode_id *id)
+static int osd_get_lma(struct inode *inode, struct dentry *dentry,
+ struct lustre_mdt_attrs *lma)
{
- struct inode *inode = NULL;
-
- inode = ldiskfs_iget(osd_sb(dev), id->oii_ino);
- if (IS_ERR(inode)) {
- CERROR("Cannot get inode, rc = %li\n", PTR_ERR(inode));
- } else if (id->oii_gen != OSD_OII_NOGEN &&
- inode->i_generation != id->oii_gen) {
- iput(inode);
- inode = ERR_PTR(-ESTALE);
- } else if (inode->i_nlink == 0) {
- /* due to parallel readdir and unlink,
- * we can have dead inode here. */
- CWARN("stale inode\n");
- make_bad_inode(inode);
- iput(inode);
- inode = ERR_PTR(-ESTALE);
- } else if (is_bad_inode(inode)) {
- CERROR("bad inode %lx\n",inode->i_ino);
- iput(inode);
- inode = ERR_PTR(-ENOENT);
- } else {
- /* Do not update file c/mtime in ldiskfs.
- * NB: we don't have any lock to protect this because we don't
- * have reference on osd_object now, but contention with
- * another lookup + attr_set can't happen in the tiny window
- * between if (...) and set S_NOCMTIME. */
- if (!(inode->i_flags & S_NOCMTIME))
- inode->i_flags |= S_NOCMTIME;
- }
- return inode;
-}
-
-static int osd_fid_lookup(const struct lu_env *env,
- struct osd_object *obj, const struct lu_fid *fid)
-{
- struct osd_thread_info *info;
- struct lu_device *ldev = obj->oo_dt.do_lu.lo_dev;
- struct osd_device *dev;
- struct osd_inode_id *id;
- struct inode *inode;
- int result;
+ int rc;
- LINVRNT(osd_invariant(obj));
- LASSERT(obj->oo_inode == NULL);
- LASSERTF(fid_is_sane(fid) || fid_is_idif(fid), DFID, PFID(fid));
- /*
- * This assertion checks that osd layer sees only local
- * fids. Unfortunately it is somewhat expensive (does a
- * cache-lookup). Disabling it for production/acceptance-testing.
- */
- LASSERT(1 || fid_is_local(env, ldev->ld_site, fid));
-
- ENTRY;
+ dentry->d_inode = inode;
+ rc = inode->i_op->getxattr(dentry, XATTR_NAME_LMA, (void *)lma,
+ sizeof(*lma));
+ if (rc > 0) {
+ /* Check LMA compatibility */
+ if (lma->lma_incompat & ~cpu_to_le32(LMA_INCOMPAT_SUPP)) {
+ CWARN("%.16s: unsupported incompat LMA feature(s) "
+ "%lx/%#x\n",
+ LDISKFS_SB(inode->i_sb)->s_es->s_volume_name,
+ inode->i_ino, le32_to_cpu(lma->lma_incompat) &
+ ~LMA_INCOMPAT_SUPP);
+ rc = -ENOSYS;
+ } else {
+ lustre_lma_swab(lma);
+ rc = 0;
+ }
+ } else if (rc == 0) {
+ rc = -ENODATA;
+ }
- info = osd_oti_get(env);
- LASSERT(info);
- dev = osd_dev(ldev);
- id = &info->oti_id;
-
- if (OBD_FAIL_CHECK(OBD_FAIL_OST_ENOENT))
- RETURN(-ENOENT);
+ return rc;
+}
- result = osd_oi_lookup(info, dev, fid, id);
- if (result != 0) {
- if (result == -ENOENT)
- result = 0;
- GOTO(out, result);
- }
+/*
+ * retrieve object from backend ext fs.
+ **/
+struct inode *osd_iget(struct osd_thread_info *info, struct osd_device *dev,
+ struct osd_inode_id *id)
+{
+ struct inode *inode = NULL;
+
+ inode = ldiskfs_iget(osd_sb(dev), id->oii_ino);
+ if (IS_ERR(inode)) {
+ CDEBUG(D_INODE, "no inode: ino = %u, rc = %ld\n",
+ id->oii_ino, PTR_ERR(inode));
+ } else if (id->oii_gen != OSD_OII_NOGEN &&
+ inode->i_generation != id->oii_gen) {
+ CDEBUG(D_INODE, "unmatched inode: ino = %u, gen0 = %u, "
+ "gen1 = %u\n",
+ id->oii_ino, id->oii_gen, inode->i_generation);
+ iput(inode);
+ inode = ERR_PTR(-ESTALE);
+ } else if (inode->i_nlink == 0) {
+ /* due to parallel readdir and unlink,
+ * we can have dead inode here. */
+ CDEBUG(D_INODE, "stale inode: ino = %u\n", id->oii_ino);
+ make_bad_inode(inode);
+ iput(inode);
+ inode = ERR_PTR(-ESTALE);
+ } else if (is_bad_inode(inode)) {
+ CWARN("%.16s: bad inode: ino = %u\n",
+ LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name, id->oii_ino);
+ iput(inode);
+ inode = ERR_PTR(-ENOENT);
+ } else {
+ if (id->oii_gen == OSD_OII_NOGEN)
+ osd_id_gen(id, inode->i_ino, inode->i_generation);
+
+ /* Do not update file c/mtime in ldiskfs.
+ * NB: we don't have any lock to protect this because we don't
+ * have reference on osd_object now, but contention with
+ * another lookup + attr_set can't happen in the tiny window
+ * between if (...) and set S_NOCMTIME. */
+ if (!(inode->i_flags & S_NOCMTIME))
+ inode->i_flags |= S_NOCMTIME;
+ }
+ return inode;
+}
+
+struct inode *osd_iget_fid(struct osd_thread_info *info, struct osd_device *dev,
+ struct osd_inode_id *id, struct lu_fid *fid)
+{
+ struct lustre_mdt_attrs *lma = &info->oti_mdt_attrs;
+ struct inode *inode;
+ int rc;
+
+ inode = osd_iget(info, dev, id);
+ if (IS_ERR(inode))
+ return inode;
+
+ rc = osd_get_lma(inode, &info->oti_obj_dentry, lma);
+ if (rc == 0) {
+ *fid = lma->lma_self_fid;
+ } else if (rc == -ENODATA) {
+ LU_IGIF_BUILD(fid, inode->i_ino, inode->i_generation);
+ } else {
+ iput(inode);
+ inode = ERR_PTR(rc);
+ }
+ return inode;
+}
+
+static struct inode *
+osd_iget_verify(struct osd_thread_info *info, struct osd_device *dev,
+ struct osd_inode_id *id, const struct lu_fid *fid)
+{
+ struct lustre_mdt_attrs *lma = &info->oti_mdt_attrs;
+ struct inode *inode;
+ int rc;
+
+ inode = osd_iget(info, dev, id);
+ if (IS_ERR(inode))
+ return inode;
+
+ rc = osd_get_lma(inode, &info->oti_obj_dentry, lma);
+ if (rc != 0) {
+ if (rc == -ENODATA) {
+ CDEBUG(D_LFSCK, "inconsistent obj: NULL, %lu, "DFID"\n",
+ inode->i_ino, PFID(fid));
+ rc = -EREMCHG;
+ }
+ iput(inode);
+ return ERR_PTR(rc);
+ }
+
+ if (!lu_fid_eq(fid, &lma->lma_self_fid)) {
+ CDEBUG(D_LFSCK, "inconsistent obj: "DFID", %lu, "DFID"\n",
+ PFID(&lma->lma_self_fid), inode->i_ino, PFID(fid));
+ iput(inode);
+ return ERR_PTR(EREMCHG);
+ }
+ return inode;
+}
+
+static int osd_fid_lookup(const struct lu_env *env, struct osd_object *obj,
+ const struct lu_fid *fid,
+ const struct lu_object_conf *conf)
+{
+ struct osd_thread_info *info;
+ struct lu_device *ldev = obj->oo_dt.do_lu.lo_dev;
+ struct osd_device *dev;
+ struct osd_idmap_cache *oic;
+ struct osd_inode_id *id;
+ struct inode *inode;
+ struct osd_scrub *scrub;
+ struct scrub_file *sf;
+ int result;
+ int verify = 0;
+ ENTRY;
+
+ LINVRNT(osd_invariant(obj));
+ LASSERT(obj->oo_inode == NULL);
+ LASSERTF(fid_is_sane(fid) || fid_is_idif(fid), DFID, PFID(fid));
+
+ dev = osd_dev(ldev);
+ scrub = &dev->od_scrub;
+ sf = &scrub->os_file;
+ info = osd_oti_get(env);
+ LASSERT(info);
+ oic = &info->oti_cache;
+ id = &oic->oic_lid;
+
+ if (OBD_FAIL_CHECK(OBD_FAIL_OST_ENOENT))
+ RETURN(-ENOENT);
+
+ if (fid_is_norm(fid)) {
+ /* Search order: 1. per-thread cache. */
+ if (lu_fid_eq(fid, &oic->oic_fid)) {
+ goto iget;
+ } else if (!cfs_list_empty(&scrub->os_inconsistent_items)) {
+ /* Search order: 2. OI scrub pending list. */
+ result = osd_oii_lookup(dev, fid, id);
+ if (result == 0)
+ goto iget;
+ }
+
+ if (sf->sf_flags & SF_INCONSISTENT)
+ verify = 1;
+ }
+
+ fid_zero(&oic->oic_fid);
+
+ /*
+ * Objects are created as locking anchors or place holders for objects
+ * yet to be created. No need to osd_oi_lookup() at here because FID
+ * shouldn't never be re-used, if it's really a duplicate FID from
+ * unexpected reason, we should be able to detect it later by calling
+ * do_create->osd_oi_insert()
+ */
+ if (conf != NULL && (conf->loc_flags & LOC_F_NEW) != 0)
+ GOTO(out, result = 0);
+
+ /* Search order: 3. OI files. */
+ result = osd_oi_lookup(info, dev, fid, id);
+ if (result == -ENOENT) {
+ if (!fid_is_norm(fid) ||
+ !ldiskfs_test_bit(osd_oi_fid2idx(dev,fid),
+ sf->sf_oi_bitmap))
+ GOTO(out, result = 0);
+
+ goto trigger;
+ }
+
+ if (result != 0)
+ GOTO(out, result);
+
+iget:
+ if (verify == 0)
+ inode = osd_iget(info, dev, id);
+ else
+ inode = osd_iget_verify(info, dev, id, fid);
+ if (IS_ERR(inode)) {
+ result = PTR_ERR(inode);
+ if (result == -ENOENT || result == -ESTALE) {
+ result = 0;
+ } else if (result == -EREMCHG) {
+
+trigger:
+ if (thread_is_running(&scrub->os_thread)) {
+ result = -EINPROGRESS;
+ } else if (!scrub->os_no_scrub) {
+ result = osd_scrub_start(dev);
+ LCONSOLE_ERROR("%.16s: trigger OI scrub by RPC "
+ "for "DFID", rc = %d [1]\n",
+ LDISKFS_SB(osd_sb(dev))->s_es->\
+ s_volume_name,PFID(fid), result);
+ if (result == 0 || result == -EALREADY)
+ result = -EINPROGRESS;
+ else
+ result = -EREMCHG;
+ }
+ }
- inode = osd_iget(info, dev, id);
- if (IS_ERR(inode)) {
- /*
- * If fid wasn't found in oi, inode-less object is
- * created, for which lu_object_exists() returns
- * false. This is used in a (frequent) case when
- * objects are created as locking anchors or
- * place holders for objects yet to be created.
- */
- result = PTR_ERR(inode);
GOTO(out, result);
}
}
if (!S_ISDIR(inode->i_mode) || !ldiskfs_pdo) /* done */
- goto out;
+ GOTO(out, result = 0);
+
+ LASSERT(obj->oo_hl_head == NULL);
+ obj->oo_hl_head = ldiskfs_htree_lock_head_alloc(HTREE_HBITS_DEF);
+ if (obj->oo_hl_head == NULL) {
+ obj->oo_inode = NULL;
+ iput(inode);
+ GOTO(out, result = -ENOMEM);
+ }
+ GOTO(out, result = 0);
- LASSERT(obj->oo_hl_head == NULL);
- obj->oo_hl_head = ldiskfs_htree_lock_head_alloc(HTREE_HBITS_DEF);
- if (obj->oo_hl_head == NULL) {
- obj->oo_inode = NULL;
- iput(inode);
- result = -ENOMEM;
- }
out:
- LINVRNT(osd_invariant(obj));
- RETURN(result);
+ LINVRNT(osd_invariant(obj));
+ return result;
}
/*
* life-cycle.
*/
static int osd_object_init(const struct lu_env *env, struct lu_object *l,
- const struct lu_object_conf *unused)
+ const struct lu_object_conf *conf)
{
- struct osd_object *obj = osd_obj(l);
- int result;
+ struct osd_object *obj = osd_obj(l);
+ int result;
- LINVRNT(osd_invariant(obj));
+ LINVRNT(osd_invariant(obj));
- result = osd_fid_lookup(env, obj, lu_object_fid(l));
- obj->oo_dt.do_body_ops = &osd_body_ops_new;
- if (result == 0) {
- if (obj->oo_inode != NULL)
- osd_object_init0(obj);
- }
- LINVRNT(osd_invariant(obj));
- return result;
+ result = osd_fid_lookup(env, obj, lu_object_fid(l), conf);
+ obj->oo_dt.do_body_ops = &osd_body_ops_new;
+ if (result == 0) {
+ if (obj->oo_inode != NULL) {
+ osd_object_init0(obj);
+ } else if (fid_is_otable_it(&l->lo_header->loh_fid)) {
+ obj->oo_dt.do_ops = &osd_obj_otable_it_ops;
+ /* LFSCK iterator object is special without inode */
+ l->lo_header->loh_attr |= LOHA_EXISTS;
+ }
+ }
+ LINVRNT(osd_invariant(obj));
+ return result;
}
/*
dt_txn_hook_commit(th);
- /* call per-transaction callbacks if any */
- cfs_list_for_each_entry_safe(dcb, tmp, &oh->ot_dcb_list, dcb_linkage)
- dcb->dcb_func(NULL, th, dcb, error);
+ /* call per-transaction callbacks if any */
+ cfs_list_for_each_entry_safe(dcb, tmp, &oh->ot_dcb_list, dcb_linkage) {
+ cfs_list_del_init(&dcb->dcb_linkage);
+ dcb->dcb_func(NULL, th, dcb, error);
+ }
lu_ref_del_at(&lud->ld_reference, oh->ot_dev_link, "osd-tx", th);
lu_device_put(lud);
GOTO(out, rc);
if (!osd_param_is_sane(dev, th)) {
- CWARN("%s: too many transaction credits (%d > %d)\n",
- d->dd_lu_dev.ld_obd->obd_name, oh->ot_credits,
- osd_journal(dev)->j_max_transaction_buffers);
+ CWARN("%.16s: too many transaction credits (%d > %d)\n",
+ LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name,
+ oh->ot_credits,
+ osd_journal(dev)->j_max_transaction_buffers);
/* XXX Limit the credits to 'max_transaction_buffers', and
* let the underlying filesystem to catch the error if
* we really need so many credits.
* data (ofd) and reverse ordering for metadata
* (mdd). then at some point we'll fix the latter
*/
- if (lu_device_is_md(&d->dd_lu_dev)) {
+ if (dev->od_is_md) {
LASSERT(oti->oti_r_locks == 0);
LASSERT(oti->oti_w_locks == 0);
}
* data (ofd) and reverse ordering for metadata
* (mdd). then at some point we'll fix the latter
*/
- if (lu_device_is_md(&th->th_dev->dd_lu_dev)) {
+ if (osd_dt_dev(th->th_dev)->od_is_md) {
LASSERT(oti->oti_r_locks == 0);
LASSERT(oti->oti_w_locks == 0);
}
struct kstatfs *ksfs;
int result = 0;
+ if (unlikely(osd->od_mount == NULL))
+ return -EINPROGRESS;
+
/* osd_lproc.c call this without env, allocate ksfs for that case */
if (unlikely(env == NULL)) {
OBD_ALLOC_PTR(ksfs);
*/
param->ddp_max_name_len = LDISKFS_NAME_LEN;
param->ddp_max_nlink = LDISKFS_LINK_MAX;
- param->ddp_block_shift = osd_sb(osd_dt_dev(dev))->s_blocksize_bits;
+ param->ddp_block_shift = sb->s_blocksize_bits;
param->ddp_mntopts = 0;
if (test_opt(sb, XATTR_USER))
param->ddp_mntopts |= MNTOPT_USERXATTR;
[DTO_INDEX_INSERT] = 16,
[DTO_INDEX_DELETE] = 16,
/**
- * Unused now
+ * Used for OI scrub
*/
[DTO_INDEX_UPDATE] = 16,
/**
}
static struct timespec *osd_inode_time(const struct lu_env *env,
- struct inode *inode, __u64 seconds)
+ struct inode *inode, __u64 seconds)
{
- struct osd_thread_info *oti = osd_oti_get(env);
- struct timespec *t = &oti->oti_time;
+ struct osd_thread_info *oti = osd_oti_get(env);
+ struct timespec *t = &oti->oti_time;
- t->tv_sec = seconds;
- t->tv_nsec = 0;
- *t = timespec_trunc(*t, get_sb_time_gran(inode->i_sb));
- return t;
+ t->tv_sec = seconds;
+ t->tv_nsec = 0;
+ *t = timespec_trunc(*t, inode->i_sb->s_time_gran);
+ return t;
}
return 0;
}
+static int osd_quota_transfer(struct inode *inode, const struct lu_attr *attr)
+{
+ if ((attr->la_valid & LA_UID && attr->la_uid != inode->i_uid) ||
+ (attr->la_valid & LA_GID && attr->la_gid != inode->i_gid)) {
+ struct iattr iattr;
+ int rc;
+
+ iattr.ia_valid = 0;
+ if (attr->la_valid & LA_UID)
+ iattr.ia_valid |= ATTR_UID;
+ if (attr->la_valid & LA_GID)
+ iattr.ia_valid |= ATTR_GID;
+ iattr.ia_uid = attr->la_uid;
+ iattr.ia_gid = attr->la_gid;
+
+ rc = ll_vfs_dq_transfer(inode, &iattr);
+ if (rc) {
+ CERROR("%s: quota transfer failed: rc = %d. Is quota "
+ "enforcement enabled on the ldiskfs filesystem?",
+ inode->i_sb->s_id, rc);
+ return rc;
+ }
+ }
+ return 0;
+}
+
static int osd_attr_set(const struct lu_env *env,
struct dt_object *dt,
const struct lu_attr *attr,
OSD_EXEC_OP(handle, attr_set);
inode = obj->oo_inode;
+ if (!osd_dt_dev(handle->th_dev)->od_is_md) {
+ /* OFD support */
+ rc = osd_quota_transfer(inode, attr);
+ if (rc)
+ return rc;
+ } else {
#ifdef HAVE_QUOTA_SUPPORT
- if ((attr->la_valid & LA_UID && attr->la_uid != inode->i_uid) ||
- (attr->la_valid & LA_GID && attr->la_gid != inode->i_gid)) {
- struct osd_ctxt *save = &osd_oti_get(env)->oti_ctxt;
- struct iattr iattr;
- int rc;
-
- iattr.ia_valid = 0;
- if (attr->la_valid & LA_UID)
- iattr.ia_valid |= ATTR_UID;
- if (attr->la_valid & LA_GID)
- iattr.ia_valid |= ATTR_GID;
- iattr.ia_uid = attr->la_uid;
- iattr.ia_gid = attr->la_gid;
- osd_push_ctxt(env, save);
- rc = ll_vfs_dq_transfer(inode, &iattr) ? -EDQUOT : 0;
- osd_pop_ctxt(save);
- if (rc != 0)
- return rc;
- }
+ if ((attr->la_valid & LA_UID && attr->la_uid != inode->i_uid) ||
+ (attr->la_valid & LA_GID && attr->la_gid != inode->i_gid)) {
+ struct osd_ctxt *save = &osd_oti_get(env)->oti_ctxt;
+ struct iattr iattr;
+ int rc;
+
+ iattr.ia_valid = 0;
+ if (attr->la_valid & LA_UID)
+ iattr.ia_valid |= ATTR_UID;
+ if (attr->la_valid & LA_GID)
+ iattr.ia_valid |= ATTR_GID;
+ iattr.ia_uid = attr->la_uid;
+ iattr.ia_gid = attr->la_gid;
+ osd_push_ctxt(env, save, 1);
+ rc = ll_vfs_dq_transfer(inode, &iattr) ? -EDQUOT : 0;
+ osd_pop_ctxt(save, 1);
+ if (rc != 0)
+ return rc;
+ }
#endif
-
+ }
cfs_spin_lock(&obj->oo_guard);
rc = osd_inode_setattr(env, inode, attr);
cfs_spin_unlock(&obj->oo_guard);
return rc;
}
-/*
- * Object creation.
- *
- * XXX temporary solution.
- */
-static int osd_create_pre(struct osd_thread_info *info, struct osd_object *obj,
- struct lu_attr *attr, struct thandle *th)
-{
- return 0;
-}
-
-static int osd_create_post(struct osd_thread_info *info, struct osd_object *obj,
- struct lu_attr *attr, struct thandle *th)
-{
- osd_object_init0(obj);
- if (obj->oo_inode && (obj->oo_inode->i_state & I_NEW))
- unlock_new_inode(obj->oo_inode);
- return 0;
-}
-
struct dentry *osd_child_dentry_get(const struct lu_env *env,
struct osd_object *obj,
const char *name, const int namelen)
parent = hint->dah_parent;
#ifdef HAVE_QUOTA_SUPPORT
- osd_push_ctxt(info->oti_env, save);
+ osd_push_ctxt(info->oti_env, save, osd_dt_dev(th->th_dev)->od_is_md);
#endif
inode = ldiskfs_create_inode(oth->ot_handle,
parent ? osd_dt_obj(parent)->oo_inode :
osd_sb(osd)->s_root->d_inode,
mode);
#ifdef HAVE_QUOTA_SUPPORT
- osd_pop_ctxt(save);
+ osd_pop_ctxt(save, osd_dt_dev(th->th_dev)->od_is_md);
#endif
if (!IS_ERR(inode)) {
/* Do not update file c/mtime in ldiskfs.
* NB: don't need any lock because no contention at this
* early stage */
inode->i_flags |= S_NOCMTIME;
+ inode->i_state |= I_LUSTRE_NOSCRUB;
obj->oo_inode = inode;
result = 0;
} else {
struct osd_thandle *oth;
const struct dt_index_features *feat = dof->u.dof_idx.di_feat;
- __u32 mode = (attr->la_mode & (S_IFMT | S_IRWXUGO | S_ISVTX));
+ __u32 mode = (attr->la_mode & (S_IFMT | S_IALLUGO | S_ISVTX));
LASSERT(S_ISREG(attr->la_mode));
{
LASSERT(S_ISREG(attr->la_mode));
return osd_mkfile(info, obj, (attr->la_mode &
- (S_IFMT | S_IRWXUGO | S_ISVTX)), hint, th);
+ (S_IFMT | S_IALLUGO | S_ISVTX)), hint, th);
}
static int osd_mksym(struct osd_thread_info *info, struct osd_object *obj,
{
LASSERT(S_ISLNK(attr->la_mode));
return osd_mkfile(info, obj, (attr->la_mode &
- (S_IFMT | S_IRWXUGO | S_ISVTX)), hint, th);
+ (S_IFMT | S_IALLUGO | S_ISVTX)), hint, th);
}
static int osd_mknod(struct osd_thread_info *info, struct osd_object *obj,
struct dt_object_format *dof,
struct thandle *th)
{
- cfs_umode_t mode = attr->la_mode & (S_IFMT | S_IRWXUGO | S_ISVTX);
+ cfs_umode_t mode = attr->la_mode & (S_IFMT | S_IALLUGO | S_ISVTX);
int result;
LINVRNT(osd_invariant(obj));
result = osd_mkfile(info, obj, mode, hint, th);
if (result == 0) {
LASSERT(obj->oo_inode != NULL);
+ /*
+ * This inode should be marked dirty for i_rdev. Currently
+ * that is done in the osd_attr_init().
+ */
init_special_inode(obj->oo_inode, mode, attr->la_rdev);
}
LINVRNT(osd_invariant(obj));
ah->dah_mode = child_mode;
}
+static void osd_attr_init(struct osd_thread_info *info, struct osd_object *obj,
+ struct lu_attr *attr, struct dt_object_format *dof)
+{
+ struct inode *inode = obj->oo_inode;
+ __u64 valid = attr->la_valid;
+ int result;
+
+ attr->la_valid &= ~(LA_TYPE | LA_MODE);
+
+ if (dof->dof_type != DFT_NODE)
+ attr->la_valid &= ~LA_RDEV;
+ if ((valid & LA_ATIME) && (attr->la_atime == LTIME_S(inode->i_atime)))
+ attr->la_valid &= ~LA_ATIME;
+ if ((valid & LA_CTIME) && (attr->la_ctime == LTIME_S(inode->i_ctime)))
+ attr->la_valid &= ~LA_CTIME;
+ if ((valid & LA_MTIME) && (attr->la_mtime == LTIME_S(inode->i_mtime)))
+ attr->la_valid &= ~LA_MTIME;
+
+ if (!osd_obj2dev(obj)->od_is_md) {
+ /* OFD support */
+ result = osd_quota_transfer(inode, attr);
+ if (result)
+ return;
+ } else {
+#ifdef HAVE_QUOTA_SUPPORT
+ attr->la_valid &= ~(LA_UID | LA_GID);
+#endif
+ }
+
+ if (attr->la_valid != 0) {
+ result = osd_inode_setattr(info->oti_env, inode, attr);
+ /*
+ * The osd_inode_setattr() should always succeed here. The
+ * only error that could be returned is EDQUOT when we are
+ * trying to change the UID or GID of the inode. However, this
+ * should not happen since quota enforcement is no longer
+ * enabled on ldiskfs (lquota takes care of it).
+ */
+ LASSERTF(result == 0, "%d", result);
+ inode->i_sb->s_op->dirty_inode(inode);
+ }
+
+ attr->la_valid = valid;
+}
+
/**
* Helper function for osd_object_create()
*
struct dt_object_format *dof,
struct thandle *th)
{
+ int result;
+ __u32 umask;
- int result;
+ /* we drop umask so that permissions we pass are not affected */
+ umask = current->fs->umask;
+ current->fs->umask = 0;
- result = osd_create_pre(info, obj, attr, th);
+ result = osd_create_type_f(dof->dof_type)(info, obj, attr, hint, dof,
+ th);
if (result == 0) {
- result = osd_create_type_f(dof->dof_type)(info, obj,
- attr, hint, dof, th);
- if (result == 0)
- result = osd_create_post(info, obj, attr, th);
+ osd_attr_init(info, obj, attr, dof);
+ osd_object_init0(obj);
+ /* bz 24037 */
+ if (obj->oo_inode && (obj->oo_inode->i_state & I_NEW))
+ unlock_new_inode(obj->oo_inode);
}
+
+ /* restore previous umask value */
+ current->fs->umask = umask;
+
return result;
}
struct osd_thread_info *info = osd_oti_get(env);
struct osd_inode_id *id = &info->oti_id;
struct osd_device *osd = osd_obj2dev(obj);
- struct md_ucred *uc = md_ucred(env);
LASSERT(obj->oo_inode != NULL);
- LASSERT(uc != NULL);
- id->oii_ino = obj->oo_inode->i_ino;
- id->oii_gen = obj->oo_inode->i_generation;
+ if (osd->od_is_md) {
+ struct md_ucred *uc = md_ucred(env);
+ LASSERT(uc != NULL);
+ }
- return osd_oi_insert(info, osd, fid, id, th,
- uc->mu_cap & CFS_CAP_SYS_RESOURCE_MASK);
+ osd_id_gen(id, obj->oo_inode->i_ino, obj->oo_inode->i_generation);
+ return osd_oi_insert(info, osd, fid, id, th);
}
static int osd_declare_object_create(const struct lu_env *env,
LASSERT(osd_write_locked(env, obj));
LASSERT(th != NULL);
+ if (unlikely(fid_is_acct(fid)))
+ /* Quota files can't be created from the kernel any more,
+ * 'tune2fs -O quota' will take care of creating them */
+ RETURN(-EPERM);
+
OSD_EXEC_OP(th, create);
result = __osd_object_create(info, obj, attr, hint, dof, th);
LASSERT(inode);
LASSERT(!lu_object_is_dying(dt->do_lu.lo_header));
+ if (unlikely(fid_is_acct(fid)))
+ RETURN(-EPERM);
+
+ /* Parallel control for OI scrub. For most of cases, there is no
+ * lock contention. So it will not affect unlink performance. */
+ cfs_mutex_lock(&inode->i_mutex);
if (S_ISDIR(inode->i_mode)) {
LASSERT(osd_inode_unlinked(inode) ||
inode->i_nlink == 1);
OSD_EXEC_OP(th, destroy);
result = osd_oi_delete(osd_oti_get(env), osd, fid, th);
+ cfs_mutex_unlock(&inode->i_mutex);
/* XXX: add to ext3 orphan list */
/* rc = ext3_orphan_add(handle_t *handle, struct inode *inode) */
LASSERT(dt_object_exists(dt));
LASSERT(inode->i_op != NULL && inode->i_op->setxattr != NULL);
- LASSERT(osd_write_locked(env, obj));
if (fl & LU_XATTR_REPLACE)
fs_flags |= XATTR_REPLACE;
}
/**
- * Helper function to form igif
- */
-static inline void osd_igif_get(const struct lu_env *env, struct inode *inode,
- struct lu_fid *fid)
-{
- LU_IGIF_BUILD(fid, inode->i_ino, inode->i_generation);
-}
-
-/**
* ldiskfs supports fid in dirent, it is passed in dentry->d_fsdata.
* lustre 1.8 also uses d_fsdata for passing other info to ldiskfs.
* To have compatilibility with 1.8 ldiskfs driver we need to have
* \retval 0 on success
*/
static int osd_ea_fid_get(const struct lu_env *env, struct osd_object *obj,
- __u32 ino, struct lu_fid *fid)
+ __u32 ino, struct lu_fid *fid,
+ struct osd_inode_id *id)
{
- struct osd_thread_info *info = osd_oti_get(env);
- struct lustre_mdt_attrs *mdt_attrs = &info->oti_mdt_attrs;
- struct lu_device *ldev = obj->oo_dt.do_lu.lo_dev;
- struct dentry *dentry = &info->oti_child_dentry;
- struct osd_inode_id *id = &info->oti_id;
- struct osd_device *dev;
- struct inode *inode;
- int rc;
+ struct osd_thread_info *info = osd_oti_get(env);
+ struct inode *inode;
+ ENTRY;
- ENTRY;
- dev = osd_dev(ldev);
-
- id->oii_ino = ino;
- id->oii_gen = OSD_OII_NOGEN;
-
- inode = osd_iget(info, dev, id);
- if (IS_ERR(inode)) {
- rc = PTR_ERR(inode);
- GOTO(out,rc);
- }
- dentry->d_inode = inode;
+ osd_id_gen(id, ino, OSD_OII_NOGEN);
+ inode = osd_iget_fid(info, osd_obj2dev(obj), id, fid);
+ if (IS_ERR(inode))
+ RETURN(PTR_ERR(inode));
- LASSERT(inode->i_op != NULL && inode->i_op->getxattr != NULL);
- rc = inode->i_op->getxattr(dentry, XATTR_NAME_LMA, (void *)mdt_attrs,
- sizeof *mdt_attrs);
-
- /* Check LMA compatibility */
- if (rc > 0 &&
- (mdt_attrs->lma_incompat & ~cpu_to_le32(LMA_INCOMPAT_SUPP))) {
- CWARN("Inode %lx: Unsupported incompat LMA feature(s) %#x\n",
- inode->i_ino, le32_to_cpu(mdt_attrs->lma_incompat) &
- ~LMA_INCOMPAT_SUPP);
- return -ENOSYS;
- }
-
- if (rc > 0) {
- lustre_lma_swab(mdt_attrs);
- memcpy(fid, &mdt_attrs->lma_self_fid, sizeof(*fid));
- rc = 0;
- } else if (rc == -ENODATA) {
- osd_igif_get(env, inode, fid);
- rc = 0;
- }
- iput(inode);
-out:
- RETURN(rc);
+ iput(inode);
+ RETURN(0);
}
/**
LASSERT(osd_write_locked(env, obj));
LASSERT(th != NULL);
+ if (unlikely(fid_is_acct(fid)))
+ /* Quota files can't be created from the kernel any more,
+ * 'tune2fs -O quota' will take care of creating them */
+ RETURN(-EPERM);
+
OSD_EXEC_OP(th, create);
result = __osd_object_create(info, obj, attr, hint, dof, th);
inode->i_nlink == 2)
inode->i_nlink = 1;
}
- LASSERT(inode->i_nlink < LDISKFS_LINK_MAX);
+ LASSERT(inode->i_nlink <= LDISKFS_LINK_MAX);
cfs_spin_unlock(&obj->oo_guard);
inode->i_sb->s_op->dirty_inode(inode);
LINVRNT(osd_invariant(obj));
static int osd_index_try(const struct lu_env *env, struct dt_object *dt,
const struct dt_index_features *feat)
{
- int result;
- int ea_dir = 0;
- struct osd_object *obj = osd_dt_obj(dt);
- struct osd_device *osd = osd_obj2dev(obj);
+ int result;
+ int skip_iam = 0;
+ struct osd_object *obj = osd_dt_obj(dt);
+ struct osd_device *osd = osd_obj2dev(obj);
LINVRNT(osd_invariant(obj));
LASSERT(dt_object_exists(dt));
result = 0;
else
result = -ENOTDIR;
- ea_dir = 1;
+ skip_iam = 1;
+ } else if (unlikely(feat == &dt_otable_features)) {
+ dt->do_index_ops = &osd_otable_ops;
+ return 0;
+ } else if (feat == &dt_acct_features) {
+ dt->do_index_ops = &osd_acct_index_ops;
+ result = 0;
+ skip_iam = 1;
} else if (!osd_has_index(obj)) {
struct osd_directory *dir;
result = 0;
}
- if (result == 0 && ea_dir == 0) {
+ if (result == 0 && skip_iam == 0) {
if (!osd_iam_index_probe(env, obj, feat))
result = -ENOTDIR;
}
return result;
}
+static int osd_otable_it_attr_get(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lu_attr *attr,
+ struct lustre_capa *capa)
+{
+ attr->la_valid = 0;
+ return 0;
+}
+
static const struct dt_object_operations osd_obj_ops = {
.do_read_lock = osd_object_read_lock,
.do_write_lock = osd_object_write_lock,
.do_data_get = osd_data_get,
};
+static const struct dt_object_operations osd_obj_otable_it_ops = {
+ .do_attr_get = osd_otable_it_attr_get,
+ .do_index_try = osd_index_try,
+};
+
static int osd_index_declare_iam_delete(const struct lu_env *env,
struct dt_object *dt,
const struct dt_key *key,
LASSERT(th != NULL);
if (osd_object_auth(env, dt, capa, CAPA_OPC_INDEX_INSERT))
- return -EACCES;
+ RETURN(-EACCES);
OSD_EXEC_OP(th, insert);
return rc;
}
+static int
+osd_consistency_check(struct osd_thread_info *oti, struct osd_device *dev,
+ struct osd_idmap_cache *oic)
+{
+ struct osd_scrub *scrub = &dev->od_scrub;
+ struct lu_fid *fid = &oic->oic_fid;
+ struct osd_inode_id *id = &oti->oti_id;
+ int once = 0;
+ int rc;
+ ENTRY;
+
+again:
+ rc = osd_oi_lookup(oti, dev, fid, id);
+ if (rc != 0 && rc != -ENOENT)
+ RETURN(rc);
+
+ if (rc == 0 && osd_id_eq(id, &oic->oic_lid))
+ RETURN(0);
+
+ if (thread_is_running(&scrub->os_thread)) {
+ rc = osd_oii_insert(dev, oic, rc == -ENOENT);
+ /* There is race condition between osd_oi_lookup and OI scrub.
+ * The OI scrub finished just after osd_oi_lookup() failure.
+ * Under such case, it is unnecessary to trigger OI scrub again,
+ * but try to call osd_oi_lookup() again. */
+ if (unlikely(rc == -EAGAIN))
+ goto again;
+
+ RETURN(rc);
+ }
+
+ if (!scrub->os_no_scrub && ++once == 1) {
+ CDEBUG(D_LFSCK, "Trigger OI scrub by RPC for "DFID"\n",
+ PFID(fid));
+ rc = osd_scrub_start(dev);
+ LCONSOLE_ERROR("%.16s: trigger OI scrub by RPC for "DFID
+ ", rc = %d [2]\n",
+ LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name,
+ PFID(fid), rc);
+ if (rc == 0)
+ goto again;
+ }
+
+ RETURN(rc = -EREMCHG);
+}
+
/**
* Calls ->lookup() to find dentry. From dentry get inode and
* read inode's ea to get fid. This is required for interoperability
bh = osd_ldiskfs_find_entry(dir, dentry, &de, hlock);
if (bh) {
- ino = le32_to_cpu(de->inode);
- rc = osd_get_fid_from_dentry(de, rec);
-
- /* done with de, release bh */
- brelse(bh);
- if (rc != 0)
- rc = osd_ea_fid_get(env, obj, ino, fid);
- } else {
- rc = -ENOENT;
- }
+ struct osd_thread_info *oti = osd_oti_get(env);
+ struct osd_idmap_cache *oic = &oti->oti_cache;
+ struct osd_device *dev = osd_obj2dev(obj);
+ struct osd_scrub *scrub = &dev->od_scrub;
+ struct scrub_file *sf = &scrub->os_file;
+
+ ino = le32_to_cpu(de->inode);
+ rc = osd_get_fid_from_dentry(de, rec);
+
+ /* done with de, release bh */
+ brelse(bh);
+ if (rc != 0)
+ rc = osd_ea_fid_get(env, obj, ino, fid, &oic->oic_lid);
+ else
+ osd_id_gen(&oic->oic_lid, ino, OSD_OII_NOGEN);
+
+ if (rc != 0 || !fid_is_norm(fid))
+ GOTO(out, rc);
+
+ oic->oic_fid = *fid;
+ if ((scrub->os_pos_current <= ino) &&
+ (sf->sf_flags & SF_INCONSISTENT ||
+ ldiskfs_test_bit(osd_oi_fid2idx(dev, fid),
+ sf->sf_oi_bitmap)))
+ rc = osd_consistency_check(oti, dev, oic);
+ } else {
+ rc = -ENOENT;
+ }
+
+ GOTO(out, rc);
- if (hlock != NULL)
- ldiskfs_htree_unlock(hlock);
- else
- cfs_up_read(&obj->oo_ext_idx_sem);
- RETURN (rc);
+out:
+ if (hlock != NULL)
+ ldiskfs_htree_unlock(hlock);
+ else
+ cfs_up_read(&obj->oo_ext_idx_sem);
+ return rc;
}
/**
else
LU_OBJECT_DEBUG(D_ERROR, env, luch,
"lu_object can't be located"
- ""DFID"\n", PFID(fid));
+ DFID"\n", PFID(fid));
if (child == NULL) {
lu_object_put(env, luch);
LU_OBJECT_DEBUG(D_ERROR, env, luch,
"lu_object does not exists "DFID"\n",
PFID(fid));
+ lu_object_put(env, luch);
child = ERR_PTR(-ENOENT);
}
} else
const struct dt_it *di,
struct dt_rec *dtrec, __u32 attr)
{
- struct osd_it_iam *it = (struct osd_it_iam *)di;
- struct osd_thread_info *info = osd_oti_get(env);
- struct lu_fid *fid = &info->oti_fid;
- const struct osd_fid_pack *rec;
- struct lu_dirent *lde = (struct lu_dirent *)dtrec;
- char *name;
- int namelen;
- __u64 hash;
- int rc;
+ struct osd_it_iam *it = (struct osd_it_iam *)di;
+ struct osd_thread_info *info = osd_oti_get(env);
+ ENTRY;
- name = (char *)iam_it_key_get(&it->oi_it);
- if (IS_ERR(name))
- RETURN(PTR_ERR(name));
+ if (S_ISDIR(it->oi_obj->oo_inode->i_mode)) {
+ const struct osd_fid_pack *rec;
+ struct lu_fid *fid = &info->oti_fid;
+ struct lu_dirent *lde = (struct lu_dirent *)dtrec;
+ char *name;
+ int namelen;
+ __u64 hash;
+ int rc;
- namelen = iam_it_key_size(&it->oi_it);
+ name = (char *)iam_it_key_get(&it->oi_it);
+ if (IS_ERR(name))
+ RETURN(PTR_ERR(name));
- rec = (const struct osd_fid_pack *) iam_it_rec_get(&it->oi_it);
- if (IS_ERR(rec))
- RETURN(PTR_ERR(rec));
+ namelen = iam_it_key_size(&it->oi_it);
- rc = osd_fid_unpack(fid, rec);
- if (rc)
- RETURN(rc);
+ rec = (const struct osd_fid_pack *)iam_it_rec_get(&it->oi_it);
+ if (IS_ERR(rec))
+ RETURN(PTR_ERR(rec));
- hash = iam_it_store(&it->oi_it);
+ rc = osd_fid_unpack(fid, rec);
+ if (rc)
+ RETURN(rc);
- /* IAM does not store object type in IAM index (dir) */
- osd_it_pack_dirent(lde, fid, hash, name, namelen,
- 0, LUDA_FID);
+ hash = iam_it_store(&it->oi_it);
- return 0;
+ /* IAM does not store object type in IAM index (dir) */
+ osd_it_pack_dirent(lde, fid, hash, name, namelen,
+ 0, LUDA_FID);
+ } else {
+ iam_reccpy(&it->oi_it.ii_path.ip_leaf,
+ (struct iam_rec *)dtrec);
+ }
+
+ RETURN(0);
}
/**
* \retval -ve on error
*/
static inline int osd_it_ea_rec(const struct lu_env *env,
- const struct dt_it *di,
- struct dt_rec *dtrec, __u32 attr)
-{
- struct osd_it_ea *it = (struct osd_it_ea *)di;
- struct osd_object *obj = it->oie_obj;
- struct lu_fid *fid = &it->oie_dirent->oied_fid;
- struct lu_dirent *lde = (struct lu_dirent *)dtrec;
- int rc = 0;
-
- ENTRY;
-
- if (!fid_is_sane(fid))
- rc = osd_ea_fid_get(env, obj, it->oie_dirent->oied_ino, fid);
-
- if (rc == 0)
- osd_it_pack_dirent(lde, fid, it->oie_dirent->oied_off,
- it->oie_dirent->oied_name,
- it->oie_dirent->oied_namelen,
- it->oie_dirent->oied_type,
- attr);
- RETURN(rc);
+ const struct dt_it *di,
+ struct dt_rec *dtrec, __u32 attr)
+{
+ struct osd_it_ea *it = (struct osd_it_ea *)di;
+ struct osd_object *obj = it->oie_obj;
+ struct osd_device *dev = osd_obj2dev(obj);
+ struct osd_scrub *scrub = &dev->od_scrub;
+ struct scrub_file *sf = &scrub->os_file;
+ struct osd_thread_info *oti = osd_oti_get(env);
+ struct osd_idmap_cache *oic = &oti->oti_cache;
+ struct lu_fid *fid = &it->oie_dirent->oied_fid;
+ struct lu_dirent *lde = (struct lu_dirent *)dtrec;
+ __u32 ino = it->oie_dirent->oied_ino;
+ int rc = 0;
+ ENTRY;
+
+ if (!fid_is_sane(fid)) {
+ rc = osd_ea_fid_get(env, obj, ino, fid, &oic->oic_lid);
+ if (rc != 0)
+ RETURN(rc);
+ } else {
+ osd_id_gen(&oic->oic_lid, ino, OSD_OII_NOGEN);
+ }
+
+ osd_it_pack_dirent(lde, fid, it->oie_dirent->oied_off,
+ it->oie_dirent->oied_name,
+ it->oie_dirent->oied_namelen,
+ it->oie_dirent->oied_type, attr);
+
+ if (!fid_is_norm(fid))
+ RETURN(0);
+
+ oic->oic_fid = *fid;
+ if ((scrub->os_pos_current <= ino) &&
+ (sf->sf_flags & SF_INCONSISTENT ||
+ ldiskfs_test_bit(osd_oi_fid2idx(dev, fid), sf->sf_oi_bitmap)))
+ rc = osd_consistency_check(oti, dev, oic);
+
+ RETURN(rc);
}
/**
static int osd_device_init(const struct lu_env *env, struct lu_device *d,
const char *name, struct lu_device *next)
{
- return osd_procfs_init(osd_dev(d), name);
+ struct osd_device *osd = osd_dev(d);
+
+ strncpy(osd->od_svname, name, MAX_OBD_NAME);
+ return osd_procfs_init(osd, name);
}
static int osd_shutdown(const struct lu_env *env, struct osd_device *o)
{
- struct osd_thread_info *info = osd_oti_get(env);
+ ENTRY;
- ENTRY;
+ osd_scrub_cleanup(env, o);
- if (o->od_oi_table != NULL)
- osd_oi_fini(info, o);
+ if (o->od_fsops) {
+ fsfilt_put_ops(o->od_fsops);
+ o->od_fsops = NULL;
+ }
- if (o->od_fsops) {
- fsfilt_put_ops(o->od_fsops);
- o->od_fsops = NULL;
- }
+ /* shutdown quota slave instance associated with the device */
+ if (o->od_quota_slave != NULL) {
+ qsd_fini(env, o->od_quota_slave);
+ o->od_quota_slave = NULL;
+ }
- RETURN(0);
+ RETURN(0);
}
static int osd_mount(const struct lu_env *env,
l->ld_ops = &osd_lu_ops;
o->od_dt_dev.dd_ops = &osd_dt_ops;
cfs_spin_lock_init(&o->od_osfs_lock);
+ cfs_mutex_init(&o->od_otable_mutex);
o->od_osfs_age = cfs_time_shift_64(-1000);
o->od_capa_hash = init_capa_hash();
if (o->od_capa_hash == NULL) {
err = osd_mount(env, o, cfg);
break;
case LCFG_CLEANUP:
+ lu_dev_del_linkage(d->ld_site, d);
err = osd_shutdown(env, o);
break;
default:
static int osd_prepare(const struct lu_env *env, struct lu_device *pdev,
struct lu_device *dev)
{
- struct osd_device *osd = osd_dev(dev);
- struct osd_thread_info *oti = osd_oti_get(env);
- int result;
+ struct osd_device *osd = osd_dev(dev);
+ int result;
+ ENTRY;
- ENTRY;
-
- /* 1. initialize oi before any file create or file open */
- result = osd_oi_init(oti, osd);
+ /* 1. setup scrub, including OI files initialization */
+ result = osd_scrub_setup(env, osd);
if (result < 0)
RETURN(result);
- if (!lu_device_is_md(pdev))
+ /* 2. setup quota slave instance */
+ osd->od_quota_slave = qsd_init(env, osd->od_svname, &osd->od_dt_dev,
+ osd->od_proc_entry);
+ if (IS_ERR(osd->od_quota_slave)) {
+ result = PTR_ERR(osd->od_quota_slave);
+ osd->od_quota_slave = NULL;
+ RETURN(result);
+ }
+
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2,3,50,0)
+ /* Unfortunately, the current MDD implementation relies on some specific
+ * code to be executed in the OSD layer. Since OFD now also uses the OSD
+ * module, we need a way to skip the metadata-specific code when running
+ * with OFD.
+ * The hack here is to check the type of the parent device which is
+ * either MD (i.e. MDD device) with the current MDT stack or DT (i.e.
+ * OFD device) on an OST. As a reminder, obdfilter does not use the OSD
+ * layer and still relies on lvfs. This hack won't work any more when
+ * LOD is landed since LOD is of DT type.
+ * This code should be removed once the orion MDT changes (LOD/OSP, ...)
+ * have been landed */
+ osd->od_is_md = lu_device_is_md(pdev);
+#else
+#warning "all is_md checks must be removed from osd-ldiskfs"
+#endif
+
+ if (!osd->od_is_md)
RETURN(0);
- /* 2. setup local objects */
+ /* 3. setup local objects */
result = llo_local_objects_setup(env, lu2md_dev(pdev), lu2dt_dev(dev));
RETURN(result);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff