Merge branch busybox (up to "ash: comment out free(p) just before...")

8 files changed, 292 insertions, 131 deletions

diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index 6391f9bd9..32a66d03d 100644
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -363,7 +363,6 @@ struct globals {
 
         jmp_buf listingbuf;
         char line_buffer[80];
-        char partname_buffer[80];
         /* Raw disk label. For DOS-type partition tables the MBR,
          * with descriptions of the primary partitions. */
         char MBRbuffer[MAX_SECTOR_SIZE];
@@ -399,7 +398,6 @@ struct globals {
 #define total_number_of_sectors (G.total_number_of_sectors)
 #define listingbuf      (G.listingbuf     )
 #define line_buffer     (G.line_buffer    )
-#define partname_buffer (G.partname_buffer)
 #define MBRbuffer       (G.MBRbuffer      )
 #define ptes            (G.ptes           )
 #define INIT_G() do { \
@@ -468,9 +466,6 @@ static sector_t bb_BLKGETSIZE_sectors(int fd)
 
 #define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
 
-#define hsc2sector(h,s,c) \
-        (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
-
 static void
 close_dev_fd(void)
 {
@@ -478,9 +473,7 @@ close_dev_fd(void)
         xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
 }
 
-/*
- * Return partition name - uses static storage
- */
+/* Return partition name */
 static const char *
 partname(const char *dev, int pno, int lth)
 {
@@ -489,8 +482,8 @@ partname(const char *dev, int pno, int lth)
         int bufsiz;
         char *bufp;
 
-        bufp = partname_buffer;
-        bufsiz = sizeof(partname_buffer);
+        bufp = auto_string(xzalloc(80));
+        bufsiz = 80;
 
         w = strlen(dev);
         p = "";
@@ -1898,14 +1891,14 @@ check_consistency(const struct partition *p, int partition)
                 return;         /* do not check extended partitions */
 
 /* physical beginning c, h, s */
-        pbc = (p->cyl & 0xff) | ((p->sector << 2) & 0x300);
+        pbc = cylinder(p->sector, p->cyl);
         pbh = p->head;
-        pbs = p->sector & 0x3f;
+        pbs = sector(p->sector);
 
 /* physical ending c, h, s */
-        pec = (p->end_cyl & 0xff) | ((p->end_sector << 2) & 0x300);
+        pec = cylinder(p->end_sector, p->end_cyl);
         peh = p->end_head;
-        pes = p->end_sector & 0x3f;
+        pes = sector(p->end_sector);
 
 /* compute logical beginning (c, h, s) */
         linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
@@ -1916,17 +1909,17 @@ check_consistency(const struct partition *p, int partition)
 /* Same physical / logical beginning? */
         if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
                 printf("Partition %u has different physical/logical "
-                        "beginnings (non-Linux?):\n", partition + 1);
-                printf("     phys=(%u, %u, %u) ", pbc, pbh, pbs);
-                printf("logical=(%u, %u, %u)\n", lbc, lbh, lbs);
+                        "start (non-Linux?):\n", partition + 1);
+                printf("     phys=(%u,%u,%u) ", pbc, pbh, pbs);
+                printf("logical=(%u,%u,%u)\n", lbc, lbh, lbs);
         }
 
 /* Same physical / logical ending? */
         if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
                 printf("Partition %u has different physical/logical "
-                        "endings:\n", partition + 1);
-                printf("     phys=(%u, %u, %u) ", pec, peh, pes);
-                printf("logical=(%u, %u, %u)\n", lec, leh, les);
+                        "end:\n", partition + 1);
+                printf("     phys=(%u,%u,%u) ", pec, peh, pes);
+                printf("logical=(%u,%u,%u)\n", lec, leh, les);
         }
 
 /* Ending on cylinder boundary? */
