linux/drivers/block/drbd/drbd_debugfs.c
<<
>>
Prefs
   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
  19static struct dentry *drbd_debugfs_root;
  20static struct dentry *drbd_debugfs_version;
  21static struct dentry *drbd_debugfs_resources;
  22static struct dentry *drbd_debugfs_minors;
  23
  24static 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
  32static 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
  46static 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 */
  53static 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
  95static 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
 121static 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
 127static 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
 155static 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
 190static 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
 215static 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 */
 229static 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
 251static 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
 276static 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
 292static 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
 305static 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 */
 365static 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.  :-( */
 425static 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. */
 431static 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        }
 456out:
 457        return ret;
 458}
 459
 460static 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
 467static 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
 474static 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
 482void 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
 511fail:
 512        drbd_debugfs_resource_cleanup(resource);
 513        drbd_err(resource, "failed to create debugfs dentry\n");
 514}
 515
 516static void drbd_debugfs_remove(struct dentry **dp)
 517{
 518        debugfs_remove(*dp);
 519        *dp = NULL;
 520}
 521
 522void 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
 531static 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
 550static 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
 569static 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
 583static 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
 590static 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
 597static 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
 605static 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
 630static 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
 637static 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
 644static 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
 652void 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
 682fail:
 683        drbd_debugfs_connection_cleanup(connection);
 684        drbd_err(connection, "failed to create debugfs dentry\n");
 685}
 686
 687void 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
 694static 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
 705static 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
 720static 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
 735static 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
 763static 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)                                          \
 783static 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}                                                                               \
 789static 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}                                                                               \
 795static 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
 803drbd_debugfs_device_attr(oldest_requests)
 804drbd_debugfs_device_attr(act_log_extents)
 805drbd_debugfs_device_attr(resync_extents)
 806drbd_debugfs_device_attr(data_gen_id)
 807
 808void 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
 853fail:
 854        drbd_debugfs_device_cleanup(device);
 855        drbd_err(device, "failed to create debugfs entries\n");
 856}
 857
 858void 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
 868void 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
 884fail:
 885        drbd_debugfs_peer_device_cleanup(peer_device);
 886        drbd_err(peer_device, "failed to create debugfs entries\n");
 887}
 888
 889void drbd_debugfs_peer_device_cleanup(struct drbd_peer_device *peer_device)
 890{
 891        drbd_debugfs_remove(&peer_device->debugfs_peer_dev);
 892}
 893
 894static 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
 904static int drbd_version_open(struct inode *inode, struct file *file)
 905{
 906        return single_open(file, drbd_version_show, NULL);
 907}
 908
 909static 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. */
 919void 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
 927int __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
 952fail:
 953        drbd_debugfs_cleanup();
 954        if (dentry)
 955                return PTR_ERR(dentry);
 956        else
 957                return -EINVAL;
 958}
 959