blockd: add automounting support
authorJohn Crispin <john@phrozen.org>
Tue, 21 Feb 2017 11:52:15 +0000 (12:52 +0100)
committerJohn Crispin <john@phrozen.org>
Mon, 27 Feb 2017 10:11:43 +0000 (11:11 +0100)
Signed-off-by: John Crispin <john@phrozen.org>
.gitignore
CMakeLists.txt
block.c
blockd.c [new file with mode: 0644]

index d00efbf5483a2011169a98a431f8d36c520e7a30..90f63813160a3202fb37ac186b38b7506a3fbdb1 100644 (file)
@@ -3,6 +3,7 @@ mount_root
 snapshot_tool
 ubi
 block
+blockd
 fs-state
 *.so
 *.a
index e7a97db4f8d155b7c4e4d75ac667733264655457..08d277f925130b69e136f7273f2231f205bd97ca 100644 (file)
@@ -54,14 +54,18 @@ ADD_EXECUTABLE(mount_root mount_root.c)
 TARGET_LINK_LIBRARIES(mount_root fstools)
 INSTALL(TARGETS mount_root RUNTIME DESTINATION sbin)
 
+ADD_EXECUTABLE(blockd blockd.c)
+TARGET_LINK_LIBRARIES(blockd fstools ubus blobmsg_json)
+INSTALL(TARGETS blockd RUNTIME DESTINATION sbin)
+
 find_library(json NAMES json-c json)
 
 ADD_EXECUTABLE(block block.c probe.c probe-libblkid.c)
 IF(DEFINED CMAKE_UBIFS_EXTROOT)
        ADD_DEFINITIONS(-DUBIFS_EXTROOT)
-       TARGET_LINK_LIBRARIES(block blkid-tiny dl uci ubox blobmsg_json ubi-utils ${json})
+       TARGET_LINK_LIBRARIES(block blkid-tiny dl uci ubox ubus blobmsg_json ubi-utils ${json})
 ELSE(DEFINED CMAKE_UBIFS_EXTROOT)
-       TARGET_LINK_LIBRARIES(block blkid-tiny dl uci ubox blobmsg_json ${json})
+       TARGET_LINK_LIBRARIES(block blkid-tiny dl uci ubox ubus blobmsg_json ${json})
 ENDIF(DEFINED CMAKE_UBIFS_EXTROOT)
 INSTALL(TARGETS block RUNTIME DESTINATION sbin)
 
diff --git a/block.c b/block.c
index 7db30acb205d5c99e6574160f39602b127cb4fa3..d5c39372945d35308d7b786543eb50886517b5fa 100644 (file)
--- a/block.c
+++ b/block.c
 #include <libubox/vlist.h>
 #include <libubox/blobmsg_json.h>
 #include <libubox/avl-cmp.h>
+#include <libubus.h>
 
 #include "probe.h"
 
+#define AUTOFS_MOUNT_PATH       "/tmp/run/blockd/"
+
 #ifdef UBIFS_EXTROOT
 #include "libubi/libubi.h"
 #endif
@@ -55,6 +58,12 @@ enum {
        TYPE_SWAP,
 };
 