@@ -1940,22 +1933,23 @@ static void
 list_disk_geometry(void)
 {
         ullong bytes = ((ullong)total_number_of_sectors << 9);
-        long megabytes = bytes / 1000000;
-
-        if (megabytes < 10000)
-                printf("\nDisk %s: %lu MB, %llu bytes\n",
-                        disk_device, megabytes, bytes);
-        else
-                printf("\nDisk %s: %lu.%lu GB, %llu bytes\n",
-                        disk_device, megabytes/1000, (megabytes/100)%10, bytes);
-        printf("%u heads, %u sectors/track, %u cylinders",
-                   g_heads, g_sectors, g_cylinders);
-        if (units_per_sector == 1)
-                printf(", total %"SECT_FMT"u sectors",
-                        total_number_of_sectors / (sector_size/512));
-        printf("\nUnits = %s of %u * %u = %u bytes\n\n",
+        ullong xbytes = bytes / (1024*1024);
+        char x = 'M';
+
+        if (xbytes >= 10000) {
+                xbytes += 512; /* fdisk util-linux 2.28 does this */
+                xbytes /= 1024;
+                x = 'G';
+        }
+        printf("Disk %s: %llu %cB, %llu bytes, %"SECT_FMT"u sectors\n"
+                "%u cylinders, %u heads, %u sectors/track\n"
+                "Units: %s of %u * %u = %u bytes\n\n",
+                disk_device, xbytes, x,
+                bytes, total_number_of_sectors,
+                g_cylinders, g_heads, g_sectors,
                 str_units(PLURAL),
-                units_per_sector, sector_size, units_per_sector * sector_size);
+                units_per_sector, sector_size, units_per_sector * sector_size
+        );
 }
 
 /*
@@ -2099,10 +2093,17 @@ fix_partition_table_order(void)
 }
 #endif
 
+static const char *
+chs_string11(unsigned cyl, unsigned head, unsigned sect)
+{
+        char *buf = auto_string(xzalloc(sizeof(int)*3 * 3));
+        sprintf(buf, "%u,%u,%u", cylinder(sect,cyl), head, sector(sect));
+        return buf;
+}
+
 static void
 list_table(int xtra)
 {
-        const struct partition *p;
         int i, w;
 
         if (LABEL_IS_SUN) {
@@ -2126,50 +2127,62 @@ list_table(int xtra)
         }
 
         /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
-           but if the device name ends in a digit, say /dev/foo1,
-           then the partition is called /dev/foo1p3. */
+         * but if the device name ends in a digit, say /dev/foo1,
+         * then the partition is called /dev/foo1p3.
+         */
         w = strlen(disk_device);
         if (w && isdigit(disk_device[w-1]))
                 w++;
-        if (w < 5)
-                w = 5;
+        if (w < 7)
+                w = 7;
 
