libbpf: Use dynamically allocated buffer when receiving netlink messages
Subsystems (4)
PATCH v2 1/1 libbpf: Use dynamically allocated buffer when receiving netlink messages
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
Fix this by switching to a dynamically allocated buffer; we borrow the approach from iproute2 of using recvmsg() with MSG_PEEK|MSG_TRUNC to get the actual size of the pending message before receiving it, adjusting the buffer as necessary. While we're at it, also add retries on interrupted system calls around the recvmsg() call.
v2:
- Move peek logic to libbpf_netlink_recv(), don't double free on ENOMEM.
--- tools/lib/bpf/netlink.c | 55 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 4 deletions(-)
tools/lib/bpf/netlink.c +51 -4
@@ -87,29 +87,75 @@ enum { NL_DONE, }; +static int netlink_recvmsg (int sock,struct msghdr *mhdr,int flags) +{ +int len; + +do { + len =recvmsg (sock, mhdr, flags); + }while (len <0 && (errno ==EINTR || errno ==EAGAIN )); + +if (len <0 ) +return -errno; +return len; +} + +static int alloc_iov (struct iovec *iov,int len) +{ +void *nbuf; + + nbuf =realloc (iov->iov_base, len); +if (!nbuf) +return -ENOMEM ; + + iov->iov_base = nbuf; + iov->iov_len = len; +return 0 ; +} +static int libbpf_netlink_recv (int sock,__u32 nl_pid,int seq,__dump_nlmsg_t _fn,libbpf_dump_nlmsg_t fn,void *cookie) { +struct iovec iov = {}; +struct msghdr mhdr = { + .msg_iov = &iov, + .msg_iovlen =1 , + };bool multipart = true;struct nlmsgerr *err;struct nlmsghdr *nh; -char buf[4096 ];int len, ret; + ret =alloc_iov (&iov,4096 ); +if (ret) + goto done; +while (multipart) { start: multipart = false; - len =recv (sock, buf,sizeof (buf),0 ); + len =netlink_recvmsg (sock, &mhdr,MSG_PEEK |MSG_TRUNC ); +if (len <0 ) { + ret = len; + goto done; + } + +if (len > iov.iov_len) { + ret =alloc_iov (&iov, len); +if (ret) + goto done; + } + + len =netlink_recvmsg (sock, &mhdr,0 );if (len <0 ) { - ret = -errno; + ret = len; goto done; }if (len ==0 )break ; -for (nh = (struct nlmsghdr *)buf;NLMSG_OK (nh, len); +for (nh = (struct nlmsghdr *)iov.iov_base;NLMSG_OK (nh, len); nh =NLMSG_NEXT (nh, len)) {if (nh->nlmsg_pid != nl_pid) { ret = -LIBBPF_ERRNO__WRNGPID ;
@@ -151,6 +197,7 @@ static int libbpf_netlink_recv(int sock, __u32 nl_pid, int seq, } ret =0 ; done: +free (iov.iov_base);return ret; }
Signature · 1 line
2.35.1
Quoted 14 lines · Toke Høiland-Jørgensen
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
Fix this by switching to a dynamically allocated buffer; we borrow the approach from iproute2 of using
recvmsg()with MSG_PEEK|MSG_TRUNC to get the actual size of the pending message before receiving it, adjusting the buffer as necessary. While we're at it, also add retries on interrupted system calls around therecvmsg()call.
Quoted 8 lines
v2:
- Move peek logic tolibbpf_netlink_recv(), don't double free on ENOMEM.Reported-by Zhiqian Guan <[email protected]>Fixes 8bbb77b7c7a2 ("libbpf: Add various netlink helpers")Signed-off-by Toke Høiland-Jørgensen <[email protected]>---
Applied to bpf-next. One improvement would be to avoid initial malloc of 4096, especially if that size is enough for most cases. You could detect this through iov.iov_base == buf and not free(iov.iov_base) at the end. Seems reliable and simple enough. I'll leave it up to you to follow up, if you think it's a good idea.
Quoted 98 lines
tools/lib/bpf/netlink.c | 55 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 4 deletions(-)tools/lib/bpf/netlink.c +51
-5@@ -87,29 +87,75 @@ enum { NL_DONE, }; +static int netlink_recvmsg (int sock,struct msghdr *mhdr,int flags) +{ +int len; + +do { + len =recvmsg (sock, mhdr, flags); + }while (len <0 && (errno ==EINTR || errno ==EAGAIN )); + +if (len <0 ) +return -errno; +return len; +} + +static int alloc_iov (struct iovec *iov,int len) +{ +void *nbuf; + + nbuf =realloc (iov->iov_base, len); +if (!nbuf) +return -ENOMEM ; + + iov->iov_base = nbuf; + iov->iov_len = len; +return 0 ; +} +static int libbpf_netlink_recv (int sock,__u32 nl_pid,int seq,__dump_nlmsg_t _fn,libbpf_dump_nlmsg_t fn,void *cookie) { +struct iovec iov = {}; +struct msghdr mhdr = { + .msg_iov = &iov, + .msg_iovlen =1 , + };bool multipart = true;struct nlmsgerr *err;struct nlmsghdr *nh; -char buf[4096 ];int len, ret; + ret =alloc_iov (&iov,4096 ); +if (ret) + goto done; +while (multipart) { start: multipart = false; - len =recv (sock, buf,sizeof (buf),0 ); + len =netlink_recvmsg (sock, &mhdr,MSG_PEEK |MSG_TRUNC ); +if (len <0 ) { + ret = len; + goto done; + } + +if (len > iov.iov_len) { + ret =alloc_iov (&iov, len); +if (ret) + goto done; + } + + len =netlink_recvmsg (sock, &mhdr,0 );if (len <0 ) { - ret = -errno; + ret = len; goto done; }if (len ==0 )break ; -for (nh = (struct nlmsghdr *)buf;NLMSG_OK (nh, len); +for (nh = (struct nlmsghdr *)iov.iov_base;NLMSG_OK (nh, len); nh =NLMSG_NEXT (nh, len)) {if (nh->nlmsg_pid != nl_pid) { ret = -LIBBPF_ERRNO__WRNGPID ;@@ -151,6 +197,7 @@ static int libbpf_netlink_recv(int sock, __u32 nl_pid, int seq, } ret =0 ; done: +free (iov.iov_base);return ret; } --2.35.1
Quoted 18 lines · Andrii Nakryiko
Quoted 17 lines · Toke Høiland-Jørgensen
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
Fix this by switching to a dynamically allocated buffer; we borrow the approach from iproute2 of using
recvmsg()with MSG_PEEK|MSG_TRUNC to get the actual size of the pending message before receiving it, adjusting the buffer as necessary. While we're at it, also add retries on interrupted system calls around therecvmsg()call.v2:
- Move peek logic tolibbpf_netlink_recv(), don't double free on ENOMEM.
Quoted 7 lines
Quoted 5 lines
Reported-by Zhiqian Guan <[email protected]>Fixes 8bbb77b7c7a2 ("libbpf: Add various netlink helpers")Signed-off-by Toke Høiland-Jørgensen <[email protected]>---
Applied to bpf-next.
Awesome, thanks!
Quoted 5 lines
One improvement would be to avoid initial malloc of 4096, especially if that size is enough for most cases. You could detect this through iov.iov_base == buf and not
free(iov.iov_base)at the end. Seems reliable and simple enough. I'll leave it up to you to follow up, if you think it's a good idea.
Hmm, seems distributions tend to default the stack size limit to 8k; so not sure if blowing half of that on a buffer just to avoid a call to malloc() in a non-performance-sensitive is ideal to begin with? I think I'd prefer to just keep the dynamic allocation...
-Toke
Quoted 37 lines · Toke Høiland-Jørgensen
Quoted 18 lines · Andrii Nakryiko
Quoted 17 lines · Toke Høiland-Jørgensen
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
Fix this by switching to a dynamically allocated buffer; we borrow the approach from iproute2 of using
recvmsg()with MSG_PEEK|MSG_TRUNC to get the actual size of the pending message before receiving it, adjusting the buffer as necessary. While we're at it, also add retries on interrupted system calls around therecvmsg()call.v2:
- Move peek logic tolibbpf_netlink_recv(), don't double free on ENOMEM.Quoted 7 lines
Quoted 5 lines
Reported-by Zhiqian Guan <[email protected]>Fixes 8bbb77b7c7a2 ("libbpf: Add various netlink helpers")Signed-off-by Toke Høiland-Jørgensen <[email protected]>---
Applied to bpf-next.
Awesome, thanks!
Quoted 5 lines
One improvement would be to avoid initial malloc of 4096, especially if that size is enough for most cases. You could detect this through iov.iov_base == buf and not
free(iov.iov_base)at the end. Seems reliable and simple enough. I'll leave it up to you to follow up, if you think it's a good idea.
Quoted 4 lines
Hmm, seems distributions tend to default the stack size limit to 8k; so not sure if blowing half of that on a buffer just to avoid a call to
malloc()in a non-performance-sensitive is ideal to begin with? I think I'd prefer to just keep the dynamic allocation...
8KB for user-space thread stack, really? Not 2MB by default? Are you sure you are not confusing this with kernel threads?
Quoted 3 lines
-Toke
Quoted 38 lines · Andrii Nakryiko
Quoted 37 lines · Toke Høiland-Jørgensen
Quoted 18 lines · Andrii Nakryiko
Quoted 17 lines · Toke Høiland-Jørgensen
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
Fix this by switching to a dynamically allocated buffer; we borrow the approach from iproute2 of using
recvmsg()with MSG_PEEK|MSG_TRUNC to get the actual size of the pending message before receiving it, adjusting the buffer as necessary. While we're at it, also add retries on interrupted system calls around therecvmsg()call.v2:
- Move peek logic tolibbpf_netlink_recv(), don't double free on ENOMEM.Quoted 7 lines
Quoted 5 lines
Reported-by Zhiqian Guan <[email protected]>Fixes 8bbb77b7c7a2 ("libbpf: Add various netlink helpers")Signed-off-by Toke Høiland-Jørgensen <[email protected]>---
Applied to bpf-next.
Awesome, thanks!
Quoted 5 lines
One improvement would be to avoid initial malloc of 4096, especially if that size is enough for most cases. You could detect this through iov.iov_base == buf and not
free(iov.iov_base)at the end. Seems reliable and simple enough. I'll leave it up to you to follow up, if you think it's a good idea.
Quoted 7 lines
Quoted 4 lines
Hmm, seems distributions tend to default the stack size limit to 8k; so not sure if blowing half of that on a buffer just to avoid a call to
malloc()in a non-performance-sensitive is ideal to begin with? I think I'd prefer to just keep the dynamic allocation...8KB for user-space thread stack, really? Not 2MB by default? Are you sure you are not confusing this with kernel threads?
Ha, oops! I was looking in the right place, just got the units wrong; those were kbytes not bytes, so 8M stack size. Sorry for the confusion :)
-Toke
This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Hello:
This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Quoted 8 lines · On Sat, 12 Feb 2022 00:48:19 +0100 you wrote:
When receiving netlink messages, libbpf was using a statically allocated stack buffer of 4k bytes. This happened to work fine on systems with a 4k page size, but on systems with larger page sizes it can lead to truncated messages. The user-visible impact of this was that libbpf would insist no XDP program was attached to some interfaces because that bit of the netlink message got chopped off.
[...]
Here is the summary with links:
- [bpf-next,v2] libbpf: Use dynamically allocated buffer when receiving netlink messages
https://git.kernel.org/bpf/bpf-next/c/9c3de619e13e
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html