Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/mpls/af_mpls.c |
static int mpls_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
struct netlink_ext_ack *extack) {
struct mpls_route_config *cfg;
int err;
cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
if (!cfg)
return -ENOMEM;
err = rtm_to_route_config(skb, nlh, cfg, extack);
if (err <... | [
0,
0
] |
Linux Kernel | net/mpls/af_mpls.c | static int mpls_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,
struct fib_dump_filter *filter,
struct netlink_callback *cb) {
struct netlink_ext_ack *extack = cb->extack;
struct nlattr *tb[RTA_MAX + 1];
struct rtmsg *rtm;
int... | [
1,
0
] |
Linux Kernel | net/mpls/af_mpls.c | static inline size_t lfib_nlmsg_size(struct mpls_route *rt) {
size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg)) + nla_total_size(4) +
nla_total_size(1); /* RTA_TTL_PROPAGATE */
if (rt->rt_nhn == 1) {
struct mpls_nh *nh = rt->rt_nh;
if (nh->nh_dev)
payload += nla_total_size(4); ... | [
1,
0
] |
Linux Kernel | net/mpls/af_mpls.c | static int mpls_net_init(struct net *net) {
struct ctl_table *table;
int i;
net->mpls.platform_labels = 0;
net->mpls.platform_label = NULL;
net->mpls.ip_ttl_propagate = 1;
net->mpls.default_ttl = 255;
table = kmemdup(mpls_table, sizeof(mpls_table), GFP_KERNEL);
if (table == NULL)
return -ENOMEM;
... | [
1,
0
] |
Linux Kernel | net/mpls/af_mpls.c |
static int __init mpls_init(void) {
int err;
BUILD_BUG_ON(sizeof(struct mpls_shim_hdr) != 4);
err = register_pernet_subsys(&mpls_net_ops);
if (err)
goto out;
err = register_netdevice_notifier(&mpls_dev_notifier);
if (err)
goto out_unregister_pernet;
dev_add_pack(&mpls_packet_type);
rtnl_af... | [
0,
0
] |
Linux Kernel | net/mpls/mpls_iptunnel.c | static unsigned int mpls_encap_size(struct mpls_iptunnel_encap *en) {
return en->labels * sizeof(struct mpls_shim_hdr);
} | [
1,
0
] |
Linux Kernel | net/mptcp/crypto.c | void mptcp_crypto_hmac_sha(u64 key1, u64 key2, u8 *msg, int len, void *hmac) {
u8 input[SHA256_BLOCK_SIZE + SHA256_DIGEST_SIZE];
u8 key1be[8];
u8 key2be[8];
int i;
if (WARN_ON_ONCE(len > SHA256_DIGEST_SIZE))
len = SHA256_DIGEST_SIZE;
put_unaligned_be64(key1, key1be);
put_unaligned_be64(key2, key2be)... | [
1,
0
] |
Linux Kernel | net/mptcp/ctrl.c |
static struct mptcp_pernet *mptcp_get_pernet(const struct net *net) {
return net_generic(net, mptcp_pernet_id);
} | [
0,
0
] |
Linux Kernel | net/mptcp/ctrl.c |
unsigned int mptcp_get_add_addr_timeout(const struct net *net) {
return mptcp_get_pernet(net)->add_addr_timeout;
} | [
0,
0
] |
Linux Kernel | net/mptcp/ctrl.c |
static int mptcp_pernet_new_table(struct net *net,
struct mptcp_pernet *pernet) {
return 0;
} | [
0,
0
] |
Linux Kernel | net/mptcp/diag.c |
void mptcp_diag_subflow_init(struct tcp_ulp_ops *ops) {
ops->get_info = subflow_get_info;
ops->get_info_size = subflow_get_info_size;
} | [
0,
0
] |
Linux Kernel | net/mptcp/mib.c |
void mptcp_seq_show(struct seq_file *seq) {
unsigned long sum[ARRAY_SIZE(mptcp_snmp_list) - 1];
struct net *net = seq->private;
int i;
seq_puts(seq, "MPTcpExt:");
for (i = 0; mptcp_snmp_list[i].name; i++)
seq_printf(seq, " %s", mptcp_snmp_list[i].name);
seq_puts(seq, "\nMPTcpExt:");
memset(sum, 0,... | [
1,
0
] |
Linux Kernel | net/mptcp/mib.h |
static inline void MPTCP_INC_STATS(struct net *net,
enum linux_mptcp_mib_field field) {
if (likely(net->mib.mptcp_statistics))
SNMP_INC_STATS(net->mib.mptcp_statistics, field);
} | [
0,
0
] |
Linux Kernel | net/mptcp/options.c | static bool mptcp_established_options_mp_prio(struct sock *sk,
unsigned int *size,
unsigned int remaining,
struct mptcp_out_options *opts) {
struct mptcp_subflow_context *subflow =... | [
1,
0
] |
Linux Kernel | net/mptcp/options.c |
static bool add_addr_hmac_valid(struct mptcp_sock *msk,
struct mptcp_options_received *mp_opt) {
u64 hmac = 0;
if (mp_opt->echo)
return true;
hmac = add_addr_generate_hmac(msk->remote_key, msk->local_key, &mp_opt->addr);
pr_debug("msk=%p, ahmac=%llu, mp_opt->ahmac=%llu\n"... | [
0,
0
] |
Linux Kernel | net/mptcp/options.c |
static __sum16 mptcp_make_csum(const struct mptcp_ext *mpext) {
return __mptcp_make_csum(mpext->data_seq, mpext->subflow_seq, mpext->data_len,
~csum_unfold(mpext->csum));
} | [
0,
0
] |
Linux Kernel | net/mptcp/options.c |
__be32 mptcp_get_reset_option(const struct sk_buff *skb) {
const struct mptcp_ext *ext = mptcp_get_ext(skb);
u8 flags, reason;
if (ext) {
flags = ext->reset_transient;
reason = ext->reset_reason;
return mptcp_option(MPTCPOPT_RST, TCPOLEN_MPTCP_RST, flags, reason);
}
return htonl(0u);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm.c | int mptcp_pm_announce_addr(struct mptcp_sock *msk,
const struct mptcp_addr_info *addr, bool echo) {
u8 add_addr = READ_ONCE(msk->pm.addr_signal);
pr_debug("msk=%p, local_id=%d, echo=%d", msk, addr->id, echo);
lockdep_assert_held(&msk->pm.lock);
if (add_addr &
(echo ? BIT(MPTC... | [
0,
0
] |
Linux Kernel | net/mptcp/pm.c | bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk) {
struct mptcp_pm_data *pm = &msk->pm;
unsigned int subflows_max;
int ret = 0;
if (mptcp_pm_is_userspace(msk))
return mptcp_userspace_pm_active(msk);
subflows_max = mptcp_pm_get_subflows_max(msk);
pr_debug("msk=%p subflows=%d max=%d allow=%d", m... | [
1,
0
] |
Linux Kernel | net/mptcp/pm.c | void mptcp_pm_subflow_check_next(struct mptcp_sock *msk, const struct sock *ssk,
const struct mptcp_subflow_context *subflow) {
struct mptcp_pm_data *pm = &msk->pm;
bool update_subflows;
update_subflows =
(subflow->request_join || subflow->mp_join) && mptcp_pm_is_kernel(msk... | [
0,
0
] |
Linux Kernel | net/mptcp/pm.c |
void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk) {
if (!mptcp_pm_should_add_signal(msk))
return;
mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm.c | bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, const struct sk_buff *skb,
unsigned int opt_size, unsigned int remaining,
struct mptcp_addr_info *addr, bool *echo,
bool *drop_other_suboptions) {
int ret = false;
u8 add_a... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static void local_address(const struct sock_common *skc,
struct mptcp_addr_info *addr) {
addr->family = skc->skc_family;
addr->port = htons(skc->skc_num);
if (addr->family == AF_INET)
addr->addr.s_addr = skc->skc_rcv_saddr;
#if IS_ENABLED(CONFIG_MPTCP_IPV6)
else if (addr->family =... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static bool lookup_subflow_by_daddr(const struct list_head *list,
const struct mptcp_addr_info *daddr) {
struct mptcp_subflow_context *subflow;
struct mptcp_addr_info cur;
struct sock_common *skc;
list_for_each_entry(subflow, list, node) {
skc = (struct sock_common *)mp... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
unsigned int mptcp_pm_get_add_addr_accept_max(const struct mptcp_sock *msk) {
struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
return READ_ONCE(pernet->add_addr_accept_max);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk) {
struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) ||
(find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap,
MPTCP_PM_MAX_ADDR_ID + 1,
... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
struct mptcp_pm_add_entry *
mptcp_pm_del_add_timer(struct mptcp_sock *msk,
const struct mptcp_addr_info *addr, bool check_id) {
struct mptcp_pm_add_entry *entry;
struct sock *sk = (struct sock *)msk;
spin_lock_bh(&msk->pm.lock);
entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
if (... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
void mptcp_pm_free_anno_list(struct mptcp_sock *msk) {
struct mptcp_pm_add_entry *entry, *tmp;
struct sock *sk = (struct sock *)msk;
LIST_HEAD(free_list);
pr_debug("msk=%p", msk);
spin_lock_bh(&msk->pm.lock);
list_splice_init(&msk->pm.anno_list, &free_list);
spin_unlock_bh(&msk->pm.lock);
list_for_e... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static void mptcp_pm_send_ack(struct mptcp_sock *msk,
struct mptcp_subflow_context *subflow, bool prio,
bool backup) {
spin_unlock_bh(&msk->pm.lock);
__mptcp_pm_send_ack(msk, subflow, prio, backup);
spin_lock_bh(&msk->pm.lock);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static struct mptcp_pm_addr_entry *
__lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info,
bool lookup_by_id) {
struct mptcp_pm_addr_entry *entry;
list_for_each_entry(entry, &pernet->local_addr_list, list) {
if ((!lookup_by_id &&
mptcp_addresses_equal(&entry->add... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk) {
mptcp_pm_create_subflow_or_signal_addr(msk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static bool mptcp_local_id_match(const struct mptcp_sock *msk, u8 local_id,
u8 id) {
return local_id == id || (!local_id && msk->mpc_endpoint_id == id);
} | [
1,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static int mptcp_pm_family_to_addr(int family) {
#if IS_ENABLED(CONFIG_MPTCP_IPV6)
if (family == AF_INET6)
return MPTCP_PM_ADDR_ATTR_ADDR6;
#endif
return MPTCP_PM_ADDR_ATTR_ADDR4;
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c | static int mptcp_pm_parse_pm_addr_attr(struct nlattr *tb[],
const struct nlattr *attr,
struct genl_info *info,
struct mptcp_addr_info *addr,
bool require_family) {
... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
int mptcp_pm_get_flags_and_ifindex_by_id(struct mptcp_sock *msk,
unsigned int id, u8 *flags,
int *ifindex) {
struct mptcp_pm_addr_entry *entry;
struct sock *sk = (struct sock *)msk;
struct net *net = sock_net(sk);
*flags = 0;
... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
const struct mptcp_addr_info *addr,
bool force) {
struct mptcp_rm_list list = {.nr = 0};
bool ret;
list.ids[list.nr++] = addr->id;
ret = remove_anno_list_by_saddr(msk, add... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c | static void __flush_addrs(struct list_head *list) {
while (!list_empty(list)) {
struct mptcp_pm_addr_entry *cur;
cur = list_entry(list->next, struct mptcp_pm_addr_entry, list);
list_del_rcu(&cur->list);
__mptcp_pm_release_addr_entry(cur);
}
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static void __reset_counters(struct pm_nl_pernet *pernet) {
WRITE_ONCE(pernet->add_addr_signal_max, 0);
WRITE_ONCE(pernet->add_addr_accept_max, 0);
WRITE_ONCE(pernet->local_addr_max, 0);
pernet->addrs = 0;
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static int mptcp_nl_fill_addr(struct sk_buff *skb,
struct mptcp_pm_addr_entry *entry) {
struct mptcp_addr_info *addr = &entry->addr;
struct nlattr *attr;
attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
if (!attr)
return -EMSGSIZE;
if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FA... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static int mptcp_nl_cmd_get_limits(struct sk_buff *skb,
struct genl_info *info) {
struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
struct sk_buff *msg;
void *reply;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
reply = genlmsg_put_re... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb,
gfp_t gfp) {
genlmsg_multicast_netns(&mptcp_genl_family, net, nlskb, 0,
MPTCP_PM_EV_GRP_OFFSET, gfp);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static int mptcp_event_sub_established(struct sk_buff *skb,
const struct mptcp_sock *msk,
const struct sock *ssk) {
return mptcp_event_put_token_and_ssk(skb, msk, ssk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
static int mptcp_event_created(struct sk_buff *skb,
const struct mptcp_sock *msk,
const struct sock *ssk) {
int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token);
if (err)
return err;
if (nla_put_u8(skb, MPTCP_ATTR_SERVER_SIDE, READ_ONCE(msk-... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c |
void mptcp_event_addr_announced(const struct sock *ssk,
const struct mptcp_addr_info *info) {
struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
struct mptcp_sock *msk = mptcp_sk(subflow->conn);
struct net *net = sock_net(ssk);
struct nlmsghdr *nlh;
struct sk_buff... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_netlink.c | static int __net_init pm_nl_init_net(struct net *net) {
struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
pernet->subflows_max = 2;
pernet->next_id = 1;
pernet->stale_loss_cnt = 4;
spin_lock_init(&pernet->lock);
/* No need to initialize other pernet fiel... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_userspace.c |
void mptcp_free_local_addr_list(struct mptcp_sock *msk) {
struct mptcp_pm_addr_entry *entry, *tmp;
struct sock *sk = (struct sock *)msk;
LIST_HEAD(free_list);
if (!mptcp_pm_is_userspace(msk))
return;
spin_lock_bh(&msk->pm.lock);
list_splice_init(&msk->pm.userspace_pm_local_addr_list, &free_list);
s... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_userspace.c |
int mptcp_userspace_pm_get_flags_and_ifindex_by_id(struct mptcp_sock *msk,
unsigned int id, u8 *flags,
int *ifindex) {
struct mptcp_pm_addr_entry *entry, *match = NULL;
*flags = 0;
*ifindex = 0;
spin_lock_bh... | [
0,
0
] |
Linux Kernel | net/mptcp/pm_userspace.c |
int mptcp_nl_cmd_remove(struct sk_buff *skb, struct genl_info *info) {
struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
struct nlattr *id = info->attrs[MPTCP_PM_ATTR_LOC_ID];
struct mptcp_pm_addr_entry *match = NULL;
struct mptcp_pm_addr_entry *entry;
struct mptcp_sock *msk;
LIST_HEAD(free_list);
... | [
1,
0
] |
Linux Kernel | net/mptcp/pm_userspace.c |
static struct sock *mptcp_nl_find_ssk(struct mptcp_sock *msk,
const struct mptcp_addr_info *local,
const struct mptcp_addr_info *remote) {
struct mptcp_subflow_context *subflow;
if (local->family != remote->family)
return NULL;
mpt... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c | static u64 mptcp_wnd_end(const struct mptcp_sock *msk) {
return READ_ONCE(msk->wnd_end);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static int __mptcp_socket_create(struct mptcp_sock *msk) {
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
struct socket *ssock;
int err;
err = mptcp_subflow_create_socket(sk, &ssock);
if (err)
return err;
msk->first = ssock->sk;
msk->subflow = ssock;
subflow = mptcp... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void __mptcp_rmem_reclaim(struct sock *sk, int amount) {
amount >>= PAGE_SHIFT;
mptcp_sk(sk)->rmem_fwd_alloc -= amount << PAGE_SHIFT;
__sk_mem_reduce_allocated(sk, amount);
} | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_rfree(struct sk_buff *skb) {
unsigned int len = skb->truesize;
struct sock *sk = skb->sk;
atomic_sub(len, &sk->sk_rmem_alloc);
mptcp_rmem_uncharge(sk, len);
} | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
void mptcp_set_owner_r(struct sk_buff *skb, struct sock *sk) {
skb_orphan(skb);
skb->sk = sk;
skb->destructor = mptcp_rfree;
atomic_add(skb->truesize, &sk->sk_rmem_alloc);
mptcp_rmem_charge(sk, skb->truesize);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static bool __mptcp_move_skb(struct mptcp_sock *msk, struct sock *ssk,
struct sk_buff *skb, unsigned int offset,
size_t copy_len) {
struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
struct sock *sk = (struct sock *)msk;
struct sk_buff *tail;
... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static bool mptcp_pending_data_fin(struct sock *sk, u64 *seq) {
struct mptcp_sock *msk = mptcp_sk(sk);
if (READ_ONCE(msk->rcv_data_fin) &&
((1 << sk->sk_state) &
(TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_FIN_WAIT2))) {
u64 rcv_data_fin_seq = READ_ONCE(msk->rcv_data_fin_seq);
if (msk->ack_seq... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static inline bool tcp_can_send_ack(const struct sock *ssk) {
return !((1 << inet_sk_state_load(ssk)) &
(TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_TIME_WAIT | TCPF_CLOSE |
TCPF_LISTEN));
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
void __mptcp_subflow_send_ack(struct sock *ssk) {
if (tcp_can_send_ack(ssk))
tcp_send_ack(ssk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_send_ack(struct mptcp_sock *msk) {
struct mptcp_subflow_context *subflow;
mptcp_for_each_subflow(msk, subflow)
mptcp_subflow_send_ack(mptcp_subflow_tcp_sock(subflow));
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_cleanup_rbuf(struct mptcp_sock *msk) {
int old_space = READ_ONCE(msk->old_wspace);
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
int space = __mptcp_space(sk);
bool cleanup, rx_empty;
cleanup = (space > 0) && (space >= (old_space << 1));
rx_empty = !__mpt... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static bool move_skbs_to_msk(struct mptcp_sock *msk, struct sock *ssk) {
struct sock *sk = (struct sock *)msk;
unsigned int moved = 0;
__mptcp_move_skbs_from_subflow(msk, ssk, &moved);
__mptcp_ofo_queue(msk);
if (unlikely(ssk->sk_err)) {
if (!sock_owned_by_user(sk))
__mptcp_error_report(sk);
el... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c | void mptcp_data_ready(struct sock *sk, struct sock *ssk) {
struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
struct mptcp_sock *msk = mptcp_sk(sk);
int sk_rbuf, ssk_rbuf;
if (unlikely(subflow->disposable))
return;
ssk_rbuf = READ_ONCE(ssk->sk_rcvbuf);
sk_rbuf = READ_ONCE(sk->sk_rcvbuf);
... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void mptcp_check_for_eof(struct mptcp_sock *msk) {
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
int receivers = 0;
mptcp_for_each_subflow(msk, subflow) receivers += !subflow->rx_eof;
if (receivers)
return;
if (!(sk->sk_shutdown & RCV_SHUTDOWN)) {
/* hopefully... | [
0,
1
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_clean_una_wakeup(struct sock *sk) {
mptcp_data_lock(sk);
__mptcp_clean_una_wakeup(sk);
mptcp_data_unlock(sk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_enter_memory_pressure(struct sock *sk) {
struct mptcp_subflow_context *subflow;
struct mptcp_sock *msk = mptcp_sk(sk);
bool first = true;
sk_stream_moderate_sndbuf(sk);
mptcp_for_each_subflow(msk, subflow) {
struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
if (first)
tcp_... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static struct mptcp_data_frag *
mptcp_carve_data_frag(const struct mptcp_sock *msk, struct page_frag *pfrag,
int orig_offset) {
int offset = ALIGN(orig_offset, sizeof(long));
struct mptcp_data_frag *dfrag;
dfrag = (struct mptcp_data_frag *)(page_to_virt(pfrag->page) + offset);
dfrag->dat... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static struct sk_buff *__mptcp_do_alloc_tx_skb(struct sock *sk, gfp_t gfp) {
struct sk_buff *skb;
skb = alloc_skb_fclone(MAX_TCP_HEADER, gfp);
if (likely(skb)) {
if (likely(__mptcp_add_ext(skb, gfp))) {
skb_reserve(skb, MAX_TCP_HEADER);
skb->ip_summed = CHECKSUM_PARTIAL;
INIT_LIST_HEAD(&sk... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static struct sk_buff *mptcp_alloc_tx_skb(struct sock *sk, struct sock *ssk,
bool data_lock_held) {
gfp_t gfp = data_lock_held ? GFP_ATOMIC : sk->sk_allocation;
return __mptcp_alloc_tx_skb(sk, ssk, gfp);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
void mptcp_subflow_set_active(struct mptcp_subflow_context *subflow) {
if (!subflow->stale)
return;
subflow->stale = 0;
MPTCP_INC_STATS(sock_net(mptcp_subflow_tcp_sock(subflow)),
MPTCP_MIB_SUBFLOWRECOVER);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk,
bool first) {
struct mptcp_sock *msk = mptcp_sk(sk);
struct mptcp_sendmsg_info info = {
.data_lock_held = true,
};
struct mptcp_data_frag *dfrag;
struct sock *xmit_ssk;
int len, copied ... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static int mptcp_sendmsg_fastopen(struct sock *sk, struct sock *ssk,
struct msghdr *msg, size_t len,
int *copied_syn) {
unsigned int saved_flags = msg->msg_flags;
struct mptcp_sock *msk = mptcp_sk(sk);
int ret;
lock_sock(ssk);
msg->msg_flags... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c | static struct sock *mptcp_subflow_get_retrans(struct mptcp_sock *msk) {
struct sock *backup = NULL, *pick = NULL;
struct mptcp_subflow_context *subflow;
int min_stale_count = INT_MAX;
sock_owned_by_me((const struct sock *)msk);
if (__mptcp_check_fallback(msk))
return NULL;
mptcp_for_each_subflow(msk,... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static unsigned int mptcp_sync_mss(struct sock *sk, u32 pmtu) { return 0; } | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void __mptcp_retrans(struct sock *sk) {
struct mptcp_sock *msk = mptcp_sk(sk);
struct mptcp_sendmsg_info info = {};
struct mptcp_data_frag *dfrag;
size_t copied = 0;
struct sock *ssk;
int ret;
mptcp_clean_una_wakeup(sk);
ssk = mptcp_subflow_get_retrans(msk);
dfrag = mptcp_rtx_head(sk);
if (... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void mptcp_ca_reset(struct sock *sk) {
struct inet_connection_sock *icsk = inet_csk(sk);
tcp_assign_congestion_control(sk);
strcpy(mptcp_sk(sk)->ca_name, icsk->icsk_ca_ops->name);
tcp_cleanup_congestion_control(sk);
icsk->icsk_ca_ops = NULL;
} | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c | static int mptcp_init_sock(struct sock *sk) {
struct net *net = sock_net(sk);
int ret;
ret = __mptcp_init_sock(sk);
if (ret)
return ret;
if (!mptcp_is_enabled(net))
return -ENOPROTOOPT;
if (unlikely(!net->mib.mptcp_statistics) && !mptcp_mib_alloc(net))
return -ENOMEM;
ret = __mptcp_socket_... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void __mptcp_clear_xmit(struct sock *sk) {
struct mptcp_sock *msk = mptcp_sk(sk);
struct mptcp_data_frag *dtmp, *dfrag;
WRITE_ONCE(msk->first_pending, NULL);
list_for_each_entry_safe(dfrag, dtmp, &msk->rtx_queue, list)
dfrag_clear(sk, dfrag);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void __mptcp_wr_shutdown(struct sock *sk) {
struct mptcp_sock *msk = mptcp_sk(sk);
pr_debug("msk=%p snd_data_fin_enable=%d shutdown=%x state=%d pending=%d", msk,
msk->snd_data_fin_enable, sk->sk_shutdown, sk->sk_state,
!!mptcp_send_head(sk));
WRITE_ONCE(msk->write_seq, msk->write_se... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static void mptcp_close(struct sock *sk, long timeout) {
bool do_cancel_work;
lock_sock(sk);
do_cancel_work = __mptcp_close(sk, timeout);
release_sock(sk);
if (do_cancel_work)
mptcp_cancel_work(sk);
sock_put(sk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static int mptcp_disconnect(struct sock *sk, int flags) {
struct mptcp_sock *msk = mptcp_sk(sk);
inet_sk_state_store(sk, TCP_CLOSE);
mptcp_stop_timer(sk);
sk_stop_timer(sk, &sk->sk_timer);
if (msk->token)
mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
mptcp_destroy_common(msk, MPTCP_CF_FAST... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
void __mptcp_check_push(struct sock *sk, struct sock *ssk) {
if (!mptcp_send_head(sk))
return;
if (!sock_owned_by_user(sk))
__mptcp_subflow_push_pending(sk, ssk, false);
else
__set_bit(MPTCP_PUSH_PENDING, &mptcp_sk(sk)->cb_flags);
}
#define MPTCP_FLAGS_PROCESS_CTX_NEED ... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static void mptcp_unhash(struct sock *sk) {} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | void mptcp_finish_connect(struct sock *ssk) {
struct mptcp_subflow_context *subflow;
struct mptcp_sock *msk;
struct sock *sk;
subflow = mptcp_subflow_ctx(ssk);
sk = subflow->conn;
msk = mptcp_sk(sk);
pr_debug("msk=%p, token=%u", sk, subflow->token);
subflow->map_seq = subflow->iasn;
subflow->map_su... | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static int mptcp_forward_alloc_get(const struct sock *sk) {
return sk->sk_forward_alloc + mptcp_sk(sk)->rmem_fwd_alloc;
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c | static int mptcp_ioctl_outq(const struct mptcp_sock *msk, u64 v) {
const struct sock *sk = (void *)msk;
u64 delta;
if (sk->sk_state == TCP_LISTEN)
return -EINVAL;
if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
return 0;
delta = msk->write_seq - v;
if (__mptcp_check_fallback(msk) && ms... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static int mptcp_stream_connect(struct socket *sock, struct sockaddr *uaddr,
int addr_len, int flags) {
int ret;
lock_sock(sock->sk);
mptcp_sk(sock->sk)->connect_flags = flags;
ret = __inet_stream_connect(sock, uaddr, addr_len, flags, 0);
release_sock(sock->sk);
return ret;... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.c |
static int mptcp_listen(struct socket *sock, int backlog) {
struct mptcp_sock *msk = mptcp_sk(sock->sk);
struct socket *ssock;
int err;
pr_debug("msk=%p", msk);
lock_sock(sock->sk);
ssock = __mptcp_nmpc_socket(msk);
if (!ssock) {
err = -EINVAL;
goto unlock;
}
mptcp_token_destroy(msk);
in... | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h |
static inline bool before64(__u64 seq1, __u64 seq2) {
return (__s64)(seq1 - seq2) < 0;
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h |
static inline void msk_owned_by_me(const struct mptcp_sock *msk) {
sock_owned_by_me((const struct sock *)msk);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h |
static inline struct mptcp_data_frag *mptcp_send_next(struct sock *sk) {
struct mptcp_sock *msk = mptcp_sk(sk);
struct mptcp_data_frag *cur;
cur = msk->first_pending;
return list_is_last(&cur->list, &msk->rtx_queue) ? NULL
: list_next_entry(cur, list);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h | static inline u64 mptcp_expand_seq(u64 old_seq, u64 cur_seq, bool use_64bit) {
if (use_64bit)
return cur_seq;
return __mptcp_expand_seq(old_seq, cur_seq);
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h | static inline void mptcp_token_init_request(struct request_sock *req) {
mptcp_subflow_rsk(req)->token_node.pprev = NULL;
} | [
0,
0
] |
Linux Kernel | net/mptcp/protocol.h |
static inline int mptcp_rm_addr_len(const struct mptcp_rm_list *rm_list) {
if (rm_list->nr == 0 || rm_list->nr > MPTCP_RM_IDS_MAX)
return -EINVAL;
return TCPOLEN_MPTCP_RM_ADDR_BASE + roundup(rm_list->nr - 1, 4) + 1;
} | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.h |
static inline bool is_active_ssk(struct mptcp_subflow_context *subflow) {
return (subflow->request_mptcp || subflow->request_join);
} | [
1,
0
] |
Linux Kernel | net/mptcp/protocol.h | static inline void subflow_init_req_cookie_join_save(
const struct mptcp_subflow_request_sock *subflow_req, struct sk_buff *skb) {
} | [
0,
0
] |
Linux Kernel | net/mptcp/sockopt.c |
static void sockopt_seq_inc(struct mptcp_sock *msk) {
u32 seq = (msk->setsockopt_seq + 1) & 0x00ffffff;
msk->setsockopt_seq = sockopt_seq_reset((struct sock *)msk) + seq;
} | [
1,
0
] |
Linux Kernel | net/mptcp/sockopt.c |
static int mptcp_setsockopt_sol_socket_linger(struct mptcp_sock *msk,
sockptr_t optval,
unsigned int optlen) {
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
struct linger ling;
sockptr_t k... | [
1,
0
] |
Linux Kernel | net/mptcp/sockopt.c |
static int mptcp_setsockopt_v6(struct mptcp_sock *msk, int optname,
sockptr_t optval, unsigned int optlen) {
struct sock *sk = (struct sock *)msk;
int ret = -EOPNOTSUPP;
struct socket *ssock;
switch (optname) {
case IPV6_V6ONLY:
case IPV6_TRANSPARENT:
case IPV6_FREEBIND:
... | [
1,
0
] |
Linux Kernel | net/mptcp/sockopt.c |
static int mptcp_setsockopt_sol_tcp_congestion(struct mptcp_sock *msk,
sockptr_t optval,
unsigned int optlen) {
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
char name[TCP_CA_NAME_MAX];
... | [
1,
0
] |
Linux Kernel | net/mptcp/sockopt.c |
static int mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk,
sockptr_t optval,
unsigned int optlen) {
struct mptcp_subflow_context *subflow;
struct sock *sk = (struct sock *)msk;
int val;
if (optlen < sizeof(int))
... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.