[linux-2.6-block.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,
};

void seq_printf_with_thousands_grouping(struct seq_file *seq, long v)
{
	/* v is in kB/sec. We don't expect TiByte/sec yet. */
	if (unlikely(v >= 1000000)) {
		/* cool: > GiByte/s */
		seq_printf(seq, "%ld,", v / 1000000);
		v /= 1000000;
		seq_printf(seq, "%03ld,%03ld", v/1000, v % 1000);
	} else if (likely(v >= 1000))
		seq_printf(seq, "%ld,%03ld", v/1000, v % 1000);
	else
		seq_printf(seq, "%ld", v);
}

/*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, "] ");

	if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
		seq_printf(seq, "verified:");
	else
		seq_printf(seq, "sync'ed:");
	seq_printf(seq, "%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. */
	/* ------------------------ ~18s average ------------------------ */
	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);

	dbdt = Bit2KB(db/dt);
	seq_printf(seq, " speed: ");
	seq_printf_with_thousands_grouping(seq, dbdt);
	seq_printf(seq, " (");
	/* ------------------------- ~3s average ------------------------ */
	if (proc_details >= 1) {
		/* this is what drbd_rs_should_slow_down() uses */
		i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
		dt = (jiffies - mdev->rs_mark_time[i]) / HZ;
		if (!dt)
			dt++;
		db = mdev->rs_mark_left[i] - rs_left;
		dbdt = Bit2KB(db/dt);
		seq_printf_with_thousands_grouping(seq, dbdt);
		seq_printf(seq, " -- ");
	}

	/* --------------------- long term average ---------------------- */
	/* 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);
	seq_printf_with_thousands_grouping(seq, dbdt);
	seq_printf(seq, ")");

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

	if (proc_details >= 1) {
		/* 64 bit:
		 * we convert to sectors in the display below. */
		u64 bm_bits = drbd_bm_bits(mdev);
		u64 bit_pos;
		if (mdev->state.conn == C_VERIFY_S ||
		    mdev->state.conn == C_VERIFY_T)
			bit_pos = bm_bits - mdev->ov_left;
		else
			bit_pos = mdev->bm_resync_fo;
		/* Total sectors may be slightly off for oddly
		 * sized devices. So what. */
		seq_printf(seq,
			"\t%3d%% sector pos: %llu/%llu\n",
			(int)(bit_pos / (bm_bits/100+1)),
			(unsigned long long) BM_BIT_TO_SECT(bit_pos),
			(unsigned long long) BM_BIT_TO_SECT(bm_bits));
	}
}

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:%llu\n",
				   Bit2KB((unsigned long long)
					   drbd_bm_total_weight(mdev)));
		}
		if (mdev->state.conn == C_SYNC_SOURCE ||
		    mdev->state.conn == C_SYNC_TARGET ||
		    mdev->state.conn == C_VERIFY_S ||
		    mdev->state.conn == C_VERIFY_T)
			drbd_syncer_progress(mdev, seq);

		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
439d5953 LE	48	void seq_printf_with_thousands_grouping(struct seq_file *seq, long v)
	49	{
	50	/* v is in kB/sec. We don't expect TiByte/sec yet. */
	51	if (unlikely(v >= 1000000)) {
	52	/* cool: > GiByte/s */
	53	seq_printf(seq, "%ld,", v / 1000000);
	54	v /= 1000000;
	55	seq_printf(seq, "%03ld,%03ld", v/1000, v % 1000);
	56	} else if (likely(v >= 1000))
	57	seq_printf(seq, "%ld,%03ld", v/1000, v % 1000);
	58	else
	59	seq_printf(seq, "%ld", v);
	60	}
