1 #define pr_fmt(fmt) "drbd debugfs: " fmt
2 #include <linux/kernel.h>
3 #include <linux/module.h>
4 #include <linux/debugfs.h>
5 #include <linux/seq_file.h>
6 #include <linux/stat.h>
7 #include <linux/jiffies.h>
8 #include <linux/list.h>
9 
10 #include "drbd_int.h"
11 #include "drbd_req.h"
12 #include "drbd_debugfs.h"
13 
14 
15 /**********************************************************************
16  * Whenever you change the file format, remember to bump the version. *
17  **********************************************************************/
18 
19 static struct dentry *drbd_debugfs_root;
20 static struct dentry *drbd_debugfs_version;
21 static struct dentry *drbd_debugfs_resources;
22 static struct dentry *drbd_debugfs_minors;
23 
24 static void seq_print_age_or_dash(struct seq_file *m, bool valid, unsigned long dt)
25 {
26 	if (valid)
27 		seq_printf(m, "\t%d", jiffies_to_msecs(dt));
28 	else
29 		seq_printf(m, "\t-");
30 }
31 
32 static void __seq_print_rq_state_bit(struct seq_file *m,
33 	bool is_set, char *sep, const char *set_name, const char *unset_name)
34 {
35 	if (is_set && set_name) {
36 		seq_putc(m, *sep);
37 		seq_puts(m, set_name);
38 		*sep = '|';
39 	} else if (!is_set && unset_name) {
40 		seq_putc(m, *sep);
41 		seq_puts(m, unset_name);
42 		*sep = '|';
43 	}
44 }
45 
46 static void seq_print_rq_state_bit(struct seq_file *m,
47 	bool is_set, char *sep, const char *set_name)
48 {
49 	__seq_print_rq_state_bit(m, is_set, sep, set_name, NULL);
50 }
51 
52 /* pretty print enum drbd_req_state_bits req->rq_state */
53 static void seq_print_request_state(struct seq_file *m, struct drbd_request *req)
54 {
55 	unsigned int s = req->rq_state;
56 	char sep = ' ';
57 	seq_printf(m, "\t0x%08x", s);
58 	seq_printf(m, "\tmaster: %s", req->master_bio ? "pending" : "completed");
59 
60 	/* RQ_WRITE ignored, already reported */
61 	seq_puts(m, "\tlocal:");
62 	seq_print_rq_state_bit(m, s & RQ_IN_ACT_LOG, &sep, "in-AL");
63 	seq_print_rq_state_bit(m, s & RQ_POSTPONED, &sep, "postponed");
64 	seq_print_rq_state_bit(m, s & RQ_COMPLETION_SUSP, &sep, "suspended");
65 	sep = ' ';
66 	seq_print_rq_state_bit(m, s & RQ_LOCAL_PENDING, &sep, "pending");
67 	seq_print_rq_state_bit(m, s & RQ_LOCAL_COMPLETED, &sep, "completed");
68 	seq_print_rq_state_bit(m, s & RQ_LOCAL_ABORTED, &sep, "aborted");
69 	seq_print_rq_state_bit(m, s & RQ_LOCAL_OK, &sep, "ok");
70 	if (sep == ' ')
71 		seq_puts(m, " -");
72 
73 	/* for_each_connection ... */
74 	seq_printf(m, "\tnet:");
75 	sep = ' ';
76 	seq_print_rq_state_bit(m, s & RQ_NET_PENDING, &sep, "pending");
77 	seq_print_rq_state_bit(m, s & RQ_NET_QUEUED, &sep, "queued");
78 	seq_print_rq_state_bit(m, s & RQ_NET_SENT, &sep, "sent");
79 	seq_print_rq_state_bit(m, s & RQ_NET_DONE, &sep, "done");
80 	seq_print_rq_state_bit(m, s & RQ_NET_SIS, &sep, "sis");
81 	seq_print_rq_state_bit(m, s & RQ_NET_OK, &sep, "ok");
82 	if (sep == ' ')
83 		seq_puts(m, " -");
84 
85 	seq_printf(m, " :");
86 	sep = ' ';
87 	seq_print_rq_state_bit(m, s & RQ_EXP_RECEIVE_ACK, &sep, "B");
88 	seq_print_rq_state_bit(m, s & RQ_EXP_WRITE_ACK, &sep, "C");
89 	seq_print_rq_state_bit(m, s & RQ_EXP_BARR_ACK, &sep, "barr");
90 	if (sep == ' ')
91 		seq_puts(m, " -");
92 	seq_printf(m, "\n");
93 }
94 
95 static void seq_print_one_request(struct seq_file *m, struct drbd_request *req, unsigned long now)
96 {
97 	/* change anything here, fixup header below! */
98 	unsigned int s = req->rq_state;
99 
100 #define RQ_HDR_1 "epoch\tsector\tsize\trw"
101 	seq_printf(m, "0x%x\t%llu\t%u\t%s",
102 		req->epoch,
103 		(unsigned long long)req->i.sector, req->i.size >> 9,
104 		(s & RQ_WRITE) ? "W" : "R");
105 
106 #define RQ_HDR_2 "\tstart\tin AL\tsubmit"
107 	seq_printf(m, "\t%d", jiffies_to_msecs(now - req->start_jif));
108 	seq_print_age_or_dash(m, s & RQ_IN_ACT_LOG, now - req->in_actlog_jif);
109 	seq_print_age_or_dash(m, s & RQ_LOCAL_PENDING, now - req->pre_submit_jif);
110 
111 #define RQ_HDR_3 "\tsent\tacked\tdone"
112 	seq_print_age_or_dash(m, s & RQ_NET_SENT, now - req->pre_send_jif);
113 	seq_print_age_or_dash(m, (s & RQ_NET_SENT) && !(s & RQ_NET_PENDING), now - req->acked_jif);
114 	seq_print_age_or_dash(m, s & RQ_NET_DONE, now - req->net_done_jif);
115 
116 #define RQ_HDR_4 "\tstate\n"
117 	seq_print_request_state(m, req);
118 }
119 #define RQ_HDR RQ_HDR_1 RQ_HDR_2 RQ_HDR_3 RQ_HDR_4
120 
121 static void seq_print_minor_vnr_req(struct seq_file *m, struct drbd_request *req, unsigned long now)
122 {
123 	seq_printf(m, "%u\t%u\t", req->device->minor, req->device->vnr);
124 	seq_print_one_request(m, req, now);
125 }
126 
127 static void seq_print_resource_pending_meta_io(struct seq_file *m, struct drbd_resource *resource, unsigned long now)
128 {
129 	struct drbd_device *device;
130 	unsigned int i;
131 
132 	seq_puts(m, "minor\tvnr\tstart\tsubmit\tintent\n");
133 	rcu_read_lock();
134 	idr_for_each_entry(&resource->devices, device, i) {
135 		struct drbd_md_io tmp;
136 		/* In theory this is racy,
137 		 * in the sense that there could have been a
138 		 * drbd_md_put_buffer(); drbd_md_get_buffer();
139 		 * between accessing these members here.  */
140 		tmp = device->md_io;
141 		if (atomic_read(&tmp.in_use)) {
142 			seq_printf(m, "%u\t%u\t%d\t",
143 				device->minor, device->vnr,
144 				jiffies_to_msecs(now - tmp.start_jif));
145 			if (time_before(tmp.submit_jif, tmp.start_jif))
146 				seq_puts(m, "-\t");
147 			else
148 				seq_printf(m, "%d\t", jiffies_to_msecs(now - tmp.submit_jif));
149 			seq_printf(m, "%s\n", tmp.current_use);
150 		}
151 	}
152 	rcu_read_unlock();
153 }
154 
155 static void seq_print_waiting_for_AL(struct seq_file *m, struct drbd_resource *resource, unsigned long now)
156 {
157 	struct drbd_device *device;
158 	unsigned int i;
159 
160 	seq_puts(m, "minor\tvnr\tage\t#waiting\n");
161 	rcu_read_lock();
162 	idr_for_each_entry(&resource->devices, device, i) {
163 		unsigned long jif;
164 		struct drbd_request *req;
165 		int n = atomic_read(&device->ap_actlog_cnt);
166 		if (n) {
167 			spin_lock_irq(&device->resource->req_lock);
168 			req = list_first_entry_or_null(&device->pending_master_completion[1],
169 				struct drbd_request, req_pending_master_completion);
170 			/* if the oldest request does not wait for the activity log
171 			 * it is not interesting for us here */
172 			if (req && !(req->rq_state & RQ_IN_ACT_LOG))
173 				jif = req->start_jif;
174 			else
175 				req = NULL;
176 			spin_unlock_irq(&device->resource->req_lock);
177 		}
178 		if (n) {
179 			seq_printf(m, "%u\t%u\t", device->minor, device->vnr);
180 			if (req)
181 				seq_printf(m, "%u\t", jiffies_to_msecs(now - jif));
182 			else
183 				seq_puts(m, "-\t");
184 			seq_printf(m, "%u\n", n);
185 		}
186 	}
187 	rcu_read_unlock();
188 }
189 
190 static void seq_print_device_bitmap_io(struct seq_file *m, struct drbd_device *device, unsigned long now)
191 {
192 	struct drbd_bm_aio_ctx *ctx;
193 	unsigned long start_jif;
194 	unsigned int in_flight;
195 	unsigned int flags;
196 	spin_lock_irq(&device->resource->req_lock);
197 	ctx = list_first_entry_or_null(&device->pending_bitmap_io, struct drbd_bm_aio_ctx, list);
198 	if (ctx && ctx->done)
199 		ctx = NULL;
200 	if (ctx) {
201 		start_jif = ctx->start_jif;
202 		in_flight = atomic_read(&ctx->in_flight);
203 		flags = ctx->flags;
204 	}
205 	spin_unlock_irq(&device->resource->req_lock);
206 	if (ctx) {
207 		seq_printf(m, "%u\t%u\t%c\t%u\t%u\n",
208 			device->minor, device->vnr,
209 			(flags & BM_AIO_READ) ? 'R' : 'W',
210 			jiffies_to_msecs(now - start_jif),
211 			in_flight);
212 	}
213 }
214 
215 static void seq_print_resource_pending_bitmap_io(struct seq_file *m, struct drbd_resource *resource, unsigned long now)
216 {
217 	struct drbd_device *device;
218 	unsigned int i;
219 
220 	seq_puts(m, "minor\tvnr\trw\tage\t#in-flight\n");
221 	rcu_read_lock();
222 	idr_for_each_entry(&resource->devices, device, i) {
223 		seq_print_device_bitmap_io(m, device, now);
224 	}
225 	rcu_read_unlock();
226 }
227 
228 /* pretty print enum peer_req->flags */
229 static void seq_print_peer_request_flags(struct seq_file *m, struct drbd_peer_request *peer_req)
230 {
231 	unsigned long f = peer_req->flags;
232 	char sep = ' ';
233 
234 	__seq_print_rq_state_bit(m, f & EE_SUBMITTED, &sep, "submitted", "preparing");
235 	__seq_print_rq_state_bit(m, f & EE_APPLICATION, &sep, "application", "internal");
236 	seq_print_rq_state_bit(m, f & EE_CALL_AL_COMPLETE_IO, &sep, "in-AL");
237 	seq_print_rq_state_bit(m, f & EE_SEND_WRITE_ACK, &sep, "C");
238 	seq_print_rq_state_bit(m, f & EE_MAY_SET_IN_SYNC, &sep, "set-in-sync");
239 
240 	if (f & EE_IS_TRIM) {
241 		seq_putc(m, sep);
242 		sep = '|';
243 		if (f & EE_IS_TRIM_USE_ZEROOUT)
244 			seq_puts(m, "zero-out");
245 		else
246 			seq_puts(m, "trim");
247 	}
248 	seq_putc(m, '\n');
249 }
250 
251 static void seq_print_peer_request(struct seq_file *m,
252 	struct drbd_device *device, struct list_head *lh,
253 	unsigned long now)
254 {
255 	bool reported_preparing = false;
256 	struct drbd_peer_request *peer_req;
257 	list_for_each_entry(peer_req, lh, w.list) {
258 		if (reported_preparing && !(peer_req->flags & EE_SUBMITTED))
259 			continue;
260 
261 		if (device)
262 			seq_printf(m, "%u\t%u\t", device->minor, device->vnr);
263 
264 		seq_printf(m, "%llu\t%u\t%c\t%u\t",
265 			(unsigned long long)peer_req->i.sector, peer_req->i.size >> 9,
266 			(peer_req->flags & EE_WRITE) ? 'W' : 'R',
267 			jiffies_to_msecs(now - peer_req->submit_jif));
268 		seq_print_peer_request_flags(m, peer_req);
269 		if (peer_req->flags & EE_SUBMITTED)
270 			break;
271 		else
272 			reported_preparing = true;
273 	}
274 }
275 
276 static void seq_print_device_peer_requests(struct seq_file *m,
277 	struct drbd_device *device, unsigned long now)
278 {
279 	seq_puts(m, "minor\tvnr\tsector\tsize\trw\tage\tflags\n");
280 	spin_lock_irq(&device->resource->req_lock);
281 	seq_print_peer_request(m, device, &device->active_ee, now);
282 	seq_print_peer_request(m, device, &device->read_ee, now);
283 	seq_print_peer_request(m, device, &device->sync_ee, now);
284 	spin_unlock_irq(&device->resource->req_lock);
285 	if (test_bit(FLUSH_PENDING, &device->flags)) {
286 		seq_printf(m, "%u\t%u\t-\t-\tF\t%u\tflush\n",
287 			device->minor, device->vnr,
288 			jiffies_to_msecs(now - device->flush_jif));
289 	}
290 }
291 
292 static void seq_print_resource_pending_peer_requests(struct seq_file *m,
293 	struct drbd_resource *resource, unsigned long now)
294 {
295 	struct drbd_device *device;
296 	unsigned int i;
297 
298 	rcu_read_lock();
299 	idr_for_each_entry(&resource->devices, device, i) {
300 		seq_print_device_peer_requests(m, device, now);
301 	}
302 	rcu_read_unlock();
303 }
304 
305 static void seq_print_resource_transfer_log_summary(struct seq_file *m,
306 	struct drbd_resource *resource,
307 	struct drbd_connection *connection,
308 	unsigned long now)
309 {
310 	struct drbd_request *req;
311 	unsigned int count = 0;
312 	unsigned int show_state = 0;
313 
314 	seq_puts(m, "n\tdevice\tvnr\t" RQ_HDR);
315 	spin_lock_irq(&resource->req_lock);
316 	list_for_each_entry(req, &connection->transfer_log, tl_requests) {
317 		unsigned int tmp = 0;
318 		unsigned int s;
319 		++count;
320 
321 		/* don't disable irq "forever" */
322 		if (!(count & 0x1ff)) {
323 			struct drbd_request *req_next;
324 			kref_get(&req->kref);
325 			spin_unlock_irq(&resource->req_lock);
326 			cond_resched();
327 			spin_lock_irq(&resource->req_lock);
328 			req_next = list_next_entry(req, tl_requests);
329 			if (kref_put(&req->kref, drbd_req_destroy))
330 				req = req_next;
331 			if (&req->tl_requests == &connection->transfer_log)
332 				break;
333 		}
334 
335 		s = req->rq_state;
336 
337 		/* This is meant to summarize timing issues, to be able to tell
338 		 * local disk problems from network problems.
339 		 * Skip requests, if we have shown an even older request with
340 		 * similar aspects already.  */
341 		if (req->master_bio == NULL)
342 			tmp |= 1;
343 		if ((s & RQ_LOCAL_MASK) && (s & RQ_LOCAL_PENDING))
344 			tmp |= 2;
345 		if (s & RQ_NET_MASK) {
346 			if (!(s & RQ_NET_SENT))
347 				tmp |= 4;
348 			if (s & RQ_NET_PENDING)
349 				tmp |= 8;
350 			if (!(s & RQ_NET_DONE))
351 				tmp |= 16;
352 		}
353 		if ((tmp & show_state) == tmp)
354 			continue;
355 		show_state |= tmp;
356 		seq_printf(m, "%u\t", count);
357 		seq_print_minor_vnr_req(m, req, now);
358 		if (show_state == 0x1f)
359 			break;
360 	}
361 	spin_unlock_irq(&resource->req_lock);
362 }
363 
364 /* TODO: transfer_log and friends should be moved to resource */
365 static int in_flight_summary_show(struct seq_file *m, void *pos)
366 {
367 	struct drbd_resource *resource = m->private;
368 	struct drbd_connection *connection;
369 	unsigned long jif = jiffies;
370 
371 	connection = first_connection(resource);
372 	/* This does not happen, actually.
373 	 * But be robust and prepare for future code changes. */
374 	if (!connection || !kref_get_unless_zero(&connection->kref))
375 		return -ESTALE;
376 
377 	/* BUMP me if you change the file format/content/presentation */
378 	seq_printf(m, "v: %u\n\n", 0);
379 
380 	seq_puts(m, "oldest bitmap IO\n");
381 	seq_print_resource_pending_bitmap_io(m, resource, jif);
382 	seq_putc(m, '\n');
383 
384 	seq_puts(m, "meta data IO\n");
385 	seq_print_resource_pending_meta_io(m, resource, jif);
386 	seq_putc(m, '\n');
387 
388 	seq_puts(m, "socket buffer stats\n");
389 	/* for each connection ... once we have more than one */
390 	rcu_read_lock();
391 	if (connection->data.socket) {
392 		/* open coded SIOCINQ, the "relevant" part */
393 		struct tcp_sock *tp = tcp_sk(connection->data.socket->sk);
394 		int answ = tp->rcv_nxt - tp->copied_seq;
395 		seq_printf(m, "unread receive buffer: %u Byte\n", answ);
396 		/* open coded SIOCOUTQ, the "relevant" part */
397 		answ = tp->write_seq - tp->snd_una;
398 		seq_printf(m, "unacked send buffer: %u Byte\n", answ);
399 	}
400 	rcu_read_unlock();
401 	seq_putc(m, '\n');
402 
403 	seq_puts(m, "oldest peer requests\n");
404 	seq_print_resource_pending_peer_requests(m, resource, jif);
405 	seq_putc(m, '\n');
406 
407 	seq_puts(m, "application requests waiting for activity log\n");
408 	seq_print_waiting_for_AL(m, resource, jif);
409 	seq_putc(m, '\n');
410 
411 	seq_puts(m, "oldest application requests\n");
412 	seq_print_resource_transfer_log_summary(m, resource, connection, jif);
413 	seq_putc(m, '\n');
414 
415 	jif = jiffies - jif;
416 	if (jif)
417 		seq_printf(m, "generated in %d ms\n", jiffies_to_msecs(jif));
418 	kref_put(&connection->kref, drbd_destroy_connection);
419 	return 0;
420 }
421 
422 /* simple_positive(file->f_path.dentry) respectively debugfs_positive(),
423  * but neither is "reachable" from here.
424  * So we have our own inline version of it above.  :-( */
425 static inline int debugfs_positive(struct dentry *dentry)
426 {
427         return dentry->d_inode && !d_unhashed(dentry);
428 }
429 
430 /* make sure at *open* time that the respective object won't go away. */
431 static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, void *),
432 		                void *data, struct kref *kref,
433 				void (*release)(struct kref *))
434 {
435 	struct dentry *parent;
436 	int ret = -ESTALE;
437 
438 	/* Are we still linked,
439 	 * or has debugfs_remove() already been called? */
440 	parent = file->f_path.dentry->d_parent;
441 	/* not sure if this can happen: */
442 	if (!parent || !parent->d_inode)
443 		goto out;
444 	/* serialize with d_delete() */
445 	mutex_lock(&parent->d_inode->i_mutex);
446 	/* Make sure the object is still alive */
447 	if (debugfs_positive(file->f_path.dentry)
448 	&& kref_get_unless_zero(kref))
449 		ret = 0;
450 	mutex_unlock(&parent->d_inode->i_mutex);
451 	if (!ret) {
452 		ret = single_open(file, show, data);
453 		if (ret)
454 			kref_put(kref, release);
455 	}
456 out:
457 	return ret;
458 }
459 
460 static int in_flight_summary_open(struct inode *inode, struct file *file)
461 {
462 	struct drbd_resource *resource = inode->i_private;
463 	return drbd_single_open(file, in_flight_summary_show, resource,
464 				&resource->kref, drbd_destroy_resource);
465 }
466 
467 static int in_flight_summary_release(struct inode *inode, struct file *file)
468 {
469 	struct drbd_resource *resource = inode->i_private;
470 	kref_put(&resource->kref, drbd_destroy_resource);
471 	return single_release(inode, file);
472 }
473 
474 static const struct file_operations in_flight_summary_fops = {
475 	.owner		= THIS_MODULE,
476 	.open		= in_flight_summary_open,
477 	.read		= seq_read,
478 	.llseek		= seq_lseek,
479 	.release	= in_flight_summary_release,
480 };
481 
482 void drbd_debugfs_resource_add(struct drbd_resource *resource)
483 {
484 	struct dentry *dentry;
485 	if (!drbd_debugfs_resources)
486 		return;
487 
488 	dentry = debugfs_create_dir(resource->name, drbd_debugfs_resources);
489 	if (IS_ERR_OR_NULL(dentry))
490 		goto fail;
491 	resource->debugfs_res = dentry;
492 
493 	dentry = debugfs_create_dir("volumes", resource->debugfs_res);
494 	if (IS_ERR_OR_NULL(dentry))
495 		goto fail;
496 	resource->debugfs_res_volumes = dentry;
497 
498 	dentry = debugfs_create_dir("connections", resource->debugfs_res);
499 	if (IS_ERR_OR_NULL(dentry))
500 		goto fail;
501 	resource->debugfs_res_connections = dentry;
502 
503 	dentry = debugfs_create_file("in_flight_summary", S_IRUSR|S_IRGRP,
504 			resource->debugfs_res, resource,
505 			&in_flight_summary_fops);
506 	if (IS_ERR_OR_NULL(dentry))
507 		goto fail;
508 	resource->debugfs_res_in_flight_summary = dentry;
509 	return;
510 
511 fail:
512 	drbd_debugfs_resource_cleanup(resource);
513 	drbd_err(resource, "failed to create debugfs dentry\n");
514 }
515 
516 static void drbd_debugfs_remove(struct dentry **dp)
517 {
518 	debugfs_remove(*dp);
519 	*dp = NULL;
520 }
521 
522 void drbd_debugfs_resource_cleanup(struct drbd_resource *resource)
523 {
524 	/* it is ok to call debugfs_remove(NULL) */
525 	drbd_debugfs_remove(&resource->debugfs_res_in_flight_summary);
526 	drbd_debugfs_remove(&resource->debugfs_res_connections);
527 	drbd_debugfs_remove(&resource->debugfs_res_volumes);
528 	drbd_debugfs_remove(&resource->debugfs_res);
529 }
530 
531 static void seq_print_one_timing_detail(struct seq_file *m,
532 	const struct drbd_thread_timing_details *tdp,
533 	unsigned long now)
534 {
535 	struct drbd_thread_timing_details td;
536 	/* No locking...
537 	 * use temporary assignment to get at consistent data. */
538 	do {
539 		td = *tdp;
540 	} while (td.cb_nr != tdp->cb_nr);
541 	if (!td.cb_addr)
542 		return;
543 	seq_printf(m, "%u\t%d\t%s:%u\t%ps\n",
544 			td.cb_nr,
545 			jiffies_to_msecs(now - td.start_jif),
546 			td.caller_fn, td.line,
547 			td.cb_addr);
548 }
549 
550 static void seq_print_timing_details(struct seq_file *m,
551 		const char *title,
552 		unsigned int cb_nr, struct drbd_thread_timing_details *tdp, unsigned long now)
553 {
554 	unsigned int start_idx;
555 	unsigned int i;
556 
557 	seq_printf(m, "%s\n", title);
558 	/* If not much is going on, this will result in natural ordering.
559 	 * If it is very busy, we will possibly skip events, or even see wrap
560 	 * arounds, which could only be avoided with locking.
561 	 */
562 	start_idx = cb_nr % DRBD_THREAD_DETAILS_HIST;
563 	for (i = start_idx; i < DRBD_THREAD_DETAILS_HIST; i++)
564 		seq_print_one_timing_detail(m, tdp+i, now);
565 	for (i = 0; i < start_idx; i++)
566 		seq_print_one_timing_detail(m, tdp+i, now);
567 }
568 
569 static int callback_history_show(struct seq_file *m, void *ignored)
570 {
571 	struct drbd_connection *connection = m->private;
572 	unsigned long jif = jiffies;
573 
574 	/* BUMP me if you change the file format/content/presentation */
575 	seq_printf(m, "v: %u\n\n", 0);
576 
577 	seq_puts(m, "n\tage\tcallsite\tfn\n");
578 	seq_print_timing_details(m, "worker", connection->w_cb_nr, connection->w_timing_details, jif);
579 	seq_print_timing_details(m, "receiver", connection->r_cb_nr, connection->r_timing_details, jif);
580 	return 0;
581 }
582 
583 static int callback_history_open(struct inode *inode, struct file *file)
584 {
585 	struct drbd_connection *connection = inode->i_private;
586 	return drbd_single_open(file, callback_history_show, connection,
587 				&connection->kref, drbd_destroy_connection);
588 }
589 
590 static int callback_history_release(struct inode *inode, struct file *file)
591 {
592 	struct drbd_connection *connection = inode->i_private;
593 	kref_put(&connection->kref, drbd_destroy_connection);
594 	return single_release(inode, file);
595 }
596 
597 static const struct file_operations connection_callback_history_fops = {
598 	.owner		= THIS_MODULE,
599 	.open		= callback_history_open,
600 	.read		= seq_read,
601 	.llseek		= seq_lseek,
602 	.release	= callback_history_release,
603 };
604 
605 static int connection_oldest_requests_show(struct seq_file *m, void *ignored)
606 {
607 	struct drbd_connection *connection = m->private;
608 	unsigned long now = jiffies;
609 	struct drbd_request *r1, *r2;
610 
611 	/* BUMP me if you change the file format/content/presentation */
612 	seq_printf(m, "v: %u\n\n", 0);
613 
614 	spin_lock_irq(&connection->resource->req_lock);
615 	r1 = connection->req_next;
616 	if (r1)
617 		seq_print_minor_vnr_req(m, r1, now);
618 	r2 = connection->req_ack_pending;
619 	if (r2 && r2 != r1) {
620 		r1 = r2;
621 		seq_print_minor_vnr_req(m, r1, now);
622 	}
623 	r2 = connection->req_not_net_done;
624 	if (r2 && r2 != r1)
625 		seq_print_minor_vnr_req(m, r2, now);
626 	spin_unlock_irq(&connection->resource->req_lock);
627 	return 0;
628 }
629 
630 static int connection_oldest_requests_open(struct inode *inode, struct file *file)
631 {
632 	struct drbd_connection *connection = inode->i_private;
633 	return drbd_single_open(file, connection_oldest_requests_show, connection,
634 				&connection->kref, drbd_destroy_connection);
635 }
636 
637 static int connection_oldest_requests_release(struct inode *inode, struct file *file)
638 {
639 	struct drbd_connection *connection = inode->i_private;
640 	kref_put(&connection->kref, drbd_destroy_connection);
641 	return single_release(inode, file);
642 }
643 
644 static const struct file_operations connection_oldest_requests_fops = {
645 	.owner		= THIS_MODULE,
646 	.open		= connection_oldest_requests_open,
647 	.read		= seq_read,
648 	.llseek		= seq_lseek,
649 	.release	= connection_oldest_requests_release,
650 };
651 
652 void drbd_debugfs_connection_add(struct drbd_connection *connection)
653 {
654 	struct dentry *conns_dir = connection->resource->debugfs_res_connections;
655 	struct dentry *dentry;
656 	if (!conns_dir)
657 		return;
658 
659 	/* Once we enable mutliple peers,
660 	 * these connections will have descriptive names.
661 	 * For now, it is just the one connection to the (only) "peer". */
662 	dentry = debugfs_create_dir("peer", conns_dir);
663 	if (IS_ERR_OR_NULL(dentry))
664 		goto fail;
665 	connection->debugfs_conn = dentry;
666 
667 	dentry = debugfs_create_file("callback_history", S_IRUSR|S_IRGRP,
668 			connection->debugfs_conn, connection,
669 			&connection_callback_history_fops);
670 	if (IS_ERR_OR_NULL(dentry))
671 		goto fail;
672 	connection->debugfs_conn_callback_history = dentry;
673 
674 	dentry = debugfs_create_file("oldest_requests", S_IRUSR|S_IRGRP,
675 			connection->debugfs_conn, connection,
676 			&connection_oldest_requests_fops);
677 	if (IS_ERR_OR_NULL(dentry))
678 		goto fail;
679 	connection->debugfs_conn_oldest_requests = dentry;
680 	return;
681 
682 fail:
683 	drbd_debugfs_connection_cleanup(connection);
684 	drbd_err(connection, "failed to create debugfs dentry\n");
685 }
686 
687 void drbd_debugfs_connection_cleanup(struct drbd_connection *connection)
688 {
689 	drbd_debugfs_remove(&connection->debugfs_conn_callback_history);
690 	drbd_debugfs_remove(&connection->debugfs_conn_oldest_requests);
691 	drbd_debugfs_remove(&connection->debugfs_conn);
692 }
693 
694 static void resync_dump_detail(struct seq_file *m, struct lc_element *e)
695 {
696        struct bm_extent *bme = lc_entry(e, struct bm_extent, lce);
697 
698        seq_printf(m, "%5d %s %s %s", bme->rs_left,
699 		  test_bit(BME_NO_WRITES, &bme->flags) ? "NO_WRITES" : "---------",
700 		  test_bit(BME_LOCKED, &bme->flags) ? "LOCKED" : "------",
701 		  test_bit(BME_PRIORITY, &bme->flags) ? "PRIORITY" : "--------"
702 		  );
703 }
704 
705 static int device_resync_extents_show(struct seq_file *m, void *ignored)
706 {
707 	struct drbd_device *device = m->private;
708 
709 	/* BUMP me if you change the file format/content/presentation */
710 	seq_printf(m, "v: %u\n\n", 0);
711 
712 	if (get_ldev_if_state(device, D_FAILED)) {
713 		lc_seq_printf_stats(m, device->resync);
714 		lc_seq_dump_details(m, device->resync, "rs_left flags", resync_dump_detail);
715 		put_ldev(device);
716 	}
717 	return 0;
718 }
719 
720 static int device_act_log_extents_show(struct seq_file *m, void *ignored)
721 {
722 	struct drbd_device *device = m->private;
723 
724 	/* BUMP me if you change the file format/content/presentation */
725 	seq_printf(m, "v: %u\n\n", 0);
726 
727 	if (get_ldev_if_state(device, D_FAILED)) {
728 		lc_seq_printf_stats(m, device->act_log);
729 		lc_seq_dump_details(m, device->act_log, "", NULL);
730 		put_ldev(device);
731 	}
732 	return 0;
733 }
734 
735 static int device_oldest_requests_show(struct seq_file *m, void *ignored)
736 {
737 	struct drbd_device *device = m->private;
738 	struct drbd_resource *resource = device->resource;
739 	unsigned long now = jiffies;
740 	struct drbd_request *r1, *r2;
741 	int i;
742 
743 	/* BUMP me if you change the file format/content/presentation */
744 	seq_printf(m, "v: %u\n\n", 0);
745 
746 	seq_puts(m, RQ_HDR);
747 	spin_lock_irq(&resource->req_lock);
748 	/* WRITE, then READ */
749 	for (i = 1; i >= 0; --i) {
750 		r1 = list_first_entry_or_null(&device->pending_master_completion[i],
751 			struct drbd_request, req_pending_master_completion);
752 		r2 = list_first_entry_or_null(&device->pending_completion[i],
753 			struct drbd_request, req_pending_local);
754 		if (r1)
755 			seq_print_one_request(m, r1, now);
756 		if (r2 && r2 != r1)
757 			seq_print_one_request(m, r2, now);
758 	}
759 	spin_unlock_irq(&resource->req_lock);
760 	return 0;
761 }
762 
763 static int device_data_gen_id_show(struct seq_file *m, void *ignored)
764 {
765 	struct drbd_device *device = m->private;
766 	struct drbd_md *md;
767 	enum drbd_uuid_index idx;
768 
769 	if (!get_ldev_if_state(device, D_FAILED))
770 		return -ENODEV;
771 
772 	md = &device->ldev->md;
773 	spin_lock_irq(&md->uuid_lock);
774 	for (idx = UI_CURRENT; idx <= UI_HISTORY_END; idx++) {
775 		seq_printf(m, "0x%016llX\n", md->uuid[idx]);
776 	}
777 	spin_unlock_irq(&md->uuid_lock);
778 	put_ldev(device);
779 	return 0;
780 }
781 
782 #define drbd_debugfs_device_attr(name)						\
783 static int device_ ## name ## _open(struct inode *inode, struct file *file)	\
784 {										\
785 	struct drbd_device *device = inode->i_private;				\
786 	return drbd_single_open(file, device_ ## name ## _show, device,		\
787 				&device->kref, drbd_destroy_device);		\
788 }										\
789 static int device_ ## name ## _release(struct inode *inode, struct file *file)	\
790 {										\
791 	struct drbd_device *device = inode->i_private;				\
792 	kref_put(&device->kref, drbd_destroy_device);				\
793 	return single_release(inode, file);					\
794 }										\
795 static const struct file_operations device_ ## name ## _fops = {		\
796 	.owner		= THIS_MODULE,						\
797 	.open		= device_ ## name ## _open,				\
798 	.read		= seq_read,						\
799 	.llseek		= seq_lseek,						\
800 	.release	= device_ ## name ## _release,				\
801 };
802 
803 drbd_debugfs_device_attr(oldest_requests)
804 drbd_debugfs_device_attr(act_log_extents)
805 drbd_debugfs_device_attr(resync_extents)
806 drbd_debugfs_device_attr(data_gen_id)
807 
808 void drbd_debugfs_device_add(struct drbd_device *device)
809 {
810 	struct dentry *vols_dir = device->resource->debugfs_res_volumes;
811 	char minor_buf[8]; /* MINORMASK, MINORBITS == 20; */
812 	char vnr_buf[8];   /* volume number vnr is even 16 bit only; */
813 	char *slink_name = NULL;
814 
815 	struct dentry *dentry;
816 	if (!vols_dir || !drbd_debugfs_minors)
817 		return;
818 
819 	snprintf(vnr_buf, sizeof(vnr_buf), "%u", device->vnr);
820 	dentry = debugfs_create_dir(vnr_buf, vols_dir);
821 	if (IS_ERR_OR_NULL(dentry))
822 		goto fail;
823 	device->debugfs_vol = dentry;
824 
825 	snprintf(minor_buf, sizeof(minor_buf), "%u", device->minor);
826 	slink_name = kasprintf(GFP_KERNEL, "../resources/%s/volumes/%u",
827 			device->resource->name, device->vnr);
828 	if (!slink_name)
829 		goto fail;
830 	dentry = debugfs_create_symlink(minor_buf, drbd_debugfs_minors, slink_name);
831 	kfree(slink_name);
832 	slink_name = NULL;
833 	if (IS_ERR_OR_NULL(dentry))
834 		goto fail;
835 	device->debugfs_minor = dentry;
836 
837 #define DCF(name)	do {					\
838 	dentry = debugfs_create_file(#name, S_IRUSR|S_IRGRP,	\
839 			device->debugfs_vol, device,		\
840 			&device_ ## name ## _fops);		\
841 	if (IS_ERR_OR_NULL(dentry))				\
842 		goto fail;					\
843 	device->debugfs_vol_ ## name = dentry;			\
844 	} while (0)
845 
846 	DCF(oldest_requests);
847 	DCF(act_log_extents);
848 	DCF(resync_extents);
849 	DCF(data_gen_id);
850 #undef DCF
851 	return;
852 
853 fail:
854 	drbd_debugfs_device_cleanup(device);
855 	drbd_err(device, "failed to create debugfs entries\n");
856 }
857 
858 void drbd_debugfs_device_cleanup(struct drbd_device *device)
859 {
860 	drbd_debugfs_remove(&device->debugfs_minor);
861 	drbd_debugfs_remove(&device->debugfs_vol_oldest_requests);
862 	drbd_debugfs_remove(&device->debugfs_vol_act_log_extents);
863 	drbd_debugfs_remove(&device->debugfs_vol_resync_extents);
864 	drbd_debugfs_remove(&device->debugfs_vol_data_gen_id);
865 	drbd_debugfs_remove(&device->debugfs_vol);
866 }
867 
868 void drbd_debugfs_peer_device_add(struct drbd_peer_device *peer_device)
869 {
870 	struct dentry *conn_dir = peer_device->connection->debugfs_conn;
871 	struct dentry *dentry;
872 	char vnr_buf[8];
873 
874 	if (!conn_dir)
875 		return;
876 
877 	snprintf(vnr_buf, sizeof(vnr_buf), "%u", peer_device->device->vnr);
878 	dentry = debugfs_create_dir(vnr_buf, conn_dir);
879 	if (IS_ERR_OR_NULL(dentry))
880 		goto fail;
881 	peer_device->debugfs_peer_dev = dentry;
882 	return;
883 
884 fail:
885 	drbd_debugfs_peer_device_cleanup(peer_device);
886 	drbd_err(peer_device, "failed to create debugfs entries\n");
887 }
888 
889 void drbd_debugfs_peer_device_cleanup(struct drbd_peer_device *peer_device)
890 {
891 	drbd_debugfs_remove(&peer_device->debugfs_peer_dev);
892 }
893 
894 static int drbd_version_show(struct seq_file *m, void *ignored)
895 {
896 	seq_printf(m, "# %s\n", drbd_buildtag());
897 	seq_printf(m, "VERSION=%s\n", REL_VERSION);
898 	seq_printf(m, "API_VERSION=%u\n", API_VERSION);
899 	seq_printf(m, "PRO_VERSION_MIN=%u\n", PRO_VERSION_MIN);
900 	seq_printf(m, "PRO_VERSION_MAX=%u\n", PRO_VERSION_MAX);
901 	return 0;
902 }
903 
904 static int drbd_version_open(struct inode *inode, struct file *file)
905 {
906 	return single_open(file, drbd_version_show, NULL);
907 }
908 
909 static struct file_operations drbd_version_fops = {
910 	.owner = THIS_MODULE,
911 	.open = drbd_version_open,
912 	.llseek = seq_lseek,
913 	.read = seq_read,
914 	.release = single_release,
915 };
916 
917 /* not __exit, may be indirectly called
918  * from the module-load-failure path as well. */
919 void drbd_debugfs_cleanup(void)
920 {
921 	drbd_debugfs_remove(&drbd_debugfs_resources);
922 	drbd_debugfs_remove(&drbd_debugfs_minors);
923 	drbd_debugfs_remove(&drbd_debugfs_version);
924 	drbd_debugfs_remove(&drbd_debugfs_root);
925 }
926 
927 int __init drbd_debugfs_init(void)
928 {
929 	struct dentry *dentry;
930 
931 	dentry = debugfs_create_dir("drbd", NULL);
932 	if (IS_ERR_OR_NULL(dentry))
933 		goto fail;
934 	drbd_debugfs_root = dentry;
935 
936 	dentry = debugfs_create_file("version", 0444, drbd_debugfs_root, NULL, &drbd_version_fops);
937 	if (IS_ERR_OR_NULL(dentry))
938 		goto fail;
939 	drbd_debugfs_version = dentry;
940 
941 	dentry = debugfs_create_dir("resources", drbd_debugfs_root);
942 	if (IS_ERR_OR_NULL(dentry))
943 		goto fail;
944 	drbd_debugfs_resources = dentry;
945 
946 	dentry = debugfs_create_dir("minors", drbd_debugfs_root);
947 	if (IS_ERR_OR_NULL(dentry))
948 		goto fail;
949 	drbd_debugfs_minors = dentry;
950 	return 0;
951 
952 fail:
953 	drbd_debugfs_cleanup();
954 	if (dentry)
955 		return PTR_ERR(dentry);
956 	else
957 		return -EINVAL;
958 }
959