2 * Copyright (c) 2023 Benjamin Stürz <benni@stuerz.xyz>
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 #define _XOPEN_SOURCE 700
21 #include <dev/biovar.h>
22 #include <sys/cdefs.h>
23 #include <sys/types.h>
24 #include <sys/disklabel.h>
25 #include <sys/sysctl.h>
26 #include <sys/ioctl.h>
27 #include <sys/mount.h>
44 static int diskcount (void)
46 const int mib[2] = { CTL_HW, HW_DISKCOUNT };
48 size_t len = sizeof diskcount;
50 if (sysctl (mib, 2, &diskcount, &len, NULL, 0) == -1)
51 err (1, "sysctl(hw.diskcount)");
56 static char *disknames (void)
58 const int num = diskcount ();
59 const int mib[2] = { CTL_HW, HW_DISKNAMES };
60 size_t len = 32 * num;
61 char *buffer = malloc (len);
63 if (sysctl (mib, 2, buffer, &len, NULL, 0) == -1)
64 err (1, "sysctl(hw.disknames)");
69 static char *stripdisk (char *n)
71 const char sufx[] = " disk";
72 const size_t ln = strnlen (n, 16);
73 const size_t ls = sizeof sufx - 1;
75 if (memcmp (n + ln - ls, sufx, ls) == 0) {
82 static void print_size (uint64_t sz)
99 for (const struct unit *u = &units[0]; u->factor; ++u) {
100 if (sz >= (u->factor * 9 / 10)) {
107 const unsigned scaled10 = sz * 10 / factor;
108 const unsigned scaled = sz / factor;
109 if (scaled10 >= 1000) {
110 printf ("%u", scaled);
111 } else if (scaled10 >= 100) {
112 printf (" %u", scaled);
114 printf ("%u.%u", scaled, scaled10 % 10);
128 FIELD_COMMENT = 0x40,
130 FIELD_DEFAULT = FIELD_NAME | FIELD_SIZE | FIELD_TYPE | FIELD_COMMENT,
135 OPT_NOUNICODE = 0x02,
148 const struct my_diskinfo *sub; // If this is part of a RAID
149 const char *raidstatus; // Only available if (sub != NULL)
160 struct my_partinfo parts[MAXPARTITIONS];
161 const char *raidstatus; // If this is a RAID device
174 static void print_header (int fields, const struct padding *p)
176 if (fields & FIELD_NAME)
177 printf ("%-*s ", p->name, "NAME");
179 if (fields & FIELD_DUID)
180 printf ("%-18s ", "DUID");
182 if (fields & FIELD_SIZE)
183 printf ("%-4s ", "SIZE");
185 if (fields & FIELD_USED)
186 printf ("%-4s ", "USED");
188 if (fields & FIELD_FREE)
189 printf ("%-4s ", "FREE");
191 if (fields & FIELD_TYPE)
192 printf ("%-*s ", p->type, "TYPE");
194 if (fields & FIELD_COMMENT)
195 printf ("%-*s ", p->comment, "COMMENT");
204 static void print_duid (const u_char *duid)
206 for (size_t i = 0; i < 8; ++i) {
207 printf ("%02x", duid[i]);
211 static void print_disk (const struct my_diskinfo *, int, int, const char *, const struct padding *);
212 static void print_part (
213 const struct my_diskinfo *disk,
214 const struct my_partinfo *part,
218 const struct padding *p
220 if (fields & FIELD_NAME) {
221 const char *prefix = (options & OPT_NOUNICODE) ? " " : (last ? "└─" : "├─");
227 p->name - 2 - (int)strlen (disk->name) - 1,
232 if (fields & FIELD_DUID) {
233 print_duid (disk->duid);
234 printf (".%c ", part->letter);
237 if (fields & FIELD_SIZE)
238 print_size (part->size);
240 if (fields & FIELD_USED) {
242 print_size (part->fssize - part->free);
248 if (fields & FIELD_FREE) {
250 print_size (part->free);
256 if (fields & FIELD_TYPE)
257 printf ("%-*s ", p->type, part->fstype);
259 if (fields & FIELD_COMMENT)
260 printf ("%-*s ", p->comment, part->mount ? part->mount : "");
269 print_disk (part->sub, fields, options, part->raidstatus, p);
273 static void print_disk (
274 const struct my_diskinfo *disk,
277 const char *raidstatus,
278 const struct padding *p
280 if (fields & FIELD_NAME) {
281 const char *prefix = raidstatus ? (options & OPT_NOUNICODE ? " " : "│ └─") : "";
286 p->name - (raidstatus ? 4 : 0),
291 if (fields & FIELD_DUID) {
292 print_duid (disk->duid);
296 if (fields & FIELD_SIZE)
297 print_size (disk->size);
299 if (fields & FIELD_USED)
300 print_size (disk->used);
302 if (fields & FIELD_FREE)
303 print_size (disk->size - disk->used);
305 if (fields & FIELD_TYPE)
306 printf ("%-*.16s ", p->type, disk->type);
308 if (fields & FIELD_COMMENT) {
310 printf ("%-*s ", p->comment, raidstatus);
311 } else if (disk->raidstatus) {
316 p->comment - (int)strnlen (disk->label, sizeof disk->label) - (int)strlen (disk->raidstatus) - 3,
320 printf ("%-*.16s ", p->comment, disk->label);
331 for (uint8_t i = 0; i < disk->num_parts; ++i)
332 print_part (disk, &disk->parts[i], fields, options, i == (disk->num_parts - 1), p);
336 static const struct statfs *find_mount (const char *dev)
338 static struct statfs *mounts = NULL;
342 n_mounts = getmntinfo (&mounts, MNT_NOWAIT);
344 err (1, "getmntinfo()");
347 for (int i = 0; i < n_mounts; ++i) {
348 if (!strcmp (dev, mounts[i].f_mntfromname))
355 static int read_disk (const char *name, struct my_diskinfo *disk)
357 struct disklabel label;
358 char *ppath, *letter;
360 memset (disk, 0, sizeof *disk);
366 fd = opendev (name, O_RDONLY, OPENDEV_PART | OPENDEV_BLCK, &ppath);
368 warn ("read_disk(): opendev(%s)", name);
372 if (ioctl (fd, DIOCGDINFO, &label) < 0) {
373 warn ("read_disk(): ioctl(%s, DIOCGDINFO)", name);
379 len = strlen (ppath);
380 letter = ppath + len - 1;
383 strlcpy (disk->name, name, sizeof disk->name);
384 disk->size = DL_GETDSIZE (&label) * label.d_secsize;
385 memcpy (disk->type, label.d_typename, sizeof disk->type);
386 stripdisk (disk->type);
387 memcpy (disk->label, label.d_packname, sizeof disk->label);
388 memcpy (disk->duid, label.d_uid, sizeof disk->duid);
391 for (uint16_t i = 0; i < label.d_npartitions; ++i) {
392 const struct partition *p = &label.d_partitions[i];
393 const struct statfs *mnt;
394 struct my_partinfo part;
396 memset (&part, 0, sizeof part);
398 part.size = DL_GETPSIZE (p) * label.d_secsize;
403 part.letter = 'a' + i;
404 *letter = part.letter;
405 mnt = find_mount (ppath);
408 const uint64_t bs = mnt->f_bsize;
409 part.mount = mnt->f_mntonname;
410 part.fssize = mnt->f_blocks * bs;
411 part.free = mnt->f_bfree * bs;
414 part.fstype = fstypenames[p->p_fstype];
416 disk->used += part.size;
417 disk->parts[disk->num_parts++] = part;
423 static const char *bd_statusstr (int status) {
425 case BIOC_SDONLINE: return BIOC_SDONLINE_S;
426 case BIOC_SDOFFLINE: return BIOC_SDOFFLINE_S;
427 case BIOC_SDFAILED: return BIOC_SDFAILED_S;
428 case BIOC_SDREBUILD: return BIOC_SDREBUILD_S;
429 case BIOC_SDHOTSPARE: return BIOC_SDHOTSPARE_S;
430 case BIOC_SDUNUSED: return BIOC_SDUNUSED_S;
431 case BIOC_SDSCRUB: return BIOC_SDSCRUB_S;
432 case BIOC_SDINVALID: return BIOC_SDINVALID_S;
433 default: return "Unknown";
437 static const char *bv_statusstr (int status) {
439 case BIOC_SVONLINE: return BIOC_SVONLINE_S;
440 case BIOC_SVOFFLINE: return BIOC_SVOFFLINE_S;
441 case BIOC_SVDEGRADED: return BIOC_SVDEGRADED_S;
442 case BIOC_SVBUILDING: return BIOC_SVBUILDING_S;
443 case BIOC_SVSCRUB: return BIOC_SVSCRUB_S;
444 case BIOC_SVREBUILD: return BIOC_SVREBUILD_S;
445 case BIOC_SVINVALID: return BIOC_SVINVALID_S;
446 default: return "Unknown";
450 static void read_raid (
451 struct my_diskinfo *disk,
452 struct my_diskinfo *disks,
458 fd = opendev (disk->name, O_RDONLY, OPENDEV_PART | OPENDEV_BLCK, NULL);
460 warn ("read_raid(): opendev(%s)", disk->name);
464 memset (&bi, 0, sizeof bi);
466 if (ioctl (fd, BIOCINQ, &bi) == -1)
469 for (int i = 0; i < bi.bi_novol; ++i) {
472 memset (&bv, 0, sizeof bv);
473 memcpy (&bv.bv_bio, &bi.bi_bio, sizeof bi.bi_bio);
476 if (ioctl (fd, BIOCVOL, &bv) == -1) {
477 warn ("read_raid(%s): BIOCVOL(%d)", disk->name, i);
481 if (strcmp (disk->name, bv.bv_dev) != 0)
484 disk->raidstatus = bv_statusstr (bv.bv_status);
486 for (int j = 0; j < bv.bv_nodisk; ++j) {
491 memset (&bd, 0, sizeof bd);
492 memcpy (&bd.bd_bio, &bi.bi_bio, sizeof bi.bi_bio);
496 if (ioctl (fd, BIOCDISK, &bd) == -1) {
497 warn ("read_raid(%s): BIOCDISK(%d, %d)", disk->name, i, j);
501 len_vendor = strlen (bd.bd_vendor);
502 if (len_vendor < 4 || len_vendor > 8) {
503 warnx ("read_raid(%s): unexpected vendor string: %.32s", disk->name, bd.bd_vendor);
506 letter = bd.bd_vendor[len_vendor - 1];
508 for (size_t k = 0; k < num_disks; ++k) {
509 if (!memcmp (bd.bd_vendor, disks[k].name, 3)) {
510 for (size_t l = 0; l < disks[k].num_parts; ++l) {
511 if (letter == disks[k].parts[l].letter) {
512 disks[k].parts[l].sub = disk;
513 disks[k].parts[l].raidstatus = bd_statusstr(bd.bd_status);
526 static int usage (void)
528 fputs ("Usage: lsblk [-abinUuV] [disk...]\n", stderr);
532 static void pad_update (int *pad, int newval)
538 static void pad_disk (struct padding *p, const struct my_diskinfo *disk)
543 len_disk = strnlen (disk->name, sizeof disk->name);
544 comment = strnlen (disk->label, sizeof disk->label);
545 if (disk->raidstatus)
546 comment += strlen (disk->raidstatus) + 3;
548 pad_update (&p->name, len_disk);
549 pad_update (&p->type, strnlen (disk->type, sizeof disk->type));
550 pad_update (&p->comment, comment);
552 for (int i = 0; i < disk->num_parts; ++i) {
553 const struct my_partinfo *part = &disk->parts[i];
555 pad_update (&p->name, len_disk + 3);
556 pad_update (&p->type, strlen (part->fstype));
559 pad_update (&p->name, strnlen (part->sub->name, sizeof part->sub->name) + 4);
560 pad_update (&p->comment, strlen (part->raidstatus));
561 } else if (part->mount) {
562 pad_update (&p->comment, strlen (part->mount));
568 static int compare_disk (const void *p1, const void *p2)
570 const struct my_diskinfo *d1 = p1;
571 const struct my_diskinfo *d2 = p2;
573 return strcmp (d1->name, d2->name);
576 int main (int argc, char *argv[])
579 int fields = FIELD_DEFAULT;
583 if (unveil ("/dev", "r") == -1)
584 err (1, "unveil(/dev)");
586 if (unveil (NULL, NULL) == -1)
589 while ((option = getopt (argc, argv, ":abinUuV")) != -1) {
595 options |= OPT_NOBIO;
598 options |= OPT_NOUNICODE;
601 options |= OPT_NOHEADER;
604 fields |= FIELD_DUID;
607 fields |= FIELD_USED | FIELD_FREE;
610 puts ("lsblk-" VERSION);
620 char *names = argc == 0 ? disknames () : NULL;
622 if (pledge ("stdio rpath disklabel", NULL) == -1)
627 const char *s = names;
629 while ((s = strchr (s, ',')) != NULL)
635 struct my_diskinfo *disks = calloc (cap_disks, sizeof (struct my_diskinfo));
636 size_t num_disks = 0;
639 for (char *name; (name = strsep (&names, ",")) != NULL; ) {
640 char *colon = strchr (name, ':');
641 struct my_diskinfo disk;
645 if (read_disk (name, &disk) == 0) {
646 disks[num_disks++] = disk;
655 for (int i = 0; i < argc; ++i) {
656 char *name = basename (argv[i]);
657 char *last = name + strlen (name) - 1;
658 struct my_diskinfo disk;
660 if (isalpha (*last)) {
661 warnx ("%s: specifying a partition is not supported, using the drive.", name);
664 if (read_disk (name, &disk) == 0) {
665 disks[num_disks++] = disk;
677 mergesort (disks, num_disks, sizeof *disks, compare_disk);
679 if (!(options & OPT_NOBIO)) {
680 for (size_t i = 0; i < num_disks; ++i) {
681 read_raid (&disks[i], disks, num_disks);
686 .name = strlen ("NAME"),
687 .type = strlen ("TYPE"),
688 .comment = strlen ("COMMENT"),
691 for (size_t i = 0; i < num_disks; ++i)
692 pad_disk (&p, &disks[i]);
694 if (!(options & OPT_NOHEADER))
695 print_header (fields, &p);
697 for (size_t i = 0; i < num_disks; ++i) {
698 print_disk (&disks[i], fields, options, NULL, &p);