-        //            1 12345678901 12345678901 12345678901  12
-        printf("%*s Boot      Start         End      Blocks  Id System\n",
-                   w+1, "Device");
+        printf("%-*s Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type\n",
+                   w-1, "Device");
 
         for (i = 0; i < g_partitions; i++) {
+                const struct partition *p;
                 const struct pte *pe = &ptes[i];
-                sector_t psects;
-                sector_t pblocks;
-                unsigned podd;
+                char boot4[4];
+                char numstr6[6];
+                sector_t start_sect;
+                sector_t end_sect;
+                sector_t nr_sects;
 
                 p = pe->part_table;
                 if (!p || is_cleared_partition(p))
                         continue;
 
-                psects = get_nr_sects(p);
-                pblocks = psects;
-                podd = 0;
-
-                if (sector_size < 1024) {
-                        pblocks /= (1024 / sector_size);
-                        podd = psects % (1024 / sector_size);
+                sprintf(boot4, "%02x", p->boot_ind);
+                if ((p->boot_ind & 0x7f) == 0) {
+                        /* 0x80 shown as '*', 0x00 is ' ' */
+                        boot4[0] = p->boot_ind ? '*' : ' ';
+                        boot4[1] = ' ';
                 }
-                if (sector_size > 1024)
-                        pblocks *= (sector_size / 1024);
 
-                printf("%s  %c %11"SECT_FMT"u %11"SECT_FMT"u %11"SECT_FMT"u%c %2x %s\n",
-                        partname(disk_device, i+1, w+2),
-                        !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
-                                ? '*' : '?',
-                        cround(get_partition_start_from_dev_start(pe)),           /* start */
-                        cround(get_partition_start_from_dev_start(pe) + psects    /* end */
-                                - (psects ? 1 : 0)),
-                        pblocks, podd ? '+' : ' ', /* odd flag on end */
-                        p->sys_ind,                                     /* type id */
-                        partition_type(p->sys_ind));                    /* type name */
+                start_sect = get_partition_start_from_dev_start(pe);
+                end_sect = start_sect;
+                nr_sects = get_nr_sects(p);
+                if (nr_sects != 0)
+                        end_sect += nr_sects - 1;
+
+                smart_ulltoa5((ullong)nr_sects * sector_size,
+                        numstr6, " KMGTPEZY")[0] = '\0';
 
+#define SFMT SECT_FMT
+                //      Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type
+                printf("%s%s %-11s"/**/" %-11s"/**/" %10"SFMT"u %10"SFMT"u %10"SFMT"u %s %2x %s\n",
+                        partname(disk_device, i+1, w+2),
+                        boot4,
+                        chs_string11(p->cyl, p->head, p->sector),
+                        chs_string11(p->end_cyl, p->end_head, p->end_sector),
+                        start_sect,
+                        end_sect,
+                        nr_sects,
+                        numstr6,
+                        p->sys_ind,
+                        partition_type(p->sys_ind)
+                );
+#undef SFMT
                 check_consistency(p, i);
         }
 
@@ -2198,13 +2211,17 @@ x_list_table(int extend)
                 p = (extend ? pe->ext_pointer : pe->part_table);
                 if (p != NULL) {
                         printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",
-                                i + 1, p->boot_ind, p->head,
+                                i + 1, p->boot_ind,
+                                p->head,
                                 sector(p->sector),
-                                cylinder(p->sector, p->cyl), p->end_head,
+                                cylinder(p->sector, p->cyl),
+                                p->end_head,
                                 sector(p->end_sector),
                                 cylinder(p->end_sector, p->end_cyl),
-                                get_start_sect(p), get_nr_sects(p),
-                                p->sys_ind);
+                                get_start_sect(p),
+                                get_nr_sects(p),
+                                p->sys_ind
+                        );
                         if (p->sys_ind)
                                 check_consistency(p, i);
                 }
@@ -2261,6 +2278,7 @@ verify(void)
 {
         int i, j;
         sector_t total = 1;
+        sector_t chs_size;
         sector_t first[g_partitions], last[g_partitions];
         struct partition *p;
 
@@ -2322,11 +2340,14 @@ verify(void)
                 }
         }
 
-        if (total > g_heads * g_sectors * g_cylinders)
-                printf("Total allocated sectors %u greater than the maximum "
-                        "%u\n", total, g_heads * g_sectors * g_cylinders);
+        chs_size = (sector_t)g_heads * g_sectors * g_cylinders;
+        if (total > chs_size)
+                printf("Total allocated sectors %u"
+                        " greater than CHS size %"SECT_FMT"u\n",
+                        total, chs_size
+                );
         else {
-                total = g_heads * g_sectors * g_cylinders - total;
+                total = chs_size - total;
                 if (total != 0)
                         printf("%"SECT_FMT"u unallocated sectors\n", total);
         }
diff --git a/util-linux/mdev.c b/util-linux/mdev.c
index 37514eb54..a59115dd4 100644
--- a/util-linux/mdev.c
+++ b/util-linux/mdev.c
@@ -543,8 +543,7 @@ static char *build_alias(char *alias, const char *device_name)
 
 /* mknod in /dev based on a path like "/sys/block/hda/hda1"
  * NB1: path parameter needs to have SCRATCH_SIZE scratch bytes
- * after NUL, but we promise to not mangle (IOW: to restore NUL if needed)
- * path string.
+ * after NUL, but we promise to not mangle it (IOW: to restore NUL if needed).
  * NB2: "mdev -s" may call us many times, do not leak memory/fds!
  *
  * device_name = $DEVNAME (may be NULL)
@@ -810,41 +809,39 @@ static void make_device(char *device_name, char *path, int operation)
         } /* for (;;) */
 }
 
