/* Slab for OFD object allocation */
static struct kmem_cache *ofd_object_kmem;
-
static struct lu_kmem_descr ofd_caches[] = {
{
.ckd_cache = &ofd_object_kmem,
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;
}
}
LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc);
target_recovery_init(&ofd->ofd_lut, tgt_request_handle);
+ OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_OST_PREPARE_DELAY, OBD_FAIL_ONCE,
+ (OBD_TIMEOUT_DEFAULT + 1) / 4);
LASSERT(obd->obd_no_conn);
spin_lock(&obd->obd_dev_lock);
obd->obd_no_conn = 0;
*/
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
{
struct obd_device *obd = ofd_obd(ofd);
+ tgt_tunables_fini(&ofd->ofd_lut);
lprocfs_free_per_client_stats(obd);
lprocfs_obd_cleanup(obd);
lprocfs_free_obd_stats(obd);
*/
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;
}
res = ldlm_resource_get(ofd->ofd_namespace, NULL,
&tsi->tsi_resid, LDLM_EXTENT, 0);
if (!IS_ERR(res)) {
- ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0);
+ ldlm_res_lvbo_update(res, NULL, 0);
ldlm_resource_putref(res);
}
}
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:
if (!IS_ERR(res)) {
struct ost_lvb *res_lvb;
- ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0);
+ ldlm_res_lvbo_update(res, NULL, 0);
res_lvb = res->lr_lvb_data;
repbody->oa.o_valid |= OBD_MD_FLBLOCKS;
repbody->oa.o_blocks = res_lvb->lvb_blocks;
0, OST_SET_INFO, ofd_set_info_hdl,
&RQF_OBD_SET_INFO, LUSTRE_OST_VERSION),
TGT_OST_HDL(0, OST_GET_INFO, ofd_get_info_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_GETATTR, ofd_getattr_hdl),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_GETATTR, ofd_getattr_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE,
OST_SETATTR, ofd_setattr_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
OST_CREATE, ofd_create_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR,
+TGT_OST_HDL(HAS_REPLY | IS_MUTABLE,
OST_DESTROY, ofd_destroy_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO, OST_STATFS, ofd_statfs_hdl),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO,
- OST_BRW_READ, tgt_brw_read,
+TGT_OST_HDL(HAS_REPLY, OST_STATFS, ofd_statfs_hdl),
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY, OST_BRW_READ, tgt_brw_read,
ofd_hp_brw),
/* don't set CORPUS flag for brw_write because -ENOENT may be valid case */
-TGT_OST_HDL_HP(HABEO_CORPUS| MUTABOR, OST_BRW_WRITE, tgt_brw_write,
+TGT_OST_HDL_HP(HAS_BODY | IS_MUTABLE, OST_BRW_WRITE, tgt_brw_write,
ofd_hp_brw),
-TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR,
+TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY | IS_MUTABLE,
OST_PUNCH, ofd_punch_hdl,
ofd_hp_punch),
-TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_SYNC, ofd_sync_hdl),
-TGT_OST_HDL(0 | HABEO_REFERO, OST_QUOTACTL, ofd_quotactl),
-TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_LADVISE, ofd_ladvise_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC, ofd_sync_hdl),
+TGT_OST_HDL(HAS_REPLY, OST_QUOTACTL, ofd_quotactl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE, ofd_ladvise_hdl),
};
static struct tgt_opc_slice ofd_common_slice[] = {
obt = &obd->u.obt;
obt->obt_magic = OBT_MAGIC;
- m->ofd_fmd_max_num = OFD_FMD_MAX_NUM_DEFAULT;
- m->ofd_fmd_max_age = OFD_FMD_MAX_AGE_DEFAULT;
-
spin_lock_init(&m->ofd_flags_lock);
m->ofd_raid_degraded = 0;
m->ofd_checksum_t10pi_enforce = 0;
- m->ofd_syncjournal = 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_tunables_init(m);
- if (rc) {
- CERROR("Can't init ofd lprocfs, rc %d\n", rc);
- RETURN(rc);
- }
-
/* No connection accepted until configurations will finish */
spin_lock(&obd->obd_dev_lock);
obd->obd_no_conn = 1;
info = ofd_info_init(env, NULL);
if (info == NULL)
- GOTO(err_fini_proc, rc = -EFAULT);
+ RETURN(-EFAULT);
rc = ofd_stack_init(env, m, cfg);
if (rc) {
- CERROR("Can't init device stack, rc %d\n", rc);
- GOTO(err_fini_proc, rc);
+ CERROR("%s: can't init device stack, rc %d\n",
+ obd->obd_name, rc);
+ RETURN(rc);
}
#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0)
if (rc)
GOTO(err_free_ns, rc);
+ rc = ofd_tunables_init(m);
+ if (rc)
+ GOTO(err_fini_lut, rc);
+
tgd->tgd_reserved_pcnt = 0;
m->ofd_brw_size = m->ofd_lut.lut_dt_conf.ddp_brw_size;
rc = ofd_fs_setup(env, m, obd);
if (rc)
- GOTO(err_fini_lut, rc);
+ GOTO(err_fini_proc, rc);
fid.f_seq = FID_SEQ_LOCAL_NAME;
fid.f_oid = 1;
m->ofd_los = NULL;
err_fini_fs:
ofd_fs_cleanup(env, m);
+err_fini_proc:
+ ofd_procfs_fini(m);
err_fini_lut:
tgt_fini(env, &m->ofd_lut);
err_free_ns:
obd->obd_namespace = m->ofd_namespace = NULL;
err_fini_stack:
ofd_stack_fini(env, m, &m->ofd_osd->dd_lu_dev);
-err_fini_proc:
- ofd_procfs_fini(m);
return rc;
}
obd_exports_barrier(obd);
obd_zombie_barrier();
+ ofd_procfs_fini(m);
tgt_fini(env, &m->ofd_lut);
ofd_stop_inconsistency_verification_thread(m);
lfsck_degister(env, m->ofd_osd);
}
ofd_stack_fini(env, m, &m->ofd_dt_dev.dd_lu_dev);
- ofd_procfs_fini(m);
+
LASSERT(atomic_read(&d->ld_ref) == 0);
server_put_mount(obd->obd_name, true);
EXIT;
rc = lu_kmem_init(ofd_caches);
if (rc)
return rc;
-
- rc = ofd_fmd_init();
- if (rc) {
- lu_kmem_fini(ofd_caches);
- return(rc);
- }
-
rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
LUSTRE_OST_NAME, &ofd_device_type);
return rc;
*/
static void __exit ofd_exit(void)
{
- ofd_fmd_exit();
lu_kmem_fini(ofd_caches);
class_unregister_type(LUSTRE_OST_NAME);
}