X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_lproc.c;h=0ee5148906a8ea8c33fb8494ac21d9485046fcb0;hb=94cb946d1360c0df541423ec10487545e4697aa7;hp=f83366bc1b7683fa0fa8a1dfa6cdbfae6068e962;hpb=1b2547843817b4b7adbeb87ea9b070d9cac35c90;p=fs%2Flustre-release.git

diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
index f83366b..0ee5148 100644
--- a/lustre/mdt/mdt_lproc.c
+++ b/lustre/mdt/mdt_lproc.c
@@ -59,7 +59,6 @@
 #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>
@@ -226,10 +225,17 @@ int mdt_procfs_init(struct mdt_device *mdt, const char *name)
 	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);
@@ -240,7 +246,7 @@ int mdt_procfs_init(struct mdt_device *mdt, const char *name)
 	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);
@@ -257,15 +263,16 @@ void mdt_procfs_fini(struct mdt_device *mdt)
 {
 	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);
 }
 
@@ -466,12 +473,12 @@ out:
 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,
@@ -501,15 +508,17 @@ 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;
 }
 
@@ -624,7 +633,7 @@ static int lprocfs_rd_sec_level(char *page, char **start, off_t off,
         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,
@@ -647,8 +656,8 @@ 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,
@@ -894,54 +903,6 @@ static int lprocfs_wr_mdt_som(struct file *file, const char *buffer,
         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 (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)
 {
@@ -963,7 +924,7 @@ static int lprocfs_wr_enable_remote_dir(struct file *file, const char *buffer,
 	if (rc)
 		return rc;
 
-	if (val < 0 || val > 1)
+	if (val > 1)
 		return -ERANGE;
 
 	mdt->mdt_enable_remote_dir = val;
@@ -998,51 +959,79 @@ static int lprocfs_wr_enable_remote_dir_gid(struct file *file,
 }
 
 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 }
 };
 
@@ -1053,21 +1042,74 @@ void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars)
 }
 
 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 &&