[net-next-2.6.git] / drivers / block / drbd / drbd_proc.c

/*
   drbd_proc.c

   This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

   Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
   Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
   Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.

   drbd is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   drbd is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with drbd; see the file COPYING.  If not, write to
   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/module.h>

#include <asm/uaccess.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/drbd.h>
#include "drbd_int.h"

static int drbd_proc_open(struct inode *inode, struct file *file);


struct proc_dir_entry *drbd_proc;
const struct file_operations drbd_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= drbd_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};


/*lge
 * progress bars shamelessly adapted from driver/md/md.c
 * output looks like
 *	[=====>..............] 33.5% (23456/123456)
 *	finish: 2:20:20 speed: 6,345 (6,456) K/sec
 */
static void drbd_syncer_progress(struct drbd_conf *mdev, struct seq_file *seq)
{
	unsigned long db, dt, dbdt, rt, rs_left;
	unsigned int res;
	int i, x, y;
	int stalled = 0;

	drbd_get_syncer_progress(mdev, &rs_left, &res);

	x = res/50;
	y = 20-x;
	seq_printf(seq, "\t[");
	for (i = 1; i < x; i++)
		seq_printf(seq, "=");
	seq_printf(seq, ">");
	for (i = 0; i < y; i++)
		seq_printf(seq, ".");
	seq_printf(seq, "] ");

	seq_printf(seq, "sync'ed:%3u.%u%% ", res / 10, res % 10);
	/* if more than 1 GB display in MB */
	if (mdev->rs_total > 0x100000L)
		seq_printf(seq, "(%lu/%lu)M\n\t",
			    (unsigned long) Bit2KB(rs_left >> 10),
			    (unsigned long) Bit2KB(mdev->rs_total >> 10));
	else
		seq_printf(seq, "(%lu/%lu)K\n\t",
			    (unsigned long) Bit2KB(rs_left),
			    (unsigned long) Bit2KB(mdev->rs_total));

	/* see drivers/md/md.c
	 * We do not want to overflow, so the order of operands and
	 * the * 100 / 100 trick are important. We do a +1 to be
	 * safe against division by zero. We only estimate anyway.
	 *
	 * dt: time from mark until now
	 * db: blocks written from mark until now
	 * rt: remaining time
	 */
	/* Rolling marks. last_mark+1 may just now be modified.  last_mark+2 is
	 * at least (DRBD_SYNC_MARKS-2)*DRBD_SYNC_MARK_STEP old, and has at
	 * least DRBD_SYNC_MARK_STEP time before it will be modified. */
	i = (mdev->rs_last_mark + 2) % DRBD_SYNC_MARKS;
	dt = (jiffies - mdev->rs_mark_time[i]) / HZ;
	if (dt > (DRBD_SYNC_MARK_STEP * DRBD_SYNC_MARKS))
		stalled = 1;

	if (!dt)
		dt++;
	db = mdev->rs_mark_left[i] - rs_left;
	rt = (dt * (rs_left / (db/100+1)))/100; /* seconds */

	seq_printf(seq, "finish: %lu:%02lu:%02lu",
		rt / 3600, (rt % 3600) / 60, rt % 60);

	/* current speed average over (SYNC_MARKS * SYNC_MARK_STEP) jiffies */
	dbdt = Bit2KB(db/dt);
	if (dbdt > 1000)
		seq_printf(seq, " speed: %ld,%03ld",
			dbdt/1000, dbdt % 1000);
	else
		seq_printf(seq, " speed: %ld", dbdt);

	/* mean speed since syncer started
	 * we do account for PausedSync periods */
	dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ;
	if (dt == 0)
		dt = 1;
	db = mdev->rs_total - rs_left;
	dbdt = Bit2KB(db/dt);
	if (dbdt > 1000)
		seq_printf(seq, " (%ld,%03ld)",
			dbdt/1000, dbdt % 1000);
	else
		seq_printf(seq, " (%ld)", dbdt);

	if (mdev->state.conn == C_SYNC_TARGET) {
		if (mdev->c_sync_rate > 1000)
			seq_printf(seq, " want: %d,%03d",
				   mdev->c_sync_rate / 1000, mdev->c_sync_rate % 1000);
		else
			seq_printf(seq, " want: %d", mdev->c_sync_rate);
	}
	seq_printf(seq, " K/sec%s\n", stalled ? " (stalled)" : "");
}

