Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/rfkill/input.c |
static void rfkill_schedule_evsw_rfkillall(int state) {
if (state)
rfkill_schedule_global_op(rfkill_master_switch_op);
else
rfkill_schedule_global_op(RFKILL_GLOBAL_OP_EPO);
} | [
0,
0
] |
Linux Kernel | net/rfkill/input.c |
static void rfkill_event(struct input_handle *handle, unsigned int type,
unsigned int code, int data) {
if (type == EV_KEY && data == 1) {
switch (code) {
case KEY_WLAN:
rfkill_schedule_toggle(RFKILL_TYPE_WLAN);
break;
case KEY_BLUETOOTH:
rfkill_schedule_toggle(... | [
1,
0
] |
Linux Kernel | net/rfkill/input.c | static int rfkill_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id) {
struct input_handle *handle;
int error;
handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
if (!handle)
return -ENOMEM;
handle->dev = dev;
handle->handl... | [
0,
0
] |
Linux Kernel | net/rfkill/input.c | static void rfkill_start(struct input_handle *handle) {
spin_lock_irq(&handle->dev->event_lock);
if (test_bit(EV_SW, handle->dev->evbit) &&
test_bit(SW_RFKILL_ALL, handle->dev->swbit))
rfkill_schedule_evsw_rfkillall(test_bit(SW_RFKILL_ALL, handle->dev->sw));
spin_unlock_irq(&handle->dev->event_lock);... | [
0,
0
] |
Linux Kernel | net/rose/af_rose.c | char *rose2asc(char *buf, const rose_address *addr) {
if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
addr->rose_addr[4] == 0x00) {
strcpy(buf, "*");
} else {
sprintf(buf, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xF... | [
1,
0
] |
Linux Kernel | net/rose/af_rose.c | int rosecmpm(const rose_address *addr1, const rose_address *addr2,
unsigned short mask) {
unsigned int i, j;
if (mask > 10)
return 1;
for (i = 0; i < mask; i++) {
j = i / 2;
if ((i % 2) != 0) {
if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
return 1;
... | [
1,
0
] |
Linux Kernel | net/rose/af_rose.c | static void rose_kill_by_device(struct net_device *dev) {
struct sock *s;
spin_lock_bh(&rose_list_lock);
sk_for_each(s, &rose_list) {
struct rose_sock *rose = rose_sk(s);
if (rose->device == dev) {
rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
if (rose->neighbour)
rose->neig... | [
1,
0
] |
Linux Kernel | net/rose/af_rose.c | static struct sock *rose_find_listener(rose_address *addr, ax25_address *call) {
struct sock *s;
spin_lock_bh(&rose_list_lock);
sk_for_each(s, &rose_list) {
struct rose_sock *rose = rose_sk(s);
if (!rosecmp(&rose->source_addr, addr) &&
!ax25cmp(&rose->source_call, call) && !rose->source_ndigis &... | [
1,
0
] |
Linux Kernel | net/rose/af_rose.c | unsigned int rose_new_lci(struct rose_neigh *neigh) {
int lci;
if (neigh->dce_mode) {
for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
if (rose_find_socket(lci, neigh) == NULL &&
rose_route_free_lci(lci, neigh) == NULL)
return lci;
} else {
for (lci = sysctl_rose_maximum_vcs; ... | [
0,
0
] |
Linux Kernel | net/rose/af_rose.c | void rose_destroy_socket(struct sock *sk) {
struct sk_buff *skb;
rose_remove_socket(sk);
rose_stop_heartbeat(sk);
rose_stop_idletimer(sk);
rose_stop_timer(sk);
rose_clear_queues(sk);
while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
if (skb->sk != sk) { /* A pending connection */
/... | [
0,
0
] |
Linux Kernel | net/rose/af_rose.c |
static int rose_listen(struct socket *sock, int backlog) {
struct sock *sk = sock->sk;
if (sk->sk_state != TCP_LISTEN) {
struct rose_sock *rose = rose_sk(sk);
rose->dest_ndigis = 0;
memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
memset(&rose->dest_call, 0, AX25_ADDR_LEN);
memset(rose->dest_digis... | [
1,
0
] |
Linux Kernel | net/rose/af_rose.c |
static struct sock *rose_make_new(struct sock *osk) {
struct sock *sk;
struct rose_sock *rose, *orose;
if (osk->sk_type != SOCK_SEQPACKET)
return NULL;
sk = sk_alloc(sock_net(osk), PF_ROSE, GFP_ATOMIC, &rose_proto, 0);
if (sk == NULL)
return NULL;
rose = rose_sk(sk);
sock_init_data(NULL, sk);... | [
0,
0
] |
Linux Kernel | net/rose/af_rose.c | static int rose_accept(struct socket *sock, struct socket *newsock, int flags,
bool kern) {
struct sk_buff *skb;
struct sock *newsk;
DEFINE_WAIT(wait);
struct sock *sk;
int err = 0;
if ((sk = sock->sk) == NULL)
return -EINVAL;
lock_sock(sk);
if (sk->sk_type != SOCK_SEQPACKET... | [
0,
0
] |
Linux Kernel | net/rose/af_rose.c |
static int rose_getname(struct socket *sock, struct sockaddr *uaddr, int peer) {
struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
struct sock *sk = sock->sk;
struct rose_sock *rose = rose_sk(sk);
int n;
memset(srose, 0, sizeof(*srose));
if (peer != 0) {
if (sk->sk_state != TCP_ES... | [
1,
0
] |
Linux Kernel | net/rose/rose_in.c | static int rose_state2_machine(struct sock *sk, struct sk_buff *skb,
int frametype) {
struct rose_sock *rose = rose_sk(sk);
switch (frametype) {
case ROSE_CLEAR_REQUEST:
rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
... | [
1,
0
] |
Linux Kernel | net/rose/rose_in.c | static int rose_state5_machine(struct sock *sk, struct sk_buff *skb,
int frametype) {
if (frametype == ROSE_CLEAR_REQUEST) {
rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
rose_sk(sk)->neighbour->use--;
}
return 0;
... | [
1,
0
] |
Linux Kernel | net/rose/rose_link.c |
static void rose_start_t0timer(struct rose_neigh *neigh) {
del_timer(&neigh->t0timer);
neigh->t0timer.function = rose_t0timer_expiry;
neigh->t0timer.expires =
jiffies + msecs_to_jiffies(sysctl_rose_restart_request_timeout);
add_timer(&neigh->t0timer);
} | [
0,
0
] |
Linux Kernel | net/rose/rose_link.c |
static void rose_ftimer_expiry(struct timer_list *t) {} | [
0,
0
] |
Linux Kernel | net/rose/rose_link.c | static int rose_send_frame(struct sk_buff *skb, struct rose_neigh *neigh) {
const ax25_address *rose_call;
ax25_cb *ax25s;
if (ax25cmp(&rose_callsign, &null_ax25_address) == 0)
rose_call = (const ax25_address *)neigh->dev->dev_addr;
else
rose_call = &rose_callsign;
ax25s = neigh->ax25;
neigh->ax25... | [
0,
0
] |
Linux Kernel | net/rose/rose_loopback.c |
void rose_loopback_init(void) {
skb_queue_head_init(&loopback_queue);
timer_setup(&loopback_timer, rose_loopback_timer, 0);
} | [
0,
0
] |
Linux Kernel | net/rose/rose_loopback.c |
int rose_loopback_queue(struct sk_buff *skb, struct rose_neigh *neigh) {
struct sk_buff *skbn = NULL;
if (skb_queue_len(&loopback_queue) < ROSE_LOOPBACK_LIMIT)
skbn = skb_clone(skb, GFP_ATOMIC);
if (skbn) {
consume_skb(skb);
skb_queue_tail(&loopback_queue, skbn);
if (!rose_loopback_running())
... | [
0,
0
] |
Linux Kernel | net/rose/rose_route.c | static void rose_remove_route(struct rose_route *rose_route) {
struct rose_route *s;
if (rose_route->neigh1 != NULL)
rose_route->neigh1->use--;
if (rose_route->neigh2 != NULL)
rose_route->neigh2->use--;
if ((s = rose_route_list) == rose_route) {
rose_route_list = rose_route->next;
kfree(rose_... | [
1,
0
] |
Linux Kernel | net/rose/rose_route.c | void rose_add_loopback_neigh(void) {
struct rose_neigh *sn;
rose_loopback_neigh = kmalloc(sizeof(struct rose_neigh), GFP_KERNEL);
if (!rose_loopback_neigh)
return;
sn = rose_loopback_neigh;
sn->callsign = null_ax25_address;
sn->digipeat = NULL;
sn->ax25 = NULL;
sn->dev = NULL;
sn->count = 0;
s... | [
0,
0
] |
Linux Kernel | net/rose/rose_route.c |
static int rose_dev_exists(rose_address *addr) {
struct net_device *dev;
rcu_read_lock();
for_each_netdev_rcu(&init_net, dev) {
if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
rosecmp(addr, (const rose_address *)dev->dev_addr) == 0)
goto out;
}
dev = NULL;
out:
rcu_read_unlock()... | [
0,
0
] |
Linux Kernel | net/rose/rose_route.c |
static void rose_del_route_by_neigh(struct rose_neigh *rose_neigh) {
struct rose_route *rose_route, *s;
rose_neigh->restarted = 0;
rose_stop_t0timer(rose_neigh);
rose_start_ftimer(rose_neigh);
skb_queue_purge(&rose_neigh->queue);
spin_lock_bh(&rose_route_list_lock);
rose_route = rose_route_list;
... | [
1,
0
] |
Linux Kernel | net/rose/rose_route.c | void rose_link_device_down(struct net_device *dev) {
struct rose_neigh *rose_neigh;
for (rose_neigh = rose_neigh_list; rose_neigh != NULL;
rose_neigh = rose_neigh->next) {
if (rose_neigh->dev == dev) {
rose_del_route_by_neigh(rose_neigh);
rose_kill_by_neigh(rose_neigh);
}
}
} | [
0,
0
] |
Linux Kernel | net/rose/rose_route.c | static int rose_neigh_show(struct seq_file *seq, void *v) {
char buf[11];
int i;
if (v == SEQ_START_TOKEN)
seq_puts(
seq,
"addr callsign dev count use mode restart t0 tf digipeaters\n");
else {
struct rose_neigh *rose_neigh = v;
seq_printf(seq, "%05d %-9s %-4s %3d %3d %3s ... | [
1,
0
] |
Linux Kernel | net/rose/rose_subr.c | void rose_requeue_frames(struct sock *sk) {
struct sk_buff *skb, *skb_prev = NULL;
while ((skb = skb_dequeue(&rose_sk(sk)->ack_queue)) != NULL) {
if (skb_prev == NULL)
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/rose/rose_subr.c | static int rose_parse_ccitt(unsigned char *p,
struct rose_facilities_struct *facilities,
int len) {
unsigned char l, n = 0;
char callsign[11];
do {
switch (*p & 0xC0) {
case 0x00:
if (len < 2)
return -1;
p += 2;
n += 2;
... | [
1,
0
] |
Linux Kernel | net/rose/rose_timer.c |
void rose_start_hbtimer(struct sock *sk) {
struct rose_sock *rose = rose_sk(sk);
sk_stop_timer(sk, &rose->timer);
rose->timer.function = rose_timer_expiry;
rose->timer.expires = jiffies + rose->hb;
sk_reset_timer(sk, &rose->timer, rose->timer.expires);
} | [
0,
0
] |
Linux Kernel | net/rose/rose_timer.c |
void rose_stop_idletimer(struct sock *sk) {
sk_stop_timer(sk, &rose_sk(sk)->idletimer);
} | [
0,
0
] |
Linux Kernel | net/rose/rose_timer.c | static void rose_timer_expiry(struct timer_list *t) {
struct rose_sock *rose = from_timer(rose, t, timer);
struct sock *sk = &rose->sock;
bh_lock_sock(sk);
switch (rose->state) {
case ROSE_STATE_1:
case ROSE_STATE_4: /* T2 */
rose_write_internal(sk, ROSE_CLEAR_REQUEST);
rose->state = ROSE_STATE_2;
... | [
1,
0
] |
Linux Kernel | net/rose/sysctl_net_rose.c |
void __init rose_register_sysctl(void) {
rose_table_header = register_net_sysctl(&init_net, "net/rose", rose_table);
} | [
0,
0
] |
Linux Kernel | net/rose/sysctl_net_rose.c |
void rose_unregister_sysctl(void) {
unregister_net_sysctl_table(rose_table_header);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | static void rxrpc_write_space(struct sock *sk) {
_enter("%p", sk);
rcu_read_lock();
if (rxrpc_writable(sk)) {
struct socket_wq *wq = rcu_dereference(sk->sk_wq);
if (skwq_has_sleeper(wq))
wake_up_interruptible(&wq->wait);
sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
}
rcu_read_unlock();
} | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call) {
_enter("%d{%d}", call->debug_id, refcount_read(&call->ref));
mutex_lock(&call->user_mutex);
rxrpc_release_call(rxrpc_sk(sock->sk), call);
if (call->notify_rx) {
spin_lock(&call->notify_lock);
call->notify_rx = rxrpc_dummy_notif... | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | bool rxrpc_kernel_check_life(const struct socket *sock,
const struct rxrpc_call *call) {
return call->state != RXRPC_CALL_COMPLETE;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | void rxrpc_kernel_new_call_notification(
struct socket *sock, rxrpc_notify_new_call_t notify_new_call,
rxrpc_discard_new_call_t discard_new_call) {
struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
rx->notify_new_call = notify_new_call;
rx->discard_new_call = discard_new_call;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | void rxrpc_kernel_set_max_life(struct socket *sock, struct rxrpc_call *call,
unsigned long hard_timeout) {
unsigned long now;
mutex_lock(&call->user_mutex);
now = jiffies;
hard_timeout += now;
WRITE_ONCE(call->expect_term_by, hard_timeout);
rxrpc_reduce_call_timer(call, hard... | [
0,
0
] |
Linux Kernel | net/rxrpc/af_rxrpc.c | static int rxrpc_release_sock(struct sock *sk) {
struct rxrpc_sock *rx = rxrpc_sk(sk);
_enter("%p{%d,%d}", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
sock_orphan(sk);
sk->sk_shutdown = SHUTDOWN_MASK;
/* We want to kill off all connections from a service socket
* as fast as possible because we can... | [
1,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline bool rxrpc_to_server(const struct rxrpc_skb_priv *sp) {
return sp->hdr.flags & RXRPC_CLIENT_INITIATED;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline bool rxrpc_sending_to_server(const struct rxrpc_txbuf *txb) {
return txb->wire.flags & RXRPC_CLIENT_INITIATED;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline bool rxrpc_sending_to_client(const struct rxrpc_txbuf *txb) {
return !rxrpc_sending_to_server(txb);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline void rxrpc_reduce_conn_timer(struct rxrpc_connection *conn,
unsigned long expire_at) {
timer_reduce(&conn->timer, expire_at);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline bool __rxrpc_use_local(struct rxrpc_local *local,
enum rxrpc_local_trace why) {
int r, u;
r = refcount_read(&local->ref);
u = atomic_fetch_add_unless(&local->active_users, 1, 0);
trace_rxrpc_local(local->debug_id, why, r, u);
return u != 0;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h | static inline int __init rxrpc_sysctl_init(void) { return 0; } | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h | static inline void rxrpc_sysctl_exit(void) {}
#endif | [
0,
0
] |
Linux Kernel | net/rxrpc/ar-internal.h |
static inline bool before(u32 seq1, u32 seq2) { return (s32)(seq1 - seq2) < 0; } | [
0,
0
] |
Linux Kernel | net/rxrpc/call_accept.c | int rxrpc_service_prealloc(struct rxrpc_sock *rx, gfp_t gfp) {
struct rxrpc_backlog *b = rx->backlog;
if (!b) {
b = kzalloc(sizeof(struct rxrpc_backlog), gfp);
if (!b)
return -ENOMEM;
rx->backlog = b;
}
return 0;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/call_event.c | void rxrpc_propose_ping(struct rxrpc_call *call, u32 serial,
enum rxrpc_propose_ack_trace why) {
unsigned long now = jiffies;
unsigned long ping_at = now + rxrpc_idle_ack_delay;
if (time_before(ping_at, call->ping_at)) {
WRITE_ONCE(call->ping_at, ping_at);
rxrpc_reduce_call_timer(... | [
1,
0
] |
Linux Kernel | net/rxrpc/call_event.c | static void rxrpc_decant_prepared_tx(struct rxrpc_call *call) {
struct rxrpc_txbuf *txb;
if (rxrpc_is_client_call(call) && !test_bit(RXRPC_CALL_EXPOSED, &call->flags))
rxrpc_expose_client_call(call);
while ((txb = list_first_entry_or_null(&call->tx_sendmsg, struct rxrpc_txbuf,
... | [
0,
0
] |
Linux Kernel | net/rxrpc/call_object.c |
static void rxrpc_call_timer_expired(struct timer_list *t) {
struct rxrpc_call *call = from_timer(call, t, timer);
_enter("%d", call->debug_id);
if (call->state < RXRPC_CALL_COMPLETE) {
trace_rxrpc_timer_expired(call, jiffies);
rxrpc_poke_call(call, rxrpc_call_poke_timer);
}
} | [
0,
0
] |
Linux Kernel | net/rxrpc/call_object.c | static struct rxrpc_call *
rxrpc_alloc_client_call(struct rxrpc_sock *rx, struct sockaddr_rxrpc *srx,
struct rxrpc_conn_parameters *cp,
struct rxrpc_call_params *p, gfp_t gfp,
unsigned int debug_id) {
struct rxrpc_call *call;
ktime_t now;
int... | [
0,
0
] |
Linux Kernel | net/rxrpc/call_object.c | static void rxrpc_start_call_timer(struct rxrpc_call *call) {
unsigned long now = jiffies;
unsigned long j = now + MAX_JIFFY_OFFSET;
call->delay_ack_at = j;
call->ack_lost_at = j;
call->resend_at = j;
call->ping_at = j;
call->keepalive_at = j;
call->expect_rx_by = j;
call->expect_req_by = j;
call->... | [
1,
0
] |
Linux Kernel | net/rxrpc/call_object.c | void rxrpc_see_call(struct rxrpc_call *call, enum rxrpc_call_trace why) {
if (call) {
int r = refcount_read(&call->ref);
trace_rxrpc_call(call->debug_id, r, 0, why);
}
} | [
0,
0
] |
Linux Kernel | net/rxrpc/call_object.c | void rxrpc_put_call(struct rxrpc_call *call, enum rxrpc_call_trace why) {
struct rxrpc_net *rxnet = call->rxnet;
unsigned int debug_id = call->debug_id;
bool dead;
int r;
ASSERT(call != NULL);
dead = __refcount_dec_and_test(&call->ref, &r);
trace_rxrpc_call(debug_id, r - 1, 0, why);
if (dead) {
AS... | [
1,
0
] |
Linux Kernel | net/rxrpc/call_object.c | static void rxrpc_destroy_call(struct work_struct *work) {
struct rxrpc_call *call = container_of(work, struct rxrpc_call, destroyer);
struct rxrpc_txbuf *txb;
del_timer_sync(&call->timer);
rxrpc_cleanup_ring(call);
while ((txb = list_first_entry_or_null(&call->tx_sendmsg, struct rxrpc_txbuf,
... | [
0,
0
] |
Linux Kernel | net/rxrpc/call_object.c | void rxrpc_cleanup_call(struct rxrpc_call *call) {
memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
del_timer(&call->timer);
if (rcu_read_lock_held())
schedule_work(&call->destroyer);
else
... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_client.c |
struct rxrpc_bundle *rxrpc_get_bundle(struct rxrpc_bundle *bundle,
enum rxrpc_bundle_trace why) {
int r;
__refcount_inc(&bundle->ref, &r);
trace_rxrpc_bundle(bundle->debug_id, r + 1, why);
return bundle;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | static bool rxrpc_may_reuse_conn(struct rxrpc_connection *conn) {
struct rxrpc_net *rxnet;
int id_cursor, id, distance, limit;
if (!conn)
goto dont_reuse;
rxnet = conn->rxnet;
if (test_bit(RXRPC_CONN_DONT_REUSE, &conn->flags))
goto dont_reuse;
if (conn->state != RXRPC_CONN_CLIENT || conn->proto.e... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | static void rxrpc_add_conn_to_bundle(struct rxrpc_bundle *bundle, gfp_t gfp)
__releases(bundle->channel_lock) {
struct rxrpc_connection *candidate = NULL, *old = NULL;
bool conflict;
int i;
_enter("");
conflict = bundle->alloc_conn;
if (!conflict)
bundle->alloc_conn = true;
spin_unlock(&bundle->... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | static void rxrpc_maybe_add_conn(struct rxrpc_bundle *bundle, gfp_t gfp) {
struct rxrpc_call *call;
int i, usable;
_enter("");
spin_lock(&bundle->channel_lock);
usable = 0;
for (i = 0; i < ARRAY_SIZE(bundle->conns); i++)
if (rxrpc_may_reuse_conn(bundle->conns[i]))
usable++;
if (!usable && !l... | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | static void rxrpc_activate_channels_locked(struct rxrpc_bundle *bundle) {
struct rxrpc_connection *conn;
unsigned long avail, mask;
unsigned int channel, slot;
if (bundle->try_upgrade)
mask = 1;
else
mask = ULONG_MAX;
while (!list_empty(&bundle->waiting_calls)) {
avail = bundle->avail_chans & ... | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | int rxrpc_connect_call(struct rxrpc_sock *rx, struct rxrpc_call *call,
struct rxrpc_conn_parameters *cp,
struct sockaddr_rxrpc *srx, gfp_t gfp) {
struct rxrpc_bundle *bundle;
struct rxrpc_net *rxnet = cp->local->rxnet;
int ret = 0;
_enter("{%d,%lx},", call->debug_i... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | static void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle) {
struct rxrpc_local *local = bundle->local;
bool need_put = false;
if (atomic_dec_and_lock(&bundle->active, &local->client_bundles_lock)) {
if (!bundle->exclusive) {
_debug("erase bundle");
rb_erase(&bundle->local_node, &local->cli... | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_client.c | void rxrpc_destroy_all_client_connections(struct rxrpc_net *rxnet) {
_enter("");
spin_lock(&rxnet->client_conn_cache_lock);
rxnet->kill_all_client_conns = true;
spin_unlock(&rxnet->client_conn_cache_lock);
del_timer_sync(&rxnet->client_conn_reap_timer);
if (!rxrpc_queue_work(&rxnet->client_conn_reaper))
... | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_event.c | void rxrpc_process_delayed_final_acks(struct rxrpc_connection *conn,
bool force) {
unsigned long j = jiffies, next_j;
unsigned int channel;
bool set;
again:
next_j = j + LONG_MAX;
set = false;
for (channel = 0; channel < RXRPC_MAXCALLS; channel++) {
struct rxrpc_ch... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_object.c |
static void rxrpc_connection_timer(struct timer_list *timer) {
struct rxrpc_connection *conn =
container_of(timer, struct rxrpc_connection, timer);
rxrpc_queue_conn(conn, rxrpc_conn_queue_timer);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_object.c | struct rxrpc_connection *rxrpc_get_connection(struct rxrpc_connection *conn,
enum rxrpc_conn_trace why) {
int r;
__refcount_inc(&conn->ref, &r);
trace_rxrpc_conn(conn->debug_id, r + 1, why);
return conn;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_object.c | static void rxrpc_clean_up_connection(struct work_struct *work) {
struct rxrpc_connection *conn =
container_of(work, struct rxrpc_connection, destructor);
struct rxrpc_net *rxnet = conn->rxnet;
ASSERT(!rcu_access_pointer(conn->channels[0].call) &&
!rcu_access_pointer(conn->channels[1].call) &&
... | [
0,
0
] |
Linux Kernel | net/rxrpc/conn_service.c | struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *peer,
struct sk_buff *skb) {
struct rxrpc_connection *conn = NULL;
struct rxrpc_conn_proto k;
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
struct rb_node *p;
unsigned int seq = 0;
k.e... | [
1,
0
] |
Linux Kernel | net/rxrpc/conn_service.c | void rxrpc_new_incoming_connection(struct rxrpc_sock *rx,
struct rxrpc_connection *conn,
const struct rxrpc_security *sec,
struct sk_buff *skb) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
_enter("");
conn-... | [
1,
0
] |
Linux Kernel | net/rxrpc/input.c |
static void rxrpc_proto_abort(const char *why, struct rxrpc_call *call,
rxrpc_seq_t seq) {
if (rxrpc_abort_call(why, call, seq, RX_PROTOCOL_ERROR, -EBADMSG))
rxrpc_send_abort_packet(call);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/input.c | static bool rxrpc_rotate_tx_window(struct rxrpc_call *call, rxrpc_seq_t to,
struct rxrpc_ack_summary *summary) {
struct rxrpc_txbuf *txb;
bool rot_last = false;
list_for_each_entry_rcu(txb, &call->tx_buffer, call_link, false) {
if (before_eq(txb->seq, call->acks_hard_ack))
... | [
1,
0
] |
Linux Kernel | net/rxrpc/input.c |
static void rxrpc_input_update_ack_window(struct rxrpc_call *call,
rxrpc_seq_t window,
rxrpc_seq_t wtop) {
atomic64_set_release(&call->ackr_window, ((u64)wtop) << 32 | window);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/input.c | static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
enum rxrpc_call_state state;
rxrpc_serial_t serial = sp->hdr.serial;
rxrpc_seq_t seq0 = sp->hdr.seq;
_enter("{%llx,%x},{%u,%x}", atomic64_read(&call->ackr_window),
call->rx_highes... | [
1,
0
] |
Linux Kernel | net/rxrpc/input.c | static void rxrpc_input_soft_acks(struct rxrpc_call *call, u8 *acks,
rxrpc_seq_t seq, int nr_acks,
struct rxrpc_ack_summary *summary) {
unsigned int i;
for (i = 0; i < nr_acks; i++) {
if (acks[i] == RXRPC_ACK_TYPE_ACK) {
summary->nr_acks... | [
1,
0
] |
Linux Kernel | net/rxrpc/input.c | static void rxrpc_input_abort(struct rxrpc_call *call, struct sk_buff *skb) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
trace_rxrpc_rx_abort(call, sp->hdr.serial, skb->priority);
rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, skb->priority,
-ECONNABORTED);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/input.c | void rxrpc_implicit_end_call(struct rxrpc_call *call, struct sk_buff *skb) {
struct rxrpc_connection *conn = call->conn;
switch (READ_ONCE(call->state)) {
case RXRPC_CALL_SERVER_AWAIT_ACK:
rxrpc_call_completed(call);
fallthrough;
case RXRPC_CALL_COMPLETE:
break;
default:
if (rxrpc_abort_call(... | [
0,
1
] |
Linux Kernel | net/rxrpc/insecure.c |
static int none_secure_packet(struct rxrpc_call *call,
struct rxrpc_txbuf *txb) {
return 0;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/insecure.c |
static void none_free_call_crypto(struct rxrpc_call *call) {} | [
0,
0
] |
Linux Kernel | net/rxrpc/insecure.c |
static int none_respond_to_challenge(struct rxrpc_connection *conn,
struct sk_buff *skb, u32 *_abort_code) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
trace_rxrpc_rx_eproto(NULL, sp->hdr.serial, tracepoint_string("chall_none"));
return -EPROTO;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/insecure.c |
static int none_verify_response(struct rxrpc_connection *conn,
struct sk_buff *skb, u32 *_abort_code) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
trace_rxrpc_rx_eproto(NULL, sp->hdr.serial, tracepoint_string("resp_none"));
return -EPROTO;
} | [
0,
0
] |
Linux Kernel | net/rxrpc/insecure.c |
static void none_clear(struct rxrpc_connection *conn) {} | [
0,
0
] |
Linux Kernel | net/rxrpc/io_thread.c | static noinline int rxrpc_extract_header(struct rxrpc_skb_priv *sp,
struct sk_buff *skb) {
struct rxrpc_wire_header whdr;
if (skb_copy_bits(skb, 0, &whdr, sizeof(whdr)) < 0) {
trace_rxrpc_rx_eproto(NULL, sp->hdr.serial, tracepoint_string("bad_hdr"));
return -EBADMSG... | [
1,
0
] |
Linux Kernel | net/rxrpc/key.c | static void rxrpc_free_preparse(struct key_preparsed_payload *prep) {
rxrpc_free_token_list(prep->payload.data[0]);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/key.c | int rxrpc_request_key(struct rxrpc_sock *rx, sockptr_t optval, int optlen) {
struct key *key;
char *description;
_enter("");
if (optlen <= 0 || optlen > PAGE_SIZE - 1 || rx->securities)
return -EINVAL;
description = memdup_sockptr_nul(optval, optlen);
if (IS_ERR(description))
return PTR_ERR(descr... | [
1,
0
] |
Linux Kernel | net/rxrpc/key.c | int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
const void *session_key, time64_t expiry,
u32 kvno) {
const struct cred *cred = current_cred();
struct key *key;
int ret;
struct {
u32 kver;
struct rxrpc_key_data_v1 v1;
} data;
... | [
1,
0
] |
Linux Kernel | net/rxrpc/key.c | struct key *rxrpc_get_null_key(const char *keyname) {
const struct cred *cred = current_cred();
struct key *key;
int ret;
key = key_alloc(&key_type_rxrpc, keyname, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
cred, KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
if (IS_ERR(key))
return key;
ret ... | [
0,
0
] |
Linux Kernel | net/rxrpc/local_object.c | static void rxrpc_encap_err_rcv(struct sock *sk, struct sk_buff *skb, int err,
__be16 port, u32 info, u8 *payload) {
if (ip_hdr(skb)->version == IPVERSION)
return ip_icmp_error(sk, skb, err, port, info, payload);
if (IS_ENABLED(CONFIG_AF_RXRPC_IPV6))
return ipv6_icmp_error(sk... | [
0,
0
] |
Linux Kernel | net/rxrpc/local_object.c | static long rxrpc_local_cmp_key(const struct rxrpc_local *local,
const struct sockaddr_rxrpc *srx) {
long diff;
diff = ((local->srx.transport_type - srx->transport_type) ?:
(local->srx.transport_len - srx->transport_len) ?:
(local->srx.transport.family - srx->transport.family));... | [
1,
0
] |
Linux Kernel | net/rxrpc/local_object.c | static struct rxrpc_local *rxrpc_alloc_local(struct rxrpc_net *rxnet,
const struct sockaddr_rxrpc *srx) {
struct rxrpc_local *local;
local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
if (local) {
refcount_set(&local->ref, 1);
atomic_set(&local->active_u... | [
1,
0
] |
Linux Kernel | net/rxrpc/local_object.c | void rxrpc_unuse_local(struct rxrpc_local *local, enum rxrpc_local_trace why) {
unsigned int debug_id = local->debug_id;
int r, u;
if (local) {
r = refcount_read(&local->ref);
u = atomic_dec_return(&local->active_users);
trace_rxrpc_local(debug_id, why, r, u);
if (u == 0)
kthread_stop(local... | [
1,
0
] |
Linux Kernel | net/rxrpc/net_ns.c |
static void rxrpc_peer_keepalive_timeout(struct timer_list *timer) {
struct rxrpc_net *rxnet =
container_of(timer, struct rxrpc_net, peer_keepalive_timer);
if (rxnet->live)
rxrpc_queue_work(&rxnet->peer_keepalive_work);
} | [
0,
0
] |
Linux Kernel | net/rxrpc/net_ns.c | static __net_exit void rxrpc_exit_net(struct net *net) {
struct rxrpc_net *rxnet = rxrpc_net(net);
rxnet->live = false;
del_timer_sync(&rxnet->peer_keepalive_timer);
cancel_work_sync(&rxnet->peer_keepalive_work);
del_timer_sync(&rxnet->peer_keepalive_timer);
rxrpc_destroy_all_calls(rxnet);
rxrpc_destroy... | [
0,
0
] |
Linux Kernel | net/rxrpc/output.c | int rxrpc_send_abort_packet(struct rxrpc_call *call) {
struct rxrpc_connection *conn;
struct rxrpc_abort_buffer pkt;
struct msghdr msg;
struct kvec iov[1];
rxrpc_serial_t serial;
int ret;
if (rxrpc_is_client_call(call) &&
test_bit(RXRPC_CALL_TX_ALL_ACKED, &call->flags))
return 0;
if (test_bi... | [
1,
0
] |
Linux Kernel | net/rxrpc/output.c | void rxrpc_send_keepalive(struct rxrpc_peer *peer) {
struct rxrpc_wire_header whdr;
struct msghdr msg;
struct kvec iov[2];
size_t len;
int ret;
_enter("");
msg.msg_name = &peer->srx.transport;
msg.msg_namelen = peer->srx.transport_len;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flag... | [
1,
0
] |
Linux Kernel | net/rxrpc/output.c | void rxrpc_transmit_one(struct rxrpc_call *call, struct rxrpc_txbuf *txb) {
int ret;
ret = rxrpc_send_data_packet(call, txb);
if (ret < 0) {
switch (ret) {
case -ENETUNREACH:
case -EHOSTUNREACH:
case -ECONNREFUSED:
rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR, 0, ret);
break... | [
1,
0
] |
Linux Kernel | net/rxrpc/peer_event.c | void rxrpc_input_error(struct rxrpc_local *local, struct sk_buff *skb) {
struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
struct sockaddr_rxrpc srx;
struct rxrpc_peer *peer = NULL;
_enter("L=%x", local->debug_id);
if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) {
_leave("UDP empty mess... | [
1,
0
] |
Linux Kernel | net/rxrpc/peer_event.c | static void rxrpc_store_error(struct rxrpc_peer *peer, struct sk_buff *skb) {
enum rxrpc_call_completion compl= RXRPC_CALL_NETWORK_ERROR;
struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
struct sock_extended_err *ee = &serr->ee;
int err = ee->ee_errno;
_enter("");
switch (ee->ee_origin) {
case SO_EE_ORI... | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.