Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/rds/ib_cm.c |
static void poll_scq(struct rds_ib_connection *ic, struct ib_cq *cq,
struct ib_wc *wcs) {
int nr, i;
struct ib_wc *wc;
while ((nr = ib_poll_cq(cq, RDS_IB_WC_MAX, wcs)) > 0) {
for (i = 0; i < nr; i++) {
wc = wcs + i;
rdsdebug("wc wr_id 0x%llx status %u byte_len %u imm_data %u... | [
0,
0
] |
Linux Kernel | net/rds/ib_cm.c |
static void rds_ib_cq_comp_handler_send(struct ib_cq *cq, void *context) {
struct rds_connection *conn = context;
struct rds_ib_connection *ic = conn->c_transport_data;
rdsdebug("conn %p cq %p\n", conn, cq);
rds_ib_stats_inc(s_ib_evt_handler_call);
tasklet_schedule(&ic->i_send_tasklet);
} | [
0,
0
] |
Linux Kernel | net/rds/ib_cm.c |
static inline int ibdev_get_unused_vector(struct rds_ib_device *rds_ibdev) {
int min = rds_ibdev->vector_load[rds_ibdev->dev->num_comp_vectors - 1];
int index = rds_ibdev->dev->num_comp_vectors - 1;
int i;
for (i = rds_ibdev->dev->num_comp_vectors - 1; i >= 0; i--) {
if (rds_ibdev->vector_load[i] < min) {... | [
1,
0
] |
Linux Kernel | net/rds/ib_cm.c | static struct rds_header **rds_dma_hdrs_alloc(struct rds_ib_device *dev,
dma_addr_t **dma_addrs,
u32 num_hdrs,
enum dma_data_direction dir) {
struct rds_header **hdrs;
dma_addr_t... | [
0,
0
] |
Linux Kernel | net/rds/ib_cm.c | static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event, bool isv6) {
const union rds_ib_conn_priv *dp = event->param.conn.private_data;
u8 data_len, major, minor;
u32 version = 0;
__be16 mask;
u16 common;
/* Be paranoid. RDS always has privdata */
if (!event->param.conn.private_data_len) {
... | [
1,
0
] |
Linux Kernel | net/rds/ib_frmr.c |
static struct rds_ib_mr *rds_ib_alloc_frmr(struct rds_ib_device *rds_ibdev,
int npages) {
struct rds_ib_mr_pool *pool;
struct rds_ib_mr *ibmr = NULL;
struct rds_ib_frmr *frmr;
int err = 0;
if (npages <= RDS_MR_8K_MSG_SIZE)
pool = rds_ibdev->mr_8k_pool;
else
... | [
0,
0
] |
Linux Kernel | net/rds/ib_frmr.c | static void rds_ib_free_frmr(struct rds_ib_mr *ibmr, bool drop) {
struct rds_ib_mr_pool *pool = ibmr->pool;
if (drop)
llist_add(&ibmr->llnode, &pool->drop_list);
else
llist_add(&ibmr->llnode, &pool->free_list);
atomic_add(ibmr->sg_len, &pool->free_pinned);
atomic_inc(&pool->dirty_count);
if (atomi... | [
0,
0
] |
Linux Kernel | net/rds/ib_frmr.c | struct rds_ib_mr *rds_ib_reg_frmr(struct rds_ib_device *rds_ibdev,
struct rds_ib_connection *ic,
struct scatterlist *sg, unsigned long nents,
u32 *key) {
struct rds_ib_mr *ibmr = NULL;
struct rds_ib_frmr *frmr;
i... | [
1,
1
] |
Linux Kernel | net/rds/ib_rdma.c |
static struct rds_ib_device *rds_ib_get_device(__be32 ipaddr) {
struct rds_ib_device *rds_ibdev;
struct rds_ib_ipaddr *i_ipaddr;
rcu_read_lock();
list_for_each_entry_rcu(rds_ibdev, &rds_ib_devices, list) {
list_for_each_entry_rcu(i_ipaddr, &rds_ibdev->ipaddr_list, list) {
if (i_ipaddr->ipaddr == ipa... | [
0,
0
] |
Linux Kernel | net/rds/ib_rdma.c | void rds_ib_destroy_nodev_conns(void) {
struct rds_ib_connection *ic, *_ic;
LIST_HEAD(tmp_list);
spin_lock_irq(&ib_nodev_conns_lock);
list_splice(&ib_nodev_conns, &tmp_list);
spin_unlock_irq(&ib_nodev_conns_lock);
list_for_each_entry_safe(ic, _ic, &tmp_list, ib_node)
rds_conn_destroy(ic->conn);
} | [
0,
0
] |
Linux Kernel | net/rds/ib_rdma.c | static void list_to_llist_nodes(struct list_head *list,
struct llist_node **nodes_head,
struct llist_node **nodes_tail) {
struct rds_ib_mr *ibmr;
struct llist_node *cur = NULL;
struct llist_node **next = nodes_head;
list_for_each_entry(ibmr, list,... | [
0,
0
] |
Linux Kernel | net/rds/ib_rdma.c |
void rds_ib_flush_mrs(void) {
struct rds_ib_device *rds_ibdev;
down_read(&rds_ib_devices_lock);
list_for_each_entry(rds_ibdev, &rds_ib_devices, list) {
if (rds_ibdev->mr_8k_pool)
rds_ib_flush_mr_pool(rds_ibdev->mr_8k_pool, 0, NULL);
if (rds_ibdev->mr_1m_pool)
rds_ib_flush_mr_pool(rds_ibdev-... | [
0,
0
] |
Linux Kernel | net/rds/ib_rdma.c |
void rds_ib_destroy_mr_pool(struct rds_ib_mr_pool *pool) {
cancel_delayed_work_sync(&pool->flush_worker);
rds_ib_flush_mr_pool(pool, 1, NULL);
WARN_ON(atomic_read(&pool->item_count));
WARN_ON(atomic_read(&pool->free_pinned));
kfree(pool);
} | [
0,
0
] |
Linux Kernel | net/rds/ib_rdma.c | struct rds_ib_mr_pool *rds_ib_create_mr_pool(struct rds_ib_device *rds_ibdev,
int pool_type) {
struct rds_ib_mr_pool *pool;
pool = kzalloc(sizeof(*pool), GFP_KERNEL);
if (!pool)
return ERR_PTR(-ENOMEM);
pool->pool_type = pool_type;
init_llist_head(&pool->free... | [
1,
0
] |
Linux Kernel | net/rds/ib_rdma.c | void rds_ib_mr_exit(void) { destroy_workqueue(rds_ib_mr_wq); } | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
void rds_ib_recv_init_ring(struct rds_ib_connection *ic) {
struct rds_ib_recv_work *recv;
u32 i;
for (i = 0, recv = ic->i_recvs; i < ic->i_recv_ring.w_nr; i++, recv++) {
struct ib_sge *sge;
recv->r_ibinc = NULL;
recv->r_frag = NULL;
recv->r_wr.next = NULL;
recv->r_wr.wr_id = i;
recv->r... | [
1,
0
] |
Linux Kernel | net/rds/ib_recv.c |
static int rds_ib_recv_alloc_cache(struct rds_ib_refill_cache *cache,
gfp_t gfp) {
struct rds_ib_cache_head *head;
int cpu;
cache->percpu = alloc_percpu_gfp(struct rds_ib_cache_head, gfp);
if (!cache->percpu)
return -ENOMEM;
for_each_possible_cpu(cpu) {
head = per... | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
static void rds_ib_cache_splice_all_lists(struct rds_ib_refill_cache *cache,
struct list_head *caller_list) {
struct rds_ib_cache_head *head;
int cpu;
for_each_possible_cpu(cpu) {
head = per_cpu_ptr(cache->percpu, cpu);
if (head->first) {
list_splice_entir... | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
void rds_ib_recv_free_caches(struct rds_ib_connection *ic) {
struct rds_ib_incoming *inc;
struct rds_ib_incoming *inc_tmp;
struct rds_page_frag *frag;
struct rds_page_frag *frag_tmp;
LIST_HEAD(list);
rds_ib_cache_xfer_to_ready(&ic->i_cache_incs);
rds_ib_cache_splice_all_lists(&ic->i_cache_incs, &list);
... | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
static struct rds_page_frag *
rds_ib_refill_one_frag(struct rds_ib_connection *ic, gfp_t slab_mask,
gfp_t page_mask) {
struct rds_page_frag *frag;
struct list_head *cache_item;
int ret;
cache_item = rds_ib_recv_cache_get(&ic->i_cache_frags);
if (cache_item) {
frag = container_of(c... | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c | int rds_ib_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to) {
struct rds_ib_incoming *ibinc;
struct rds_page_frag *frag;
unsigned long to_copy;
unsigned long frag_off = 0;
int copied = 0;
int ret;
u32 len;
ibinc = container_of(inc, struct rds_ib_incoming, ii_inc);
frag = list_entry(ibi... | [
1,
1
] |
Linux Kernel | net/rds/ib_recv.c |
static u64 rds_ib_get_ack(struct rds_ib_connection *ic) {
unsigned long flags;
u64 seq;
clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
spin_lock_irqsave(&ic->i_ack_lock, flags);
seq = ic->i_ack_next;
spin_unlock_irqrestore(&ic->i_ack_lock, flags);
return seq;
}
#else | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
static u64 rds_ib_get_ack(struct rds_ib_connection *ic) {
clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
smp_mb__after_atomic();
return atomic64_read(&ic->i_ack_next);
}
#endif | [
0,
0
] |
Linux Kernel | net/rds/ib_recv.c |
int rds_ib_recv_path(struct rds_conn_path *cp) {
struct rds_connection *conn = cp->cp_conn;
struct rds_ib_connection *ic = conn->c_transport_data;
rdsdebug("conn %p\n", conn);
if (rds_conn_up(conn)) {
rds_ib_attempt_ack(ic);
rds_ib_recv_refill(conn, 0, GFP_KERNEL);
rds_ib_stats_inc(s_ib_rx_refill_... | [
0,
0
] |
Linux Kernel | net/rds/ib_ring.c |
u32 rds_ib_ring_alloc(struct rds_ib_work_ring *ring, u32 val, u32 *pos) {
u32 ret = 0, avail;
avail = ring->w_nr - __rds_ib_ring_used(ring);
rdsdebug("ring %p val %u next %u free %u\n", ring, val, ring->w_alloc_ptr,
avail);
if (val && avail) {
ret = min(val, avail);
*pos = ring->w_alloc_p... | [
1,
0
] |
Linux Kernel | net/rds/ib_send.c | static void rds_ib_send_complete(struct rds_message *rm, int wc_status,
void (*complete)(struct rds_message *rm,
int status)) {
int notify_status;
switch (wc_status) {
case IB_WC_WR_FLUSH_ERR:
return;
case IB_WC_SUCCESS:
... | [
0,
0
] |
Linux Kernel | net/rds/ib_send.c | static void rds_ib_send_unmap_rdma(struct rds_ib_connection *ic,
struct rm_rdma_op *op, int wc_status) {
if (op->op_mapped) {
ib_dma_unmap_sg(ic->i_cm_id->device, op->op_sg, op->op_nents,
op->op_write ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
op->op_mapped = 0;... | [
0,
0
] |
Linux Kernel | net/rds/ib_send.c | static void rds_ib_send_unmap_atomic(struct rds_ib_connection *ic,
struct rm_atomic_op *op, int wc_status) {
if (op->op_mapped) {
ib_dma_unmap_sg(ic->i_cm_id->device, op->op_sg, 1, DMA_FROM_DEVICE);
op->op_mapped = 0;
}
rds_ib_send_complete(container_of(op, struct rd... | [
0,
0
] |
Linux Kernel | net/rds/ib_send.c | static struct rds_message *rds_ib_send_unmap_op(struct rds_ib_connection *ic,
struct rds_ib_send_work *send,
int wc_status) {
struct rds_message *rm = NULL;
switch (send->s_wr.opcode) {
case IB_WR_SEND:
if (send->... | [
1,
0
] |
Linux Kernel | net/rds/ib_send.c |
void rds_ib_send_init_ring(struct rds_ib_connection *ic) {
struct rds_ib_send_work *send;
u32 i;
for (i = 0, send = ic->i_sends; i < ic->i_send_ring.w_nr; i++, send++) {
struct ib_sge *sge;
send->s_op = NULL;
send->s_wr.wr_id = i;
send->s_wr.sg_list = send->s_sge;
send->s_wr.ex.imm_data = ... | [
1,
0
] |
Linux Kernel | net/rds/ib_send.c |
void rds_ib_send_add_credits(struct rds_connection *conn,
unsigned int credits) {
struct rds_ib_connection *ic = conn->c_transport_data;
if (credits == 0)
return;
rdsdebug("credits=%u current=%u%s\n", credits,
IB_GET_SEND_CREDITS(atomic_read(&ic->i_credits)),
... | [
0,
0
] |
Linux Kernel | net/rds/loop.c | static int rds_loop_conn_alloc(struct rds_connection *conn, gfp_t gfp) {
struct rds_loop_connection *lc;
unsigned long flags;
lc = kzalloc(sizeof(struct rds_loop_connection), gfp);
if (!lc)
return -ENOMEM;
INIT_LIST_HEAD(&lc->loop_node);
lc->conn = conn;
conn->c_transport_data = lc;
spin_lock_irq... | [
0,
0
] |
Linux Kernel | net/rds/loop.c |
static void rds_loop_conn_free(void *arg) {
struct rds_loop_connection *lc = arg;
unsigned long flags;
rdsdebug("lc %p\n", lc);
spin_lock_irqsave(&loop_conns_lock, flags);
list_del(&lc->loop_node);
spin_unlock_irqrestore(&loop_conns_lock, flags);
kfree(lc);
} | [
0,
0
] |
Linux Kernel | net/rds/loop.c |
void rds_loop_net_exit(void) { unregister_pernet_device(&rds_loop_net_ops); } | [
0,
0
] |
Linux Kernel | net/rds/message.c | static void rds_message_purge(struct rds_message *rm) {
unsigned long i, flags;
bool zcopy = false;
if (unlikely(test_bit(RDS_MSG_PAGEVEC, &rm->m_flags)))
return;
spin_lock_irqsave(&rm->m_rs_lock, flags);
if (rm->m_rs) {
struct rds_sock *rs = rm->m_rs;
if (rm->data.op_mmp_znotifier) {
zco... | [
0,
1
] |
Linux Kernel | net/rds/message.c | int rds_message_add_extension(struct rds_header *hdr, unsigned int type,
const void *data, unsigned int len) {
unsigned int ext_len = sizeof(u8) + len;
unsigned char *dst;
if (hdr->h_exthdr[0] != RDS_EXTHDR_NONE)
return 0;
if (type >= __RDS_EXTHDR_MAX || len != rds_exthdr_siz... | [
1,
0
] |
Linux Kernel | net/rds/message.c | struct rds_message *rds_message_alloc(unsigned int extra_len, gfp_t gfp) {
struct rds_message *rm;
if (extra_len > KMALLOC_MAX_SIZE - sizeof(struct rds_message))
return NULL;
rm = kzalloc(sizeof(struct rds_message) + extra_len, gfp);
if (!rm)
goto out;
rm->m_used_sgs = 0;
rm->m_total_sgs = extra_... | [
1,
0
] |
Linux Kernel | net/rds/message.c |
void rds_message_unmapped(struct rds_message *rm) {
clear_bit(RDS_MSG_MAPPED, &rm->m_flags);
wake_up_interruptible(&rm->m_flush_wait);
} | [
0,
0
] |
Linux Kernel | net/rds/rdma.c | static unsigned int rds_pages_in_vec(struct rds_iovec *vec) {
if ((vec->addr + vec->bytes <= vec->addr) || (vec->bytes > (u64)UINT_MAX))
return 0;
return ((vec->addr + vec->bytes + PAGE_SIZE - 1) >> PAGE_SHIFT) -
(vec->addr >> PAGE_SHIFT);
} | [
1,
1
] |
Linux Kernel | net/rds/rdma.c |
static struct rds_mr *rds_mr_tree_walk(struct rb_root *root, u64 key,
struct rds_mr *insert) {
struct rb_node **p = &root->rb_node;
struct rb_node *parent = NULL;
struct rds_mr *mr;
while (*p) {
parent = *p;
mr = rb_entry(parent, struct rds_mr, r_rb_node);
i... | [
0,
0
] |
Linux Kernel | net/rds/rdma.c | void rds_rdma_drop_keys(struct rds_sock *rs) {
struct rds_mr *mr;
struct rb_node *node;
unsigned long flags;
spin_lock_irqsave(&rs->rs_rdma_lock, flags);
while ((node = rb_first(&rs->rs_rdma_keys))) {
mr = rb_entry(node, struct rds_mr, r_rb_node);
if (mr->r_trans == rs->rs_transport)
mr->r_inva... | [
1,
0
] |
Linux Kernel | net/rds/rdma.c | static int rds_pin_pages(unsigned long user_addr, unsigned int nr_pages,
struct page **pages, int write) {
unsigned int gup_flags = FOLL_LONGTERM;
int ret;
if (write)
gup_flags |= FOLL_WRITE;
ret = pin_user_pages_fast(user_addr, nr_pages, gup_flags, pages);
if (ret >= 0 && ret <... | [
1,
0
] |
Linux Kernel | net/rds/rdma.c | int rds_get_mr_for_dest(struct rds_sock *rs, sockptr_t optval, int optlen) {
struct rds_get_mr_for_dest_args args;
struct rds_get_mr_args new_args;
if (optlen != sizeof(struct rds_get_mr_for_dest_args))
return -EINVAL;
if (copy_from_sockptr(&args, optval, sizeof(struct rds_get_mr_for_dest_args)))
retu... | [
1,
1
] |
Linux Kernel | net/rds/rdma.c | void rds_atomic_free_op(struct rm_atomic_op *ao) {
struct page *page = sg_page(ao->op_sg);
unpin_user_pages_dirty_lock(&page, 1, true);
kfree(ao->op_notifier);
ao->op_notifier = NULL;
ao->op_active = 0;
} | [
0,
0
] |
Linux Kernel | net/rds/rdma.c | int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
struct cmsghdr *cmsg) {
unsigned long flags;
struct rds_mr *mr;
u32 r_key;
int err = 0;
if (cmsg->cmsg_len < CMSG_LEN(sizeof(rds_rdma_cookie_t)) ||
rm->m_rdma_cookie != 0)
return -EINVAL;
memcpy(&rm->m_rdm... | [
1,
0
] |
Linux Kernel | net/rds/rdma_transport.c | static int rds_rdma_listen_init_common(rdma_cm_event_handler handler,
struct sockaddr *sa,
struct rdma_cm_id **ret_cm_id) {
struct rdma_cm_id *cm_id;
int ret;
cm_id = rdma_create_id(&init_net, handler, NULL, RDMA_PS_TCP, IB_QPT_RC);
... | [
0,
1
] |
Linux Kernel | net/rds/rds.h | static inline u32 rds_rdma_cookie_offset(rds_rdma_cookie_t cookie) {
return cookie >> 32;
}
#define RDS_ATOMIC_TYPE_CSWP 0
#define RDS_ATOMIC_TYPE_FADD 1
/*
* m_sock_item and m_conn_item are on lists that are serialized under
* conn->c_lock. m_sock_item has additional meaning in that once it is empty
* the mess... | [
0,
0
] |
Linux Kernel | net/rds/rds.h |
static inline struct rds_sock *rds_sk_to_rs(const struct sock *sk) {
return container_of(sk, struct rds_sock, rs_sk);
} | [
0,
0
] |
Linux Kernel | net/rds/rds.h |
static inline int rds_conn_path_state(struct rds_conn_path *cp) {
return atomic_read(&cp->cp_state);
} | [
0,
0
] |
Linux Kernel | net/rds/rds.h |
static inline int rds_conn_state(struct rds_connection *conn) {
WARN_ON(conn->c_trans->t_mp_capable);
return rds_conn_path_state(&conn->c_path[0]);
} | [
0,
0
] |
Linux Kernel | net/rds/rds.h |
static inline int rds_conn_up(struct rds_connection *conn) {
WARN_ON(conn->c_trans->t_mp_capable);
return rds_conn_path_up(&conn->c_path[0]);
} | [
0,
0
] |
Linux Kernel | net/rds/rds.h |
static inline int rds_conn_connecting(struct rds_connection *conn) {
WARN_ON(conn->c_trans->t_mp_capable);
return rds_conn_path_connecting(&conn->c_path[0]);
} | [
0,
0
] |
Linux Kernel | net/rds/recv.c |
void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
struct in6_addr *saddr) {
refcount_set(&inc->i_refcount, 1);
INIT_LIST_HEAD(&inc->i_item);
inc->i_conn = conn;
inc->i_saddr = *saddr;
inc->i_usercopy.rdma_cookie = 0;
inc->i_usercopy.rx_tstamp = ktime_set(0, 0);
m... | [
1,
0
] |
Linux Kernel | net/rds/send.c |
static void rds_send_sndbuf_remove(struct rds_sock *rs,
struct rds_message *rm) {
u32 len = be32_to_cpu(rm->m_inc.i_hdr.h_len);
assert_spin_locked(&rs->rs_lock);
BUG_ON(rs->rs_snd_bytes < len);
rs->rs_snd_bytes -= len;
if (rs->rs_snd_bytes == 0)
rds_stats_inc(s_send_... | [
0,
0
] |
Linux Kernel | net/rds/send.c | static inline void __rds_send_complete(struct rds_sock *rs,
struct rds_message *rm, int status) {
struct rm_rdma_op *ro;
struct rm_atomic_op *ao;
ro = &rm->rdma;
if (ro->op_active && ro->op_notify && ro->op_notifier) {
ro->op_notifier->n_status = status;
list_add_... | [
1,
0
] |
Linux Kernel | net/rds/send.c | static void rds_send_remove_from_sock(struct list_head *messages, int status) {
unsigned long flags;
struct rds_sock *rs = NULL;
struct rds_message *rm;
while (!list_empty(messages)) {
int was_on_sock = 0;
rm = list_entry(messages->next, struct rds_message, m_conn_item);
list_del_init(&rm->m_conn_... | [
1,
0
] |
Linux Kernel | net/rds/stats.c |
void rds_stats_exit(void) {
rds_info_deregister_func(RDS_INFO_COUNTERS, rds_stats_info);
} | [
0,
0
] |
Linux Kernel | net/rds/tcp.c | void rds_tcp_set_callbacks(struct socket *sock, struct rds_conn_path *cp) {
struct rds_tcp_connection *tc = cp->cp_transport_data;
rdsdebug("setting sock %p callbacks to tc %p\n", sock, tc);
write_lock_bh(&sock->sk->sk_callback_lock);
spin_lock(&rds_tcp_tc_list_lock);
list_add_tail(&tc->t_list_item, &rds_tc... | [
1,
0
] |
Linux Kernel | net/rds/tcp.c | int rds_tcp_laddr_check(struct net *net, const struct in6_addr *addr,
__u32 scope_id) {
struct net_device *dev = NULL;
#if IS_ENABLED(CONFIG_IPV6)
int ret;
#endif
if (ipv6_addr_v4mapped(addr)) {
if (inet_addr_type(net, addr->s6_addr32[3]) == RTN_LOCAL)
return 0;
return -EADD... | [
0,
0
] |
Linux Kernel | net/rds/tcp.c |
static void rds_tcp_conn_free(void *arg) {
struct rds_tcp_connection *tc = arg;
unsigned long flags;
rdsdebug("freeing tc %p\n", tc);
spin_lock_irqsave(&rds_tcp_conn_lock, flags);
if (!tc->t_tcp_node_detached)
list_del(&tc->t_tcp_node);
spin_unlock_irqrestore(&rds_tcp_conn_lock, flags);
kmem_cache... | [
0,
0
] |
Linux Kernel | net/rds/tcp.c |
static int rds_tcp_conn_alloc(struct rds_connection *conn, gfp_t gfp) {
struct rds_tcp_connection *tc;
int i, j;
int ret = 0;
for (i = 0; i < RDS_MPATH_WORKERS; i++) {
tc = kmem_cache_alloc(rds_tcp_conn_slab, gfp);
if (!tc) {
ret = -ENOMEM;
goto fail;
}
mutex_init(&tc->t_conn_path_... | [
1,
0
] |
Linux Kernel | net/rds/tcp.c |
static void rds_tcp_set_unloading(void) { atomic_set(&rds_tcp_unloading, 1); } | [
0,
0
] |
Linux Kernel | net/rds/tcp.c |
static bool rds_tcp_is_unloading(struct rds_connection *conn) {
return atomic_read(&rds_tcp_unloading) != 0;
} | [
0,
0
] |
Linux Kernel | net/rds/tcp.c | static void rds_tcp_destroy_conns(void) {
struct rds_tcp_connection *tc, *_tc;
LIST_HEAD(tmp_list);
spin_lock_irq(&rds_tcp_conn_lock);
list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) {
if (!list_has_conn(&tmp_list, tc->t_cpath->cp_conn))
list_move_tail(&tc->t_tcp_node, &tmp_list);
... | [
0,
0
] |
Linux Kernel | net/rds/tcp.c | static u8 rds_tcp_get_tos_map(u8 tos) { return 0; } | [
0,
0
] |
Linux Kernel | net/rds/tcp.c |
static void rds_tcp_kill_sock(struct net *net) {
struct rds_tcp_connection *tc, *_tc;
LIST_HEAD(tmp_list);
struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
struct socket *lsock = rtn->rds_tcp_listen_sock;
rtn->rds_tcp_listen_sock = NULL;
rds_tcp_listen_stop(lsock, &rtn->rds_tcp_accept_w);
spin... | [
0,
0
] |
Linux Kernel | net/rds/tcp.c |
static int rds_tcp_skbuf_handler(struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *fpos) {
struct net *net = current->nsproxy->net_ns;
int err;
err = proc_dointvec_minmax(ctl, write, buffer, lenp, fpos);
if (err < 0) {
pr_warn("Invalid input. Must be >=... | [
1,
0
] |
Linux Kernel | net/rds/tcp_listen.c | void rds_tcp_keepalive(struct socket *sock) {
int keepidle = 5; /* send a probe 'keepidle' secs after last data */
int keepcnt = 5; /* number of unack'ed probes before declaring dead */
sock_set_keepalive(sock->sk);
tcp_sock_set_keepcnt(sock->sk, keepcnt);
tcp_sock_set_keepidle(sock->sk, keepidle);
/* KE... | [
0,
0
] |
Linux Kernel | net/rds/tcp_recv.c | void rds_tcp_data_ready(struct sock *sk) {
void (*ready)(struct sock *sk);
struct rds_conn_path *cp;
struct rds_tcp_connection *tc;
rdsdebug("data ready sk %p\n", sk);
read_lock_bh(&sk->sk_callback_lock);
cp = sk->sk_user_data;
if (!cp) {
ready = sk->sk_data_ready;
goto out;
}
tc = cp->cp_t... | [
0,
0
] |
Linux Kernel | net/rds/tcp_send.c |
void rds_tcp_xmit_path_complete(struct rds_conn_path *cp) {
struct rds_tcp_connection *tc = cp->cp_transport_data;
tcp_sock_set_cork(tc->t_sock->sk, false);
} | [
0,
0
] |
Linux Kernel | net/rds/threads.c |
void rds_connect_worker(struct work_struct *work) {
struct rds_conn_path *cp =
container_of(work, struct rds_conn_path, cp_conn_w.work);
struct rds_connection *conn = cp->cp_conn;
int ret;
if (cp->cp_index > 0 &&
rds_addr_cmp(&cp->cp_conn->c_laddr, &cp->cp_conn->c_faddr) >= 0)
return;
clear_... | [
0,
0
] |
Linux Kernel | net/rds/transport.c |
void rds_trans_put(struct rds_transport *trans) {
if (trans)
module_put(trans->t_owner);
} | [
0,
0
] |
Linux Kernel | net/rds/transport.c | unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,
unsigned int avail)
{
struct rds_transport *trans;
unsigned int total = 0;
unsigned int part;
int i;
rds_info_iter_unmap(iter);
down_read(&rds_trans_sem);
for (i = 0; i < RDS_TRANS_COUNT; i++) ... | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static int rfkill_led_trigger_activate(struct led_classdev *led) {
struct rfkill *rfkill;
rfkill = container_of(led->trigger, struct rfkill, led_trigger);
rfkill_led_trigger_event(rfkill);
return 0;
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
const char *rfkill_get_led_trigger_name(struct rfkill *rfkill) {
return rfkill->led_trigger.name;
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static inline int rfkill_led_trigger_register(struct rfkill *rfkill) {
return 0;
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static int rfkill_global_led_trigger_register(void) { return 0; } | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | static void rfkill_global_led_trigger_unregister(void) {}
#endif | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static void rfkill_fill_event(struct rfkill_event_ext *ev,
struct rfkill *rfkill, enum rfkill_operation op) {
unsigned long flags;
ev->idx = rfkill->idx;
ev->type = rfkill->type;
ev->op = op;
spin_lock_irqsave(&rfkill->lock, flags);
ev->hard = !!(rfkill->state & RFKILL_BLOCK... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | static void rfkill_event(struct rfkill *rfkill) {
if (!rfkill->registered)
return;
kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
rfkill_send_events(rfkill, RFKILL_OP_CHANGE);
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | static void rfkill_set_block(struct rfkill *rfkill, bool blocked) {
unsigned long flags;
bool prev, curr;
int err;
if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
return;
if (rfkill->ops->query)
rfkill->ops->query(rfkill, rfkill->data);
spin_lock_irqsave(&rfkill->lock, flags);... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static void rfkill_update_global_state(enum rfkill_type type, bool blocked) {
int i;
if (type != RFKILL_TYPE_ALL) {
rfkill_global_states[type].cur = blocked;
return;
}
for (i = 0; i < NUM_RFKILL_TYPES; i++)
rfkill_global_states[i].cur = blocked;
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | bool rfkill_is_epo_lock_active(void) { return rfkill_epo_lock_active; } | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t type_show(struct device *dev, struct device_attribute *attr,
char *buf) {
struct rfkill *rfkill = to_rfkill(dev);
return sprintf(buf, "%s\n", rfkill_types[rfkill->type]);
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t index_show(struct device *dev, struct device_attribute *attr,
char *buf) {
struct rfkill *rfkill = to_rfkill(dev);
return sprintf(buf, "%d\n", rfkill->idx);
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t persistent_show(struct device *dev,
struct device_attribute *attr, char *buf) {
struct rfkill *rfkill = to_rfkill(dev);
return sprintf(buf, "%d\n", rfkill->persistent);
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t hard_show(struct device *dev, struct device_attribute *attr,
char *buf) {
struct rfkill *rfkill = to_rfkill(dev);
return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0);
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static u8 user_state_from_blocked(unsigned long state) {
if (state & RFKILL_BLOCK_HW)
return RFKILL_USER_STATE_HARD_BLOCKED;
if (state & RFKILL_BLOCK_SW)
return RFKILL_USER_STATE_SOFT_BLOCKED;
return RFKILL_USER_STATE_UNBLOCKED;
} | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t state_show(struct device *dev, struct device_attribute *attr,
char *buf) {
struct rfkill *rfkill = to_rfkill(dev);
return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state));
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static ssize_t state_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count) {
struct rfkill *rfkill = to_rfkill(dev);
unsigned long state;
int err;
if (!capable(CAP_NET_ADMIN))
return -EPERM;
err = kstrtoul(buf, 0, &state);
if (err)
retu... | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env) {
struct rfkill *rfkill = to_rfkill(dev);
unsigned long flags;
unsigned long reasons;
u32 state;
int error;
error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
if (error)
return error;
error = add_uevent_var(env... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
void rfkill_pause_polling(struct rfkill *rfkill) {
BUG_ON(!rfkill);
if (!rfkill->ops->poll)
return;
rfkill->polling_paused = true;
cancel_delayed_work_sync(&rfkill->poll_work);
} | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
struct rfkill *__must_check rfkill_alloc(const char *name,
struct device *parent,
const enum rfkill_type type,
const struct rfkill_ops *ops,
void *ops_data... | [
1,
0
] |
Linux Kernel | net/rfkill/core.c |
int __must_check rfkill_register(struct rfkill *rfkill) {
static unsigned long rfkill_no;
struct device *dev;
int error;
if (!rfkill)
return -EINVAL;
dev = &rfkill->dev;
mutex_lock(&rfkill_global_mutex);
if (rfkill->registered) {
error = -EALREADY;
goto unlock;
}
rfkill->idx = rfkill... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c |
void rfkill_unregister(struct rfkill *rfkill) {
BUG_ON(!rfkill);
if (rfkill->ops->poll)
cancel_delayed_work_sync(&rfkill->poll_work);
cancel_work_sync(&rfkill->uevent_work);
cancel_work_sync(&rfkill->sync_work);
rfkill->registered = false;
device_del(&rfkill->dev);
mutex_lock(&rfkill_global_mute... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | static int rfkill_fop_open(struct inode *inode, struct file *file) {
struct rfkill_data *data;
struct rfkill *rfkill;
struct rfkill_int_event *ev, *tmp;
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->max_size = RFKILL_EVENT_SIZE_V1;
INIT_LIST_HEAD(&data->events);
mute... | [
0,
0
] |
Linux Kernel | net/rfkill/core.c | static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos) {
struct rfkill_data *data = file->private_data;
struct rfkill *rfkill;
struct rfkill_event_ext ev;
int ret;
if (count < RFKILL_EVENT_SIZE_V1 - 1)
return -EINVAL;
/*
... | [
1,
0
] |
Linux Kernel | net/rfkill/input.c | static void __rfkill_handle_global_op(enum rfkill_sched_op op) {
unsigned int i;
switch (op) {
case RFKILL_GLOBAL_OP_EPO:
rfkill_epo();
break;
case RFKILL_GLOBAL_OP_RESTORE:
rfkill_restore_states();
break;
case RFKILL_GLOBAL_OP_UNLOCK:
rfkill_remove_epo_lock();
break;
case RFKILL_GL... | [
0,
0
] |
Linux Kernel | net/rfkill/input.c | static void rfkill_schedule_global_op(enum rfkill_sched_op op) {
unsigned long flags;
spin_lock_irqsave(&rfkill_op_lock, flags);
rfkill_op = op;
rfkill_op_pending = true;
if (op == RFKILL_GLOBAL_OP_EPO && !rfkill_is_epo_lock_active()) {
mod_delayed_work(system_wq, &rfkill_op_work, 0);
rfkill_last_sc... | [
0,
0
] |
Linux Kernel | net/rfkill/input.c |
static void rfkill_schedule_toggle(enum rfkill_type type) {
unsigned long flags;
if (rfkill_is_epo_lock_active())
return;
spin_lock_irqsave(&rfkill_op_lock, flags);
if (!rfkill_op_pending) {
__set_bit(type, rfkill_sw_pending);
__change_bit(type, rfkill_sw_state);
rfkill_schedule_ratelimited()... | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.