obd = class_name2obd(next);
if (obd == NULL) {
CERROR("%s: can't locate next device: %s\n",
- m->ofd_dt_dev.dd_lu_dev.ld_obd->obd_name, next);
+ ofd_name(m), next);
GOTO(out, rc = -ENOTCONN);
}
rc = obd_connect(NULL, exp, obd, &obd->obd_uuid, data, NULL);
if (rc) {
CERROR("%s: cannot connect to next dev %s: rc = %d\n",
- m->ofd_dt_dev.dd_lu_dev.ld_obd->obd_name, next, rc);
+ ofd_name(m), next, rc);
GOTO(out, rc);
}
LASSERT(m->ofd_osd_exp);
obd_disconnect(m->ofd_osd_exp);
- m->ofd_osd = NULL;
EXIT;
}
switch (cfg->lcfg_command) {
case LCFG_PARAM: {
- struct lprocfs_static_vars lvars;
-
+ struct obd_device *obd = ofd_obd(m);
/* For interoperability */
struct cfg_interop_param *ptr = NULL;
struct lustre_cfg *old_cfg = NULL;
break;
}
- lprocfs_ofd_init_vars(&lvars);
- rc = class_process_proc_param(PARAM_OST, lvars.obd_vars, cfg,
+ rc = class_process_proc_seq_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",
ENTRY;
- OBD_SLAB_ALLOC_PTR_GFP(of, ofd_object_kmem, __GFP_IO);
+ OBD_SLAB_ALLOC_PTR_GFP(of, ofd_object_kmem, GFP_NOFS);
if (of != NULL) {
struct lu_object *o;
struct lu_object_header *h;
}
default:
CERROR("%s: unknown lfsck event: rc = %d\n",
- ofd_obd(ofd)->obd_name, event);
+ ofd_name(ofd), event);
return -EINVAL;
}
struct ofd_device *ofd = ofd_dev(dev);
struct obd_device *obd = ofd_obd(ofd);
struct lu_device *next = &ofd->ofd_osd->dd_lu_dev;
- struct lfsck_start_param lsp;
int rc;
ENTRY;
}
rc = lfsck_register_namespace(env, ofd->ofd_osd, ofd->ofd_namespace);
+ /* The LFSCK instance is registered just now, so it must be there when
+ * register the namespace to such instance. */
LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc);
- lsp.lsp_start = NULL;
- lsp.lsp_index_valid = 0;
- rc = lfsck_start(env, ofd->ofd_osd, &lsp);
- if (rc != 0) {
- CWARN("%s: auto trigger paused LFSCK failed: rc = %d\n",
- obd->obd_name, rc);
- rc = 0;
- }
-
target_recovery_init(&ofd->ofd_lut, tgt_request_handle);
LASSERT(obd->obd_no_conn);
spin_lock(&obd->obd_dev_lock);
.ldo_prepare = ofd_prepare,
};
+LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
+
static int ofd_procfs_init(struct ofd_device *ofd)
{
- struct lprocfs_static_vars lvars;
struct obd_device *obd = ofd_obd(ofd);
cfs_proc_dir_entry_t *entry;
int rc = 0;
/* lprocfs must be setup before the ofd so state can be safely added
* to /proc incrementally as the ofd is setup */
- lprocfs_ofd_init_vars(&lvars);
- rc = lprocfs_obd_setup(obd, lvars.obd_vars);
+ obd->obd_vars = lprocfs_ofd_obd_vars;
+ rc = lprocfs_seq_obd_setup(obd);
if (rc) {
CERROR("%s: lprocfs_obd_setup failed: %d.\n",
obd->obd_name, rc);
obd->obd_uses_nid_stats = 1;
- entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
+ entry = lprocfs_seq_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_proc_exports_entry = entry;
entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
- lprocfs_nid_stats_clear_read,
- lprocfs_nid_stats_clear_write, obd, NULL);
+#ifndef HAVE_ONLY_PROCFS_SEQ
+ NULL, NULL,
+#endif
+ obd, &lprocfs_nid_stats_clear_fops);
if (IS_ERR(entry)) {
rc = PTR_ERR(entry);
CERROR("%s: add proc entry 'clear' failed: %d.\n",
rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST,
ofd_stats_counter_init);
if (rc)
- GOTO(remove_entry_clear, rc);
+ GOTO(obd_cleanup, rc);
RETURN(0);
-remove_entry_clear:
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
obd_cleanup:
lprocfs_obd_cleanup(obd);
lprocfs_free_obd_stats(obd);
return rc;
}
+/**
+ * ofd_procfs_add_brw_stats_symlink - expose osd stats to ofd layer
+ *
+ * The osd interfaces to the backend file system exposes useful data
+ * such as brw_stats and read or write cache states. This same data
+ * needs to be exposed into the obdfilter (ofd) layer to maintain
+ * backwards compatibility. This function creates the symlinks in the
+ * proc layer to enable this.
+ */
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;
- cfs_proc_dir_entry_t *osd_root = osd_obd->obd_type->typ_procroot;
- cfs_proc_dir_entry_t *osd_dir;
- osd_dir = lprocfs_srch(osd_root, obd->obd_name);
- if (osd_dir == NULL)
+ if (obd->obd_proc_entry == NULL)
return;
- if (lprocfs_srch(osd_dir, "brw_stats") != NULL)
- lprocfs_add_symlink("brw_stats", obd->obd_proc_entry,
- "../../%s/%s/brw_stats",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "read_cache_enable") != NULL)
- lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry,
- "../../%s/%s/read_cache_enable",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "readcache_max_filesize") != NULL)
- lprocfs_add_symlink("readcache_max_filesize",
- obd->obd_proc_entry,
- "../../%s/%s/readcache_max_filesize",
- osd_root->name, osd_dir->name);
-
- if (lprocfs_srch(osd_dir, "writethrough_cache_enable") != NULL)
- lprocfs_add_symlink("writethrough_cache_enable",
- obd->obd_proc_entry,
- "../../%s/%s/writethrough_cache_enable",
- osd_root->name, osd_dir->name);
+ 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);
}
static void ofd_procfs_fini(struct ofd_device *ofd)
{
struct obd_device *obd = ofd_obd(ofd);
- lprocfs_remove_proc_entry("writethrough_cache_enable",
- obd->obd_proc_entry);
- lprocfs_remove_proc_entry("readcache_max_filesize",
- obd->obd_proc_entry);
- lprocfs_remove_proc_entry("read_cache_enable", obd->obd_proc_entry);
- lprocfs_remove_proc_entry("brw_stats", obd->obd_proc_entry);
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
lprocfs_free_per_client_stats(obd);
lprocfs_obd_cleanup(obd);
lprocfs_free_obd_stats(obd);
* to go... deadlock! */
res = ldlm_resource_get(ofd->ofd_namespace, NULL,
&tsi->tsi_resid, LDLM_EXTENT, 0);
- if (res != NULL) {
+ if (!IS_ERR(res)) {
ldlm_res_lvbo_update(res, NULL, 0);
ldlm_resource_putref(res);
}
LASSERT(exp != NULL);
skip_orphan = !!(exp_connect_flags(exp) & OBD_CONNECT_SKIP_ORPHAN);
+ if (OBD_FAIL_CHECK(OBD_FAIL_OST_NODESTROY))
+ goto done;
+
LCONSOLE(D_INFO, "%s: deleting orphan objects from "DOSTID
" to "DOSTID"\n", ofd_name(ofd), seq, end_id + 1, seq, last);
GOTO(out_put, rc);
rc = ofd_destroy_by_fid(env, ofd, fid, 1);
- if (rc != 0 && rc != -ENOENT) /* this is pretty fatal... */
- CEMERG("%s: error destroying precreated id "DFID
- ": rc = %d\n", ofd_name(ofd), PFID(fid), rc);
+ if (rc != 0 && rc != -ENOENT && rc != -ESTALE &&
+ likely(rc != -EREMCHG && rc != -EINPROGRESS))
+ /* this is pretty fatal... */
+ CEMERG("%s: error destroying precreated id "
+ DFID": rc = %d\n",
+ ofd_name(ofd), PFID(fid), rc);
oid--;
if (!skip_orphan) {
CDEBUG(D_HA, "%s: after destroy: set last_id to "DOSTID"\n",
ofd_name(ofd), seq, oid);
+done:
if (!skip_orphan) {
+ ofd_seq_last_oid_set(oseq, oid);
rc = ofd_seq_last_oid_write(env, ofd, oseq);
} else {
/* don't reuse orphan object, return last used objid */
out:
mutex_unlock(&oseq->os_create_lock);
out_nolock:
- if (rc == 0)
+ if (rc == 0) {
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 8, 53, 0)
+ struct ofd_thread_info *info = ofd_info(tsi->tsi_env);
+ struct lu_fid *fid = &info->fti_fid;
+
+ /* For compatible purpose, it needs to convert back to
+ * OST ID before put it on wire. */
+ *fid = rep_oa->o_oi.oi_fid;
+ fid_to_ostid(fid, &rep_oa->o_oi);
+#endif
rep_oa->o_valid |= OBD_MD_FLID | OBD_MD_FLGROUP;
-
+ }
ofd_seq_put(tsi->tsi_env, oseq);
out_sem:
}
rc = tgt_sync(tsi->tsi_env, tsi->tsi_tgt,
- fo != NULL ? ofd_object_child(fo) : NULL);
+ fo != NULL ? ofd_object_child(fo) : NULL,
+ repbody->oa.o_size, repbody->oa.o_blocks);
if (rc)
GOTO(put, rc);
}
rc = ofd_object_punch(tsi->tsi_env, fo, start, end, &info->fti_attr,
- ff);
+ ff, (struct obdo *)oa);
if (rc)
GOTO(out_put, rc);
* to go... deadlock! */
res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid,
LDLM_EXTENT, 0);
- if (res != NULL) {
+ if (!IS_ERR(res)) {
ldlm_res_lvbo_update(res, NULL, 0);
ldlm_resource_putref(res);
}
.tos_hs = tgt_dlm_handlers
},
{
- .tos_opc_start = UPDATE_OBJ,
- .tos_opc_end = UPDATE_LAST_OPC,
+ .tos_opc_start = OUT_UPDATE_FIRST_OPC,
+ .tos_opc_end = OUT_UPDATE_LAST_OPC,
.tos_hs = tgt_out_handlers
},
{
m->ofd_tot_granted = 0;
m->ofd_tot_pending = 0;
m->ofd_seq_count = 0;
+ init_waitqueue_head(&m->ofd_inconsistency_thread.t_ctl_waitq);
+ INIT_LIST_HEAD(&m->ofd_inconsistency_list);
+ spin_lock_init(&m->ofd_inconsistency_lock);
spin_lock_init(&m->ofd_batch_lock);
- rwlock_init(&obd->u.filter.fo_sptlrpc_lock);
- sptlrpc_rule_set_init(&obd->u.filter.fo_sptlrpc_rset);
init_rwsem(&m->ofd_lastid_rwsem);
obd->u.filter.fo_fl_oss_capa = 0;
if (rc)
GOTO(err_fini_lut, rc);
+ rc = ofd_start_inconsistency_verification_thread(m);
+ if (rc != 0)
+ GOTO(err_fini_fs, rc);
+
RETURN(0);
+
+err_fini_fs:
+ ofd_fs_cleanup(env, m);
err_fini_lut:
tgt_fini(env, &m->ofd_lut);
err_free_ns:
stop.ls_status = LS_PAUSED;
stop.ls_flags = 0;
lfsck_stop(env, m->ofd_osd, &stop);
- lfsck_degister(env, m->ofd_osd);
target_recovery_fini(obd);
obd_exports_barrier(obd);
obd_zombie_barrier();
tgt_fini(env, &m->ofd_lut);
+ ofd_stop_inconsistency_verification_thread(m);
+ lfsck_degister(env, m->ofd_osd);
ofd_fs_cleanup(env, m);
ofd_free_capa_keys(m);
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);
+ server_put_mount(obd->obd_name, true);
EXIT;
}
int __init ofd_init(void)
{
- struct lprocfs_static_vars lvars;
int rc;
rc = lu_kmem_init(ofd_caches);
return(rc);
}
- lprocfs_ofd_init_vars(&lvars);
-
- rc = class_register_type(&ofd_obd_ops, NULL, NULL,
+ rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
#ifndef HAVE_ONLY_PROCFS_SEQ
- lvars.module_vars,
+ NULL,
#endif
- LUSTRE_OST_NAME, &ofd_device_type);
+ LUSTRE_OST_NAME, &ofd_device_type);
return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff