* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2016, Intel Corporation.
+ * Copyright (c) 2012, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
top->ld_ops->ldo_process_config(env, top, lcfg);
OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
+ if (m->ofd_los != NULL) {
+ local_oid_storage_fini(env, m->ofd_los);
+ m->ofd_los = NULL;
+ }
+
lu_site_purge(env, top->ld_site, ~0);
if (!cfs_hash_is_empty(top->ld_site->ls_obj_hash)) {
- LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_ERROR, NULL);
+ LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_OTHER, NULL);
lu_site_print(env, top->ld_site, &msgdata, lu_cdebug_printer);
}
EXIT;
}
+static void ofd_stack_pre_fini(const struct lu_env *env, struct ofd_device *m,
+ struct lu_device *top)
+{
+ struct lustre_cfg_bufs bufs;
+ struct lustre_cfg *lcfg;
+ ENTRY;
+
+ LASSERT(top);
+
+ lustre_cfg_bufs_reset(&bufs, ofd_name(m));
+ lustre_cfg_bufs_set_string(&bufs, 1, NULL);
+ OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
+ if (!lcfg) {
+ CERROR("%s: failed to trigger LCFG_PRE_CLEANUP\n", ofd_name(m));
+ } else {
+ lustre_cfg_init(lcfg, LCFG_PRE_CLEANUP, &bufs);
+ top->ld_ops->ldo_process_config(env, top, lcfg);
+ OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount,
+ lcfg->lcfg_buflens));
+ }
+
+ EXIT;
+}
+
/* For interoperability, see mdt_interop_param[]. */
static struct cfg_interop_param ofd_interop_param[] = {
{ "ost.quota_type", NULL },
sval = strchr(param, '=');
if (sval != NULL) {
paramlen = sval - param;
- if (strncmp(param, "writethrough_cache_enable",
- paramlen) == 0 ||
- strncmp(param, "readcache_max_filesize",
- paramlen) == 0 ||
- strncmp(param, "read_cache_enable",
- paramlen) == 0 ||
- strncmp(param, "brw_stats", paramlen) == 0)
+ if (strncmp(param, "brw_stats", paramlen) == 0)
return true;
}
}
switch (cfg->lcfg_command) {
case LCFG_PARAM: {
- struct obd_device *obd = ofd_obd(m);
/* For interoperability */
- struct cfg_interop_param *ptr = NULL;
- struct lustre_cfg *old_cfg = NULL;
- char *param = NULL;
+ struct cfg_interop_param *ptr = NULL;
+ struct lustre_cfg *old_cfg = NULL;
+ char *param = NULL;
+ ssize_t count;
param = lustre_cfg_string(cfg, 1);
if (param == NULL) {
break;
}
- rc = class_process_proc_param(PARAM_OST, obd->obd_vars, cfg,
- d->ld_obd);
- if (rc > 0 || rc == -ENOSYS) {
- CDEBUG(D_CONFIG, "pass param %s down the stack.\n",
- param);
- /* we don't understand; pass it on */
- rc = next->ld_ops->ldo_process_config(env, next, cfg);
+ count = class_modify_config(cfg, PARAM_OST,
+ &d->ld_obd->obd_kset.kobj);
+ if (count > 0) {
+ rc = 0;
+ break;
}
+ CDEBUG(D_CONFIG, "pass param %s down the stack.\n",
+ param);
+ /* we don't understand; pass it on */
+ rc = next->ld_ops->ldo_process_config(env, next, cfg);
break;
}
case LCFG_SPTLRPC_CONF: {
.ldo_prepare = ofd_prepare,
};
-LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
-
-/**
- * Initialize all needed procfs entries for OFD device.
- *
- * \param[in] ofd OFD device
- *
- * \retval 0 if successful
- * \retval negative value on error
- */
-static int ofd_procfs_init(struct ofd_device *ofd)
-{
- struct obd_device *obd = ofd_obd(ofd);
- struct proc_dir_entry *entry;
- int rc = 0;
-
- ENTRY;
-
- /* lprocfs must be setup before the ofd so state can be safely added
- * to /proc incrementally as the ofd is setup */
- obd->obd_vars = lprocfs_ofd_obd_vars;
- rc = lprocfs_obd_setup(obd, false);
- if (rc) {
- CERROR("%s: lprocfs_obd_setup failed: %d.\n",
- obd->obd_name, rc);
- RETURN(rc);
- }
-
- rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_STATS_LAST);
- if (rc) {
- CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n",
- obd->obd_name, rc);
- GOTO(obd_cleanup, rc);
- }
-
- obd->obd_uses_nid_stats = 1;
-
- entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
- if (IS_ERR(entry)) {
- rc = PTR_ERR(entry);
- CERROR("%s: error %d setting up lprocfs for %s\n",
- obd->obd_name, rc, "exports");
- GOTO(obd_cleanup, rc);
- }
- obd->obd_proc_exports_entry = entry;
-
- entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
- obd, &lprocfs_nid_stats_clear_fops);
- if (IS_ERR(entry)) {
- rc = PTR_ERR(entry);
- CERROR("%s: add proc entry 'clear' failed: %d.\n",
- obd->obd_name, rc);
- GOTO(obd_cleanup, rc);
- }
-
- ofd_stats_counter_init(obd->obd_stats);
-
- rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
- ofd_stats_counter_init);
- if (rc)
- GOTO(obd_cleanup, rc);
- RETURN(0);
-obd_cleanup:
- lprocfs_obd_cleanup(obd);
- lprocfs_free_obd_stats(obd);
-
- return rc;
-}
-
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
/**
* Expose OSD statistics to OFD layer.
*
*/
static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd)
{
- struct obd_device *obd = ofd_obd(ofd);
- struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd;
+ struct obd_device *obd = ofd_obd(ofd);
+ struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd;
+ struct kobj_type *osd_type;
+ int i;
+
+ osd_type = get_ktype(&ofd->ofd_osd->dd_kobj);
+ for (i = 0; osd_type->default_attrs[i]; i++) {
+ if (strcmp(osd_type->default_attrs[i]->name,
+ "read_cache_enable") == 0) {
+ ofd->ofd_read_cache_enable =
+ osd_type->default_attrs[i];
+ }
+
+ if (strcmp(osd_type->default_attrs[i]->name,
+ "readcache_max_filesize") == 0) {
+ ofd->ofd_read_cache_max_filesize =
+ osd_type->default_attrs[i];
+ }
+
+ if (strcmp(osd_type->default_attrs[i]->name,
+ "writethrough_cache_enable") == 0) {
+ ofd->ofd_write_cache_enable =
+ osd_type->default_attrs[i];
+ }
+ }
if (obd->obd_proc_entry == NULL)
return;
lprocfs_add_symlink("brw_stats", obd->obd_proc_entry,
"../../%s/%s/brw_stats",
osd_obd->obd_type->typ_name, obd->obd_name);
-
- lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry,
- "../../%s/%s/read_cache_enable",
- osd_obd->obd_type->typ_name, obd->obd_name);
-
- lprocfs_add_symlink("readcache_max_filesize",
- obd->obd_proc_entry,
- "../../%s/%s/readcache_max_filesize",
- osd_obd->obd_type->typ_name, obd->obd_name);
-
- lprocfs_add_symlink("writethrough_cache_enable",
- obd->obd_proc_entry,
- "../../%s/%s/writethrough_cache_enable",
- osd_obd->obd_type->typ_name, obd->obd_name);
}
+#endif
/**
* Cleanup all procfs entries in OFD.
*/
int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd)
{
- struct seq_server_site *ss = &ofd->ofd_seq_site;
- struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev;
- char *obd_name = ofd_name(ofd);
- char *name = NULL;
- int rc = 0;
+ struct seq_server_site *ss = &ofd->ofd_seq_site;
+ struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev;
+ char *obd_name = ofd_name(ofd);
+ char *name = NULL;
+ int len = strlen(obd_name) + 7;
+ int rc = 0;
ss = &ofd->ofd_seq_site;
lu->ld_site->ld_seq_site = ss;
ss->ss_lu = lu->ld_site;
ss->ss_node_id = ofd->ofd_lut.lut_lsd.lsd_osd_index;
- OBD_ALLOC(name, sizeof(obd_name) * 2 + 10);
+ OBD_ALLOC(name, len);
if (name == NULL)
return -ENOMEM;
rc = seq_server_init(env, ss->ss_server_seq, ofd->ofd_osd, obd_name,
LUSTRE_SEQ_SERVER, ss);
if (rc) {
- CERROR("%s : seq server init error %d\n", obd_name, rc);
+ CERROR("%s: seq server init error: rc = %d\n", obd_name, rc);
GOTO(out_server, rc);
}
ss->ss_server_seq->lss_space.lsr_index = ss->ss_node_id;
if (ss->ss_client_seq == NULL)
GOTO(out_server, rc = -ENOMEM);
- /*
- * It always printed as "%p", so that the name is unique in the kernel,
- * even if the filesystem is mounted twice. So sizeof(.) * 2 is enough.
- */
- snprintf(name, sizeof(obd_name) * 2 + 7, "%p-super", obd_name);
+ snprintf(name, len, "%s-super", obd_name);
rc = seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA,
name, NULL);
if (rc) {
- CERROR("%s : seq client init error %d\n", obd_name, rc);
+ CERROR("%s: seq client init error: rc = %d\n", obd_name, rc);
GOTO(out_client, rc);
}
ss->ss_server_seq = NULL;
}
out_name:
- OBD_FREE(name, sizeof(obd_name) * 2 + 10);
+ OBD_FREE(name, len);
return rc;
}
return rc;
}
-struct locked_region {
- struct list_head list;
- struct lustre_handle lh;
-};
-/**
- * Lock single extent and save lock handle in the list.
- *
- * This is supplemental function for lock_zero_regions(). It allocates
- * new locked_region structure and locks it with extent lock, then adds
- * it to the list of all such regions.
- *
- * \param[in] ns LDLM namespace
- * \param[in] res_id resource ID
- * \param[in] begin start of region
- * \param[in] end end of region
- * \param[in] locked list head of regions list
- *
- * \retval 0 if successful locking
- * \retval negative value on error
- */
-static int lock_region(struct ldlm_namespace *ns, struct ldlm_res_id *res_id,
- unsigned long long begin, unsigned long long end,
- struct list_head *locked)
+static int ofd_lock_unlock_region(const struct lu_env *env,
+ struct ldlm_namespace *ns,
+ struct ldlm_res_id *res_id,
+ unsigned long long begin,
+ unsigned long long end)
{
- struct locked_region *region = NULL;
__u64 flags = 0;
int rc;
+ struct lustre_handle lh = { 0 };
LASSERT(begin <= end);
- OBD_ALLOC_PTR(region);
- if (region == NULL)
- return -ENOMEM;
- rc = tgt_extent_lock(ns, res_id, begin, end, ®ion->lh,
- LCK_PR, &flags);
+ rc = tgt_extent_lock(env, ns, res_id, begin, end, &lh, LCK_PR, &flags);
if (rc != 0)
return rc;
- CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end,
- ®ion->lh);
- list_add(®ion->list, locked);
+ CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, &lh);
+ tgt_extent_unlock(&lh, LCK_PR);
return 0;
}
* \retval 0 if successful
* \retval negative value on error
*/
-static int lock_zero_regions(struct ldlm_namespace *ns,
+static int lock_zero_regions(const struct lu_env *env,
+ struct ldlm_namespace *ns,
struct ldlm_res_id *res_id,
- struct fiemap *fiemap,
- struct list_head *locked)
+ struct fiemap *fiemap)
{
__u64 begin = fiemap->fm_start;
unsigned int i;
if (fiemap_start[i].fe_logical > begin) {
CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n",
begin, fiemap_start[i].fe_logical);
- rc = lock_region(ns, res_id, begin,
- fiemap_start[i].fe_logical, locked);
+ rc = ofd_lock_unlock_region(env, ns, res_id, begin,
+ fiemap_start[i].fe_logical);
if (rc)
RETURN(rc);
}
if (begin < (fiemap->fm_start + fiemap->fm_length)) {
CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n",
begin, fiemap->fm_start + fiemap->fm_length);
- rc = lock_region(ns, res_id, begin,
- fiemap->fm_start + fiemap->fm_length, locked);
+ rc = ofd_lock_unlock_region(env, ns, res_id, begin,
+ fiemap->fm_start + fiemap->fm_length);
}
RETURN(rc);
}
-/**
- * Unlock all previously locked sparse areas for given resource.
- *
- * This function goes through list of locked regions, unlocking and freeing
- * them one-by-one.
- *
- * \param[in] ns LDLM namespace
- * \param[in] locked list head of regions list
- */
-static void
-unlock_zero_regions(struct ldlm_namespace *ns, struct list_head *locked)
-{
- struct locked_region *entry, *temp;
-
- list_for_each_entry_safe(entry, temp, locked, list) {
- CDEBUG(D_OTHER, "ost unlock lh=%p\n", &entry->lh);
- tgt_extent_unlock(&entry->lh, LCK_PR);
- list_del(&entry->list);
- OBD_FREE_PTR(entry);
- }
-}
/**
* OFD request handler for OST_GET_INFO RPC.
* flushed back from client, then call fiemap again. */
if (fm_key->lfik_oa.o_valid & OBD_MD_FLFLAGS &&
fm_key->lfik_oa.o_flags & OBD_FL_SRVLOCK) {
- struct list_head locked;
-
- INIT_LIST_HEAD(&locked);
ost_fid_build_resid(fid, &fti->fti_resid);
- rc = lock_zero_regions(ofd->ofd_namespace,
- &fti->fti_resid, fiemap,
- &locked);
- if (rc == 0 && !list_empty(&locked)) {
+ rc = lock_zero_regions(tsi->tsi_env, ofd->ofd_namespace,
+ &fti->fti_resid, fiemap);
+ if (rc == 0)
rc = ofd_fiemap_get(tsi->tsi_env, ofd, fid,
fiemap);
- unlock_zero_regions(ofd->ofd_namespace,
- &locked);
- }
}
} else if (KEY_IS(KEY_LAST_FID)) {
struct ofd_device *ofd = ofd_exp(exp);
if (unlikely(tsi->tsi_ost_body->oa.o_flags & OBD_FL_FLUSH))
lock_mode = LCK_PW;
- rc = tgt_extent_lock(tsi->tsi_tgt->lut_obd->obd_namespace,
+ rc = tgt_extent_lock(tsi->tsi_env,
+ tsi->tsi_tgt->lut_obd->obd_namespace,
&tsi->tsi_resid, 0, OBD_OBJECT_EOF, &lh,
lock_mode, &flags);
if (rc != 0)
res = ldlm_resource_get(ofd->ofd_namespace, NULL,
&tsi->tsi_resid, LDLM_EXTENT, 0);
if (!IS_ERR(res)) {
- ldlm_res_lvbo_update(res, NULL, 0);
+ ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0);
ldlm_resource_putref(res);
}
}
oseq->os_destroys_in_progress = 1;
mutex_lock(&oseq->os_create_lock);
if (!oseq->os_destroys_in_progress) {
- CERROR("%s:[%llu] destroys_in_progress already"
- " cleared\n", ofd_name(ofd), seq);
+ CDEBUG(D_HA,
+ "%s:[%llu] destroys_in_progress already cleared\n",
+ ofd_name(ofd), seq);
rc = ostid_set_id(&rep_oa->o_oi,
ofd_seq_last_oid(oseq));
GOTO(out, rc);
u64 next_id;
int created = 0;
int count;
+ int rc2;
if (!(oa->o_valid & OBD_MD_FLFLAGS) ||
!(oa->o_flags & OBD_FL_DELORPHAN)) {
granted = 0;
}
- rc = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq));
+ rc2 = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq));
+ rc = rc ? : rc2;
}
EXIT;
ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE,
tsi->tsi_jobid, 1);
+ if (unlikely(!oseq->os_last_id_synced))
+ oseq->os_last_id_synced = 1;
out:
mutex_unlock(&oseq->os_create_lock);
out_nolock:
osfs = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_STATFS);
rc = ofd_statfs(tsi->tsi_env, tsi->tsi_exp, osfs,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), 0);
+ ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, 0);
if (rc != 0)
CERROR("%s: statfs failed: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
oa->o_flags & OBD_FL_SRVLOCK;
if (srvlock) {
- rc = tgt_extent_lock(ns, &tsi->tsi_resid, start, end, &lh,
- LCK_PW, &flags);
+ rc = tgt_extent_lock(tsi->tsi_env, ns, &tsi->tsi_resid, start,
+ end, &lh, LCK_PW, &flags);
if (rc != 0)
RETURN(rc);
}
res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid,
LDLM_EXTENT, 0);
if (!IS_ERR(res)) {
- ldlm_res_lvbo_update(res, NULL, 0);
+ struct ost_lvb *res_lvb;
+
+ ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0);
+ res_lvb = res->lr_lvb_data;
+ repbody->oa.o_valid |= OBD_MD_FLBLOCKS;
+ repbody->oa.o_blocks = res_lvb->lvb_blocks;
ldlm_resource_putref(res);
}
}
ioo.ioo_oid = body->oa.o_oi;
ioo.ioo_bufcnt = 1;
- rc = tgt_extent_lock(exp->exp_obd->obd_namespace,
+ rc = tgt_extent_lock(env, exp->exp_obd->obd_namespace,
&tsi->tsi_resid, start, end - 1,
&lockh, LCK_PR, &flags);
if (rc != 0)
spin_lock_init(&m->ofd_flags_lock);
m->ofd_raid_degraded = 0;
- m->ofd_syncjournal = 0;
+ m->ofd_checksum_t10pi_enforce = 0;
+ m->ofd_sync_journal = 0;
ofd_slc_set(m);
m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT;
/* set this lu_device to obd, because error handling need it */
obd->obd_lu_dev = &m->ofd_dt_dev.dd_lu_dev;
- rc = ofd_procfs_init(m);
+ rc = ofd_tunables_init(m);
if (rc) {
CERROR("Can't init ofd lprocfs, rc %d\n", rc);
RETURN(rc);
GOTO(err_fini_proc, rc);
}
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
ofd_procfs_add_brw_stats_symlink(m);
+#endif
snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-%s",
"filter"/*LUSTRE_OST_NAME*/, obd->obd_uuid.uuid);
tgd->tgd_reserved_pcnt = 0;
- if (DT_DEF_BRW_SIZE < (1U << tgd->tgd_blockbits))
- m->ofd_brw_size = 1U << tgd->tgd_blockbits;
- else
- m->ofd_brw_size = DT_DEF_BRW_SIZE;
-
- m->ofd_cksum_types_supported = cksum_types_supported_server();
+ m->ofd_brw_size = m->ofd_lut.lut_dt_conf.ddp_brw_size;
+ m->ofd_cksum_types_supported =
+ obd_cksum_types_supported_server(obd->obd_name);
m->ofd_precreate_batch = OFD_PRECREATE_BATCH_DEFAULT;
if (tgd->tgd_osfs.os_bsize * tgd->tgd_osfs.os_blocks <
OFD_PRECREATE_SMALL_FS)
stop.ls_status = LS_PAUSED;
stop.ls_flags = 0;
lfsck_stop(env, m->ofd_osd, &stop);
+ ofd_stack_pre_fini(env, m, &m->ofd_dt_dev.dd_lu_dev);
target_recovery_fini(obd);
if (m->ofd_namespace != NULL)
ldlm_namespace_free_prior(m->ofd_namespace, NULL,
nm_config_file_deregister_tgt(env, obd->u.obt.obt_nodemap_config_file);
obd->u.obt.obt_nodemap_config_file = NULL;
- if (m->ofd_los != NULL) {
- local_oid_storage_fini(env, m->ofd_los);
- m->ofd_los = NULL;
- }
-
if (m->ofd_namespace != NULL) {
ldlm_namespace_free_post(m->ofd_namespace);
d->ld_obd->obd_namespace = m->ofd_namespace = NULL;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff