misc-utils/lslocks.c

   1 /*
   2  * lslocks(8) - list local system locks
   3  *
   4  * Copyright (C) 2012 Davidlohr Bueso <dave@gnu.org>
   5  *
   6  * Very generally based on lslk(8) by Victor A. Abell <abe@purdue.edu>
   7  * Since it stopped being maintained over a decade ago, this
   8  * program should be considered its replacement.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it would be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <getopt.h>
  28 #include <stdlib.h>
  29 #include <assert.h>
  30 #include <dirent.h>
  31 #include <unistd.h>
  32 #include <sys/stat.h>
  33 #include <sys/types.h>
  34
  35 #include <libmount.h>
  36 #include <libsmartcols.h>
  37
  38 #include "pathnames.h"
  39 #include "canonicalize.h"
  40 #include "nls.h"
  41 #include "xalloc.h"
  42 #include "strutils.h"
  43 #include "c.h"
  44 #include "list.h"
  45 #include "closestream.h"
  46 #include "optutils.h"
  47 #include "procutils.h"
  48
  49 /* column IDs */
  50 enum {
  51         COL_SRC = 0,
  52         COL_PID,
  53         COL_TYPE,
  54         COL_SIZE,
  55         COL_MODE,
  56         COL_M,
  57         COL_START,
  58         COL_END,
  59         COL_PATH,
  60         COL_BLOCKER
  61 };
  62
  63 /* column names */
  64 struct colinfo {
  65         const char *name; /* header */
  66         double     whint; /* width hint (N < 1 is in percent of termwidth) */
  67         int        flags; /* SCOLS_FL_* */
  68         const char *help;
  69 };
  70
  71 /* columns descriptions */
  72 static struct colinfo infos[] = {
  73         [COL_SRC]  = { "COMMAND",15, 0, N_("command of the process holding the lock") },
  74         [COL_PID]  = { "PID",     5, SCOLS_FL_RIGHT, N_("PID of the process holding the lock") },
  75         [COL_TYPE] = { "TYPE",    5, SCOLS_FL_RIGHT, N_("kind of lock") },
  76         [COL_SIZE] = { "SIZE",    4, SCOLS_FL_RIGHT, N_("size of the lock") },
  77         [COL_MODE] = { "MODE",    5, 0, N_("lock access mode") },
  78         [COL_M]    = { "M",       1, 0, N_("mandatory state of the lock: 0 (none), 1 (set)")},
  79         [COL_START] = { "START", 10, SCOLS_FL_RIGHT, N_("relative byte offset of the lock")},
  80         [COL_END]  = { "END",    10, SCOLS_FL_RIGHT, N_("ending offset of the lock")},
  81         [COL_PATH] = { "PATH",    0, SCOLS_FL_TRUNC, N_("path of the locked file")},
  82         [COL_BLOCKER] = { "BLOCKER", 0, SCOLS_FL_RIGHT, N_("PID of the process blocking the lock") }
  83 };
  84
  85 static int columns[ARRAY_SIZE(infos) * 2];
  86 static size_t ncolumns;
  87
  88 static pid_t pid = 0;
  89
  90 static struct libmnt_table *tab;                /* /proc/self/mountinfo */
  91
  92 /* basic output flags */
  93 static int no_headings;
  94 static int no_inaccessible;
  95 static int raw;
  96 static int json;
  97 static int bytes;
  98
  99 struct lock {
 100         struct list_head locks;
 101
 102         char *cmdname;
 103         pid_t pid;
 104         char *path;
 105         char *type;
 106         char *mode;
 107         off_t start;
 108         off_t end;
 109         unsigned int mandatory :1,
 110                      blocked   :1;
 111         uint64_t size;
 112         int id;
 113 };
 114
 115 static void rem_lock(struct lock *lock)
 116 {
 117         if (!lock)
 118                 return;
 119
 120         free(lock->path);
 121         free(lock->mode);
 122         free(lock->cmdname);
 123         free(lock->type);
 124         list_del(&lock->locks);
 125         free(lock);
 126 }
 127
 128 static void disable_columns_truncate(void)
 129 {
 130         size_t i;
 131
 132         for (i = 0; i < ARRAY_SIZE(infos); i++)
 133                 infos[i].flags &= ~SCOLS_FL_TRUNC;
 134 }
 135
 136 /*
 137  * Associate the device's mountpoint for a filename
 138  */
 139 static char *get_fallback_filename(dev_t dev)
 140 {
 141         struct libmnt_fs *fs;
 142         char *res = NULL;
 143
 144         if (!tab) {
 145                 tab = mnt_new_table_from_file(_PATH_PROC_MOUNTINFO);
 146                 if (!tab)
 147                         return NULL;
 148         }
 149
 150         fs = mnt_table_find_devno(tab, dev, MNT_ITER_BACKWARD);
 151         if (!fs)
 152                 return NULL;
 153
 154         xasprintf(&res, "%s...", mnt_fs_get_target(fs));
 155         return res;
 156 }
 157
 158 /*
 159  * Return the absolute path of a file from
 160  * a given inode number (and its size)
 161  */
 162 static char *get_filename_sz(ino_t inode, pid_t lock_pid, size_t *size)
 163 {
 164         struct stat sb;
 165         struct dirent *dp;
 166         DIR *dirp;
 167         size_t len;
 168         int fd;
 169         char path[PATH_MAX], sym[PATH_MAX], *ret = NULL;
 170
 171         *size = 0;
 172         memset(path, 0, sizeof(path));
 173         memset(sym, 0, sizeof(sym));
 174
 175         /*
 176          * We know the pid so we don't have to
 177          * iterate the *entire* filesystem searching
 178          * for the damn file.
 179          */
 180         sprintf(path, "/proc/%d/fd/", lock_pid);
 181         if (!(dirp = opendir(path)))
 182                 return NULL;
 183
 184         if ((len = strlen(path)) >= (sizeof(path) - 2))
 185                 goto out;
 186
 187         if ((fd = dirfd(dirp)) < 0 )
 188                 goto out;
 189
 190         while ((dp = readdir(dirp))) {
 191                 if (!strcmp(dp->d_name, ".") ||
 192                     !strcmp(dp->d_name, ".."))
 193                         continue;
 194
 195                 /* care only for numerical descriptors */
 196                 if (!strtol(dp->d_name, (char **) NULL, 10))
 197                         continue;
 198
 199                 if (!fstatat(fd, dp->d_name, &sb, 0)
 200                     && inode != sb.st_ino)
 201                         continue;
 202
 203                 if ((len = readlinkat(fd, dp->d_name, sym, sizeof(sym) - 1)) < 1)
 204                         goto out;
 205
 206                 *size = sb.st_size;
 207                 sym[len] = '\0';
 208
 209                 ret = xstrdup(sym);
 210                 break;
 211         }
 212 out:
 213         closedir(dirp);
 214         return ret;
 215 }
 216
 217 /*
 218  * Return the inode number from a string
 219  */
 220 static ino_t get_dev_inode(char *str, dev_t *dev)
 221 {
 222         unsigned int maj = 0, min = 0;
 223         ino_t inum = 0;
 224
 225         sscanf(str, "%02x:%02x:%ju", &maj, &min, &inum);
 226
 227         *dev = (dev_t) makedev(maj, min);
 228         return inum;
 229 }
 230
 231 static int get_local_locks(struct list_head *locks)
 232 {
 233         int i;
 234         ino_t inode = 0;
 235         FILE *fp;
 236         char buf[PATH_MAX], *tok = NULL;
 237         size_t sz;
 238         struct lock *l;
 239         dev_t dev = 0;
 240
 241         if (!(fp = fopen(_PATH_PROC_LOCKS, "r")))
 242                 return -1;
 243
 244         while (fgets(buf, sizeof(buf), fp)) {
 245
 246                 l = xcalloc(1, sizeof(*l));
 247                 INIT_LIST_HEAD(&l->locks);
 248
 249                 for (tok = strtok(buf, " "), i = 0; tok;
 250                      tok = strtok(NULL, " "), i++) {
 251
 252                         /*
 253                          * /proc/locks has *exactly* 8 "blocks" of text
 254                          * separated by ' ' - check <kernel>/fs/locks.c
 255                          */
 256                         switch (i) {
 257                         case 0: /* ID: */
 258                                 tok[strlen(tok) - 1] = '\0';
 259                                 l->id = strtos32_or_err(tok, _("failed to parse ID"));
 260                                 break;
 261                         case 1: /* posix, flock, etc */
 262                                 if (strcmp(tok, "->") == 0) {   /* optional field */
 263                                         l->blocked = 1;
 264                                         i--;
 265                                 } else
 266                                         l->type = xstrdup(tok);
 267                                 break;
 268
 269                         case 2: /* is this a mandatory lock? other values are advisory or noinode */
 270                                 l->mandatory = *tok == 'M' ? 1 : 0;
 271                                 break;
 272                         case 3: /* lock mode */
 273                                 l->mode = xstrdup(tok);
 274                                 break;
 275
 276                         case 4: /* PID */
 277                                 /*
 278                                  * If user passed a pid we filter it later when adding
 279                                  * to the list, no need to worry now. OFD locks use -1 PID.
 280                                  */
 281                                 l->pid = strtos32_or_err(tok, _("failed to parse pid"));
 282                                 if (l->pid > 0) {
 283                                         l->cmdname = proc_get_command_name(l->pid);
 284                                         if (!l->cmdname)
 285                                                 l->cmdname = xstrdup(_("(unknown)"));
 286                                 } else
 287                                         l->cmdname = xstrdup(_("(undefined)"));
 288                                 break;
 289
 290                         case 5: /* device major:minor and inode number */
 291                                 inode = get_dev_inode(tok, &dev);
 292                                 break;
 293
 294                         case 6: /* start */
 295                                 l->start = !strcmp(tok, "EOF") ? 0 :
 296                                            strtou64_or_err(tok, _("failed to parse start"));
 297                                 break;
 298
 299                         case 7: /* end */
 300                                 /* replace '\n' character */
 301                                 tok[strlen(tok)-1] = '\0';
 302                                 l->end = !strcmp(tok, "EOF") ? 0 :
 303                                          strtou64_or_err(tok, _("failed to parse end"));
 304                                 break;
 305                         default:
 306                                 break;
 307                         }
 308                 }
 309
 310                 l->path = get_filename_sz(inode, l->pid, &sz);
 311
 312                 /* no permissions -- ignore */
 313                 if (!l->path && no_inaccessible) {
 314                         rem_lock(l);
 315                         continue;
 316                 }
 317
 318                 if (!l->path) {
 319                         /* probably no permission to peek into l->pid's path */
 320                         l->path = get_fallback_filename(dev);
 321                         l->size = 0;
 322                 } else
 323                         l->size = sz;
 324
 325                 list_add(&l->locks, locks);
 326         }
 327
 328         fclose(fp);
 329         return 0;
 330 }
 331
 332 static int column_name_to_id(const char *name, size_t namesz)
 333 {
 334         size_t i;
 335
 336         assert(name);
 337
 338         for (i = 0; i < ARRAY_SIZE(infos); i++) {
 339                 const char *cn = infos[i].name;
 340
 341                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 342                         return i;
 343         }
 344         warnx(_("unknown column: %s"), name);
 345         return -1;
 346 }
 347
 348 static inline int get_column_id(int num)
 349 {
 350         assert(num >= 0);
 351         assert((size_t) num < ncolumns);
 352         assert(columns[num] < (int) ARRAY_SIZE(infos));
 353
 354         return columns[num];
 355 }
 356
 357
 358 static inline struct colinfo *get_column_info(unsigned num)
 359 {
 360         return &infos[ get_column_id(num) ];
 361 }
 362
 363 static pid_t get_blocker(int id, struct list_head *locks)
 364 {
 365         struct list_head *p;
 366
 367         list_for_each(p, locks) {
 368                 struct lock *l = list_entry(p, struct lock, locks);
 369
 370                 if (l->id == id && !l->blocked)
 371                         return l->pid;
 372         }
 373
 374         return 0;
 375 }
 376
 377 static void add_scols_line(struct libscols_table *table, struct lock *l, struct list_head *locks)
 378 {
 379         size_t i;
 380         struct libscols_line *line;
 381         /*
 382          * Whenever cmdname or filename is NULL it is most
 383          * likely  because there's no read permissions
 384          * for the specified process.
 385          */
 386         const char *notfnd = "";
 387
 388         assert(l);
 389         assert(table);
 390
 391         line = scols_table_new_line(table, NULL);
 392         if (!line)
 393                 err(EXIT_FAILURE, _("failed to allocate output line"));
 394
 395         for (i = 0; i < ncolumns; i++) {
 396                 char *str = NULL;
 397
 398                 switch (get_column_id(i)) {
 399                 case COL_SRC:
 400                         xasprintf(&str, "%s", l->cmdname ? l->cmdname : notfnd);
 401                         break;
 402                 case COL_PID:
 403                         xasprintf(&str, "%d", l->pid);
 404                         break;
 405                 case COL_TYPE:
 406                         xasprintf(&str, "%s", l->type);
 407                         break;
 408                 case COL_SIZE:
 409                         if (!l->size)
 410                                 break;
 411                         if (bytes)
 412                                 xasprintf(&str, "%ju", l->size);
 413                         else
 414                                 str = size_to_human_string(SIZE_SUFFIX_1LETTER, l->size);
 415                         break;
 416                 case COL_MODE:
 417                         xasprintf(&str, "%s%s", l->mode, l->blocked ? "*" : "");
 418                         break;
 419                 case COL_M:
 420                         xasprintf(&str, "%d", l->mandatory ? 1 : 0);
 421                         break;
 422                 case COL_START:
 423                         xasprintf(&str, "%jd", l->start);
 424                         break;
 425                 case COL_END:
 426                         xasprintf(&str, "%jd", l->end);
 427                         break;
 428                 case COL_PATH:
 429                         xasprintf(&str, "%s", l->path ? l->path : notfnd);
 430                         break;
 431                 case COL_BLOCKER:
 432                 {
 433                         pid_t bl = l->blocked && l->id ?
 434                                                 get_blocker(l->id, locks) : 0;
 435                         if (bl)
 436                                 xasprintf(&str, "%d", (int) bl);
 437                 }
 438                 default:
 439                         break;
 440                 }
 441
 442                 if (str && scols_line_refer_data(line, i, str))
 443                         err(EXIT_FAILURE, _("failed to add output data"));
 444         }
 445 }
 446
 447 static int show_locks(struct list_head *locks)
 448 {
 449         int rc = 0;
 450         size_t i;
 451         struct list_head *p, *pnext;
 452         struct libscols_table *table;
 453
 454         table = scols_new_table();
 455         if (!table)
 456                 err(EXIT_FAILURE, _("failed to allocate output table"));
 457
 458         scols_table_enable_raw(table, raw);
 459         scols_table_enable_json(table, json);
 460         scols_table_enable_noheadings(table, no_headings);
 461
 462         if (json)
 463                 scols_table_set_name(table, "locks");
 464
 465         for (i = 0; i < ncolumns; i++) {
 466                 struct libscols_column *cl;
 467                 struct colinfo *col = get_column_info(i);
 468
 469                 cl = scols_table_new_column(table, col->name, col->whint, col->flags);
 470                 if (!cl)
 471                         err(EXIT_FAILURE, _("failed to allocate output column"));
 472
 473                 if (json) {
 474                         int id = get_column_id(i);
 475
 476                         switch (id) {
 477                         case COL_SIZE:
 478                                 if (!bytes)
 479                                         break;
 480                                 /* fallthrough */
 481                         case COL_PID:
 482                         case COL_START:
 483                         case COL_END:
 484                         case COL_BLOCKER:
 485                                 scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
 486                                 break;
 487                         case COL_M:
 488                                 scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
 489                                 break;
 490                         default:
 491                                 scols_column_set_json_type(cl, SCOLS_JSON_STRING);
 492                                 break;
 493                         }
 494                 }
 495
 496         }
 497
 498         /* prepare data for output */
 499         list_for_each(p, locks) {
 500                 struct lock *l = list_entry(p, struct lock, locks);
 501
 502                 if (pid && pid != l->pid)
 503                         continue;
 504
 505                 add_scols_line(table, l, locks);
 506         }
 507
 508         /* destroy the list */
 509         list_for_each_safe(p, pnext, locks) {
 510                 struct lock *l = list_entry(p, struct lock, locks);
 511                 rem_lock(l);
 512         }
 513
 514         scols_print_table(table);
 515         scols_unref_table(table);
 516         return rc;
 517 }
 518
 519
 520 static void __attribute__((__noreturn__)) usage(void)
 521 {
 522         FILE *out = stdout;
 523         size_t i;
 524
 525         fputs(USAGE_HEADER, out);
 526
 527         fprintf(out,
 528                 _(" %s [options]\n"), program_invocation_short_name);
 529
 530         fputs(USAGE_SEPARATOR, out);
 531         fputs(_("List local system locks.\n"), out);
 532
 533         fputs(USAGE_OPTIONS, out);
 534         fputs(_(" -b, --bytes            print SIZE in bytes rather than in human readable format\n"), out);
 535         fputs(_(" -J, --json             use JSON output format\n"), out);
 536         fputs(_(" -i, --noinaccessible   ignore locks without read permissions\n"), out);
 537         fputs(_(" -n, --noheadings       don't print headings\n"), out);
 538         fputs(_(" -o, --output <list>    define which output columns to use\n"), out);
 539         fputs(_("     --output-all       output all columns\n"), out);
 540         fputs(_(" -p, --pid <pid>        display only locks held by this process\n"), out);
 541         fputs(_(" -r, --raw              use the raw output format\n"), out);
 542         fputs(_(" -u, --notruncate       don't truncate text in columns\n"), out);
 543
 544         fputs(USAGE_SEPARATOR, out);
 545         printf(USAGE_HELP_OPTIONS(24));
 546
 547         fputs(USAGE_COLUMNS, out);
 548
 549         for (i = 0; i < ARRAY_SIZE(infos); i++)
 550                 fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
 551
 552         printf(USAGE_MAN_TAIL("lslocks(8)"));
 553
 554         exit(EXIT_SUCCESS);
 555 }
 556
 557 int main(int argc, char *argv[])
 558 {
 559         int c, rc = 0;
 560         struct list_head locks;
 561         char *outarg = NULL;
 562         enum {
 563                 OPT_OUTPUT_ALL = CHAR_MAX + 1
 564         };
 565         static const struct option long_opts[] = {
 566                 { "bytes",      no_argument,       NULL, 'b' },
 567                 { "json",       no_argument,       NULL, 'J' },
 568                 { "pid",        required_argument, NULL, 'p' },
 569                 { "help",       no_argument,       NULL, 'h' },
 570                 { "output",     required_argument, NULL, 'o' },
 571                 { "output-all", no_argument,       NULL, OPT_OUTPUT_ALL },
 572                 { "notruncate", no_argument,       NULL, 'u' },
 573                 { "version",    no_argument,       NULL, 'V' },
 574                 { "noheadings", no_argument,       NULL, 'n' },
 575                 { "raw",        no_argument,       NULL, 'r' },
 576                 { "noinaccessible", no_argument, NULL, 'i' },
 577                 { NULL, 0, NULL, 0 }
 578         };
 579
 580         static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
 581                 { 'J','r' },
 582                 { 0 }
 583         };
 584         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 585         setlocale(LC_ALL, "");
 586         bindtextdomain(PACKAGE, LOCALEDIR);
 587         textdomain(PACKAGE);
 588         close_stdout_atexit();
 589
 590         while ((c = getopt_long(argc, argv,
 591                                 "biJp:o:nruhV", long_opts, NULL)) != -1) {
 592
 593                 err_exclusive_options(c, long_opts, excl, excl_st);
 594
 595                 switch(c) {
 596                 case 'b':
 597                         bytes = 1;
 598                         break;
 599                 case 'i':
 600                         no_inaccessible = 1;
 601                         break;
 602                 case 'J':
 603                         json = 1;
 604                         break;
 605                 case 'p':
 606                         pid = strtos32_or_err(optarg, _("invalid PID argument"));
 607                         break;
 608                 case 'o':
 609                         outarg = optarg;
 610                         break;
 611                 case OPT_OUTPUT_ALL:
 612                         for (ncolumns = 0; ncolumns < ARRAY_SIZE(infos); ncolumns++)
 613                                 columns[ncolumns] = ncolumns;
 614                         break;
 615                 case 'n':
 616                         no_headings = 1;
 617                         break;
 618                 case 'r':
 619                         raw = 1;
 620                         break;
 621                 case 'u':
 622                         disable_columns_truncate();
 623                         break;
 624
 625                 case 'V':
 626                         print_version(EXIT_SUCCESS);
 627                 case 'h':
 628                         usage();
 629                 default:
 630                         errtryhelp(EXIT_FAILURE);
 631                 }
 632         }
 633
 634         INIT_LIST_HEAD(&locks);
 635
 636         if (!ncolumns) {
 637                 /* default columns */
 638                 columns[ncolumns++] = COL_SRC;
 639                 columns[ncolumns++] = COL_PID;
 640                 columns[ncolumns++] = COL_TYPE;
 641                 columns[ncolumns++] = COL_SIZE;
 642                 columns[ncolumns++] = COL_MODE;
 643                 columns[ncolumns++] = COL_M;
 644                 columns[ncolumns++] = COL_START;
 645                 columns[ncolumns++] = COL_END;
 646                 columns[ncolumns++] = COL_PATH;
 647         }
 648
 649         if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
 650                                          &ncolumns, column_name_to_id) < 0)
 651                 return EXIT_FAILURE;
 652
 653         scols_init_debug(0);
 654
 655         rc = get_local_locks(&locks);
 656
 657         if (!rc && !list_empty(&locks))
 658                 rc = show_locks(&locks);
 659
 660         mnt_unref_table(tab);
 661         return rc;
 662 }