From 52a4ac3ede9b5bbc8015105d6fd5524c70e9bef5 Mon Sep 17 00:00:00 2001 From: Manuel Bentele Date: Fri, 12 Mar 2021 14:52:47 +0100 Subject: [KERNEL] Refactor code to satisfy Linux kernel code style --- src/kernel/blk.c | 211 +++++++--------- src/kernel/blk.h | 1 + src/kernel/dnbd3_main.c | 42 ++-- src/kernel/dnbd3_main.h | 24 +- src/kernel/net.c | 645 ++++++++++++++++++++++-------------------------- src/kernel/net.h | 14 +- src/kernel/sysfs.c | 143 ++++++----- src/kernel/sysfs.h | 16 +- src/kernel/utils.c | 21 +- src/kernel/utils.h | 1 + src/shared/serialize.c | 38 ++- 11 files changed, 535 insertions(+), 621 deletions(-) diff --git a/src/kernel/blk.c b/src/kernel/blk.c index 7315ccb..63a2f8c 100644 --- a/src/kernel/blk.c +++ b/src/kernel/blk.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 /* * This file is part of the Distributed Network Block Device 3 * @@ -26,28 +27,25 @@ #include -#define dnbd3_req_read(req) \ - req_op(req) == REQ_OP_READ -#define dnbd3_req_fs(req) \ - dnbd3_req_read(req) || req_op(req) == REQ_OP_WRITE -#define dnbd3_req_special(req) \ - blk_rq_is_private(req) +#define dnbd3_req_read(req) (req_op(req) == REQ_OP_READ) +#define dnbd3_req_fs(req) (dnbd3_req_read(req) || req_op(req) == REQ_OP_WRITE) +#define dnbd3_req_special(req) blk_rq_is_private(req) static int dnbd3_close_device(dnbd3_device_t *dev) { int result; - if (dev->imgname) { + + if (dev->imgname) dev_info(dnbd3_device_to_dev(dev), "closing down device.\n"); - } + /* quickly fail all requests */ dnbd3_blk_fail_all_requests(dev); dev->panic = 0; dev->discover = 0; result = dnbd3_net_disconnect(dev); - if (dev->imgname) { - kfree(dev->imgname); - dev->imgname = NULL; - } + kfree(dev->imgname); + dev->imgname = NULL; + /* new requests might have been queued up, */ /* but now that imgname is NULL no new ones can show up */ dnbd3_blk_fail_all_requests(dev); @@ -72,30 +70,25 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int int i = 0; u8 locked = 0; - if (arg != 0) - { + if (arg != 0) { msg = kmalloc(sizeof(*msg), GFP_KERNEL); - if (msg == NULL) return -ENOMEM; - if (copy_from_user((char *)msg, (char *)arg, 2) != 0 || msg->len != sizeof(*msg)) - { + if (msg == NULL) + return -ENOMEM; + if (copy_from_user((char *)msg, (char *)arg, 2) != 0 || msg->len != sizeof(*msg)) { result = -ENOEXEC; goto cleanup_return; } - if (copy_from_user((char *)msg, (char *)arg, sizeof(*msg)) != 0) - { + if (copy_from_user((char *)msg, (char *)arg, sizeof(*msg)) != 0) { result = -ENOENT; goto cleanup_return; } - if (msg->imgname != NULL && msg->imgnamelen > 0) - { + if (msg->imgname != NULL && msg->imgnamelen > 0) { imgname = kmalloc(msg->imgnamelen + 1, GFP_KERNEL); - if (imgname == NULL) - { + if (imgname == NULL) { result = -ENOMEM; goto cleanup_return; } - if (copy_from_user(imgname, msg->imgname, msg->imgnamelen) != 0) - { + if (copy_from_user(imgname, msg->imgname, msg->imgnamelen) != 0) { result = -ENOENT; goto cleanup_return; } @@ -103,30 +96,20 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int } } - - switch (cmd) - { + switch (cmd) { case IOCTL_OPEN: - if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) - { + if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) { result = -EBUSY; break; } locked = 1; - if (dev->imgname != NULL) - { + if (dev->imgname != NULL) { result = -EBUSY; - } - else if (imgname == NULL) - { + } else if (imgname == NULL) { result = -EINVAL; - } - else if (msg == NULL) - { + } else if (msg == NULL) { result = -EINVAL; - } - else - { + } else { if (sizeof(msg->hosts[0]) != sizeof(dev->cur_server.host)) dev_warn(dnbd3_device_to_dev(dev), "odd size bug triggered in IOCTL\n"); @@ -141,9 +124,8 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int dev->use_server_provided_alts = msg->use_server_provided_alts; dev_info(dnbd3_device_to_dev(dev), "opening device.\n"); - if (blk_queue->backing_dev_info != NULL) { + if (blk_queue->backing_dev_info != NULL) blk_queue->backing_dev_info->ra_pages = (msg->read_ahead_kb * 1024) / PAGE_SIZE; - } /* add specified servers to alt server list */ for (i = 0; i < msg->hosts_num; i++) { @@ -153,18 +135,26 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int dev->alt_servers[i].failures = 0; if (dev->alt_servers[i].host.type == HOST_IP4) - dev_dbg(dnbd3_device_to_dev(dev), "adding server %pI4\n", dev->alt_servers[i].host.addr); + dev_dbg(dnbd3_device_to_dev(dev), "adding server %pI4\n", + dev->alt_servers[i].host.addr); else - dev_dbg(dnbd3_device_to_dev(dev), "adding server [%pI6]\n", dev->alt_servers[i].host.addr); + dev_dbg(dnbd3_device_to_dev(dev), "adding server [%pI6]\n", + dev->alt_servers[i].host.addr); } - /* probe added alt servers in specified order and choose first working server as initial server */ + /* + * probe added alt servers in specified order and + * choose first working server as initial server + */ for (i = 0; i < msg->hosts_num; i++) { /* probe added alt server */ memcpy(&dev->cur_server, &dev->alt_servers[i], sizeof(dev->cur_server)); if (dnbd3_net_connect(dev) != 0) { - /* probing server failed, cleanup connection and proceed with next specified server */ + /* + * probing server failed, cleanup connection and + * proceed with next specified server + */ dnbd3_net_disconnect(dev); result = -ENOENT; } else { @@ -174,18 +164,17 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int } } - if (result >= 0) - { + if (result >= 0) { /* probing was successful */ if (dev->cur_server.host.type == HOST_IP4) - dev_dbg(dnbd3_device_to_dev(dev), "server %pI4 is initial server\n", dev->cur_server.host.addr); + dev_dbg(dnbd3_device_to_dev(dev), "server %pI4 is initial server\n", + dev->cur_server.host.addr); else - dev_dbg(dnbd3_device_to_dev(dev), "server [%pI6] is initial server\n", dev->cur_server.host.addr); + dev_dbg(dnbd3_device_to_dev(dev), "server [%pI6] is initial server\n", + dev->cur_server.host.addr); imgname = NULL; // Prevent kfree at the end - } - else - { + } else { /* probing failed */ dev->imgname = NULL; } @@ -193,8 +182,7 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int break; case IOCTL_CLOSE: - if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) - { + if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) { result = -EBUSY; break; } @@ -203,41 +191,33 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int break; case IOCTL_SWITCH: - if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) - { + if (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) { result = -EBUSY; break; } locked = 1; - if (dev->imgname == NULL) - { + if (dev->imgname == NULL) { result = -ENOENT; - } - else if (msg == NULL) - { + } else if (msg == NULL) { result = -EINVAL; - } - else - { + } else { /* convert host to dnbd3-server for switching */ memcpy(&server.host, &msg->hosts[0], sizeof(server.host)); server.failures = 0; alt_server = get_existing_server(&server, dev); - if (alt_server == NULL) - { + if (alt_server == NULL) { /* specified server is not known, so do not switch */ result = -EINVAL; - } - else - { + } else { /* specified server is known, so try to switch to it */ - if (!is_same_server(&dev->cur_server, alt_server)) - { + if (!is_same_server(&dev->cur_server, alt_server)) { if (alt_server->host.type == HOST_IP4) - dev_info(dnbd3_device_to_dev(dev), "manual server switch to %pI4\n", alt_server->host.addr); + dev_info(dnbd3_device_to_dev(dev), "manual server switch to %pI4\n", + alt_server->host.addr); else - dev_info(dnbd3_device_to_dev(dev), "manual server switch to [%pI6]\n", alt_server->host.addr); + dev_info(dnbd3_device_to_dev(dev), "manual server switch to [%pI6]\n", + alt_server->host.addr); /* save current working server */ /* lock device to get consistent copy of current working server */ spin_lock_irqsave(&dev->blk_lock, irqflags); @@ -250,23 +230,22 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int /* connect to new specified server (switching) */ memcpy(&dev->cur_server, alt_server, sizeof(dev->cur_server)); result = dnbd3_net_connect(dev); - if (result != 0) - { + if (result != 0) { /* reconnect with old server if switching has failed */ memcpy(&dev->cur_server, &old_server, sizeof(dev->cur_server)); if (dnbd3_net_connect(dev) != 0) { /* we couldn't reconnect to the old server */ /* device is dangling now and needs another SWITCH call */ - dev_warn(dnbd3_device_to_dev(dev), "switching failed and could not switch back to old server - dangling device\n"); + dev_warn( + dnbd3_device_to_dev(dev), + "switching failed and could not switch back to old server - dangling device\n"); result = -ECONNABORTED; } else { /* switching didn't work but we are back to the old server */ result = -EAGAIN; } } - } - else - { + } else { /* specified server is already working, so do not switch */ result = 0; } @@ -277,25 +256,19 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int case IOCTL_ADD_SRV: case IOCTL_REM_SRV: if (dev->imgname == NULL) - { result = -ENOENT; - } else if (msg == NULL) - { result = -EINVAL; - } /* protect access to 'new_servers_num' and 'new_servers' */ spin_lock_irqsave(&dev->blk_lock, irqflags); - if (dev->new_servers_num >= NUMBER_SERVERS) - { + if (dev->new_servers_num >= NUMBER_SERVERS) { result = -EAGAIN; - } - else - { + } else { /* add or remove specified server */ memcpy(&dev->new_servers[dev->new_servers_num].host, &msg->hosts[0], sizeof(msg->hosts[0])); - dev->new_servers[dev->new_servers_num].failures = (cmd == IOCTL_ADD_SRV ? 0 : 1); // 0 = ADD, 1 = REM + dev->new_servers[dev->new_servers_num].failures = + (cmd == IOCTL_ADD_SRV ? 0 : 1); // 0 = ADD, 1 = REM ++dev->new_servers_num; result = 0; } @@ -315,8 +288,8 @@ static int dnbd3_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int atomic_set(&dev->connection_lock, 0); cleanup_return: - if (msg) kfree(msg); - if (imgname) kfree(imgname); + kfree(msg); + kfree(imgname); return result; } @@ -370,7 +343,7 @@ int dnbd3_blk_add_device(dnbd3_device_t *dev, int minor) dev->imgname = NULL; dev->rid = 0; dev->update_available = 0; - memset(dev->alt_servers, 0, sizeof(dev->alt_servers[0])*NUMBER_SERVERS); + memset(dev->alt_servers, 0, sizeof(dev->alt_servers[0]) * NUMBER_SERVERS); dev->thread_send = NULL; dev->thread_receive = NULL; dev->thread_discover = NULL; @@ -393,8 +366,7 @@ int dnbd3_blk_add_device(dnbd3_device_t *dev, int minor) dev->tag_set.driver_data = dev; ret = blk_mq_alloc_tag_set(&dev->tag_set); - if (ret) - { + if (ret) { dev_err(dnbd3_device_to_dev(dev), "blk_mq_alloc_tag_set failed\n"); goto out; } @@ -420,8 +392,8 @@ int dnbd3_blk_add_device(dnbd3_device_t *dev, int minor) #undef ONE_MEG // set up disk - if (!(dev->disk = alloc_disk(1))) - { + dev->disk = alloc_disk(1); + if (!dev->disk) { dev_err(dnbd3_device_to_dev(dev), "alloc_disk failed\n"); ret = -ENOMEM; goto out_cleanup_queue; @@ -453,7 +425,7 @@ out: int dnbd3_blk_del_device(dnbd3_device_t *dev) { - dev_dbg(dnbd3_device_to_dev(dev), "dnbd3_blk_del_device called\n"); + dev_dbg(dnbd3_device_to_dev(dev), "%s called\n", __func__); while (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) schedule(); dnbd3_close_device(dev); @@ -472,57 +444,48 @@ void dnbd3_blk_fail_all_requests(dnbd3_device_t *dev) unsigned long flags; struct list_head local_copy; int dup; + INIT_LIST_HEAD(&local_copy); spin_lock_irqsave(&dev->blk_lock, flags); - while (!list_empty(&dev->request_queue_receive)) - { - list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_receive, queuelist) - { + while (!list_empty(&dev->request_queue_receive)) { + list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_receive, queuelist) { list_del_init(&blk_request->queuelist); dup = 0; - list_for_each_entry_safe(blk_request2, tmp_request2, &local_copy, queuelist) - { - if (blk_request == blk_request2) - { - dev_warn(dnbd3_device_to_dev(dev), "same request is in request_queue_receive multiple times\n"); + list_for_each_entry_safe(blk_request2, tmp_request2, &local_copy, queuelist) { + if (blk_request == blk_request2) { + dev_warn(dnbd3_device_to_dev(dev), + "same request is in request_queue_receive multiple times\n"); BUG(); dup = 1; break; } } - if (!dup) list_add(&blk_request->queuelist, &local_copy); + if (!dup) + list_add(&blk_request->queuelist, &local_copy); } } - while (!list_empty(&dev->request_queue_send)) - { - list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_send, queuelist) - { + while (!list_empty(&dev->request_queue_send)) { + list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_send, queuelist) { list_del_init(&blk_request->queuelist); dup = 0; - list_for_each_entry_safe(blk_request2, tmp_request2, &local_copy, queuelist) - { - if (blk_request == blk_request2) - { + list_for_each_entry_safe(blk_request2, tmp_request2, &local_copy, queuelist) { + if (blk_request == blk_request2) { dev_warn(dnbd3_device_to_dev(dev), "request is in both lists\n"); BUG(); dup = 1; break; } } - if (!dup) list_add(&blk_request->queuelist, &local_copy); + if (!dup) + list_add(&blk_request->queuelist, &local_copy); } } spin_unlock_irqrestore(&dev->blk_lock, flags); - list_for_each_entry_safe(blk_request, tmp_request, &local_copy, queuelist) - { + list_for_each_entry_safe(blk_request, tmp_request, &local_copy, queuelist) { list_del_init(&blk_request->queuelist); if (dnbd3_req_fs(blk_request)) - { blk_mq_end_request(blk_request, BLK_STS_IOERR); - } else if (dnbd3_req_special(blk_request)) - { kfree(blk_request); - } } } diff --git a/src/kernel/blk.h b/src/kernel/blk.h index 5f7f2db..45b4352 100644 --- a/src/kernel/blk.h +++ b/src/kernel/blk.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * This file is part of the Distributed Network Block Device 3 * diff --git a/src/kernel/dnbd3_main.c b/src/kernel/dnbd3_main.c index 133c579..6e5b4a7 100644 --- a/src/kernel/dnbd3_main.c +++ b/src/kernel/dnbd3_main.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 /* * This file is part of the Distributed Network Block Device 3 * @@ -34,27 +35,25 @@ struct device *dnbd3_device_to_dev(dnbd3_device_t *dev) return disk_to_dev(dev->disk); } -int is_same_server(const dnbd3_server_t * const a, const dnbd3_server_t * const b) +int is_same_server(const dnbd3_server_t *const a, const dnbd3_server_t *const b) { - return (a->host.type == b->host.type) && (a->host.port == b->host.port) - && (0 == memcmp(a->host.addr, b->host.addr, (a->host.type == HOST_IP4 ? 4 : 16))); + return (a->host.type == b->host.type) && (a->host.port == b->host.port) && + (0 == memcmp(a->host.addr, b->host.addr, (a->host.type == HOST_IP4 ? 4 : 16))); } -dnbd3_server_t *get_existing_server(const dnbd3_server_entry_t * const newserver, dnbd3_device_t * const dev) +dnbd3_server_t *get_existing_server(const dnbd3_server_entry_t *const newserver, dnbd3_device_t *const dev) { int i; - for (i = 0; i < NUMBER_SERVERS; ++i) - { - if ((newserver->host.type == dev->alt_servers[i].host.type) - && (newserver->host.port == dev->alt_servers[i].host.port) - && (0 - == memcmp(newserver->host.addr, dev->alt_servers[i].host.addr, (newserver->host.type == HOST_IP4 ? 4 : 16)))) - { + + for (i = 0; i < NUMBER_SERVERS; ++i) { + if ((newserver->host.type == dev->alt_servers[i].host.type) && + (newserver->host.port == dev->alt_servers[i].host.port) && + (0 == memcmp(newserver->host.addr, dev->alt_servers[i].host.addr, + (newserver->host.type == HOST_IP4 ? 4 : 16)))) { return &dev->alt_servers[i]; - break; } } - return NULL ; + return NULL; } static int __init dnbd3_init(void) @@ -66,8 +65,8 @@ static int __init dnbd3_init(void) return -ENOMEM; // initialize block device - if ((major = register_blkdev(0, "dnbd3")) == 0) - { + major = register_blkdev(0, "dnbd3"); + if (major == 0) { pr_err("register_blkdev failed\n"); return -EIO; } @@ -76,12 +75,13 @@ static int __init dnbd3_init(void) pr_debug("machine type %s\n", DNBD3_ENDIAN_MODE); // add MAX_NUMBER_DEVICES devices - for (i = 0; i < max_devs; i++) - { - if (dnbd3_blk_add_device(&dnbd3_devices[i], i) != 0) - { + for (i = 0; i < max_devs; i++) { + if (dnbd3_blk_add_device(&dnbd3_devices[i], i) != 0) { pr_err("dnbd3_blk_add_device failed\n"); - return -EIO; // TODO: delete all devices added so far. it could happen that it's not the first one that fails. also call unregister_blkdev and free memory + // TODO: delete all devices added so far. + // It could happen that it's not the first one that fails. + // Also call unregister_blkdev and free memory. + return -EIO; } } @@ -96,9 +96,7 @@ static void __exit dnbd3_exit(void) pr_debug("exiting kernel module...\n"); for (i = 0; i < max_devs; i++) - { dnbd3_blk_del_device(&dnbd3_devices[i]); - } unregister_blkdev(major, "dnbd3"); kfree(dnbd3_devices); diff --git a/src/kernel/dnbd3_main.h b/src/kernel/dnbd3_main.h index ec8c8cf..c5b0930 100644 --- a/src/kernel/dnbd3_main.h +++ b/src/kernel/dnbd3_main.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * This file is part of the Distributed Network Block Device 3 * @@ -34,16 +35,14 @@ extern int major; -typedef struct -{ +typedef struct { dnbd3_host_t host; - unsigned long rtts[4]; // Last four round trip time measurements in µs - uint16_t protocol_version; // dnbd3 protocol version of this server - uint8_t failures; // How many times the server was unreachable + unsigned long rtts[4]; // Last four round trip time measurements in µs + uint16_t protocol_version; // dnbd3 protocol version of this server + uint8_t failures; // How many times the server was unreachable } dnbd3_server_t; -typedef struct -{ +typedef struct { // block struct gendisk *disk; struct blk_mq_tag_set tag_set; @@ -60,7 +59,7 @@ typedef struct unsigned long cur_rtt; serialized_buffer_t payload_buffer; dnbd3_server_t alt_servers[NUMBER_SERVERS]; // array of alt servers - int new_servers_num; // number of new alt servers that are waiting to be copied to above array + int new_servers_num; // number of new alt servers that are waiting to be copied to above array dnbd3_server_entry_t new_servers[NUMBER_SERVERS]; // pending new alt servers uint8_t discover, panic, update_available, panic_count; atomic_t connection_lock; @@ -72,8 +71,8 @@ typedef struct struct socket *better_sock; // process - struct task_struct * thread_send; - struct task_struct * thread_receive; + struct task_struct *thread_send; + struct task_struct *thread_receive; struct task_struct *thread_discover; struct timer_list hb_timer; wait_queue_head_t process_queue_send; @@ -85,7 +84,8 @@ typedef struct extern inline struct device *dnbd3_device_to_dev(dnbd3_device_t *dev); -extern inline int is_same_server(const dnbd3_server_t * const a, const dnbd3_server_t * const b); -extern inline dnbd3_server_t *get_existing_server(const dnbd3_server_entry_t * const newserver, dnbd3_device_t * const dev); +extern inline int is_same_server(const dnbd3_server_t *const a, const dnbd3_server_t *const b); +extern inline dnbd3_server_t *get_existing_server(const dnbd3_server_entry_t *const newserver, + dnbd3_device_t *const dev); #endif /* DNBD_H_ */ diff --git a/src/kernel/net.c b/src/kernel/net.c index 70695d9..3f10add 100644 --- a/src/kernel/net.c +++ b/src/kernel/net.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 /* * This file is part of the Distributed Network Block Device 3 * @@ -29,36 +30,32 @@ #include #ifndef MIN -#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif #ifndef ktime_to_s #define ktime_to_s(kt) ktime_divns(kt, NSEC_PER_SEC) #endif -#if 1 // CONFIG_DEBUG_DRIVER -#define ASSERT(x) \ -do { \ - if (!(x)) { \ - printk(KERN_EMERG "assertion failed %s: %d: %s\n", \ - __FILE__, __LINE__, #x); \ - BUG(); \ - } \ -} while (0) -#else -#define ASSERT(x) do { } while (0) -#endif +#define ASSERT(x) \ + do { \ + if (!(x)) { \ + printk(KERN_EMERG "assertion failed %s: %d: %s\n", __FILE__, __LINE__, #x); \ + BUG(); \ + } \ + } while (0) -#define dnbd3_sock_create(af,type,proto,sock) sock_create_kern(&init_net, (af) == HOST_IP4 ? AF_INET : AF_INET6, type, proto, sock) +#define dnbd3_sock_create(af, type, proto, sock) \ + sock_create_kern(&init_net, (af) == HOST_IP4 ? AF_INET : AF_INET6, type, proto, sock) // cmd_flags and cmd_type are merged into cmd_flags now #if REQ_FLAG_BITS > 24 #error "Fix CMD bitshift" #endif // Pack into cmd_flags field by shifting CMD_* into unused bits of cmd_flags -#define dnbd3_cmd_to_priv(req, cmd) (req)->cmd_flags = REQ_OP_DRV_IN | ((cmd) << REQ_FLAG_BITS) -#define dnbd3_priv_to_cmd(req) ((req)->cmd_flags >> REQ_FLAG_BITS) -#define dnbd3_req_op(req) req_op(req) +#define dnbd3_cmd_to_priv(req, cmd) ((req)->cmd_flags = REQ_OP_DRV_IN | ((cmd) << REQ_FLAG_BITS)) +#define dnbd3_priv_to_cmd(req) ((req)->cmd_flags >> REQ_FLAG_BITS) +#define dnbd3_req_op(req) req_op(req) #define DNBD3_DEV_READ REQ_OP_READ #define DNBD3_REQ_OP_SPECIAL REQ_OP_DRV_IN @@ -66,43 +63,50 @@ do { \ * Some macros for easier debug output. * Server IP:port info will be printed. */ -#define __dnbd3_dev_dbg_host(dev, host, fmt, ...) do { \ - if ((host).type == HOST_IP4) { \ - dev_dbg(dnbd3_device_to_dev((dev)), "(%pI4:%d): " fmt, (host).addr, (int)ntohs((host).port), ##__VA_ARGS__); \ - } else { \ - dev_dbg(dnbd3_device_to_dev((dev)), "([%pI6]:%d): " fmt, (host).addr, (int)ntohs((host).port), ##__VA_ARGS__); \ - } \ -} while (0) - -#define __dnbd3_dev_err_host(dev, host, fmt, ...) do { \ - if ((host).type == HOST_IP4) { \ - dev_err(dnbd3_device_to_dev((dev)), "(%pI4:%d): " fmt, (host).addr, (int)ntohs((host).port), ##__VA_ARGS__); \ - } else { \ - dev_err(dnbd3_device_to_dev((dev)), "([%pI6]:%d): " fmt, (host).addr, (int)ntohs((host).port), ##__VA_ARGS__); \ - } \ -} while (0) - -#define dnbd3_dev_dbg_host_cur(dev, fmt, ...) __dnbd3_dev_dbg_host((dev), (dev)->cur_server.host, fmt, ##__VA_ARGS__) -#define dnbd3_dev_err_host_cur(dev, fmt, ...) __dnbd3_dev_err_host((dev), (dev)->cur_server.host, fmt, ##__VA_ARGS__) -#define dnbd3_dev_dbg_host_alt(dev, fmt, ...) __dnbd3_dev_dbg_host((dev), (dev)->alt_servers[i].host, fmt, ##__VA_ARGS__) -#define dnbd3_dev_err_host_alt(dev, fmt, ...) __dnbd3_dev_err_host((dev), (dev)->alt_servers[i].host, fmt, ##__VA_ARGS__) - -static struct socket* dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host); - -static inline dnbd3_server_t *get_free_alt_server(dnbd3_device_t * const dev) +#define __dnbd3_dev_dbg_host(dev, host, fmt, ...) \ + do { \ + if ((host).type == HOST_IP4) { \ + dev_dbg(dnbd3_device_to_dev((dev)), "(%pI4:%d): " fmt, (host).addr, (int)ntohs((host).port), \ + ##__VA_ARGS__); \ + } else { \ + dev_dbg(dnbd3_device_to_dev((dev)), "([%pI6]:%d): " fmt, (host).addr, (int)ntohs((host).port), \ + ##__VA_ARGS__); \ + } \ + } while (0) + +#define __dnbd3_dev_err_host(dev, host, fmt, ...) \ + do { \ + if ((host).type == HOST_IP4) { \ + dev_err(dnbd3_device_to_dev((dev)), "(%pI4:%d): " fmt, (host).addr, (int)ntohs((host).port), \ + ##__VA_ARGS__); \ + } else { \ + dev_err(dnbd3_device_to_dev((dev)), "([%pI6]:%d): " fmt, (host).addr, (int)ntohs((host).port), \ + ##__VA_ARGS__); \ + } \ + } while (0) + +#define dnbd3_dev_dbg_host_cur(dev, fmt, ...) __dnbd3_dev_dbg_host((dev), (dev)->cur_server.host, fmt, ##__VA_ARGS__) +#define dnbd3_dev_err_host_cur(dev, fmt, ...) __dnbd3_dev_err_host((dev), (dev)->cur_server.host, fmt, ##__VA_ARGS__) +#define dnbd3_dev_dbg_host_alt(dev, fmt, ...) \ + __dnbd3_dev_dbg_host((dev), (dev)->alt_servers[i].host, fmt, ##__VA_ARGS__) +#define dnbd3_dev_err_host_alt(dev, fmt, ...) \ + __dnbd3_dev_err_host((dev), (dev)->alt_servers[i].host, fmt, ##__VA_ARGS__) + +static struct socket *dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host); + +static inline dnbd3_server_t *get_free_alt_server(dnbd3_device_t *const dev) { int i; - for (i = 0; i < NUMBER_SERVERS; ++i) - { + + for (i = 0; i < NUMBER_SERVERS; ++i) { if (dev->alt_servers[i].host.type == 0) return &dev->alt_servers[i]; } - for (i = 0; i < NUMBER_SERVERS; ++i) - { + for (i = 0; i < NUMBER_SERVERS; ++i) { if (dev->alt_servers[i].failures > 10) return &dev->alt_servers[i]; } - return NULL ; + return NULL; } static void dnbd3_net_heartbeat(struct timer_list *arg) @@ -113,36 +117,29 @@ static void dnbd3_net_heartbeat(struct timer_list *arg) // Other intervals can be derived using dev->heartbeat_count. #define timeout_seconds(x) (dev->heartbeat_count % (x) == 0) - if (!dev->panic) - { - if (timeout_seconds(TIMER_INTERVAL_KEEPALIVE_PACKET)) - { - struct request *req = kmalloc(sizeof(struct request), GFP_ATOMIC ); + if (!dev->panic) { + if (timeout_seconds(TIMER_INTERVAL_KEEPALIVE_PACKET)) { + struct request *req = kmalloc(sizeof(struct request), GFP_ATOMIC); // send keepalive - if (req) - { + if (req) { unsigned long irqflags; + dnbd3_cmd_to_priv(req, CMD_KEEPALIVE); spin_lock_irqsave(&dev->blk_lock, irqflags); list_add_tail(&req->queuelist, &dev->request_queue_send); spin_unlock_irqrestore(&dev->blk_lock, irqflags); wake_up(&dev->process_queue_send); - } - else - { + } else { dev_err(dnbd3_device_to_dev(dev), "couldn't create keepalive request\n"); } } - if ((dev->heartbeat_count > STARTUP_MODE_DURATION && timeout_seconds(TIMER_INTERVAL_PROBE_NORMAL)) - || (dev->heartbeat_count <= STARTUP_MODE_DURATION && timeout_seconds(TIMER_INTERVAL_PROBE_STARTUP))) - { + if ((dev->heartbeat_count > STARTUP_MODE_DURATION && timeout_seconds(TIMER_INTERVAL_PROBE_NORMAL)) || + (dev->heartbeat_count <= STARTUP_MODE_DURATION && timeout_seconds(TIMER_INTERVAL_PROBE_STARTUP))) { // Normal discovery dev->discover = 1; wake_up(&dev->process_queue_discover); } - } - else if (timeout_seconds(TIMER_INTERVAL_PROBE_PANIC)) - { + } else if (timeout_seconds(TIMER_INTERVAL_PROBE_PANIC)) { // Panic discovery dev->discover = 1; wake_up(&dev->process_queue_discover); @@ -192,24 +189,20 @@ static int dnbd3_net_discover(void *data) buf = kmalloc(4096, GFP_KERNEL); if (!buf) - { - dev_err(dnbd3_device_to_dev(dev), "kmalloc failed for payload buf (discover)\n"); - return ENOMEM; - } + return -ENOMEM; + payload = (serialized_buffer_t *)buf; // Reuse this buffer to save kernel mem dnbd3_request.magic = dnbd3_packet_magic; - for (i = 0; i < NUMBER_SERVERS; ++i) { + for (i = 0; i < NUMBER_SERVERS; ++i) check_order[i] = i; - } - while (!kthread_should_stop()) - { + while (!kthread_should_stop()) { wait_event_interruptible(dev->process_queue_discover, - kthread_should_stop() || dev->discover || dev->thread_discover == NULL); + kthread_should_stop() || dev->discover || dev->thread_discover == NULL); - if (kthread_should_stop() || dev->imgname == NULL || dev->thread_discover == NULL ) + if (kthread_should_stop() || dev->imgname == NULL || dev->thread_discover == NULL) break; if (!dev->discover) @@ -221,22 +214,22 @@ static int dnbd3_net_discover(void *data) // Check if the list of alt servers needs to be updated and do so if necessary spin_lock_irqsave(&dev->blk_lock, irqflags); - if (dev->new_servers_num) - { - for (i = 0; i < dev->new_servers_num; ++i) - { - if (dev->new_servers[i].host.type != HOST_IP4 && dev->new_servers[i].host.type != HOST_IP6) // Invalid entry? + if (dev->new_servers_num) { + for (i = 0; i < dev->new_servers_num; ++i) { + if (dev->new_servers[i].host.type != HOST_IP4 && + dev->new_servers[i].host.type != HOST_IP6) // Invalid entry? continue; alt_server = get_existing_server(&dev->new_servers[i], dev); - if (alt_server != NULL ) // Server already known - { - if (dev->new_servers[i].failures == 1) - { + if (alt_server != NULL) { + // Server already known + if (dev->new_servers[i].failures == 1) { // REMOVE request if (alt_server->host.type == HOST_IP4) - dnbd3_dev_dbg_host_cur(dev, "removing alt server %pI4\n", alt_server->host.addr); + dnbd3_dev_dbg_host_cur(dev, "removing alt server %pI4\n", + alt_server->host.addr); else - dnbd3_dev_dbg_host_cur(dev, "removing alt server [%pI6]\n", alt_server->host.addr); + dnbd3_dev_dbg_host_cur(dev, "removing alt server [%pI6]\n", + alt_server->host.addr); alt_server->host.type = 0; continue; } @@ -247,15 +240,17 @@ static int dnbd3_net_discover(void *data) if (dev->new_servers[i].failures == 1) // REMOVE, but server is not in list anyways continue; alt_server = get_free_alt_server(dev); - if (alt_server == NULL ) // All NUMBER_SERVERS slots are taken, ignore entry + if (alt_server == NULL) // All NUMBER_SERVERS slots are taken, ignore entry continue; // Add new server entry alt_server->host = dev->new_servers[i].host; if (alt_server->host.type == HOST_IP4) - dnbd3_dev_dbg_host_cur(dev, "adding alt server %pI4\n", alt_server->host.addr); + dnbd3_dev_dbg_host_cur(dev, "adding alt server %pI4\n", alt_server->host.addr); else - dnbd3_dev_dbg_host_cur(dev, "adding alt server [%pI6]\n", alt_server->host.addr); - alt_server->rtts[0] = alt_server->rtts[1] = alt_server->rtts[2] = alt_server->rtts[3] = RTT_UNREACHABLE; + dnbd3_dev_dbg_host_cur(dev, "adding alt server [%pI6]\n", + alt_server->host.addr); + alt_server->rtts[0] = alt_server->rtts[1] = alt_server->rtts[2] = alt_server->rtts[3] = + RTT_UNREACHABLE; alt_server->protocol_version = 0; alt_server->failures = 0; } @@ -267,13 +262,10 @@ static int dnbd3_net_discover(void *data) best_rtt = 0xFFFFFFFul; if (dev->heartbeat_count < STARTUP_MODE_DURATION || dev->panic) - { isize = NUMBER_SERVERS; - } else - { isize = 3; - } + if (NUMBER_SERVERS > isize) { for (i = 0; i < isize; ++i) { j = ((ktime_to_s(start) >> i) ^ (ktime_to_us(start) >> j)) % NUMBER_SERVERS; @@ -285,21 +277,21 @@ static int dnbd3_net_discover(void *data) } } - for (j = 0; j < NUMBER_SERVERS; ++j) - { + for (j = 0; j < NUMBER_SERVERS; ++j) { i = check_order[j]; if (dev->alt_servers[i].host.type == 0) // Empty slot continue; - if (!dev->panic && dev->alt_servers[i].failures > 50 && (ktime_to_us(start) & 7) != 0) // If not in panic mode, skip server if it failed too many times + if (!dev->panic && dev->alt_servers[i].failures > 50 && + (ktime_to_us(start) & 7) != + 0) // If not in panic mode, skip server if it failed too many times continue; if (isize-- <= 0 && !is_same_server(&dev->cur_server, &dev->alt_servers[i])) continue; // Initialize socket and connect sock = dnbd3_connect(dev, &dev->alt_servers[i].host); - if (sock == NULL) - { - dnbd3_dev_dbg_host_alt(dev, "dnbd3_net_discover: Couldn't connect\n"); + if (sock == NULL) { + dnbd3_dev_dbg_host_alt(dev, "%s: Couldn't connect\n", __func__); goto error; } @@ -316,8 +308,7 @@ static int dnbd3_net_discover(void *data) dnbd3_request.size = iov[1].iov_len = serializer_get_written_length(payload); fixup_request(dnbd3_request); mlen = iov[1].iov_len + sizeof(dnbd3_request); - if (kernel_sendmsg(sock, &msg, iov, 2, mlen) != mlen) - { + if (kernel_sendmsg(sock, &msg, iov, 2, mlen) != mlen) { dnbd3_dev_err_host_alt(dev, "requesting image size failed\n"); goto error; } @@ -325,78 +316,79 @@ static int dnbd3_net_discover(void *data) // receive net reply iov[0].iov_base = &dnbd3_reply; iov[0].iov_len = sizeof(dnbd3_reply); - if (kernel_recvmsg(sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != sizeof(dnbd3_reply)) - { + if (kernel_recvmsg(sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != + sizeof(dnbd3_reply)) { dnbd3_dev_err_host_alt(dev, "receiving image size packet (header) failed (discover)\n"); goto error; } fixup_reply(dnbd3_reply); - if (dnbd3_reply.magic != dnbd3_packet_magic || dnbd3_reply.cmd != CMD_SELECT_IMAGE || dnbd3_reply.size < 4) - { - dnbd3_dev_err_host_alt(dev, "content of image size packet (header) mismatched (discover)\n"); + if (dnbd3_reply.magic != dnbd3_packet_magic || dnbd3_reply.cmd != CMD_SELECT_IMAGE || + dnbd3_reply.size < 4) { + dnbd3_dev_err_host_alt(dev, + "content of image size packet (header) mismatched (discover)\n"); goto error; } // receive data iov[0].iov_base = payload; iov[0].iov_len = dnbd3_reply.size; - if (kernel_recvmsg(sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != dnbd3_reply.size) - { - dnbd3_dev_err_host_alt(dev, "receiving image size packet (payload) failed (discover)\n"); + if (kernel_recvmsg(sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != dnbd3_reply.size) { + dnbd3_dev_err_host_alt(dev, + "receiving image size packet (payload) failed (discover)\n"); goto error; } serializer_reset_read(payload, dnbd3_reply.size); dev->alt_servers[i].protocol_version = serializer_get_uint16(payload); - if (dev->alt_servers[i].protocol_version < MIN_SUPPORTED_SERVER) - { - dnbd3_dev_err_host_alt(dev, "server version too old (client: %d, server: %d, min supported: %d)\n", - (int)PROTOCOL_VERSION, (int)dev->alt_servers[i].protocol_version, (int)MIN_SUPPORTED_SERVER); + if (dev->alt_servers[i].protocol_version < MIN_SUPPORTED_SERVER) { + dnbd3_dev_err_host_alt( + dev, "server version too old (client: %d, server: %d, min supported: %d)\n", + (int)PROTOCOL_VERSION, (int)dev->alt_servers[i].protocol_version, + (int)MIN_SUPPORTED_SERVER); goto error; } name = serializer_get_string(payload); - if (name == NULL ) - { + if (name == NULL) { dnbd3_dev_err_host_alt(dev, "server did not supply an image name (discover)\n"); goto error; } - if (strcmp(name, dev->imgname) != 0) - { - dnbd3_dev_err_host_alt(dev, "image name does not match requested one (client: '%s', server: '%s') (discover)\n", - dev->imgname, name); + if (strcmp(name, dev->imgname) != 0) { + dnbd3_dev_err_host_alt( + dev, + "image name does not match requested one (client: '%s', server: '%s') (discover)\n", + dev->imgname, name); goto error; } rid = serializer_get_uint16(payload); - if (rid != dev->rid) - { - dnbd3_dev_err_host_alt(dev, "server supplied wrong rid (client: '%d', server: '%d') (discover)\n", - (int)dev->rid, (int)rid); + if (rid != dev->rid) { + dnbd3_dev_err_host_alt( + dev, "server supplied wrong rid (client: '%d', server: '%d') (discover)\n", + (int)dev->rid, (int)rid); goto error; } filesize = serializer_get_uint64(payload); - if (filesize != dev->reported_size) - { - dnbd3_dev_err_host_alt(dev, "reported image size of %llu does not match expected value %llu (discover)\n", - (unsigned long long)filesize, (unsigned long long)dev->reported_size); + if (filesize != dev->reported_size) { + dnbd3_dev_err_host_alt( + dev, + "reported image size of %llu does not match expected value %llu (discover)\n", + (unsigned long long)filesize, (unsigned long long)dev->reported_size); goto error; } // panic mode, take first responding server - if (dev->panic) - { + if (dev->panic) { dnbd3_dev_dbg_host_alt(dev, "panic mode, changing server ...\n"); while (atomic_cmpxchg(&dev->connection_lock, 0, 1) != 0) - { schedule(); - } - if (dev->panic) // Re-check, a connect might have been in progress - { + + if (dev->panic) { + // Re-check, a connect might have been in progress dev->panic = 0; - if (best_sock != NULL ) + if (best_sock != NULL) sock_release(best_sock); dev->better_sock = sock; // Pass over socket to take a shortcut in *_connect(); @@ -425,8 +417,7 @@ static int dnbd3_net_discover(void *data) // start rtt measurement start = ktime_get_real(); - if (kernel_sendmsg(sock, &msg, iov, 1, sizeof(dnbd3_request)) <= 0) - { + if (kernel_sendmsg(sock, &msg, iov, 1, sizeof(dnbd3_request)) <= 0) { dnbd3_dev_err_host_alt(dev, "requesting test block failed (discover)\n"); goto error; } @@ -434,56 +425,52 @@ static int dnbd3_net_discover(void *data) // receive net reply iov[0].iov_base = &dnbd3_reply; iov[0].iov_len = sizeof(dnbd3_reply); - if (kernel_recvmsg(sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != sizeof(dnbd3_reply)) - { + if (kernel_recvmsg(sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != + sizeof(dnbd3_reply)) { dnbd3_dev_err_host_alt(dev, "receiving test block header packet failed (discover)\n"); goto error; } fixup_reply(dnbd3_reply); - if (dnbd3_reply.magic - != dnbd3_packet_magic|| dnbd3_reply.cmd != CMD_GET_BLOCK || dnbd3_reply.size != RTT_BLOCK_SIZE) - { - dnbd3_dev_err_host_alt(dev, "unexpected reply to block request: cmd=%d, size=%d (discover)\n", - (int)dnbd3_reply.cmd, (int)dnbd3_reply.size); + if (dnbd3_reply.magic != dnbd3_packet_magic || dnbd3_reply.cmd != CMD_GET_BLOCK || + dnbd3_reply.size != RTT_BLOCK_SIZE) { + dnbd3_dev_err_host_alt( + dev, "unexpected reply to block request: cmd=%d, size=%d (discover)\n", + (int)dnbd3_reply.cmd, (int)dnbd3_reply.size); goto error; } // receive data iov[0].iov_base = buf; iov[0].iov_len = RTT_BLOCK_SIZE; - if (kernel_recvmsg(sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != RTT_BLOCK_SIZE) - { + if (kernel_recvmsg(sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != RTT_BLOCK_SIZE) { dnbd3_dev_err_host_alt(dev, "receiving test block payload failed (discover)\n"); goto error; } end = ktime_get_real(); // end rtt measurement - dev->alt_servers[i].rtts[turn] = (unsigned long) ktime_us_delta(end, start); + dev->alt_servers[i].rtts[turn] = (unsigned long)ktime_us_delta(end, start); - rtt = (dev->alt_servers[i].rtts[0] + dev->alt_servers[i].rtts[1] + dev->alt_servers[i].rtts[2] - + dev->alt_servers[i].rtts[3]) / 4; + rtt = (dev->alt_servers[i].rtts[0] + dev->alt_servers[i].rtts[1] + dev->alt_servers[i].rtts[2] + + dev->alt_servers[i].rtts[3]) / + 4; - if (best_rtt > rtt) - { + if (best_rtt > rtt) { // This one is better, keep socket open in case we switch best_rtt = rtt; best_server = i; - if (best_sock != NULL ) + if (best_sock != NULL) sock_release(best_sock); best_sock = sock; sock = NULL; - } - else - { + } else { // Not better, discard connection sock_release(sock); sock = NULL; } // update cur servers rtt - if (is_same_server(&dev->cur_server, &dev->alt_servers[i])) - { + if (is_same_server(&dev->cur_server, &dev->alt_servers[i])) { dev->cur_rtt = rtt; current_server = i; } @@ -492,52 +479,48 @@ static int dnbd3_net_discover(void *data) continue; -error: ; +error: ++dev->alt_servers[i].failures; if (sock != NULL) { sock_release(sock); sock = NULL; } dev->alt_servers[i].rtts[turn] = RTT_UNREACHABLE; - if (is_same_server(&dev->cur_server, &dev->alt_servers[i])) - { + if (is_same_server(&dev->cur_server, &dev->alt_servers[i])) { dev->cur_rtt = RTT_UNREACHABLE; current_server = i; } continue; } - if (dev->panic) - { + if (dev->panic) { // After 21 retries, bail out by reporting errors to block layer - if (PROBE_COUNT_TIMEOUT > 0 && dev->panic_count < 255 && ++dev->panic_count == PROBE_COUNT_TIMEOUT + 1) + if (PROBE_COUNT_TIMEOUT > 0 && dev->panic_count < 255 && + ++dev->panic_count == PROBE_COUNT_TIMEOUT + 1) dnbd3_blk_fail_all_requests(dev); } - if (best_server == -1 || kthread_should_stop() || dev->thread_discover == NULL ) // No alt server could be reached at all or thread should stop - { - if (best_sock != NULL ) // Should never happen actually - { + if (best_server == -1 || kthread_should_stop() || dev->thread_discover == NULL) { + // No alt server could be reached at all or thread should stop + if (best_sock != NULL) { + // Should never happen actually sock_release(best_sock); best_sock = NULL; } continue; } - do_change = ready && best_server != current_server && (ktime_to_us(start) & 3) != 0 - && RTT_THRESHOLD_FACTOR(dev->cur_rtt) > best_rtt + 1500; + do_change = ready && best_server != current_server && (ktime_to_us(start) & 3) != 0 && + RTT_THRESHOLD_FACTOR(dev->cur_rtt) > best_rtt + 1500; if (ready && !do_change) { spin_lock_irqsave(&dev->blk_lock, irqflags); - if (!list_empty(&dev->request_queue_send)) - { + if (!list_empty(&dev->request_queue_send)) { cur_request = list_entry(dev->request_queue_send.next, struct request, queuelist); do_change = (cur_request == last_request); if (do_change) dev_warn(dnbd3_device_to_dev(dev), "hung request\n"); - } - else - { + } else { cur_request = (struct request *)123; } last_request = cur_request; @@ -546,10 +529,9 @@ error: ; // take server with lowest rtt // if a (dis)connect is already in progress, we do nothing, this is not panic mode - if (do_change && atomic_cmpxchg(&dev->connection_lock, 0, 1) == 0) - { + if (do_change && atomic_cmpxchg(&dev->connection_lock, 0, 1) == 0) { dev_info(dnbd3_device_to_dev(dev), "server %d is faster (%lluµs vs. %lluµs)\n", best_server, - (unsigned long long)best_rtt, (unsigned long long)dev->cur_rtt); + (unsigned long long)best_rtt, (unsigned long long)dev->cur_rtt); kfree(buf); dev->better_sock = best_sock; // Take shortcut by continuing to use open connection put_task_struct(dev->thread_discover); @@ -563,8 +545,7 @@ error: ; } // Clean up connection that was held open for quicker server switch - if (best_sock != NULL ) - { + if (best_sock != NULL) { sock_release(best_sock); best_sock = NULL; } @@ -573,15 +554,14 @@ error: ; turn = (turn + 1) % 4; if (turn == 2) // Set ready when we only have 2 of 4 measurements for quicker load balancing ready = 1; - } kfree(buf); - if (kthread_should_stop()) { - dev_dbg(dnbd3_device_to_dev(dev), "kthread dnbd3_net_discover terminated normally\n"); - } else { - dev_dbg(dnbd3_device_to_dev(dev), "kthread dnbd3_net_discover exited unexpectedly\n"); - } + if (kthread_should_stop()) + dev_dbg(dnbd3_device_to_dev(dev), "kthread %s terminated normally\n", __func__); + else + dev_dbg(dnbd3_device_to_dev(dev), "kthread %s exited unexpectedly\n", __func__); + return 0; } @@ -605,20 +585,18 @@ static int dnbd3_net_send(void *data) // move already sent requests to request_queue_send again spin_lock_irqsave(&dev->blk_lock, irqflags); - if (!list_empty(&dev->request_queue_receive)) - { + if (!list_empty(&dev->request_queue_receive)) { dev_dbg(dnbd3_device_to_dev(dev), "request queue was not empty"); - list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_receive, queuelist) - { + list_for_each_entry_safe(blk_request, tmp_request, &dev->request_queue_receive, queuelist) { list_del_init(&blk_request->queuelist); list_add(&blk_request->queuelist, &dev->request_queue_send); } } spin_unlock_irqrestore(&dev->blk_lock, irqflags); - while (!kthread_should_stop()) - { - wait_event_interruptible(dev->process_queue_send, kthread_should_stop() || !list_empty(&dev->request_queue_send)); + while (!kthread_should_stop()) { + wait_event_interruptible(dev->process_queue_send, + kthread_should_stop() || !list_empty(&dev->request_queue_send)); if (kthread_should_stop()) break; @@ -626,16 +604,14 @@ static int dnbd3_net_send(void *data) // extract block request /* lock since we aquire a blk request from the request_queue_send */ spin_lock_irqsave(&dev->blk_lock, irqflags); - if (list_empty(&dev->request_queue_send)) - { + if (list_empty(&dev->request_queue_send)) { spin_unlock_irqrestore(&dev->blk_lock, irqflags); continue; } blk_request = list_entry(dev->request_queue_send.next, struct request, queuelist); // what to do? - switch (dnbd3_req_op(blk_request)) - { + switch (dnbd3_req_op(blk_request)) { case DNBD3_DEV_READ: dnbd3_request.cmd = CMD_GET_BLOCK; dnbd3_request.offset = blk_rq_pos(blk_request) << 9; // *512 @@ -652,7 +628,8 @@ static int dnbd3_net_send(void *data) default: if (!atomic_read(&dev->connection_lock)) - dev_err(dnbd3_device_to_dev(dev), "unknown command (send %u %u)\n", (int)blk_request->cmd_flags, (int)dnbd3_req_op(blk_request)); + dev_err(dnbd3_device_to_dev(dev), "unknown command (send %u %u)\n", + (int)blk_request->cmd_flags, (int)dnbd3_req_op(blk_request)); list_del_init(&blk_request->queuelist); spin_unlock_irqrestore(&dev->blk_lock, irqflags); continue; @@ -664,8 +641,7 @@ static int dnbd3_net_send(void *data) fixup_request(dnbd3_request); iov.iov_base = &dnbd3_request; iov.iov_len = sizeof(dnbd3_request); - if (kernel_sendmsg(dev->sock, &msg, &iov, 1, sizeof(dnbd3_request)) != sizeof(dnbd3_request)) - { + if (kernel_sendmsg(dev->sock, &msg, &iov, 1, sizeof(dnbd3_request)) != sizeof(dnbd3_request)) { if (!atomic_read(&dev->connection_lock)) dnbd3_dev_err_host_cur(dev, "connection to server lost (send)\n"); ret = -ESHUTDOWN; @@ -673,12 +649,11 @@ static int dnbd3_net_send(void *data) } } - dev_dbg(dnbd3_device_to_dev(dev), "kthread dnbd3_net_send terminated normally\n"); + dev_dbg(dnbd3_device_to_dev(dev), "kthread %s terminated normally\n", __func__); return 0; cleanup: - if (!atomic_read(&dev->connection_lock)) - { + if (!atomic_read(&dev->connection_lock)) { if (dev->sock) kernel_sock_shutdown(dev->sock, SHUT_RDWR); dev->panic = 1; @@ -686,11 +661,10 @@ cleanup: wake_up(&dev->process_queue_discover); } - if (kthread_should_stop() || ret == 0 || atomic_read(&dev->connection_lock)) { - dev_dbg(dnbd3_device_to_dev(dev), "kthread dnbd3_net_send terminated normally (cleanup)\n"); - } else { - dev_err(dnbd3_device_to_dev(dev), "kthread dnbd3_net_send terminated abnormally (%d)\n", ret); - } + if (kthread_should_stop() || ret == 0 || atomic_read(&dev->connection_lock)) + dev_dbg(dnbd3_device_to_dev(dev), "kthread %s terminated normally (cleanup)\n", __func__); + else + dev_err(dnbd3_device_to_dev(dev), "kthread %s terminated abnormally (%d)\n", __func__, ret); return 0; } @@ -709,15 +683,14 @@ static int dnbd3_net_receive(void *data) void *kaddr; unsigned long irqflags; uint16_t rid; - unsigned long int recv_timeout = jiffies; + unsigned long recv_timeout = jiffies; int count, remaining, ret = 0; init_msghdr(msg); set_user_nice(current, -20); - while (!kthread_should_stop()) - { + while (!kthread_should_stop()) { // receive net reply iov.iov_base = &dnbd3_reply; iov.iov_len = sizeof(dnbd3_reply); @@ -728,21 +701,19 @@ static int dnbd3_net_receive(void *data) break; /* check return value of kernel_recvmsg() */ - if (ret == 0) - { + if (ret == 0) { /* have not received any data, but remote peer is shutdown properly */ dnbd3_dev_dbg_host_cur(dev, "remote peer has performed an orderly shutdown\n"); goto cleanup; - } - else if (ret < 0) - { - if (ret == -EAGAIN) - { - if (jiffies < recv_timeout) recv_timeout = jiffies; // Handle overflow - if ((jiffies - recv_timeout) / HZ > SOCKET_KEEPALIVE_TIMEOUT) - { + } else if (ret < 0) { + if (ret == -EAGAIN) { + if (jiffies < recv_timeout) + recv_timeout = jiffies; // Handle overflow + if ((jiffies - recv_timeout) / HZ > SOCKET_KEEPALIVE_TIMEOUT) { if (!atomic_read(&dev->connection_lock)) - dnbd3_dev_err_host_cur(dev, "receive timeout reached (%d of %d secs)\n", (int)((jiffies - recv_timeout) / HZ), (int)SOCKET_KEEPALIVE_TIMEOUT); + dnbd3_dev_err_host_cur(dev, "receive timeout reached (%d of %d secs)\n", + (int)((jiffies - recv_timeout) / HZ), + (int)SOCKET_KEEPALIVE_TIMEOUT); ret = -ETIMEDOUT; goto cleanup; } @@ -757,8 +728,7 @@ static int dnbd3_net_receive(void *data) } /* check if arrived data is valid */ - if (ret != sizeof(dnbd3_reply)) - { + if (ret != sizeof(dnbd3_reply)) { if (!atomic_read(&dev->connection_lock)) dnbd3_dev_err_host_cur(dev, "recv msg header\n"); ret = -EINVAL; @@ -767,14 +737,12 @@ static int dnbd3_net_receive(void *data) fixup_reply(dnbd3_reply); // check error - if (dnbd3_reply.magic != dnbd3_packet_magic) - { + if (dnbd3_reply.magic != dnbd3_packet_magic) { dnbd3_dev_err_host_cur(dev, "wrong packet magic (receive)\n"); ret = -EINVAL; goto cleanup; } - if (dnbd3_reply.cmd == 0) - { + if (dnbd3_reply.cmd == 0) { dnbd3_dev_err_host_cur(dev, "command was 0 (Receive)\n"); ret = -EINVAL; goto cleanup; @@ -784,49 +752,45 @@ static int dnbd3_net_receive(void *data) recv_timeout = jiffies; // what to do? - switch (dnbd3_reply.cmd) - { + switch (dnbd3_reply.cmd) { case CMD_GET_BLOCK: // search for replied request in queue blk_request = NULL; spin_lock_irqsave(&dev->blk_lock, irqflags); - list_for_each_entry_safe(received_request, tmp_request, &dev->request_queue_receive, queuelist) - { - if ((uint64_t)(uintptr_t)received_request == dnbd3_reply.handle) // Double cast to prevent warning on 32bit - { + list_for_each_entry_safe(received_request, tmp_request, &dev->request_queue_receive, + queuelist) { + if ((uint64_t)(uintptr_t)received_request == dnbd3_reply.handle) { + // Double cast to prevent warning on 32bit blk_request = received_request; list_del_init(&blk_request->queuelist); break; } } spin_unlock_irqrestore(&dev->blk_lock, irqflags); - if (blk_request == NULL) - { + if (blk_request == NULL) { dnbd3_dev_err_host_cur(dev, "received block data for unrequested handle (%llu: %llu)\n", - (unsigned long long)dnbd3_reply.handle, (unsigned long long)dnbd3_reply.size); + (unsigned long long)dnbd3_reply.handle, + (unsigned long long)dnbd3_reply.size); ret = -EINVAL; goto cleanup; } // receive data and answer to block layer - rq_for_each_segment(bvec_inst, blk_request, iter) - { + rq_for_each_segment(bvec_inst, blk_request, iter) { kaddr = kmap(bvec->bv_page) + bvec->bv_offset; iov.iov_base = kaddr; iov.iov_len = bvec->bv_len; ret = kernel_recvmsg(dev->sock, &msg, &iov, 1, bvec->bv_len, msg.msg_flags); kunmap(bvec->bv_page); - if (ret != bvec->bv_len) - { - if (ret == 0) - { + if (ret != bvec->bv_len) { + if (ret == 0) { /* have not received any data, but remote peer is shutdown properly */ - dnbd3_dev_dbg_host_cur(dev, "remote peer has performed an orderly shutdown\n"); + dnbd3_dev_dbg_host_cur( + dev, "remote peer has performed an orderly shutdown\n"); ret = 0; - } - else - { + } else { if (!atomic_read(&dev->connection_lock)) - dnbd3_dev_err_host_cur(dev, "receiving from net to block layer\n"); + dnbd3_dev_err_host_cur(dev, + "receiving from net to block layer\n"); ret = -EINVAL; } // Requeue request @@ -840,8 +804,7 @@ static int dnbd3_net_receive(void *data) continue; case CMD_GET_SERVERS: - if (!dev->use_server_provided_alts) - { + if (!dev->use_server_provided_alts) { remaining = dnbd3_reply.size; goto consume_payload; } @@ -850,13 +813,11 @@ static int dnbd3_net_receive(void *data) spin_unlock_irqrestore(&dev->blk_lock, irqflags); count = MIN(NUMBER_SERVERS, dnbd3_reply.size / sizeof(dnbd3_server_entry_t)); - if (count != 0) - { + if (count != 0) { iov.iov_base = dev->new_servers; iov.iov_len = count * sizeof(dnbd3_server_entry_t); - if (kernel_recvmsg(dev->sock, &msg, &iov, 1, (count * sizeof(dnbd3_server_entry_t)), msg.msg_flags) - != (count * sizeof(dnbd3_server_entry_t))) - { + if (kernel_recvmsg(dev->sock, &msg, &iov, 1, (count * sizeof(dnbd3_server_entry_t)), + msg.msg_flags) != (count * sizeof(dnbd3_server_entry_t))) { if (!atomic_read(&dev->connection_lock)) dnbd3_dev_err_host_cur(dev, "recv CMD_GET_SERVERS payload\n"); ret = -EINVAL; @@ -868,16 +829,17 @@ static int dnbd3_net_receive(void *data) } // If there were more servers than accepted, remove the remaining data from the socket buffer remaining = dnbd3_reply.size - (count * sizeof(dnbd3_server_entry_t)); - consume_payload: while (remaining > 0) - { - count = MIN(sizeof(dnbd3_reply), remaining); // Abuse the reply struct as the receive buffer +consume_payload: + while (remaining > 0) { + count = MIN(sizeof(dnbd3_reply), + remaining); // Abuse the reply struct as the receive buffer iov.iov_base = &dnbd3_reply; iov.iov_len = count; ret = kernel_recvmsg(dev->sock, &msg, &iov, 1, iov.iov_len, msg.msg_flags); - if (ret <= 0) - { + if (ret <= 0) { if (!atomic_read(&dev->connection_lock)) - dnbd3_dev_err_host_cur(dev, "recv additional payload from CMD_GET_SERVERS\n"); + dnbd3_dev_err_host_cur( + dev, "recv additional payload from CMD_GET_SERVERS\n"); ret = -EINVAL; goto cleanup; } @@ -886,37 +848,31 @@ static int dnbd3_net_receive(void *data) continue; case CMD_LATEST_RID: - if (dnbd3_reply.size != 2) - { + if (dnbd3_reply.size != 2) { dev_err(dnbd3_device_to_dev(dev), "CMD_LATEST_RID.size != 2\n"); continue; } iov.iov_base = &rid; iov.iov_len = sizeof(rid); - if (kernel_recvmsg(dev->sock, &msg, &iov, 1, iov.iov_len, msg.msg_flags) <= 0) - { + if (kernel_recvmsg(dev->sock, &msg, &iov, 1, iov.iov_len, msg.msg_flags) <= 0) { if (!atomic_read(&dev->connection_lock)) dev_err(dnbd3_device_to_dev(dev), "could not receive CMD_LATEST_RID payload\n"); - } - else - { + } else { rid = net_order_16(rid); - dev_info(dnbd3_device_to_dev(dev), "latest rid of %s is %d (currently using %d)\n", dev->imgname, (int)rid, (int)dev->rid); + dev_info(dnbd3_device_to_dev(dev), "latest rid of %s is %d (currently using %d)\n", + dev->imgname, (int)rid, (int)dev->rid); dev->update_available = (rid > dev->rid ? 1 : 0); } continue; case CMD_KEEPALIVE: if (dnbd3_reply.size != 0) - { dev_err(dnbd3_device_to_dev(dev), "keep alive packet with payload\n"); - } continue; default: dev_err(dnbd3_device_to_dev(dev), "unknown command (receive)\n"); continue; - } } @@ -924,8 +880,7 @@ static int dnbd3_net_receive(void *data) return 0; cleanup: - if (!atomic_read(&dev->connection_lock)) - { + if (!atomic_read(&dev->connection_lock)) { if (dev->sock) kernel_sock_shutdown(dev->sock, SHUT_RDWR); dev->panic = 1; @@ -933,41 +888,42 @@ cleanup: wake_up(&dev->process_queue_discover); } - if (kthread_should_stop() || ret == 0 || atomic_read(&dev->connection_lock)) { - dev_dbg(dnbd3_device_to_dev(dev), "kthread dnbd3_net_receive terminated normally (cleanup)\n"); - } else { - dev_err(dnbd3_device_to_dev(dev), "kthread dnbd3_net_receive terminated abnormally (%d)\n", ret); - } + if (kthread_should_stop() || ret == 0 || atomic_read(&dev->connection_lock)) + dev_dbg(dnbd3_device_to_dev(dev), "kthread %s terminated normally (cleanup)\n", __func__); + else + dev_err(dnbd3_device_to_dev(dev), "kthread %s terminated abnormally (%d)\n", __func__, ret); + return 0; } -static struct socket* dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host) +static struct socket *dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host) { int ret; struct socket *sock; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0) +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 1, 0) struct __kernel_sock_timeval timeout; #else struct timeval timeout; #endif -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0) sockptr_t timeout_ptr; + timeout_ptr = KERNEL_SOCKPTR(&timeout); #else char *timeout_ptr; + timeout_ptr = (char *)&timeout; #endif timeout.tv_sec = SOCKET_TIMEOUT_CLIENT_DATA; timeout.tv_usec = 0; - if (dnbd3_sock_create(host->type, SOCK_STREAM, IPPROTO_TCP, &sock) < 0) - { + if (dnbd3_sock_create(host->type, SOCK_STREAM, IPPROTO_TCP, &sock) < 0) { dev_err(dnbd3_device_to_dev(dev), "couldn't create socket\n"); return NULL; } -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0) +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 1, 0) sock_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO_NEW, timeout_ptr, sizeof(timeout)); sock_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO_NEW, timeout_ptr, sizeof(timeout)); #else @@ -975,30 +931,27 @@ static struct socket* dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host) sock_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, timeout_ptr, sizeof(timeout)); #endif sock->sk->sk_allocation = GFP_NOIO; - if (host->type == HOST_IP4) - { + if (host->type == HOST_IP4) { struct sockaddr_in sin; + memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; memcpy(&(sin.sin_addr), host->addr, 4); sin.sin_port = host->port; ret = kernel_connect(sock, (struct sockaddr *)&sin, sizeof(sin), O_NONBLOCK); - if (ret != 0 && ret != -EINPROGRESS) - { + if (ret != 0 && ret != -EINPROGRESS) { dev_err(dnbd3_device_to_dev(dev), "connection to host failed (v4)\n"); goto error; } - } - else - { + } else { struct sockaddr_in6 sin; + memset(&sin, 0, sizeof(sin)); sin.sin6_family = AF_INET6; memcpy(&(sin.sin6_addr), host->addr, 16); sin.sin6_port = host->port; ret = kernel_connect(sock, (struct sockaddr *)&sin, sizeof(sin), O_NONBLOCK); - if (ret != 0 && ret != -EINPROGRESS) - { + if (ret != 0 && ret != -EINPROGRESS) { dev_err(dnbd3_device_to_dev(dev), "connection to host failed (v6)\n"); goto error; } @@ -1006,9 +959,11 @@ static struct socket* dnbd3_connect(dnbd3_device_t *dev, dnbd3_host_t *host) if (ret != 0) { /* XXX How can we do a connect with short timeout? This is dumb */ ktime_t start = ktime_get_real(); + while (ktime_ms_delta(ktime_get_real(), start) < SOCKET_TIMEOUT_CLIENT_DATA * 1000) { struct sockaddr_storage addr; - ret = kernel_getpeername(sock, (struct sockaddr*)&addr); + + ret = kernel_getpeername(sock, (struct sockaddr *)&addr); if (ret >= 0) break; msleep(1); @@ -1033,26 +988,22 @@ int dnbd3_net_connect(dnbd3_device_t *dev) // do some checks before connecting req1 = kmalloc(sizeof(*req1), GFP_ATOMIC); - if (!req1) - { + if (!req1) { dnbd3_dev_err_host_cur(dev, "kmalloc failed\n"); goto error; } - if (dev->cur_server.host.port == 0 || dev->cur_server.host.type == 0 || dev->imgname == NULL ) - { + if (dev->cur_server.host.port == 0 || dev->cur_server.host.type == 0 || dev->imgname == NULL) { dnbd3_dev_err_host_cur(dev, "host, port or image name not set\n"); goto error; } - if (dev->sock) - { + if (dev->sock) { dnbd3_dev_err_host_cur(dev, "socket already connected\n"); goto error; } - if (dev->cur_server.host.type != HOST_IP4 && dev->cur_server.host.type != HOST_IP6) - { + if (dev->cur_server.host.type != HOST_IP4 && dev->cur_server.host.type != HOST_IP6) { dnbd3_dev_err_host_cur(dev, "unknown address type %d\n", (int)dev->cur_server.host.type); goto error; } @@ -1063,8 +1014,7 @@ int dnbd3_net_connect(dnbd3_device_t *dev) dnbd3_dev_dbg_host_cur(dev, "connecting ...\n"); - if (dev->better_sock == NULL ) - { + if (dev->better_sock == NULL) { // no established connection yet from discovery thread, start new one uint64_t reported_size; dnbd3_request_t dnbd3_request; @@ -1074,12 +1024,12 @@ int dnbd3_net_connect(dnbd3_device_t *dev) uint16_t rid; char *name; int mlen; + init_msghdr(msg); dev->sock = dnbd3_connect(dev, &dev->cur_server.host); - if (dev->sock == NULL) - { - dnbd3_dev_err_host_cur(dev, "dnbd3_net_connect: Failed\n"); + if (dev->sock == NULL) { + dnbd3_dev_err_host_cur(dev, "%s: Failed\n", __func__); goto error; } @@ -1097,74 +1047,68 @@ int dnbd3_net_connect(dnbd3_device_t *dev) dnbd3_request.size = iov[1].iov_len = serializer_get_written_length(&dev->payload_buffer); fixup_request(dnbd3_request); mlen = sizeof(dnbd3_request) + iov[1].iov_len; - if (kernel_sendmsg(dev->sock, &msg, iov, 2, mlen) != mlen) - { + if (kernel_sendmsg(dev->sock, &msg, iov, 2, mlen) != mlen) { dnbd3_dev_err_host_cur(dev, "couldn't send CMD_SIZE_REQUEST\n"); goto error; } // receive reply header iov[0].iov_base = &dnbd3_reply; iov[0].iov_len = sizeof(dnbd3_reply); - if (kernel_recvmsg(dev->sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != sizeof(dnbd3_reply)) - { + if (kernel_recvmsg(dev->sock, &msg, iov, 1, sizeof(dnbd3_reply), msg.msg_flags) != + sizeof(dnbd3_reply)) { dnbd3_dev_err_host_cur(dev, "received corrupted reply header after CMD_SIZE_REQUEST\n"); goto error; } // check reply header fixup_reply(dnbd3_reply); - if (dnbd3_reply.cmd != CMD_SELECT_IMAGE || dnbd3_reply.size < 3 || dnbd3_reply.size > MAX_PAYLOAD - || dnbd3_reply.magic != dnbd3_packet_magic) - { - dnbd3_dev_err_host_cur(dev, "received invalid reply to CMD_SIZE_REQUEST, image doesn't exist on server\n"); + if (dnbd3_reply.cmd != CMD_SELECT_IMAGE || dnbd3_reply.size < 3 || dnbd3_reply.size > MAX_PAYLOAD || + dnbd3_reply.magic != dnbd3_packet_magic) { + dnbd3_dev_err_host_cur( + dev, "received invalid reply to CMD_SIZE_REQUEST, image doesn't exist on server\n"); goto error; } // receive reply payload iov[0].iov_base = &dev->payload_buffer; iov[0].iov_len = dnbd3_reply.size; - if (kernel_recvmsg(dev->sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != dnbd3_reply.size) - { + if (kernel_recvmsg(dev->sock, &msg, iov, 1, dnbd3_reply.size, msg.msg_flags) != dnbd3_reply.size) { dnbd3_dev_err_host_cur(dev, "cold not read CMD_SELECT_IMAGE payload on handshake\n"); goto error; } // handle/check reply payload serializer_reset_read(&dev->payload_buffer, dnbd3_reply.size); dev->cur_server.protocol_version = serializer_get_uint16(&dev->payload_buffer); - if (dev->cur_server.protocol_version < MIN_SUPPORTED_SERVER) - { + if (dev->cur_server.protocol_version < MIN_SUPPORTED_SERVER) { dnbd3_dev_err_host_cur(dev, "server version is lower than min supported version\n"); goto error; } name = serializer_get_string(&dev->payload_buffer); - if (dev->rid != 0 && strcmp(name, dev->imgname) != 0) - { + if (dev->rid != 0 && strcmp(name, dev->imgname) != 0) { dnbd3_dev_err_host_cur(dev, "server offers image '%s', requested '%s'\n", name, dev->imgname); goto error; } - if (strlen(dev->imgname) < strlen(name)) - { - dev->imgname = krealloc(dev->imgname, strlen(name) + 1, GFP_ATOMIC ); - if (dev->imgname == NULL) - { + if (strlen(dev->imgname) < strlen(name)) { + dev->imgname = krealloc(dev->imgname, strlen(name) + 1, GFP_ATOMIC); + if (dev->imgname == NULL) { dnbd3_dev_err_host_cur(dev, "reallocating buffer for new image name failed\n"); goto error; } } strcpy(dev->imgname, name); rid = serializer_get_uint16(&dev->payload_buffer); - if (dev->rid != 0 && dev->rid != rid) - { - dnbd3_dev_err_host_cur(dev, "server provides rid %d, requested was %d\n", (int)rid, (int)dev->rid); + if (dev->rid != 0 && dev->rid != rid) { + dnbd3_dev_err_host_cur(dev, "server provides rid %d, requested was %d\n", (int)rid, + (int)dev->rid); goto error; } dev->rid = rid; reported_size = serializer_get_uint64(&dev->payload_buffer); - if (reported_size < 4096) - { + if (reported_size < 4096) { dnbd3_dev_err_host_cur(dev, "reported size by server is < 4096\n"); goto error; } if (dev->reported_size != 0 && dev->reported_size != reported_size) { - dnbd3_dev_err_host_cur(dev, "newly connected server reports size %llu, but expected is %llu\n", reported_size, dev->reported_size); + dnbd3_dev_err_host_cur(dev, "newly connected server reports size %llu, but expected is %llu\n", + reported_size, dev->reported_size); goto error; } else if (dev->reported_size == 0) { // store image information @@ -1173,9 +1117,8 @@ int dnbd3_net_connect(dnbd3_device_t *dev) dnbd3_dev_dbg_host_cur(dev, "image size: %llu\n", dev->reported_size); dev->update_available = 0; } - } - else // Switching server, connection is already established and size request was executed - { + } else { + // Switching server, connection is already established and size request was executed dnbd3_dev_dbg_host_cur(dev, "on-the-fly server change ...\n"); dev->sock = dev->better_sock; dev->better_sock = NULL; @@ -1237,40 +1180,35 @@ int dnbd3_net_connect(dnbd3_device_t *dev) return 0; error: - if (dev->thread_send) - { + if (dev->thread_send) { kthread_stop(dev->thread_send); put_task_struct(dev->thread_send); dev->thread_send = NULL; } - if (dev->thread_receive) - { + if (dev->thread_receive) { kthread_stop(dev->thread_receive); put_task_struct(dev->thread_receive); dev->thread_receive = NULL; } - if (dev->thread_discover) - { + if (dev->thread_discover) { kthread_stop(dev->thread_discover); put_task_struct(dev->thread_discover); dev->thread_discover = NULL; } - if (dev->sock) - { + if (dev->sock) { sock_release(dev->sock); dev->sock = NULL; } dev->cur_server.host.type = 0; dev->cur_server.host.port = 0; - if (req1) - kfree(req1); + kfree(req1); return -1; } int dnbd3_net_disconnect(dnbd3_device_t *dev) { - struct task_struct* thread = NULL; + struct task_struct *thread = NULL; int ret; dev_dbg(dnbd3_device_to_dev(dev), "disconnecting device ...\n"); @@ -1285,8 +1223,7 @@ int dnbd3_net_disconnect(dnbd3_device_t *dev) } // kill sending and receiving threads - if (dev->thread_send) - { + if (dev->thread_send) { dnbd3_dev_dbg_host_cur(dev, "stop send thread\n"); thread = dev->thread_send; ret = kthread_stop(thread); @@ -1296,15 +1233,13 @@ int dnbd3_net_disconnect(dnbd3_device_t *dev) dev_dbg(dnbd3_device_to_dev(dev), "send thread has never run\n"); } else { /* thread has run, check if it has terminated successfully */ - if (ret < 0) { + if (ret < 0) dev_err(dnbd3_device_to_dev(dev), "send thread was not terminated correctly\n"); - } } dev->thread_send = NULL; } - if (dev->thread_receive) - { + if (dev->thread_receive) { dnbd3_dev_dbg_host_cur(dev, "stop receive thread\n"); thread = dev->thread_receive; ret = kthread_stop(thread); @@ -1314,15 +1249,13 @@ int dnbd3_net_disconnect(dnbd3_device_t *dev) dev_dbg(dnbd3_device_to_dev(dev), "receive thread has never run\n"); } else { /* thread has run, check if it has terminated successfully */ - if (ret < 0) { + if (ret < 0) dev_err(dnbd3_device_to_dev(dev), "receive thread was not terminated correctly\n"); - } } dev->thread_receive = NULL; } - if (dev->thread_discover) - { + if (dev->thread_discover) { dnbd3_dev_dbg_host_cur(dev, "stop discover thread\n"); thread = dev->thread_discover; ret = kthread_stop(thread); @@ -1333,14 +1266,14 @@ int dnbd3_net_disconnect(dnbd3_device_t *dev) } else { /* thread has run, check if it has terminated successfully */ if (ret < 0) { - dev_err(dnbd3_device_to_dev(dev), "discover thread was not terminated correctly (%d)\n", ret); + dev_err(dnbd3_device_to_dev(dev), "discover thread was not terminated correctly (%d)\n", + ret); } } dev->thread_discover = NULL; } - if (dev->sock) - { + if (dev->sock) { sock_release(dev->sock); dev->sock = NULL; } diff --git a/src/kernel/net.h b/src/kernel/net.h index e7accd0..d46505b 100644 --- a/src/kernel/net.h +++ b/src/kernel/net.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * This file is part of the Distributed Network Block Device 3 * @@ -23,12 +24,13 @@ #include "dnbd3_main.h" -#define init_msghdr(h) do { \ - h.msg_name = NULL; \ - h.msg_namelen = 0; \ - h.msg_control = NULL; \ - h.msg_controllen = 0; \ - h.msg_flags = MSG_WAITALL | MSG_NOSIGNAL; \ +#define init_msghdr(h) \ + do { \ + h.msg_name = NULL; \ + h.msg_namelen = 0; \ + h.msg_control = NULL; \ + h.msg_controllen = 0; \ + h.msg_flags = MSG_WAITALL | MSG_NOSIGNAL; \ } while (0) int dnbd3_net_connect(dnbd3_device_t *lo); diff --git a/src/kernel/sysfs.c b/src/kernel/sysfs.c index 1dbae3c..5b9a5ce 100644 --- a/src/kernel/sysfs.c +++ b/src/kernel/sysfs.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 /* * This file is part of the Distributed Network Block Device 3 * @@ -24,15 +25,19 @@ #include "utils.h" #ifndef MIN -#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif ssize_t show_cur_server_addr(char *buf, dnbd3_device_t *dev) { if (dev->cur_server.host.type == HOST_IP4) - return MIN(snprintf(buf, PAGE_SIZE, "%pI4:%d\n", dev->cur_server.host.addr, (int)ntohs(dev->cur_server.host.port)), PAGE_SIZE); + return MIN(snprintf(buf, PAGE_SIZE, "%pI4:%d\n", dev->cur_server.host.addr, + (int)ntohs(dev->cur_server.host.port)), + PAGE_SIZE); else if (dev->cur_server.host.type == HOST_IP6) - return MIN(snprintf(buf, PAGE_SIZE, "[%pI6]:%d\n", dev->cur_server.host.addr, (int)ntohs(dev->cur_server.host.port)), PAGE_SIZE); + return MIN(snprintf(buf, PAGE_SIZE, "[%pI6]:%d\n", dev->cur_server.host.addr, + (int)ntohs(dev->cur_server.host.port)), + PAGE_SIZE); *buf = '\0'; return 0; } @@ -45,9 +50,10 @@ ssize_t show_cur_server_rtt(char *buf, dnbd3_device_t *dev) ssize_t show_alt_server_num(char *buf, dnbd3_device_t *dev) { int i, num = 0; - for (i = 0; i < NUMBER_SERVERS; ++i) - { - if (dev->alt_servers[i].host.type) ++num; + + for (i = 0; i < NUMBER_SERVERS; ++i) { + if (dev->alt_servers[i].host.type) + ++num; } return MIN(snprintf(buf, PAGE_SIZE, "%d\n", num), PAGE_SIZE); } @@ -55,28 +61,31 @@ ssize_t show_alt_server_num(char *buf, dnbd3_device_t *dev) ssize_t show_alt_servers(char *buf, dnbd3_device_t *dev) { int i, size = PAGE_SIZE, ret; - for (i = 0; i < NUMBER_SERVERS; ++i) - { + + for (i = 0; i < NUMBER_SERVERS; ++i) { if (dev->alt_servers[i].host.type == HOST_IP4) - ret = MIN(snprintf(buf, size, "%pI4:%d,%llu,%d\n", - dev->alt_servers[i].host.addr, - (int)ntohs(dev->alt_servers[i].host.port), - (unsigned long long)((dev->alt_servers[i].rtts[0] + dev->alt_servers[i].rtts[1] + dev->alt_servers[i].rtts[2] + dev->alt_servers[i].rtts[3]) / 4), - (int)dev->alt_servers[i].failures) - , size); + ret = MIN(snprintf(buf, size, "%pI4:%d,%llu,%d\n", dev->alt_servers[i].host.addr, + (int)ntohs(dev->alt_servers[i].host.port), + (unsigned long long)((dev->alt_servers[i].rtts[0] + + dev->alt_servers[i].rtts[1] + + dev->alt_servers[i].rtts[2] + + dev->alt_servers[i].rtts[3]) / 4), + (int)dev->alt_servers[i].failures), + size); else if (dev->alt_servers[i].host.type == HOST_IP6) - ret = MIN(snprintf(buf, size, "[%pI6]:%d,%llu,%d\n", - dev->alt_servers[i].host.addr, - (int)ntohs(dev->alt_servers[i].host.port), - (unsigned long long)((dev->alt_servers[i].rtts[0] + dev->alt_servers[i].rtts[1] + dev->alt_servers[i].rtts[2] + dev->alt_servers[i].rtts[3]) / 4), - (int)dev->alt_servers[i].failures) - , size); + ret = MIN(snprintf(buf, size, "[%pI6]:%d,%llu,%d\n", dev->alt_servers[i].host.addr, + (int)ntohs(dev->alt_servers[i].host.port), + (unsigned long long)((dev->alt_servers[i].rtts[0] + + dev->alt_servers[i].rtts[1] + + dev->alt_servers[i].rtts[2] + + dev->alt_servers[i].rtts[3]) / 4), + (int)dev->alt_servers[i].failures), + size); else continue; size -= ret; buf += ret; - if (size <= 0) - { + if (size <= 0) { size = 0; break; } @@ -86,7 +95,8 @@ ssize_t show_alt_servers(char *buf, dnbd3_device_t *dev) ssize_t show_image_name(char *buf, dnbd3_device_t *dev) { - if (dev->imgname == NULL) return sprintf(buf, "(null)"); + if (dev->imgname == NULL) + return sprintf(buf, "(null)"); return MIN(snprintf(buf, PAGE_SIZE, "%s\n", dev->imgname), PAGE_SIZE); } @@ -100,77 +110,64 @@ ssize_t show_update_available(char *buf, dnbd3_device_t *dev) return MIN(snprintf(buf, PAGE_SIZE, "%d\n", dev->update_available), PAGE_SIZE); } -device_attr_t cur_server_addr = -{ - .attr = {.name = "cur_server_addr", .mode = 0444 }, - .show = show_cur_server_addr, - .store = NULL, +device_attr_t cur_server_addr = { + .attr = { .name = "cur_server_addr", .mode = 0444 }, + .show = show_cur_server_addr, + .store = NULL, }; -device_attr_t cur_server_rtt = -{ - .attr = {.name = "cur_server_rtt", .mode = 0444 }, - .show = show_cur_server_rtt, - .store = NULL, +device_attr_t cur_server_rtt = { + .attr = { .name = "cur_server_rtt", .mode = 0444 }, + .show = show_cur_server_rtt, + .store = NULL, }; -device_attr_t alt_server_num = -{ - .attr = {.name = "alt_server_num", .mode = 0444 }, - .show = show_alt_server_num, - .store = NULL, +device_attr_t alt_server_num = { + .attr = { .name = "alt_server_num", .mode = 0444 }, + .show = show_alt_server_num, + .store = NULL, }; -device_attr_t alt_servers = -{ - .attr = {.name = "alt_servers", .mode = 0444 }, - .show = show_alt_servers, - .store = NULL, +device_attr_t alt_servers = { + .attr = { .name = "alt_servers", .mode = 0444 }, + .show = show_alt_servers, + .store = NULL, }; -device_attr_t image_name = -{ - .attr = {.name = "image_name", .mode = 0444 }, - .show = show_image_name, - .store = NULL, +device_attr_t image_name = { + .attr = { .name = "image_name", .mode = 0444 }, + .show = show_image_name, + .store = NULL, }; -device_attr_t rid = -{ - .attr = {.name = "rid", .mode = 0444 }, - .show = show_rid, - .store = NULL, +device_attr_t rid = { + .attr = { .name = "rid", .mode = 0444 }, + .show = show_rid, + .store = NULL, }; -device_attr_t update_available = -{ - .attr = {.name = "update_available", .mode = 0444 }, - .show = show_update_available, - .store = NULL, +device_attr_t update_available = { + .attr = { .name = "update_available", .mode = 0444 }, + .show = show_update_available, + .store = NULL, }; ssize_t device_show(struct kobject *kobj, struct attribute *attr, char *buf) { device_attr_t *device_attr = container_of(attr, device_attr_t, attr); dnbd3_device_t *dev = container_of(kobj, dnbd3_device_t, kobj); + return device_attr->show(buf, dev); } -struct attribute *device_attrs[] = -{ - &cur_server_addr.attr, - &cur_server_rtt.attr, - &alt_server_num.attr, - &alt_servers.attr, - &image_name.attr, - &rid.attr, - &update_available.attr, - NULL, +struct attribute *device_attrs[] = { + &cur_server_addr.attr, &cur_server_rtt.attr, + &alt_server_num.attr, &alt_servers.attr, + &image_name.attr, &rid.attr, + &update_available.attr, NULL, }; - -struct sysfs_ops device_ops = -{ +const struct sysfs_ops device_ops = { .show = device_show, }; @@ -179,14 +176,12 @@ void release(struct kobject *kobj) kobj->state_initialized = 0; } -struct kobj_type device_ktype = -{ +struct kobj_type device_ktype = { .default_attrs = device_attrs, .sysfs_ops = &device_ops, .release = release, }; - void dnbd3_sysfs_init(dnbd3_device_t *dev) { int error; diff --git a/src/kernel/sysfs.h b/src/kernel/sysfs.h index a90840b..ec6c261 100644 --- a/src/kernel/sysfs.h +++ b/src/kernel/sysfs.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * This file is part of the Distributed Network Block Device 3 * @@ -27,19 +28,16 @@ void dnbd3_sysfs_init(dnbd3_device_t *dev); void dnbd3_sysfs_exit(dnbd3_device_t *dev); -typedef struct -{ +typedef struct { struct attribute attr; - ssize_t (*show)(char *, dnbd3_device_t *); - ssize_t (*store)(const char *, size_t, dnbd3_device_t *); + ssize_t (*show)(char *buf, dnbd3_device_t *dev); + ssize_t (*store)(const char *buf, size_t len, dnbd3_device_t *dev); } device_attr_t; -typedef struct -{ +typedef struct { struct attribute attr; - ssize_t (*show)(char *, dnbd3_server_t *); - ssize_t (*store)(const char *, size_t, dnbd3_server_t *); + ssize_t (*show)(char *buf, dnbd3_server_t *dev); + ssize_t (*store)(const char *buf, size_t len, dnbd3_server_t *dev); } server_attr_t; - #endif /* SYSFS_H_ */ diff --git a/src/kernel/utils.c b/src/kernel/utils.c index 902025f..c40120a 100644 --- a/src/kernel/utils.c +++ b/src/kernel/utils.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 /* * This file is part of the Distributed Network Block Device 3 * @@ -26,16 +27,22 @@ unsigned int inet_addr(char *str) { int a, b, c, d; char arr[4]; - sscanf(str, "%d.%d.%d.%d", &a, &b, &c, &d); - arr[0] = a; - arr[1] = b; - arr[2] = c; - arr[3] = d; - return *(unsigned int *) arr; + int ret; + + ret = sscanf(str, "%d.%d.%d.%d", &a, &b, &c, &d); + if (ret > 0) { + arr[0] = a; + arr[1] = b; + arr[2] = c; + arr[3] = d; + } + + return *(unsigned int *)arr; } void inet_ntoa(struct in_addr addr, char *str) { - unsigned char *ptr = (unsigned char *) &addr; + unsigned char *ptr = (unsigned char *)&addr; + sprintf(str, "%d.%d.%d.%d", ptr[0] & 0xff, ptr[1] & 0xff, ptr[2] & 0xff, ptr[3] & 0xff); } diff --git a/src/kernel/utils.h b/src/kernel/utils.h index e54b3cf..1364c30 100644 --- a/src/kernel/utils.h +++ b/src/kernel/utils.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * This file is part of the Distributed Network Block Device 3 * diff --git a/src/shared/serialize.c b/src/shared/serialize.c index 648b719..1f7cddd 100644 --- a/src/shared/serialize.c +++ b/src/shared/serialize.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: GPL-2.0 #include #include @@ -15,14 +16,17 @@ void serializer_reset_write(serialized_buffer_t *buffer) uint8_t serializer_get_uint8(serialized_buffer_t *buffer) { - if (buffer->buffer_pointer + 1 > buffer->buffer_end) return 0; + if (buffer->buffer_pointer + 1 > buffer->buffer_end) + return 0; return (uint8_t)*buffer->buffer_pointer++; } uint16_t serializer_get_uint16(serialized_buffer_t *buffer) { uint16_t ret; - if (buffer->buffer_pointer + 2 > buffer->buffer_end) return 0; + + if (buffer->buffer_pointer + 2 > buffer->buffer_end) + return 0; memcpy(&ret, buffer->buffer_pointer, 2); buffer->buffer_pointer += 2; return net_order_16(ret); @@ -31,7 +35,9 @@ uint16_t serializer_get_uint16(serialized_buffer_t *buffer) uint64_t serializer_get_uint64(serialized_buffer_t *buffer) { uint64_t ret; - if (buffer->buffer_pointer + 8 > buffer->buffer_end) return 0; + + if (buffer->buffer_pointer + 8 > buffer->buffer_end) + return 0; memcpy(&ret, buffer->buffer_pointer, 8); buffer->buffer_pointer += 8; return net_order_64(ret); @@ -40,22 +46,29 @@ uint64_t serializer_get_uint64(serialized_buffer_t *buffer) char *serializer_get_string(serialized_buffer_t *buffer) { char *ptr = buffer->buffer_pointer, *start = buffer->buffer_pointer; - if (ptr >= buffer->buffer_end) return NULL; - while (ptr < buffer->buffer_end && *ptr) ++ptr; - if (*ptr) return NULL; // String did not terminate within buffer (possibly corrupted/malicious packet) + + if (ptr >= buffer->buffer_end) + return NULL; + while (ptr < buffer->buffer_end && *ptr) + ++ptr; + // String did not terminate within buffer (possibly corrupted/malicious packet) + if (*ptr) + return NULL; buffer->buffer_pointer = ptr + 1; return start; } void serializer_put_uint8(serialized_buffer_t *buffer, uint8_t value) { - if (buffer->buffer_pointer + 1 > buffer->buffer_end) return; + if (buffer->buffer_pointer + 1 > buffer->buffer_end) + return; *buffer->buffer_pointer++ = (char)value; } void serializer_put_uint16(serialized_buffer_t *buffer, uint16_t value) { - if (buffer->buffer_pointer + 2 > buffer->buffer_end) return; + if (buffer->buffer_pointer + 2 > buffer->buffer_end) + return; value = net_order_16(value); memcpy(buffer->buffer_pointer, &value, 2); buffer->buffer_pointer += 2; @@ -63,7 +76,8 @@ void serializer_put_uint16(serialized_buffer_t *buffer, uint16_t value) void serializer_put_uint64(serialized_buffer_t *buffer, uint64_t value) { - if (buffer->buffer_pointer + 8 > buffer->buffer_end) return; + if (buffer->buffer_pointer + 8 > buffer->buffer_end) + return; value = net_order_64(value); memcpy(buffer->buffer_pointer, &value, 8); buffer->buffer_pointer += 8; @@ -72,12 +86,14 @@ void serializer_put_uint64(serialized_buffer_t *buffer, uint64_t value) void serializer_put_string(serialized_buffer_t *buffer, const char *value) { const size_t len = strlen(value) + 1; - if (buffer->buffer_pointer + len > buffer->buffer_end) return; + + if (buffer->buffer_pointer + len > buffer->buffer_end) + return; memcpy(buffer->buffer_pointer, value, len); buffer->buffer_pointer += len; } uint32_t serializer_get_written_length(serialized_buffer_t *buffer) { - return (uint32_t)( buffer->buffer_pointer - buffer->buffer ); + return (uint32_t)(buffer->buffer_pointer - buffer->buffer); } -- cgit v1.2.3-55-g7522