Run clang-format on source tree (excl igmp.c)

1 files changed, 131 insertions, 159 deletions

diff --git a/minecproxy/uring.c b/minecproxy/uring.c
index abea592..dd0d28a 100644
--- a/minecproxy/uring.c
+++ b/minecproxy/uring.c
@@ -19,23 +19,24 @@ struct uring_ev {
 	int tfd;
 };
 
+/* clang-format off */
 enum cqe_type {
 	CQE_TYPE_NORMAL		= 0x0,
 	CQE_TYPE_CANCEL		= 0x1,
 	CQE_TYPE_CLOSE		= 0x2,
 	CQE_TYPE_POLL_CANCEL	= 0x3
 };
+/* clang-format on */
 
 #define CQE_TYPE_PTR_MASK 0x3
 
 uint64_t sqe_count = 0;
 uint64_t cqe_count = 0;
 
-static struct io_uring_sqe *
-get_sqe(struct uring_task *task)
+static struct io_uring_sqe *get_sqe(struct uring_task *task)
 {
 	struct io_uring_sqe *sqe;
-	
+
 	assert_die(task, "invalid arguments");
 
 	sqe = io_uring_get_sqe(&cfg->uring->uring);
@@ -51,8 +52,7 @@ get_sqe(struct uring_task *task)
 	return sqe;
 }
 
-void
-uring_task_refdump(struct uring_task *task)
+void uring_task_refdump(struct uring_task *task)
 {
 	char buf[4096];
 	struct uring_task *tmp;
@@ -83,45 +83,43 @@ uring_task_refdump(struct uring_task *task)
 		memcpy(dst, tmp->name, strlen(tmp->name));
 	}
 
-	info("%s (0x%p parent 0x%p free 0x%p fd %i ref %u)",
-	     buf, task, task->parent, task->free, task->fd,
-	     task->refcount);
+	info("%s (0x%p parent 0x%p free 0x%p fd %i ref %u)", buf, task,
+	     task->parent, task->free, task->fd, task->refcount);
 }
 
 /*
  * Similar to uring_task_put, but can be called from other tasks
  * while the task is active.
  */
-void
-uring_task_destroy(struct uring_task *task)
+void uring_task_destroy(struct uring_task *task)
 {
 	assert_return(task);
 	assert_return_silent(!task->dead);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	if (task->fd >= 0) {
 		struct io_uring_sqe *sqe;
-	
+
 		sqe = get_sqe(task);
 		io_uring_prep_cancel(sqe, task, 0);
-		io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_CANCEL));
+		io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task |
+						    CQE_TYPE_CANCEL));
 	}
 
 	task->dead = true;
 	uring_task_put(task);
 }
 
-void
-uring_task_put(struct uring_task *task)
+void uring_task_put(struct uring_task *task)
 {
 	struct uring_task *parent;
 
 	assert_return(task);
 
-	debug(DBG_REF, "task %s (%p), refcount %u -> %u",
-	      task->name, task, task->refcount, task->refcount - 1);
+	debug(DBG_REF, "task %s (%p), refcount %u -> %u", task->name, task,
+	      task->refcount, task->refcount - 1);
 
 	task->refcount--;
 
@@ -147,13 +145,12 @@ uring_task_put(struct uring_task *task)
 	}
 }
 
-void
-uring_task_get(struct uring_task *task)
+void uring_task_get(struct uring_task *task)
 {
 	assert_return(task);
 
-	debug(DBG_REF, "task %s (%p), refcount %u -> %u",
-	      task->name, task, task->refcount, task->refcount + 1);
+	debug(DBG_REF, "task %s (%p), refcount %u -> %u", task->name, task,
+	      task->refcount, task->refcount + 1);
 
 	if (task->refcount < 0)
 		error("Negative refcount!");
@@ -161,17 +158,16 @@ uring_task_get(struct uring_task *task)
 	task->refcount++;
 }
 
-void
-uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
+void uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
 {
 	assert_return(task && tbuf);
 
-	debug(DBG_UR, "task %s (%p), buf %p, refcount %u",
-	      task->name, task, tbuf, task->refcount);
+	debug(DBG_UR, "task %s (%p), buf %p, refcount %u", task->name, task,
+	      tbuf, task->refcount);
 
 	/* iov_len and msg_namelen are set at send/receive time */
 	tbuf->iov.iov_base = tbuf->buf;
-	tbuf->msg.msg_name = &task->saddr.storage;
+	tbuf->msg.msg_name = &task->saddr.st;
 	tbuf->msg.msg_iov = &tbuf->iov;
 	tbuf->msg.msg_iovlen = 1;
 	tbuf->msg.msg_control = NULL;
@@ -180,24 +176,22 @@ uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
 	task->tbuf = tbuf;
 }
 
-void
-uring_task_set_fd(struct uring_task *task, int fd)
+void uring_task_set_fd(struct uring_task *task, int fd)
 {
 	assert_return(task);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task, fd,
+	      task->refcount);
 
 	task->fd = fd;
 }
 
-void
-uring_task_close_fd(struct uring_task *task)
+void uring_task_close_fd(struct uring_task *task)
 {
 	assert_return(task);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	if (task->fd < 0)
 		return;
@@ -206,17 +200,16 @@ uring_task_close_fd(struct uring_task *task)
 	task->fd = -1;
 }
 
-struct uring_task *
-uring_parent()
+struct uring_task *uring_parent()
 {
 	assert_die(cfg->uring, "invalid arguments");
 
 	return &cfg->uring->task;
 }
 
-void
-uring_task_init(struct uring_task *task, const char *name,
-		struct uring_task *parent, void (*free)(struct uring_task *))
+void uring_task_init(struct uring_task *task, const char *name,
+		     struct uring_task *parent,
+		     void (*free)(struct uring_task *))
 {
 	static bool first = true;
 
@@ -236,38 +229,37 @@ uring_task_init(struct uring_task *task, const char *name,
 	task->tbuf = NULL;
 
 	if (task->parent) {
-		debug(DBG_REF, "task %s (%p), refcount %u, "
+		debug(DBG_REF,
+		      "task %s (%p), refcount %u, "
 		      "getting parent %s (%p), refcount %u",
-		      task->name, task, task->refcount,
-		      task->parent->name, task->parent, task->parent->refcount);
+		      task->name, task, task->refcount, task->parent->name,
+		      task->parent, task->parent->refcount);
 		uring_task_get(task->parent);
 	}
 }
 
-void
-uring_close(struct uring_task *task, int fd)
+void uring_close(struct uring_task *task, int fd)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && fd >= 0);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
-       	sqe = get_sqe(task);
+	sqe = get_sqe(task);
 	io_uring_prep_close(sqe, fd);
 	io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_CLOSE));
 }
 
-static void
-uring_tbuf_write_cb(struct uring_task *task, int res)
+static void uring_tbuf_write_cb(struct uring_task *task, int res)
 {
 	int r;
 
 	assert_return(task && task->tbuf && task->final_cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	if (res < 0) {
 		r = res;
@@ -282,52 +274,51 @@ uring_tbuf_write_cb(struct uring_task *task, int res)
 	}
 
 	uring_write(task, task->tbuf->buf + task->tbuf->done,
-		    task->tbuf->len - task->tbuf->done,
-		    uring_tbuf_write_cb);
+		    task->tbuf->len - task->tbuf->done, uring_tbuf_write_cb);
 	return;
 
 finished:
 	task->final_cb(task, r);
 }
 
-void
-uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb)
+void uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb)
 {
-	assert_return(task && task->fd >= 0 && task->tbuf && task->tbuf->len > 0);
+	assert_return(task && task->fd >= 0 && task->tbuf &&
+		      task->tbuf->len > 0);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	task->tbuf->done = 0;
 	task->final_cb = final_cb;
-	uring_write(task, &task->tbuf->buf, task->tbuf->len, uring_tbuf_write_cb);
+	uring_write(task, &task->tbuf->buf, task->tbuf->len,
+		    uring_tbuf_write_cb);
 }
 
-void
-uring_write(struct uring_task *task, void *buf, size_t len, utask_cb_t cb)
+void uring_write(struct uring_task *task, void *buf, size_t len, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && buf && len > 0 && cb && task->fd >= 0);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
-       	sqe = get_sqe(task);
+	sqe = get_sqe(task);
 	task->cb = cb;
 	io_uring_prep_write(sqe, task->fd, buf, len, 0);
 	io_uring_sqe_set_data(sqe, task);
 }
 
