Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_dumpit(struct tipc_nl_compat_cmd_dump *cmd,
struct tipc_nl_compat_msg *msg) {
struct nlmsghdr *nlh;
struct sk_buff *arg;
int err;
if (msg->req_type &&
(!msg->req_size || !TLV_CHECK_TYPE(msg->req, msg->req_type)))
return -EINVAL;
msg->rep ... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_bearer_dump(struct tipc_nl_compat_msg *msg,
struct nlattr **attrs) {
struct nlattr *bearer[TIPC_NLA_BEARER_MAX + 1];
int err;
if (!attrs[TIPC_NLA_BEARER])
return -EINVAL;
err = nla_parse_nested_deprecated(bearer, TIPC_NLA_BEARER_MAX,
... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_bearer_enable(struct tipc_nl_compat_cmd_doit *cmd,
struct sk_buff *skb,
struct tipc_nl_compat_msg *msg) {
struct nlattr *prop;
struct nlattr *bearer;
struct tipc_bearer_config *b;
int len;
b = (struct t... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static inline u32 perc(u32 count, u32 total) {
return (count * 100 + (total / 2)) / total;
} | [
1,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int __tipc_add_link_prop(struct sk_buff *skb,
struct tipc_nl_compat_msg *msg,
struct tipc_link_config *lc) {
switch (msg->cmd) {
case TIPC_CMD_SET_LINK_PRI:
return nla_put_u32(skb, TIPC_NLA_PROP_PRIO, ntohl(lc->value));
case TIPC_CMD_SET_... | [
1,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_bearer_set(struct sk_buff *skb,
struct tipc_nl_compat_msg *msg) {
struct nlattr *prop;
struct nlattr *bearer;
struct tipc_link_config *lc;
lc = (struct tipc_link_config *)TLV_DATA(msg->req);
bearer = nla_nest_start_noflag(skb, TIPC_NLA_BEARER);... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int
tipc_nl_compat_name_table_dump_header(struct tipc_nl_compat_msg *msg) {
int i;
u32 depth;
struct tipc_name_table_query *ntq;
static const char *const header[] = {"Type ", "Lower Upper ",
"Port Identity ",
... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_publ_dump(struct tipc_nl_compat_msg *msg, u32 sock) {
int err;
void *hdr;
struct nlattr *nest;
struct sk_buff *args;
struct tipc_nl_compat_cmd_dump dump;
args = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!args)
return -ENOMEM;
hdr =
genlmsg_put(args, 0, 0, &tipc_ge... | [
0,
0
] |
Linux Kernel | net/tipc/netlink_compat.c |
static int tipc_nl_compat_sk_dump(struct tipc_nl_compat_msg *msg,
struct nlattr **attrs) {
int err;
u32 sock_ref;
struct nlattr *sock[TIPC_NLA_SOCK_MAX + 1];
if (!attrs[TIPC_NLA_SOCK])
return -EINVAL;
err = nla_parse_nested_deprecated(sock, TIPC_NLA_SOCK_MAX,
... | [
1,
0
] |
Linux Kernel | net/tipc/node.c |
char *tipc_node_get_id_str(struct tipc_node *node) {
return node->peer_id_string;
}
#ifdef CONFIG_TIPC_CRYPTO | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static void tipc_node_kref_release(struct kref *kref) {
struct tipc_node *n = container_of(kref, struct tipc_node, kref);
kfree(n->bc_entry.link);
call_rcu(&n->rcu, tipc_node_free);
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id) {
struct tipc_net *tn = tipc_net(net);
struct tipc_node *n;
bool found = false;
rcu_read_lock();
list_for_each_entry_rcu(n, &tn->node_list, list) {
read_lock_bh(&n->lock);
if (!memcmp(id, n->peer_id, 16) && kref_get_unless_zero(&n... | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static void tipc_node_read_unlock(struct tipc_node *n) __releases(n->lock) {
read_unlock_bh(&n->lock);
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static void tipc_node_calculate_timer(struct tipc_node *n,
struct tipc_link *l) {
unsigned long tol = tipc_link_tolerance(l);
unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
if (intv < n->keepalive_intv)
n->keepalive_intv = intv;
/* Ensure link's abort limit c... | [
1,
0
] |
Linux Kernel | net/tipc/node.c |
void tipc_node_stop(struct net *net) {
struct tipc_net *tn = tipc_net(net);
struct tipc_node *node, *t_node;
spin_lock_bh(&tn->node_list_lock);
list_for_each_entry_safe(node, t_node, &tn->node_list, list)
tipc_node_delete(node);
spin_unlock_bh(&tn->node_list_lock);
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port) {
struct tipc_node *node;
struct tipc_sock_conn *conn, *safe;
if (in_own_node(net, dnode))
return;
node = tipc_node_find(net, dnode);
if (!node)
return;
tipc_node_write_lock(node);
list_for_each_entry_safe(conn, safe, &node->conn... | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static void tipc_node_clear_links(struct tipc_node *node) {
int i;
for (i = 0; i < MAX_BEARERS; i++) {
struct tipc_link_entry *le = &node->links[i];
if (le->link) {
kfree(le->link);
le->link = NULL;
node->link_cnt--;
}
}
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
struct sk_buff_head *xmitq) {
struct tipc_media_addr *maddr;
tipc_node_write_lock(n);
__tipc_node_link_up(n, bearer_id, xmitq);
maddr = &n->links[bearer_id].maddr;
tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr,... | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static u32 tipc_node_suggest_addr(struct net *net, u32 addr) {
struct tipc_node *n;
addr ^= tipc_net(net)->random;
while ((n = tipc_node_find(net, addr))) {
tipc_node_put(n);
addr++;
}
return addr;
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c | u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr) {
struct tipc_net *tn = tipc_net(net);
struct tipc_node *n;
bool preliminary;
u32 sugg_addr;
n = tipc_node_find(net, addr);
if (n) {
if (!memcmp(n->peer_id, id, NODE_ID_LEN))
addr = 0;
tipc_node_put(n);
if (!addr)
return 0;
... | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static void node_lost_contact(struct tipc_node *n,
struct sk_buff_head *inputq) {
struct tipc_sock_conn *conn, *safe;
struct tipc_link *l;
struct list_head *conns = &n->conn_sks;
struct sk_buff *skb;
uint i;
pr_debug("Lost contact with %x\n", n->addr);
n->delete_at = jiffies... | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static struct tipc_node *tipc_node_find_by_name(struct net *net,
const char *link_name,
unsigned int *bearer_id) {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_link *l;
struct tipc_node *n;
struct... | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static int __tipc_nl_add_monitor_prop(struct net *net,
struct tipc_nl_msg *msg) {
struct nlattr *attrs;
void *hdr;
u32 val;
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 0,
TIPC_NL_MON_GET);
if (!hdr)
return -EMSGSIZE;
... | [
0,
0
] |
Linux Kernel | net/tipc/node.c | static int tipc_nl_retrieve_key(struct nlattr **attrs,
struct tipc_aead_key **pkey) {
struct nlattr *attr = attrs[TIPC_NLA_NODE_KEY];
struct tipc_aead_key *key;
if (!attr)
return -ENODATA;
if (nla_len(attr) < sizeof(*key))
return -EINVAL;
key = (struct tipc_aead_key *... | [
1,
0
] |
Linux Kernel | net/tipc/node.c |
static int tipc_nl_retrieve_nodeid(struct nlattr **attrs, u8 **node_id) {
struct nlattr *attr = attrs[TIPC_NLA_NODE_ID];
if (!attr)
return -ENODATA;
if (nla_len(attr) < TIPC_NODEID_LEN)
return -EINVAL;
*node_id = (u8 *)nla_data(attr);
return 0;
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
static int tipc_nl_retrieve_rekeying(struct nlattr **attrs, u32 *intv) {
struct nlattr *attr = attrs[TIPC_NLA_NODE_REKEYING];
if (!attr)
return -ENODATA;
*intv = nla_get_u32(attr);
return 0;
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
int tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info) {
int err;
rtnl_lock();
err = __tipc_nl_node_set_key(skb, info);
rtnl_unlock();
return err;
} | [
0,
0
] |
Linux Kernel | net/tipc/node.c |
void tipc_node_pre_cleanup_net(struct net *exit_net) {
struct tipc_node *n;
struct tipc_net *tn;
struct net *tmp;
rcu_read_lock();
for_each_net_rcu(tmp) {
if (tmp == exit_net)
continue;
tn = tipc_net(tmp);
if (!tn)
continue;
spin_lock_bh(&tn->node_list_lock);
list_for_each_en... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c |
static bool tsk_unreturnable(struct tipc_sock *tsk) {
return msg_dest_droppable(&tsk->phdr) != 0;
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c |
static bool tsk_conn_cong(struct tipc_sock *tsk) {
return tsk->snt_unacked > tsk->snd_win;
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static void tsk_advance_rx_queue(struct sock *sk) {
trace_tipc_sk_advance_rx(sk, NULL, TIPC_DUMP_SK_RCVQ, " ");
kfree_skb(__skb_dequeue(&sk->sk_receive_queue));
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg) {
struct sock *sk = &tsk->sk;
u32 self = tipc_own_addr(sock_net(sk));
u32 peer_port = tsk_peer_port(tsk);
u32 orig_node, peer_node;
if (unlikely(!tipc_sk_connected(sk)))
return false;
if (unlikely(msg_origport(msg) != peer_port))
... | [
1,
0
] |
Linux Kernel | net/tipc/socket.c | static int tipc_sk_sock_err(struct socket *sock, long *timeout) {
struct sock *sk = sock->sk;
int err = sock_error(sk);
int typ = sock->type;
if (err)
return err;
if (typ == SOCK_STREAM || typ == SOCK_SEQPACKET) {
if (sk->sk_state == TIPC_DISCONNECTING)
return -EPIPE;
else if (!tipc_sk_conn... | [
1,
0
] |
Linux Kernel | net/tipc/socket.c |
static int tipc_bind(struct socket *sock, struct sockaddr *skaddr, int alen) {
struct tipc_uaddr *ua = (struct tipc_uaddr *)skaddr;
u32 atype = ua->addrtype;
if (alen) {
if (!tipc_uaddr_valid(ua, alen))
return -EINVAL;
if (atype == TIPC_SOCKET_ADDR)
return -EAFNOSUPPORT;
if (ua->sr.type ... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static __poll_t tipc_poll(struct file *file, struct socket *sock,
poll_table *wait) {
struct sock *sk = sock->sk;
struct tipc_sock *tsk = tipc_sk(sk);
__poll_t revents = 0;
sock_poll_wait(file, sock, wait);
trace_tipc_sk_poll(sk, NULL, TIPC_DUMP_ALL, " ");
if (sk->sk_shutdown & R... | [
1,
0
] |
Linux Kernel | net/tipc/socket.c | static int tipc_send_group_msg(struct net *net, struct tipc_sock *tsk,
struct msghdr *m, struct tipc_member *mb,
u32 dnode, u32 dport, int dlen) {
u16 bc_snd_nxt = tipc_group_bc_snd_nxt(tsk->group);
struct tipc_mc_method *method = &tsk->mc_method;
int ... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c |
static int tipc_wait_for_connect(struct socket *sock, long *timeo_p) {
DEFINE_WAIT_FUNC(wait, woken_wake_function);
struct sock *sk = sock->sk;
int done;
do {
int err = sock_error(sk);
if (err)
return err;
if (!*timeo_p)
return -ETIMEDOUT;
if (signal_pending(current))
return ... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static int tipc_listen(struct socket *sock, int len) {
struct sock *sk = sock->sk;
int res;
lock_sock(sk);
res = tipc_set_sk_state(sk, TIPC_LISTEN);
release_sock(sk);
return res;
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static int tipc_wait_for_accept(struct socket *sock, long timeo) {
struct sock *sk = sock->sk;
DEFINE_WAIT_FUNC(wait, woken_wake_function);
int err;
for (;;) {
if (timeo && skb_queue_empty(&sk->sk_receive_queue)) {
add_wait_queue(sk_sleep(sk), &wait);
release_sock(sk);
timeo = wait_woken(... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static void tipc_sk_retry_connect(struct sock *sk, struct sk_buff_head *list) {
struct tipc_sock *tsk = tipc_sk(sk);
if (tsk->cong_link_cnt) {
sk_reset_timer(sk, &sk->sk_timer, jiffies + msecs_to_jiffies(100));
return;
}
/* Prepare SYN for retransmit */
tipc_msg_skb_clone(&sk->sk_write_queue, list);
... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | void tipc_socket_stop(void) {
sock_unregister(tipc_family_ops.family);
proto_unregister(&tipc_proto);
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | static int __tipc_nl_list_sk_publ(struct sk_buff *skb,
struct netlink_callback *cb,
struct tipc_sock *tsk, u32 *last_publ) {
int err;
struct publication *p;
if (*last_publ) {
list_for_each_entry(p, &tsk->publications, binding_sock) {
i... | [
0,
0
] |
Linux Kernel | net/tipc/socket.c |
u32 tipc_sock_get_portid(struct sock *sk) {
return (sk) ? (tipc_sk(sk))->portid : 0;
} | [
0,
0
] |
Linux Kernel | net/tipc/socket.c | bool tipc_sk_overlimit1(struct sock *sk, struct sk_buff *skb) {
atomic_t *dcnt = &tipc_sk(sk)->dupl_rcvcnt;
unsigned int lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt);
unsigned int qsize = sk->sk_backlog.len + sk_rmem_alloc_get(sk);
return (qsize > lim * 90 / 100);
} | [
1,
0
] |
Linux Kernel | net/tipc/subscr.c |
static void tipc_sub_send_event(struct tipc_subscription *sub,
struct publication *p, u32 event) {
struct tipc_subscr *s = &sub->evt.s;
struct tipc_event *evt = &sub->evt;
if (sub->inactive)
return;
tipc_evt_write(evt, event, event);
if (p) {
tipc_evt_write(evt, found... | [
0,
0
] |
Linux Kernel | net/tipc/subscr.c |
void tipc_sub_report_overlap(struct tipc_subscription *sub,
struct publication *p, u32 event, bool must) {
struct tipc_service_range *sr = &sub->s.seq;
u32 filter = sub->s.filter;
if (!tipc_sub_check_overlap(sr, &p->sr))
return;
if (!must && !(filter & TIPC_SUB_PORTS))
ret... | [
1,
0
] |
Linux Kernel | net/tipc/subscr.c |
struct tipc_subscription *tipc_sub_subscribe(struct net *net,
struct tipc_subscr *s, int conid) {
u32 lower = tipc_sub_read(s, seq.lower);
u32 upper = tipc_sub_read(s, seq.upper);
u32 filter = tipc_sub_read(s, filter);
struct tipc_subscription *sub;
u32 timeout;
... | [
1,
0
] |
Linux Kernel | net/tipc/topsrv.c |
static void conn_get(struct tipc_conn *con) { kref_get(&con->kref); } | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c |
static void tipc_conn_send_work(struct work_struct *work) {
struct tipc_conn *con = container_of(work, struct tipc_conn, swork);
if (connected(con))
tipc_conn_send_to_sock(con);
conn_put(con);
} | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c |
static int tipc_conn_rcv_sub(struct tipc_topsrv *srv, struct tipc_conn *con,
struct tipc_subscr *s) {
struct tipc_net *tn = tipc_net(srv->net);
struct tipc_subscription *sub;
u32 s_filter = tipc_sub_read(s, filter);
if (s_filter & TIPC_SUB_CANCEL) {
tipc_sub_write(s, filter, s... | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c | static void tipc_conn_data_ready(struct sock *sk) {
struct tipc_conn *con;
read_lock_bh(&sk->sk_callback_lock);
con = sk->sk_user_data;
if (connected(con)) {
conn_get(con);
if (!queue_work(con->server->rcv_wq, &con->rwork))
conn_put(con);
}
read_unlock_bh(&sk->sk_callback_lock);
} | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c | static void tipc_topsrv_listener_data_ready(struct sock *sk) {
struct tipc_topsrv *srv;
read_lock_bh(&sk->sk_callback_lock);
srv = sk->sk_user_data;
if (srv)
queue_work(srv->rcv_wq, &srv->awork);
read_unlock_bh(&sk->sk_callback_lock);
} | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c |
static void tipc_topsrv_kern_evt(struct net *net, struct tipc_event *evt) {
u32 port = *(u32 *)&evt->s.usr_handle;
u32 self = tipc_own_addr(net);
struct sk_buff_head evtq;
struct sk_buff *skb;
skb = tipc_msg_create(TOP_SRV, 0, INT_H_SIZE, sizeof(*evt), self, self, port,
port, 0);
i... | [
1,
0
] |
Linux Kernel | net/tipc/topsrv.c |
static void tipc_topsrv_stop(struct net *net) {
struct tipc_topsrv *srv = tipc_topsrv(net);
struct socket *lsock = srv->listener;
struct tipc_conn *con;
int id;
spin_lock_bh(&srv->idr_lock);
for (id = 0; srv->idr_in_use; id++) {
con = idr_find(&srv->conn_idr, id);
if (con) {
spin_unlock_bh(&... | [
0,
0
] |
Linux Kernel | net/tipc/topsrv.c |
void __net_exit tipc_topsrv_exit_net(struct net *net) { tipc_topsrv_stop(net); } | [
0,
0
] |
Linux Kernel | net/tipc/trace.c | int tipc_list_dump(struct sk_buff_head *list, bool more, char *buf) {
int i = 0;
size_t sz = (more) ? LIST_LMAX : LIST_LMIN;
u32 count, len;
struct sk_buff *hskb, *tskb, *skb, *tmp;
if (!list) {
i += scnprintf(buf, sz, "(null)\n");
return i;
}
len = skb_queue_len(list);
i += scnprintf(buf, sz,... | [
1,
0
] |
Linux Kernel | net/tipc/udp_media.c | static int tipc_udp_recv(struct sock *sk, struct sk_buff *skb) {
struct udp_bearer *ub;
struct tipc_bearer *b;
struct tipc_msg *hdr;
int err;
ub = rcu_dereference_sk_user_data(sk);
if (!ub) {
pr_err_ratelimited("Failed to get UDP bearer reference");
goto out;
}
skb_pull(skb, sizeof(struct udphd... | [
1,
0
] |
Linux Kernel | net/tipc/udp_media.c |
static int __tipc_nl_add_udp_addr(struct sk_buff *skb,
struct udp_media_addr *addr, int nla_t) {
if (ntohs(addr->proto) == ETH_P_IP) {
struct sockaddr_in ip4;
memset(&ip4, 0, sizeof(ip4));
ip4.sin_family = AF_INET;
ip4.sin_port = addr->port;
ip4.sin_addr.s_addr ... | [
1,
0
] |
Linux Kernel | net/tipc/udp_media.c |
int tipc_udp_nl_bearer_add(struct tipc_bearer *b, struct nlattr *attr) {
int err;
struct udp_media_addr addr = {0};
struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
struct udp_media_addr *dst;
if (nla_parse_nested_deprecated(opts, TIPC_NLA_UDP_MAX, attr,
tipc_nl_udp_policy, NULL)... | [
0,
0
] |
Linux Kernel | net/tls/tls.h | static inline void tls_device_cleanup(void) {} | [
0,
0
] |
Linux Kernel | net/tls/tls.h |
static inline int tls_set_device_offload_rx(struct sock *sk,
struct tls_context *ctx) {
return -EOPNOTSUPP;
} | [
0,
0
] |
Linux Kernel | net/tls/tls.h |
static inline void tls_bigint_subtract(unsigned char *seq, int n) {
u64 rcd_sn;
__be64 *p;
BUILD_BUG_ON(TLS_MAX_REC_SEQ_SIZE != 8);
p = (__be64 *)seq;
rcd_sn = be64_to_cpu(*p);
*p = cpu_to_be64(rcd_sn - n);
} | [
0,
0
] |
Linux Kernel | net/tls/tls.h |
static inline void tls_advance_record_sn(struct sock *sk,
struct tls_prot_info *prot,
struct cipher_context *ctx) {
if (tls_bigint_increment(ctx->rec_seq, prot->rec_seq_size))
tls_err_abort(sk, -EBADMSG);
if (prot->version != TL... | [
1,
0
] |
Linux Kernel | net/tls/tls_device.c | static struct net_device *get_netdev_for_sock(struct sock *sk) {
struct dst_entry *dst = sk_dst_get(sk);
struct net_device *netdev = NULL;
if (likely(dst)) {
netdev = netdev_sk_get_lowest_dev(dst->dev, sk);
dev_hold(netdev);
}
dst_release(dst);
return netdev;
} | [
0,
0
] |
Linux Kernel | net/tls/tls_device.c |
int tls_device_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) {
unsigned char record_type = TLS_RECORD_TYPE_DATA;
struct tls_context *tls_ctx = tls_get_ctx(sk);
union tls_iter_offset iter;
int rc;
mutex_lock(&tls_ctx->tx_lock);
lock_sock(sk);
if (unlikely(msg->msg_controllen)) {
rc = tls... | [
1,
0
] |
Linux Kernel | net/tls/tls_device.c |
int tls_device_sendpage(struct sock *sk, struct page *page, int offset,
size_t size, int flags) {
struct tls_context *tls_ctx = tls_get_ctx(sk);
union tls_iter_offset iter_offset;
struct iov_iter msg_iter;
char *kaddr;
struct kvec iov;
int rc;
if (flags & MSG_SENDPAGE_NOTLAST)
... | [
0,
0
] |
Linux Kernel | net/tls/tls_device.c | static void tls_device_core_ctrl_rx_resync(struct tls_context *tls_ctx,
struct tls_offload_context_rx *ctx,
struct sock *sk,
struct sk_buff *skb) {
struct strp_msg *rxm;
if (ctx->resync_... | [
1,
0
] |
Linux Kernel | net/tls/tls_device.c |
static void tls_device_attach(struct tls_context *ctx, struct sock *sk,
struct net_device *netdev) {
if (sk->sk_destruct != tls_device_sk_destruct) {
refcount_set(&ctx->refcount, 1);
dev_hold(netdev);
RCU_INIT_POINTER(ctx->netdev, netdev);
spin_lock_irq(&tls_device_lock)... | [
0,
0
] |
Linux Kernel | net/tls/tls_device.c |
static int tls_dev_event(struct notifier_block *this, unsigned long event,
void *ptr) {
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
if (!dev->tlsdev_ops &&
!(dev->features & (NETIF_F_HW_TLS_RX | NETIF_F_HW_TLS_TX)))
return NOTIFY_DONE;
switch (event) {
case N... | [
1,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c |
static void tls_init_aead_request(struct aead_request *aead_req,
struct crypto_aead *aead) {
aead_request_set_tfm(aead_req, aead);
aead_request_set_ad(aead_req, TLS_AAD_SPACE_SIZE);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c | static int fill_sg_in(struct scatterlist *sg_in, struct sk_buff *skb,
struct tls_offload_context_tx *ctx, u64 *rcd_sn,
s32 *sync_size, int *resync_sgs) {
int tcp_payload_offset = skb_tcp_all_headers(skb);
int payload_len = skb->len - tcp_payload_offset;
u32 tcp_seq = nt... | [
0,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c | static void fill_sg_out(struct scatterlist sg_out[3], void *buf,
struct tls_context *tls_ctx, struct sk_buff *nskb,
int tcp_payload_offset, int payload_len, int sync_size,
void *dummy_buf) {
const struct tls_cipher_size_desc *cipher_sz =
&t... | [
0,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c | static struct sk_buff *tls_sw_fallback(struct sock *sk, struct sk_buff *skb) {
int tcp_payload_offset = skb_tcp_all_headers(skb);
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_offload_context_tx *ctx = tls_offload_ctx_tx(tls_ctx);
int payload_len = skb->len - tcp_payload_offset;
struct scatterlist... | [
1,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c |
struct sk_buff *tls_validate_xmit_skb(struct sock *sk, struct net_device *dev,
struct sk_buff *skb) {
if (dev == rcu_dereference_bh(tls_get_ctx(sk)->netdev) ||
netif_is_bond_master(dev))
return skb;
return tls_sw_fallback(sk, skb);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c |
struct sk_buff *tls_validate_xmit_skb_sw(struct sock *sk,
struct net_device *dev,
struct sk_buff *skb) {
return tls_sw_fallback(sk, skb);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_device_fallback.c |
struct sk_buff *tls_encrypt_skb(struct sk_buff *skb) {
return tls_sw_fallback(skb->sk, skb);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_main.c |
void update_sk_prot(struct sock *sk, struct tls_context *ctx) {
int ip_ver = sk->sk_family == AF_INET6 ? TLSV6 : TLSV4;
WRITE_ONCE(sk->sk_prot, &tls_prots[ip_ver][ctx->tx_conf][ctx->rx_conf]);
WRITE_ONCE(sk->sk_socket->ops,
&tls_proto_ops[ip_ver][ctx->tx_conf][ctx->rx_conf]);
} | [
1,
0
] |
Linux Kernel | net/tls/tls_main.c |
void tls_free_partial_record(struct sock *sk, struct tls_context *ctx) {
struct scatterlist *sg;
for (sg = ctx->partially_sent_record; sg; sg = sg_next(sg)) {
put_page(sg_page(sg));
sk_mem_uncharge(sk, sg->length);
}
ctx->partially_sent_record = NULL;
} | [
0,
0
] |
Linux Kernel | net/tls/tls_main.c |
static void tls_sk_proto_close(struct sock *sk, long timeout) {
struct inet_connection_sock *icsk = inet_csk(sk);
struct tls_context *ctx = tls_get_ctx(sk);
long timeo = sock_sndtimeo(sk, 0);
bool free_ctx;
if (ctx->tx_conf == TLS_SW)
tls_sw_cancel_work_tx(ctx);
lock_sock(sk);
free_ctx = ctx->tx_co... | [
1,
0
] |
Linux Kernel | net/tls/tls_main.c | static void tls_build_proto(struct sock *sk) {
int ip_ver = sk->sk_family == AF_INET6 ? TLSV6 : TLSV4;
struct proto *prot = READ_ONCE(sk->sk_prot);
if (ip_ver == TLSV6 &&
unlikely(prot != smp_load_acquire(&saved_tcpv6_prot))) {
mutex_lock(&tcpv6_prot_mutex);
if (likely(prot != saved_tcpv6_prot)) {
... | [
0,
0
] |
Linux Kernel | net/tls/tls_strp.c | struct sk_buff *tls_strp_msg_detach(struct tls_sw_context_rx *ctx) {
struct tls_strparser *strp = &ctx->strp;
#ifdef CONFIG_TLS_DEVICE
DEBUG_NET_WARN_ON_ONCE(!strp->anchor->decrypted);
#else
WARN_ON(1);
#endif
if (strp->copy_mode) {
struct sk_buff *skb;
/* Replace anchor with an empty skb, this is a... | [
1,
0
] |
Linux Kernel | net/tls/tls_strp.c |
static void tls_strp_flush_anchor_copy(struct tls_strparser *strp) {
struct skb_shared_info *shinfo = skb_shinfo(strp->anchor);
int i;
DEBUG_NET_WARN_ON_ONCE(atomic_read(&shinfo->dataref) != 1);
for (i = 0; i < shinfo->nr_frags; i++)
__skb_frag_unref(&shinfo->frags[i], false);
shinfo->nr_frags = 0;
s... | [
0,
0
] |
Linux Kernel | net/tls/tls_strp.c | static void tls_strp_load_anchor_with_queue(struct tls_strparser *strp,
int len) {
struct tcp_sock *tp = tcp_sk(strp->sk);
struct sk_buff *first;
u32 offset;
first = tcp_recv_skb(strp->sk, tp->copied_seq, &offset);
if (WARN_ON_ONCE(!first))
return;
strp->anc... | [
1,
0
] |
Linux Kernel | net/tls/tls_strp.c |
void tls_strp_check_rcv(struct tls_strparser *strp) {
if (unlikely(strp->stopped) || strp->msg_ready)
return;
if (tls_strp_read_sock(strp) == -ENOMEM)
queue_work(tls_strp_wq, &strp->work);
} | [
1,
0
] |
Linux Kernel | net/tls/tls_strp.c |
void tls_strp_msg_done(struct tls_strparser *strp) {
WARN_ON(!strp->stm.full_len);
if (likely(!strp->copy_mode))
tcp_read_done(strp->sk, strp->stm.full_len);
else
tls_strp_flush_anchor_copy(strp);
strp->msg_ready = 0;
memset(&strp->stm, 0, sizeof(strp->stm));
tls_strp_check_rcv(strp);
} | [
1,
0
] |
Linux Kernel | net/tls/tls_strp.c |
void tls_strp_stop(struct tls_strparser *strp) { strp->stopped = 1; } | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static int __skb_nsg(struct sk_buff *skb, int offset, int len,
unsigned int recursion_level) {
int start = skb_headlen(skb);
int i, chunk = start - offset;
struct sk_buff *frag_iter;
int elt = 0;
if (unlikely(recursion_level >= 24))
return -EMSGSIZE;
if (chunk > 0) {
if (chun... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c | static void tls_decrypt_done(struct crypto_async_request *req, int err) {
struct aead_request *aead_req = (struct aead_request *)req;
struct scatterlist *sgout = aead_req->dst;
struct scatterlist *sgin = aead_req->src;
struct tls_sw_context_rx *ctx;
struct tls_context *tls_ctx;
struct scatterlist *sg;
uns... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static int tls_do_decryption(struct sock *sk, struct scatterlist *sgin,
struct scatterlist *sgout, char *iv_recv,
size_t data_len, struct aead_request *aead_req,
struct tls_decrypt_arg *darg) {
struct tls_context *tls_ctx = tls_ge... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static struct tls_rec *tls_get_rec(struct sock *sk) {
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_prot_info *prot = &tls_ctx->prot_info;
struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
struct sk_msg *msg_pl, *msg_en;
struct tls_rec *rec;
int mem_size;
mem_size = sizeof(struct tls_r... | [
1,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static void tls_merge_open_record(struct sock *sk, struct tls_rec *to,
struct tls_rec *from, u32 orig_end) {
struct sk_msg *msg_npl = &from->msg_plaintext;
struct sk_msg *msg_opl = &to->msg_plaintext;
struct scatterlist *osge, *nsge;
u32 i, j;
i = msg_opl->sg.end;
sk_msg_... | [
1,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static int tls_sw_push_pending_record(struct sock *sk, int flags) {
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
struct tls_rec *rec = ctx->open_rec;
struct sk_msg *msg_pl;
size_t copied;
if (!rec)
return 0;
msg_pl = &rec->msg_plaintext;
c... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c | static int tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock,
bool nonblock, bool released) {
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
DEFINE_WAIT_FUNC(wait, woken_wake_function);
long timeo;
timeo = sock_rcvtimeo(... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c | static int tls_setup_from_iter(struct iov_iter *from, int length,
int *pages_used, struct scatterlist *to,
int to_max_pages) {
int rc = 0, i = 0, num_elem = *pages_used, maxpages;
struct page *pages[MAX_SKB_FRAGS];
unsigned int size = 0;
ssize_t copi... | [
1,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static int tls_record_content_type(struct msghdr *msg, struct tls_msg *tlm,
u8 *control) {
int err;
if (!*control) {
*control = tlm->control;
if (!*control)
return -EBADMSG;
err =
put_cmsg(msg, SOL_TLS, TLS_GET_RECORD_TYPE, sizeof(*control), control);
... | [
1,
0
] |
Linux Kernel | net/tls/tls_sw.c |
static int tls_rx_reader_lock(struct sock *sk, struct tls_sw_context_rx *ctx,
bool nonblock) {
long timeo;
int err;
lock_sock(sk);
timeo = sock_rcvtimeo(sk, nonblock);
while (unlikely(ctx->reader_present)) {
DEFINE_WAIT_FUNC(wait, woken_wake_function);
ctx->reader_co... | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c |
void tls_sw_cancel_work_tx(struct tls_context *tls_ctx) {
struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
set_bit(BIT_TX_CLOSING, &ctx->tx_bitmask);
set_bit(BIT_TX_SCHEDULED, &ctx->tx_bitmask);
cancel_delayed_work_sync(&ctx->tx_work.work);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_sw.c |
void tls_sw_free_resources_rx(struct sock *sk) {
struct tls_context *tls_ctx = tls_get_ctx(sk);
tls_sw_release_resources_rx(sk);
tls_sw_free_ctx_rx(tls_ctx);
} | [
0,
0
] |
Linux Kernel | net/tls/tls_toe.c |
int tls_toe_bypass(struct sock *sk) {
struct tls_toe_device *dev;
struct tls_context *ctx;
int rc = 0;
spin_lock_bh(&device_spinlock);
list_for_each_entry(dev, &device_list, dev_list) {
if (dev->feature && dev->feature(dev)) {
ctx = tls_ctx_create(sk);
if (!ctx)
goto out;
ctx-... | [
1,
0
] |
Linux Kernel | net/tls/tls_toe.c |
void tls_toe_unregister_device(struct tls_toe_device *device) {
spin_lock_bh(&device_spinlock);
list_del(&device->dev_list);
spin_unlock_bh(&device_spinlock);
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.