Merge branch 'busybox' into merge

6 files changed, 213 insertions, 8 deletions

diff --git a/util-linux/blkdiscard.c b/util-linux/blkdiscard.c
new file mode 100644
index 000000000..ace88a1f0
--- /dev/null
+++ b/util-linux/blkdiscard.c
@@ -0,0 +1,83 @@
+/*
+ * Mini blkdiscard implementation for busybox
+ *
+ * Copyright (C) 2015 by Ari Sundholm <ari@tuxera.com> and Tuxera Inc.
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//config:config BLKDISCARD
+//config:       bool "blkdiscard"
+//config:       default y
+//config:       help
+//config:         blkdiscard discards sectors on a given device.
+
+//kbuild:lib-$(CONFIG_BLKDISCARD) += blkdiscard.o
+//applet:IF_BLKDISCARD(APPLET(blkdiscard, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//usage:#define blkdiscard_trivial_usage
+//usage:       "[-o OFS] [-l LEN] [-s] DEVICE"
+//usage:#define blkdiscard_full_usage "\n\n"
+//usage:        "Discard sectors on DEVICE\n"
+//usage:        "\n     -o OFS  Byte offset into device"
+//usage:        "\n     -l LEN  Number of bytes to discard"
+//usage:        "\n     -s      Perform a secure discard"
+//usage:
+//usage:#define blkdiscard_example_usage
+//usage:        "$ blkdiscard -o 0 -l 1G /dev/sdb"
+
+#include "libbb.h"
+#include <linux/fs.h>
+
+int blkdiscard_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int blkdiscard_main(int argc UNUSED_PARAM, char **argv)
+{
+        unsigned opts;
+        const char *offset_str = "0";
+        const char *length_str;
+        uint64_t offset; /* Leaving these two variables out does not  */
+        uint64_t length; /* shrink code size and hampers readability. */
+        uint64_t range[2];
+//      struct stat st;
+        int fd;
+
+        enum {
+                OPT_OFFSET = (1 << 0),
+                OPT_LENGTH = (1 << 1),
+                OPT_SECURE = (1 << 2),
+        };
+
+        opt_complementary = "=1";
+        opts = getopt32(argv, "o:l:s", &offset_str, &length_str);
+        argv += optind;
+
+        fd = xopen(argv[0], O_RDWR|O_EXCL);
+//Why bother, BLK[SEC]DISCARD will fail on non-blockdevs anyway?
+//      xfstat(fd, &st);
+//      if (!S_ISBLK(st.st_mode))
+//              bb_error_msg_and_die("%s: not a block device", argv[0]);
+
+        offset = xatoull_sfx(offset_str, kMG_suffixes);
+
+        if (opts & OPT_LENGTH)
+                length = xatoull_sfx(length_str, kMG_suffixes);
+        else {
+                xioctl(fd, BLKGETSIZE64, &length);
+                length -= offset;
+        }
+
+        range[0] = offset;
+        range[1] = length;
+        ioctl_or_perror_and_die(fd,
+                        (opts & OPT_SECURE) ? BLKSECDISCARD : BLKDISCARD,
+                        &range,
+                        "%s: %s failed",
+                        argv[0],
+                        (opts & OPT_SECURE) ? "BLKSECDISCARD" : "BLKDISCARD"
+        );
+
+        if (ENABLE_FEATURE_CLEAN_UP)
+                close(fd);
+
+        return EXIT_SUCCESS;
+}
diff --git a/util-linux/mount.c b/util-linux/mount.c
index cb40c802d..c428f5827 100644
--- a/util-linux/mount.c
+++ b/util-linux/mount.c
@@ -259,9 +259,11 @@ static struct mntent *getmntent_r(FILE* stream, struct mntent* result,
 
 // Not real flags, but we want to be able to check for this.
 enum {
-        MOUNT_USERS  = (1 << 28) * ENABLE_DESKTOP,
+        MOUNT_USERS  = (1 << 27) * ENABLE_DESKTOP,
+        MOUNT_NOFAIL = (1 << 28) * ENABLE_DESKTOP,
         MOUNT_NOAUTO = (1 << 29),
         MOUNT_SWAP   = (1 << 30),
+        MOUNT_FAKEFLAGS = MOUNT_USERS | MOUNT_NOFAIL | MOUNT_NOAUTO | MOUNT_SWAP
 };
 
 
@@ -326,6 +328,7 @@ static const int32_t mount_options[] = {
                 /* "swap"   */ MOUNT_SWAP,
                 IF_DESKTOP(/* "user"  */ MOUNT_USERS,)
                 IF_DESKTOP(/* "users" */ MOUNT_USERS,)
+                IF_DESKTOP(/* "nofail" */ MOUNT_NOFAIL,)
                 /* "_netdev" */ 0,
                 IF_DESKTOP(/* "comment=" */ 0,) /* systemd uses this in fstab */
         )
@@ -385,6 +388,7 @@ static const char mount_option_str[] =
                 "swap\0"
                 IF_DESKTOP("user\0")
                 IF_DESKTOP("users\0")
+                IF_DESKTOP("nofail\0")
                 "_netdev\0"
                 IF_DESKTOP("comment=\0") /* systemd uses this in fstab */
         )
