#include <obd.h>
#include <obd_class.h>
#include <lustre_mds.h>
-#include <lustre_mdt.h>
#include <lprocfs_status.h>
#include "mdt_internal.h"
#include <lnet/lib-lnet.h>
lprocfs_mdt_init_vars(&lvars);
rc = lprocfs_obd_setup(obd, lvars.obd_vars);
if (rc) {
- CERROR("Can't init lprocfs, rc %d\n", rc);
+ CERROR("%s: cannot create proc entries: rc = %d\n",
+ mdt_obd_name(mdt), rc);
+ return rc;
+ }
+
+ rc = hsm_cdt_procfs_init(mdt);
+ if (rc) {
+ CERROR("%s: cannot create hsm proc entries: rc = %d\n",
+ mdt_obd_name(mdt), rc);
return rc;
}
- ptlrpc_lprocfs_register_obd(obd);
obd->obd_proc_exports_entry = proc_mkdir("exports",
obd->obd_proc_entry);
rc = lprocfs_alloc_md_stats(obd, LPROC_MDT_LAST);
if (rc)
return rc;
- mdt_stats_counter_init(obd->md_stats);
+ mdt_stats_counter_init(obd->obd_md_stats);
rc = lprocfs_job_stats_init(obd, LPROC_MDT_LAST,
mdt_stats_counter_init);
{
struct obd_device *obd = mdt2obd_dev(mdt);
- if (obd->obd_proc_exports_entry) {
- lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
- obd->obd_proc_exports_entry = NULL;
- }
- lprocfs_free_per_client_stats(obd);
- lprocfs_obd_cleanup(obd);
- ptlrpc_lprocfs_unregister_obd(obd);
- lprocfs_free_md_stats(obd);
- lprocfs_free_obd_stats(obd);
+ if (obd->obd_proc_exports_entry != NULL) {
+ lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
+ obd->obd_proc_exports_entry = NULL;
+ }
+
+ lprocfs_free_per_client_stats(obd);
+ hsm_cdt_procfs_fini(mdt);
+ lprocfs_obd_cleanup(obd);
+ lprocfs_free_md_stats(obd);
+ lprocfs_free_obd_stats(obd);
lprocfs_job_stats_fini(obd);
}
OBD_ALLOC(kernbuf, count + 1);
if (kernbuf == NULL)
GOTO(failed, rc = -ENOMEM);
- if (cfs_copy_from_user(kernbuf, buffer, count))
+ if (copy_from_user(kernbuf, buffer, count))
GOTO(failed, rc = -EFAULT);
/* Remove any extraneous bits from the upcall (e.g. linefeeds) */
if (param == NULL)
return -ENOMEM;
- if (cfs_copy_from_user(param, buffer, size)) {
+ if (copy_from_user(param, buffer, size)) {
CERROR("%s: bad identity data\n", mdt_obd_name(mdt));
GOTO(out, rc = -EFAULT);
}
static int lprocfs_rd_capa(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
- struct obd_device *obd = data;
- struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+ struct obd_device *obd = data;
+ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- return snprintf(page, count, "capability on: %s %s\n",
- mdt->mdt_opts.mo_oss_capa ? "oss" : "",
- mdt->mdt_opts.mo_mds_capa ? "mds" : "");
+ return snprintf(page, count, "capability on: %s %s\n",
+ mdt->mdt_lut.lut_oss_capa ? "oss" : "",
+ mdt->mdt_lut.lut_mds_capa ? "mds" : "");
}
static int lprocfs_wr_capa(struct file *file, const char *buffer,
return -EINVAL;
}
- mdt->mdt_opts.mo_oss_capa = (val & 0x1);
- mdt->mdt_opts.mo_mds_capa = !!(val & 0x2);
+ spin_lock(&mdt->mdt_lut.lut_flags_lock);
+ mdt->mdt_lut.lut_oss_capa = !!(val & 0x1);
+ mdt->mdt_lut.lut_mds_capa = !!(val & 0x2);
+ spin_unlock(&mdt->mdt_lut.lut_flags_lock);
mdt->mdt_capa_conf = 1;
LCONSOLE_INFO("MDS %s %s MDS fid capability.\n",
mdt_obd_name(mdt),
- mdt->mdt_opts.mo_mds_capa ? "enabled" : "disabled");
+ mdt->mdt_lut.lut_mds_capa ? "enabled" : "disabled");
LCONSOLE_INFO("MDS %s %s OSS fid capability.\n",
mdt_obd_name(mdt),
- mdt->mdt_opts.mo_oss_capa ? "enabled" : "disabled");
+ mdt->mdt_lut.lut_oss_capa ? "enabled" : "disabled");
return count;
}
* bytes into kbuf, to ensure that the string is NUL-terminated.
* UUID_MAX should include a trailing NUL already.
*/
- if (cfs_copy_from_user(kbuf, buffer,
- min_t(unsigned long, BUFLEN - 1, count))) {
+ if (copy_from_user(kbuf, buffer,
+ min_t(unsigned long, BUFLEN - 1, count))) {
count = -EFAULT;
goto out;
}
struct obd_device *obd = data;
struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
- return snprintf(page, count, "%d\n", mdt->mdt_sec_level);
+ return snprintf(page, count, "%d\n", mdt->mdt_lut.lut_sec_level);
}
static int lprocfs_wr_sec_level(struct file *file, const char *buffer,
return -EINVAL;
}
- mdt->mdt_sec_level = val;
- return count;
+ mdt->mdt_lut.lut_sec_level = val;
+ return count;
}
static int lprocfs_rd_cos(char *page, char **start, off_t off,
errmsg = "string too long";
GOTO(failed, rc = -EINVAL);
}
- if (cfs_copy_from_user(kernbuf, buffer, count)) {
+ if (copy_from_user(kernbuf, buffer, count)) {
errmsg = "bad address";
GOTO(failed, rc = -EFAULT);
}
errmsg = "no memory";
GOTO(failed, rc = -ENOMEM);
}
- if (cfs_copy_from_user(kernbuf, buffer, count)) {
+ if (copy_from_user(kernbuf, buffer, count)) {
errmsg = "bad address";
GOTO(failed, rc = -EFAULT);
}
if (count > (sizeof(kernbuf) - 1))
return -EINVAL;
- if (cfs_copy_from_user(kernbuf, buffer, count))
+ if (copy_from_user(kernbuf, buffer, count))
return -EFAULT;
kernbuf[count] = '\0';
return count;
}
-/* Temporary; for testing purposes only */
-static int lprocfs_mdt_wr_mdc(struct file *file, const char *buffer,
- unsigned long count, void *data)
-{
- struct obd_device *obd = data;
- struct obd_export *exp = NULL;
- struct obd_uuid *uuid;
- char *kbuf;
- char *tmpbuf;
-
- OBD_ALLOC(kbuf, UUID_MAX);
- if (kbuf == NULL)
- return -ENOMEM;
-
- /*
- * OBD_ALLOC() will zero kbuf, but we only copy UUID_MAX - 1
- * bytes into kbuf, to ensure that the string is NUL-terminated.
- * UUID_MAX should include a trailing NUL already.
- */
- if (cfs_copy_from_user(kbuf, buffer,
- min_t(unsigned long, UUID_MAX - 1, count))) {
- count = -EFAULT;
- goto out;
- }
- tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, UUID_MAX - 1, count));
-
- OBD_ALLOC(uuid, UUID_MAX);
- if (uuid == NULL) {
- count = -ENOMEM;
- goto out;
- }
-
- obd_str2uuid(uuid, tmpbuf);
- exp = cfs_hash_lookup(obd->obd_uuid_hash, uuid);
- if (exp == NULL) {
- CERROR("%s: no export %s found\n",
- obd->obd_name, obd_uuid2str(uuid));
- } else {
- mdt_hsm_copytool_send(exp);
- class_export_put(exp);
- }
-
- OBD_FREE(uuid, UUID_MAX);
-out:
- OBD_FREE(kbuf, UUID_MAX);
- return count;
-}
-
static int lprocfs_rd_enable_remote_dir(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
if (rc)
return rc;
- if (val < 0 || val > 1)
+ if (val > 1)
return -ERANGE;
mdt->mdt_enable_remote_dir = val;
}
static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
- { "uuid", lprocfs_rd_uuid, 0, 0 },
- { "recovery_status", lprocfs_obd_rd_recovery_status, 0, 0 },
- { "num_exports", lprocfs_rd_num_exports, 0, 0 },
- { "identity_expire", lprocfs_rd_identity_expire,
- lprocfs_wr_identity_expire, 0 },
- { "identity_acquire_expire", lprocfs_rd_identity_acquire_expire,
- lprocfs_wr_identity_acquire_expire, 0 },
- { "identity_upcall", lprocfs_rd_identity_upcall,
- lprocfs_wr_identity_upcall, 0 },
- { "identity_flush", 0, lprocfs_wr_identity_flush, 0 },
- { "identity_info", 0, lprocfs_wr_identity_info, 0 },
- { "capa", lprocfs_rd_capa,
- lprocfs_wr_capa, 0 },
- { "capa_timeout", lprocfs_rd_capa_timeout,
- lprocfs_wr_capa_timeout, 0 },
- { "capa_key_timeout", lprocfs_rd_ck_timeout,
- lprocfs_wr_ck_timeout, 0 },
- { "capa_count", lprocfs_rd_capa_count, 0, 0 },
- { "site_stats", lprocfs_rd_site_stats, 0, 0 },
- { "evict_client", 0, lprocfs_mdt_wr_evict_client, 0 },
- { "hash_stats", lprocfs_obd_rd_hash, 0, 0 },
- { "sec_level", lprocfs_rd_sec_level,
- lprocfs_wr_sec_level, 0 },
- { "commit_on_sharing", lprocfs_rd_cos, lprocfs_wr_cos, 0 },
- { "root_squash", lprocfs_rd_root_squash,
- lprocfs_wr_root_squash, 0 },
- { "nosquash_nids", lprocfs_rd_nosquash_nids,
- lprocfs_wr_nosquash_nids, 0 },
- { "som", lprocfs_rd_mdt_som,
- lprocfs_wr_mdt_som, 0 },
- { "mdccomm", 0, lprocfs_mdt_wr_mdc, 0 },
- { "instance", lprocfs_target_rd_instance, 0 },
- { "ir_factor", lprocfs_obd_rd_ir_factor,
- lprocfs_obd_wr_ir_factor, 0 },
+ { "uuid", lprocfs_rd_uuid, NULL,
+ NULL, NULL, 0 },
+ { "recovery_status", lprocfs_obd_rd_recovery_status, NULL,
+ NULL, NULL, 0 },
+ { "num_exports", lprocfs_rd_num_exports, NULL,
+ NULL, NULL, 0 },
+ { "identity_expire", lprocfs_rd_identity_expire,
+ lprocfs_wr_identity_expire,
+ NULL, NULL, 0 },
+ { "identity_acquire_expire", lprocfs_rd_identity_acquire_expire,
+ lprocfs_wr_identity_acquire_expire,
+ NULL, NULL, 0 },
+ { "identity_upcall", lprocfs_rd_identity_upcall,
+ lprocfs_wr_identity_upcall,
+ NULL, NULL, 0 },
+ { "identity_flush", NULL, lprocfs_wr_identity_flush,
+ NULL, NULL, 0 },
+ { "identity_info", NULL, lprocfs_wr_identity_info,
+ NULL, NULL, 0 },
+ { "capa", lprocfs_rd_capa,
+ lprocfs_wr_capa,
+ NULL, NULL, 0 },
+ { "capa_timeout", lprocfs_rd_capa_timeout,
+ lprocfs_wr_capa_timeout,
+ NULL, NULL, 0 },
+ { "capa_key_timeout", lprocfs_rd_ck_timeout,
+ lprocfs_wr_ck_timeout,
+ NULL, NULL, 0 },
+ { "capa_count", lprocfs_rd_capa_count, NULL,
+ NULL, NULL, 0 },
+ { "site_stats", lprocfs_rd_site_stats, NULL,
+ NULL, NULL, 0 },
+ { "evict_client", NULL, lprocfs_mdt_wr_evict_client,
+ NULL, NULL, 0 },
+ { "hash_stats", lprocfs_obd_rd_hash, NULL,
+ NULL, NULL, 0 },
+ { "sec_level", lprocfs_rd_sec_level,
+ lprocfs_wr_sec_level,
+ NULL, NULL, 0 },
+ { "commit_on_sharing", lprocfs_rd_cos, lprocfs_wr_cos,
+ NULL, NULL, 0 },
+ { "root_squash", lprocfs_rd_root_squash,
+ lprocfs_wr_root_squash,
+ NULL, NULL, 0 },
+ { "nosquash_nids", lprocfs_rd_nosquash_nids,
+ lprocfs_wr_nosquash_nids,
+ NULL, NULL, 0 },
+ { "som", lprocfs_rd_mdt_som,
+ lprocfs_wr_mdt_som,
+ NULL, NULL, 0 },
+ { "instance", lprocfs_target_rd_instance, NULL,
+ NULL, NULL, 0},
+ { "ir_factor", lprocfs_obd_rd_ir_factor,
+ lprocfs_obd_wr_ir_factor,
+ NULL, NULL, 0 },
{ "job_cleanup_interval", lprocfs_rd_job_interval,
- lprocfs_wr_job_interval, 0 },
+ lprocfs_wr_job_interval,
+ NULL, NULL, 0 },
{ "enable_remote_dir", lprocfs_rd_enable_remote_dir,
- lprocfs_wr_enable_remote_dir, 0},
+ lprocfs_wr_enable_remote_dir,
+ NULL, NULL, 0},
{ "enable_remote_dir_gid", lprocfs_rd_enable_remote_dir_gid,
- lprocfs_wr_enable_remote_dir_gid, 0},
+ lprocfs_wr_enable_remote_dir_gid,
+ NULL, NULL, 0},
+ { "hsm_control", lprocfs_rd_hsm_cdt_control,
+ lprocfs_wr_hsm_cdt_control,
+ NULL, NULL, 0 },
{ 0 }
};
static struct lprocfs_vars lprocfs_mdt_module_vars[] = {
- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
+ { "num_refs", lprocfs_rd_numrefs, NULL,
+ NULL, NULL, 0 },
{ 0 }
};
}
struct lprocfs_vars lprocfs_mds_obd_vars[] = {
- { "uuid", lprocfs_rd_uuid, 0, 0 },
+ { "uuid", lprocfs_rd_uuid, NULL, NULL, NULL, 0 },
{ 0 }
};
struct lprocfs_vars lprocfs_mds_module_vars[] = {
- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
+ { "num_refs", lprocfs_rd_numrefs, NULL, NULL, NULL, 0 },
{ 0 }
};
+int lprocfs_mdt_print_open_files(cfs_hash_t *hs, cfs_hash_bd_t *bd,
+ cfs_hlist_node_t *hnode, void *v)
+{
+ struct obd_export *exp = cfs_hash_object(hs, hnode);
+ struct seq_file *seq = v;
+
+ if (exp->exp_lock_hash != NULL) {
+ struct mdt_export_data *med = &exp->exp_mdt_data;
+ struct mdt_file_data *mfd;
+
+ spin_lock(&med->med_open_lock);
+ cfs_list_for_each_entry(mfd, &med->med_open_head, mfd_list) {
+ seq_printf(seq, DFID"\n",
+ PFID(mdt_object_fid(mfd->mfd_object)));
+ }
+ spin_unlock(&med->med_open_lock);
+ }
+
+ return 0;
+}
+
+int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
+{
+ struct nid_stat *stats = seq->private;
+ struct obd_device *obd = stats->nid_obd;
+
+ cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
+ lprocfs_mdt_print_open_files, seq);
+
+ return 0;
+}
+
+int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file)
+{
+ struct proc_dir_entry *dp = PDE(inode);
+ struct seq_file *seq;
+ struct nid_stat *tmp;
+ int rc;
+
+ if (LPROCFS_ENTRY_CHECK(dp))
+ return -ENOENT;
+
+ tmp = dp->data;
+ rc = single_open(file, &lprocfs_mdt_open_files_seq_show, NULL);
+ if (rc != 0)
+ return rc;
+
+ seq = file->private_data;
+ seq->private = tmp;
+
+ return 0;
+}
+
void mdt_counter_incr(struct ptlrpc_request *req, int opcode)
{
struct obd_export *exp = req->rq_export;
- if (exp->exp_obd && exp->exp_obd->md_stats)
- lprocfs_counter_incr(exp->exp_obd->md_stats, opcode);
+ if (exp->exp_obd && exp->exp_obd->obd_md_stats)
+ lprocfs_counter_incr(exp->exp_obd->obd_md_stats, opcode);
if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
lprocfs_counter_incr(exp->exp_nid_stats->nid_stats, opcode);
if (exp->exp_obd && exp->exp_obd->u.obt.obt_jobstats.ojs_hash &&
git://git.whamcloud.com / fs / lustre-release.git / blobdiff