Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/wireless/wext-spy.c | int iw_handler_get_thrspy(struct net_device *dev, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra) {
struct iw_spy_data *spydata = get_spydata(dev);
struct iw_thrspy *threshold = (struct iw_thrspy *)extra;
if (!spydata)
return -EOPNOTSUPP;
/* Just do it */
thr... | [
0,
0
] |
Linux Kernel | net/x25/af_x25.c | int x25_parse_address_block(struct sk_buff *skb,
struct x25_address *called_addr,
struct x25_address *calling_addr) {
unsigned char len;
int needed;
int rc;
if (!pskb_may_pull(skb, 1)) {
rc = 0;
goto empty;
}
len = *skb->data;
needed = 1 +... | [
1,
0
] |
Linux Kernel | net/x25/af_x25.c |
int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
struct x25_address *calling_addr) {
unsigned int called_len, calling_len;
char *called, *calling;
unsigned int i;
called_len = (*p >> 0) & 0x0F;
calling_len = (*p >> 4) & 0x0F;
called = called_addr->x25_addr;
callin... | [
1,
0
] |
Linux Kernel | net/x25/af_x25.c |
int x25_addr_aton(unsigned char *p, struct x25_address *called_addr,
struct x25_address *calling_addr) {
unsigned int called_len, calling_len;
char *called, *calling;
int i;
called = called_addr->x25_addr;
calling = calling_addr->x25_addr;
called_len = strlen(called);
calling_len = st... | [
1,
0
] |
Linux Kernel | net/x25/af_x25.c | static void x25_remove_socket(struct sock *sk) {
write_lock_bh(&x25_list_lock);
sk_del_node_init(sk);
write_unlock_bh(&x25_list_lock);
} | [
0,
0
] |
Linux Kernel | net/x25/af_x25.c |
static int x25_getsockopt(struct socket *sock, int level, int optname,
char __user *optval, int __user *optlen) {
struct sock *sk = sock->sk;
int val, len, rc = -ENOPROTOOPT;
if (level != SOL_X25 || optname != X25_QBITINCL)
goto out;
rc = -EFAULT;
if (get_user(len, optlen))
... | [
1,
0
] |
Linux Kernel | net/x25/af_x25.c |
static struct sock *x25_alloc_socket(struct net *net, int kern) {
struct x25_sock *x25;
struct sock *sk = sk_alloc(net, AF_X25, GFP_ATOMIC, &x25_proto, kern);
if (!sk)
goto out;
sock_init_data(NULL, sk);
x25 = x25_sk(sk);
skb_queue_head_init(&x25->ack_queue);
skb_queue_head_init(&x25->fragment_que... | [
0,
0
] |
Linux Kernel | net/x25/af_x25.c |
static int x25_release(struct socket *sock) {
struct sock *sk = sock->sk;
struct x25_sock *x25;
if (!sk)
return 0;
x25 = x25_sk(sk);
sock_hold(sk);
lock_sock(sk);
switch (x25->state) {
case X25_STATE_0:
case X25_STATE_2:
x25_disconnect(sk, 0, 0, 0);
__x25_destroy_socket(sk);
goto ... | [
1,
0
] |
Linux Kernel | net/x25/af_x25.c |
static int x25_wait_for_connection_establishment(struct sock *sk) {
DECLARE_WAITQUEUE(wait, current);
int rc;
add_wait_queue_exclusive(sk_sleep(sk), &wait);
for (;;) {
__set_current_state(TASK_INTERRUPTIBLE);
rc = -ERESTARTSYS;
if (signal_pending(current))
break;
rc = sock_error(sk);
... | [
0,
0
] |
Linux Kernel | net/x25/af_x25.c |
static void __exit x25_exit(void) {
x25_proc_exit();
x25_link_free();
x25_route_free();
x25_unregister_sysctl();
unregister_netdevice_notifier(&x25_dev_notifier);
dev_remove_pack(&x25_packet_type);
sock_unregister(AF_X25);
proto_unregister(&x25_proto);
} | [
0,
0
] |
Linux Kernel | net/x25/x25_dev.c |
void x25_establish_link(struct x25_neigh *nb) {
struct sk_buff *skb;
unsigned char *ptr;
switch (nb->dev->type) {
case ARPHRD_X25:
if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) {
pr_err("x25_dev: out of memory\n");
return;
}
ptr = skb_put(skb, 1);
*ptr = X25_IFACE_CONNECT;
brea... | [
0,
0
] |
Linux Kernel | net/x25/x25_in.c | static int x25_state4_machine(struct sock *sk, struct sk_buff *skb,
int frametype) {
struct x25_sock *x25 = x25_sk(sk);
switch (frametype) {
case X25_RESET_REQUEST:
x25_write_internal(sk, X25_RESET_CONFIRMATION);
fallthrough;
case X25_RESET_CONFIRMATION: {
x25_stop_ti... | [
1,
0
] |
Linux Kernel | net/x25/x25_in.c | static int x25_state5_machine(struct sock *sk, struct sk_buff *skb,
int frametype) {
struct x25_sock *x25 = x25_sk(sk);
switch (frametype) {
case X25_CLEAR_REQUEST:
if (!pskb_may_pull(skb, X25_STD_MIN_LEN + 2)) {
x25_write_internal(sk, X25_CLEAR_REQUEST);
x25->state ... | [
0,
0
] |
Linux Kernel | net/x25/x25_in.c | int x25_process_rx_frame(struct sock *sk, struct sk_buff *skb) {
struct x25_sock *x25 = x25_sk(sk);
int queued = 0, frametype, ns, nr, q, d, m;
if (x25->state == X25_STATE_0)
return 0;
frametype = x25_decode(sk, skb, &ns, &nr, &q, &d, &m);
switch (x25->state) {
case X25_STATE_1:
queued = x25_stat... | [
1,
0
] |
Linux Kernel | net/x25/x25_in.c |
int x25_backlog_rcv(struct sock *sk, struct sk_buff *skb) {
int queued = x25_process_rx_frame(sk, skb);
if (!queued)
kfree_skb(skb);
return 0;
} | [
0,
0
] |
Linux Kernel | net/x25/x25_link.c | void x25_link_control(struct sk_buff *skb, struct x25_neigh *nb,
unsigned short frametype) {
struct sk_buff *skbn;
switch (frametype) {
case X25_RESTART_REQUEST:
switch (nb->state) {
case X25_LINK_STATE_0:
nb->state = X25_LINK_STATE_3;
x25_transmit_restart_confirmation(... | [
1,
0
] |
Linux Kernel | net/x25/x25_link.c | void x25_transmit_clear_request(struct x25_neigh *nb, unsigned int lci,
unsigned char cause) {
unsigned char *dptr;
int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2;
struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
if (!skb)
return;
skb_reserve(skb, X25_MAX_L2_LEN);
dpt... | [
1,
0
] |
Linux Kernel | net/x25/x25_link.c |
void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *nb) {
switch (nb->state) {
case X25_LINK_STATE_0:
skb_queue_tail(&nb->queue, skb);
nb->state = X25_LINK_STATE_1;
x25_establish_link(nb);
break;
case X25_LINK_STATE_1:
case X25_LINK_STATE_2:
skb_queue_tail(&nb->queue, skb);
br... | [
1,
0
] |
Linux Kernel | net/x25/x25_link.c | void x25_link_device_up(struct net_device *dev) {
struct x25_neigh *nb = kmalloc(sizeof(*nb), GFP_ATOMIC);
if (!nb)
return;
skb_queue_head_init(&nb->queue);
timer_setup(&nb->t20timer, x25_t20timer_expiry, 0);
dev_hold(dev);
nb->dev = dev;
nb->state = X25_LINK_STATE_0;
nb->extended = 0;
nb->glo... | [
0,
0
] |
Linux Kernel | net/x25/x25_out.c | static void x25_send_iframe(struct sock *sk, struct sk_buff *skb) {
struct x25_sock *x25 = x25_sk(sk);
if (!skb)
return;
if (x25->neighbour->extended) {
skb->data[2] = (x25->vs << 1) & 0xFE;
skb->data[3] &= X25_EXT_M_BIT;
skb->data[3] |= (x25->vr << 1) & 0xFE;
} else {
skb->data[2] &= X25_... | [
1,
0
] |
Linux Kernel | net/x25/x25_proc.c |
static void *x25_seq_route_start(struct seq_file *seq, loff_t *pos)
__acquires(x25_route_list_lock) {
read_lock_bh(&x25_route_list_lock);
return seq_list_start_head(&x25_route_list, *pos);
} | [
0,
0
] |
Linux Kernel | net/x25/x25_proc.c |
static void x25_seq_route_stop(struct seq_file *seq, void *v)
__releases(x25_route_list_lock) {
read_unlock_bh(&x25_route_list_lock);
} | [
0,
0
] |
Linux Kernel | net/x25/x25_proc.c |
static void *x25_seq_socket_start(struct seq_file *seq, loff_t *pos)
__acquires(x25_list_lock) {
read_lock_bh(&x25_list_lock);
return seq_hlist_start_head(&x25_list, *pos);
} | [
0,
0
] |
Linux Kernel | net/x25/x25_proc.c |
static void *x25_seq_forward_next(struct seq_file *seq, void *v, loff_t *pos) {
return seq_list_next(v, &x25_forward_list, pos);
} | [
0,
0
] |
Linux Kernel | net/x25/x25_proc.c | void __exit x25_proc_exit(void) {
remove_proc_subtree("x25", init_net.proc_net);
}
#else | [
0,
0
] |
Linux Kernel | net/x25/x25_route.c | static void __x25_remove_route(struct x25_route *rt) {
if (rt->node.next) {
list_del(&rt->node);
x25_route_put(rt);
}
} | [
0,
0
] |
Linux Kernel | net/x25/x25_route.c |
static int x25_del_route(struct x25_address *address, unsigned int sigdigits,
struct net_device *dev) {
struct x25_route *rt;
int rc = -EINVAL;
write_lock_bh(&x25_route_list_lock);
list_for_each_entry(rt, &x25_route_list, node) {
if (!memcmp(&rt->address, address, sigdigits) &&
... | [
1,
0
] |
Linux Kernel | net/x25/x25_route.c | void x25_route_device_down(struct net_device *dev) {
struct x25_route *rt;
struct list_head *entry, *tmp;
write_lock_bh(&x25_route_list_lock);
list_for_each_safe(entry, tmp, &x25_route_list) {
rt = list_entry(entry, struct x25_route, node);
if (rt->dev == dev)
__x25_remove_route(rt);
}
writ... | [
0,
0
] |
Linux Kernel | net/x25/x25_subr.c | void x25_frames_acked(struct sock *sk, unsigned short nr) {
struct sk_buff *skb;
struct x25_sock *x25 = x25_sk(sk);
int modulus = x25->neighbour->extended ? X25_EMODULUS : X25_SMODULUS;
if (x25->va != nr)
while (skb_peek(&x25->ack_queue) && x25->va != nr) {
skb = skb_dequeue(&x25->ack_queue);
k... | [
1,
0
] |
Linux Kernel | net/x25/x25_subr.c | void x25_requeue_frames(struct sock *sk) {
struct sk_buff *skb, *skb_prev = NULL;
while ((skb = skb_dequeue(&x25_sk(sk)->ack_queue)) != NULL) {
if (!skb_prev)
skb_queue_head(&sk->sk_write_queue, skb);
else
skb_append(skb_prev, skb, &sk->sk_write_queue);
skb_prev = skb;
}
} | [
0,
0
] |
Linux Kernel | net/x25/x25_subr.c |
void x25_disconnect(struct sock *sk, int reason, unsigned char cause,
unsigned char diagnostic) {
struct x25_sock *x25 = x25_sk(sk);
x25_clear_queues(sk);
x25_stop_timer(sk);
x25->lci = 0;
x25->state = X25_STATE_0;
x25->causediag.cause = cause;
x25->causediag.diagnostic = diagnosti... | [
0,
0
] |
Linux Kernel | net/x25/x25_timer.c | static void x25_heartbeat_expiry(struct timer_list *t) {
struct sock *sk = from_timer(sk, t, sk_timer);
bh_lock_sock(sk);
if (sock_owned_by_user(sk))
goto restart_heartbeat;
switch (x25_sk(sk)->state) {
case X25_STATE_0:
/*
* Magic here: If we listen() and a new link dies
* before it is a... | [
1,
0
] |
Linux Kernel | net/x25/x25_timer.c | static inline void x25_do_timer_expiry(struct sock *sk) {
struct x25_sock *x25 = x25_sk(sk);
switch (x25->state) {
case X25_STATE_3:
if (x25->condition & X25_COND_ACK_PENDING) {
x25->condition &= ~X25_COND_ACK_PENDING;
x25_enquiry_response(sk);
}
break;
case X25_STATE_1: /* T21 */
c... | [
1,
0
] |
Linux Kernel | net/xdp/xdp_umem.c |
static void xdp_umem_unaccount_pages(struct xdp_umem *umem) {
if (umem->user) {
atomic_long_sub(umem->npgs, &umem->user->locked_vm);
free_uid(umem->user);
}
} | [
0,
0
] |
Linux Kernel | net/xdp/xdp_umem.c |
static void xdp_umem_addr_unmap(struct xdp_umem *umem) {
vunmap(umem->addrs);
umem->addrs = NULL;
} | [
0,
0
] |
Linux Kernel | net/xdp/xdp_umem.c |
static void xdp_umem_release(struct xdp_umem *umem) {
umem->zc = false;
ida_free(&umem_ida, umem->id);
xdp_umem_addr_unmap(umem);
xdp_umem_unpin_pages(umem);
xdp_umem_unaccount_pages(umem);
kfree(umem);
} | [
0,
0
] |
Linux Kernel | net/xdp/xdp_umem.c |
void xdp_put_umem(struct xdp_umem *umem, bool defer_cleanup) {
if (!umem)
return;
if (refcount_dec_and_test(&umem->users)) {
if (defer_cleanup) {
INIT_WORK(&umem->work, xdp_umem_release_deferred);
schedule_work(&umem->work);
} else {
xdp_umem_release(umem);
}
}
} | [
0,
0
] |
Linux Kernel | net/xdp/xdp_umem.c |
struct xdp_umem *xdp_umem_create(struct xdp_umem_reg *mr) {
struct xdp_umem *umem;
int err;
umem = kzalloc(sizeof(*umem), GFP_KERNEL);
if (!umem)
return ERR_PTR(-ENOMEM);
err = ida_alloc(&umem_ida, GFP_KERNEL);
if (err < 0) {
kfree(umem);
return ERR_PTR(err);
}
umem->id = err;
err = xd... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
void xsk_set_rx_need_wakeup(struct xsk_buff_pool *pool) {
if (pool->cached_need_wakeup & XDP_WAKEUP_RX)
return;
pool->fq->ring->flags |= XDP_RING_NEED_WAKEUP;
pool->cached_need_wakeup |= XDP_WAKEUP_RX;
} | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c |
void xsk_set_tx_need_wakeup(struct xsk_buff_pool *pool) {
struct xdp_sock *xs;
if (pool->cached_need_wakeup & XDP_WAKEUP_TX)
return;
rcu_read_lock();
list_for_each_entry_rcu(xs, &pool->xsk_tx_list, tx_list) {
xs->tx->ring->flags |= XDP_RING_NEED_WAKEUP;
}
rcu_read_unlock();
pool->cached_need_w... | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c |
void xsk_clear_rx_need_wakeup(struct xsk_buff_pool *pool) {
if (!(pool->cached_need_wakeup & XDP_WAKEUP_RX))
return;
pool->fq->ring->flags &= ~XDP_RING_NEED_WAKEUP;
pool->cached_need_wakeup &= ~XDP_WAKEUP_RX;
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int __xsk_rcv_zc(struct xdp_sock *xs, struct xdp_buff *xdp, u32 len) {
struct xdp_buff_xsk *xskb = container_of(xdp, struct xdp_buff_xsk, xdp);
u64 addr;
int err;
addr = xp_get_handle(xskb);
err = xskq_prod_reserve_desc(xs->rx, addr, len);
if (err) {
xs->rx_queue_full++;
return err;
}
... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static bool xsk_tx_writeable(struct xdp_sock *xs) {
if (xskq_cons_present_entries(xs->tx) > xs->tx->nentries / 2)
return false;
return true;
} | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c |
int xsk_generic_rcv(struct xdp_sock *xs, struct xdp_buff *xdp) {
int err;
spin_lock_bh(&xs->rx_lock);
err = xsk_rcv_check(xs, xdp);
if (!err) {
err = __xsk_rcv(xs, xdp);
xsk_flush(xs);
}
spin_unlock_bh(&xs->rx_lock);
return err;
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int xsk_rcv(struct xdp_sock *xs, struct xdp_buff *xdp) {
int err;
u32 len;
err = xsk_rcv_check(xs, xdp);
if (err)
return err;
if (xdp->rxq->mem.type == MEM_TYPE_XSK_BUFF_POOL) {
len = xdp->data_end - xdp->data;
return __xsk_rcv_zc(xs, xdp, len);
}
err = __xsk_rcv(xs, xdp);
if (!er... | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int xsk_wakeup(struct xdp_sock *xs, u8 flags) {
struct net_device *dev = xs->dev;
return dev->netdev_ops->ndo_xsk_wakeup(dev, xs->queue_id, flags);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static void xsk_destruct_skb(struct sk_buff *skb) {
u64 addr = (u64)(long)skb_shinfo(skb)->destructor_arg;
struct xdp_sock *xs = xdp_sk(skb->sk);
unsigned long flags;
spin_lock_irqsave(&xs->pool->cq_lock, flags);
xskq_prod_submit_addr(xs->pool->cq, addr);
spin_unlock_irqrestore(&xs->pool->cq_lock, flags);... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static struct sk_buff *xsk_build_skb(struct xdp_sock *xs,
struct xdp_desc *desc) {
struct net_device *dev = xs->dev;
struct sk_buff *skb;
if (dev->priv_flags & IFF_TX_SKB_NO_LINEAR) {
skb = xsk_build_skb_zerocopy(xs, desc);
if (IS_ERR(skb))
return skb;
} else... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c | static int xsk_xmit(struct sock *sk) {
struct xdp_sock *xs = xdp_sk(sk);
int ret;
if (unlikely(!(xs->dev->flags & IFF_UP)))
return -ENETDOWN;
if (unlikely(!xs->tx))
return -ENOBUFS;
if (xs->zc)
return xsk_wakeup(xs, XDP_WAKEUP_TX);
rcu_read_unlock();
ret = xsk_generic_xmit(sk);
/* Reaquir... | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c | static int __xsk_sendmsg(struct socket *sock, struct msghdr *m,
size_t total_len) {
bool need_wait = !(m->msg_flags & MSG_DONTWAIT);
struct sock *sk = sock->sk;
struct xdp_sock *xs = xdp_sk(sk);
struct xsk_buff_pool *pool;
if (unlikely(!xsk_is_bound(xs)))
return -ENXIO;
if (unl... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int xsk_sendmsg(struct socket *sock, struct msghdr *m,
size_t total_len) {
int ret;
rcu_read_lock();
ret = __xsk_sendmsg(sock, m, total_len);
rcu_read_unlock();
return ret;
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c | static int xsk_init_queue(u32 entries, struct xsk_queue **queue,
bool umem_queue) {
struct xsk_queue *q;
if (entries == 0 || *queue || !is_power_of_2(entries))
return -EINVAL;
q = xskq_create(entries, umem_queue);
if (!q)
return -ENOMEM;
smp_wmb();
WRITE_ONCE(*queue, q);... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c | static void xsk_unbind_dev(struct xdp_sock *xs) {
struct net_device *dev = xs->dev;
if (xs->state != XSK_BOUND)
return;
WRITE_ONCE(xs->state, XSK_UNBOUND);
xp_del_xsk(xs->pool, xs);
synchronize_net();
dev_put(dev);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static struct xsk_map *
xsk_get_map_list_entry(struct xdp_sock *xs,
struct xdp_sock __rcu ***map_entry) {
struct xsk_map *map = NULL;
struct xsk_map_node *node;
*map_entry = NULL;
spin_lock_bh(&xs->map_list_lock);
node = list_first_entry_or_null(&xs->map_list, struct xsk_map_node, no... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c | static void xsk_delete_from_maps(struct xdp_sock *xs) {
struct xdp_sock __rcu **map_entry = NULL;
struct xsk_map *map;
while ((map = xsk_get_map_list_entry(xs, &map_entry))) {
xsk_map_try_sock_delete(map, xs, map_entry);
bpf_map_put(&map->map);
}
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static void xsk_enter_umem_offsets(struct xdp_ring_offset_v1 *ring) {
ring->producer = offsetof(struct xdp_umem_ring, ptrs.producer);
ring->consumer = offsetof(struct xdp_umem_ring, ptrs.consumer);
ring->desc = offsetof(struct xdp_umem_ring, desc);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c | static int xsk_notifier(struct notifier_block *this, unsigned long msg,
void *ptr) {
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
struct net *net = dev_net(dev);
struct sock *sk;
switch (msg) {
case NETDEV_UNREGISTER:
mutex_lock(&net->xdp.lock);
sk_for_each(sk, &... | [
1,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int xsk_create(struct net *net, struct socket *sock, int protocol,
int kern) {
struct xdp_sock *xs;
struct sock *sk;
if (!ns_capable(net->user_ns, CAP_NET_RAW))
return -EPERM;
if (sock->type != SOCK_RAW)
return -ESOCKTNOSUPPORT;
if (protocol)
return -EPROTONOSUPPORT... | [
0,
0
] |
Linux Kernel | net/xdp/xsk.c |
static int __net_init xsk_net_init(struct net *net) {
mutex_init(&net->xdp.lock);
INIT_HLIST_HEAD(&net->xdp.list);
return 0;
} | [
0,
0
] |
Linux Kernel | net/xdp/xskmap.c |
static void xsk_map_sock_add(struct xdp_sock *xs, struct xsk_map_node *node) {
spin_lock_bh(&xs->map_list_lock);
list_add_tail(&node->node, &xs->map_list);
spin_unlock_bh(&xs->map_list_lock);
} | [
0,
0
] |
Linux Kernel | net/xdp/xskmap.c |
static void xsk_map_free(struct bpf_map *map) {
struct xsk_map *m = container_of(map, struct xsk_map, map);
synchronize_net();
bpf_map_area_free(m);
} | [
0,
0
] |
Linux Kernel | net/xdp/xskmap.c |
static int xsk_map_update_elem(struct bpf_map *map, void *key, void *value,
u64 map_flags) {
struct xsk_map *m = container_of(map, struct xsk_map, map);
struct xdp_sock __rcu **map_entry;
struct xdp_sock *xs, *old_xs;
u32 i = *(u32 *)key, fd = *(u32 *)value;
struct xsk_map_node... | [
1,
0
] |
Linux Kernel | net/xdp/xsk_buff_pool.c |
static void __xp_dma_unmap(struct xsk_dma_map *dma_map, unsigned long attrs) {
dma_addr_t *dma;
u32 i;
for (i = 0; i < dma_map->dma_pages_cnt; i++) {
dma = &dma_map->dma_pages[i];
if (*dma) {
*dma &= ~XSK_NEXT_PG_CONTIG_MASK;
dma_unmap_page_attrs(dma_map->dev, *dma, PAGE_SIZE, DMA_BIDIRECTIO... | [
0,
0
] |
Linux Kernel | net/xdp/xsk_buff_pool.c |
static int xp_init_dma_info(struct xsk_buff_pool *pool,
struct xsk_dma_map *dma_map) {
if (!pool->unaligned) {
u32 i;
for (i = 0; i < pool->heads_cnt; i++) {
struct xdp_buff_xsk *xskb = &pool->heads[i];
xp_init_xskb_dma(xskb, pool, dma_map->dma_pages, xskb->orig_addr... | [
1,
0
] |
Linux Kernel | net/xdp/xsk_buff_pool.c |
static u32 xp_alloc_reused(struct xsk_buff_pool *pool, struct xdp_buff **xdp,
u32 nb_entries) {
struct xdp_buff_xsk *xskb;
u32 i;
nb_entries = min_t(u32, nb_entries, pool->free_list_cnt);
i = nb_entries;
while (i--) {
xskb =
list_first_entry(&pool->free_list, struct x... | [
0,
0
] |
Linux Kernel | net/xdp/xsk_buff_pool.c |
void xp_free(struct xdp_buff_xsk *xskb) {
if (!list_empty(&xskb->free_list_node))
return;
xskb->pool->free_list_cnt++;
list_add(&xskb->free_list_node, &xskb->pool->free_list);
} | [
1,
0
] |
Linux Kernel | net/xdp/xsk_buff_pool.c |
void xp_dma_sync_for_cpu_slow(struct xdp_buff_xsk *xskb) {
dma_sync_single_range_for_cpu(xskb->pool->dev, xskb->dma, 0,
xskb->pool->frame_len, DMA_BIDIRECTIONAL);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_diag.c |
static int xsk_diag_put_ring(const struct xsk_queue *queue, int nl_type,
struct sk_buff *nlskb) {
struct xdp_diag_ring dr = {};
dr.entries = queue->nentries;
return nla_put(nlskb, nl_type, sizeof(dr), &dr);
} | [
1,
0
] |
Linux Kernel | net/xdp/xsk_diag.c |
static int xsk_diag_put_umem(const struct xdp_sock *xs, struct sk_buff *nlskb) {
struct xsk_buff_pool *pool = xs->pool;
struct xdp_umem *umem = xs->umem;
struct xdp_diag_umem du = {};
int err;
if (!umem)
return 0;
du.id = umem->id;
du.size = umem->size;
du.num_pages = umem->npgs;
du.chunk_size ... | [
1,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline bool xp_unaligned_validate_desc(struct xsk_buff_pool *pool,
struct xdp_desc *desc) {
u64 addr, base_addr;
base_addr = xp_unaligned_extract_addr(desc->addr);
addr = xp_unaligned_add_offset_to_addr(desc->addr);
if (desc->len > pool->chunk_size)
re... | [
1,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline bool xskq_cons_read_desc(struct xsk_queue *q,
struct xdp_desc *desc,
struct xsk_buff_pool *pool) {
while (q->cached_cons != q->cached_prod) {
struct xdp_rxtx_ring *ring = (struct xdp_rxtx_ring *)q->ring;
u32 idx = q->... | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline void xskq_cons_release_n(struct xsk_queue *q, u32 cnt) {
q->cached_cons += cnt;
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline bool xskq_cons_peek_addr_unchecked(struct xsk_queue *q,
u64 *addr) {
if (q->cached_prod == q->cached_cons)
xskq_cons_get_entries(q);
return xskq_cons_read_addr_unchecked(q, addr);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline bool xskq_cons_peek_desc(struct xsk_queue *q,
struct xdp_desc *desc,
struct xsk_buff_pool *pool) {
if (q->cached_prod == q->cached_cons)
xskq_cons_get_entries(q);
return xskq_cons_read_desc(q, desc, pool);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h | static inline void xskq_prod_write_addr_batch(struct xsk_queue *q,
struct xdp_desc *descs,
u32 nb_entries) {
struct xdp_umem_ring *ring = (struct xdp_umem_ring *)q->ring;
u32 i, cached_prod;
cached_prod = q->cached_prod;
... | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h | static inline int xskq_prod_reserve_desc(struct xsk_queue *q, u64 addr,
u32 len) {
struct xdp_rxtx_ring *ring = (struct xdp_rxtx_ring *)q->ring;
u32 idx;
if (xskq_prod_is_full(q))
return -ENOBUFS;
idx = q->cached_prod++ & q->ring_mask;
ring->desc[idx].addr = addr... | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h | static inline void __xskq_prod_submit(struct xsk_queue *q, u32 idx) {
smp_store_release(&q->ring->producer, idx);
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h | static inline u64 xskq_nb_invalid_descs(struct xsk_queue *q) {
return q ? q->invalid_descs : 0;
} | [
0,
0
] |
Linux Kernel | net/xdp/xsk_queue.h |
static inline u64 xskq_nb_queue_empty_descs(struct xsk_queue *q) {
return q ? q->queue_empty_descs : 0;
} | [
0,
0
] |
Linux Kernel | net/xfrm/espintcp.c | static void handle_esp(struct sk_buff *skb, struct sock *sk) {
struct tcp_skb_cb *tcp_cb = (struct tcp_skb_cb *)skb->cb;
skb_reset_transport_header(skb);
memmove(skb->cb, &tcp_cb->header, sizeof(tcp_cb->header));
rcu_read_lock();
skb->dev = dev_get_by_index_rcu(sock_net(sk), skb->skb_iif);
local_bh_disab... | [
1,
0
] |
Linux Kernel | net/xfrm/espintcp.c |
static int espintcp_sendskmsg_locked(struct sock *sk, struct espintcp_msg *emsg,
int flags) {
struct sk_msg *skmsg = &emsg->skmsg;
struct scatterlist *sg;
int done = 0;
int ret;
flags |= MSG_SENDPAGE_NOTLAST;
sg = &skmsg->sg.data[skmsg->sg.start];
do {
size_t siz... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_algo.c |
static inline int ealg_entries(void) { return ARRAY_SIZE(ealg_list); } | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_algo.c |
static inline int calg_entries(void) { return ARRAY_SIZE(calg_list); } | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_algo.c |
struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id) {
return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
(void *)(unsigned long)alg_id, 1);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_algo.c |
struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe) {
return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name, probe);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_algo.c |
int xfrm_count_pfkey_auth_supported(void) {
int i, n;
for (i = 0, n = 0; i < aalg_entries(); i++)
if (aalg_list[i].available && aalg_list[i].pfkey_supported)
n++;
return n;
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_compat.c |
static int xfrm_nla_cpy(struct sk_buff *dst, const struct nlattr *src,
int len) {
return nla_put(dst, src->nla_type, len, nla_data(src));
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_compat.c | static int xfrm_attr_cpy32(void *dst, size_t *pos, const struct nlattr *src,
size_t size, int copy_len, int payload) {
struct nlmsghdr *nlmsg = dst;
struct nlattr *nla;
if (WARN_ON_ONCE(copy_len > payload))
copy_len = payload;
if (size - *pos < nla_attr_size(payload))
return... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_compat.c |
static void __exit xfrm_compat_exit(void) {
xfrm_unregister_translator(&xfrm_translator);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c |
static void __xfrm_mode_beet_prep(struct xfrm_state *x, struct sk_buff *skb,
unsigned int hsize) {
struct xfrm_offload *xo = xfrm_offload(skb);
int phlen = 0;
if (xo->flags & XFRM_GSO_SEGMENT)
skb->transport_header = skb->network_header + hsize;
skb_reset_mac_len(skb);
... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c | int xfrm_dev_policy_add(struct net *net, struct xfrm_policy *xp,
struct xfrm_user_offload *xuo, u8 dir,
struct netlink_ext_ack *extack) {
struct xfrm_dev_offload *xdo = &xp->xdo;
struct net_device *dev;
int err;
if (!xuo->flags || xuo->flags & ~XFRM_OFFLOAD_PACKE... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c |
bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x) {
int mtu;
struct dst_entry *dst = skb_dst(skb);
struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
struct net_device *dev = x->xso.dev;
if (!x->type_offload || x->encap)
return false;
if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET ||
... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c |
void xfrm_dev_backlog(struct softnet_data *sd) {
struct sk_buff_head *xfrm_backlog = &sd->xfrm_backlog;
struct sk_buff_head list;
struct sk_buff *skb;
if (skb_queue_empty(xfrm_backlog))
return;
__skb_queue_head_init(&list);
spin_lock(&xfrm_backlog->lock);
skb_queue_splice_init(xfrm_backlog, &list)... | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c |
static int xfrm_api_check(struct net_device *dev) {
#ifdef CONFIG_XFRM_OFFLOAD
if ((dev->features & NETIF_F_HW_ESP_TX_CSUM) &&
!(dev->features & NETIF_F_HW_ESP))
return NOTIFY_BAD;
if ((dev->features & NETIF_F_HW_ESP) &&
(!(dev->xfrmdev_ops && dev->xfrmdev_ops->xdo_dev_state_add &&
dev->x... | [
1,
0
] |
Linux Kernel | net/xfrm/xfrm_device.c |
static int xfrm_dev_down(struct net_device *dev) {
if (dev->features & NETIF_F_HW_ESP) {
xfrm_dev_state_flush(dev_net(dev), dev, true);
xfrm_dev_policy_flush(dev_net(dev), dev, true);
}
return NOTIFY_DONE;
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_hash.h |
static inline unsigned int __xfrm4_addr_hash(const xfrm_address_t *addr) {
return ntohl(addr->a4);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_hash.h |
static inline unsigned int
__xfrm4_daddr_saddr_hash(const xfrm_address_t *daddr,
const xfrm_address_t *saddr) {
u32 sum = (__force u32)daddr->a4 + (__force u32)saddr->a4;
return ntohl((__force __be32)sum);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_hash.h |
static inline unsigned int __xfrm4_dpref_spref_hash(const xfrm_address_t *daddr,
const xfrm_address_t *saddr,
__u8 dbits, __u8 sbits) {
return jhash_2words(ntohl(daddr->a4) & __bits2mask32(dbits),
... | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_hash.h |
static inline unsigned int __xfrm6_dpref_spref_hash(const xfrm_address_t *daddr,
const xfrm_address_t *saddr,
__u8 dbits, __u8 sbits) {
return __xfrm6_pref_hash(daddr, dbits) ^ __xfrm6_pref_hash(saddr, sbits);
} | [
0,
0
] |
Linux Kernel | net/xfrm/xfrm_hash.h |
static inline unsigned int __idx_hash(u32 index, unsigned int hmask) {
return (index ^ (index >> 8)) & hmask;
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.