-/* File callback for /sys/ traversal */
+/* File callback for /sys/ traversal.
+ * We act only on "/sys/.../dev" (pseudo)file
+ */
 static int FAST_FUNC fileAction(const char *fileName,
                 struct stat *statbuf UNUSED_PARAM,
                 void *userData,
                 int depth UNUSED_PARAM)
 {
         size_t len = strlen(fileName) - 4; /* can't underflow */
-        char *scratch = userData;
-
-        /* len check is for paranoid reasons */
-        if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX)
-                return FALSE;
-
-        strcpy(scratch, fileName);
-        scratch[len] = '\0';
-        make_device(/*DEVNAME:*/ NULL, scratch, OP_add);
-
-        return TRUE;
-}
-
-/* Directory callback for /sys/ traversal */
-static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM,
-                struct stat *statbuf UNUSED_PARAM,
-                void *userData UNUSED_PARAM,
-                int depth)
-{
-        /* Extract device subsystem -- the name of the directory
-         * under /sys/class/ */
-        if (1 == depth) {
+        char *path = userData;  /* char array[PATH_MAX + SCRATCH_SIZE] */
+        char subsys[PATH_MAX];
+        int res;
+
+        /* Is it a ".../dev" file? (len check is for paranoid reasons) */
+        if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX - 32)
+                return FALSE; /* not .../dev */
+
+        strcpy(path, fileName);
+        path[len] = '\0';
+
+        /* Read ".../subsystem" symlink in the same directory where ".../dev" is */
+        strcpy(subsys, path);
+        strcpy(subsys + len, "/subsystem");
+        res = readlink(subsys, subsys, sizeof(subsys)-1);
+        if (res > 0) {
+                subsys[res] = '\0';
                 free(G.subsystem);
                 if (G.subsys_env) {
                         bb_unsetenv_and_free(G.subsys_env);
                         G.subsys_env = NULL;
                 }
-                G.subsystem = strrchr(fileName, '/');
+                /* Set G.subsystem and $SUBSYSTEM from symlink's last component */
+                G.subsystem = strrchr(subsys, '/');
                 if (G.subsystem) {
                         G.subsystem = xstrdup(G.subsystem + 1);
                         G.subsys_env = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem);
@@ -852,6 +849,17 @@ static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM,
                 }
         }
 
+        make_device(/*DEVNAME:*/ NULL, path, OP_add);
+
+        return TRUE;
+}
+
+/* Directory callback for /sys/ traversal */
+static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM,
+                struct stat *statbuf UNUSED_PARAM,
+                void *userData UNUSED_PARAM,
+                int depth)
+{
         return (depth >= MAX_SYSFS_DEPTH ? SKIP : TRUE);
 }
 
@@ -872,8 +880,9 @@ static void load_firmware(const char *firmware, const char *sysfs_path)
         int firmware_fd, loading_fd;
 
         /* check for /lib/firmware/$FIRMWARE */
-        xchdir("/lib/firmware");
-        firmware_fd = open(firmware, O_RDONLY); /* can fail */
+        firmware_fd = -1;
+        if (chdir("/lib/firmware") == 0)
+                firmware_fd = open(firmware, O_RDONLY); /* can fail */
 
         /* check for /sys/$DEVPATH/loading ... give 30 seconds to appear */
         xchdir(sysfs_path);
@@ -1065,25 +1074,10 @@ int mdev_main(int argc UNUSED_PARAM, char **argv)
 
                 putenv((char*)"ACTION=add");
 