-static void
-uring_tbuf_read_until_cb(struct uring_task *task, int res)
+static void uring_tbuf_read_until_cb(struct uring_task *task, int res)
 {
 	int r;
 
-	assert_return(task && task->tbuf && task->final_cb && task->is_complete_cb);
+	assert_return(task && task->tbuf && task->final_cb &&
+		      task->is_complete_cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	if (res < 0) {
 		r = res;
@@ -359,14 +350,14 @@ finished:
 	task->final_cb(task, r);
 }
 
-void
-uring_tbuf_read_until(struct uring_task *task,
-		      rutask_cb_t is_complete_cb, utask_cb_t final_cb)
+void uring_tbuf_read_until(struct uring_task *task, rutask_cb_t is_complete_cb,
+			   utask_cb_t final_cb)
 {
-	assert_return(task && task->fd >= 0 && task->tbuf && is_complete_cb && final_cb);
+	assert_return(task && task->fd >= 0 && task->tbuf && is_complete_cb &&
+		      final_cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	task->tbuf->len = 0;
 	task->is_complete_cb = is_complete_cb;
@@ -375,8 +366,7 @@ uring_tbuf_read_until(struct uring_task *task,
 		   uring_tbuf_read_until_cb);
 }
 
-static int
-uring_tbuf_eof(struct uring_task *task, int res)
+static int uring_tbuf_eof(struct uring_task *task, int res)
 {
 	assert_return(task && task->tbuf, -EINVAL);
 	assert_task_alive_or(DBG_UR, task, return -EINTR);
@@ -392,17 +382,14 @@ uring_tbuf_eof(struct uring_task *task, int res)
 	return 1;
 }
 
-void
-uring_tbuf_read_until_eof(struct uring_task *task,
-			  utask_cb_t final_cb)
+void uring_tbuf_read_until_eof(struct uring_task *task, utask_cb_t final_cb)
 {
 	assert_return(task && task->tbuf && final_cb);
 
 	uring_tbuf_read_until(task, uring_tbuf_eof, final_cb);
 }
 
-static int
-uring_tbuf_have_data(struct uring_task *task, int res)
+static int uring_tbuf_have_data(struct uring_task *task, int res)
 {
 	assert_return(task, -EINVAL);
 
@@ -412,23 +399,22 @@ uring_tbuf_have_data(struct uring_task *task, int res)
 		return 1;
 }
 
-void
-uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb)
+void uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb)
 {
 	assert_return(task && final_cb);
 
 	uring_tbuf_read_until(task, uring_tbuf_have_data, final_cb);
 }
 
-void
-uring_read_offset(struct uring_task *task, void *buf, size_t len, off_t offset, utask_cb_t cb)
+void uring_read_offset(struct uring_task *task, void *buf, size_t len,
+		       off_t offset, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && buf && len > 0 && task->fd >= 0);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->cb = cb;
@@ -436,15 +422,14 @@ uring_read_offset(struct uring_task *task, void *buf, size_t len, off_t offset,
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_openat(struct uring_task *task, const char *path, utask_cb_t cb)
+void uring_openat(struct uring_task *task, const char *path, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
-       
+
 	assert_return(task && !empty_str(path) && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->cb = cb;
@@ -452,15 +437,14 @@ uring_openat(struct uring_task *task, const char *path, utask_cb_t cb)
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
+void uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && task->fd >= 0 && task->tbuf && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->tbuf->done = 0;
@@ -472,15 +456,14 @@ uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
+void uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && task->fd >= 0 && task->tbuf && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->tbuf->done = 0;
@@ -491,44 +474,43 @@ uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_connect(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
+void uring_connect(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && task->fd >= 0 && saddr && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->cb = cb;
-	io_uring_prep_connect(sqe, task->fd, (struct sockaddr *)&saddr->storage, saddr->addrlen);
+	io_uring_prep_connect(sqe, task->fd, (struct sockaddr *)&saddr->st,
+			      saddr->addrlen);
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_accept(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
+void uring_accept(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
 
 	assert_return(task && task->fd >= 0 && saddr && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
-	saddr->addrlen = sizeof(saddr->storage);
+	saddr->addrlen = sizeof(saddr->st);
 	task->cb = cb;
-	io_uring_prep_accept(sqe, task->fd, (struct sockaddr *)&saddr->storage, &saddr->addrlen, SOCK_CLOEXEC);
+	io_uring_prep_accept(sqe, task->fd, (struct sockaddr *)&saddr->st,
+			     &saddr->addrlen, SOCK_CLOEXEC);
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
+void uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
-	
+
 	assert_return(task && fd_in >= 0 && fd_out >= 0 && cb);
 
 	debug(DBG_UR, "task %s (%p), fd_in %i, fd_out %i, refcount %u",
@@ -540,15 +522,14 @@ uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb)
+void uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb)
 {
 	struct io_uring_sqe *sqe;
-	
+
 	assert_return(task && task->fd >= 0 && poll_mask && cb);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->cb = cb;
@@ -556,11 +537,10 @@ uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb)
 	io_uring_sqe_set_data(sqe, task);
 }
 
-void
-uring_poll_cancel(struct uring_task *task)
+void uring_poll_cancel(struct uring_task *task)
 {
 	struct io_uring_sqe *sqe;
-	
+
 	assert_return(task);
 
 	if (task->fd < 0) {
@@ -568,54 +548,51 @@ uring_poll_cancel(struct uring_task *task)
 		return;
 	}
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	sqe = get_sqe(task);
 	task->dead = true;
 	io_uring_prep_poll_remove(sqe, task);
-	io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_POLL_CANCEL));
+	io_uring_sqe_set_data(sqe,
+			      (void *)((uintptr_t)task | CQE_TYPE_POLL_CANCEL));
 }
 
-static void
-uring_free(struct uring_task *task)
+static void uring_free(struct uring_task *task)
 {
 	struct uring_ev *uring = container_of(task, struct uring_ev, task);
 
 	assert_return(task);
 
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	io_uring_queue_exit(&uring->uring);
 	cfg->uring = NULL;
 	xfree(uring);
 }
 
-void
-uring_refdump()
+void uring_refdump()
 {
 	assert_return(cfg->uring);
 
 	uring_task_refdump(&cfg->uring->task);
 }
 
-void
-uring_delete()
+void uring_delete()
 {
 	struct uring_task *task;
 
 	assert_return(cfg->uring);
 
 	task = &cfg->uring->task;
-	debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
-	      task->name, task, task->fd, task->refcount);
+	debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+	      task->fd, task->refcount);
 
 	uring_task_put(task);
 }
 
-static void
-uring_splice_test_cb(struct uring_task *task, int res)
+static void uring_splice_test_cb(struct uring_task *task, int res)
 {
 	struct uring_ev *uring = container_of(task, struct uring_ev, task);
 
@@ -634,12 +611,11 @@ uring_splice_test_cb(struct uring_task *task, int res)
 		debug(DBG_UR, "splice supported");
 	} else if (res == -EINVAL)
 		debug(DBG_UR, "splice not supported");
-	else 
+	else
 		error("splice check failed: %i\n", res);
 }
 
-void
-uring_init()
+void uring_init()
 {
 	struct uring_ev *uring;
 
@@ -649,7 +625,8 @@ uring_init()
 	if (!uring)
 		die("malloc: %m");
 
-	if (io_uring_queue_init_params(4096, &uring->uring, &uring->uring_params) < 0)
+	if (io_uring_queue_init_params(4096, &uring->uring,
+				       &uring->uring_params) < 0)
 		die("io_uring_queue_init_params");
 
 	debug(DBG_UR, "uring initialized, features: 0x%08x",
@@ -665,28 +642,23 @@ uring_init()
 	uring->tfd = open("/dev/null", O_RDONLY | O_CLOEXEC | O_NOCTTY);
 	if (uring->tfd < 0)
 		die("open(\"/dev/null\"): %m");
-	uring_splice(&uring->task, uring->tfd, uring->pipe[PIPE_WR], uring_splice_test_cb);
+	uring_splice(&uring->task, uring->tfd, uring->pipe[PIPE_WR],
+		     uring_splice_test_cb);
 }
 
-static inline void
-uring_print_cqe(const char *type, struct uring_task *task,
-		struct io_uring_cqe *cqe)
+static inline void uring_print_cqe(const char *type, struct uring_task *task,
+				   struct io_uring_cqe *cqe)
 {
 	assert_return(!empty_str(type) && task && cqe);
 
-	debug(DBG_UR, "got CQE "
+	debug(DBG_UR,
+	      "got CQE "
 	      "(type: %s, res: %i (%s), task: %s (%p), fd: %i, cb: %p)",
-	      type,
-	      cqe->res,
-	      cqe->res < 0 ? strerror(-cqe->res) : "ok",
-	      task->name ? task->name : "<none>",
-	      task,
-	      task->fd,
-	      task->cb);
+	      type, cqe->res, cqe->res < 0 ? strerror(-cqe->res) : "ok",
+	      task->name ? task->name : "<none>", task, task->fd, task->cb);
 }
 
-void
-uring_event_loop()
+void uring_event_loop()
 {
 	while (true) {
 		struct io_uring_cqe *cqe;
@@ -703,7 +675,8 @@ uring_event_loop()
 		}
 
 		nr = 0;
-		io_uring_for_each_cqe(&cfg->uring->uring, head, cqe) {
+		io_uring_for_each_cqe(&cfg->uring->uring, head, cqe)
+		{
 			struct uring_task *task = io_uring_cqe_get_data(cqe);
 			bool do_cb;
 			enum cqe_type cqe_type;
@@ -755,4 +728,3 @@ uring_event_loop()
 		io_uring_cq_advance(&cfg->uring->uring, nr);
 	}
 }
-