[mirror_ubuntu-bionic-kernel.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);
static int drbd_proc_release(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	= drbd_proc_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 a few GB, display in MB */
	if (mdev->rs_total > (4UL << (30 - BM_BLOCK_SHIFT)))
		seq_printf(seq, "(%lu/%lu)M",
			    (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. */
		unsigned long bm_bits = drbd_bm_bits(mdev);
		unsigned long 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)bit_pos * BM_SECT_PER_BIT,
			(unsigned long long)bm_bits * BM_SECT_PER_BIT);
	}
}

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, prev_i = -1;
	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
	*/

	down_read(&drbd_cfg_rwsem);
	idr_for_each_entry(&minors, mdev, i) {
		if (prev_i != i - 1)
			seq_printf(seq, "\n");
		prev_i = i;

		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->tconn->net_conf == NULL ? ' ' :
			    (mdev->tconn->net_conf->wire_protocol - DRBD_PROT_A+'A')),
			   drbd_suspended(mdev) ? '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);
			}
		}
	}
	up_read(&drbd_cfg_rwsem);

	return 0;
}

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

static int drbd_proc_release(struct inode *inode, struct file *file)
{
	module_put(THIS_MODULE);
	return single_release(inode, file);
}

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