141 lines
3.3 KiB
C
141 lines
3.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Shared Memory Communications over RDMA (SMC-R) and RoCE
|
|
*
|
|
* Generic hook for SMC handshake flow.
|
|
*
|
|
* Copyright IBM Corp. 2016
|
|
* Copyright (c) 2025, Alibaba Inc.
|
|
*
|
|
* Author: D. Wythe <alibuda@linux.alibaba.com>
|
|
*/
|
|
|
|
#include <linux/bpf_verifier.h>
|
|
#include <linux/bpf.h>
|
|
#include <linux/btf.h>
|
|
#include <linux/rculist.h>
|
|
|
|
#include "smc_hs_bpf.h"
|
|
|
|
static DEFINE_SPINLOCK(smc_hs_ctrl_list_lock);
|
|
static LIST_HEAD(smc_hs_ctrl_list);
|
|
|
|
static int smc_hs_ctrl_reg(struct smc_hs_ctrl *ctrl)
|
|
{
|
|
int ret = 0;
|
|
|
|
spin_lock(&smc_hs_ctrl_list_lock);
|
|
/* already exist or duplicate name */
|
|
if (smc_hs_ctrl_find_by_name(ctrl->name))
|
|
ret = -EEXIST;
|
|
else
|
|
list_add_tail_rcu(&ctrl->list, &smc_hs_ctrl_list);
|
|
spin_unlock(&smc_hs_ctrl_list_lock);
|
|
return ret;
|
|
}
|
|
|
|
static void smc_hs_ctrl_unreg(struct smc_hs_ctrl *ctrl)
|
|
{
|
|
spin_lock(&smc_hs_ctrl_list_lock);
|
|
list_del_rcu(&ctrl->list);
|
|
spin_unlock(&smc_hs_ctrl_list_lock);
|
|
|
|
/* Ensure that all readers to complete */
|
|
synchronize_rcu();
|
|
}
|
|
|
|
struct smc_hs_ctrl *smc_hs_ctrl_find_by_name(const char *name)
|
|
{
|
|
struct smc_hs_ctrl *ctrl;
|
|
|
|
list_for_each_entry_rcu(ctrl, &smc_hs_ctrl_list, list) {
|
|
if (strcmp(ctrl->name, name) == 0)
|
|
return ctrl;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int __smc_bpf_stub_set_tcp_option(struct tcp_sock *tp) { return 1; }
|
|
static int __smc_bpf_stub_set_tcp_option_cond(const struct tcp_sock *tp,
|
|
struct inet_request_sock *ireq)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static struct smc_hs_ctrl __smc_bpf_hs_ctrl = {
|
|
.syn_option = __smc_bpf_stub_set_tcp_option,
|
|
.synack_option = __smc_bpf_stub_set_tcp_option_cond,
|
|
};
|
|
|
|
static int smc_bpf_hs_ctrl_init(struct btf *btf) { return 0; }
|
|
|
|
static int smc_bpf_hs_ctrl_reg(void *kdata, struct bpf_link *link)
|
|
{
|
|
if (link)
|
|
return -EOPNOTSUPP;
|
|
|
|
return smc_hs_ctrl_reg(kdata);
|
|
}
|
|
|
|
static void smc_bpf_hs_ctrl_unreg(void *kdata, struct bpf_link *link)
|
|
{
|
|
smc_hs_ctrl_unreg(kdata);
|
|
}
|
|
|
|
static int smc_bpf_hs_ctrl_init_member(const struct btf_type *t,
|
|
const struct btf_member *member,
|
|
void *kdata, const void *udata)
|
|
{
|
|
const struct smc_hs_ctrl *u_ctrl;
|
|
struct smc_hs_ctrl *k_ctrl;
|
|
u32 moff;
|
|
|
|
u_ctrl = (const struct smc_hs_ctrl *)udata;
|
|
k_ctrl = (struct smc_hs_ctrl *)kdata;
|
|
|
|
moff = __btf_member_bit_offset(t, member) / 8;
|
|
switch (moff) {
|
|
case offsetof(struct smc_hs_ctrl, name):
|
|
if (bpf_obj_name_cpy(k_ctrl->name, u_ctrl->name,
|
|
sizeof(u_ctrl->name)) <= 0)
|
|
return -EINVAL;
|
|
return 1;
|
|
case offsetof(struct smc_hs_ctrl, flags):
|
|
if (u_ctrl->flags & ~SMC_HS_CTRL_ALL_FLAGS)
|
|
return -EINVAL;
|
|
k_ctrl->flags = u_ctrl->flags;
|
|
return 1;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct bpf_func_proto *
|
|
bpf_smc_hs_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
|
|
{
|
|
return bpf_base_func_proto(func_id, prog);
|
|
}
|
|
|
|
static const struct bpf_verifier_ops smc_bpf_verifier_ops = {
|
|
.get_func_proto = bpf_smc_hs_func_proto,
|
|
.is_valid_access = bpf_tracing_btf_ctx_access,
|
|
};
|
|
|
|
static struct bpf_struct_ops bpf_smc_hs_ctrl_ops = {
|
|
.name = "smc_hs_ctrl",
|
|
.init = smc_bpf_hs_ctrl_init,
|
|
.reg = smc_bpf_hs_ctrl_reg,
|
|
.unreg = smc_bpf_hs_ctrl_unreg,
|
|
.cfi_stubs = &__smc_bpf_hs_ctrl,
|
|
.verifier_ops = &smc_bpf_verifier_ops,
|
|
.init_member = smc_bpf_hs_ctrl_init_member,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
int bpf_smc_hs_ctrl_init(void)
|
|
{
|
|
return register_bpf_struct_ops(&bpf_smc_hs_ctrl_ops, smc_hs_ctrl);
|
|
}
|