[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;
		unsigned long long stop_sector = 0;
		if (mdev->state.conn == C_VERIFY_S ||
		    mdev->state.conn == C_VERIFY_T) {
			bit_pos = bm_bits - mdev->ov_left;
			if (verify_can_do_stop_sector(mdev))
				stop_sector = mdev->ov_stop_sector;
		} 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",
			(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);
		if (stop_sector != 0 && stop_sector != ULLONG_MAX)
			seq_printf(seq, " stop sector: %llu", stop_sector);
		seq_printf(seq, "\n");
	}
}

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;
	struct net_conf *nc;
	char wp;

	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
	*/

	rcu_read_lock();
	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 {
			/* reset mdev->congestion_reason */
			bdi_rw_congested(&mdev->rq_queue->backing_dev_info);

			nc = rcu_dereference(mdev->tconn->net_conf);
			wp = nc ? nc->wire_protocol - DRBD_PROT_A + 'A' : ' ';
			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),
			   wp,
			   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->tconn->epochs,
			   write_ordering_chars[mdev->tconn->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);
			}
		}
	}
	rcu_read_unlock();

	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_DATA(inode));
	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);
fc251d5c	55	v %= 1000000;
439d5953 LE	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;
58ffa580	170	unsigned long long stop_sector = 0;
5f9915bb	171	if (mdev->state.conn == C_VERIFY_S \|\|
58ffa580	172	mdev->state.conn == C_VERIFY_T) {
5f9915bb	173	bit_pos = bm_bits - mdev->ov_left;
58ffa580 LE	174	if (verify_can_do_stop_sector(mdev))
	175	stop_sector = mdev->ov_stop_sector;
	176	} else
5f9915bb LE	177	bit_pos = mdev->bm_resync_fo;
	178	/* Total sectors may be slightly off for oddly
	179	* sized devices. So what. */
	180	seq_printf(seq,
58ffa580	181	"\t%3d%% sector pos: %llu/%llu",
5f9915bb	182	(int)(bit_pos / (bm_bits/100+1)),
4896e8c1 LE	183	(unsigned long long)bit_pos * BM_SECT_PER_BIT,
4896e8c1 LE	184	(unsigned long long)bm_bits * BM_SECT_PER_BIT);
58ffa580 LE	185	if (stop_sector != 0 && stop_sector != ULLONG_MAX)
	186	seq_printf(seq, " stop sector: %llu", stop_sector);
	187	seq_printf(seq, "\n");
5f9915bb	188	}
b411b363 PR	189	}
	190
	191	static void resync_dump_detail(struct seq_file seq, struct lc_element e)
	192	{
	193	struct bm_extent *bme = lc_entry(e, struct bm_extent, lce);
	194
	195	seq_printf(seq, "%5d %s %s\n", bme->rs_left,
	196	bme->flags & BME_NO_WRITES ? "NO_WRITES" : "---------",
	197	bme->flags & BME_LOCKED ? "LOCKED" : "------"
	198	);
	199	}
	200
	201	static int drbd_seq_show(struct seq_file seq, void v)
	202	{
81a5d60e	203	int i, prev_i = -1;
b411b363 PR	204	const char *sn;
b411b363 PR	205	struct drbd_conf *mdev;
44ed167d PR	206	struct net_conf *nc;
44ed167d PR	207	char wp;
b411b363 PR	208
	209	static char write_ordering_chars[] = {
	210	[WO_none] = 'n',
	211	[WO_drain_io] = 'd',
	212	[WO_bdev_flush] = 'f',
b411b363 PR	213	};
	214
	215	seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",
	216	API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX, drbd_buildtag());
	217
	218	/*
	219	cs .. connection state
	220	ro .. node role (local/remote)
	221	ds .. disk state (local/remote)
	222	protocol
	223	various flags
	224	ns .. network send
	225	nr .. network receive
	226	dw .. disk write
	227	dr .. disk read
	228	al .. activity log write count
	229	bm .. bitmap update write count
	230	pe .. pending (waiting for ack or data reply)
	231	ua .. unack'd (still need to send ack or data reply)
	232	ap .. application requests accepted, but not yet completed
	233	ep .. number of epochs currently "on the fly", P_BARRIER_ACK pending
	234	wo .. write ordering mode currently in use
	235	oos .. known out-of-sync kB
	236	*/
	237
c141ebda	238	rcu_read_lock();
81a5d60e PR	239	idr_for_each_entry(&minors, mdev, i) {
81a5d60e PR	240	if (prev_i != i - 1)
b411b363	241	seq_printf(seq, "\n");
81a5d60e	242	prev_i = i;
b411b363 PR	243
	244	sn = drbd_conn_str(mdev->state.conn);
	245
	246	if (mdev->state.conn == C_STANDALONE &&
	247	mdev->state.disk == D_DISKLESS &&
	248	mdev->state.role == R_SECONDARY) {
	249	seq_printf(seq, "%2d: cs:Unconfigured\n", i);
	250	} else {
8a943170 LE	251	/* reset mdev->congestion_reason */
	252	bdi_rw_congested(&mdev->rq_queue->backing_dev_info);
	253
44ed167d PR	254	nc = rcu_dereference(mdev->tconn->net_conf);
44ed167d PR	255	wp = nc ? nc->wire_protocol - DRBD_PROT_A + 'A' : ' ';
b411b363	256	seq_printf(seq,
0778286a	257	"%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
b411b363 PR	258	" ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
	259	"lo:%d pe:%d ua:%d ap:%d ep:%d wo:%c",
	260	i, sn,
	261	drbd_role_str(mdev->state.role),
	262	drbd_role_str(mdev->state.peer),
	263	drbd_disk_str(mdev->state.disk),
	264	drbd_disk_str(mdev->state.pdsk),
44ed167d	265	wp,
2aebfabb	266	drbd_suspended(mdev) ? 's' : 'r',
b411b363 PR	267	mdev->state.aftr_isp ? 'a' : '-',
	268	mdev->state.peer_isp ? 'p' : '-',
	269	mdev->state.user_isp ? 'u' : '-',
	270	mdev->congestion_reason ?: '-',
0778286a	271	test_bit(AL_SUSPENDED, &mdev->flags) ? 's' : '-',
b411b363 PR	272	mdev->send_cnt/2,
	273	mdev->recv_cnt/2,
	274	mdev->writ_cnt/2,
	275	mdev->read_cnt/2,
	276	mdev->al_writ_cnt,
	277	mdev->bm_writ_cnt,
	278	atomic_read(&mdev->local_cnt),
	279	atomic_read(&mdev->ap_pending_cnt) +
	280	atomic_read(&mdev->rs_pending_cnt),
	281	atomic_read(&mdev->unacked_cnt),
	282	atomic_read(&mdev->ap_bio_cnt),
12038a3a	283	mdev->tconn->epochs,
4b0007c0	284	write_ordering_chars[mdev->tconn->write_ordering]
b411b363	285	);
18edc0b9 LE	286	seq_printf(seq, " oos:%llu\n",
	287	Bit2KB((unsigned long long)
	288	drbd_bm_total_weight(mdev)));
b411b363 PR	289	}
b411b363 PR	290	if (mdev->state.conn == C_SYNC_SOURCE \|\|
439d5953 LE	291	mdev->state.conn == C_SYNC_TARGET \|\|
	292	mdev->state.conn == C_VERIFY_S \|\|
	293	mdev->state.conn == C_VERIFY_T)
b411b363 PR	294	drbd_syncer_progress(mdev, seq);
b411b363 PR	295
b411b363 PR	296	if (proc_details >= 1 && get_ldev_if_state(mdev, D_FAILED)) {
	297	lc_seq_printf_stats(seq, mdev->resync);
	298	lc_seq_printf_stats(seq, mdev->act_log);
	299	put_ldev(mdev);
	300	}
	301
	302	if (proc_details >= 2) {
	303	if (mdev->resync) {
	304	lc_seq_dump_details(seq, mdev->resync, "rs_left",
	305	resync_dump_detail);
	306	}
	307	}
	308	}
c141ebda	309	rcu_read_unlock();
b411b363 PR	310
	311	return 0;
	312	}
	313
	314	static int drbd_proc_open(struct inode inode, struct file file)
	315	{
3da127fa	316	if (try_module_get(THIS_MODULE))
d9dda78b	317	return single_open(file, drbd_seq_show, PDE_DATA(inode));
3da127fa LE	318	return -ENODEV;
	319	}
	320
	321	static int drbd_proc_release(struct inode inode, struct file file)
	322	{
	323	module_put(THIS_MODULE);
	324	return single_release(inode, file);
b411b363 PR	325	}
	326
	327	/* PROC FS stuff end */