mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 02:23:16 +00:00
457fed775c
As nlmsg_put() does not clear the memory that is reserved,
it this the caller responsability to make sure all of this
memory will be written, in order to not reveal prior content.
While we are at it, we can provide the socket cookie even
if clsock is not set.
syzbot reported :
BUG: KMSAN: uninit-value in __arch_swab32 arch/x86/include/uapi/asm/swab.h:10 [inline]
BUG: KMSAN: uninit-value in __fswab32 include/uapi/linux/swab.h:59 [inline]
BUG: KMSAN: uninit-value in __swab32p include/uapi/linux/swab.h:179 [inline]
BUG: KMSAN: uninit-value in __be32_to_cpup include/uapi/linux/byteorder/little_endian.h:82 [inline]
BUG: KMSAN: uninit-value in get_unaligned_be32 include/linux/unaligned/access_ok.h:30 [inline]
BUG: KMSAN: uninit-value in ____bpf_skb_load_helper_32 net/core/filter.c:240 [inline]
BUG: KMSAN: uninit-value in ____bpf_skb_load_helper_32_no_cache net/core/filter.c:255 [inline]
BUG: KMSAN: uninit-value in bpf_skb_load_helper_32_no_cache+0x14a/0x390 net/core/filter.c:252
CPU: 1 PID: 5262 Comm: syz-executor.5 Not tainted 5.5.0-rc5-syzkaller #0
Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011
Call Trace:
__dump_stack lib/dump_stack.c:77 [inline]
dump_stack+0x1c9/0x220 lib/dump_stack.c:118
kmsan_report+0xf7/0x1e0 mm/kmsan/kmsan_report.c:118
__msan_warning+0x58/0xa0 mm/kmsan/kmsan_instr.c:215
__arch_swab32 arch/x86/include/uapi/asm/swab.h:10 [inline]
__fswab32 include/uapi/linux/swab.h:59 [inline]
__swab32p include/uapi/linux/swab.h:179 [inline]
__be32_to_cpup include/uapi/linux/byteorder/little_endian.h:82 [inline]
get_unaligned_be32 include/linux/unaligned/access_ok.h:30 [inline]
____bpf_skb_load_helper_32 net/core/filter.c:240 [inline]
____bpf_skb_load_helper_32_no_cache net/core/filter.c:255 [inline]
bpf_skb_load_helper_32_no_cache+0x14a/0x390 net/core/filter.c:252
Uninit was created at:
kmsan_save_stack_with_flags mm/kmsan/kmsan.c:144 [inline]
kmsan_internal_poison_shadow+0x66/0xd0 mm/kmsan/kmsan.c:127
kmsan_kmalloc_large+0x73/0xc0 mm/kmsan/kmsan_hooks.c:128
kmalloc_large_node_hook mm/slub.c:1406 [inline]
kmalloc_large_node+0x282/0x2c0 mm/slub.c:3841
__kmalloc_node_track_caller+0x44b/0x1200 mm/slub.c:4368
__kmalloc_reserve net/core/skbuff.c:141 [inline]
__alloc_skb+0x2fd/0xac0 net/core/skbuff.c:209
alloc_skb include/linux/skbuff.h:1049 [inline]
netlink_dump+0x44b/0x1ab0 net/netlink/af_netlink.c:2224
__netlink_dump_start+0xbb2/0xcf0 net/netlink/af_netlink.c:2352
netlink_dump_start include/linux/netlink.h:233 [inline]
smc_diag_handler_dump+0x2ba/0x300 net/smc/smc_diag.c:242
sock_diag_rcv_msg+0x211/0x610 net/core/sock_diag.c:256
netlink_rcv_skb+0x451/0x650 net/netlink/af_netlink.c:2477
sock_diag_rcv+0x63/0x80 net/core/sock_diag.c:275
netlink_unicast_kernel net/netlink/af_netlink.c:1302 [inline]
netlink_unicast+0xf9e/0x1100 net/netlink/af_netlink.c:1328
netlink_sendmsg+0x1248/0x14d0 net/netlink/af_netlink.c:1917
sock_sendmsg_nosec net/socket.c:639 [inline]
sock_sendmsg net/socket.c:659 [inline]
kernel_sendmsg+0x433/0x440 net/socket.c:679
sock_no_sendpage+0x235/0x300 net/core/sock.c:2740
kernel_sendpage net/socket.c:3776 [inline]
sock_sendpage+0x1e1/0x2c0 net/socket.c:937
pipe_to_sendpage+0x38c/0x4c0 fs/splice.c:458
splice_from_pipe_feed fs/splice.c:512 [inline]
__splice_from_pipe+0x539/0xed0 fs/splice.c:636
splice_from_pipe fs/splice.c:671 [inline]
generic_splice_sendpage+0x1d5/0x2d0 fs/splice.c:844
do_splice_from fs/splice.c:863 [inline]
do_splice fs/splice.c:1170 [inline]
__do_sys_splice fs/splice.c:1447 [inline]
__se_sys_splice+0x2380/0x3350 fs/splice.c:1427
__x64_sys_splice+0x6e/0x90 fs/splice.c:1427
do_syscall_64+0xb8/0x160 arch/x86/entry/common.c:296
entry_SYSCALL_64_after_hwframe+0x44/0xa9
Fixes: f16a7dd5cf
("smc: netlink interface for SMC sockets")
Signed-off-by: Eric Dumazet <edumazet@google.com>
Cc: Ursula Braun <ubraun@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
266 lines
7.4 KiB
C
266 lines
7.4 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Shared Memory Communications over RDMA (SMC-R) and RoCE
|
|
*
|
|
* Monitoring SMC transport protocol sockets
|
|
*
|
|
* Copyright IBM Corp. 2016
|
|
*
|
|
* Author(s): Ursula Braun <ubraun@linux.vnet.ibm.com>
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sock_diag.h>
|
|
#include <linux/inet_diag.h>
|
|
#include <linux/smc_diag.h>
|
|
#include <net/netlink.h>
|
|
#include <net/smc.h>
|
|
|
|
#include "smc.h"
|
|
#include "smc_core.h"
|
|
|
|
static void smc_gid_be16_convert(__u8 *buf, u8 *gid_raw)
|
|
{
|
|
sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
|
|
be16_to_cpu(((__be16 *)gid_raw)[0]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[1]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[2]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[3]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[4]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[5]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[6]),
|
|
be16_to_cpu(((__be16 *)gid_raw)[7]));
|
|
}
|
|
|
|
static void smc_diag_msg_common_fill(struct smc_diag_msg *r, struct sock *sk)
|
|
{
|
|
struct smc_sock *smc = smc_sk(sk);
|
|
|
|
memset(r, 0, sizeof(*r));
|
|
r->diag_family = sk->sk_family;
|
|
sock_diag_save_cookie(sk, r->id.idiag_cookie);
|
|
if (!smc->clcsock)
|
|
return;
|
|
r->id.idiag_sport = htons(smc->clcsock->sk->sk_num);
|
|
r->id.idiag_dport = smc->clcsock->sk->sk_dport;
|
|
r->id.idiag_if = smc->clcsock->sk->sk_bound_dev_if;
|
|
if (sk->sk_protocol == SMCPROTO_SMC) {
|
|
r->id.idiag_src[0] = smc->clcsock->sk->sk_rcv_saddr;
|
|
r->id.idiag_dst[0] = smc->clcsock->sk->sk_daddr;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
} else if (sk->sk_protocol == SMCPROTO_SMC6) {
|
|
memcpy(&r->id.idiag_src, &smc->clcsock->sk->sk_v6_rcv_saddr,
|
|
sizeof(smc->clcsock->sk->sk_v6_rcv_saddr));
|
|
memcpy(&r->id.idiag_dst, &smc->clcsock->sk->sk_v6_daddr,
|
|
sizeof(smc->clcsock->sk->sk_v6_daddr));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static int smc_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
|
|
struct smc_diag_msg *r,
|
|
struct user_namespace *user_ns)
|
|
{
|
|
if (nla_put_u8(skb, SMC_DIAG_SHUTDOWN, sk->sk_shutdown))
|
|
return 1;
|
|
|
|
r->diag_uid = from_kuid_munged(user_ns, sock_i_uid(sk));
|
|
r->diag_inode = sock_i_ino(sk);
|
|
return 0;
|
|
}
|
|
|
|
static int __smc_diag_dump(struct sock *sk, struct sk_buff *skb,
|
|
struct netlink_callback *cb,
|
|
const struct smc_diag_req *req,
|
|
struct nlattr *bc)
|
|
{
|
|
struct smc_sock *smc = smc_sk(sk);
|
|
struct smc_diag_fallback fallback;
|
|
struct user_namespace *user_ns;
|
|
struct smc_diag_msg *r;
|
|
struct nlmsghdr *nlh;
|
|
|
|
nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
|
|
cb->nlh->nlmsg_type, sizeof(*r), NLM_F_MULTI);
|
|
if (!nlh)
|
|
return -EMSGSIZE;
|
|
|
|
r = nlmsg_data(nlh);
|
|
smc_diag_msg_common_fill(r, sk);
|
|
r->diag_state = sk->sk_state;
|
|
if (smc->use_fallback)
|
|
r->diag_mode = SMC_DIAG_MODE_FALLBACK_TCP;
|
|
else if (smc->conn.lgr && smc->conn.lgr->is_smcd)
|
|
r->diag_mode = SMC_DIAG_MODE_SMCD;
|
|
else
|
|
r->diag_mode = SMC_DIAG_MODE_SMCR;
|
|
user_ns = sk_user_ns(NETLINK_CB(cb->skb).sk);
|
|
if (smc_diag_msg_attrs_fill(sk, skb, r, user_ns))
|
|
goto errout;
|
|
|
|
fallback.reason = smc->fallback_rsn;
|
|
fallback.peer_diagnosis = smc->peer_diagnosis;
|
|
if (nla_put(skb, SMC_DIAG_FALLBACK, sizeof(fallback), &fallback) < 0)
|
|
goto errout;
|
|
|
|
if ((req->diag_ext & (1 << (SMC_DIAG_CONNINFO - 1))) &&
|
|
smc->conn.alert_token_local) {
|
|
struct smc_connection *conn = &smc->conn;
|
|
struct smc_diag_conninfo cinfo = {
|
|
.token = conn->alert_token_local,
|
|
.sndbuf_size = conn->sndbuf_desc ?
|
|
conn->sndbuf_desc->len : 0,
|
|
.rmbe_size = conn->rmb_desc ? conn->rmb_desc->len : 0,
|
|
.peer_rmbe_size = conn->peer_rmbe_size,
|
|
|
|
.rx_prod.wrap = conn->local_rx_ctrl.prod.wrap,
|
|
.rx_prod.count = conn->local_rx_ctrl.prod.count,
|
|
.rx_cons.wrap = conn->local_rx_ctrl.cons.wrap,
|
|
.rx_cons.count = conn->local_rx_ctrl.cons.count,
|
|
|
|
.tx_prod.wrap = conn->local_tx_ctrl.prod.wrap,
|
|
.tx_prod.count = conn->local_tx_ctrl.prod.count,
|
|
.tx_cons.wrap = conn->local_tx_ctrl.cons.wrap,
|
|
.tx_cons.count = conn->local_tx_ctrl.cons.count,
|
|
|
|
.tx_prod_flags =
|
|
*(u8 *)&conn->local_tx_ctrl.prod_flags,
|
|
.tx_conn_state_flags =
|
|
*(u8 *)&conn->local_tx_ctrl.conn_state_flags,
|
|
.rx_prod_flags = *(u8 *)&conn->local_rx_ctrl.prod_flags,
|
|
.rx_conn_state_flags =
|
|
*(u8 *)&conn->local_rx_ctrl.conn_state_flags,
|
|
|
|
.tx_prep.wrap = conn->tx_curs_prep.wrap,
|
|
.tx_prep.count = conn->tx_curs_prep.count,
|
|
.tx_sent.wrap = conn->tx_curs_sent.wrap,
|
|
.tx_sent.count = conn->tx_curs_sent.count,
|
|
.tx_fin.wrap = conn->tx_curs_fin.wrap,
|
|
.tx_fin.count = conn->tx_curs_fin.count,
|
|
};
|
|
|
|
if (nla_put(skb, SMC_DIAG_CONNINFO, sizeof(cinfo), &cinfo) < 0)
|
|
goto errout;
|
|
}
|
|
|
|
if (smc->conn.lgr && !smc->conn.lgr->is_smcd &&
|
|
(req->diag_ext & (1 << (SMC_DIAG_LGRINFO - 1))) &&
|
|
!list_empty(&smc->conn.lgr->list)) {
|
|
struct smc_diag_lgrinfo linfo = {
|
|
.role = smc->conn.lgr->role,
|
|
.lnk[0].ibport = smc->conn.lgr->lnk[0].ibport,
|
|
.lnk[0].link_id = smc->conn.lgr->lnk[0].link_id,
|
|
};
|
|
|
|
memcpy(linfo.lnk[0].ibname,
|
|
smc->conn.lgr->lnk[0].smcibdev->ibdev->name,
|
|
sizeof(smc->conn.lgr->lnk[0].smcibdev->ibdev->name));
|
|
smc_gid_be16_convert(linfo.lnk[0].gid,
|
|
smc->conn.lgr->lnk[0].gid);
|
|
smc_gid_be16_convert(linfo.lnk[0].peer_gid,
|
|
smc->conn.lgr->lnk[0].peer_gid);
|
|
|
|
if (nla_put(skb, SMC_DIAG_LGRINFO, sizeof(linfo), &linfo) < 0)
|
|
goto errout;
|
|
}
|
|
if (smc->conn.lgr && smc->conn.lgr->is_smcd &&
|
|
(req->diag_ext & (1 << (SMC_DIAG_DMBINFO - 1))) &&
|
|
!list_empty(&smc->conn.lgr->list)) {
|
|
struct smc_connection *conn = &smc->conn;
|
|
struct smcd_diag_dmbinfo dinfo = {
|
|
.linkid = *((u32 *)conn->lgr->id),
|
|
.peer_gid = conn->lgr->peer_gid,
|
|
.my_gid = conn->lgr->smcd->local_gid,
|
|
.token = conn->rmb_desc->token,
|
|
.peer_token = conn->peer_token
|
|
};
|
|
|
|
if (nla_put(skb, SMC_DIAG_DMBINFO, sizeof(dinfo), &dinfo) < 0)
|
|
goto errout;
|
|
}
|
|
|
|
nlmsg_end(skb, nlh);
|
|
return 0;
|
|
|
|
errout:
|
|
nlmsg_cancel(skb, nlh);
|
|
return -EMSGSIZE;
|
|
}
|
|
|
|
static int smc_diag_dump_proto(struct proto *prot, struct sk_buff *skb,
|
|
struct netlink_callback *cb)
|
|
{
|
|
struct net *net = sock_net(skb->sk);
|
|
struct nlattr *bc = NULL;
|
|
struct hlist_head *head;
|
|
struct sock *sk;
|
|
int rc = 0;
|
|
|
|
read_lock(&prot->h.smc_hash->lock);
|
|
head = &prot->h.smc_hash->ht;
|
|
if (hlist_empty(head))
|
|
goto out;
|
|
|
|
sk_for_each(sk, head) {
|
|
if (!net_eq(sock_net(sk), net))
|
|
continue;
|
|
rc = __smc_diag_dump(sk, skb, cb, nlmsg_data(cb->nlh), bc);
|
|
if (rc)
|
|
break;
|
|
}
|
|
|
|
out:
|
|
read_unlock(&prot->h.smc_hash->lock);
|
|
return rc;
|
|
}
|
|
|
|
static int smc_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = smc_diag_dump_proto(&smc_proto, skb, cb);
|
|
if (!rc)
|
|
rc = smc_diag_dump_proto(&smc_proto6, skb, cb);
|
|
return rc;
|
|
}
|
|
|
|
static int smc_diag_handler_dump(struct sk_buff *skb, struct nlmsghdr *h)
|
|
{
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
if (h->nlmsg_type == SOCK_DIAG_BY_FAMILY &&
|
|
h->nlmsg_flags & NLM_F_DUMP) {
|
|
{
|
|
struct netlink_dump_control c = {
|
|
.dump = smc_diag_dump,
|
|
.min_dump_alloc = SKB_WITH_OVERHEAD(32768),
|
|
};
|
|
return netlink_dump_start(net->diag_nlsk, skb, h, &c);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const struct sock_diag_handler smc_diag_handler = {
|
|
.family = AF_SMC,
|
|
.dump = smc_diag_handler_dump,
|
|
};
|
|
|
|
static int __init smc_diag_init(void)
|
|
{
|
|
return sock_diag_register(&smc_diag_handler);
|
|
}
|
|
|
|
static void __exit smc_diag_exit(void)
|
|
{
|
|
sock_diag_unregister(&smc_diag_handler);
|
|
}
|
|
|
|
module_init(smc_diag_init);
|
|
module_exit(smc_diag_exit);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 43 /* AF_SMC */);
|