*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/osd/osd_handler.c
*
return idc;
}
+static void osd_idc_dump_lma(const struct lu_env *env,
+ struct osd_device *osd,
+ unsigned long ino,
+ bool check_in_oi)
+{
+ struct osd_thread_info *info = osd_oti_get(env);
+ struct lustre_ost_attrs *loa = &info->oti_ost_attrs;
+ const struct lu_fid *fid;
+ struct osd_inode_id lid;
+ struct inode *inode;
+ int rc;
+
+ inode = osd_ldiskfs_iget(osd_sb(osd), ino);
+ if (IS_ERR(inode)) {
+ CERROR("%s: can't get inode %lu: rc = %d\n",
+ osd->od_svname, ino, (int)PTR_ERR(inode));
+ return;
+ }
+ if (is_bad_inode(inode)) {
+ CERROR("%s: bad inode %lu\n", osd->od_svname, ino);
+ goto put;
+ }
+ rc = osd_get_lma(info, inode, &info->oti_obj_dentry, loa);
+ if (rc) {
+ CERROR("%s: can't get LMA for %lu: rc = %d\n",
+ osd->od_svname, ino, rc);
+ goto put;
+ }
+ fid = &loa->loa_lma.lma_self_fid;
+ LCONSOLE(D_INFO, "%s: "DFID" in inode %lu/%u\n", osd->od_svname,
+ PFID(fid), ino, (unsigned)inode->i_generation);
+ if (!check_in_oi)
+ goto put;
+ rc = osd_oi_lookup(osd_oti_get(env), osd, fid, &lid, 0);
+ if (rc) {
+ CERROR("%s: can't lookup "DFID": rc = %d\n",
+ osd->od_svname, PFID(fid), rc);
+ goto put;
+ }
+ LCONSOLE(D_INFO, "%s: "DFID" maps to %u/%u\n", osd->od_svname,
+ PFID(fid), lid.oii_ino, lid.oii_gen);
+put:
+ iput(inode);
+}
+
+static void osd_idc_dump_debug(const struct lu_env *env,
+ struct osd_device *osd,
+ const struct lu_fid *fid,
+ unsigned long ino1,
+ unsigned long ino2)
+{
+ struct osd_inode_id lid;
+
+ int rc;
+
+ rc = osd_oi_lookup(osd_oti_get(env), osd, fid, &lid, 0);
+ if (!rc) {
+ LCONSOLE(D_INFO, "%s: "DFID" maps to %u/%u\n",
+ osd->od_svname, PFID(fid), lid.oii_ino, lid.oii_gen);
+ osd_idc_dump_lma(env, osd, lid.oii_ino, false);
+ } else {
+ CERROR("%s: can't lookup "DFID": rc = %d\n",
+ osd->od_svname, PFID(fid), rc);
+ }
+ if (ino1)
+ osd_idc_dump_lma(env, osd, ino1, true);
+ if (ino2)
+ osd_idc_dump_lma(env, osd, ino2, true);
+}
+
/*
* lookup mapping for given FID and fill it from the given object.
* the object is lolcal by definition.
if (obj->oo_inode == NULL)
return 0;
if (idc->oic_lid.oii_ino != obj->oo_inode->i_ino) {
- LASSERT(idc->oic_lid.oii_ino == 0);
+ if (idc->oic_lid.oii_ino) {
+ osd_idc_dump_debug(env, osd, fid,
+ idc->oic_lid.oii_ino,
+ obj->oo_inode->i_ino);
+ return -EINVAL;
+ }
idc->oic_lid.oii_ino = obj->oo_inode->i_ino;
idc->oic_lid.oii_gen = obj->oo_inode->i_generation;
}
lustre_loa_swab(loa, true);
/* Check LMA compatibility */
if (lma->lma_incompat & ~LMA_INCOMPAT_SUPP) {
- CWARN("%s: unsupported incompat LMA feature(s) %#x "
- "for fid = "DFID", ino = %lu\n",
+ rc = -EOPNOTSUPP;
+ CWARN("%s: unsupported incompat LMA feature(s) %#x for fid = "DFID", ino = %lu: rc = %d\n",
osd_ino2name(inode),
lma->lma_incompat & ~LMA_INCOMPAT_SUPP,
- PFID(&lma->lma_self_fid), inode->i_ino);
- rc = -EOPNOTSUPP;
+ PFID(&lma->lma_self_fid), inode->i_ino, rc);
}
} else if (rc == 0) {
rc = -ENODATA;
iput(inode);
inode = ERR_PTR(-ESTALE);
} else if (is_bad_inode(inode)) {
- CWARN("%s: bad inode: ino = %u\n",
- osd_dev2name(dev), id->oii_ino);
+ rc = -ENOENT;
+ CWARN("%s: bad inode: ino = %u: rc = %d\n",
+ osd_dev2name(dev), id->oii_ino, rc);
iput(inode);
- inode = ERR_PTR(-ENOENT);
+ inode = ERR_PTR(rc);
} else if ((rc = osd_attach_jinode(inode))) {
iput(inode);
inode = ERR_PTR(rc);
if (!rc2) {
fid = &loa->loa_lma.lma_self_fid;
} else if (rc2 == -ENODATA) {
- if (unlikely(parent == inode->i_sb->s_root->d_inode)) {
+ if (unlikely(is_root_inode(parent))) {
fid = &info->oti_fid3;
lu_local_obj_fid(fid, OSD_FS_ROOT_OID);
} else if (!osd->od_is_ost && osd->od_index == 0) {
if (!rc) {
*fid = loa->loa_lma.lma_self_fid;
} else if (rc == -ENODATA) {
- if (unlikely(inode == osd_sb(dev)->s_root->d_inode))
+ if (unlikely(is_root_inode(inode)))
lu_local_obj_fid(fid, OSD_FS_ROOT_OID);
else
lu_igif_build(fid, inode->i_ino, inode->i_generation);
struct dir_context ctx;
struct osd_thread_info *oclb_info;
struct osd_device *oclb_dev;
- struct osd_idmap_cache *oclb_oic;
int oclb_items;
bool oclb_found;
};
struct lu_fid *fid = &oti->oti_fid3;
struct osd_inode_id *id = &oti->oti_id3;
struct osd_device *dev = oclb->oclb_dev;
- struct osd_idmap_cache *oic = oclb->oclb_oic;
struct inode *inode;
oclb->oclb_items++;
iput(inode);
osd_add_oi_cache(oti, dev, id, fid);
- oic->oic_fid = *fid;
- oic->oic_lid = *id;
- oic->oic_dev = dev;
- osd_oii_insert(dev, oic, true);
+ osd_oii_insert(dev, fid, id, true);
oclb->oclb_found = true;
return 1;
* the correct OI mapping for the slave MDT-object.
*/
static int osd_check_lmv(struct osd_thread_info *oti, struct osd_device *dev,
- struct inode *inode, struct osd_idmap_cache *oic)
+ struct inode *inode)
{
struct lu_buf *buf = &oti->oti_big_buf;
struct dentry *dentry = &oti->oti_obj_dentry;
.ctx.actor = osd_stripe_dir_filldir,
.oclb_info = oti,
.oclb_dev = dev,
- .oclb_oic = oic,
.oclb_found = false,
};
int rc = 0;
out:
if (rc < 0)
- CDEBUG(D_LFSCK, "%s: fail to check LMV EA, inode = %lu/%u,"
- DFID": rc = %d\n", osd_ino2name(inode),
- inode->i_ino, inode->i_generation,
- PFID(&oic->oic_fid), rc);
+ CDEBUG(D_LFSCK,
+ "%s: cannot check LMV, ino = %lu/%u: rc = %d\n",
+ osd_ino2name(inode), inode->i_ino, inode->i_generation,
+ rc);
else
rc = 0;
LINVRNT(osd_invariant(obj));
LASSERT(obj->oo_inode == NULL);
- LASSERTF(fid_is_sane(fid) || fid_is_idif(fid), DFID"\n", PFID(fid));
+
+ if (fid_is_sane(fid) == 0) {
+ CERROR("%s: invalid FID "DFID"\n", ldev->ld_obd->obd_name,
+ PFID(fid));
+ dump_stack();
+ RETURN(-EINVAL);
+ }
dev = osd_dev(ldev);
scrub = &dev->od_scrub.os_scrub;
if (scrub->os_partial_scan && !scrub->os_in_join)
goto join;
- osd_add_oi_cache(info, dev, id, fid);
if (IS_ERR_OR_NULL(inode) || result) {
- osd_oii_insert(dev, oic, result == -ENOENT);
+ osd_oii_insert(dev, fid, id, result == -ENOENT);
GOTO(out, result = -EINPROGRESS);
}
LASSERT(remote);
LASSERT(obj->oo_inode == inode);
- osd_oii_insert(dev, oic, true);
+ osd_oii_insert(dev, fid, id, true);
goto found;
}
join:
rc1 = osd_scrub_start(env, dev, flags);
- LCONSOLE_WARN("%s: trigger OI scrub by RPC for the " DFID" with flags "
- "0x%x, rc = %d\n", osd_name(dev), PFID(fid), flags, rc1);
+ CDEBUG_LIMIT(D_LFSCK | D_CONSOLE | D_WARNING,
+ "%s: trigger OI scrub by RPC for "DFID"/%u with flags %#x: rc = %d\n",
+ osd_name(dev), PFID(fid), id->oii_ino, flags, rc1);
if (rc1 && rc1 != -EALREADY)
GOTO(out, result = -EREMCHG);
- osd_add_oi_cache(info, dev, id, fid);
if (IS_ERR_OR_NULL(inode) || result) {
- osd_oii_insert(dev, oic, result == -ENOENT);
+ osd_oii_insert(dev, fid, id, result == -ENOENT);
GOTO(out, result = -EINPROGRESS);
}
LASSERT(remote);
LASSERT(obj->oo_inode == inode);
- osd_oii_insert(dev, oic, true);
+ osd_oii_insert(dev, fid, id, true);
goto found;
check_lma:
if (saved_ino == id->oii_ino && saved_gen == id->oii_gen) {
result = -EREMCHG;
+ osd_scrub_refresh_mapping(info, dev, fid, id, DTO_INDEX_DELETE,
+ true, 0, NULL);
goto trigger;
}
if (S_ISDIR(inode->i_mode) &&
(flags & SS_AUTO_PARTIAL || sf->sf_status == SS_SCANNING))
- osd_check_lmv(info, dev, inode, oic);
+ osd_check_lmv(info, dev, inode);
result = osd_attach_jinode(inode);
if (result)
struct osd_thandle *oh = container_of(jcb, struct osd_thandle, ot_jcb);
struct thandle *th = &oh->ot_super;
struct lu_device *lud = &th->th_dev->dd_lu_dev;
+ struct osd_device *osd = osd_dev(lud);
struct dt_txn_commit_cb *dcb, *tmp;
LASSERT(oh->ot_handle == NULL);
}
lu_ref_del_at(&lud->ld_reference, &oh->ot_dev_link, "osd-tx", th);
- lu_device_put(lud);
+ if (atomic_dec_and_test(&osd->od_commit_cb_in_flight))
+ wake_up(&osd->od_commit_cb_done);
th->th_dev = NULL;
OBD_FREE_PTR(oh);
th->th_dev = d;
th->th_result = 0;
oh->ot_credits = 0;
+ oh->oh_declared_ext = 0;
INIT_LIST_HEAD(&oh->ot_commit_dcb_list);
INIT_LIST_HEAD(&oh->ot_stop_dcb_list);
INIT_LIST_HEAD(&oh->ot_trunc_locks);
oh->ot_handle = jh;
LASSERT(oti->oti_txns == 0);
- lu_device_get(&d->dd_lu_dev);
+ atomic_inc(&dev->od_commit_cb_in_flight);
lu_ref_add_at(&d->dd_lu_dev.ld_reference, &oh->ot_dev_link,
"osd-tx", th);
oti->oti_txns++;
if (!rc)
rc = rc2;
- osd_process_truncates(&truncates);
+ osd_process_truncates(env, &truncates);
} else {
osd_trans_stop_cb(oh, th->th_result);
OBD_FREE_PTR(oh);
if (unlikely(remove_agents != 0))
osd_process_scheduled_agent_removals(env, osd);
+ LASSERT(oti->oti_ins_cache_depth > 0);
oti->oti_ins_cache_depth--;
/* reset OI cache for safety */
if (oti->oti_ins_cache_depth == 0)
OBD_CKSUM_T10IP512 :
OBD_CKSUM_T10IP4K;
} else {
- CERROR("%s: unsupported checksum type of "
- "T10PI type '%s'",
+ CERROR("%s: unsupported checksum type of T10PI type '%s'\n",
d->od_svname, name);
}
} else {
- CERROR("%s: unsupported T10PI type '%s'",
+ CERROR("%s: unsupported T10PI type '%s'\n",
d->od_svname, name);
}
}
bool ignore_edquot = !(attr->la_flags & LUSTRE_SET_SYNC_FL);
if (!ignore_edquot)
- CDEBUG(D_QUOTA, "%s: enforce quota on UID %u, GID %u"
- "(the quota space is %lld)\n",
- obj->oo_inode->i_sb->s_id, attr->la_uid,
+ CDEBUG(D_QUOTA,
+ "%s: enforce quota on UID %u, GID %u (quota space is %lld)\n",
+ osd_ino2name(obj->oo_inode), attr->la_uid,
attr->la_gid, bspace);
/* USERQUOTA */
rc = dquot_transfer(inode, &iattr);
if (rc) {
- CERROR("%s: quota transfer failed: rc = %d. Is quota "
- "enforcement enabled on the ldiskfs "
- "filesystem?\n", inode->i_sb->s_id, rc);
+ CERROR("%s: quota transfer failed. Is quota enforcement enabled on the ldiskfs filesystem? rc = %d\n",
+ osd_ino2name(inode), rc);
return rc;
}
}
rc = -ENOTSUPP;
#endif
if (rc) {
- CERROR("%s: quota transfer failed: rc = %d. Is project "
- "enforcement enabled on the ldiskfs "
- "filesystem?\n", inode->i_sb->s_id, rc);
+ CERROR("%s: quota transfer failed. Is project enforcement enabled on the ldiskfs filesystem? rc = %d\n",
+ osd_ino2name(inode), rc);
return rc;
}
}
struct osd_thandle *oth;
struct dt_object *parent = NULL;
struct inode *inode;
- uid_t owner[2] = {0, 0};
+ struct iattr iattr = {
+ .ia_valid = ATTR_UID | ATTR_GID |
+ ATTR_CTIME | ATTR_MTIME | ATTR_ATIME,
+ .ia_ctime.tv_sec = attr->la_ctime,
+ .ia_mtime.tv_sec = attr->la_mtime,
+ .ia_atime.tv_sec = attr->la_atime,
+ .ia_uid = GLOBAL_ROOT_UID,
+ .ia_gid = GLOBAL_ROOT_GID,
+ };
+ const struct osd_timespec omit = { .tv_nsec = UTIME_OMIT };
if (attr->la_valid & LA_UID)
- owner[0] = attr->la_uid;
+ iattr.ia_uid = make_kuid(&init_user_ns, attr->la_uid);
if (attr->la_valid & LA_GID)
- owner[1] = attr->la_gid;
+ iattr.ia_gid = make_kgid(&init_user_ns, attr->la_gid);
LINVRNT(osd_invariant(obj));
LASSERT(obj->oo_inode == NULL);
!dt_object_remote(hint->dah_parent))
parent = hint->dah_parent;
+ /* if a time component is not valid set it to UTIME_OMIT */
+ if (!(attr->la_valid & LA_CTIME))
+ iattr.ia_ctime = omit;
+ if (!(attr->la_valid & LA_MTIME))
+ iattr.ia_mtime = omit;
+ if (!(attr->la_valid & LA_ATIME))
+ iattr.ia_atime = omit;
+
inode = ldiskfs_create_inode(oth->ot_handle,
parent ? osd_dt_obj(parent)->oo_inode :
osd_sb(osd)->s_root->d_inode,
- mode, owner);
+ mode, &iattr);
if (!IS_ERR(inode)) {
/* Do not update file c/mtime in ldiskfs. */
inode->i_flags |= S_NOCMTIME;
return result;
}
-
static void osd_ah_init(const struct lu_env *env, struct dt_allocation_hint *ah,
struct dt_object *parent, struct dt_object *child,
umode_t child_mode)
LASSERT(obj->oo_inode != NULL);
+ if (CFS_FAIL_CHECK(OBD_FAIL_OSD_OI_ENOSPC))
+ return -ENOSPC;
+
oh = container_of(th, struct osd_thandle, ot_super);
LASSERT(oh->ot_handle);
osd_trans_exec_op(env, th, OSD_OT_INSERT);
struct thandle *handle)
{
struct osd_thandle *oh;
+ struct super_block *sb = osd_sb(osd_dev(dt->do_lu.lo_dev));
+ int credits;
int rc;
ENTRY;
* vs. osd_mkreg: osd_mk_index will create 2 blocks for root_node and
* leaf_node, could involves the block, block bitmap, groups, GDT
* change for each block, so add 4 * 2 credits in that case.
+ *
+ * The default ACL initialization may consume an additional 16 blocks
*/
- osd_trans_declare_op(env, oh, OSD_OT_CREATE,
- osd_dto_credits_noquota[DTO_OBJECT_CREATE] +
- (dof->dof_type == DFT_INDEX) ? 4 * 2 : 0);
+ credits = osd_dto_credits_noquota[DTO_OBJECT_CREATE] +
+ ((dof->dof_type == DFT_INDEX) ? 4 * 2 : 0);
+
+ /**
+ * While ldiskfs_new_inode() calls ldiskfs_init_acl() we have to add
+ * credits for possible default ACL creation in new inode
+ */
+ if (hint && hint->dah_acl_len)
+ credits += osd_calc_bkmap_credits(sb, NULL, 0, -1,
+ (hint->dah_acl_len + sb->s_blocksize - 1) >>
+ sb->s_blocksize_bits);
+
+ osd_trans_declare_op(env, oh, OSD_OT_CREATE, credits);
+
/*
* Reuse idle OI block may cause additional one OI block
* to be changed.
__u32 saved_nlink = dir->i_nlink;
int rc;
+ if (OBD_FAIL_CHECK(OBD_FAIL_OSD_DOTDOT_ENOSPC))
+ return -ENOSPC;
+
dot_dot_ldp = (struct ldiskfs_dentry_param *)info->oti_ldp2;
osd_get_ldiskfs_dirent_param(dot_dot_ldp, dot_dot_fid);
struct osd_thread_info *info = osd_oti_get(env);
struct inode *local;
struct osd_thandle *oh;
- uid_t own[2] = {0, 0};
+ struct iattr iattr = {
+ .ia_valid = ATTR_UID | ATTR_GID |
+ ATTR_CTIME | ATTR_MTIME | ATTR_ATIME,
+ .ia_ctime.tv_nsec = UTIME_OMIT,
+ .ia_mtime.tv_nsec = UTIME_OMIT,
+ .ia_atime.tv_nsec = UTIME_OMIT,
+ .ia_uid = GLOBAL_ROOT_UID,
+ .ia_gid = GLOBAL_ROOT_GID,
+ };
int rc;
ENTRY;
oh = container_of(th, struct osd_thandle, ot_super);
LASSERT(oh->ot_handle->h_transaction != NULL);
- local = ldiskfs_create_inode(oh->ot_handle, pobj->oo_inode, type, own);
+ local = ldiskfs_create_inode(oh->ot_handle, pobj->oo_inode,
+ type, &iattr);
if (IS_ERR(local)) {
CERROR("%s: create local error %d\n", osd_name(osd),
(int)PTR_ERR(local));
*/
if (S_ISLNK(type)) {
BUILD_BUG_ON(LDISKFS_N_BLOCKS * 4 < FID_LEN + 1);
- rc = snprintf((char *)LDISKFS_I(local)->i_data,
- LDISKFS_N_BLOCKS * 4, DFID, PFID(fid));
+ rc = scnprintf((char *)LDISKFS_I(local)->i_data,
+ LDISKFS_N_BLOCKS * 4, DFID, PFID(fid));
i_size_write(local, rc);
LDISKFS_I(local)->i_disksize = rc;
i_projid_read(pobj->oo_inode) != 0) {
rc = osd_transfer_project(local, 0, th);
if (rc) {
- CERROR("%s: quota transfer failed: rc = %d. Is project "
- "quota enforcement enabled on the ldiskfs "
- "filesystem?\n", local->i_sb->s_id, rc);
+ CERROR("%s: quota transfer failed:. Is project quota enforcement enabled on the ldiskfs filesystem? rc = %d\n",
+ osd_ino2name(local), rc);
RETURN(ERR_PTR(rc));
}
}
obj->oo_dt.do_body_ops = &osd_body_ops;
}
- if (!result && !CFS_FAIL_CHECK(OBD_FAIL_OSD_NO_OI_ENTRY))
+ if (!result && !CFS_FAIL_CHECK(OBD_FAIL_OSD_NO_OI_ENTRY)) {
+ struct inode *inode = obj->oo_inode;
+
result = __osd_oi_insert(env, obj, fid, th);
+ if (result && inode) {
+ spin_lock(&obj->oo_guard);
+ clear_nlink(inode);
+ spin_unlock(&obj->oo_guard);
+ osd_dirty_inode(inode, I_DIRTY_DATASYNC);
+ ldiskfs_set_inode_state(inode,
+ LDISKFS_STATE_LUSTRE_DESTROY);
+ iput(inode);
+ obj->oo_inode = NULL;
+ }
+ }
/*
* a small optimization - dt_insert() isn't usually applied
struct thandle *handle)
{
struct osd_thandle *oh;
+ int rc;
/* it's possible that object doesn't exist yet */
LASSERT(handle != NULL);
osd_trans_declare_op(env, oh, OSD_OT_REF_ADD,
osd_dto_credits_noquota[DTO_ATTR_SET_BASE]);
- osd_idc_find_and_init(env, osd_dev(dt->do_lu.lo_dev), osd_dt_obj(dt));
+ rc = osd_idc_find_and_init(env, osd_dev(dt->do_lu.lo_dev),
+ osd_dt_obj(dt));
- return 0;
+ return rc;
}
/*
dquot_initialize(inode);
rc = ll_vfs_removexattr(dentry, inode, XATTR_NAME_FID);
if (rc == -ENODATA) {
- if ((fl & LU_XATTR_REPLACE) && !(fl & LU_XATTR_CREATE))
- RETURN(rc);
+ /* XATTR_NAME_FID is already absent */
+ rc = 0;
} else if (rc) {
RETURN(rc);
}
return 0;
}
+static bool osd_check_stale(struct dt_object *dt)
+{
+ return false;
+}
/*
* Index operations.
*/
.do_xattr_list = osd_xattr_list,
.do_object_sync = osd_object_sync,
.do_invalidate = osd_invalidate,
+ .do_check_stale = osd_check_stale,
};
static const struct dt_object_operations osd_obj_otable_it_ops = {
LASSERT(pobj->oo_inode);
ldp = (struct ldiskfs_dentry_param *)info->oti_ldp;
- if (unlikely(pobj->oo_inode ==
- osd_sb(osd_obj2dev(pobj))->s_root->d_inode))
+ if (unlikely(osd_object_is_root(pobj)))
ldp->edp_magic = 0;
else
osd_get_ldiskfs_dirent_param(ldp, fid);
static int
osd_consistency_check(struct osd_thread_info *oti, struct osd_device *dev,
- struct osd_idmap_cache *oic)
+ const struct lu_fid *fid, struct osd_inode_id *id)
{
struct lustre_scrub *scrub = &dev->od_scrub.os_scrub;
- struct lu_fid *fid = &oic->oic_fid;
- struct osd_inode_id *id = &oic->oic_lid;
struct inode *inode = NULL;
int once = 0;
bool insert;
}
}
- rc = osd_oii_insert(dev, oic, insert);
+ rc = osd_oii_insert(dev, fid, id, insert);
/*
* There is race condition between osd_oi_lookup and OI scrub.
* The OI scrub finished just after osd_oi_lookup() failure.
if (!S_ISDIR(inode->i_mode))
rc = 0;
else
- rc = osd_check_lmv(oti, dev, inode, oic);
+ rc = osd_check_lmv(oti, dev, inode);
GOTO(out, rc);
}
if (dev->od_auto_scrub_interval != AS_NEVER && ++once == 1) {
rc = osd_scrub_start(oti->oti_env, dev, SS_AUTO_PARTIAL |
SS_CLEAR_DRYRUN | SS_CLEAR_FAILOUT);
- CDEBUG(D_LFSCK | D_CONSOLE | D_WARNING,
- "%s: trigger partial OI scrub for RPC inconsistency "
- "checking FID "DFID": rc = %d\n",
- osd_dev2name(dev), PFID(fid), rc);
+ CDEBUG_LIMIT(D_LFSCK | D_CONSOLE | D_WARNING,
+ "%s: trigger partial OI scrub for RPC inconsistency, checking FID "DFID"/%u: rc = %d\n",
+ osd_dev2name(dev), PFID(fid), id->oii_ino, rc);
if (rc == 0 || rc == -EALREADY)
goto again;
}
GOTO(out, rc);
out:
- if (inode)
- iput(inode);
+ iput(inode);
RETURN(rc);
}
static int osd_fail_fid_lookup(struct osd_thread_info *oti,
struct osd_device *dev,
- struct osd_idmap_cache *oic,
struct lu_fid *fid, __u32 ino)
{
struct lustre_ost_attrs *loa = &oti->oti_ost_attrs;
+ struct osd_idmap_cache *oic = &oti->oti_cache;
struct inode *inode;
int rc;
if (!IS_ERR(bh)) {
struct osd_thread_info *oti = osd_oti_get(env);
struct osd_inode_id *id = &oti->oti_id;
- struct osd_idmap_cache *oic = &oti->oti_cache;
struct osd_device *dev = osd_obj2dev(obj);
ino = le32_to_cpu(de->inode);
if (OBD_FAIL_CHECK(OBD_FAIL_FID_LOOKUP)) {
brelse(bh);
- rc = osd_fail_fid_lookup(oti, dev, oic, fid, ino);
+ rc = osd_fail_fid_lookup(oti, dev, fid, ino);
GOTO(out, rc);
}
osd_id_gen(id, ino, OSD_OII_NOGEN);
}
- if (rc != 0 || osd_remote_fid(env, dev, fid)) {
- fid_zero(&oic->oic_fid);
-
+ if (rc != 0 || osd_remote_fid(env, dev, fid))
GOTO(out, rc);
- }
- osd_add_oi_cache(osd_oti_get(env), osd_obj2dev(obj), id, fid);
- rc = osd_consistency_check(oti, dev, oic);
- if (rc == -ENOENT)
- fid_zero(&oic->oic_fid);
- else
+ rc = osd_consistency_check(oti, dev, fid, id);
+ if (rc != -ENOENT) {
/* Other error should not affect lookup result. */
rc = 0;
+
+ /* Normal file mapping should be added into OI cache
+ * after FID in LMA check, but for local files like
+ * hsm_actions, their FIDs are not stored in OI files,
+ * see osd_initial_OI_scrub(), and here is the only
+ * place to load mapping into OI cache.
+ */
+ if (!fid_is_namespace_visible(fid))
+ osd_add_oi_cache(osd_oti_get(env),
+ osd_obj2dev(obj), id, fid);
+ }
} else {
rc = PTR_ERR(bh);
}
}
};
-
-/**
- * Creates or initializes iterator context.
- *
- * \retval struct osd_it_ea, iterator structure on success
- *
- */
-static struct dt_it *osd_it_ea_init(const struct lu_env *env,
- struct dt_object *dt,
- __u32 attr)
+struct osd_it_ea *osd_it_dir_init(const struct lu_env *env,
+ struct inode *inode, __u32 attr)
{
- struct osd_object *obj = osd_dt_obj(dt);
struct osd_thread_info *info = osd_oti_get(env);
struct osd_it_ea *oie;
struct file *file;
- struct lu_object *lo = &dt->do_lu;
struct dentry *obj_dentry;
ENTRY;
- if (!dt_object_exists(dt) || obj->oo_destroyed)
- RETURN(ERR_PTR(-ENOENT));
-
OBD_SLAB_ALLOC_PTR_GFP(oie, osd_itea_cachep, GFP_NOFS);
if (oie == NULL)
RETURN(ERR_PTR(-ENOMEM));
obj_dentry = &oie->oie_dentry;
- obj_dentry->d_inode = obj->oo_inode;
- obj_dentry->d_sb = osd_sb(osd_obj2dev(obj));
+ obj_dentry->d_inode = inode;
+ obj_dentry->d_sb = inode->i_sb;
obj_dentry->d_name.hash = 0;
oie->oie_rd_dirent = 0;
if (oie->oie_buf == NULL)
RETURN(ERR_PTR(-ENOMEM));
}
- oie->oie_obj = obj;
+ oie->oie_obj = NULL;
file = &oie->oie_file;
else
file->f_mode = FMODE_32BITHASH;
file->f_path.dentry = obj_dentry;
- file->f_mapping = obj->oo_inode->i_mapping;
- file->f_op = obj->oo_inode->i_fop;
- file->f_inode = obj->oo_inode;
+ file->f_mapping = inode->i_mapping;
+ file->f_op = inode->i_fop;
+ file->f_inode = inode;
+
+ RETURN(oie);
+}
+/**
+ * Creates or initializes iterator context.
+ *
+ * \retval struct osd_it_ea, iterator structure on success
+ *
+ */
+static struct dt_it *osd_it_ea_init(const struct lu_env *env,
+ struct dt_object *dt,
+ __u32 attr)
+{
+ struct osd_object *obj = osd_dt_obj(dt);
+ struct lu_object *lo = &dt->do_lu;
+ struct osd_it_ea *oie;
+
+ ENTRY;
+
+ if (!dt_object_exists(dt) || obj->oo_destroyed)
+ RETURN(ERR_PTR(-ENOENT));
+
+ oie = osd_it_dir_init(env, obj->oo_inode, attr);
+ if (IS_ERR(oie))
+ RETURN((struct dt_it *)oie);
+
+ oie->oie_obj = obj;
lu_object_get(lo);
RETURN((struct dt_it *)oie);
}
+void osd_it_dir_fini(const struct lu_env *env, struct osd_it_ea *oie,
+ struct inode *inode)
+{
+ struct osd_thread_info *info = osd_oti_get(env);
+
+ ENTRY;
+ oie->oie_file.f_op->release(inode, &oie->oie_file);
+ if (unlikely(oie->oie_buf != info->oti_it_ea_buf))
+ OBD_FREE(oie->oie_buf, OSD_IT_EA_BUFSIZE);
+ else
+ info->oti_it_ea_buf_used = 0;
+ OBD_SLAB_FREE_PTR(oie, osd_itea_cachep);
+ EXIT;
+}
+
/**
* Destroy or finishes iterator context.
*
*/
static void osd_it_ea_fini(const struct lu_env *env, struct dt_it *di)
{
- struct osd_thread_info *info = osd_oti_get(env);
struct osd_it_ea *oie = (struct osd_it_ea *)di;
struct osd_object *obj = oie->oie_obj;
struct inode *inode = obj->oo_inode;
ENTRY;
- oie->oie_file.f_op->release(inode, &oie->oie_file);
+ osd_it_dir_fini(env, (struct osd_it_ea *)di, inode);
osd_object_put(env, obj);
- if (unlikely(oie->oie_buf != info->oti_it_ea_buf))
- OBD_FREE(oie->oie_buf, OSD_IT_EA_BUFSIZE);
- else
- info->oti_it_ea_buf_used = 0;
- OBD_SLAB_FREE_PTR(oie, osd_itea_cachep);
EXIT;
}
/* "." is just the object itself. */
if (namelen == 1 && name[0] == '.') {
- *fid = obj->oo_dt.do_lu.lo_header->loh_fid;
+ if (obj != NULL)
+ *fid = obj->oo_dt.do_lu.lo_header->loh_fid;
} else if (d_type & LDISKFS_DIRENT_LUFID) {
rec = (struct osd_fid_pack *)(name + namelen + 1);
if (osd_fid_unpack(fid, rec) != 0)
d_type &= ~LDISKFS_DIRENT_LUFID;
/* NOT export local root. */
- if (unlikely(osd_sb(osd_obj2dev(obj))->s_root->d_inode->i_ino == ino)) {
+ if (obj != NULL &&
+ unlikely(osd_sb(osd_obj2dev(obj))->s_root->d_inode->i_ino == ino)) {
ino = obj->oo_inode->i_ino;
*fid = obj->oo_dt.do_lu.lo_header->loh_fid;
}
* \retval -ve on error
* \retval +1 reach the end of entry
*/
-static int osd_ldiskfs_it_fill(const struct lu_env *env,
- const struct dt_it *di)
+int osd_ldiskfs_it_fill(const struct lu_env *env, const struct dt_it *di)
{
struct osd_it_ea *it = (struct osd_it_ea *)di;
struct osd_object *obj = it->oie_obj;
- struct inode *inode = obj->oo_inode;
struct htree_lock *hlock = NULL;
struct file *filp = &it->oie_file;
int rc = 0;
it->oie_dirent = it->oie_buf;
it->oie_rd_dirent = 0;
- if (obj->oo_hl_head != NULL) {
- hlock = osd_oti_get(env)->oti_hlock;
- ldiskfs_htree_lock(hlock, obj->oo_hl_head,
- inode, LDISKFS_HLOCK_READDIR);
- } else {
- down_read(&obj->oo_ext_idx_sem);
+ if (obj) {
+ if (obj->oo_hl_head != NULL) {
+ hlock = osd_oti_get(env)->oti_hlock;
+ ldiskfs_htree_lock(hlock, obj->oo_hl_head,
+ obj->oo_inode,
+ LDISKFS_HLOCK_READDIR);
+ } else {
+ down_read(&obj->oo_ext_idx_sem);
+ }
}
filp->f_cred = current_cred();
rc = osd_security_file_alloc(filp);
if (rc)
- RETURN(rc);
+ GOTO(unlock, rc);
filp->f_flags |= O_NOATIME;
filp->f_mode |= FMODE_NONOTIFY;
rc = iterate_dir(filp, &buf.ctx);
if (rc)
- RETURN(rc);
-
- if (hlock != NULL)
- ldiskfs_htree_unlock(hlock);
- else
- up_read(&obj->oo_ext_idx_sem);
+ GOTO(unlock, rc);
if (it->oie_rd_dirent == 0) {
/*
it->oie_dirent = it->oie_buf;
it->oie_it_dirent = 1;
}
+unlock:
+ if (obj) {
+ if (hlock != NULL)
+ ldiskfs_htree_unlock(hlock);
+ else
+ up_read(&obj->oo_ext_idx_sem);
+ }
RETURN(rc);
}
* That means we lose it!
*/
if (rc != 0)
- CDEBUG(D_LFSCK, "%s: fail to reinsert the dirent, "
- "dir = %lu/%u, name = %.*s, "DFID": rc = %d\n",
- osd_ino2name(inode),
- dir->i_ino, dir->i_generation, namelen,
- dentry->d_name.name, PFID(fid), rc);
+ CDEBUG(D_LFSCK,
+ "%s: fail to reinsert the dirent, dir = %lu/%u, name = %.*s, "DFID": rc = %d\n",
+ osd_ino2name(inode), dir->i_ino, dir->i_generation,
+ namelen, dentry->d_name.name, PFID(fid), rc);
RETURN(rc);
}
if (o->od_mnt != NULL) {
shrink_dcache_sb(osd_sb(o));
osd_sync(env, &o->od_dt_dev);
+ wait_event(o->od_commit_cb_done,
+ !atomic_read(&o->od_commit_cb_in_flight));
mntput(o->od_mnt);
o->od_mnt = NULL;
const char *name = lustre_cfg_string(cfg, 0);
const char *dev = lustre_cfg_string(cfg, 1);
const char *opts;
- unsigned long page, s_flags, lmd_flags = 0;
+ unsigned long page, s_flags = 0, lmd_flags = 0;
struct page *__page;
struct file_system_type *type;
char *options = NULL;
- char *str;
+ const char *str;
struct osd_thread_info *info = osd_oti_get(env);
struct lu_fid *fid = &info->oti_fid;
struct inode *inode;
RETURN(-E2BIG);
strcpy(o->od_mntdev, dev);
- str = lustre_cfg_string(cfg, 2);
- s_flags = simple_strtoul(str, NULL, 0);
- str = strstr(str, ":");
- if (str)
- lmd_flags = simple_strtoul(str + 1, NULL, 0);
+ str = lustre_cfg_buf(cfg, 2);
+ sscanf(str, "%lu:%lu", &s_flags, &lmd_flags);
+
opts = lustre_cfg_string(cfg, 3);
#ifdef __BIG_ENDIAN
if (opts == NULL || strstr(opts, "bigendian_extents") == NULL) {
"force_over_256tb",
"force_over_512tb",
"force_over_1024tb",
+ "resetoi",
NULL
};
strncat(options, opts, PAGE_SIZE);
}
if (lmd_flags & LMD_FLG_DEV_RDONLY) {
- LCONSOLE_WARN("%s: not support dev_rdonly on this device",
+ LCONSOLE_WARN("%s: not support dev_rdonly on this device\n",
name);
GOTO(out_mnt, rc = -EOPNOTSUPP);
osd_procfs_fini(o);
if (o->od_oi_table != NULL)
osd_oi_fini(osd_oti_get(env), o);
+ if (o->od_extent_bytes_percpu)
+ free_percpu(o->od_extent_bytes_percpu);
osd_obj_map_fini(o);
osd_umount(env, o);
{
struct lu_device *l = osd2lu_dev(o);
struct osd_thread_info *info;
- int rc;
int cplen = 0;
+ char *opts = NULL;
+ bool restored = false;
+ int rc;
/* if the module was re-loaded, env can loose its keys */
rc = lu_env_refill((struct lu_env *)env);
spin_lock_init(&o->od_lock);
o->od_index_backup_policy = LIBP_NONE;
o->od_t10_type = 0;
+ init_waitqueue_head(&o->od_commit_cb_done);
o->od_read_cache = 1;
o->od_writethrough_cache = 1;
o->od_readcache_max_iosize = OSD_READCACHE_MAX_IO_MB << 20;
o->od_writethrough_max_iosize = OSD_WRITECACHE_MAX_IO_MB << 20;
o->od_auto_scrub_interval = AS_DEFAULT;
+ /* default fallocate to unwritten extents: LU-14326/LU-14333 */
+ o->od_fallocate_zero_blocks = 0;
cplen = strlcpy(o->od_svname, lustre_cfg_string(cfg, 4),
sizeof(o->od_svname));
if (rc != 0)
GOTO(out_site, rc);
+ opts = lustre_cfg_string(cfg, 3);
+ if (opts && strstr(opts, "resetoi"))
+ restored = true;
+
INIT_LIST_HEAD(&o->od_ios_list);
/* setup scrub, including OI files initialization */
o->od_in_init = 1;
- rc = osd_scrub_setup(env, o);
+ rc = osd_scrub_setup(env, o, restored);
o->od_in_init = 0;
if (rc < 0)
GOTO(out_site, rc);
GOTO(out_procfs, rc);
}
+ o->od_extent_bytes_percpu = alloc_percpu(unsigned int);
+ if (!o->od_extent_bytes_percpu) {
+ rc = -ENOMEM;
+ GOTO(out_procfs, rc);
+ }
+
RETURN(0);
out_procfs:
#ifdef CONFIG_KALLSYMS
priv_security_file_alloc =
- (void *)kallsyms_lookup_name("security_file_alloc");
+ (void *)cfs_kallsyms_lookup_name("security_file_alloc");
#endif
- rc = class_register_type(&osd_obd_device_ops, NULL, true, NULL,
+ rc = class_register_type(&osd_obd_device_ops, NULL, true,
LUSTRE_OSD_LDISKFS_NAME, &osd_device_type);
if (rc) {
lu_kmem_fini(ldiskfs_caches);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff