1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3    drbd_proc.c
4 
5    This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
6 
7    Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
8    Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
9    Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
10 
11 
12  */
13 
14 #include <linux/module.h>
15 
16 #include <linux/uaccess.h>
17 #include <linux/fs.h>
18 #include <linux/file.h>
19 #include <linux/proc_fs.h>
20 #include <linux/seq_file.h>
21 #include <linux/drbd.h>
22 #include "drbd_int.h"
23 
24 struct proc_dir_entry *drbd_proc;
25 
seq_printf_with_thousands_grouping(struct seq_file * seq,long v)26 static void seq_printf_with_thousands_grouping(struct seq_file *seq, long v)
27 {
28 	/* v is in kB/sec. We don't expect TiByte/sec yet. */
29 	if (unlikely(v >= 1000000)) {
30 		/* cool: > GiByte/s */
31 		seq_printf(seq, "%ld,", v / 1000000);
32 		v %= 1000000;
33 		seq_printf(seq, "%03ld,%03ld", v/1000, v % 1000);
34 	} else if (likely(v >= 1000))
35 		seq_printf(seq, "%ld,%03ld", v/1000, v % 1000);
36 	else
37 		seq_printf(seq, "%ld", v);
38 }
39 
drbd_get_syncer_progress(struct drbd_device * device,union drbd_dev_state state,unsigned long * rs_total,unsigned long * bits_left,unsigned int * per_mil_done)40 static void drbd_get_syncer_progress(struct drbd_device *device,
41 		union drbd_dev_state state, unsigned long *rs_total,
42 		unsigned long *bits_left, unsigned int *per_mil_done)
43 {
44 	/* this is to break it at compile time when we change that, in case we
45 	 * want to support more than (1<<32) bits on a 32bit arch. */
46 	typecheck(unsigned long, device->rs_total);
47 	*rs_total = device->rs_total;
48 
49 	/* note: both rs_total and rs_left are in bits, i.e. in
50 	 * units of BM_BLOCK_SIZE.
51 	 * for the percentage, we don't care. */
52 
53 	if (state.conn == C_VERIFY_S || state.conn == C_VERIFY_T)
54 		*bits_left = device->ov_left;
55 	else
56 		*bits_left = drbd_bm_total_weight(device) - device->rs_failed;
57 	/* >> 10 to prevent overflow,
58 	 * +1 to prevent division by zero */
59 	if (*bits_left > *rs_total) {
60 		/* D'oh. Maybe a logic bug somewhere.  More likely just a race
61 		 * between state change and reset of rs_total.
62 		 */
63 		*bits_left = *rs_total;
64 		*per_mil_done = *rs_total ? 0 : 1000;
65 	} else {
66 		/* Make sure the division happens in long context.
67 		 * We allow up to one petabyte storage right now,
68 		 * at a granularity of 4k per bit that is 2**38 bits.
69 		 * After shift right and multiplication by 1000,
70 		 * this should still fit easily into a 32bit long,
71 		 * so we don't need a 64bit division on 32bit arch.
72 		 * Note: currently we don't support such large bitmaps on 32bit
73 		 * arch anyways, but no harm done to be prepared for it here.
74 		 */
75 		unsigned int shift = *rs_total > UINT_MAX ? 16 : 10;
76 		unsigned long left = *bits_left >> shift;
77 		unsigned long total = 1UL + (*rs_total >> shift);
78 		unsigned long tmp = 1000UL - left * 1000UL/total;
79 		*per_mil_done = tmp;
80 	}
81 }
82 
83 
84 /*lge
85  * progress bars shamelessly adapted from driver/md/md.c
86  * output looks like
87  *	[=====>..............] 33.5% (23456/123456)
88  *	finish: 2:20:20 speed: 6,345 (6,456) K/sec
89  */
drbd_syncer_progress(struct drbd_device * device,struct seq_file * seq,union drbd_dev_state state)90 static void drbd_syncer_progress(struct drbd_device *device, struct seq_file *seq,
91 		union drbd_dev_state state)
92 {
93 	unsigned long db, dt, dbdt, rt, rs_total, rs_left;
94 	unsigned int res;
95 	int i, x, y;
96 	int stalled = 0;
97 
98 	drbd_get_syncer_progress(device, state, &rs_total, &rs_left, &res);
99 
100 	x = res/50;
101 	y = 20-x;
102 	seq_puts(seq, "\t[");
103 	for (i = 1; i < x; i++)
104 		seq_putc(seq, '=');
105 	seq_putc(seq, '>');
106 	for (i = 0; i < y; i++)
107 		seq_putc(seq, '.');
108 	seq_puts(seq, "] ");
109 
110 	if (state.conn == C_VERIFY_S || state.conn == C_VERIFY_T)
111 		seq_puts(seq, "verified:");
112 	else
113 		seq_puts(seq, "sync'ed:");
114 	seq_printf(seq, "%3u.%u%% ", res / 10, res % 10);
115 
116 	/* if more than a few GB, display in MB */
117 	if (rs_total > (4UL << (30 - BM_BLOCK_SHIFT)))
118 		seq_printf(seq, "(%lu/%lu)M",
119 			    (unsigned long) Bit2KB(rs_left >> 10),
120 			    (unsigned long) Bit2KB(rs_total >> 10));
121 	else
122 		seq_printf(seq, "(%lu/%lu)K",
123 			    (unsigned long) Bit2KB(rs_left),
124 			    (unsigned long) Bit2KB(rs_total));
125 
126 	seq_puts(seq, "\n\t");
127 
128 	/* see drivers/md/md.c
129 	 * We do not want to overflow, so the order of operands and
130 	 * the * 100 / 100 trick are important. We do a +1 to be
131 	 * safe against division by zero. We only estimate anyway.
132 	 *
133 	 * dt: time from mark until now
134 	 * db: blocks written from mark until now
135 	 * rt: remaining time
136 	 */
137 	/* Rolling marks. last_mark+1 may just now be modified.  last_mark+2 is
138 	 * at least (DRBD_SYNC_MARKS-2)*DRBD_SYNC_MARK_STEP old, and has at
139 	 * least DRBD_SYNC_MARK_STEP time before it will be modified. */
140 	/* ------------------------ ~18s average ------------------------ */
141 	i = (device->rs_last_mark + 2) % DRBD_SYNC_MARKS;
142 	dt = (jiffies - device->rs_mark_time[i]) / HZ;
143 	if (dt > 180)
144 		stalled = 1;
145 
146 	if (!dt)
147 		dt++;
148 	db = device->rs_mark_left[i] - rs_left;
149 	rt = (dt * (rs_left / (db/100+1)))/100; /* seconds */
150 
151 	seq_printf(seq, "finish: %lu:%02lu:%02lu",
152 		rt / 3600, (rt % 3600) / 60, rt % 60);
153 
154 	dbdt = Bit2KB(db/dt);
155 	seq_puts(seq, " speed: ");
156 	seq_printf_with_thousands_grouping(seq, dbdt);
157 	seq_puts(seq, " (");
158 	/* ------------------------- ~3s average ------------------------ */
159 	if (drbd_proc_details >= 1) {
160 		/* this is what drbd_rs_should_slow_down() uses */
161 		i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
162 		dt = (jiffies - device->rs_mark_time[i]) / HZ;
163 		if (!dt)
164 			dt++;
165 		db = device->rs_mark_left[i] - rs_left;
166 		dbdt = Bit2KB(db/dt);
167 		seq_printf_with_thousands_grouping(seq, dbdt);
168 		seq_puts(seq, " -- ");
169 	}
170 
171 	/* --------------------- long term average ---------------------- */
172 	/* mean speed since syncer started
173 	 * we do account for PausedSync periods */
174 	dt = (jiffies - device->rs_start - device->rs_paused) / HZ;
175 	if (dt == 0)
176 		dt = 1;
177 	db = rs_total - rs_left;
178 	dbdt = Bit2KB(db/dt);
179 	seq_printf_with_thousands_grouping(seq, dbdt);
180 	seq_putc(seq, ')');
181 
182 	if (state.conn == C_SYNC_TARGET ||
183 	    state.conn == C_VERIFY_S) {
184 		seq_puts(seq, " want: ");
185 		seq_printf_with_thousands_grouping(seq, device->c_sync_rate);
186 	}
187 	seq_printf(seq, " K/sec%s\n", stalled ? " (stalled)" : "");
188 
189 	if (drbd_proc_details >= 1) {
190 		/* 64 bit:
191 		 * we convert to sectors in the display below. */
192 		unsigned long bm_bits = drbd_bm_bits(device);
193 		unsigned long bit_pos;
194 		unsigned long long stop_sector = 0;
195 		if (state.conn == C_VERIFY_S ||
196 		    state.conn == C_VERIFY_T) {
197 			bit_pos = bm_bits - device->ov_left;
198 			if (verify_can_do_stop_sector(device))
199 				stop_sector = device->ov_stop_sector;
200 		} else
201 			bit_pos = device->bm_resync_fo;
202 		/* Total sectors may be slightly off for oddly
203 		 * sized devices. So what. */
204 		seq_printf(seq,
205 			"\t%3d%% sector pos: %llu/%llu",
206 			(int)(bit_pos / (bm_bits/100+1)),
207 			(unsigned long long)bit_pos * BM_SECT_PER_BIT,
208 			(unsigned long long)bm_bits * BM_SECT_PER_BIT);
209 		if (stop_sector != 0 && stop_sector != ULLONG_MAX)
210 			seq_printf(seq, " stop sector: %llu", stop_sector);
211 		seq_putc(seq, '\n');
212 	}
213 }
214 
drbd_seq_show(struct seq_file * seq,void * v)215 int drbd_seq_show(struct seq_file *seq, void *v)
216 {
217 	int i, prev_i = -1;
218 	const char *sn;
219 	struct drbd_device *device;
220 	struct net_conf *nc;
221 	union drbd_dev_state state;
222 	char wp;
223 
224 	static char write_ordering_chars[] = {
225 		[WO_NONE] = 'n',
226 		[WO_DRAIN_IO] = 'd',
227 		[WO_BDEV_FLUSH] = 'f',
228 	};
229 
230 	seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",
231 		   API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX, drbd_buildtag());
232 
233 	/*
234 	  cs .. connection state
235 	  ro .. node role (local/remote)
236 	  ds .. disk state (local/remote)
237 	     protocol
238 	     various flags
239 	  ns .. network send
240 	  nr .. network receive
241 	  dw .. disk write
242 	  dr .. disk read
243 	  al .. activity log write count
244 	  bm .. bitmap update write count
245 	  pe .. pending (waiting for ack or data reply)
246 	  ua .. unack'd (still need to send ack or data reply)
247 	  ap .. application requests accepted, but not yet completed
248 	  ep .. number of epochs currently "on the fly", P_BARRIER_ACK pending
249 	  wo .. write ordering mode currently in use
250 	 oos .. known out-of-sync kB
251 	*/
252 
253 	rcu_read_lock();
254 	idr_for_each_entry(&drbd_devices, device, i) {
255 		if (prev_i != i - 1)
256 			seq_putc(seq, '\n');
257 		prev_i = i;
258 
259 		state = device->state;
260 		sn = drbd_conn_str(state.conn);
261 
262 		if (state.conn == C_STANDALONE &&
263 		    state.disk == D_DISKLESS &&
264 		    state.role == R_SECONDARY) {
265 			seq_printf(seq, "%2d: cs:Unconfigured\n", i);
266 		} else {
267 			/* reset device->congestion_reason */
268 
269 			nc = rcu_dereference(first_peer_device(device)->connection->net_conf);
270 			wp = nc ? nc->wire_protocol - DRBD_PROT_A + 'A' : ' ';
271 			seq_printf(seq,
272 			   "%2d: cs:%s ro:%s/%s ds:%s/%s %c %c%c%c%c%c%c\n"
273 			   "    ns:%u nr:%u dw:%u dr:%u al:%u bm:%u "
274 			   "lo:%d pe:%d ua:%d ap:%d ep:%d wo:%c",
275 			   i, sn,
276 			   drbd_role_str(state.role),
277 			   drbd_role_str(state.peer),
278 			   drbd_disk_str(state.disk),
279 			   drbd_disk_str(state.pdsk),
280 			   wp,
281 			   drbd_suspended(device) ? 's' : 'r',
282 			   state.aftr_isp ? 'a' : '-',
283 			   state.peer_isp ? 'p' : '-',
284 			   state.user_isp ? 'u' : '-',
285 			   device->congestion_reason ?: '-',
286 			   test_bit(AL_SUSPENDED, &device->flags) ? 's' : '-',
287 			   device->send_cnt/2,
288 			   device->recv_cnt/2,
289 			   device->writ_cnt/2,
290 			   device->read_cnt/2,
291 			   device->al_writ_cnt,
292 			   device->bm_writ_cnt,
293 			   atomic_read(&device->local_cnt),
294 			   atomic_read(&device->ap_pending_cnt) +
295 			   atomic_read(&device->rs_pending_cnt),
296 			   atomic_read(&device->unacked_cnt),
297 			   atomic_read(&device->ap_bio_cnt),
298 			   first_peer_device(device)->connection->epochs,
299 			   write_ordering_chars[device->resource->write_ordering]
300 			);
301 			seq_printf(seq, " oos:%llu\n",
302 				   Bit2KB((unsigned long long)
303 					   drbd_bm_total_weight(device)));
304 		}
305 		if (state.conn == C_SYNC_SOURCE ||
306 		    state.conn == C_SYNC_TARGET ||
307 		    state.conn == C_VERIFY_S ||
308 		    state.conn == C_VERIFY_T)
309 			drbd_syncer_progress(device, seq, state);
310 
311 		if (drbd_proc_details >= 1 && get_ldev_if_state(device, D_FAILED)) {
312 			lc_seq_printf_stats(seq, device->resync);
313 			lc_seq_printf_stats(seq, device->act_log);
314 			put_ldev(device);
315 		}
316 
317 		if (drbd_proc_details >= 2)
318 			seq_printf(seq, "\tblocked on activity log: %d\n", atomic_read(&device->ap_actlog_cnt));
319 	}
320 	rcu_read_unlock();
321 
322 	return 0;
323 }
324