]> git.ipfire.org Git - thirdparty/util-linux.git/blob - misc-utils/lsblk.c
projects / thirdparty / util-linux.git / blob
? search:


bb16c23c13231381d13578b33c60b09426af4fff
[thirdparty/util-linux.git] / misc-utils / lsblk.c
1 /*
2 * lsblk(8) - list block devices
3 *
4 * Copyright (C) 2010,2011,2012 Red Hat, Inc. All rights reserved.
5 * Written by Milan Broz <mbroz@redhat.com>
6 * Karel Zak <kzak@redhat.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it would be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include <stdio.h>
24 #include <errno.h>
25 #include <getopt.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <dirent.h>
31 #include <fcntl.h>
32 #include <string.h>
33 #include <sys/ioctl.h>
34 #include <stdarg.h>
35 #include <locale.h>
36 #include <pwd.h>
37 #include <grp.h>
38 #include <ctype.h>
39 #include <assert.h>
40
41 #include <blkid.h>
42
43 #include "c.h"
44 #include "pathnames.h"
45 #include "blkdev.h"
46 #include "canonicalize.h"
47 #include "nls.h"
48 #include "xalloc.h"
49 #include "strutils.h"
50 #include "sysfs.h"
51 #include "closestream.h"
52 #include "optutils.h"
53
54 #include "lsblk.h"
55
56 UL_DEBUG_DEFINE_MASK(lsblk);
57 UL_DEBUG_DEFINE_MASKNAMES(lsblk) = UL_DEBUG_EMPTY_MASKNAMES;
58
59 #define LSBLK_EXIT_SOMEOK 64
60 #define LSBLK_EXIT_ALLFAILED 32
61
62 static int column_id_to_number(int id);
63
64 /* column IDs */
65 enum {
66 COL_NAME = 0,
67 COL_KNAME,
68 COL_PATH,
69 COL_MAJMIN,
70 COL_FSAVAIL,
71 COL_FSSIZE,
72 COL_FSTYPE,
73 COL_FSUSED,
74 COL_FSUSEPERC,
75 COL_TARGET,
76 COL_LABEL,
77 COL_UUID,
78 COL_PTUUID,
79 COL_PTTYPE,
80 COL_PARTTYPE,
81 COL_PARTLABEL,
82 COL_PARTUUID,
83 COL_PARTFLAGS,
84 COL_RA,
85 COL_RO,
86 COL_RM,
87 COL_HOTPLUG,
88 COL_MODEL,
89 COL_SERIAL,
90 COL_SIZE,
91 COL_STATE,
92 COL_OWNER,
93 COL_GROUP,
94 COL_MODE,
95 COL_ALIOFF,
96 COL_MINIO,
97 COL_OPTIO,
98 COL_PHYSEC,
99 COL_LOGSEC,
100 COL_ROTA,
101 COL_SCHED,
102 COL_RQ_SIZE,
103 COL_TYPE,
104 COL_DALIGN,
105 COL_DGRAN,
106 COL_DMAX,
107 COL_DZERO,
108 COL_WSAME,
109 COL_WWN,
110 COL_RAND,
111 COL_PKNAME,
112 COL_HCTL,
113 COL_TRANSPORT,
114 COL_SUBSYS,
115 COL_REV,
116 COL_VENDOR,
117 COL_ZONED,
118 };
119
120 /* basic table settings */
121 enum {
122 LSBLK_ASCII = (1 << 0),
123 LSBLK_RAW = (1 << 1),
124 LSBLK_NOHEADINGS = (1 << 2),
125 LSBLK_EXPORT = (1 << 3),
126 LSBLK_TREE = (1 << 4),
127 LSBLK_JSON = (1 << 5),
128 };
129
130 /* Types used for qsort() and JSON */
131 enum {
132 COLTYPE_STR = 0, /* default */
133 COLTYPE_NUM = 1, /* always u64 number */
134 COLTYPE_SORTNUM = 2, /* string on output, u64 for qsort() */
135 COLTYPE_SIZE = 3, /* srring by default, number when --bytes */
136 COLTYPE_BOOL = 4 /* 0 or 1 */
137 };
138
139 /* column names */
140 struct colinfo {
141 const char *name; /* header */
142 double whint; /* width hint (N < 1 is in percent of termwidth) */
143 int flags; /* SCOLS_FL_* */
144 const char *help;
145
146 int type; /* COLTYPE_* */
147 };
148
149 /* columns descriptions */
150 static struct colinfo infos[] = {
151 [COL_NAME] = { "NAME", 0.25, SCOLS_FL_TREE | SCOLS_FL_NOEXTREMES, N_("device name") },
152 [COL_KNAME] = { "KNAME", 0.3, 0, N_("internal kernel device name") },
153 [COL_PKNAME] = { "PKNAME", 0.3, 0, N_("internal parent kernel device name") },
154 [COL_PATH] = { "PATH", 0.3, 0, N_("path to the device node") },
155 [COL_MAJMIN] = { "MAJ:MIN", 6, 0, N_("major:minor device number"), COLTYPE_SORTNUM },
156
157 [COL_FSAVAIL] = { "FSAVAIL", 5, SCOLS_FL_RIGHT, N_("filesystem size available") },
158 [COL_FSSIZE] = { "FSSIZE", 5, SCOLS_FL_RIGHT, N_("filesystem size") },
159 [COL_FSTYPE] = { "FSTYPE", 0.1, SCOLS_FL_TRUNC, N_("filesystem type") },
160 [COL_FSUSED] = { "FSUSED", 5, SCOLS_FL_RIGHT, N_("filesystem size used") },
161 [COL_FSUSEPERC] = { "FSUSE%", 3, SCOLS_FL_RIGHT, N_("filesystem use percentage") },
162
163 [COL_TARGET] = { "MOUNTPOINT", 0.10, SCOLS_FL_TRUNC, N_("where the device is mounted") },
164 [COL_LABEL] = { "LABEL", 0.1, 0, N_("filesystem LABEL") },
165 [COL_UUID] = { "UUID", 36, 0, N_("filesystem UUID") },
166
167 [COL_PTUUID] = { "PTUUID", 36, 0, N_("partition table identifier (usually UUID)") },
168 [COL_PTTYPE] = { "PTTYPE", 0.1, 0, N_("partition table type") },
169
170 [COL_PARTTYPE] = { "PARTTYPE", 36, 0, N_("partition type UUID") },
171 [COL_PARTLABEL] = { "PARTLABEL", 0.1, 0, N_("partition LABEL") },
172 [COL_PARTUUID] = { "PARTUUID", 36, 0, N_("partition UUID") },
173 [COL_PARTFLAGS] = { "PARTFLAGS", 36, 0, N_("partition flags") },
174
175 [COL_RA] = { "RA", 3, SCOLS_FL_RIGHT, N_("read-ahead of the device"), COLTYPE_NUM },
176 [COL_RO] = { "RO", 1, SCOLS_FL_RIGHT, N_("read-only device"), COLTYPE_BOOL },
177 [COL_RM] = { "RM", 1, SCOLS_FL_RIGHT, N_("removable device"), COLTYPE_BOOL },
178 [COL_HOTPLUG]= { "HOTPLUG", 1, SCOLS_FL_RIGHT, N_("removable or hotplug device (usb, pcmcia, ...)"), COLTYPE_BOOL },
179 [COL_ROTA] = { "ROTA", 1, SCOLS_FL_RIGHT, N_("rotational device"), COLTYPE_BOOL },
180 [COL_RAND] = { "RAND", 1, SCOLS_FL_RIGHT, N_("adds randomness"), COLTYPE_BOOL },
181 [COL_MODEL] = { "MODEL", 0.1, SCOLS_FL_TRUNC, N_("device identifier") },
182 [COL_SERIAL] = { "SERIAL", 0.1, SCOLS_FL_TRUNC, N_("disk serial number") },
183 [COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the device"), COLTYPE_SIZE },
184 [COL_STATE] = { "STATE", 7, SCOLS_FL_TRUNC, N_("state of the device") },
185 [COL_OWNER] = { "OWNER", 0.1, SCOLS_FL_TRUNC, N_("user name"), },
186 [COL_GROUP] = { "GROUP", 0.1, SCOLS_FL_TRUNC, N_("group name") },
187 [COL_MODE] = { "MODE", 10, 0, N_("device node permissions") },
188 [COL_ALIOFF] = { "ALIGNMENT", 6, SCOLS_FL_RIGHT, N_("alignment offset"), COLTYPE_NUM },
189 [COL_MINIO] = { "MIN-IO", 6, SCOLS_FL_RIGHT, N_("minimum I/O size"), COLTYPE_NUM },
190 [COL_OPTIO] = { "OPT-IO", 6, SCOLS_FL_RIGHT, N_("optimal I/O size"), COLTYPE_NUM },
191 [COL_PHYSEC] = { "PHY-SEC", 7, SCOLS_FL_RIGHT, N_("physical sector size"), COLTYPE_NUM },
192 [COL_LOGSEC] = { "LOG-SEC", 7, SCOLS_FL_RIGHT, N_("logical sector size"), COLTYPE_NUM },
193 [COL_SCHED] = { "SCHED", 0.1, 0, N_("I/O scheduler name") },
194 [COL_RQ_SIZE]= { "RQ-SIZE", 5, SCOLS_FL_RIGHT, N_("request queue size"), COLTYPE_NUM },
195 [COL_TYPE] = { "TYPE", 4, 0, N_("device type") },
196 [COL_DALIGN] = { "DISC-ALN", 6, SCOLS_FL_RIGHT, N_("discard alignment offset"), COLTYPE_NUM },
197 [COL_DGRAN] = { "DISC-GRAN", 6, SCOLS_FL_RIGHT, N_("discard granularity"), COLTYPE_SIZE },
198 [COL_DMAX] = { "DISC-MAX", 6, SCOLS_FL_RIGHT, N_("discard max bytes"), COLTYPE_SIZE },
199 [COL_DZERO] = { "DISC-ZERO", 1, SCOLS_FL_RIGHT, N_("discard zeroes data"), COLTYPE_BOOL },
200 [COL_WSAME] = { "WSAME", 6, SCOLS_FL_RIGHT, N_("write same max bytes"), COLTYPE_SIZE },
201 [COL_WWN] = { "WWN", 18, 0, N_("unique storage identifier") },
202 [COL_HCTL] = { "HCTL", 10, 0, N_("Host:Channel:Target:Lun for SCSI") },
203 [COL_TRANSPORT] = { "TRAN", 6, 0, N_("device transport type") },
204 [COL_SUBSYS] = { "SUBSYSTEMS", 0.1, SCOLS_FL_NOEXTREMES, N_("de-duplicated chain of subsystems") },
205 [COL_REV] = { "REV", 4, SCOLS_FL_RIGHT, N_("device revision") },
206 [COL_VENDOR] = { "VENDOR", 0.1, SCOLS_FL_TRUNC, N_("device vendor") },
207 [COL_ZONED] = { "ZONED", 0.3, 0, N_("zone model") },
208 };
209
210 struct lsblk *lsblk; /* global handler */
211
212 /* columns[] array specifies all currently wanted output column. The columns
213 * are defined by infos[] array and you can specify (on command line) each
214 * column twice. That's enough, dynamically allocated array of the columns is
215 * unnecessary overkill and over-engineering in this case */
216 static int columns[ARRAY_SIZE(infos) * 2];
217 static size_t ncolumns;
218
219
220 static inline void add_column(int id)
221 {
222 if (ncolumns >= ARRAY_SIZE(columns))
223 errx(EXIT_FAILURE, _("too many columns specified, "
224 "the limit is %zu columns"),
225 ARRAY_SIZE(columns) - 1);
226 columns[ ncolumns++ ] = id;
227 }
228
229 static inline void add_uniq_column(int id)
230 {
231 if (column_id_to_number(id) < 0)
232 add_column(id);
233 }
234
235 static int excludes[256];
236 static size_t nexcludes;
237
238 static int includes[256];
239 static size_t nincludes;
240
241 static void lsblk_init_debug(void)
242 {
243 __UL_INIT_DEBUG_FROM_ENV(lsblk, LSBLK_DEBUG_, 0, LSBLK_DEBUG);
244 }
245
246 static int is_maj_excluded(int maj)
247 {
248 size_t i;
249
250 assert(ARRAY_SIZE(excludes) > nexcludes);
251
252 if (!nexcludes)
253 return 0; /* filter not enabled, device not excluded */
254
255 for (i = 0; i < nexcludes; i++) {
256 if (excludes[i] == maj) {
257 DBG(FILTER, ul_debug("exclude: maj=%d", maj));
258 return 1;
259 }
260 }
261 return 0;
262 }
263
264 static int is_maj_included(int maj)
265 {
266 size_t i;
267
268 assert(ARRAY_SIZE(includes) > nincludes);
269
270 if (!nincludes)
271 return 1; /* filter not enabled, device is included */
272
273 for (i = 0; i < nincludes; i++) {
274 if (includes[i] == maj) {
275 DBG(FILTER, ul_debug("include: maj=%d", maj));
276 return 1;
277 }
278 }
279 return 0;
280 }
281
282 /* array with IDs of enabled columns */
283 static int get_column_id(int num)
284 {
285 assert(num >= 0);
286 assert((size_t) num < ncolumns);
287 assert(columns[num] < (int) ARRAY_SIZE(infos));
288 return columns[num];
289 }
290
291 static struct colinfo *get_column_info(int num)
292 {
293 return &infos[ get_column_id(num) ];
294 }
295
296 static int column_name_to_id(const char *name, size_t namesz)
297 {
298 size_t i;
299
300 for (i = 0; i < ARRAY_SIZE(infos); i++) {
301 const char *cn = infos[i].name;
302
303 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
304 return i;
305 }
306 warnx(_("unknown column: %s"), name);
307 return -1;
308 }
309
310 static int column_id_to_number(int id)
311 {
312 size_t i;
313
314 for (i = 0; i < ncolumns; i++)
315 if (columns[i] == id)
316 return i;
317 return -1;
318 }
319
320 static int is_dm(const char *name)
321 {
322 return strncmp(name, "dm-", 3) ? 0 : 1;
323 }
324
325 static struct dirent *xreaddir(DIR *dp)
326 {
327 struct dirent *d;
328
329 assert(dp);
330
331 while ((d = readdir(dp))) {
332 if (!strcmp(d->d_name, ".") ||
333 !strcmp(d->d_name, ".."))
334 continue;
335
336 /* blacklist here? */
337 break;
338 }
339 return d;
340 }
341
342 static char *get_device_path(struct lsblk_device *dev)
343 {
344 char path[PATH_MAX];
345
346 assert(dev);
347 assert(dev->name);
348
349 if (is_dm(dev->name))
350 return __canonicalize_dm_name(lsblk->sysroot, dev->name);
351
352 snprintf(path, sizeof(path), "/dev/%s", dev->name);
353 sysfs_devname_sys_to_dev(path);
354 return xstrdup(path);
355 }
356
357 static int is_readonly_device(struct lsblk_device *dev)
358 {
359 int fd, ro = 0;
360
361 if (ul_path_scanf(dev->sysfs, "ro", "%d", &ro) == 1)
362 return ro;
363
364 /* fallback if "ro" attribute does not exist */
365 fd = open(dev->filename, O_RDONLY);
366 if (fd != -1) {
367 if (ioctl(fd, BLKROGET, &ro) != 0)
368 ro = 0;
369 close(fd);
370 }
371 return ro;
372 }
373
374 static char *get_scheduler(struct lsblk_device *dev)
375 {
376 char buf[128];
377 char *p, *res = NULL;
378
379 if (ul_path_read_buffer(dev->sysfs, buf, sizeof(buf), "queue/scheduler") == 0)
380 return NULL;
381 p = strchr(buf, '[');
382 if (p) {
383 res = p + 1;
384 p = strchr(res, ']');
385 if (p) {
386 *p = '\0';
387 res = xstrdup(res);
388 } else
389 res = NULL;
390 }
391 return res;
392 }
393
394 static char *get_type(struct lsblk_device *dev)
395 {
396 char *res = NULL, *p;
397
398 if (cxt->partition)
399 return xstrdup("part");
400
401 if (is_dm(dev->name)) {
402 char *dm_uuid = NULL;
403
404 /* The DM_UUID prefix should be set to subsystem owning
405 * the device - LVM, CRYPT, DMRAID, MPATH, PART */
406 if (ul_path_read_string(dev->sysfs, &dm_uuid, "dm/uuid") > 0
407 && dm_uuid) {
408 char *tmp = dm_uuid;
409 char *dm_uuid_prefix = strsep(&tmp, "-");
410
411 if (dm_uuid_prefix) {
412 /* kpartx hack to remove partition number */
413 if (strncasecmp(dm_uuid_prefix, "part", 4) == 0)
414 dm_uuid_prefix[4] = '\0';
415
416 res = xstrdup(dm_uuid_prefix);
417 }
418 }
419
420 free(dm_uuid);
421 if (!res)
422 /* No UUID or no prefix - just mark it as DM device */
423 res = xstrdup("dm");
424
425 } else if (!strncmp(dev->name, "loop", 4)) {
426 res = xstrdup("loop");
427
428 } else if (!strncmp(dev->name, "md", 2)) {
429 char *md_level = NULL;
430
431 ul_path_read_string(dev->sysfs, &md_level, "md/level");
432 res = md_level ? md_level : xstrdup("md");
433
434 } else {
435 const char *type = NULL;
436 int x = 0;
437
438 if (ul_path_read_s32(dev->sysfs, &x, "device/type") == 0)
439 type = blkdev_scsi_type_to_name(x);
440 if (!type)
441 type = "disk";
442 res = xstrdup(type);
443 }
444
445 for (p = res; p && *p; p++)
446 *p = tolower((unsigned char) *p);
447 return res;
448 }
449
450 /* Thanks to lsscsi code for idea of detection logic used here */
451 static char *get_transport(struct lsblk_device *dev)
452 {
453 struct path_cxt *sysfs = dev->sysfs;
454 char *attr = NULL;
455 const char *trans = NULL;
456
457
458 /* SCSI - Serial Peripheral Interface */
459 if (sysfs_blkdev_scsi_host_is(sysfs, "spi"))
460 trans = "spi";
461
462 /* FC/FCoE - Fibre Channel / Fibre Channel over Ethernet */
463 else if (sysfs_blkdev_scsi_host_is(sysfs, "fc")) {
464 attr = sysfs_blkdev_scsi_host_strdup_attribute(sysfs, "fc", "symbolic_name");
465 if (!attr)
466 return NULL;
467 trans = strstr(attr, " over ") ? "fcoe" : "fc";
468 free(attr);
469 }
470
471 /* SAS - Serial Attached SCSI */
472 else if (sysfs_blkdev_scsi_host_is(sysfs, "sas") ||
473 sysfs_blkdev_scsi_has_attribute(sysfs, "sas_device"))
474 trans = "sas";
475
476
477 /* SBP - Serial Bus Protocol (FireWire) */
478 else if (sysfs_blkdev_scsi_has_attribute(sysfs, "ieee1394_id"))
479 trans = "sbp";
480
481 /* iSCSI */
482 else if (sysfs_blkdev_scsi_host_is(sysfs, "iscsi"))
483 trans ="iscsi";
484
485 /* USB - Universal Serial Bus */
486 else if (sysfs_blkdev_scsi_path_contains(sysfs, "usb"))
487 trans = "usb";
488
489 /* ATA, SATA */
490 else if (sysfs_blkdev_scsi_host_is(sysfs, "scsi")) {
491 attr = sysfs_blkdev_scsi_host_strdup_attribute(sysfs, "scsi", "proc_name");
492 if (!attr)
493 return NULL;
494 if (!strncmp(attr, "ahci", 4) || !strncmp(attr, "sata", 4))
495 trans = "sata";
496 else if (strstr(attr, "ata"))
497 trans = "ata";
498 free(attr);
499
500 } else if (strncmp(dev->name, "nvme", 4) == 0)
501 trans = "nvme";
502
503 return trans ? xstrdup(trans) : NULL;
504 }
505
506 static char *get_subsystems(struct lsblk_device *dev)
507 {
508 char path[PATH_MAX];
509 char *sub, *chain, *res = NULL;
510 size_t len = 0, last = 0;
511
512 chain = sysfs_blkdev_get_devchain(dev->sysfs, path, sizeof(path));
513 if (!chain)
514 return NULL;
515
516 while (sysfs_blkdev_next_subsystem(dev->sysfs, chain, &sub) == 0) {
517 size_t sz;
518
519 /* don't create "block:scsi:scsi", but "block:scsi" */
520 if (len && strcmp(res + last, sub) == 0) {
521 free(sub);
522 continue;
523 }
524
525 sz = strlen(sub);
526 res = xrealloc(res, len + sz + 2);
527 if (len)
528 res[len++] = ':';
529
530 memcpy(res + len, sub, sz + 1);
531 last = len;
532 len += sz;
533 free(sub);
534 }
535
536 return res;
537 }
538
539
540 #define is_parsable(_l) (scols_table_is_raw((_l)->table) || \
541 scols_table_is_export((_l)->table) || \
542 scols_table_is_json((_l)->table))
543
544 static char *mk_name(const char *name)
545 {
546 char *p;
547 if (!name)
548 return NULL;
549 if (lsblk->paths)
550 xasprintf(&p, "/dev/%s", name);
551 else
552 p = xstrdup(name);
553 if (p)
554 sysfs_devname_sys_to_dev(p);
555 return p;
556 }
557
558 static char *mk_dm_name(const char *name)
559 {
560 char *p;
561 if (!name)
562 return NULL;
563 if (lsblk->paths)
564 xasprintf(&p, "/dev/mapper/%s", name);
565 else
566 p = xstrdup(name);
567 return p;
568 }
569
570 /* stores data to scols cell userdata (invisible and independent on output)
571 * to make the original values accessible for sort functions
572 */
573 static void set_sortdata_u64(struct libscols_line *ln, int col, uint64_t x)
574 {
575 struct libscols_cell *ce = scols_line_get_cell(ln, col);
576 uint64_t *data;
577
578 if (!ce)
579 return;
580 data = xmalloc(sizeof(uint64_t));
581 *data = x;
582 scols_cell_set_userdata(ce, data);
583 }
584
585 static void set_sortdata_u64_from_string(struct libscols_line *ln, int col, const char *str)
586 {
587 uint64_t x;
588
589 if (!str || sscanf(str, "%"SCNu64, &x) != 1)
590 return;
591
592 set_sortdata_u64(ln, col, x);
593 }
594
595 static void unref_sortdata(struct libscols_table *tb)
596 {
597 struct libscols_iter *itr;
598 struct libscols_line *ln;
599
600 if (!tb || !lsblk->sort_col)
601 return;
602 itr = scols_new_iter(SCOLS_ITER_FORWARD);
603 if (!itr)
604 return;
605 while (scols_table_next_line(tb, itr, &ln) == 0) {
606 struct libscols_cell *ce = scols_line_get_column_cell(ln,
607 lsblk->sort_col);
608 void *data = scols_cell_get_userdata(ce);
609 free(data);
610 }
611
612 scols_free_iter(itr);
613 }
614
615 static char *get_vfs_attribute(struct lsblk_device *dev, int id)
616 {
617 char *sizestr;
618 uint64_t vfs_attr = 0;
619 char *mnt;
620
621 if (!dev->fsstat.f_blocks) {
622 mnt = lsblk_device_get_mountpoint(dev);
623 if (!mnt || dev->is_swap)
624 return NULL;
625 if (statvfs(mnt, &dev->fsstat) != 0)
626 return NULL;
627 }
628
629 switch(id) {
630 case COL_FSSIZE:
631 vfs_attr = dev->fsstat.f_frsize * dev->fsstat.f_blocks;
632 break;
633 case COL_FSAVAIL:
634 vfs_attr = dev->fsstat.f_frsize * dev->fsstat.f_bavail;
635 break;
636 case COL_FSUSED:
637 vfs_attr = dev->fsstat.f_frsize * (dev->fsstat.f_blocks - dev->fsstat.f_bfree);
638 break;
639 case COL_FSUSEPERC:
640 if (dev->fsstat.f_blocks == 0)
641 return xstrdup("-");
642
643 xasprintf(&sizestr, "%.0f%%",
644 (double)(dev->fsstat.f_blocks - dev->fsstat.f_bfree) /
645 dev->fsstat.f_blocks * 100);
646 return sizestr;
647 }
648
649 if (!vfs_attr)
650 sizestr = xstrdup("0");
651 else if (lsblk->bytes)
652 xasprintf(&sizestr, "%ju", vfs_attr);
653 else
654 sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, vfs_attr);
655
656 return sizestr;
657 }
658
659 static struct stat *device_get_stat(struct lsblk_device *dev)
660 {
661 if (!dev->st.st_rdev)
662 stat(dev->filename, &dev->st);
663
664 return &dev->st;
665 }
666
667 static void set_scols_data(struct lsblk_device *dev, int col, int id, struct libscols_line *ln)
668 {
669 struct lsblk_devprop *prop;
670 int sort = 0;
671 char *str = NULL;
672
673 if (lsblk->sort_id == id)
674 sort = 1;
675
676 switch(id) {
677 case COL_NAME:
678 str = dev->dm_name ? mk_dm_name(dev->dm_name) : mk_name(dev->name);
679 break;
680 case COL_KNAME:
681 str = mk_name(dev->name);
682 break;
683 case COL_PKNAME:
684 if (dev->parent)
685 str = mk_name(dev->parent->name);
686 break;
687 case COL_PATH:
688 if (dev->filename)
689 str = xstrdup(dev->filename);
690 break;
691 case COL_OWNER:
692 {
693 struct stat *st = device_get_stat(dev);
694 struct passwd *pw = st ? NULL : getpwuid(st->st_uid);
695 if (pw)
696 str = xstrdup(pw->pw_name);
697 break;
698 }
699 case COL_GROUP:
700 {
701 struct stat *st = device_get_stat(dev);
702 struct group *gr = st ? NULL : getgrgid(st->st_gid);
703 if (gr)
704 str = xstrdup(gr->gr_name);
705 break;
706 }
707 case COL_MODE:
708 {
709 struct stat *st = device_get_stat(dev);
710 char md[11] = { '\0' };
711
712 if (st)
713 str = xstrdup(xstrmode(st->st_mode, md));
714 break;
715 }
716 case COL_MAJMIN:
717 if (is_parsable(lsblk))
718 xasprintf(&str, "%u:%u", dev->maj, dev->min);
719 else
720 xasprintf(&str, "%3u:%-3u", dev->maj, dev->min);
721 if (sort)
722 set_sortdata_u64(ln, col, makedev(dev->maj, dev->min));
723 break;
724 case COL_FSTYPE:
725 prop = lsblk_device_get_properties(dev);
726 if (prop && prop->fstype)
727 str = xstrdup(prop->fstype);
728 break;
729 case COL_FSSIZE:
730 case COL_FSAVAIL:
731 case COL_FSUSED:
732 case COL_FSUSEPERC:
733 str = get_vfs_attribute(dev, id);
734 break;
735 case COL_TARGET:
736 str = xstrdup(lsblk_device_get_mountpoint(dev));
737 break;
738 case COL_LABEL:
739 prop = lsblk_device_get_properties(dev);
740 if (prop && prop->label)
741 str = xstrdup(prop->label);
742 break;
743 case COL_UUID:
744 prop = lsblk_device_get_properties(dev);
745 if (prop && prop->uuid)
746 str = xstrdup(prop->uuid);
747 break;
748 case COL_PTUUID:
749 prop = lsblk_device_get_properties(dev);
750 if (prop && prop->ptuuid)
751 str = xstrdup(prop->ptuuid);
752 break;
753 case COL_PTTYPE:
754 prop = lsblk_device_get_properties(dev);
755 if (prop && prop->pttype)
756 str = xstrdup(prop->pttype);
757 break;
758 case COL_PARTTYPE:
759 prop = lsblk_device_get_properties(dev);
760 if (prop && prop->parttype)
761 str = xstrdup(prop->parttype);
762 break;
763 case COL_PARTLABEL:
764 prop = lsblk_device_get_properties(dev);
765 if (prop && prop->partlabel)
766 str = xstrdup(prop->partlabel);
767 break;
768 case COL_PARTUUID:
769 prop = lsblk_device_get_properties(dev);
770 if (prop && prop->partuuid)
771 str = xstrdup(prop->partuuid);
772 break;
773 case COL_PARTFLAGS:
774 prop = lsblk_device_get_properties(dev);
775 if (prop && prop->partflags)
776 str = xstrdup(prop->partflags);
777 break;
778 case COL_WWN:
779 prop = lsblk_device_get_properties(dev);
780 if (prop && prop->wwn)
781 str = xstrdup(prop->wwn);
782 break;
783 case COL_RA:
784 ul_path_read_string(dev->sysfs, &str, "queue/read_ahead_kb");
785 if (sort)
786 set_sortdata_u64_from_string(ln, col, str);
787 break;
788 case COL_RO:
789 str = xstrdup(is_readonly_device(dev) ? "1" : "0");
790 break;
791 case COL_RM:
792 ul_path_read_string(dev->sysfs, &str, "removable");
793 if (!str && sysfs_blkdev_get_parent(dev->sysfs))
794 ul_path_read_string(sysfs_blkdev_get_parent(dev->sysfs),
795 &str,
796 "removable");
797 break;
798 case COL_HOTPLUG:
799 str = sysfs_blkdev_is_hotpluggable(dev->sysfs) ? xstrdup("1") : xstrdup("0");
800 break;
801 case COL_ROTA:
802 ul_path_read_string(dev->sysfs, &str, "queue/rotational");
803 break;
804 case COL_RAND:
805 ul_path_read_string(dev->sysfs, &str, "queue/add_random");
806 break;
807 case COL_MODEL:
808 if (!dev->partition && dev->nslaves == 0) {
809 prop = lsblk_device_get_properties(dev);
810 if (prop && prop->model)
811 str = xstrdup(prop->model);
812 else
813 ul_path_read_string(dev->sysfs, &str, "device/model");
814 }
815 break;
816 case COL_SERIAL:
817 if (!dev->partition && dev->nslaves == 0) {
818 prop = lsblk_device_get_properties(dev);
819 if (prop && prop->serial)
820 str = xstrdup(prop->serial);
821 else
822 ul_path_read_string(dev->sysfs, &str, "device/serial");
823 }
824 break;
825 case COL_REV:
826 if (!dev->partition && dev->nslaves == 0)
827 ul_path_read_string(dev->sysfs, &str, "device/rev");
828 break;
829 case COL_VENDOR:
830 if (!dev->partition && dev->nslaves == 0)
831 ul_path_read_string(dev->sysfs, &str, "device/vendor");
832 break;
833 case COL_SIZE:
834 if (!dev->size)
835 break;
836 if (lsblk->bytes)
837 xasprintf(&str, "%ju", dev->size);
838 else
839 str = size_to_human_string(SIZE_SUFFIX_1LETTER, dev->size);
840 if (sort)
841 set_sortdata_u64(ln, col, dev->size);
842 break;
843 case COL_STATE:
844 if (!dev->partition && !dev->dm_name)
845 ul_path_read_string(dev->sysfs, &str, "device/state");
846 else if (dev->dm_name) {
847 int x = 0;
848 if (ul_path_read_s32(dev->sysfs, &x, "dm/suspended") == 0)
849 str = xstrdup(x ? "suspended" : "running");
850 }
851 break;
852 case COL_ALIOFF:
853 ul_path_read_string(dev->sysfs, &str, "alignment_offset");
854 if (sort)
855 set_sortdata_u64_from_string(ln, col, str);
856 break;
857 case COL_MINIO:
858 ul_path_read_string(dev->sysfs, &str, "queue/minimum_io_size");
859 if (sort)
860 set_sortdata_u64_from_string(ln, col, str);
861 break;
862 case COL_OPTIO:
863 ul_path_read_string(dev->sysfs, &str, "queue/optimal_io_size");
864 if (sort)
865 set_sortdata_u64_from_string(ln, col, str);
866 break;
867 case COL_PHYSEC:
868 ul_path_read_string(dev->sysfs, &str, "queue/physical_block_size");
869 if (sort)
870 set_sortdata_u64_from_string(ln, col, str);
871 break;
872 case COL_LOGSEC:
873 ul_path_read_string(dev->sysfs, &str, "queue/logical_block_size");
874 if (sort)
875 set_sortdata_u64_from_string(ln, col, str);
876 break;
877 case COL_SCHED:
878 str = get_scheduler(dev);
879 break;
880 case COL_RQ_SIZE:
881 ul_path_read_string(dev->sysfs, &str, "queue/nr_requests");
882 if (sort)
883 set_sortdata_u64_from_string(ln, col, str);
884 break;
885 case COL_TYPE:
886 str = get_type(dev);
887 break;
888 case COL_HCTL:
889 {
890 int h, c, t, l;
891 if (sysfs_blkdev_scsi_get_hctl(dev->sysfs, &h, &c, &t, &l) == 0)
892 xasprintf(&str, "%d:%d:%d:%d", h, c, t, l);
893 break;
894 }
895 case COL_TRANSPORT:
896 str = get_transport(dev);
897 break;
898 case COL_SUBSYS:
899 str = get_subsystems(dev);
900 break;
901 case COL_DALIGN:
902 if (dev->discard)
903 ul_path_read_string(dev->sysfs, &str, "discard_alignment");
904 if (!str)
905 str = xstrdup("0");
906 if (sort)
907 set_sortdata_u64_from_string(ln, col, str);
908 break;
909 case COL_DGRAN:
910 if (lsblk->bytes) {
911 ul_path_read_string(dev->sysfs, &str, "queue/discard_granularity");
912 if (sort)
913 set_sortdata_u64_from_string(ln, col, str);
914 } else {
915 uint64_t x;
916 if (ul_path_read_u64(dev->sysfs, &x, "queue/discard_granularity") == 0) {
917 str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
918 if (sort)
919 set_sortdata_u64(ln, col, x);
920 }
921 }
922 break;
923 case COL_DMAX:
924 if (lsblk->bytes) {
925 ul_path_read_string(dev->sysfs, &str, "queue/discard_max_bytes");
926 if (sort)
927 set_sortdata_u64_from_string(ln, col, str);
928 } else {
929 uint64_t x;
930 if (ul_path_read_u64(dev->sysfs, &x, "queue/discard_max_bytes") == 0) {
931 str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
932 if (sort)
933 set_sortdata_u64(ln, col, x);
934 }
935 }
936 break;
937 case COL_DZERO:
938 if (dev->discard)
939 ul_path_read_string(dev->sysfs, &str, "queue/discard_zeroes_data");
940 if (!str)
941 str = xstrdup("0");
942 break;
943 case COL_WSAME:
944 if (lsblk->bytes) {
945 ul_path_read_string(dev->sysfs, &str, "queue/write_same_max_bytes");
946 if (sort)
947 set_sortdata_u64_from_string(ln, col, str);
948 } else {
949 uint64_t x;
950
951 if (ul_path_read_u64(dev->sysfs, &x, "queue/write_same_max_bytes") == 0) {
952 str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
953 if (sort)
954 set_sortdata_u64(ln, col, x);
955 }
956 }
957 if (!str)
958 str = xstrdup("0");
959 break;
960 case COL_ZONED:
961 ul_path_read_string(dev->sysfs, &str, "queue/zoned");
962 break;
963 };
964
965 if (str && scols_line_refer_data(ln, col, str))
966 err(EXIT_FAILURE, _("failed to add output data"));
967 }
968
969 static void device_to_scols(struct lsblk_device *dev, struct lsblk_device *parent, struct libscols_table *tab)
970 {
971 size_t i;
972 struct lsblk_iter itr;
973 struct lsblk_device *child = NULL;
974
975 dev->scols_line = scols_table_new_line(tab, parent ? parent->scols_line : NULL);
976 if (!dev->scols_line)
977 err(EXIT_FAILURE, _("failed to allocate output line"));
978
979 for (i = 0; i < ncolumns; i++)
980 set_scols_data(dev, i, get_column_id(i), dev->scols_line);
981
982 lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
983
984 while (lsblk_device_next_child(dev, &itr, &child) == 0)
985 device_to_scols(child, dev, tab);
986 }
987
988 static void devtree_to_scols(struct lsblk_devtree *tr, struct libscols_table *tab)
989 {
990 struct lsblk_iter itr;
991 struct lsblk_device *dev = NULL;
992
993 lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
994
995 while (lsblk_devtree_next_root(tr, &itr, &dev) == 0)
996 device_to_scols(dev, NULL, tab);
997 }
998
999 static int set_device(struct lsblk_device *dev,
1000 struct lsblk_device *parent,
1001 struct lsblk_device *wholedisk,
1002 const char *name)
1003 {
1004 dev_t devno;
1005
1006 DBG(DEV, ul_debugobj(dev, "setting context for %s [parent=%p, wholedisk=%p]",
1007 name, parent, wholedisk));
1008
1009 dev->parent = parent;
1010 dev->name = xstrdup(name);
1011 dev->partition = wholedisk != NULL;
1012
1013 dev->filename = get_device_path(dev);
1014 if (!dev->filename) {
1015 DBG(DEV, ul_debugobj(dev, "%s: failed to get device path", dev->name));
1016 return -1;
1017 }
1018 DBG(DEV, ul_debugobj(dev, "%s: filename=%s", dev->name, dev->filename));
1019
1020 devno = __sysfs_devname_to_devno(lsblk->sysroot, dev->name, wholedisk ? wholedisk->name : NULL);
1021
1022 if (!devno) {
1023 DBG(DEV, ul_debugobj(dev, "%s: unknown device name", dev->name));
1024 return -1;
1025 }
1026
1027 if (lsblk->inverse) {
1028 dev->sysfs = ul_new_sysfs_path(devno, wholedisk ? wholedisk->sysfs : NULL, lsblk->sysroot);
1029 if (!dev->sysfs) {
1030 DBG(DEV, ul_debugobj(dev, "%s: failed to initialize sysfs handler", dev->name));
1031 return -1;
1032 }
1033 if (parent)
1034 sysfs_blkdev_set_parent(parent->sysfs, dev->sysfs);
1035 } else {
1036 dev->sysfs = ul_new_sysfs_path(devno, parent ? parent->sysfs : NULL, lsblk->sysroot);
1037 if (!dev->sysfs) {
1038 DBG(DEV, ul_debugobj(dev, "%s: failed to initialize sysfs handler", dev->name));
1039 return -1;
1040 }
1041 }
1042
1043 dev->maj = major(devno);
1044 dev->min = minor(devno);
1045 dev->size = 0;
1046
1047 if (ul_path_read_u64(dev->sysfs, &dev->size, "size") == 0) /* in sectors */
1048 dev->size <<= 9; /* in bytes */
1049
1050 if (ul_path_read_s32(dev->sysfs, &dev->discard,
1051 "queue/discard_granularity") != 0)
1052 dev->discard = 0;
1053
1054 /* Ignore devices of zero size */
1055 if (!lsblk->all_devices && dev->size == 0) {
1056 DBG(DEV, ul_debugobj(dev, "zero size device -- ignore"));
1057 return -1;
1058 }
1059 if (is_dm(dev->name)) {
1060 ul_path_read_string(dev->sysfs, &dev->dm_name, "dm/name");
1061 if (!dev->dm_name) {
1062 DBG(DEV, ul_debugobj(dev, "%s: failed to get dm name", dev->name));
1063 return -1;
1064 }
1065 }
1066
1067 dev->npartitions = sysfs_blkdev_count_partitions(dev->sysfs, dev->name);
1068 dev->nholders = ul_path_count_dirents(dev->sysfs, "holders");
1069 dev->nslaves = ul_path_count_dirents(dev->sysfs, "slaves");
1070
1071 DBG(DEV, ul_debugobj(dev, "%s: npartitions=%d, nholders=%d, nslaves=%d",
1072 dev->name, dev->npartitions, dev->nholders, dev->nslaves));
1073
1074 /* ignore non-SCSI devices */
1075 if (lsblk->scsi && sysfs_blkdev_scsi_get_hctl(dev->sysfs, NULL, NULL, NULL, NULL)) {
1076 DBG(DEV, ul_debugobj(dev, "non-scsi device -- ignore"));
1077 return -1;
1078 }
1079
1080 DBG(DEV, ul_debugobj(dev, "%s: context successfully initialized", dev->name));
1081 return 0;
1082 }
1083
1084 struct lsblk_device *devtree_get_device_or_new(struct lsblk_devtree *tr,
1085 struct lsblk_device *parent,
1086 struct lsblk_device *disk,
1087 const char *name)
1088 {
1089 struct lsblk_device *dev = lsblk_devtree_get_device(tr, name);
1090
1091 if (!dev) {
1092 dev = lsblk_new_device(tr);
1093 if (!dev)
1094 err(EXIT_FAILURE, _("failed to allocate device"));
1095
1096 if (set_device(dev, parent, disk, name) != 0) {
1097 lsblk_unref_device(dev);
1098 return NULL;
1099 }
1100 lsblk_devtree_add_device(tr, dev);
1101 lsblk_unref_device(dev); /* keep it referenced by devtree only */
1102 } else
1103 DBG(DEV, ul_debugobj(dev, "%s: already processed", name));
1104
1105 return dev;
1106 }
1107
1108 static int process_dependencies(struct lsblk_device *dev, struct lsblk_device *parent,
1109 int do_partitions, const char *part_name);
1110
1111 /*
1112 * List device partitions if any.
1113 */
1114 static int list_partitions(struct lsblk_device *wholedisk_dev, struct lsblk_device *parent_dev,
1115 const char *part_name)
1116 {
1117 DIR *dir;
1118 struct dirent *d;
1119 struct lsblk_device part_dev = { .parent = NULL };
1120 int r = -1;
1121
1122 assert(wholedisk_dev);
1123
1124 /*
1125 * Do not process further if there are no partitions for
1126 * this device or the device itself is a partition.
1127 */
1128 if (!wholedisk_dev->npartitions || wholedisk_dev->partition)
1129 return -1;
1130
1131 DBG(DEV, ul_debugobj(wholedisk_dev, "probe whole-disk for partitions"));
1132
1133 dir = ul_path_opendir(wholedisk_dev->sysfs, NULL);
1134 if (!dir)
1135 err(EXIT_FAILURE, _("failed to open device directory in sysfs"));
1136
1137 while ((d = xreaddir(dir))) {
1138 /* Process particular partition only? */
1139 if (part_name && strcmp(part_name, d->d_name))
1140 continue;
1141
1142 if (!(sysfs_blkdev_is_partition_dirent(dir, d, wholedisk_dev->name)))
1143 continue;
1144
1145 DBG(DEV, ul_debugobj(wholedisk_dev, " checking %s", d->d_name));
1146
1147 if (lsblk->inverse) {
1148 /*
1149 * <parent_dev>
1150 * `-<part_dev>
1151 * `-<wholedisk_dev>
1152 * `-...
1153 */
1154 if (set_device(&part_dev, parent_dev, wholedisk_dev, d->d_name))
1155 goto next;
1156
1157 if (!parent_dev && part_dev.nholders)
1158 goto next;
1159
1160 wholedisk_dev->parent = &part_dev;
1161 if (!lsblk->nodeps)
1162 process_dependencies(wholedisk_dev, &part_dev, 0, NULL);
1163 } else {
1164 /*
1165 * <parent_dev>
1166 * `-<wholedisk_dev>
1167 * `-<part_dev>
1168 * `-...
1169 */
1170 int ps = set_device(&part_dev, wholedisk_dev, wholedisk_dev, d->d_name);
1171
1172 if (ps == 0 && !lsblk->nodeps)
1173 process_dependencies(&part_dev, wholedisk_dev, 0, NULL);
1174 }
1175 next:
1176 r = 0;
1177 }
1178
1179 DBG(DEV, ul_debugobj(wholedisk_dev, "probe whole-disk for partitions -- done"));
1180 closedir(dir);
1181 return r;
1182 }
1183
1184 static int get_wholedisk_from_partition_dirent(DIR *dir,
1185 struct dirent *d, struct lsblk_device *dev)
1186 {
1187 char path[PATH_MAX];
1188 char *p;
1189 int len;
1190
1191 if ((len = readlinkat(dirfd(dir), d->d_name, path, sizeof(path) - 1)) < 0)
1192 return 0;
1193
1194 path[len] = '\0';
1195
1196 /* The path ends with ".../<device>/<partition>" */
1197 p = strrchr(path, '/');
1198 if (!p)
1199 return 0;
1200 *p = '\0';
1201
1202 p = strrchr(path, '/');
1203 if (!p)
1204 return 0;
1205 p++;
1206
1207 return set_device(dev, NULL, NULL, p);
1208 }
1209
1210 /*
1211 * List device dependencies: partitions, holders (inverse = 0) or slaves (inverse = 1).
1212 */
1213 static int list_deps(struct lsblk_device *dev)
1214 {
1215 DIR *dir;
1216 struct dirent *d;
1217 struct lsblk_device dep = { .parent = NULL };
1218 const char *depname;
1219
1220 assert(dev);
1221
1222 if (lsblk->nodeps)
1223 return 0;
1224
1225 DBG(DEV, ul_debugobj(dev, "%s: list dependencies", dev->name));
1226
1227 if (!(lsblk->inverse ? dev->nslaves : dev->nholders))
1228 return 0;
1229
1230 depname = lsblk->inverse ? "slaves" : "holders";
1231 dir = ul_path_opendir(dev->sysfs, depname);
1232 if (!dir)
1233 return 0;
1234
1235 DBG(DEV, ul_debugobj(dev, "%s: checking for '%s' dependence", dev->name, depname));
1236
1237 while ((d = xreaddir(dir))) {
1238 /* Is the dependency a partition? */
1239 if (sysfs_blkdev_is_partition_dirent(dir, d, NULL)) {
1240 if (!get_wholedisk_from_partition_dirent(dir, d, &dep)) {
1241 DBG(DEV, ul_debugobj(dev, "%s: %s: dependence is partition",
1242 dev->name, d->d_name));
1243 process_dependencies(&dep, dev, 1, d->d_name);
1244 }
1245 }
1246 /* The dependency is a whole device. */
1247 else if (!set_device(&dep, dev, NULL, d->d_name)) {
1248 DBG(DEV, ul_debugobj(dev, "%s: %s: dependence is whole-disk",
1249 dev->name, d->d_name));
1250 /* For inverse tree we don't want to show partitions
1251 * if the dependence is on whole-disk */
1252 process_dependencies(&dep, dev, lsblk->inverse ? 0 : 1, NULL);
1253 }
1254 }
1255 closedir(dir);
1256
1257 DBG(DEV, ul_debugobj(dev, "%s: checking for '%s' -- done", dev->name, depname));
1258 return 0;
1259 }
1260
1261 static int process_dependencies(struct lsblk_device *dev, struct lsblk_device *parent,
1262 int do_partitions, const char *part_name)
1263 {
1264 #ifdef SUCK
1265 if (do_partitions && dev->npartitions)
1266 list_partitions(dev, parent, part_name); /* partitions + whole-disk */
1267
1268 return list_deps(dev);
1269 #endif
1270 return 0;
1271 }
1272
1273 /* Iterate devices in sysfs */
1274 static int process_all_devices(struct lsblk_devtree *tr)
1275 {
1276 DIR *dir;
1277 struct dirent *d;
1278 struct path_cxt *pc = ul_new_path(_PATH_SYS_BLOCK);
1279
1280 if (!pc)
1281 err(EXIT_FAILURE, _("failed to allocate /sys handler"));
1282
1283 ul_path_set_prefix(pc, lsblk->sysroot);
1284
1285 /* TODO: reuse @pc in set_device(), etc. */
1286 dir = ul_path_opendir(pc, NULL);
1287 if (!dir)
1288 goto done;
1289
1290 DBG(DEV, ul_debug("iterate on " _PATH_SYS_BLOCK));
1291
1292 while ((d = xreaddir(dir))) {
1293 struct lsblk_device *dev;
1294
1295 DBG(DEV, ul_debug(" %s dentry", d->d_name));
1296
1297 dev = devtree_get_device_or_new(tr, NULL, NULL, d->d_name);
1298 if (!dev)
1299 continue;
1300
1301 /* remove unwanted devices */
1302 if (is_maj_excluded(dev->maj) || !is_maj_included(dev->maj)) {
1303 DBG(DEV, ul_debug(" %s: ignore (by filter)", d->d_name));
1304 lsblk_devtree_remove_device(tr, dev);
1305 continue;
1306 }
1307
1308 /* process dependencies for top level devices */
1309 if ((lsblk->inverse ? dev->nholders : dev->nslaves) <= 0
1310 && process_dependencies(dev, NULL, 1, NULL) == 0)
1311 lsblk_devtree_add_root(tr, dev);
1312 }
1313
1314 closedir(dir);
1315 done:
1316 ul_unref_path(pc);
1317 DBG(DEV, ul_debug("iterate on " _PATH_SYS_BLOCK " -- done"));
1318 return 0;
1319 }
1320
1321 static int process_one_device(char *devname)
1322 {
1323 struct lsblk_device parent = { .parent = NULL }, dev = { .parent = NULL };
1324 struct stat st;
1325 char buf[PATH_MAX + 1], *name = NULL, *diskname = NULL;
1326 dev_t disk = 0;
1327 int real_part = 0, rc = -EINVAL;
1328
1329 if (stat(devname, &st) || !S_ISBLK(st.st_mode)) {
1330 warnx(_("%s: not a block device"), devname);
1331 goto leave;
1332 }
1333
1334 /* TODO: sysfs_devno_to_devname() internally initializes path_cxt, it
1335 * would be better to use ul_new_sysfs_path() + sysfs_blkdev_get_name()
1336 * and reuse path_cxt for set_device()
1337 */
1338 name = sysfs_devno_to_devname(st.st_rdev, buf, sizeof(buf));
1339 if (!name) {
1340 warn(_("%s: failed to get sysfs name"), devname);
1341 goto leave;
1342 }
1343 name = xstrdup(name);
1344
1345 if (!strncmp(name, "dm-", 3)) {
1346 /* dm mapping is never a real partition! */
1347 real_part = 0;
1348 } else {
1349 if (blkid_devno_to_wholedisk(st.st_rdev, buf, sizeof(buf), &disk)) {
1350 warn(_("%s: failed to get whole-disk device number"), devname);
1351 goto leave;
1352 }
1353 diskname = buf;
1354 real_part = st.st_rdev != disk;
1355 }
1356
1357 if (!real_part) {
1358 /*
1359 * Device is not a partition.
1360 */
1361 if (set_device(&dev, NULL, NULL, name))
1362 goto leave;
1363 process_dependencies(&dev, NULL, !lsblk->inverse, NULL);
1364 } else {
1365 /*
1366 * Partition, read sysfs name of the device.
1367 */
1368 if (set_device(&parent, NULL, NULL, diskname))
1369 goto leave;
1370 if (set_device(&dev, &parent, &parent, name))
1371 goto leave;
1372
1373 if (lsblk->inverse)
1374 process_dependencies(&parent, &dev, 1, dev.name);
1375 else
1376 process_dependencies(&dev, &parent, 1, NULL);
1377 }
1378
1379 rc = 0;
1380 leave:
1381 free(name);
1382 return rc;
1383 }
1384
1385 static void parse_excludes(const char *str0)
1386 {
1387 const char *str = str0;
1388
1389 while (str && *str) {
1390 char *end = NULL;
1391 unsigned long n;
1392
1393 errno = 0;
1394 n = strtoul(str, &end, 10);
1395
1396 if (end == str || (end && *end && *end != ','))
1397 errx(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
1398 if (errno != 0 && (n == ULONG_MAX || n == 0))
1399 err(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
1400 excludes[nexcludes++] = n;
1401
1402 if (nexcludes == ARRAY_SIZE(excludes))
1403 /* TRANSLATORS: The standard value for %d is 256. */
1404 errx(EXIT_FAILURE, _("the list of excluded devices is "
1405 "too large (limit is %d devices)"),
1406 (int)ARRAY_SIZE(excludes));
1407
1408 str = end && *end ? end + 1 : NULL;
1409 }
1410 }
1411
1412 static void parse_includes(const char *str0)
1413 {
1414 const char *str = str0;
1415
1416 while (str && *str) {
1417 char *end = NULL;
1418 unsigned long n;
1419
1420 errno = 0;
1421 n = strtoul(str, &end, 10);
1422
1423 if (end == str || (end && *end && *end != ','))
1424 errx(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
1425 if (errno != 0 && (n == ULONG_MAX || n == 0))
1426 err(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
1427 includes[nincludes++] = n;
1428
1429 if (nincludes == ARRAY_SIZE(includes))
1430 /* TRANSLATORS: The standard value for %d is 256. */
1431 errx(EXIT_FAILURE, _("the list of included devices is "
1432 "too large (limit is %d devices)"),
1433 (int)ARRAY_SIZE(includes));
1434 str = end && *end ? end + 1 : NULL;
1435 }
1436 }
1437
1438 /*
1439 * see set_sortdata_u64() and columns initialization in main()
1440 */
1441 static int cmp_u64_cells(struct libscols_cell *a,
1442 struct libscols_cell *b,
1443 __attribute__((__unused__)) void *data)
1444 {
1445 uint64_t *adata = (uint64_t *) scols_cell_get_userdata(a),
1446 *bdata = (uint64_t *) scols_cell_get_userdata(b);
1447
1448 if (adata == NULL && bdata == NULL)
1449 return 0;
1450 if (adata == NULL)
1451 return -1;
1452 if (bdata == NULL)
1453 return 1;
1454 return *adata == *bdata ? 0 : *adata >= *bdata ? 1 : -1;
1455 }
1456
1457 static void __attribute__((__noreturn__)) usage(void)
1458 {
1459 FILE *out = stdout;
1460 size_t i;
1461
1462 fputs(USAGE_HEADER, out);
1463 fprintf(out, _(" %s [options] [<device> ...]\n"), program_invocation_short_name);
1464
1465 fputs(USAGE_SEPARATOR, out);
1466 fputs(_("List information about block devices.\n"), out);
1467
1468 fputs(USAGE_OPTIONS, out);
1469 fputs(_(" -a, --all print all devices\n"), out);
1470 fputs(_(" -b, --bytes print SIZE in bytes rather than in human readable format\n"), out);
1471 fputs(_(" -d, --nodeps don't print slaves or holders\n"), out);
1472 fputs(_(" -D, --discard print discard capabilities\n"), out);
1473 fputs(_(" -z, --zoned print zone model\n"), out);
1474 fputs(_(" -e, --exclude <list> exclude devices by major number (default: RAM disks)\n"), out);
1475 fputs(_(" -f, --fs output info about filesystems\n"), out);
1476 fputs(_(" -i, --ascii use ascii characters only\n"), out);
1477 fputs(_(" -I, --include <list> show only devices with specified major numbers\n"), out);
1478 fputs(_(" -J, --json use JSON output format\n"), out);
1479 fputs(_(" -l, --list use list format output\n"), out);
1480 fputs(_(" -T, --tree use tree format output\n"), out);
1481 fputs(_(" -m, --perms output info about permissions\n"), out);
1482 fputs(_(" -n, --noheadings don't print headings\n"), out);
1483 fputs(_(" -o, --output <list> output columns\n"), out);
1484 fputs(_(" -O, --output-all output all columns\n"), out);
1485 fputs(_(" -p, --paths print complete device path\n"), out);
1486 fputs(_(" -P, --pairs use key=\"value\" output format\n"), out);
1487 fputs(_(" -r, --raw use raw output format\n"), out);
1488 fputs(_(" -s, --inverse inverse dependencies\n"), out);
1489 fputs(_(" -S, --scsi output info about SCSI devices\n"), out);
1490 fputs(_(" -t, --topology output info about topology\n"), out);
1491 fputs(_(" -x, --sort <column> sort output by <column>\n"), out);
1492 fputs(_(" --sysroot <dir> use specified directory as system root\n"), out);
1493 fputs(USAGE_SEPARATOR, out);
1494 printf(USAGE_HELP_OPTIONS(22));
1495
1496 fprintf(out, USAGE_COLUMNS);
1497
1498 for (i = 0; i < ARRAY_SIZE(infos); i++)
1499 fprintf(out, " %11s %s\n", infos[i].name, _(infos[i].help));
1500
1501 printf(USAGE_MAN_TAIL("lsblk(8)"));
1502
1503 exit(EXIT_SUCCESS);
1504 }
1505
1506 static void check_sysdevblock(void)
1507 {
1508 if (access(_PATH_SYS_DEVBLOCK, R_OK) != 0)
1509 err(EXIT_FAILURE, _("failed to access sysfs directory: %s"),
1510 _PATH_SYS_DEVBLOCK);
1511 }
1512
1513 int main(int argc, char *argv[])
1514 {
1515 struct lsblk _ls = { .sort_id = -1, .flags = LSBLK_TREE };
1516 struct lsblk_devtree *tr = NULL;
1517 int c, status = EXIT_FAILURE;
1518 char *outarg = NULL;
1519 size_t i;
1520 int force_tree = 0;
1521
1522 enum {
1523 OPT_SYSROOT = CHAR_MAX + 1
1524 };
1525
1526 static const struct option longopts[] = {
1527 { "all", no_argument, NULL, 'a' },
1528 { "bytes", no_argument, NULL, 'b' },
1529 { "nodeps", no_argument, NULL, 'd' },
1530 { "discard", no_argument, NULL, 'D' },
1531 { "zoned", no_argument, NULL, 'z' },
1532 { "help", no_argument, NULL, 'h' },
1533 { "json", no_argument, NULL, 'J' },
1534 { "output", required_argument, NULL, 'o' },
1535 { "output-all", no_argument, NULL, 'O' },
1536 { "perms", no_argument, NULL, 'm' },
1537 { "noheadings", no_argument, NULL, 'n' },
1538 { "list", no_argument, NULL, 'l' },
1539 { "ascii", no_argument, NULL, 'i' },
1540 { "raw", no_argument, NULL, 'r' },
1541 { "inverse", no_argument, NULL, 's' },
1542 { "fs", no_argument, NULL, 'f' },
1543 { "exclude", required_argument, NULL, 'e' },
1544 { "include", required_argument, NULL, 'I' },
1545 { "topology", no_argument, NULL, 't' },
1546 { "paths", no_argument, NULL, 'p' },
1547 { "pairs", no_argument, NULL, 'P' },
1548 { "scsi", no_argument, NULL, 'S' },
1549 { "sort", required_argument, NULL, 'x' },
1550 { "sysroot", required_argument, NULL, OPT_SYSROOT },
1551 { "tree", no_argument, NULL, 'T' },
1552 { "version", no_argument, NULL, 'V' },
1553 { NULL, 0, NULL, 0 },
1554 };
1555
1556 static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
1557 { 'D','O' },
1558 { 'I','e' },
1559 { 'J', 'P', 'r' },
1560 { 'O','S' },
1561 { 'O','f' },
1562 { 'O','m' },
1563 { 'O','t' },
1564 { 'P','T', 'l','r' },
1565 { 0 }
1566 };
1567 int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
1568
1569 setlocale(LC_ALL, "");
1570 bindtextdomain(PACKAGE, LOCALEDIR);
1571 textdomain(PACKAGE);
1572 atexit(close_stdout);
1573
1574 lsblk = &_ls;
1575
1576 lsblk_init_debug();
1577
1578 while((c = getopt_long(argc, argv,
1579 "abdDze:fhJlnmo:OpPiI:rstVSTx:", longopts, NULL)) != -1) {
1580
1581 err_exclusive_options(c, longopts, excl, excl_st);
1582
1583 switch(c) {
1584 case 'a':
1585 lsblk->all_devices = 1;
1586 break;
1587 case 'b':
1588 lsblk->bytes = 1;
1589 break;
1590 case 'd':
1591 lsblk->nodeps = 1;
1592 break;
1593 case 'D':
1594 add_uniq_column(COL_NAME);
1595 add_uniq_column(COL_DALIGN);
1596 add_uniq_column(COL_DGRAN);
1597 add_uniq_column(COL_DMAX);
1598 add_uniq_column(COL_DZERO);
1599 break;
1600 case 'z':
1601 add_uniq_column(COL_NAME);
1602 add_uniq_column(COL_ZONED);
1603 break;
1604 case 'e':
1605 parse_excludes(optarg);
1606 break;
1607 case 'h':
1608 usage();
1609 break;
1610 case 'J':
1611 lsblk->flags |= LSBLK_JSON;
1612 break;
1613 case 'l':
1614 lsblk->flags &= ~LSBLK_TREE; /* disable the default */
1615 break;
1616 case 'n':
1617 lsblk->flags |= LSBLK_NOHEADINGS;
1618 break;
1619 case 'o':
1620 outarg = optarg;
1621 break;
1622 case 'O':
1623 for (ncolumns = 0 ; ncolumns < ARRAY_SIZE(infos); ncolumns++)
1624 columns[ncolumns] = ncolumns;
1625 break;
1626 case 'p':
1627 lsblk->paths = 1;
1628 break;
1629 case 'P':
1630 lsblk->flags |= LSBLK_EXPORT;
1631 lsblk->flags &= ~LSBLK_TREE; /* disable the default */
1632 break;
1633 case 'i':
1634 lsblk->flags |= LSBLK_ASCII;
1635 break;
1636 case 'I':
1637 parse_includes(optarg);
1638 break;
1639 case 'r':
1640 lsblk->flags &= ~LSBLK_TREE; /* disable the default */
1641 lsblk->flags |= LSBLK_RAW; /* enable raw */
1642 break;
1643 case 's':
1644 lsblk->inverse = 1;
1645 break;
1646 case 'f':
1647 add_uniq_column(COL_NAME);
1648 add_uniq_column(COL_FSTYPE);
1649 add_uniq_column(COL_LABEL);
1650 add_uniq_column(COL_UUID);
1651 add_uniq_column(COL_FSAVAIL);
1652 add_uniq_column(COL_FSUSEPERC);
1653 add_uniq_column(COL_TARGET);
1654 break;
1655 case 'm':
1656 add_uniq_column(COL_NAME);
1657 add_uniq_column(COL_SIZE);
1658 add_uniq_column(COL_OWNER);
1659 add_uniq_column(COL_GROUP);
1660 add_uniq_column(COL_MODE);
1661 break;
1662 case 't':
1663 add_uniq_column(COL_NAME);
1664 add_uniq_column(COL_ALIOFF);
1665 add_uniq_column(COL_MINIO);
1666 add_uniq_column(COL_OPTIO);
1667 add_uniq_column(COL_PHYSEC);
1668 add_uniq_column(COL_LOGSEC);
1669 add_uniq_column(COL_ROTA);
1670 add_uniq_column(COL_SCHED);
1671 add_uniq_column(COL_RQ_SIZE);
1672 add_uniq_column(COL_RA);
1673 add_uniq_column(COL_WSAME);
1674 break;
1675 case 'S':
1676 lsblk->nodeps = 1;
1677 lsblk->scsi = 1;
1678 add_uniq_column(COL_NAME);
1679 add_uniq_column(COL_HCTL);
1680 add_uniq_column(COL_TYPE);
1681 add_uniq_column(COL_VENDOR);
1682 add_uniq_column(COL_MODEL);
1683 add_uniq_column(COL_REV);
1684 add_uniq_column(COL_TRANSPORT);
1685 break;
1686 case 'T':
1687 force_tree = 1;
1688 break;
1689
1690 case OPT_SYSROOT:
1691 lsblk->sysroot = optarg;
1692 break;
1693 case 'V':
1694 printf(UTIL_LINUX_VERSION);
1695 return EXIT_SUCCESS;
1696 case 'x':
1697 lsblk->flags &= ~LSBLK_TREE; /* disable the default */
1698 lsblk->sort_id = column_name_to_id(optarg, strlen(optarg));
1699 if (lsblk->sort_id >= 0)
1700 break;
1701 /* fallthrough */
1702 default:
1703 errtryhelp(EXIT_FAILURE);
1704 }
1705 }
1706
1707 if (force_tree)
1708 lsblk->flags |= LSBLK_TREE;
1709
1710 check_sysdevblock();
1711
1712 if (!ncolumns) {
1713 add_column(COL_NAME);
1714 add_column(COL_MAJMIN);
1715 add_column(COL_RM);
1716 add_column(COL_SIZE);
1717 add_column(COL_RO);
1718 add_column(COL_TYPE);
1719 add_column(COL_TARGET);
1720 }
1721
1722 if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
1723 &ncolumns, column_name_to_id) < 0)
1724 return EXIT_FAILURE;
1725
1726 if (lsblk->all_devices == 0 && nexcludes == 0 && nincludes == 0)
1727 excludes[nexcludes++] = 1; /* default: ignore RAM disks */
1728
1729 if (lsblk->sort_id < 0)
1730 /* Since Linux 4.8 we have sort devices by default, because
1731 * /sys is no more sorted */
1732 lsblk->sort_id = COL_MAJMIN;
1733
1734 /* For --inverse --list we still follow parent->child relation */
1735 if (lsblk->inverse && !(lsblk->flags & LSBLK_TREE))
1736 lsblk->force_tree_order = 1;
1737
1738 if (lsblk->sort_id >= 0 && column_id_to_number(lsblk->sort_id) < 0) {
1739 /* the sort column is not between output columns -- add as hidden */
1740 add_column(lsblk->sort_id);
1741 lsblk->sort_hidden = 1;
1742 }
1743
1744 lsblk_mnt_init();
1745 scols_init_debug(0);
1746 ul_path_init_debug();
1747
1748 /*
1749 * initialize output columns
1750 */
1751 if (!(lsblk->table = scols_new_table()))
1752 errx(EXIT_FAILURE, _("failed to allocate output table"));
1753 scols_table_enable_raw(lsblk->table, !!(lsblk->flags & LSBLK_RAW));
1754 scols_table_enable_export(lsblk->table, !!(lsblk->flags & LSBLK_EXPORT));
1755 scols_table_enable_ascii(lsblk->table, !!(lsblk->flags & LSBLK_ASCII));
1756 scols_table_enable_json(lsblk->table, !!(lsblk->flags & LSBLK_JSON));
1757 scols_table_enable_noheadings(lsblk->table, !!(lsblk->flags & LSBLK_NOHEADINGS));
1758
1759 if (lsblk->flags & LSBLK_JSON)
1760 scols_table_set_name(lsblk->table, "blockdevices");
1761
1762 for (i = 0; i < ncolumns; i++) {
1763 struct colinfo *ci = get_column_info(i);
1764 struct libscols_column *cl;
1765 int id = get_column_id(i), fl = ci->flags;
1766
1767 if (!(lsblk->flags & LSBLK_TREE) && id == COL_NAME)
1768 fl &= ~SCOLS_FL_TREE;
1769 if (lsblk->sort_hidden && lsblk->sort_id == id)
1770 fl |= SCOLS_FL_HIDDEN;
1771
1772 cl = scols_table_new_column(lsblk->table, ci->name, ci->whint, fl);
1773 if (!cl) {
1774 warn(_("failed to allocate output column"));
1775 goto leave;
1776 }
1777 if (!lsblk->sort_col && lsblk->sort_id == id) {
1778 lsblk->sort_col = cl;
1779 scols_column_set_cmpfunc(cl,
1780 ci->type == COLTYPE_NUM ? cmp_u64_cells :
1781 ci->type == COLTYPE_SIZE ? cmp_u64_cells :
1782 ci->type == COLTYPE_SORTNUM ? cmp_u64_cells : scols_cmpstr_cells,
1783 NULL);
1784 }
1785 if (lsblk->flags & LSBLK_JSON) {
1786 switch (ci->type) {
1787 case COLTYPE_SIZE:
1788 if (!lsblk->bytes)
1789 break;
1790 /* fallthrough */
1791 case COLTYPE_NUM:
1792 scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
1793 break;
1794 case COLTYPE_BOOL:
1795 scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
1796 break;
1797 default:
1798 scols_column_set_json_type(cl, SCOLS_JSON_STRING);
1799 break;
1800 }
1801 }
1802 }
1803
1804 tr = lsblk_new_devtree();
1805 if (!tr)
1806 err(EXIT_FAILURE, _("failed to allocate device tree"));
1807
1808 if (optind == argc)
1809 status = process_all_devices(tr) == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1810 else {
1811 int cnt = 0, cnt_err = 0;
1812
1813 while (optind < argc) {
1814 if (process_one_device(argv[optind++]) != 0)
1815 cnt_err++;
1816 cnt++;
1817 }
1818 status = cnt == 0 ? EXIT_FAILURE : /* nothing */
1819 cnt == cnt_err ? LSBLK_EXIT_ALLFAILED :/* all failed */
1820 cnt_err ? LSBLK_EXIT_SOMEOK : /* some ok */
1821 EXIT_SUCCESS; /* all success */
1822 }
1823
1824 devtree_to_scols(tr, lsblk->table);
1825
1826 if (lsblk->sort_col)
1827 scols_sort_table(lsblk->table, lsblk->sort_col);
1828 if (lsblk->force_tree_order)
1829 scols_sort_table_by_tree(lsblk->table);
1830
1831 scols_print_table(lsblk->table);
1832
1833 leave:
1834 if (lsblk->sort_col)
1835 unref_sortdata(lsblk->table);
1836
1837 scols_unref_table(lsblk->table);
1838
1839 lsblk_mnt_deinit();
1840 lsblk_properties_deinit();
1841 lsblk_unref_devtree(tr);
1842
1843 return status;
1844 }
Unnamed repository; edit this file 'description' to name the repository.