-                /* ACTION_FOLLOWLINKS is needed since in newer kernels
-                 * /sys/block/loop* (for example) are symlinks to dirs,
-                 * not real directories.
-                 * (kernel's CONFIG_SYSFS_DEPRECATED makes them real dirs,
-                 * but we can't enforce that on users)
-                 */
-                if (access("/sys/class/block", F_OK) != 0) {
-                        /* Scan obsolete /sys/block only if /sys/class/block
-                         * doesn't exist. Otherwise we'll have dupes.
-                         * Also, do not complain if it doesn't exist.
-                         * Some people configure kernel to have no blockdevs.
-                         */
-                        recursive_action("/sys/block",
-                                ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET,
-                                fileAction, dirAction, temp, 0);
-                }
-                recursive_action("/sys/class",
-                        ACTION_RECURSE | ACTION_FOLLOWLINKS,
-                        fileAction, dirAction, temp, 0);
+                /* Create all devices from /sys/dev hierarchy */
+                recursive_action("/sys/dev",
+                                 ACTION_RECURSE | ACTION_FOLLOWLINKS,
+                                 fileAction, dirAction, temp, 0);
         } else {
                 char *fw;
                 char *seq;
diff --git a/util-linux/mount.c b/util-linux/mount.c
index 13590ceb4..eb8b7ba7b 100644
--- a/util-linux/mount.c
+++ b/util-linux/mount.c
@@ -1931,7 +1931,6 @@ static int singlemount(struct mntent *mp, int ignore_busy)
                 int len;
                 char c;
                 char *hostname, *share;
-                char *dotted, *ip;
                 len_and_sockaddr *lsa;
 
                 // Parse mp->mnt_fsname of the form "//hostname/share[/dir1/dir2]"
@@ -1971,13 +1970,26 @@ static int singlemount(struct mntent *mp, int ignore_busy)
                 if (!lsa)
                         goto report_error;
 
-                // Insert "ip=..." option into options
-                dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
-                if (ENABLE_FEATURE_CLEAN_UP) free(lsa);
-                ip = xasprintf("ip=%s", dotted);
-                if (ENABLE_FEATURE_CLEAN_UP) free(dotted);
-                parse_mount_options(ip, &filteropts);
-                if (ENABLE_FEATURE_CLEAN_UP) free(ip);
+                // If there is no "ip=..." option yet
+                if (!is_prefixed_with(filteropts, ",ip="+1)
+                 && !strstr(filteropts, ",ip=")
+                ) {
+                        char *dotted, *ip;
+                        // Insert "ip=..." option into options
+                        dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
+                        if (ENABLE_FEATURE_CLEAN_UP) free(lsa);
+                        ip = xasprintf("ip=%s", dotted);
+                        if (ENABLE_FEATURE_CLEAN_UP) free(dotted);
+// Note: IPv6 scoped addresses ("host%iface", see RFC 4007) should be
+// handled by libc in getnameinfo() (inside xmalloc_sockaddr2dotted_noport()).
+// Currently, glibc does not support that (has no NI_NUMERICSCOPE),
+// musl apparently does. This results in "ip=numericIPv6%iface_name"
+// (instead of _numeric_ iface_id) with glibc.
+// This probably should be fixed in glibc, not here.
+// The workaround is to manually specify correct "ip=ADDR%n" option.
+                        parse_mount_options(ip, &filteropts);
+                        if (ENABLE_FEATURE_CLEAN_UP) free(ip);
+                }
 
                 mp->mnt_type = (char*)"cifs";
                 rc = mount_it_now(mp, vfsflags, filteropts);
diff --git a/util-linux/unshare.c b/util-linux/unshare.c
index fa7086add..dcc59559a 100644
--- a/util-linux/unshare.c
+++ b/util-linux/unshare.c
@@ -103,7 +103,7 @@ enum {
         OPT_mount       = 1 << 0,
         OPT_uts         = 1 << 1,
         OPT_ipc         = 1 << 2,
-        OPT_network     = 1 << 3,
+        OPT_net         = 1 << 3,
         OPT_pid         = 1 << 4,
         OPT_user        = 1 << 5, /* OPT_user, NS_USR_POS, and ns_list[] index must match! */
         OPT_fork        = 1 << 6,
@@ -142,7 +142,7 @@ static const char unshare_longopts[] ALIGN1 =
         "mount\0"               Optional_argument       "\xf0"
         "uts\0"                 Optional_argument       "\xf1"
         "ipc\0"                 Optional_argument       "\xf2"
-        "network\0"             Optional_argument       "\xf3"
+        "net\0"                 Optional_argument       "\xf3"
         "pid\0"                 Optional_argument       "\xf4"
         "user\0"                Optional_argument       "\xf5"
         "fork\0"                No_argument             "f"
diff --git a/util-linux/volume_id/get_devname.c b/util-linux/volume_id/get_devname.c
index 6b97df113..b64d28ceb 100644
--- a/util-linux/volume_id/get_devname.c
+++ b/util-linux/volume_id/get_devname.c
@@ -107,7 +107,11 @@ uuidcache_check_device(const char *device,
                 int depth UNUSED_PARAM)
 {
         /* note: this check rejects links to devices, among other nodes */
-        if (!S_ISBLK(statbuf->st_mode))
+        if (!S_ISBLK(statbuf->st_mode)
+#if ENABLE_FEATURE_VOLUMEID_UBIFS
+         && !(S_ISCHR(statbuf->st_mode) && strncmp(bb_basename(device), "ubi", 3) == 0)
+#endif
+        )
                 return TRUE;
 
         /* Users report that mucking with floppies (especially non-present
diff --git a/util-linux/volume_id/ubifs.c b/util-linux/volume_id/ubifs.c
new file mode 100644
index 000000000..13604ec35
--- /dev/null
+++ b/util-linux/volume_id/ubifs.c
@@ -0,0 +1,125 @@
+/*
+ * volume_id - reads filesystem label and uuid
+ *
+ * Copyright (C) 2012 S-G Bergh <sgb@systemasis.org>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+
+//kbuild:lib-$(CONFIG_FEATURE_VOLUMEID_UBIFS) += ubifs.o
+
+//config:
+//config:config FEATURE_VOLUMEID_UBIFS
+//config:       bool "UBIFS filesystem"
+//config:       default y
+//config:       depends on VOLUMEID
+//config:       help
+//config:         UBIFS (Unsorted Block Image File System) is a file
+//config:         system for use with raw flash memory media.
+//config:
+
+#include "volume_id_internal.h"
+
+#define UBIFS_NODE_MAGIC  0x06101831
+
+/*
+ * struct ubifs_ch - common header node.
+ * @magic: UBIFS node magic number (%UBIFS_NODE_MAGIC)
+ * @crc: CRC-32 checksum of the node header
+ * @sqnum: sequence number
+ * @len: full node length
+ * @node_type: node type
+ * @group_type: node group type
+ * @padding: reserved for future, zeroes
+ *
+ * Every UBIFS node starts with this common part. If the node has a key, the
+ * key always goes next.
+ */
+struct ubifs_ch {
+        uint32_t magic;
+        uint32_t crc;
+        uint64_t sqnum;
+        uint32_t len;
+        uint8_t node_type;
+        uint8_t group_type;
+        uint8_t padding[2];
+} PACKED;
+
+/*
+ * struct ubifs_sb_node - superblock node.
+ * @ch: common header
+ * @padding: reserved for future, zeroes
+ * @key_hash: type of hash function used in keys
+ * @key_fmt: format of the key
+ * @flags: file-system flags (%UBIFS_FLG_BIGLPT, etc)
+ * @min_io_size: minimal input/output unit size
+ * @leb_size: logical eraseblock size in bytes
+ * @leb_cnt: count of LEBs used by file-system
+ * @max_leb_cnt: maximum count of LEBs used by file-system
+ * @max_bud_bytes: maximum amount of data stored in buds
+ * @log_lebs: log size in logical eraseblocks
+ * @lpt_lebs: number of LEBs used for lprops table
+ * @orph_lebs: number of LEBs used for recording orphans
+ * @jhead_cnt: count of journal heads
+ * @fanout: tree fanout (max. number of links per indexing node)
+ * @lsave_cnt: number of LEB numbers in LPT's save table
+ * @fmt_version: UBIFS on-flash format version
+ * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)
+ * @padding1: reserved for future, zeroes
+ * @rp_uid: reserve pool UID
+ * @rp_gid: reserve pool GID
+ * @rp_size: size of the reserved pool in bytes
+ * @padding2: reserved for future, zeroes
+ * @time_gran: time granularity in nanoseconds
+ * @uuid: UUID generated when the file system image was created
+ * @ro_compat_version: UBIFS R/O compatibility version
+ */
+struct ubifs_sb_node {
+        struct ubifs_ch ch;
+        uint8_t padding[2];
+        uint8_t key_hash;
+        uint8_t key_fmt;
+        uint32_t flags;
+        uint32_t min_io_size;
+        uint32_t leb_size;
+        uint32_t leb_cnt;
+        uint32_t max_leb_cnt;
+        uint64_t max_bud_bytes;
+        uint32_t log_lebs;
+        uint32_t lpt_lebs;
+        uint32_t orph_lebs;
+        uint32_t jhead_cnt;
+        uint32_t fanout;
+        uint32_t lsave_cnt;
+        uint32_t fmt_version;
+        uint16_t default_compr;
+        uint8_t padding1[2];
+        uint32_t rp_uid;
+        uint32_t rp_gid;
+        uint64_t rp_size;
+        uint32_t time_gran;
+        uint8_t uuid[16];
+        uint32_t ro_compat_version;
+/*
+        uint8_t padding2[3968];
+*/
+} PACKED;
+
+int FAST_FUNC volume_id_probe_ubifs(struct volume_id *id /*,uint64_t off*/)
+{
+#define off ((uint64_t)0)
+        struct ubifs_sb_node *sb;
+
+        dbg("UBIFS: probing at offset 0x%llx", (unsigned long long) off);
+        sb = volume_id_get_buffer(id, off, sizeof(struct ubifs_sb_node));
+        if (!sb)
+                return -1;
+
+        if (le32_to_cpu(sb->ch.magic) != UBIFS_NODE_MAGIC)
+                return -1;
+
+        IF_FEATURE_BLKID_TYPE(id->type = "ubifs";)
+        volume_id_set_uuid(id, sb->uuid, UUID_DCE);
+
+        return 0;
+}
diff --git a/util-linux/volume_id/volume_id.c b/util-linux/volume_id/volume_id.c
index 3f71e0084..5bb95994b 100644
--- a/util-linux/volume_id/volume_id.c
+++ b/util-linux/volume_id/volume_id.c
@@ -168,6 +168,9 @@ static const probe_fptr fs2[] = {
 #if ENABLE_FEATURE_VOLUMEID_OCFS2
         volume_id_probe_ocfs2,
 #endif
+#if ENABLE_FEATURE_VOLUMEID_UBIFS
+        volume_id_probe_ubifs,
+#endif
 };
 
 int FAST_FUNC volume_id_probe_all(struct volume_id *id, /*uint64_t off,*/ uint64_t size)
diff --git a/util-linux/volume_id/volume_id_internal.h b/util-linux/volume_id/volume_id_internal.h
index 3061ac4d5..759a832e6 100644
--- a/util-linux/volume_id/volume_id_internal.h
+++ b/util-linux/volume_id/volume_id_internal.h
@@ -221,4 +221,6 @@ int FAST_FUNC volume_id_probe_udf(struct volume_id *id /*,uint64_t off*/);
 
 int FAST_FUNC volume_id_probe_xfs(struct volume_id *id /*,uint64_t off*/);
 
+int FAST_FUNC volume_id_probe_ubifs(struct volume_id *id /*,uint64_t off*/);
+
 POP_SAVED_FUNCTION_VISIBILITY