+enum {
+       TYPE_DEV,
+       TYPE_HOTPLUG,
+       TYPE_AUTOFS,
+};
+
 struct mount {
        struct vlist_node node;
        int type;
@@ -67,6 +76,7 @@ struct mount {
        char *label;
        char *device;
        int extroot;
+       int autofs;
        int overlay;
        int disabled_fsck;
        unsigned int prio;
@@ -104,6 +114,7 @@ enum {
        MOUNT_TARGET,
        MOUNT_DEVICE,
        MOUNT_OPTIONS,
+       MOUNT_AUTOFS,
        __MOUNT_MAX
 };
 
@@ -119,6 +130,7 @@ static const struct blobmsg_policy mount_policy[__MOUNT_MAX] = {
        [MOUNT_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
        [MOUNT_OPTIONS] = { .name = "options", .type = BLOBMSG_TYPE_STRING },
        [MOUNT_ENABLE] = { .name = "enabled", .type = BLOBMSG_TYPE_INT32 },
+       [MOUNT_AUTOFS] = { .name = "autofs", .type = BLOBMSG_TYPE_INT32 },
 };
 
 static const struct uci_blob_param_list mount_attr_list = {
@@ -247,7 +259,7 @@ static int mount_add(struct uci_section *s)
        struct blob_attr *tb[__MOUNT_MAX] = { 0 };
        struct mount *m;
 
-        blob_buf_init(&b, 0);
+       blob_buf_init(&b, 0);
        uci_to_blob(&b, s, &mount_attr_list);
        blobmsg_parse(mount_policy, __MOUNT_MAX, tb, blob_data(b.head), blob_len(b.head));
 
@@ -263,7 +275,10 @@ static int mount_add(struct uci_section *s)
        m->label = blobmsg_get_strdup(tb[MOUNT_LABEL]);
        m->target = blobmsg_get_strdup(tb[MOUNT_TARGET]);
        m->device = blobmsg_get_basename(tb[MOUNT_DEVICE]);
-
+       if (tb[MOUNT_AUTOFS])
+               m->autofs = blobmsg_get_u32(tb[MOUNT_AUTOFS]);
+       else
+               m->autofs = 0;
        parse_mount_options(m, blobmsg_get_strdup(tb[MOUNT_OPTIONS]));
 
        m->overlay = m->extroot = 0;
@@ -900,7 +915,65 @@ static int handle_mount(const char *source, const char *target,
        return err;
 }
 
-static int mount_device(struct probe_info *pr, int hotplug)
+static void blockd_notify(char *device, struct mount *m, struct probe_info *pr)
+{
+       struct ubus_context *ctx = ubus_connect(NULL);
+       uint32_t id;
+
+       if (!ctx)
+               return;
+
+       if (!ubus_lookup_id(ctx, "block", &id)) {
+               struct blob_buf buf = { 0 };
+               char *d = strrchr(device, '/');
+
+               if (d)
+                       d++;
+               else
+                       d = device;
+
+               blob_buf_init(&buf, 0);
+
+               if (m) {
+
+                       blobmsg_add_string(&buf, "device", d);
+                       if (m->uuid)
+                               blobmsg_add_string(&buf, "uuid", m->uuid);
+                       if (m->label)
+                               blobmsg_add_string(&buf, "label", m->label);
+                       if (m->target)
+                               blobmsg_add_string(&buf, "target", m->target);
+                       if (m->options)
+                               blobmsg_add_string(&buf, "options", m->options);
+                       if (m->autofs)
+                               blobmsg_add_u32(&buf, "autofs", m->autofs);
+                       if (pr->type)
+                               blobmsg_add_string(&buf, "type", pr->type);
+                       if (pr->version)
+                               blobmsg_add_string(&buf, "version", pr->version);
+               } else if (pr) {
+                       blobmsg_add_string(&buf, "device", d);
+                       if (pr->uuid)
+                               blobmsg_add_string(&buf, "uuid", pr->uuid);
+                       if (pr->label)
+                               blobmsg_add_string(&buf, "label", pr->label);
+                       if (pr->type)
+                               blobmsg_add_string(&buf, "type", pr->type);
+                       if (pr->version)
+                               blobmsg_add_string(&buf, "version", pr->version);
+                       blobmsg_add_u32(&buf, "anon", 1);
+               } else {
+                       blobmsg_add_string(&buf, "device", d);
+                       blobmsg_add_u32(&buf, "remove", 1);
+               }
+
+               ubus_invoke(ctx, id, "hotplug", buf.head, NULL, NULL, 3000);
+       }
+
+       ubus_free(ctx);
+}
+
+static int mount_device(struct probe_info *pr, int type)
 {
        struct mount *m;
        char *device;
@@ -912,7 +985,7 @@ static int mount_device(struct probe_info *pr, int hotplug)
        device = basename(pr->dev);
 
        if (!strcmp(pr->type, "swap")) {
-               if (hotplug && !auto_swap)
+               if ((type == TYPE_HOTPLUG) && !auto_swap)
                        return -1;
                m = find_swap(pr->uuid, pr->label, device);
                if (m || anon_swap)
@@ -921,11 +994,8 @@ static int mount_device(struct probe_info *pr, int hotplug)
                return 0;
        }
 
-       if (hotplug && !auto_mount)
-               return -1;
-
        mp = find_mount_point(pr->dev);
-       if (mp) {
+       if (mp && (type != TYPE_HOTPLUG)) {
                ULOG_ERR("%s is already mounted on %s\n", pr->dev, mp);
                free(mp);
                return -1;
@@ -935,11 +1005,35 @@ static int mount_device(struct probe_info *pr, int hotplug)
        if (m && m->extroot)
                return -1;
 
+       if (m) switch (type) {
+       case TYPE_HOTPLUG:
+               blockd_notify(device, m, pr);
+               if (m->autofs)
+                       return 0;
+               if (!auto_mount)
+                       return -1;
+               break;
+       case TYPE_AUTOFS:
+               if (!m->autofs)
+                       return -1;
+               break;
+       case TYPE_DEV:
+               if (m->autofs)
+                       return -1;
+               break;
+       } else if (type == TYPE_HOTPLUG) {
+               blockd_notify(device, NULL, pr);
+       }
+
        if (m) {
                char *target = m->target;
                char _target[32];
                int err = 0;
 
+               if (m->autofs) {
+                       snprintf(_target, sizeof(_target), "/tmp/run/blockd/%s", device);
+                       target = _target;
+               }
                if (!target) {
                        snprintf(_target, sizeof(_target), "/mnt/%s", device);
                        target = _target;
@@ -1013,13 +1107,10 @@ static int umount_device(struct probe_info *pr)
        return err;
 }
 
-static int main_hotplug(int argc, char **argv)
+static int mount_action(char *action, char *device, int type)
 {
        char path[32];
-       char *action, *device, *mount_point;
-
-       action = getenv("ACTION");
-       device = getenv("DEVNAME");
+       char *mount_point;
 
        if (!action || !device)
                return -1;
@@ -1027,6 +1118,10 @@ static int main_hotplug(int argc, char **argv)
 
        if (!strcmp(action, "remove")) {
                int err = 0;
+
+               if (type == TYPE_HOTPLUG)
+                       blockd_notify(device, NULL, NULL);
+
                mount_point = find_mount_point(path);
                if (mount_point)
                        err = umount2(mount_point, MNT_DETACH);
@@ -1047,7 +1142,37 @@ static int main_hotplug(int argc, char **argv)
                return -1;
        cache_load(0);
 
-       return mount_device(find_block_info(NULL, NULL, path), 1);
+       return mount_device(find_block_info(NULL, NULL, path), type);
+}
+
+static int main_hotplug(int argc, char **argv)
+{
+       return mount_action(getenv("ACTION"), getenv("DEVNAME"), TYPE_HOTPLUG);
+}
+
+static int main_autofs(int argc, char **argv)
+{
+       if (argc < 3)
+               return -1;
+
+       if (!strcmp(argv[2], "start")) {
+               struct probe_info *pr;
+
+               if (config_load(NULL))
+                       return -1;
+
+               cache_load(0);
+               list_for_each_entry(pr, &devices, list) {
+                       struct mount *m = find_block(pr->uuid, pr->label, NULL, NULL);
+
+                       if (m && m->autofs)
+                               mount_device(pr, TYPE_HOTPLUG);
+                       else
+                               blockd_notify(pr->dev, m, pr);
+               }
+               return 0;
+       }
+       return mount_action(argv[2], argv[3], TYPE_AUTOFS);
 }
 
 static int find_block_mtd(char *name, char *part, int plen)
@@ -1425,7 +1550,7 @@ static int main_mount(int argc, char **argv)
 
        cache_load(1);
        list_for_each_entry(pr, &devices, list)
-               mount_device(pr, 0);
+               mount_device(pr, TYPE_DEV);
 
        handle_swapfiles(true);
 
@@ -1645,6 +1770,9 @@ int main(int argc, char **argv)
                if (!strcmp(argv[1], "hotplug"))
                        return main_hotplug(argc, argv);
 
+               if (!strcmp(argv[1], "autofs"))
+                       return main_autofs(argc, argv);
+
                if (!strcmp(argv[1], "extroot"))
                        return main_extroot(argc, argv);
 
diff --git a/blockd.c b/blockd.c
new file mode 100644 (file)
index 0000000..3af5390
--- /dev/null
+++ b/blockd.c
@@ -0,0 +1,467 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <sys/wait.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <errno.h>
+
+#include <linux/limits.h>
+#include <linux/auto_fs4.h>
+
+#include <libubox/uloop.h>
+#include <libubox/vlist.h>
+#include <libubox/ulog.h>
+#include <libubox/avl-cmp.h>
+#include <libubus.h>
+
+#include "libfstools/libfstools.h"
+
+#define        AUTOFS_MOUNT_PATH       "/tmp/run/blockd/"
+#define AUTOFS_TIMEOUT         30
+#define AUTOFS_EXPIRE_TIMER    (5 * 1000)
+
+struct device {
+       struct vlist_node node;
+       struct blob_attr *msg;
+       char *name;
+       char *target;
+       int autofs;
+       int anon;
+};
+
+static struct uloop_fd fd_autofs_read;
+static int fd_autofs_write = 0;
+static struct ubus_auto_conn conn;
+struct blob_buf bb = { 0 };
+
+enum {
+       MOUNT_UUID,
+       MOUNT_LABEL,
+       MOUNT_ENABLE,
+       MOUNT_TARGET,
+       MOUNT_DEVICE,
+       MOUNT_OPTIONS,
+       MOUNT_AUTOFS,
+       MOUNT_ANON,
+       MOUNT_REMOVE,
+       __MOUNT_MAX
+};
+
+static const struct blobmsg_policy mount_policy[__MOUNT_MAX] = {
+       [MOUNT_UUID] = { .name = "uuid", .type = BLOBMSG_TYPE_STRING },
+       [MOUNT_LABEL] = { .name = "label", .type = BLOBMSG_TYPE_STRING },
+       [MOUNT_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING },
+       [MOUNT_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
+       [MOUNT_OPTIONS] = { .name = "options", .type = BLOBMSG_TYPE_STRING },
+       [MOUNT_ENABLE] = { .name = "enabled", .type = BLOBMSG_TYPE_INT32 },
+       [MOUNT_AUTOFS] = { .name = "autofs", .type = BLOBMSG_TYPE_INT32 },
+       [MOUNT_ANON] = { .name = "anon", .type = BLOBMSG_TYPE_INT32 },
+       [MOUNT_REMOVE] = { .name = "remove", .type = BLOBMSG_TYPE_INT32 },
+};
+
+static char*
+_find_mount_point(char *device)
+{
+       char dev[32] = { 0 };
+
+       snprintf(dev, sizeof(dev), "/dev/%s", device);
+
+       return find_mount_point(dev, 0);
+}
+
+static int
+block(char *cmd, char *action, char *device)
+{
+       pid_t pid = fork();
+       int ret = -1;
+       int status;
+       char *argv[5] = { 0 };
+       int a = 0;
+
+       switch (pid) {
+       case -1:
+               ULOG_ERR("failed to fork block process\n");
+               break;
+
+       case 0:
+               argv[a++] = "/sbin/block";
+               argv[a++] = cmd;
+               argv[a++] = action;
+               argv[a++] = device;
+               execvp(argv[0], argv);
+               ULOG_ERR("failed to spawn %s %s %s\n", *argv, action, device);
+               exit(-1);
+
+       default:
+               waitpid(pid, &status, 0);
+               ret = WEXITSTATUS(status);
+               if (ret)
+                       ULOG_ERR("failed to run block. %s/%s\n", action, device);
+               break;
+       }
+
+       return ret;
+}
+
+static void
+device_free(struct device *device)
+{
+       struct blob_attr *data[__MOUNT_MAX];
+       char *target = NULL;
+       char *path = NULL, _path[64], *mp;
+
+       blobmsg_parse(mount_policy, __MOUNT_MAX, data,
+                     blob_data(device->msg), blob_len(device->msg));
+
+       if (data[MOUNT_AUTOFS]) {
+               target = device->target;
+               snprintf(_path, sizeof(_path), "/tmp/run/blockd/%s",
+                        blobmsg_get_string(data[MOUNT_DEVICE]));
+               path = _path;
+       } else {
+               path = target = device->target;
+       }
+
+       mp = _find_mount_point(device->name);
+       if (path && mp)
+               if (umount2(path, MNT_DETACH))
+                       ULOG_ERR("failed to unmount %s\n", path);
+       free(mp);
+
+       if (!target)
+               return;
+
+       if (data[MOUNT_AUTOFS])
+               unlink(target);
+       else
+               rmdir(target);
+}
+
+static void
+device_add(struct device *device)
+{
+       struct blob_attr *data[__MOUNT_MAX];
+       char path[64];
+
+       blobmsg_parse(mount_policy, __MOUNT_MAX, data,
+                     blob_data(device->msg), blob_len(device->msg));
+
+       if (!data[MOUNT_AUTOFS])
+               return;
+
+       snprintf(path, sizeof(path), "/tmp/run/blockd/%s",
+                blobmsg_get_string(data[MOUNT_DEVICE]));
+       if (symlink(path, device->target))
+               ULOG_ERR("failed to symlink %s->%s\n", device->target, path);
+}
+
+static int
+device_move(struct device *device_o, struct device *device_n)
+{
+       char path[64];
+
+       if (device_o->autofs != device_n->autofs)
+               return -1;
+
+       if (device_o->anon || device_n->anon)
+               return -1;
+
+       if (device_o->autofs) {
+               unlink(device_o->target);
+               snprintf(path, sizeof(path), "/tmp/run/blockd/%s", device_n->name);
+               if (symlink(path, device_n->target))
+                       ULOG_ERR("failed to symlink %s->%s\n", device_n->target, path);
+       } else {
+               mkdir(device_n->target, 0755);
+               if (mount(device_o->target, device_n->target, NULL, MS_MOVE, NULL))
+                       rmdir(device_n->target);
+               else
+                       rmdir(device_o->target);
+       }
+
+       return 0;
+}
+
+static void
+devices_update_cb(struct vlist_tree *tree, struct vlist_node *node_new,
+                 struct vlist_node *node_old)
+{
+       struct device *device_o = NULL, *device_n = NULL;
+
+       if (node_old)
+               device_o = container_of(node_old, struct device, node);
+
+       if (node_new)
+               device_n = container_of(node_new, struct device, node);
+
+       if (device_o && device_n) {
+               if (device_move(device_o, device_n)) {
+                       device_free(device_o);
+                       device_add(device_n);
+                       if (!device_n->autofs)
+                               block("mount", NULL, NULL);
+               }
+       } else if (device_n) {
+               device_add(device_n);
+       } else {
+               device_free(device_o);
+       }
+
+       if (device_o)
+               free(device_o);
+}
+
+VLIST_TREE(devices, avl_strcmp, devices_update_cb, false, false);
+
+static int
+block_hotplug(struct ubus_context *ctx, struct ubus_object *obj,
+             struct ubus_request_data *req, const char *method,
+             struct blob_attr *msg)
+{
+       struct blob_attr *data[__MOUNT_MAX];
+       struct device *device;
+       struct blob_attr *_msg;
+       char *devname, *_name;
+       char *target = NULL, *__target;
+       char _target[32];
+
+       blobmsg_parse(mount_policy, __MOUNT_MAX, data, blob_data(msg), blob_len(msg));
+
+       if (!data[MOUNT_DEVICE])
+               return UBUS_STATUS_INVALID_ARGUMENT;
+
+       devname = blobmsg_get_string(data[MOUNT_DEVICE]);
+
+       if (data[MOUNT_TARGET]) {
+               target = blobmsg_get_string(data[MOUNT_TARGET]);
+       } else {
+               snprintf(_target, sizeof(_target), "/mnt/%s",
+                        blobmsg_get_string(data[MOUNT_DEVICE]));
+               target = _target;
+       }
+
+       if (data[MOUNT_REMOVE])
+               device = vlist_find(&devices, devname, device, node);
+       else
+               device = calloc_a(sizeof(*device), &_msg, blob_raw_len(msg),
+                                 &_name, strlen(devname) + 1, &__target, strlen(target) + 1);
+
+       if (!device)
+               return UBUS_STATUS_UNKNOWN_ERROR;
+
+       vlist_update(&devices);
+       if (data[MOUNT_REMOVE]) {
+               vlist_delete(&devices, &device->node);
+       } else {
+               if (data[MOUNT_AUTOFS])
+                       device->autofs = blobmsg_get_u32(data[MOUNT_AUTOFS]);
+               else
+                       device->autofs = 0;
+               if (data[MOUNT_ANON])
+                       device->anon = blobmsg_get_u32(data[MOUNT_ANON]);
+               else
+                       device->anon = 0;
+               device->msg = _msg;
+               memcpy(_msg, msg, blob_raw_len(msg));
+               device->name = _name;
+               strcpy(_name, devname);
+               device->target = __target;
+               strcpy(__target, target);
+               vlist_add(&devices, &device->node, blobmsg_get_string(data[MOUNT_DEVICE]));
+       }
+       vlist_flush(&devices);
+
+       return 0;
+}
+
+static int
+block_info(struct ubus_context *ctx, struct ubus_object *obj,
+          struct ubus_request_data *req, const char *method,
+          struct blob_attr *msg)
+{
+       struct device *device;
+       void *a;
+
+       blob_buf_init(&bb, 0);
+       a = blobmsg_open_array(&bb, "devices");
+       vlist_for_each_element(&devices, device, node) {
+               void *t = blobmsg_open_table(&bb, "");
+               struct blob_attr *v;
+               char *mp;
+               int rem;
+
+               blob_for_each_attr(v, device->msg, rem)
+                       blobmsg_add_blob(&bb, v);
+
+               mp = _find_mount_point(device->name);
+               if (mp) {
+                       blobmsg_add_string(&bb, "mount", mp);
+                       free(mp);
+               }
+               blobmsg_close_table(&bb, t);
+       }
+       blobmsg_close_array(&bb, a);
+       ubus_send_reply(ctx, req, bb.head);
+
+       return 0;
+}
+
+static const struct ubus_method block_methods[] = {
+       UBUS_METHOD("hotplug", block_hotplug, mount_policy),
+       UBUS_METHOD_NOARG("info", block_info),
+};
+
+static struct ubus_object_type block_object_type =
+       UBUS_OBJECT_TYPE("block", block_methods);
+
+static struct ubus_object block_object = {
+       .name = "block",
+       .type = &block_object_type,
+       .methods = block_methods,
+       .n_methods = ARRAY_SIZE(block_methods),
+};
+
+static void
+ubus_connect_handler(struct ubus_context *ctx)
+{
+       int ret;
+
+       ret = ubus_add_object(ctx, &block_object);
+       if (ret)
+               fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
+}
+
+static int autofs_umount(void)
+{
+       umount2(AUTOFS_MOUNT_PATH, MNT_DETACH);
+       return 0;
+}
+
+static void autofs_read_handler(struct uloop_fd *u, unsigned int events)
+{
+       union autofs_v5_packet_union pktu;
+       const struct autofs_v5_packet *pkt;
+       int cmd = AUTOFS_IOC_READY;
+       struct stat st;
+
+       while (read(u->fd, &pktu, sizeof(pktu)) == -1) {
+               if (errno != EINTR)
+                       return;
+               continue;
+       }
+
+       if (pktu.hdr.type != autofs_ptype_missing_indirect) {
+               ULOG_ERR("unknown packet type %d\n", pktu.hdr.type);
+               return;
+       }
+
+       pkt = &pktu.missing_indirect;
+        ULOG_ERR("kernel is requesting a mount -> %s\n", pkt->name);
+       if (lstat(pkt->name, &st) == -1)
+               if (block("autofs", "add", (char *)pkt->name))
+                       cmd = AUTOFS_IOC_FAIL;
+
+       if (ioctl(fd_autofs_write, cmd, pkt->wait_queue_token) < 0)
+               ULOG_ERR("failed to report back to kernel\n");
+}
+
+static void autofs_expire(struct uloop_timeout *t)
+{
+       struct autofs_packet_expire pkt;
+
+       while (ioctl(fd_autofs_write, AUTOFS_IOC_EXPIRE, &pkt) == 0)
+               block("autofs", "remove", pkt.name);
+
+       uloop_timeout_set(t, AUTOFS_EXPIRE_TIMER);
+}
+
+struct uloop_timeout autofs_expire_timer = {
+       .cb = autofs_expire,
+};
+
+static int autofs_mount(void)
+{
+       int autofs_timeout = AUTOFS_TIMEOUT;
+       int kproto_version;
+       int pipefd[2];
+       char source[64];
+       char opts[64];
+
+       if (pipe(pipefd) < 0) {
+               ULOG_ERR("failed to get kernel pipe\n");
+               return -1;
+       }
+
+       snprintf(source, sizeof(source), "mountd(pid%u)", getpid());
+       snprintf(opts, sizeof(opts), "fd=%d,pgrp=%u,minproto=5,maxproto=5", pipefd[1], (unsigned) getpgrp());
+       mkdir(AUTOFS_MOUNT_PATH, 0555);
+       if (mount(source, AUTOFS_MOUNT_PATH, "autofs", 0, opts)) {
+               ULOG_ERR("unable to mount autofs on %s\n", AUTOFS_MOUNT_PATH);
+               close(pipefd[0]);
+               close(pipefd[1]);
+               return -1;
+       }
+       close(pipefd[1]);
+       fd_autofs_read.fd = pipefd[0];
+       fd_autofs_read.cb = autofs_read_handler;
+       uloop_fd_add(&fd_autofs_read, ULOOP_READ);
+
+       fd_autofs_write = open(AUTOFS_MOUNT_PATH, O_RDONLY);
+       if(fd_autofs_write < 0) {
+               autofs_umount();
+               ULOG_ERR("failed to open direcory\n");
+               return -1;
+       }
+
+       ioctl(fd_autofs_write, AUTOFS_IOC_PROTOVER, &kproto_version);
+       if (kproto_version != 5) {
+               ULOG_ERR("only kernel protocol version 5 is tested. You have %d.\n",
+                       kproto_version);
+               exit(1);
+       }
+       if (ioctl(fd_autofs_write, AUTOFS_IOC_SETTIMEOUT, &autofs_timeout))
+               ULOG_ERR("failed to set autofs timeout\n");
+
+       uloop_timeout_set(&autofs_expire_timer, AUTOFS_EXPIRE_TIMER);
+
+        fcntl(fd_autofs_write, F_SETFD, fcntl(fd_autofs_write, F_GETFD) | FD_CLOEXEC);
+        fcntl(fd_autofs_read.fd, F_SETFD, fcntl(fd_autofs_read.fd, F_GETFD) | FD_CLOEXEC);
+
+       return 0;
+}
+
+static void blockd_startup(struct uloop_timeout *t)
+{
+       block("autofs", "start", NULL);
+}
+
+struct uloop_timeout startup = {
+       .cb = blockd_startup,
+};
+
+int main(int argc, char **argv)
+{
+       ulog_open(ULOG_SYSLOG | ULOG_STDIO, LOG_DAEMON, "blockd");
+       uloop_init();
+
+       autofs_mount();
+
+       conn.cb = ubus_connect_handler;
+       ubus_auto_connect(&conn);
+
+       uloop_timeout_set(&startup, 1000);
+
+       uloop_run();
+       uloop_done();
+
+       autofs_umount();
+
+       vlist_flush_all(&devices);
+
+       return 0;
+}