b411b363 PR	61
	62	/*lge
	63	* progress bars shamelessly adapted from driver/md/md.c
	64	* output looks like
	65	* [=====>..............] 33.5% (23456/123456)
	66	* finish: 2:20:20 speed: 6,345 (6,456) K/sec
	67	*/
	68	static void drbd_syncer_progress(struct drbd_conf mdev, struct seq_file seq)
	69	{
	70	unsigned long db, dt, dbdt, rt, rs_left;
	71	unsigned int res;
	72	int i, x, y;
1d7734a0	73	int stalled = 0;
b411b363 PR	74
	75	drbd_get_syncer_progress(mdev, &rs_left, &res);
	76
	77	x = res/50;
	78	y = 20-x;
	79	seq_printf(seq, "\t[");
	80	for (i = 1; i < x; i++)
	81	seq_printf(seq, "=");
	82	seq_printf(seq, ">");
	83	for (i = 0; i < y; i++)
	84	seq_printf(seq, ".");
	85	seq_printf(seq, "] ");
	86
5f9915bb LE	87	if (mdev->state.conn == C_VERIFY_S \|\| mdev->state.conn == C_VERIFY_T)
	88	seq_printf(seq, "verified:");
	89	else
	90	seq_printf(seq, "sync'ed:");
	91	seq_printf(seq, "%3u.%u%% ", res / 10, res % 10);
	92
b411b363 PR	93	/* if more than 1 GB display in MB */
b411b363 PR	94	if (mdev->rs_total > 0x100000L)
e7f52dfb	95	seq_printf(seq, "(%lu/%lu)M\n\t",
b411b363 PR	96	(unsigned long) Bit2KB(rs_left >> 10),
	97	(unsigned long) Bit2KB(mdev->rs_total >> 10));
	98	else
e7f52dfb	99	seq_printf(seq, "(%lu/%lu)K\n\t",
b411b363 PR	100	(unsigned long) Bit2KB(rs_left),
	101	(unsigned long) Bit2KB(mdev->rs_total));
	102
	103	/* see drivers/md/md.c
	104	* We do not want to overflow, so the order of operands and
	105	* the * 100 / 100 trick are important. We do a +1 to be
	106	* safe against division by zero. We only estimate anyway.
	107	*
	108	* dt: time from mark until now
	109	* db: blocks written from mark until now
	110	* rt: remaining time
	111	*/
1d7734a0 LE	112	/* Rolling marks. last_mark+1 may just now be modified. last_mark+2 is
	113	* at least (DRBD_SYNC_MARKS-2)*DRBD_SYNC_MARK_STEP old, and has at
	114	* least DRBD_SYNC_MARK_STEP time before it will be modified. */
439d5953	115	/* ------------------------ ~18s average ------------------------ */
1d7734a0 LE	116	i = (mdev->rs_last_mark + 2) % DRBD_SYNC_MARKS;
	117	dt = (jiffies - mdev->rs_mark_time[i]) / HZ;
	118	if (dt > (DRBD_SYNC_MARK_STEP * DRBD_SYNC_MARKS))
	119	stalled = 1;
b411b363 PR	120
	121	if (!dt)
	122	dt++;
1d7734a0	123	db = mdev->rs_mark_left[i] - rs_left;
b411b363 PR	124	rt = (dt * (rs_left / (db/100+1)))/100; /* seconds */
	125
	126	seq_printf(seq, "finish: %lu:%02lu:%02lu",
	127	rt / 3600, (rt % 3600) / 60, rt % 60);
	128
b411b363	129	dbdt = Bit2KB(db/dt);
439d5953 LE	130	seq_printf(seq, " speed: ");
	131	seq_printf_with_thousands_grouping(seq, dbdt);
	132	seq_printf(seq, " (");
	133	/* ------------------------- ~3s average ------------------------ */
	134	if (proc_details >= 1) {
	135	/* this is what drbd_rs_should_slow_down() uses */
	136	i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
	137	dt = (jiffies - mdev->rs_mark_time[i]) / HZ;
439d5953 LE	138	if (!dt)
	139	dt++;
	140	db = mdev->rs_mark_left[i] - rs_left;
439d5953 LE	141	dbdt = Bit2KB(db/dt);
	142	seq_printf_with_thousands_grouping(seq, dbdt);
	143	seq_printf(seq, " -- ");
	144	}
b411b363	145
439d5953	146	/* --------------------- long term average ---------------------- */
b411b363 PR	147	/* mean speed since syncer started
	148	* we do account for PausedSync periods */
	149	dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ;
22657695	150	if (dt == 0)
b411b363 PR	151	dt = 1;
	152	db = mdev->rs_total - rs_left;
	153	dbdt = Bit2KB(db/dt);
439d5953 LE	154	seq_printf_with_thousands_grouping(seq, dbdt);
439d5953 LE	155	seq_printf(seq, ")");
b411b363	156
2649f080 LE	157	if (mdev->state.conn == C_SYNC_TARGET \|\|
2649f080 LE	158	mdev->state.conn == C_VERIFY_S) {
5f9915bb LE	159	seq_printf(seq, " want: ");
5f9915bb LE	160	seq_printf_with_thousands_grouping(seq, mdev->c_sync_rate);
1d7734a0 LE	161	}
1d7734a0 LE	162	seq_printf(seq, " K/sec%s\n", stalled ? " (stalled)" : "");
5f9915bb LE	163
	164	if (proc_details >= 1) {
	165	/* 64 bit:
	166	* we convert to sectors in the display below. */
	167	u64 bm_bits = drbd_bm_bits(mdev);
	168	u64 bit_pos;
	169	if (mdev->state.conn == C_VERIFY_S \|\|
	170	mdev->state.conn == C_VERIFY_T)
	171	bit_pos = bm_bits - mdev->ov_left;
	172	else
	173	bit_pos = mdev->bm_resync_fo;
	174	/* Total sectors may be slightly off for oddly
	175	* sized devices. So what. */
	176	seq_printf(seq,
	177	"\t%3d%% sector pos: %llu/%llu\n",
	178	(int)(bit_pos / (bm_bits/100+1)),
	179	(unsigned long long) BM_BIT_TO_SECT(bit_pos),
	180	(unsigned long long) BM_BIT_TO_SECT(bm_bits));
	181	}
b411b363 PR	182	}
	183
	184	static void resync_dump_detail(struct seq_file seq, struct lc_element e)
	185	{
	186	struct bm_extent *bme = lc_entry(e, struct bm_extent, lce);
	187
	188	seq_printf(seq, "%5d %s %s\n", bme->rs_left,
	189	bme->flags & BME_NO_WRITES ? "NO_WRITES" : "---------",
	190	bme->flags & BME_LOCKED ? "LOCKED" : "------"
	191	);
	192	}
	193
	194	static int drbd_seq_show(struct seq_file seq, void v)
	195	{
	196	int i, hole = 0;
	197	const char *sn;
	198	struct drbd_conf *mdev;
	199
	200	static char write_ordering_chars[] = {
	201	[WO_none] = 'n',
	202	[WO_drain_io] = 'd',
	203	[WO_bdev_flush] = 'f',
b411b363 PR	204	};
	205
	206	seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",
	207	API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX, drbd_buildtag());
	208
	209	/*
	210	cs .. connection state
	211	ro .. node role (local/remote)
	212	ds .. disk state (local/remote)
	213	protocol
	214	various flags
	215	ns .. network send
	216	nr .. network receive
	217	dw .. disk write
	218	dr .. disk read
	219	al .. activity log write count
	220	bm .. bitmap update write count
	221	pe .. pending (waiting for ack or data reply)
	222	ua .. unack'd (still need to send ack or data reply)
	223	ap .. application requests accepted, but not yet completed
	224	ep .. number of epochs currently "on the fly", P_BARRIER_ACK pending
	225	wo .. write ordering mode currently in use
	226	oos .. known out-of-sync kB
	227	*/
	228
	229	for (i = 0; i < minor_count; i++) {
	230	mdev = minor_to_mdev(i);
	231	if (!mdev) {
	232	hole = 1;
	233	continue;
	234	}
	235	if (hole) {
	236	hole = 0;
	237	seq_printf(seq, "\n");
	238	}
	239
	240	sn = drbd_conn_str(mdev->state.conn);
	241
	242	if (mdev->state.conn == C_STANDALONE &&
	243	mdev->state.disk == D_DISKLESS &&
	244	mdev->state.role == R_SECONDARY) {
	245	seq_printf(seq, "%2d: cs:Unconfigured\n", i);
	246	} else {
	247	seq_printf(seq,
0778286a	248	"%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
b411b363 PR	249	" ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
	250	"lo:%d pe:%d ua:%d ap:%d ep:%d wo:%c",
	251	i, sn,
	252	drbd_role_str(mdev->state.role),
	253	drbd_role_str(mdev->state.peer),
	254	drbd_disk_str(mdev->state.disk),
	255	drbd_disk_str(mdev->state.pdsk),
	256	(mdev->net_conf == NULL ? ' ' :
	257	(mdev->net_conf->wire_protocol - DRBD_PROT_A+'A')),
fb22c402	258	is_susp(mdev->state) ? 's' : 'r',
b411b363 PR	259	mdev->state.aftr_isp ? 'a' : '-',
	260	mdev->state.peer_isp ? 'p' : '-',
	261	mdev->state.user_isp ? 'u' : '-',
	262	mdev->congestion_reason ?: '-',
0778286a	263	test_bit(AL_SUSPENDED, &mdev->flags) ? 's' : '-',
b411b363 PR	264	mdev->send_cnt/2,
	265	mdev->recv_cnt/2,
	266	mdev->writ_cnt/2,
	267	mdev->read_cnt/2,
	268	mdev->al_writ_cnt,
	269	mdev->bm_writ_cnt,
	270	atomic_read(&mdev->local_cnt),
	271	atomic_read(&mdev->ap_pending_cnt) +
	272	atomic_read(&mdev->rs_pending_cnt),
	273	atomic_read(&mdev->unacked_cnt),
	274	atomic_read(&mdev->ap_bio_cnt),
	275	mdev->epochs,
	276	write_ordering_chars[mdev->write_ordering]
	277	);
18edc0b9 LE	278	seq_printf(seq, " oos:%llu\n",
	279	Bit2KB((unsigned long long)
	280	drbd_bm_total_weight(mdev)));
b411b363 PR	281	}
b411b363 PR	282	if (mdev->state.conn == C_SYNC_SOURCE \|\|
439d5953 LE	283	mdev->state.conn == C_SYNC_TARGET \|\|
	284	mdev->state.conn == C_VERIFY_S \|\|
	285	mdev->state.conn == C_VERIFY_T)
b411b363 PR	286	drbd_syncer_progress(mdev, seq);
b411b363 PR	287
b411b363 PR	288	if (proc_details >= 1 && get_ldev_if_state(mdev, D_FAILED)) {
	289	lc_seq_printf_stats(seq, mdev->resync);
	290	lc_seq_printf_stats(seq, mdev->act_log);
	291	put_ldev(mdev);
	292	}
	293
	294	if (proc_details >= 2) {
	295	if (mdev->resync) {
	296	lc_seq_dump_details(seq, mdev->resync, "rs_left",
	297	resync_dump_detail);
	298	}
	299	}
	300	}
	301
	302	return 0;
	303	}
	304
	305	static int drbd_proc_open(struct inode inode, struct file file)
	306	{
	307	return single_open(file, drbd_seq_show, PDE(inode)->data);
	308	}
	309
	310	/* PROC FS stuff end */