-#include <sys/types.h>
+#define _GNU_SOURCE
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/wait.h>
#include <linux/auto_fs4.h>
#include <libubox/uloop.h>
+#include <libubox/utils.h>
#include <libubox/vlist.h>
#include <libubox/ulog.h>
#include <libubox/avl-cmp.h>
#define AUTOFS_TIMEOUT 30
#define AUTOFS_EXPIRE_TIMER (5 * 1000)
+struct hotplug_context {
+ struct uloop_process process;
+ void *priv;
+};
+
struct device {
struct vlist_node node;
struct blob_attr *msg;
[MOUNT_REMOVE] = { .name = "remove", .type = BLOBMSG_TYPE_INT32 },
};
+enum {
+ INFO_DEVICE,
+ __INFO_MAX
+};
+
+static const struct blobmsg_policy info_policy[__INFO_MAX] = {
+ [INFO_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING },
+};
+
static char*
_find_mount_point(char *device)
{
- char dev[32] = { 0 };
+ char *dev, *mp;
+
+ if (asprintf(&dev, "/dev/%s", device) == -1)
+ exit(ENOMEM);
- snprintf(dev, sizeof(dev), "/dev/%s", device);
+ mp = find_mount_point(dev, 0);
+ free(dev);
- return find_mount_point(dev, 0);
+ return mp;
}
static int
-block(char *cmd, char *action, char *device)
+block(char *cmd, char *action, char *device, int sync, struct uloop_process *process)
{
pid_t pid = fork();
- int ret = -1;
+ int ret = sync;
int status;
char *argv[5] = { 0 };
int a = 0;
break;
case 0:
+ uloop_end();
+
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);
+ exit(EXIT_FAILURE);
default:
- waitpid(pid, &status, 0);
- ret = WEXITSTATUS(status);
- if (ret)
- ULOG_ERR("failed to run block. %s/%s\n", action, device);
+ if (!sync && process) {
+ process->pid = pid;
+ uloop_process_add(process);
+ } else if (sync) {
+ 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)
+static int send_block_notification(struct ubus_context *ctx, const char *action,
+ const char *devname, const char *target);
+static int hotplug_call_mount(struct ubus_context *ctx, const char *action,
+ const char *devname, uloop_process_handler cb, void *priv)
{
- struct blob_attr *data[__MOUNT_MAX];
- char *target = NULL;
- char *path = NULL, _path[64], *mp;
+ char * const argv[] = { "hotplug-call", "mount", NULL };
+ struct hotplug_context *c = NULL;
+ pid_t pid;
+ int err;
+
+ if (cb) {
+ c = calloc(1, sizeof(*c));
+ if (!c)
+ return -ENOMEM;
+ }
- blobmsg_parse(mount_policy, __MOUNT_MAX, data,
- blob_data(device->msg), blob_len(device->msg));
+ pid = fork();
+ switch (pid) {
+ case -1:
+ if (c)
+ free(c);
- 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;
+ err = -errno;
+ ULOG_ERR("fork() failed\n");
+ return err;
+ case 0:
+ uloop_end();
+
+ setenv("ACTION", action, 1);
+ setenv("DEVICE", devname, 1);
+
+ execv("/sbin/hotplug-call", argv);
+ exit(-1);
+ break;
+ default:
+ if (c) {
+ c->process.pid = pid;
+ c->process.cb = cb;
+ c->priv = priv;
+ uloop_process_add(&c->process);
+ }
+ break;
}
+ return 0;
+}
+
+static void device_mount_remove_hotplug_cb(struct uloop_process *p, int stat)
+{
+ struct hotplug_context *hctx = container_of(p, struct hotplug_context, process);
+ struct device *device = hctx->priv;
+ char *mp;
+
+ if (device->target)
+ unlink(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 (mp) {
+ block("autofs", "remove", device->name, 0, NULL);
+ free(mp);
+ }
- if (!target)
- return;
+ free(device);
+ free(hctx);
+}
- if (data[MOUNT_AUTOFS])
- unlink(target);
- else
- rmdir(target);
+static void device_mount_remove(struct ubus_context *ctx, struct device *device)
+{
+ static const char *action = "remove";
+
+ hotplug_call_mount(ctx, action, device->name,
+ device_mount_remove_hotplug_cb, device);
+
+ send_block_notification(ctx, action, device->name, device->target);
}
-static void
-device_add(struct device *device)
+static void device_mount_add(struct ubus_context *ctx, struct device *device)
{
- struct blob_attr *data[__MOUNT_MAX];
- char path[64];
+ struct stat st;
+ char *path, *tmp;
- blobmsg_parse(mount_policy, __MOUNT_MAX, data,
- blob_data(device->msg), blob_len(device->msg));
+ if (asprintf(&path, "/tmp/run/blockd/%s", device->name) == -1)
+ exit(ENOMEM);
- if (!data[MOUNT_AUTOFS])
- return;
+ if (!lstat(device->target, &st)) {
+ if (S_ISLNK(st.st_mode))
+ unlink(device->target);
+ else if (S_ISDIR(st.st_mode))
+ rmdir(device->target);
+ }
+
+ tmp = strrchr(device->target, '/');
+ if (tmp && tmp != device->target && tmp != &device->target[strlen(path)-1]) {
+ *tmp = '\0';
+ mkdir_p(device->target, 0755);
+ *tmp = '/';
+ }
- 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);
+ if (symlink(path, device->target)) {
+ ULOG_ERR("failed to symlink %s->%s (%d) - %m\n", device->target, path, errno);
+ } else {
+ static const char *action = "add";
+ hotplug_call_mount(ctx, action, device->name, NULL, NULL);
+ send_block_notification(ctx, action, device->name, device->target);
+ }
+ free(path);
}
static int
device_move(struct device *device_o, struct device *device_n)
{
- char path[64];
+ char *path;
if (device_o->autofs != device_n->autofs)
return -1;
if (device_o->autofs) {
unlink(device_o->target);
- snprintf(path, sizeof(path), "/tmp/run/blockd/%s", device_n->name);
+ if (asprintf(&path, "/tmp/run/blockd/%s", device_n->name) == -1)
+ exit(ENOMEM);
+
if (symlink(path, device_n->target))
- ULOG_ERR("failed to symlink %s->%s\n", device_n->target, path);
+ ULOG_ERR("failed to symlink %s->%s (%d) - %m\n", device_n->target, path, errno);
+
+ free(path);
} else {
mkdir(device_n->target, 0755);
if (mount(device_o->target, device_n->target, NULL, MS_MOVE, NULL))
return 0;
}
-static void
-devices_update_cb(struct vlist_tree *tree, struct vlist_node *node_new,
- struct vlist_node *node_old)
+static void vlist_nop_update(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);
+VLIST_TREE(devices, avl_strcmp, vlist_nop_update, false, false);
static int
block_hotplug(struct ubus_context *ctx, struct ubus_object *obj,
struct blob_attr *_msg;
char *devname, *_name;
char *target = NULL, *__target;
- char _target[32];
+ char *_target = NULL;
blobmsg_parse(mount_policy, __MOUNT_MAX, data, blob_data(msg), blob_len(msg));
if (data[MOUNT_TARGET]) {
target = blobmsg_get_string(data[MOUNT_TARGET]);
} else {
- snprintf(_target, sizeof(_target), "/mnt/%s",
- blobmsg_get_string(data[MOUNT_DEVICE]));
+ if (asprintf(&_target, "/mnt/%s",
+ blobmsg_get_string(data[MOUNT_DEVICE])) == -1)
+ exit(ENOMEM);
+
target = _target;
}
device = calloc_a(sizeof(*device), &_msg, blob_raw_len(msg),
&_name, strlen(devname) + 1, &__target, strlen(target) + 1);
- if (!device)
+ if (!device) {
+ if (_target)
+ free(_target);
+
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]);
+
+ if (device->autofs)
+ device_mount_remove(ctx, device);
else
- device->anon = 0;
+ free(device);
+
+ if (_target)
+ free(_target);
+ } else {
+ struct device *old = vlist_find(&devices, devname, device, node);
+
+ device->autofs = data[MOUNT_AUTOFS] ? blobmsg_get_u32(data[MOUNT_AUTOFS]) : 0;
+ device->anon = data[MOUNT_ANON] ? blobmsg_get_u32(data[MOUNT_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]));
+ if (_target)
+ free(_target);
+
+ vlist_add(&devices, &device->node, device->name);
+
+ if (old && device_move(old, device)) {
+ device_mount_remove(ctx, old);
+ device_mount_add(ctx, device);
+ if (!device->autofs)
+ block("mount", NULL, NULL, 0, NULL);
+ } else if (device->autofs) {
+ device_mount_add(ctx, device);
+ }
}
- vlist_flush(&devices);
return 0;
}
+static int blockd_mount(struct ubus_context *ctx, struct ubus_object *obj,
+ struct ubus_request_data *req, const char *method,
+ struct blob_attr *msg)
+{
+ static const char *action = "add";
+ struct blob_attr *data[__MOUNT_MAX];
+ struct device *device;
+ char *devname;
+
+ 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]);
+
+ device = vlist_find(&devices, devname, device, node);
+ if (!device)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ hotplug_call_mount(ctx, action, device->name, NULL, NULL);
+ send_block_notification(ctx, action, device->name, device->target);
+
+ return 0;
+}
+
+struct blockd_umount_context {
+ struct ubus_context *ctx;
+ struct ubus_request_data req;
+};
+
+static void blockd_umount_hotplug_cb(struct uloop_process *p, int stat)
+{
+ struct hotplug_context *hctx = container_of(p, struct hotplug_context, process);
+ struct blockd_umount_context *c = hctx->priv;
+
+ ubus_complete_deferred_request(c->ctx, &c->req, 0);
+
+ free(c);
+ free(hctx);
+}
+
+static int blockd_umount(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 blockd_umount_context *c;
+ static const char *action = "remove";
+ char *devname;
+ static char oldtarget[PATH_MAX];
+ struct device *device;
+ int err;
+
+ 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]);
+ device = vlist_find(&devices, devname, device, node);
+ if (device) {
+ strncpy(oldtarget, device->target, sizeof(oldtarget)-1);
+ oldtarget[PATH_MAX - 1] = '\0';
+ }
+
+ c = calloc(1, sizeof(*c));
+ if (!c)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ c->ctx = ctx;
+ ubus_defer_request(ctx, req, &c->req);
+
+ err = hotplug_call_mount(ctx, action, devname, blockd_umount_hotplug_cb, c);
+ if (err) {
+ free(c);
+ return UBUS_STATUS_UNKNOWN_ERROR;
+ }
+
+ send_block_notification(ctx, action, devname, oldtarget);
+
+ return 0;
+}
+
+static void block_info_dump(struct blob_buf *b, struct device *device)
+{
+ struct blob_attr *v;
+ char *mp;
+ int rem;
+
+ blob_for_each_attr(v, device->msg, rem)
+ blobmsg_add_blob(b, v);
+
+ mp = _find_mount_point(device->name);
+ if (mp) {
+ blobmsg_add_string(b, "mount", mp);
+ free(mp);
+ } else if (device->autofs && device->target) {
+ blobmsg_add_string(b, "mount", device->target);
+ }
+}
+
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;
+ struct blob_attr *data[__INFO_MAX];
+ struct device *device = NULL;
+
+ blobmsg_parse(info_policy, __INFO_MAX, data, blob_data(msg), blob_len(msg));
+
+ if (data[INFO_DEVICE]) {
+ device = vlist_find(&devices, blobmsg_get_string(data[INFO_DEVICE]), device, node);
+ if (!device)
+ return UBUS_STATUS_INVALID_ARGUMENT;
+ }
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);
+ if (device) {
+ block_info_dump(&bb, device);
+ } else {
+ void *a;
+
+ a = blobmsg_open_array(&bb, "devices");
+ vlist_for_each_element(&devices, device, node) {
+ void *t;
+
+ t = blobmsg_open_table(&bb, "");
+ block_info_dump(&bb, device);
+ blobmsg_close_table(&bb, t);
}
- blobmsg_close_table(&bb, t);
+ blobmsg_close_array(&bb, a);
}
- 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),
+ UBUS_METHOD("mount", blockd_mount, mount_policy),
+ UBUS_METHOD("umount", blockd_umount, mount_policy),
+ UBUS_METHOD("info", block_info, info_policy),
};
static struct ubus_object_type block_object_type =
.n_methods = ARRAY_SIZE(block_methods),
};
+/* send ubus event for successful mounts, useful for procd triggers */
+static int send_block_notification(struct ubus_context *ctx, const char *action,
+ const char *devname, const char *target)
+{
+ struct blob_buf buf = { 0 };
+ char evname[16] = "mount.";
+ int err;
+
+ if (!ctx)
+ return -ENXIO;
+
+ strncat(evname, action, sizeof(evname) - 1);
+
+ blob_buf_init(&buf, 0);
+
+ if (devname)
+ blobmsg_add_string(&buf, "device", devname);
+
+ if (target)
+ blobmsg_add_string(&buf, "target", target);
+
+ err = ubus_notify(ctx, &block_object, evname, buf.head, -1);
+
+ return err;
+}
+
static void
ubus_connect_handler(struct ubus_context *ctx)
{
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))
+ if (block("autofs", "add", (char *)pkt->name, 1, NULL))
cmd = AUTOFS_IOC_FAIL;
if (ioctl(fd_autofs_write, cmd, pkt->wait_queue_token) < 0)
struct autofs_packet_expire pkt;
while (ioctl(fd_autofs_write, AUTOFS_IOC_EXPIRE, &pkt) == 0)
- block("autofs", "remove", pkt.name);
+ block("autofs", "remove", pkt.name, 1, NULL);
uloop_timeout_set(t, AUTOFS_EXPIRE_TIMER);
}
static int autofs_mount(void)
{
- int autofs_timeout = AUTOFS_TIMEOUT;
+ unsigned long autofs_timeout = AUTOFS_TIMEOUT;
int kproto_version;
int pipefd[2];
char source[64];
if (kproto_version != 5) {
ULOG_ERR("only kernel protocol version 5 is tested. You have %d.\n",
kproto_version);
- exit(1);
+ exit(EXIT_FAILURE);
}
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);
+ 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_cb(struct uloop_process *p, int stat)
+{
+ send_block_notification(&conn.ctx, "ready", NULL, NULL);
+}
+
+static struct uloop_process startup_process = {
+ .cb = blockd_startup_cb,
+};
+
static void blockd_startup(struct uloop_timeout *t)
{
- block("autofs", "start", NULL);
+ block("autofs", "start", NULL, 0, &startup_process);
}
struct uloop_timeout startup = {
int main(int argc, char **argv)
{
+ /* make sure blockd is in it's own POSIX process group */
+ setpgrp();
+
ulog_open(ULOG_SYSLOG | ULOG_STDIO, LOG_DAEMON, "blockd");
uloop_init();
projects / project / fstools.git / blobdiff