static void resync_dump_detail(struct seq_file *seq, struct lc_element *e)
{
	struct bm_extent *bme = lc_entry(e, struct bm_extent, lce);

	seq_printf(seq, "%5d %s %s\n", bme->rs_left,
		   bme->flags & BME_NO_WRITES ? "NO_WRITES" : "---------",
		   bme->flags & BME_LOCKED ? "LOCKED" : "------"
		   );
}

static int drbd_seq_show(struct seq_file *seq, void *v)
{
	int i, hole = 0;
	const char *sn;
	struct drbd_conf *mdev;

	static char write_ordering_chars[] = {
		[WO_none] = 'n',
		[WO_drain_io] = 'd',
		[WO_bdev_flush] = 'f',
	};

	seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",
		   API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX, drbd_buildtag());

	/*
	  cs .. connection state
	  ro .. node role (local/remote)
	  ds .. disk state (local/remote)
	     protocol
	     various flags
	  ns .. network send
	  nr .. network receive
	  dw .. disk write
	  dr .. disk read
	  al .. activity log write count
	  bm .. bitmap update write count
	  pe .. pending (waiting for ack or data reply)
	  ua .. unack'd (still need to send ack or data reply)
	  ap .. application requests accepted, but not yet completed
	  ep .. number of epochs currently "on the fly", P_BARRIER_ACK pending
	  wo .. write ordering mode currently in use
	 oos .. known out-of-sync kB
	*/

	for (i = 0; i < minor_count; i++) {
		mdev = minor_to_mdev(i);
		if (!mdev) {
			hole = 1;
			continue;
		}
		if (hole) {
			hole = 0;
			seq_printf(seq, "\n");
		}

		sn = drbd_conn_str(mdev->state.conn);

		if (mdev->state.conn == C_STANDALONE &&
		    mdev->state.disk == D_DISKLESS &&
		    mdev->state.role == R_SECONDARY) {
			seq_printf(seq, "%2d: cs:Unconfigured\n", i);
		} else {
			seq_printf(seq,
			   "%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
			   "    ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
			   "lo:%d pe:%d ua:%d ap:%d ep:%d wo:%c",
			   i, sn,
			   drbd_role_str(mdev->state.role),
			   drbd_role_str(mdev->state.peer),
			   drbd_disk_str(mdev->state.disk),
			   drbd_disk_str(mdev->state.pdsk),
			   (mdev->net_conf == NULL ? ' ' :
			    (mdev->net_conf->wire_protocol - DRBD_PROT_A+'A')),
			   is_susp(mdev->state) ? 's' : 'r',
			   mdev->state.aftr_isp ? 'a' : '-',
			   mdev->state.peer_isp ? 'p' : '-',
			   mdev->state.user_isp ? 'u' : '-',
			   mdev->congestion_reason ?: '-',
			   test_bit(AL_SUSPENDED, &mdev->flags) ? 's' : '-',
			   mdev->send_cnt/2,
			   mdev->recv_cnt/2,
			   mdev->writ_cnt/2,
			   mdev->read_cnt/2,
			   mdev->al_writ_cnt,
			   mdev->bm_writ_cnt,
			   atomic_read(&mdev->local_cnt),
			   atomic_read(&mdev->ap_pending_cnt) +
			   atomic_read(&mdev->rs_pending_cnt),
			   atomic_read(&mdev->unacked_cnt),
			   atomic_read(&mdev->ap_bio_cnt),
			   mdev->epochs,
			   write_ordering_chars[mdev->write_ordering]
			);
			seq_printf(seq, " oos:%lu\n",
				   Bit2KB(drbd_bm_total_weight(mdev)));
		}
		if (mdev->state.conn == C_SYNC_SOURCE ||
		    mdev->state.conn == C_SYNC_TARGET)
			drbd_syncer_progress(mdev, seq);

		if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
			seq_printf(seq, "\t%3d%%      %lu/%lu\n",
				   (int)((mdev->rs_total-mdev->ov_left) /
					 (mdev->rs_total/100+1)),
				   mdev->rs_total - mdev->ov_left,
				   mdev->rs_total);

		if (proc_details >= 1 && get_ldev_if_state(mdev, D_FAILED)) {
			lc_seq_printf_stats(seq, mdev->resync);
			lc_seq_printf_stats(seq, mdev->act_log);
			put_ldev(mdev);
		}

		if (proc_details >= 2) {
			if (mdev->resync) {
				lc_seq_dump_details(seq, mdev->resync, "rs_left",
					resync_dump_detail);
			}
		}
	}

	return 0;
}