@@ -672,6 +676,8 @@ static int mount_it_now(struct mntent *mp, unsigned long vfsflags, char *filtero
 {
         int rc = 0;
 
+        vfsflags &= ~(unsigned long)MOUNT_FAKEFLAGS;
+
         if (FAKE_IT) {
                 if (verbose >= 2)
                         bb_error_msg("would do mount('%s','%s','%s',0x%08lx,'%s')",
@@ -2061,6 +2067,8 @@ static int singlemount(struct mntent *mp, int ignore_busy)
 
         if (errno == EBUSY && ignore_busy)
                 return 0;
+        if (errno == ENOENT && (vfsflags & MOUNT_NOFAIL))
+                return 0;
         if (rc != 0)
                 bb_perror_msg("mounting %s on %s failed", mp->mnt_fsname, mp->mnt_dir);
         return rc;
diff --git a/util-linux/swaponoff.c b/util-linux/swaponoff.c
index 5cd1fbe70..c29dd3071 100644
--- a/util-linux/swaponoff.c
+++ b/util-linux/swaponoff.c
@@ -22,11 +22,10 @@
 //usage:        )
 //usage:
 //usage:#define swapoff_trivial_usage
-//usage:       "[-a] [-e] [DEVICE]"
+//usage:       "[-a] [DEVICE]"
 //usage:#define swapoff_full_usage "\n\n"
 //usage:       "Stop swapping on DEVICE\n"
 //usage:     "\n        -a      Stop swapping on all swap devices"
-//usage:     "\n        -e      Silently skip devices that do not exist"
 
 #include "libbb.h"
 #include <mntent.h>
@@ -97,11 +96,8 @@ static int swap_enable_disable(char *device)
 {
         int err = 0;
         int quiet = 0;
-        struct stat st;
 
         resolve_mount_spec(&device);
-        if (!OPT_IFEXISTS)
-                xstat(device, &st);
 
         if (do_swapoff) {
                 err = swapoff(device);
@@ -109,6 +105,7 @@ static int swap_enable_disable(char *device)
                 quiet = (OPT_ALL && (errno == EINVAL || errno == ENOENT));
         } else {
                 /* swapon */
+                struct stat st;
                 err = stat(device, &st);
                 if (!err) {
                         if (ENABLE_DESKTOP && S_ISREG(st.st_mode)) {
@@ -119,9 +116,11 @@ static int swap_enable_disable(char *device)
                         }
                         err = swapon(device, g_flags);
                         /* Don't complain on swapon -a if device is already in use */
-                        /* Don't complain if file does not exist with -e option */
-                        quiet = (OPT_ALL && errno == EBUSY) || (OPT_IFEXISTS && errno == ENOENT);
+                        quiet = (OPT_ALL && errno == EBUSY);
                 }
+                /* Don't complain if file does not exist with -e option */
+                if (err && OPT_IFEXISTS && errno == ENOENT)
+                        err = 0;
         }
 
         if (err && !quiet) {
diff --git a/util-linux/volume_id/bcache.c b/util-linux/volume_id/bcache.c
new file mode 100644
index 000000000..648e44de5
--- /dev/null
+++ b/util-linux/volume_id/bcache.c
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2013 Rolf Fokkens <rolf@fokkens.nl>
+ *
+ * This file may be redistributed under the terms of the
+ * GNU Lesser General Public License.
+ *
+ * Based on code fragments from bcache-tools by Kent Overstreet:
+ * http://evilpiepirate.org/git/bcache-tools.git
+ */
+
+//kbuild:lib-$(CONFIG_FEATURE_VOLUMEID_BCACHE) += bcache.o
+
+//config:
+//config:config FEATURE_VOLUMEID_BCACHE
+//config:       bool "bcache filesystem"
+//config:       default y
+//config:       depends on VOLUMEID
+//config:       help
+//config:         TODO
+//config:
+
+#include "volume_id_internal.h"
+
+#define SB_LABEL_SIZE      32
+#define SB_JOURNAL_BUCKETS 256U
+
+static const char bcache_magic[] = {
+        0xc6, 0x85, 0x73, 0xf6, 0x4e, 0x1a, 0x45, 0xca,
+        0x82, 0x65, 0xf5, 0x7f, 0x48, 0xba, 0x6d, 0x81
+};
+
+struct bcache_super_block {
+        uint64_t                csum;
+        uint64_t                offset; /* sector where this sb was written */
+        uint64_t                version;
+
+        uint8_t                 magic[16];
+
+        uint8_t                 uuid[16];
+        union {
+                uint8_t         set_uuid[16];
+                uint64_t        set_magic;
+        };
+        uint8_t                 label[SB_LABEL_SIZE];
+
+        uint64_t                flags;
+        uint64_t                seq;
+        uint64_t                pad[8];
+
+        union {
+        struct {
+                /* Cache devices */
+                uint64_t        nbuckets;       /* device size */
+
+                uint16_t        block_size;     /* sectors */
+                uint16_t        bucket_size;    /* sectors */
+
+                uint16_t        nr_in_set;
+                uint16_t        nr_this_dev;
+        };
+        struct {
+                /* Backing devices */
+                uint64_t        data_offset;
+
+                /*
+                 * block_size from the cache device section is still used by
+                 * backing devices, so don't add anything here until we fix
+                 * things to not need it for backing devices anymore
+                 */
+        };
+        };
+
+        uint32_t                last_mount;     /* time_t */
+
+        uint16_t                first_bucket;
+        union {
+                uint16_t        njournal_buckets;
+                uint16_t        keys;
+        };
+        uint64_t                d[SB_JOURNAL_BUCKETS];  /* journal buckets */
+};
+
+/* magic string */
+#define BCACHE_SB_MAGIC     bcache_magic
+/* magic string len */
+#define BCACHE_SB_MAGIC_LEN sizeof (bcache_magic)
+/* super block offset */
+#define BCACHE_SB_OFF       0x1000
+/* supper block offset in kB */
+#define BCACHE_SB_KBOFF     (BCACHE_SB_OFF >> 10)
+/* magic string offset within super block */
+#define BCACHE_SB_MAGIC_OFF offsetof (struct bcache_super_block, magic)
+
+int FAST_FUNC volume_id_probe_bcache(struct volume_id *id /*,uint64_t off*/)
+{
+        struct bcache_super_block *sb;
+
+        sb = volume_id_get_buffer(id, BCACHE_SB_OFF, sizeof(*sb));
+        if (sb == NULL)
+                return -1;
+
+        if (memcmp(sb->magic, BCACHE_SB_MAGIC, BCACHE_SB_MAGIC_LEN) != 0)
+                return -1;
+
+        volume_id_set_label_string(id, sb->label, SB_LABEL_SIZE);
+        volume_id_set_uuid(id, sb->uuid, UUID_DCE);
+        IF_FEATURE_BLKID_TYPE(id->type = "bcache";)
+
+        return 0;
+}
diff --git a/util-linux/volume_id/volume_id.c b/util-linux/volume_id/volume_id.c
index 5c459a0e2..3f71e0084 100644
--- a/util-linux/volume_id/volume_id.c
+++ b/util-linux/volume_id/volume_id.c
@@ -107,6 +107,9 @@ static const probe_fptr fs1[] = {
 #if ENABLE_FEATURE_VOLUMEID_XFS
         volume_id_probe_xfs,
 #endif
+#if ENABLE_FEATURE_VOLUMEID_BCACHE
+        volume_id_probe_bcache,
+#endif
 };
 
 /* fill buffer with maximum */
diff --git a/util-linux/volume_id/volume_id_internal.h b/util-linux/volume_id/volume_id_internal.h
index 6e2dbd7bb..3061ac4d5 100644
--- a/util-linux/volume_id/volume_id_internal.h
+++ b/util-linux/volume_id/volume_id_internal.h
@@ -169,6 +169,8 @@ int FAST_FUNC volume_id_probe_linux_raid(struct volume_id *id /*,uint64_t off*/,
 
 /* FS */
 
+int FAST_FUNC volume_id_probe_bcache(struct volume_id *id /*,uint64_t off*/);
+
 int FAST_FUNC volume_id_probe_btrfs(struct volume_id *id /*,uint64_t off*/);
 
 int FAST_FUNC volume_id_probe_cramfs(struct volume_id *id /*,uint64_t off*/);