fs/dlm/debug_fs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /******************************************************************************
   3 *******************************************************************************
   4 **
   5 **  Copyright (C) 2005-2009 Red Hat, Inc.  All rights reserved.
   6 **
   7 **
   8 *******************************************************************************
   9 ******************************************************************************/
  10
  11 #include <linux/pagemap.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/init.h>
  14 #include <linux/ctype.h>
  15 #include <linux/debugfs.h>
  16 #include <linux/slab.h>
  17
  18 #include "dlm_internal.h"
  19 #include "lock.h"
  20
  21 #define DLM_DEBUG_BUF_LEN 4096
  22 static char debug_buf[DLM_DEBUG_BUF_LEN];
  23 static struct mutex debug_buf_lock;
  24
  25 static struct dentry *dlm_root;
  26
  27 static char *print_lockmode(int mode)
  28 {
  29         switch (mode) {
  30         case DLM_LOCK_IV:
  31                 return "--";
  32         case DLM_LOCK_NL:
  33                 return "NL";
  34         case DLM_LOCK_CR:
  35                 return "CR";
  36         case DLM_LOCK_CW:
  37                 return "CW";
  38         case DLM_LOCK_PR:
  39                 return "PR";
  40         case DLM_LOCK_PW:
  41                 return "PW";
  42         case DLM_LOCK_EX:
  43                 return "EX";
  44         default:
  45                 return "??";
  46         }
  47 }
  48
  49 static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
  50                                struct dlm_rsb *res)
  51 {
  52         seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
  53
  54         if (lkb->lkb_status == DLM_LKSTS_CONVERT ||
  55             lkb->lkb_status == DLM_LKSTS_WAITING)
  56                 seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));
  57
  58         if (lkb->lkb_nodeid) {
  59                 if (lkb->lkb_nodeid != res->res_nodeid)
  60                         seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,
  61                                    lkb->lkb_remid);
  62                 else
  63                         seq_printf(s, " Master:     %08x", lkb->lkb_remid);
  64         }
  65
  66         if (lkb->lkb_wait_type)
  67                 seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
  68
  69         seq_putc(s, '\n');
  70 }
  71
  72 static void print_format1(struct dlm_rsb *res, struct seq_file *s)
  73 {
  74         struct dlm_lkb *lkb;
  75         int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
  76
  77         lock_rsb(res);
  78
  79         seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
  80
  81         for (i = 0; i < res->res_length; i++) {
  82                 if (isprint(res->res_name[i]))
  83                         seq_printf(s, "%c", res->res_name[i]);
  84                 else
  85                         seq_printf(s, "%c", '.');
  86         }
  87
  88         if (res->res_nodeid > 0)
  89                 seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
  90                            res->res_nodeid);
  91         else if (res->res_nodeid == 0)
  92                 seq_puts(s, "\"\nMaster Copy\n");
  93         else if (res->res_nodeid == -1)
  94                 seq_printf(s, "\"\nLooking up master (lkid %x)\n",
  95                            res->res_first_lkid);
  96         else
  97                 seq_printf(s, "\"\nInvalid master %d\n", res->res_nodeid);
  98         if (seq_has_overflowed(s))
  99                 goto out;
 100
 101         /* Print the LVB: */
 102         if (res->res_lvbptr) {
 103                 seq_puts(s, "LVB: ");
 104                 for (i = 0; i < lvblen; i++) {
 105                         if (i == lvblen / 2)
 106                                 seq_puts(s, "\n     ");
 107                         seq_printf(s, "%02x ",
 108                                    (unsigned char) res->res_lvbptr[i]);
 109                 }
 110                 if (rsb_flag(res, RSB_VALNOTVALID))
 111                         seq_puts(s, " (INVALID)");
 112                 seq_putc(s, '\n');
 113                 if (seq_has_overflowed(s))
 114                         goto out;
 115         }
 116
 117         root_list = !list_empty(&res->res_root_list);
 118         recover_list = !list_empty(&res->res_recover_list);
 119
 120         if (root_list || recover_list) {
 121                 seq_printf(s, "Recovery: root %d recover %d flags %lx count %d\n",
 122                            root_list, recover_list,
 123                            res->res_flags, res->res_recover_locks_count);
 124         }
 125
 126         /* Print the locks attached to this resource */
 127         seq_puts(s, "Granted Queue\n");
 128         list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
 129                 print_format1_lock(s, lkb, res);
 130                 if (seq_has_overflowed(s))
 131                         goto out;
 132         }
 133
 134         seq_puts(s, "Conversion Queue\n");
 135         list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
 136                 print_format1_lock(s, lkb, res);
 137                 if (seq_has_overflowed(s))
 138                         goto out;
 139         }
 140
 141         seq_puts(s, "Waiting Queue\n");
 142         list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
 143                 print_format1_lock(s, lkb, res);
 144                 if (seq_has_overflowed(s))
 145                         goto out;
 146         }
 147
 148         if (list_empty(&res->res_lookup))
 149                 goto out;
 150
 151         seq_puts(s, "Lookup Queue\n");
 152         list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
 153                 seq_printf(s, "%08x %s",
 154                            lkb->lkb_id, print_lockmode(lkb->lkb_rqmode));
 155                 if (lkb->lkb_wait_type)
 156                         seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
 157                 seq_putc(s, '\n');
 158                 if (seq_has_overflowed(s))
 159                         goto out;
 160         }
 161  out:
 162         unlock_rsb(res);
 163 }
 164
 165 static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
 166                                struct dlm_rsb *r)
 167 {
 168         u64 xid = 0;
 169         u64 us;
 170
 171         if (lkb->lkb_flags & DLM_IFL_USER) {
 172                 if (lkb->lkb_ua)
 173                         xid = lkb->lkb_ua->xid;
 174         }
 175
 176         /* microseconds since lkb was added to current queue */
 177         us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_timestamp));
 178
 179         /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us
 180            r_nodeid r_len r_name */
 181
 182         seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
 183                    lkb->lkb_id,
 184                    lkb->lkb_nodeid,
 185                    lkb->lkb_remid,
 186                    lkb->lkb_ownpid,
 187                    (unsigned long long)xid,
 188                    lkb->lkb_exflags,
 189                    lkb->lkb_flags,
 190                    lkb->lkb_status,
 191                    lkb->lkb_grmode,
 192                    lkb->lkb_rqmode,
 193                    (unsigned long long)us,
 194                    r->res_nodeid,
 195                    r->res_length,
 196                    r->res_name);
 197 }
 198
 199 static void print_format2(struct dlm_rsb *r, struct seq_file *s)
 200 {
 201         struct dlm_lkb *lkb;
 202
 203         lock_rsb(r);
 204
 205         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
 206                 print_format2_lock(s, lkb, r);
 207                 if (seq_has_overflowed(s))
 208                         goto out;
 209         }
 210
 211         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
 212                 print_format2_lock(s, lkb, r);
 213                 if (seq_has_overflowed(s))
 214                         goto out;
 215         }
 216
 217         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
 218                 print_format2_lock(s, lkb, r);
 219                 if (seq_has_overflowed(s))
 220                         goto out;
 221         }
 222  out:
 223         unlock_rsb(r);
 224 }
 225
 226 static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
 227                               int rsb_lookup)
 228 {
 229         u64 xid = 0;
 230
 231         if (lkb->lkb_flags & DLM_IFL_USER) {
 232                 if (lkb->lkb_ua)
 233                         xid = lkb->lkb_ua->xid;
 234         }
 235
 236         seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
 237                    lkb->lkb_id,
 238                    lkb->lkb_nodeid,
 239                    lkb->lkb_remid,
 240                    lkb->lkb_ownpid,
 241                    (unsigned long long)xid,
 242                    lkb->lkb_exflags,
 243                    lkb->lkb_flags,
 244                    lkb->lkb_status,
 245                    lkb->lkb_grmode,
 246                    lkb->lkb_rqmode,
 247                    lkb->lkb_last_bast.mode,
 248                    rsb_lookup,
 249                    lkb->lkb_wait_type,
 250                    lkb->lkb_lvbseq,
 251                    (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
 252                    (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
 253 }
 254
 255 static void print_format3(struct dlm_rsb *r, struct seq_file *s)
 256 {
 257         struct dlm_lkb *lkb;
 258         int i, lvblen = r->res_ls->ls_lvblen;
 259         int print_name = 1;
 260
 261         lock_rsb(r);
 262
 263         seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
 264                    r,
 265                    r->res_nodeid,
 266                    r->res_first_lkid,
 267                    r->res_flags,
 268                    !list_empty(&r->res_root_list),
 269                    !list_empty(&r->res_recover_list),
 270                    r->res_recover_locks_count,
 271                    r->res_length);
 272         if (seq_has_overflowed(s))
 273                 goto out;
 274
 275         for (i = 0; i < r->res_length; i++) {
 276                 if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
 277                         print_name = 0;
 278         }
 279
 280         seq_puts(s, print_name ? "str " : "hex");
 281
 282         for (i = 0; i < r->res_length; i++) {
 283                 if (print_name)
 284                         seq_printf(s, "%c", r->res_name[i]);
 285                 else
 286                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
 287         }
 288         seq_putc(s, '\n');
 289         if (seq_has_overflowed(s))
 290                 goto out;
 291
 292         if (!r->res_lvbptr)
 293                 goto do_locks;
 294
 295         seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen);
 296
 297         for (i = 0; i < lvblen; i++)
 298                 seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
 299         seq_putc(s, '\n');
 300         if (seq_has_overflowed(s))
 301                 goto out;
 302
 303  do_locks:
 304         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
 305                 print_format3_lock(s, lkb, 0);
 306                 if (seq_has_overflowed(s))
 307                         goto out;
 308         }
 309
 310         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
 311                 print_format3_lock(s, lkb, 0);
 312                 if (seq_has_overflowed(s))
 313                         goto out;
 314         }
 315
 316         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
 317                 print_format3_lock(s, lkb, 0);
 318                 if (seq_has_overflowed(s))
 319                         goto out;
 320         }
 321
 322         list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) {
 323                 print_format3_lock(s, lkb, 1);
 324                 if (seq_has_overflowed(s))
 325                         goto out;
 326         }
 327  out:
 328         unlock_rsb(r);
 329 }
 330
 331 static void print_format4(struct dlm_rsb *r, struct seq_file *s)
 332 {
 333         int our_nodeid = dlm_our_nodeid();
 334         int print_name = 1;
 335         int i;
 336
 337         lock_rsb(r);
 338
 339         seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
 340                    r,
 341                    r->res_nodeid,
 342                    r->res_master_nodeid,
 343                    r->res_dir_nodeid,
 344                    our_nodeid,
 345                    r->res_toss_time,
 346                    r->res_flags,
 347                    r->res_length);
 348
 349         for (i = 0; i < r->res_length; i++) {
 350                 if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
 351                         print_name = 0;
 352         }
 353
 354         seq_puts(s, print_name ? "str " : "hex");
 355
 356         for (i = 0; i < r->res_length; i++) {
 357                 if (print_name)
 358                         seq_printf(s, "%c", r->res_name[i]);
 359                 else
 360                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
 361         }
 362         seq_putc(s, '\n');
 363         unlock_rsb(r);
 364 }
 365
 366 struct rsbtbl_iter {
 367         struct dlm_rsb *rsb;
 368         unsigned bucket;
 369         int format;
 370         int header;
 371 };
 372
 373 /*
 374  * If the buffer is full, seq_printf can be called again, but it
 375  * does nothing.  So, the these printing routines periodically check
 376  * seq_has_overflowed to avoid wasting too much time trying to print to
 377  * a full buffer.
 378  */
 379
 380 static int table_seq_show(struct seq_file *seq, void *iter_ptr)
 381 {
 382         struct rsbtbl_iter *ri = iter_ptr;
 383
 384         switch (ri->format) {
 385         case 1:
 386                 print_format1(ri->rsb, seq);
 387                 break;
 388         case 2:
 389                 if (ri->header) {
 390                         seq_puts(seq, "id nodeid remid pid xid exflags flags sts grmode rqmode time_ms r_nodeid r_len r_name\n");
 391                         ri->header = 0;
 392                 }
 393                 print_format2(ri->rsb, seq);
 394                 break;
 395         case 3:
 396                 if (ri->header) {
 397                         seq_puts(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
 398                         ri->header = 0;
 399                 }
 400                 print_format3(ri->rsb, seq);
 401                 break;
 402         case 4:
 403                 if (ri->header) {
 404                         seq_puts(seq, "version 4 rsb 2\n");
 405                         ri->header = 0;
 406                 }
 407                 print_format4(ri->rsb, seq);
 408                 break;
 409         }
 410
 411         return 0;
 412 }
 413
 414 static const struct seq_operations format1_seq_ops;
 415 static const struct seq_operations format2_seq_ops;
 416 static const struct seq_operations format3_seq_ops;
 417 static const struct seq_operations format4_seq_ops;
 418
 419 static void *table_seq_start(struct seq_file *seq, loff_t *pos)
 420 {
 421         struct rb_root *tree;
 422         struct rb_node *node;
 423         struct dlm_ls *ls = seq->private;
 424         struct rsbtbl_iter *ri;
 425         struct dlm_rsb *r;
 426         loff_t n = *pos;
 427         unsigned bucket, entry;
 428         int toss = (seq->op == &format4_seq_ops);
 429
 430         bucket = n >> 32;
 431         entry = n & ((1LL << 32) - 1);
 432
 433         if (bucket >= ls->ls_rsbtbl_size)
 434                 return NULL;
 435
 436         ri = kzalloc(sizeof(*ri), GFP_NOFS);
 437         if (!ri)
 438                 return NULL;
 439         if (n == 0)
 440                 ri->header = 1;
 441         if (seq->op == &format1_seq_ops)
 442                 ri->format = 1;
 443         if (seq->op == &format2_seq_ops)
 444                 ri->format = 2;
 445         if (seq->op == &format3_seq_ops)
 446                 ri->format = 3;
 447         if (seq->op == &format4_seq_ops)
 448                 ri->format = 4;
 449
 450         tree = toss ? &ls->ls_rsbtbl[bucket].toss : &ls->ls_rsbtbl[bucket].keep;
 451
 452         spin_lock(&ls->ls_rsbtbl[bucket].lock);
 453         if (!RB_EMPTY_ROOT(tree)) {
 454                 for (node = rb_first(tree); node; node = rb_next(node)) {
 455                         r = rb_entry(node, struct dlm_rsb, res_hashnode);
 456                         if (!entry--) {
 457                                 dlm_hold_rsb(r);
 458                                 ri->rsb = r;
 459                                 ri->bucket = bucket;
 460                                 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 461                                 return ri;
 462                         }
 463                 }
 464         }
 465         spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 466
 467         /*
 468          * move to the first rsb in the next non-empty bucket
 469          */
 470
 471         /* zero the entry */
 472         n &= ~((1LL << 32) - 1);
 473
 474         while (1) {
 475                 bucket++;
 476                 n += 1LL << 32;
 477
 478                 if (bucket >= ls->ls_rsbtbl_size) {
 479                         kfree(ri);
 480                         return NULL;
 481                 }
 482                 tree = toss ? &ls->ls_rsbtbl[bucket].toss : &ls->ls_rsbtbl[bucket].keep;
 483
 484                 spin_lock(&ls->ls_rsbtbl[bucket].lock);
 485                 if (!RB_EMPTY_ROOT(tree)) {
 486                         node = rb_first(tree);
 487                         r = rb_entry(node, struct dlm_rsb, res_hashnode);
 488                         dlm_hold_rsb(r);
 489                         ri->rsb = r;
 490                         ri->bucket = bucket;
 491                         spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 492                         *pos = n;
 493                         return ri;
 494                 }
 495                 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 496         }
 497 }
 498
 499 static void *table_seq_next(struct seq_file *seq, void *iter_ptr, loff_t *pos)
 500 {
 501         struct dlm_ls *ls = seq->private;
 502         struct rsbtbl_iter *ri = iter_ptr;
 503         struct rb_root *tree;
 504         struct rb_node *next;
 505         struct dlm_rsb *r, *rp;
 506         loff_t n = *pos;
 507         unsigned bucket;
 508         int toss = (seq->op == &format4_seq_ops);
 509
 510         bucket = n >> 32;
 511
 512         /*
 513          * move to the next rsb in the same bucket
 514          */
 515
 516         spin_lock(&ls->ls_rsbtbl[bucket].lock);
 517         rp = ri->rsb;
 518         next = rb_next(&rp->res_hashnode);
 519
 520         if (next) {
 521                 r = rb_entry(next, struct dlm_rsb, res_hashnode);
 522                 dlm_hold_rsb(r);
 523                 ri->rsb = r;
 524                 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 525                 dlm_put_rsb(rp);
 526                 ++*pos;
 527                 return ri;
 528         }
 529         spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 530         dlm_put_rsb(rp);
 531
 532         /*
 533          * move to the first rsb in the next non-empty bucket
 534          */
 535
 536         /* zero the entry */
 537         n &= ~((1LL << 32) - 1);
 538
 539         while (1) {
 540                 bucket++;
 541                 n += 1LL << 32;
 542
 543                 if (bucket >= ls->ls_rsbtbl_size) {
 544                         kfree(ri);
 545                         return NULL;
 546                 }
 547                 tree = toss ? &ls->ls_rsbtbl[bucket].toss : &ls->ls_rsbtbl[bucket].keep;
 548
 549                 spin_lock(&ls->ls_rsbtbl[bucket].lock);
 550                 if (!RB_EMPTY_ROOT(tree)) {
 551                         next = rb_first(tree);
 552                         r = rb_entry(next, struct dlm_rsb, res_hashnode);
 553                         dlm_hold_rsb(r);
 554                         ri->rsb = r;
 555                         ri->bucket = bucket;
 556                         spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 557                         *pos = n;
 558                         return ri;
 559                 }
 560                 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 561         }
 562 }
 563
 564 static void table_seq_stop(struct seq_file *seq, void *iter_ptr)
 565 {
 566         struct rsbtbl_iter *ri = iter_ptr;
 567
 568         if (ri) {
 569                 dlm_put_rsb(ri->rsb);
 570                 kfree(ri);
 571         }
 572 }
 573
 574 static const struct seq_operations format1_seq_ops = {
 575         .start = table_seq_start,
 576         .next  = table_seq_next,
 577         .stop  = table_seq_stop,
 578         .show  = table_seq_show,
 579 };
 580
 581 static const struct seq_operations format2_seq_ops = {
 582         .start = table_seq_start,
 583         .next  = table_seq_next,
 584         .stop  = table_seq_stop,
 585         .show  = table_seq_show,
 586 };
 587
 588 static const struct seq_operations format3_seq_ops = {
 589         .start = table_seq_start,
 590         .next  = table_seq_next,
 591         .stop  = table_seq_stop,
 592         .show  = table_seq_show,
 593 };
 594
 595 static const struct seq_operations format4_seq_ops = {
 596         .start = table_seq_start,
 597         .next  = table_seq_next,
 598         .stop  = table_seq_stop,
 599         .show  = table_seq_show,
 600 };
 601
 602 static const struct file_operations format1_fops;
 603 static const struct file_operations format2_fops;
 604 static const struct file_operations format3_fops;
 605 static const struct file_operations format4_fops;
 606
 607 static int table_open1(struct inode *inode, struct file *file)
 608 {
 609         struct seq_file *seq;
 610         int ret;
 611
 612         ret = seq_open(file, &format1_seq_ops);
 613         if (ret)
 614                 return ret;
 615
 616         seq = file->private_data;
 617         seq->private = inode->i_private; /* the dlm_ls */
 618         return 0;
 619 }
 620
 621 static int table_open2(struct inode *inode, struct file *file)
 622 {
 623         struct seq_file *seq;
 624         int ret;
 625
 626         ret = seq_open(file, &format2_seq_ops);
 627         if (ret)
 628                 return ret;
 629
 630         seq = file->private_data;
 631         seq->private = inode->i_private; /* the dlm_ls */
 632         return 0;
 633 }
 634
 635 static int table_open3(struct inode *inode, struct file *file)
 636 {
 637         struct seq_file *seq;
 638         int ret;
 639
 640         ret = seq_open(file, &format3_seq_ops);
 641         if (ret)
 642                 return ret;
 643
 644         seq = file->private_data;
 645         seq->private = inode->i_private; /* the dlm_ls */
 646         return 0;
 647 }
 648
 649 static int table_open4(struct inode *inode, struct file *file)
 650 {
 651         struct seq_file *seq;
 652         int ret;
 653
 654         ret = seq_open(file, &format4_seq_ops);
 655         if (ret)
 656                 return ret;
 657
 658         seq = file->private_data;
 659         seq->private = inode->i_private; /* the dlm_ls */
 660         return 0;
 661 }
 662
 663 static const struct file_operations format1_fops = {
 664         .owner   = THIS_MODULE,
 665         .open    = table_open1,
 666         .read    = seq_read,
 667         .llseek  = seq_lseek,
 668         .release = seq_release
 669 };
 670
 671 static const struct file_operations format2_fops = {
 672         .owner   = THIS_MODULE,
 673         .open    = table_open2,
 674         .read    = seq_read,
 675         .llseek  = seq_lseek,
 676         .release = seq_release
 677 };
 678
 679 static const struct file_operations format3_fops = {
 680         .owner   = THIS_MODULE,
 681         .open    = table_open3,
 682         .read    = seq_read,
 683         .llseek  = seq_lseek,
 684         .release = seq_release
 685 };
 686
 687 static const struct file_operations format4_fops = {
 688         .owner   = THIS_MODULE,
 689         .open    = table_open4,
 690         .read    = seq_read,
 691         .llseek  = seq_lseek,
 692         .release = seq_release
 693 };
 694
 695 /*
 696  * dump lkb's on the ls_waiters list
 697  */
 698 static ssize_t waiters_read(struct file *file, char __user *userbuf,
 699                             size_t count, loff_t *ppos)
 700 {
 701         struct dlm_ls *ls = file->private_data;
 702         struct dlm_lkb *lkb;
 703         size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
 704
 705         mutex_lock(&debug_buf_lock);
 706         mutex_lock(&ls->ls_waiters_mutex);
 707         memset(debug_buf, 0, sizeof(debug_buf));
 708
 709         list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
 710                 ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
 711                                lkb->lkb_id, lkb->lkb_wait_type,
 712                                lkb->lkb_nodeid, lkb->lkb_resource->res_name);
 713                 if (ret >= len - pos)
 714                         break;
 715                 pos += ret;
 716         }
 717         mutex_unlock(&ls->ls_waiters_mutex);
 718
 719         rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);
 720         mutex_unlock(&debug_buf_lock);
 721         return rv;
 722 }
 723
 724 static const struct file_operations waiters_fops = {
 725         .owner   = THIS_MODULE,
 726         .open    = simple_open,
 727         .read    = waiters_read,
 728         .llseek  = default_llseek,
 729 };
 730
 731 void dlm_delete_debug_file(struct dlm_ls *ls)
 732 {
 733         debugfs_remove(ls->ls_debug_rsb_dentry);
 734         debugfs_remove(ls->ls_debug_waiters_dentry);
 735         debugfs_remove(ls->ls_debug_locks_dentry);
 736         debugfs_remove(ls->ls_debug_all_dentry);
 737         debugfs_remove(ls->ls_debug_toss_dentry);
 738 }
 739
 740 void dlm_create_debug_file(struct dlm_ls *ls)
 741 {
 742         char name[DLM_LOCKSPACE_LEN + 8];
 743
 744         /* format 1 */
 745
 746         ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
 747                                                       S_IFREG | S_IRUGO,
 748                                                       dlm_root,
 749                                                       ls,
 750                                                       &format1_fops);
 751
 752         /* format 2 */
 753
 754         memset(name, 0, sizeof(name));
 755         snprintf(name, DLM_LOCKSPACE_LEN + 8, "%s_locks", ls->ls_name);
 756
 757         ls->ls_debug_locks_dentry = debugfs_create_file(name,
 758                                                         S_IFREG | S_IRUGO,
 759                                                         dlm_root,
 760                                                         ls,
 761                                                         &format2_fops);
 762
 763         /* format 3 */
 764
 765         memset(name, 0, sizeof(name));
 766         snprintf(name, DLM_LOCKSPACE_LEN + 8, "%s_all", ls->ls_name);
 767
 768         ls->ls_debug_all_dentry = debugfs_create_file(name,
 769                                                       S_IFREG | S_IRUGO,
 770                                                       dlm_root,
 771                                                       ls,
 772                                                       &format3_fops);
 773
 774         /* format 4 */
 775
 776         memset(name, 0, sizeof(name));
 777         snprintf(name, DLM_LOCKSPACE_LEN + 8, "%s_toss", ls->ls_name);
 778
 779         ls->ls_debug_toss_dentry = debugfs_create_file(name,
 780                                                        S_IFREG | S_IRUGO,
 781                                                        dlm_root,
 782                                                        ls,
 783                                                        &format4_fops);
 784
 785         memset(name, 0, sizeof(name));
 786         snprintf(name, DLM_LOCKSPACE_LEN + 8, "%s_waiters", ls->ls_name);
 787
 788         ls->ls_debug_waiters_dentry = debugfs_create_file(name,
 789                                                           S_IFREG | S_IRUGO,
 790                                                           dlm_root,
 791                                                           ls,
 792                                                           &waiters_fops);
 793 }
 794
 795 void __init dlm_register_debugfs(void)
 796 {
 797         mutex_init(&debug_buf_lock);
 798         dlm_root = debugfs_create_dir("dlm", NULL);
 799 }
 800
 801 void dlm_unregister_debugfs(void)
 802 {
 803         debugfs_remove(dlm_root);
 804 }
 805