static int drbd_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, drbd_seq_show, PDE(inode)->data);
}

/* PROC FS stuff end */
Commit	Line	Data
b411b363 PR	1	/*
	2	drbd_proc.c
	3
	4	This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
	5
	6	Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
	7	Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
	8	Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
	9
	10	drbd is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2, or (at your option)
	13	any later version.
	14
	15	drbd is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with drbd; see the file COPYING. If not, write to
	22	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
	23
	24	*/
	25
b411b363 PR	26	#include <linux/module.h>
	27
	28	#include <asm/uaccess.h>
	29	#include <linux/fs.h>
	30	#include <linux/file.h>
b411b363 PR	31	#include <linux/proc_fs.h>
	32	#include <linux/seq_file.h>
	33	#include <linux/drbd.h>
	34	#include "drbd_int.h"
	35
	36	static int drbd_proc_open(struct inode inode, struct file file);
	37
	38
	39	struct proc_dir_entry *drbd_proc;
7d4e9d09	40	const struct file_operations drbd_proc_fops = {
b411b363 PR	41	.owner = THIS_MODULE,
	42	.open = drbd_proc_open,
	43	.read = seq_read,
	44	.llseek = seq_lseek,
	45	.release = single_release,
	46	};
	47
	48
	49	/*lge
	50	* progress bars shamelessly adapted from driver/md/md.c
	51	* output looks like
	52	* [=====>..............] 33.5% (23456/123456)
	53	* finish: 2:20:20 speed: 6,345 (6,456) K/sec
	54	*/
	55	static void drbd_syncer_progress(struct drbd_conf mdev, struct seq_file seq)
	56	{
	57	unsigned long db, dt, dbdt, rt, rs_left;
	58	unsigned int res;
	59	int i, x, y;
1d7734a0	60	int stalled = 0;
b411b363 PR	61
	62	drbd_get_syncer_progress(mdev, &rs_left, &res);
	63
	64	x = res/50;
	65	y = 20-x;
	66	seq_printf(seq, "\t[");
	67	for (i = 1; i < x; i++)
	68	seq_printf(seq, "=");
	69	seq_printf(seq, ">");
	70	for (i = 0; i < y; i++)
	71	seq_printf(seq, ".");
	72	seq_printf(seq, "] ");
	73
	74	seq_printf(seq, "sync'ed:%3u.%u%% ", res / 10, res % 10);
	75	/* if more than 1 GB display in MB */
	76	if (mdev->rs_total > 0x100000L)
e7f52dfb	77	seq_printf(seq, "(%lu/%lu)M\n\t",
b411b363 PR	78	(unsigned long) Bit2KB(rs_left >> 10),
	79	(unsigned long) Bit2KB(mdev->rs_total >> 10));
	80	else
e7f52dfb	81	seq_printf(seq, "(%lu/%lu)K\n\t",
b411b363 PR	82	(unsigned long) Bit2KB(rs_left),
	83	(unsigned long) Bit2KB(mdev->rs_total));
	84
	85	/* see drivers/md/md.c
	86	* We do not want to overflow, so the order of operands and
	87	* the * 100 / 100 trick are important. We do a +1 to be
	88	* safe against division by zero. We only estimate anyway.
	89	*
	90	* dt: time from mark until now
	91	* db: blocks written from mark until now
	92	* rt: remaining time
	93	*/
1d7734a0 LE	94	/* Rolling marks. last_mark+1 may just now be modified. last_mark+2 is
	95	* at least (DRBD_SYNC_MARKS-2)*DRBD_SYNC_MARK_STEP old, and has at
	96	* least DRBD_SYNC_MARK_STEP time before it will be modified. */
	97	i = (mdev->rs_last_mark + 2) % DRBD_SYNC_MARKS;
	98	dt = (jiffies - mdev->rs_mark_time[i]) / HZ;
	99	if (dt > (DRBD_SYNC_MARK_STEP * DRBD_SYNC_MARKS))
	100	stalled = 1;
b411b363 PR	101
	102	if (!dt)
	103	dt++;
1d7734a0	104	db = mdev->rs_mark_left[i] - rs_left;
b411b363 PR	105	rt = (dt * (rs_left / (db/100+1)))/100; /* seconds */
	106
	107	seq_printf(seq, "finish: %lu:%02lu:%02lu",
	108	rt / 3600, (rt % 3600) / 60, rt % 60);
	109
	110	/* current speed average over (SYNC_MARKS * SYNC_MARK_STEP) jiffies */
	111	dbdt = Bit2KB(db/dt);
	112	if (dbdt > 1000)
	113	seq_printf(seq, " speed: %ld,%03ld",
	114	dbdt/1000, dbdt % 1000);
	115	else
	116	seq_printf(seq, " speed: %ld", dbdt);
	117
	118	/* mean speed since syncer started
	119	* we do account for PausedSync periods */
	120	dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ;
22657695	121	if (dt == 0)
b411b363 PR	122	dt = 1;
	123	db = mdev->rs_total - rs_left;
	124	dbdt = Bit2KB(db/dt);
	125	if (dbdt > 1000)
	126	seq_printf(seq, " (%ld,%03ld)",
	127	dbdt/1000, dbdt % 1000);
	128	else
	129	seq_printf(seq, " (%ld)", dbdt);
	130
1d7734a0 LE	131	if (mdev->state.conn == C_SYNC_TARGET) {
	132	if (mdev->c_sync_rate > 1000)
	133	seq_printf(seq, " want: %d,%03d",
	134	mdev->c_sync_rate / 1000, mdev->c_sync_rate % 1000);
	135	else
	136	seq_printf(seq, " want: %d", mdev->c_sync_rate);
	137	}
	138	seq_printf(seq, " K/sec%s\n", stalled ? " (stalled)" : "");
b411b363 PR	139	}
	140
	141	static void resync_dump_detail(struct seq_file seq, struct lc_element e)
	142	{
	143	struct bm_extent *bme = lc_entry(e, struct bm_extent, lce);
	144
	145	seq_printf(seq, "%5d %s %s\n", bme->rs_left,
	146	bme->flags & BME_NO_WRITES ? "NO_WRITES" : "---------",
	147	bme->flags & BME_LOCKED ? "LOCKED" : "------"
	148	);
	149	}
	150
	151	static int drbd_seq_show(struct seq_file seq, void v)
	152	{
	153	int i, hole = 0;
	154	const char *sn;
	155	struct drbd_conf *mdev;
	156
	157	static char write_ordering_chars[] = {
	158	[WO_none] = 'n',
	159	[WO_drain_io] = 'd',
	160	[WO_bdev_flush] = 'f',
b411b363 PR	161	};
	162
	163	seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",
	164	API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX, drbd_buildtag());
	165
	166	/*
	167	cs .. connection state
	168	ro .. node role (local/remote)
	169	ds .. disk state (local/remote)
	170	protocol
	171	various flags
	172	ns .. network send
	173	nr .. network receive
	174	dw .. disk write
	175	dr .. disk read
	176	al .. activity log write count
	177	bm .. bitmap update write count
	178	pe .. pending (waiting for ack or data reply)
	179	ua .. unack'd (still need to send ack or data reply)
	180	ap .. application requests accepted, but not yet completed
	181	ep .. number of epochs currently "on the fly", P_BARRIER_ACK pending
	182	wo .. write ordering mode currently in use
	183	oos .. known out-of-sync kB
	184	*/
	185
	186	for (i = 0; i < minor_count; i++) {
	187	mdev = minor_to_mdev(i);
	188	if (!mdev) {
	189	hole = 1;
	190	continue;
	191	}
	192	if (hole) {
	193	hole = 0;
	194	seq_printf(seq, "\n");
	195	}
	196
	197	sn = drbd_conn_str(mdev->state.conn);
	198
	199	if (mdev->state.conn == C_STANDALONE &&
	200	mdev->state.disk == D_DISKLESS &&
	201	mdev->state.role == R_SECONDARY) {
	202	seq_printf(seq, "%2d: cs:Unconfigured\n", i);
	203	} else {
	204	seq_printf(seq,
0778286a	205	"%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
b411b363 PR	206	" ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
	207	"lo:%d pe:%d ua:%d ap:%d ep:%d wo:%c",
	208	i, sn,
	209	drbd_role_str(mdev->state.role),
	210	drbd_role_str(mdev->state.peer),
	211	drbd_disk_str(mdev->state.disk),
	212	drbd_disk_str(mdev->state.pdsk),
	213	(mdev->net_conf == NULL ? ' ' :
	214	(mdev->net_conf->wire_protocol - DRBD_PROT_A+'A')),
fb22c402	215	is_susp(mdev->state) ? 's' : 'r',
b411b363 PR	216	mdev->state.aftr_isp ? 'a' : '-',
	217	mdev->state.peer_isp ? 'p' : '-',
	218	mdev->state.user_isp ? 'u' : '-',
	219	mdev->congestion_reason ?: '-',
0778286a	220	test_bit(AL_SUSPENDED, &mdev->flags) ? 's' : '-',
b411b363 PR	221	mdev->send_cnt/2,
	222	mdev->recv_cnt/2,
	223	mdev->writ_cnt/2,
	224	mdev->read_cnt/2,
	225	mdev->al_writ_cnt,
	226	mdev->bm_writ_cnt,
	227	atomic_read(&mdev->local_cnt),
	228	atomic_read(&mdev->ap_pending_cnt) +
	229	atomic_read(&mdev->rs_pending_cnt),
	230	atomic_read(&mdev->unacked_cnt),
	231	atomic_read(&mdev->ap_bio_cnt),
	232	mdev->epochs,
	233	write_ordering_chars[mdev->write_ordering]
	234	);
	235	seq_printf(seq, " oos:%lu\n",
	236	Bit2KB(drbd_bm_total_weight(mdev)));
	237	}
	238	if (mdev->state.conn == C_SYNC_SOURCE \|\|
	239	mdev->state.conn == C_SYNC_TARGET)
	240	drbd_syncer_progress(mdev, seq);
	241
	242	if (mdev->state.conn == C_VERIFY_S \|\| mdev->state.conn == C_VERIFY_T)
	243	seq_printf(seq, "\t%3d%% %lu/%lu\n",
	244	(int)((mdev->rs_total-mdev->ov_left) /
	245	(mdev->rs_total/100+1)),
	246	mdev->rs_total - mdev->ov_left,
	247	mdev->rs_total);
	248
	249	if (proc_details >= 1 && get_ldev_if_state(mdev, D_FAILED)) {
	250	lc_seq_printf_stats(seq, mdev->resync);
	251	lc_seq_printf_stats(seq, mdev->act_log);
	252	put_ldev(mdev);
	253	}
	254
	255	if (proc_details >= 2) {
	256	if (mdev->resync) {
	257	lc_seq_dump_details(seq, mdev->resync, "rs_left",
	258	resync_dump_detail);
	259	}
	260	}
	261	}
	262
	263	return 0;
	264	}
	265
	266	static int drbd_proc_open(struct inode inode, struct file file)
	267	{
	268	return single_open(file, drbd_seq_show, PDE(inode)->data);
	269	}
	270
	271	/* PROC FS stuff end */