MT#55283 type safety for uring allocs

Change-Id: I1f1e49b986f7a2cd83b898167e0c314b8862bb69

daemon/media_player.c

@@ -356,7 +356,7 @@ static bool __send_timer_send_1(struct rtp_header *rh, struct packet_stream *sin
 				endpoint_print_buf(&sink_fd->socket.local),
 				FMT_M(endpoint_print_buf(&sink->endpoint)));
 
-	struct async_send_req *req = uring_alloc_req(sizeof(*req), async_send_req_free);
+	struct async_send_req *req = uring_alloc_req(struct async_send_req, async_send_req_free);
 	req->iov = (__typeof(req->iov)) {
 		.iov_base = cp->s.s,
 		.iov_len = cp->s.len,

daemon/stun.c

@@ -684,7 +684,7 @@ int stun_binding_request(const endpoint_t *dst, uint32_t transaction[3], str *pw
 		str ufrags[2], int controlling, uint64_t tiebreaker, uint32_t priority,
 		socket_t *sock, int to_use)
 {
-	struct async_stun_req *r = uring_alloc_buffer_req(sizeof(*r));
+	struct async_stun_req *r = uring_alloc_buffer_req(struct async_stun_req);
 	int i;
 
 	output_init(&r->mh, r->iov, &r->hdr, STUN_BINDING_REQUEST, transaction);

lib/uring.c

@@ -65,6 +65,10 @@ __thread __typeof(__socket_sendmsg) (*uring_sendmsg) = __socket_sendmsg;
 #include <liburing.h>
 
 
+struct uring_buffer_req {
+	struct uring_req req;
+};
+
 static __thread struct io_uring rtpe_uring;
 
 
@@ -438,7 +442,7 @@ static void uring_poller_do_add(struct poller *p, struct poller_req *preq) {
 	if (p->evs->len > preq->it.fd && p->evs->pdata[preq->it.fd])
 		abort(); // XXX handle gracefully?
 	struct uring_poll_event *ereq
-		= uring_alloc_req(sizeof(*ereq), uring_poll_event);
+		= uring_alloc_req(struct uring_poll_event, uring_poll_event);
 	ereq->it = preq->it;
 	ereq->poller = p;
 	struct io_uring_sqe *sqe = io_uring_get_sqe(&rtpe_uring);
@@ -455,7 +459,7 @@ static void uring_poller_do_blocked(struct poller *p, struct poller_req *preq) {
 		abort(); // XXX handle gracefully?
 	struct uring_poll_event *ereq = p->evs->pdata[preq->fd];
 	struct uring_poll_unblocked *ureq
-		= uring_alloc_req(sizeof(*ureq), uring_poll_unblocked);
+		= uring_alloc_req(struct uring_poll_unblocked, uring_poll_unblocked);
 	ureq->it = ereq->it;
 	ureq->poller = p;
 	if (ureq->it.obj)
@@ -470,7 +474,7 @@ static void uring_poller_do_error(struct poller *p, struct poller_req *preq) {
 static void uring_poller_do_del(struct poller *p, struct poller_req *preq) {
 	//ilog(LOG_INFO, "del fd %i on %p", preq->fd, p);
 	struct uring_poll_removed *rreq
-		= uring_alloc_req(sizeof(*rreq), uring_poll_removed);
+		= uring_alloc_req(struct uring_poll_removed, uring_poll_removed);
 	rreq->fd = preq->fd;
 	rreq->poller = p;
 	rreq->callback = preq->callback;
@@ -484,13 +488,13 @@ static void uring_poller_do_buffers(struct poller *p, struct poller_req *preq) {
 	struct io_uring_sqe *sqe = io_uring_get_sqe(&rtpe_uring);
 	io_uring_prep_provide_buffers(sqe, preq->buf, BUFFER_SIZE, BUFFERS_COUNT, 0,
 			preq->num * BUFFERS_COUNT);
-	struct uring_req *breq = uring_alloc_buffer_req(sizeof(*breq));
+	struct uring_buffer_req *breq = uring_alloc_buffer_req(struct uring_buffer_req);
 	io_uring_sqe_set_data(sqe, breq); // XXX no content? not needed?
 }
 static void uring_poller_do_recv(struct poller *p, struct poller_req *preq) {
 	//ilog(LOG_INFO, "adding recv fd %i on %p for %p", preq->it.fd, p, preq->it.obj);
 	struct uring_poll_recv *rreq
-		= uring_alloc_req(sizeof(*rreq), uring_poll_recv);
+		= uring_alloc_req(struct uring_poll_recv, uring_poll_recv);
 	rreq->it = preq->it;
 	rreq->poller = p;
 	struct io_uring_sqe *sqe = io_uring_get_sqe(&rtpe_uring);
@@ -575,7 +579,7 @@ void uring_poller_poll(struct poller *p) {
 }
 
 void uring_poller_clear(struct poller *p) {
-	struct uring_req *req = uring_alloc_buffer_req(sizeof(*req));
+	struct uring_buffer_req *req = uring_alloc_buffer_req(struct uring_buffer_req);
 	struct io_uring_sqe *sqe = io_uring_get_sqe(&rtpe_uring);
 	io_uring_prep_cancel(sqe, 0, IORING_ASYNC_CANCEL_ANY);
 	io_uring_sqe_set_data(sqe, req);

lib/uring.h

@@ -21,15 +21,14 @@ INLINE void uring_req_free(struct uring_req *r) {
 	g_free(r);
 }
 
-INLINE void *uring_alloc_req(size_t len, uring_req_handler_fn *fn) {
-	struct uring_req *ret = g_malloc0(len);
-	ret->handler = fn;
-	return ret;
-}
+#define uring_alloc_req(T, fn) ({ \
+			T *__ret = g_new0(T, 1); \
+			__ret->req.handler = (fn); \
+			__ret; \
+		})
+
+#define uring_alloc_buffer_req(T) uring_alloc_req(T, uring_req_buffer_free)
 
-INLINE void *uring_alloc_buffer_req(size_t len) {
-	return uring_alloc_req(len, uring_req_buffer_free);
-}
 
 #ifdef HAVE_LIBURING