Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/sunrpc/xprtrdma/xprt_rdma.h |
static inline struct rpcrdma_req *rpcr_to_rdmar(const struct rpc_rqst *rqst) {
return container_of(rqst, struct rpcrdma_req, rl_slot);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/xprt_rdma.h |
static inline const char *rpcrdma_addrstr(const struct rpcrdma_xprt *r_xprt) {
return r_xprt->rx_xprt.address_strings[RPC_DISPLAY_ADDR];
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/xprt_rdma.h | static inline bool rpcrdma_regbuf_dma_map(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_regbuf *rb) {
if (likely(rpcrdma_regbuf_is_mapped(rb)))
return true;
return __rpcrdma_regbuf_dma_map(r_xprt, rb);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static inline struct rpc_xprt *xprt_from_sock(struct sock *sk) {
return (struct rpc_xprt *)sk->sk_user_data;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static inline struct sockaddr_un *xs_addr_un(struct rpc_xprt *xprt) {
return (struct sockaddr_un *)&xprt->addr;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_free_peer_addresses(struct rpc_xprt *xprt) {
unsigned int i;
for (i = 0; i < RPC_DISPLAY_MAX; i++)
switch (i) {
case RPC_DISPLAY_PROTO:
case RPC_DISPLAY_NETID:
continue;
default:
kfree(xprt->address_strings[i]);
}
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static size_t xs_alloc_sparse_pages(struct xdr_buf *buf, size_t want,
gfp_t gfp) {
size_t i, n;
if (!want || !(buf->flags & XDRBUF_SPARSE_PAGES))
return want;
n = (buf->page_base + want + PAGE_SIZE - 1) >> PAGE_SHIFT;
for (i = 0; i < n; i++) {
if (buf->pages[i])
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static ssize_t xs_sock_recvmsg(struct socket *sock, struct msghdr *msg,
int flags, size_t seek) {
ssize_t ret;
if (seek != 0)
iov_iter_advance(&msg->msg_iter, seek);
ret = sock_recvmsg(sock, msg, flags);
return ret > 0 ? ret + seek : ret;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_read_header(struct sock_xprt *transport, struct xdr_buf *buf) {
if (!transport->recv.copied) {
if (buf->head[0].iov_len >= transport->recv.offset)
memcpy(buf->head[0].iov_base, &transport->recv.xid,
transport->recv.offset);
transport->recv.copied = transport->recv.offset;
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static ssize_t xs_read_stream_reply(struct sock_xprt *transport,
struct msghdr *msg, int flags) {
struct rpc_xprt *xprt = &transport->xprt;
struct rpc_rqst *req;
ssize_t ret = 0;
spin_lock(&xprt->queue_lock);
req = xprt_lookup_rqst(xprt, transport->recv.xid);
if (!req ||... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static ssize_t xs_read_stream(struct sock_xprt *transport, int flags) {
struct msghdr msg = {0};
size_t want, read = 0;
ssize_t ret = 0;
if (transport->recv.len == 0) {
want = xs_read_stream_headersize(transport->recv.copied != 0);
ret = xs_read_stream_header(transport, &msg, flags, want,
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_poll_check_readable(struct sock_xprt *transport) {
clear_bit(XPRT_SOCK_DATA_READY, &transport->sock_state);
if (!xs_poll_socket_readable(transport))
return;
if (!test_and_set_bit(XPRT_SOCK_DATA_READY, &transport->sock_state))
queue_work(xprtiod_workqueue, &transport->recv_worker);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_stream_data_receive_workfn(struct work_struct *work) {
struct sock_xprt *transport =
container_of(work, struct sock_xprt, recv_worker);
unsigned int pflags = memalloc_nofs_save();
xs_stream_data_receive(transport);
memalloc_nofs_restore(pflags);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static int xs_nospace(struct rpc_rqst *req, struct sock_xprt *transport) {
struct rpc_xprt *xprt = &transport->xprt;
struct sock *sk = transport->inet;
int ret = -EAGAIN;
trace_rpc_socket_nospace(req, transport);
spin_lock(&xprt->transport_lock);
/* Don't race with disconnect */
if (xprt_connected(xprt... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static int xs_stream_prepare_request(struct rpc_rqst *req,
struct xdr_buf *buf) {
return xdr_alloc_bvec(buf, rpc_task_gfp_mask());
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_save_old_callbacks(struct sock_xprt *transport,
struct sock *sk) {
transport->old_data_ready = sk->sk_data_ready;
transport->old_state_change = sk->sk_state_change;
transport->old_write_space = sk->sk_write_space;
transport->old_error_report = sk->sk_error_repor... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_run_error_worker(struct sock_xprt *transport, unsigned int nr) {
set_bit(nr, &transport->sock_state);
queue_work(xprtiod_workqueue, &transport->error_worker);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_destroy(struct rpc_xprt *xprt) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
dprintk("RPC: xs_destroy xprt %p\n", xprt);
cancel_delayed_work_sync(&transport->connect_worker);
xs_close(xprt);
cancel_work_sync(&transport->recv_worker);
cancel_work_sync(&tran... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_udp_data_receive(struct sock_xprt *transport) {
struct sk_buff *skb;
struct sock *sk;
int err;
mutex_lock(&transport->recv_mutex);
sk = transport->inet;
if (sk == NULL)
goto out;
for (;;) {
skb = skb_recv_udp(sk, MSG_DONTWAIT, &err);
if (skb == NULL)
break;
xs_udp_da... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_udp_data_receive_workfn(struct work_struct *work) {
struct sock_xprt *transport =
container_of(work, struct sock_xprt, recv_worker);
unsigned int pflags = memalloc_nofs_save();
xs_udp_data_receive(transport);
memalloc_nofs_restore(pflags);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_tcp_force_close(struct rpc_xprt *xprt) {
xprt_force_disconnect(xprt);
}
#if defined(CONFIG_SUNRPC_BACKCHANNEL) | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static size_t xs_tcp_bc_maxpayload(struct rpc_xprt *xprt) { return PAGE_SIZE; }
#endif | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_udp_write_space(struct sock *sk) {
if (sock_writeable(sk))
xs_write_space(sk);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_udp_timer(struct rpc_xprt *xprt, struct rpc_task *task) {
spin_lock(&xprt->transport_lock);
xprt_adjust_cwnd(xprt, task, -ETIMEDOUT);
spin_unlock(&xprt->transport_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) {
dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
rpc_set_port(xs_addr(xprt), port);
xs_update_peer_port(xprt);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static int xs_get_srcport(struct sock_xprt *transport) {
int port = transport->srcport;
if (port == 0 && transport->xprt.resvport)
port = xs_get_random_port();
return port;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static unsigned short xs_sock_srcport(struct rpc_xprt *xprt) {
struct sock_xprt *sock = container_of(xprt, struct sock_xprt, xprt);
unsigned short ret = 0;
mutex_lock(&sock->recv_mutex);
if (sock->sock)
ret = xs_sock_getport(sock->sock);
mutex_unlock(&sock->recv_mutex);
return ret;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static struct socket *xs_create_sock(struct rpc_xprt *xprt,
struct sock_xprt *transport, int family,
int type, int protocol, bool reuseport) {
struct file *filp;
struct socket *sock;
int err;
err = __sock_create(xprt->xprt_net, family, ... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static int xs_local_finish_connecting(struct rpc_xprt *xprt,
struct socket *sock) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
if (!transport->inet) {
struct sock *sk = sock->sk;
lock_sock(sk);
xs_save_old_callbacks(transport, sk);
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_disable_swap(struct rpc_xprt *xprt) {
struct sock_xprt *xs = container_of(xprt, struct sock_xprt, xprt);
mutex_lock(&xs->recv_mutex);
if (atomic_dec_and_test(&xprt->swapper) && xs->inet)
sk_clear_memalloc(xs->inet);
mutex_unlock(&xs->recv_mutex);
}
#else | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_udp_setup_socket(struct work_struct *work) {
struct sock_xprt *transport =
container_of(work, struct sock_xprt, connect_worker.work);
struct rpc_xprt *xprt = &transport->xprt;
struct socket *sock;
int status = -EIO;
unsigned int pflags = current->flags;
if (atomic_read(&xprt->swapper)... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt,
struct socket *sock) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
unsigned int keepidle;
unsigned int keepcnt;
unsigned int timeo;
spin_lock(&xprt->transport_lock);
keepidle =... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_tcp_set_connect_timeout(struct rpc_xprt *xprt,
unsigned long connect_timeout,
unsigned long reconnect_timeout) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
struct rpc_timeout to;
unsigned lo... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_connect(struct rpc_xprt *xprt, struct rpc_task *task) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
unsigned long delay = 0;
WARN_ON_ONCE(!xprt_lock_connect(xprt, task, transport));
if (transport->sock != NULL) {
dprintk("RPC: xs_connect delayed xprt %p f... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static void xs_wake_error(struct sock_xprt *transport) {
int sockerr;
if (!test_bit(XPRT_SOCK_WAKE_ERROR, &transport->sock_state))
return;
mutex_lock(&transport->recv_mutex);
if (transport->sock == NULL)
goto out;
if (!test_and_clear_bit(XPRT_SOCK_WAKE_ERROR, &transport->sock_state))
goto out;
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c | static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) {
struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
long idle_time = 0;
if (xprt_connected(xprt))
idle_time = (long)(jiffies - xprt->last_used) / HZ;
seq_printf(seq,
"\txprt:\ttcp %u %lu %lu %l... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtsock.c |
static int param_set_max_slot_table_size(const char *val,
const struct kernel_param *kp) {
return param_set_uint_minmax(val, kp, RPC_MIN_SLOT_TABLE,
RPC_MAX_SLOT_TABLE_LIMIT);
} | [
0,
0
] |
Linux Kernel | net/switchdev/switchdev.c |
static struct switchdev_deferred_item *switchdev_deferred_dequeue(void) {
struct switchdev_deferred_item *dfitem;
spin_lock_bh(&deferred_lock);
if (list_empty(&deferred)) {
dfitem = NULL;
goto unlock;
}
dfitem = list_first_entry(&deferred, struct switchdev_deferred_item, list);
list_del(&dfitem->l... | [
0,
0
] |
Linux Kernel | net/switchdev/switchdev.c |
static int switchdev_port_attr_set_defer(struct net_device *dev,
const struct switchdev_attr *attr) {
return switchdev_deferred_enqueue(dev, attr, sizeof(*attr),
switchdev_port_attr_set_deferred);
} | [
1,
0
] |
Linux Kernel | net/switchdev/switchdev.c | int switchdev_port_attr_set(struct net_device *dev,
const struct switchdev_attr *attr,
struct netlink_ext_ack *extack) {
if (attr->flags & SWITCHDEV_F_DEFER)
return switchdev_port_attr_set_defer(dev, attr);
ASSERT_RTNL();
return switchdev_port_attr_set_n... | [
0,
0
] |
Linux Kernel | net/switchdev/switchdev.c |
static size_t switchdev_obj_size(const struct switchdev_obj *obj) {
switch (obj->id) {
case SWITCHDEV_OBJ_ID_PORT_VLAN:
return sizeof(struct switchdev_obj_port_vlan);
case SWITCHDEV_OBJ_ID_PORT_MDB:
return sizeof(struct switchdev_obj_port_mdb);
case SWITCHDEV_OBJ_ID_HOST_MDB:
return sizeof(struct s... | [
1,
0
] |
Linux Kernel | net/switchdev/switchdev.c |
static void switchdev_port_obj_del_deferred(struct net_device *dev,
const void *data) {
const struct switchdev_obj *obj = data;
int err;
err = switchdev_port_obj_del_now(dev, obj);
if (err && err != -EOPNOTSUPP)
netdev_err(dev, "failed (err=%d) to del object (id... | [
1,
0
] |
Linux Kernel | net/switchdev/switchdev.c | static int __switchdev_handle_fdb_event_to_device(
struct net_device *dev, struct net_device *orig_dev, unsigned long event,
const struct switchdev_notifier_fdb_info *fdb_info,
bool (*check_cb)(const struct net_device *dev),
bool (*foreign_dev_check_cb)(const struct net_device *dev,
... | [
1,
0
] |
Linux Kernel | net/switchdev/switchdev.c | int switchdev_handle_port_obj_add(
struct net_device *dev,
struct switchdev_notifier_port_obj_info *port_obj_info,
bool (*check_cb)(const struct net_device *dev),
int (*add_cb)(struct net_device *dev, const void *ctx,
const struct switchdev_obj *obj,
struct netlink_ex... | [
0,
0
] |
Linux Kernel | net/switchdev/switchdev.c | int switchdev_handle_port_obj_del_foreign(
struct net_device *dev,
struct switchdev_notifier_port_obj_info *port_obj_info,
bool (*check_cb)(const struct net_device *dev),
bool (*foreign_dev_check_cb)(const struct net_device *dev,
const struct net_device *foreign_dev),
... | [
0,
0
] |
Linux Kernel | net/sysctl_net.c |
static struct ctl_table_set *
net_ctl_header_lookup(struct ctl_table_root *root) {
return ¤t->nsproxy->net_ns->sysctls;
} | [
1,
0
] |
Linux Kernel | net/tipc/addr.h |
static inline void tipc_uaddr(struct tipc_uaddr *ua, u32 atype, u32 scope,
u32 type, u32 lower, u32 upper) {
ua->family = AF_TIPC;
ua->addrtype = atype;
ua->scope = scope;
ua->sr.type = type;
ua->sr.lower = lower;
ua->sr.upper = upper;
} | [
0,
0
] |
Linux Kernel | net/tipc/addr.h |
static inline bool tipc_uaddr_valid(struct tipc_uaddr *ua, int len) {
u32 atype;
if (len < sizeof(struct sockaddr_tipc))
return false;
atype = ua->addrtype;
if (ua->family != AF_TIPC)
return false;
if (atype == TIPC_SERVICE_ADDR || atype == TIPC_SOCKET_ADDR)
return true;
if (atype == TIPC_SERV... | [
1,
0
] |
Linux Kernel | net/tipc/addr.h |
static inline int tipc_node2scope(u32 node) {
return node ? TIPC_NODE_SCOPE : TIPC_CLUSTER_SCOPE;
} | [
0,
0
] |
Linux Kernel | net/tipc/addr.h |
static inline int in_own_node(struct net *net, u32 addr) {
return addr == tipc_own_addr(net) || !addr;
} | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c | static void tipc_bcbase_select_primary(struct net *net) {
struct tipc_bc_base *bb = tipc_bc_base(net);
int all_dests = tipc_link_bc_peers(bb->link);
int max_win = tipc_link_max_win(bb->link);
int min_win = tipc_link_min_win(bb->link);
int i, mtu, prim;
bb->primary_bearer = INVALID_BEARER_ID;
bb->bcast_su... | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c |
void tipc_bcast_dec_bearer_dst_cnt(struct net *net, int bearer_id) {
struct tipc_bc_base *bb = tipc_bc_base(net);
tipc_bcast_lock(net);
bb->dests[bearer_id]--;
tipc_bcbase_select_primary(net);
tipc_bcast_unlock(net);
} | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c | int tipc_bcast_xmit(struct net *net, struct sk_buff_head *pkts,
u16 *cong_link_cnt) {
struct tipc_link *l = tipc_bc_sndlink(net);
struct sk_buff_head xmitq;
int rc = 0;
__skb_queue_head_init(&xmitq);
tipc_bcast_lock(net);
if (tipc_link_bc_peers(l))
rc = tipc_link_xmit(l, pkts, &xmit... | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c | int tipc_bcast_rcv(struct net *net, struct tipc_link *l, struct sk_buff *skb) {
struct tipc_msg *hdr = buf_msg(skb);
struct sk_buff_head *inputq = &tipc_bc_base(net)->inputq;
struct sk_buff_head xmitq;
int rc;
__skb_queue_head_init(&xmitq);
if (msg_mc_netid(hdr) != tipc_netid(net) || !tipc_link_is_up(l)) ... | [
1,
0
] |
Linux Kernel | net/tipc/bcast.c | int tipc_bcast_sync_rcv(struct net *net, struct tipc_link *l,
struct tipc_msg *hdr, struct sk_buff_head *retrq) {
struct sk_buff_head *inputq = &tipc_bc_base(net)->inputq;
struct tipc_gap_ack_blks *ga;
struct sk_buff_head xmitq;
int rc = 0;
__skb_queue_head_init(&xmitq);
tipc_bcast... | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c |
void tipc_nlist_add(struct tipc_nlist *nl, u32 node) {
if (node == nl->self)
nl->local = true;
else if (tipc_dest_push(&nl->list, node, 0))
nl->remote++;
} | [
0,
0
] |
Linux Kernel | net/tipc/bcast.c |
void tipc_nlist_del(struct tipc_nlist *nl, u32 node) {
if (node == nl->self)
nl->local = false;
else if (tipc_dest_del(&nl->list, node, 0))
nl->remote--;
} | [
0,
0
] |
Linux Kernel | net/tipc/bcast.h |
static inline void tipc_bcast_lock(struct net *net) {
spin_lock_bh(&tipc_net(net)->bclock);
} | [
0,
0
] |
Linux Kernel | net/tipc/bcast.h |
static inline void tipc_bcast_unlock(struct net *net) {
spin_unlock_bh(&tipc_net(net)->bclock);
} | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
static struct tipc_bearer *bearer_get(struct net *net, int bearer_id) {
struct tipc_net *tn = tipc_net(net);
return rcu_dereference(tn->bearer_list[bearer_id]);
} | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c | static struct tipc_media *media_find_id(u8 type) {
u32 i;
for (i = 0; media_info_array[i] != NULL; i++) {
if (media_info_array[i]->type_id == type)
break;
}
return media_info_array[i];
} | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c | static int bearer_name_validate(const char *name,
struct tipc_bearer_names *name_parts) {
char name_copy[TIPC_MAX_BEARER_NAME];
char *media_name;
char *if_name;
u32 media_len;
u32 if_len;
if (strscpy(name_copy, name, TIPC_MAX_BEARER_NAME) < 0)
return 0;
/* ensure all ... | [
1,
0
] |
Linux Kernel | net/tipc/bearer.c | struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name) {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_bearer *b;
u32 i;
for (i = 0; i < MAX_BEARERS; i++) {
b = rtnl_dereference(tn->bearer_list[i]);
if (b && (!strcmp(b->name, name)))
return b;
}
return NULL... | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest) {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_bearer *b;
rcu_read_lock();
b = rcu_dereference(tn->bearer_list[bearer_id]);
if (b)
tipc_disc_remove_dest(b->disc);
rcu_read_unlock();
} | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c | static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b) {
pr_info("Resetting bearer <%s>\n", b->name);
tipc_node_delete_links(net, b->identity);
tipc_disc_reset(net, b);
return 0;
} | [
1,
0
] |
Linux Kernel | net/tipc/bearer.c |
bool tipc_bearer_hold(struct tipc_bearer *b) {
return (b && refcount_inc_not_zero(&b->refcnt));
} | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c | void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
struct sk_buff_head *xmitq) {
struct tipc_net *tn = tipc_net(net);
struct tipc_media_addr *dst;
int net_id = tn->net_id;
struct tipc_bearer *b;
struct sk_buff *skb, *tmp;
struct tipc_msg *hdr;
rcu_read_lock();
b = bearer_... | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
int tipc_bearer_setup(void) { return register_netdevice_notifier(¬ifier); } | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
void tipc_bearer_cleanup(void) { unregister_netdevice_notifier(¬ifier); } | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c | static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
struct tipc_bearer *bearer, int nlflags) {
void *hdr;
struct nlattr *attrs;
struct nlattr *prop;
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, nlflags,
TIPC_NL_BEARER_GET);
if ... | [
1,
0
] |
Linux Kernel | net/tipc/bearer.c |
int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb) {
int err;
int i = cb->args[0];
struct tipc_bearer *bearer;
struct tipc_nl_msg msg;
struct net *net = sock_net(skb->sk);
struct tipc_net *tn = net_generic(net, tipc_net_id);
if (i == MAX_BEARERS)
return 0;
msg.skb = skb;
... | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info) {
int err;
char *name;
struct sk_buff *rep;
struct tipc_bearer *bearer;
struct tipc_nl_msg msg;
struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
struct net *net = genl_info_net(info);
if (!info->attrs[TIPC_NLA_BEARER])
return -EINVA... | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info) {
int err;
char *name;
struct tipc_bearer *bearer;
struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
struct net *net = sock_net(skb->sk);
if (!info->attrs[TIPC_NLA_BEARER])
return -EINVAL;
err = nla_parse_nested_deprecated(attrs... | [
0,
0
] |
Linux Kernel | net/tipc/bearer.c |
int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info) {
int err;
rtnl_lock();
err = __tipc_nl_bearer_set(skb, info);
rtnl_unlock();
return err;
} | [
0,
0
] |
Linux Kernel | net/tipc/core.c |
static void __net_exit tipc_pernet_pre_exit(struct net *net) {
tipc_node_pre_cleanup_net(net);
} | [
0,
0
] |
Linux Kernel | net/tipc/core.c |
static int __init tipc_init(void) {
int err;
pr_info("Activated (version " TIPC_MOD_VER ")\n");
sysctl_tipc_rmem[0] = RCVBUF_MIN;
sysctl_tipc_rmem[1] = RCVBUF_DEF;
sysctl_tipc_rmem[2] = RCVBUF_MAX;
err = tipc_register_sysctl();
if (err)
goto out_sysctl;
err = register_pernet_device(&tipc_net_op... | [
0,
0
] |
Linux Kernel | net/tipc/core.h |
static inline struct name_table *tipc_name_table(struct net *net) {
return tipc_net(net)->nametbl;
} | [
0,
0
] |
Linux Kernel | net/tipc/core.h |
static inline int less_eq(u16 left, u16 right) {
return mod(right - left) < 32768u;
} | [
0,
0
] |
Linux Kernel | net/tipc/core.h |
static inline int in_range(u16 val, u16 min, u16 max) {
return !less(val, min) && !more(val, max);
} | [
0,
0
] |
Linux Kernel | net/tipc/core.h |
static inline u32 hash128to32(char *bytes) {
__be32 *tmp = (__be32 *)bytes;
u32 res;
res = ntohl(tmp[0] ^ tmp[1] ^ tmp[2] ^ tmp[3]);
if (likely(res))
return res;
return ntohl(tmp[0] | tmp[1] | tmp[2] | tmp[3]);
}
#ifdef CONFIG_SYSCTL | [
0,
0
] |
Linux Kernel | net/tipc/crypto.c | int tipc_aead_key_validate(struct tipc_aead_key *ukey, struct genl_info *info) {
int keylen;
if (unlikely(!crypto_has_alg(ukey->alg_name, 0, 0))) {
GENL_SET_ERR_MSG(info, "unable to load the algorithm (module existed?)");
return -ENODEV;
}
/* Currently, we only support the "gcm(aes)" cipher algorithm ... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c | static int tipc_aead_key_generate(struct tipc_aead_key *skey) {
int rc = 0;
rc = crypto_get_default_rng();
if (likely(!rc)) {
rc = crypto_rng_get_bytes(crypto_default_rng, skey->key, skey->keylen);
crypto_put_default_rng();
}
return rc;
} | [
0,
0
] |
Linux Kernel | net/tipc/crypto.c | static void *tipc_aead_mem_alloc(struct crypto_aead *tfm,
unsigned int crypto_ctx_size, u8 **iv,
struct aead_request **req,
struct scatterlist **sg, int nsg) {
unsigned int iv_size, req_size;
unsigned int len;
u8 *m... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c |
static inline int tipc_ehdr_size(struct tipc_ehdr *ehdr) {
return (ehdr->user != LINK_CONFIG) ? EHDR_SIZE : EHDR_CFG_SIZE;
} | [
0,
0
] |
Linux Kernel | net/tipc/crypto.c |
static inline void tipc_crypto_key_set_state(struct tipc_crypto *c,
u8 new_passive, u8 new_active,
u8 new_pending) {
struct tipc_key old = c->key;
char buf[32];
c->key.keys = ((new_passive & KEY_MASK) << (KEY_BITS * 2)) |
... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c | int tipc_crypto_key_init(struct tipc_crypto *c, struct tipc_aead_key *ukey,
u8 mode, bool master_key) {
struct tipc_aead *aead = NULL;
int rc = 0;
rc = tipc_aead_init(&aead, ukey, mode);
/* Attach it to the crypto */
if (likely(!rc)) {
rc = tipc_crypto_key_attach(c, aead, 0, mas... | [
0,
0
] |
Linux Kernel | net/tipc/crypto.c | static bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending) {
struct tipc_aead *tmp1, *tmp2 = NULL;
struct tipc_key key;
bool aligned = false;
u8 new_passive = 0;
int x;
spin_lock(&rx->lock);
key = rx->key;
if (key.pending == new_pending) {
aligned = true;
goto exit;
}
if ... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c | static struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx,
struct tipc_crypto *rx,
struct sk_buff *skb,
u8 tx_key) {
struct tipc_skb_cb *skb_cb = TIPC_SKB_CB... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c |
static char *tipc_crypto_key_dump(struct tipc_crypto *c, char *buf) {
struct tipc_key key = c->key;
struct tipc_aead *aead;
int k, i = 0;
char *s;
for (k = KEY_MIN; k <= KEY_MAX; k++) {
if (k == KEY_MASTER) {
if (is_rx(c))
continue;
if (time_before(jiffies, c->timer2 + TIPC_TX_GRACE_... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c | int tipc_crypto_key_distr(struct tipc_crypto *tx, u8 key,
struct tipc_node *dest) {
struct tipc_aead *aead;
u32 dnode = tipc_node_get_addr(dest);
int rc = -ENOKEY;
if (!sysctl_tipc_key_exchange_enabled)
return 0;
if (key) {
rcu_read_lock();
aead = tipc_aead_get(tx->aead... | [
0,
0
] |
Linux Kernel | net/tipc/crypto.c | static int tipc_crypto_key_xmit(struct net *net, struct tipc_aead_key *skey,
u16 gen, u8 mode, u32 dnode) {
struct sk_buff_head pkts;
struct tipc_msg *hdr;
struct sk_buff *skb;
u16 size, cong_link_cnt;
u8 *data;
int rc;
size = tipc_aead_key_size(skey);
skb = tipc_buf_acq... | [
1,
0
] |
Linux Kernel | net/tipc/crypto.c | static void tipc_crypto_work_tx(struct work_struct *work) {
struct delayed_work *dwork = to_delayed_work(work);
struct tipc_crypto *tx = container_of(dwork, struct tipc_crypto, work);
struct tipc_aead_key *skey = NULL;
struct tipc_key key = tx->key;
struct tipc_aead *aead;
int rc = -ENOMEM;
if (unlikely(... | [
0,
0
] |
Linux Kernel | net/tipc/crypto.h |
static inline u32 msg_key_gen(struct tipc_msg *m) {
return msg_bits(m, 4, 16, 0xffff);
} | [
0,
0
] |
Linux Kernel | net/tipc/crypto.h |
static inline u32 msg_key_mode(struct tipc_msg *m) {
return msg_bits(m, 4, 0, 0xf);
} | [
0,
0
] |
Linux Kernel | net/tipc/diag.c |
static void __exit tipc_diag_exit(void) {
sock_diag_unregister(&tipc_sock_diag_handler);
} | [
0,
0
] |
Linux Kernel | net/tipc/discover.c | void tipc_disc_add_dest(struct tipc_discoverer *d) {
spin_lock_bh(&d->lock);
d->num_nodes++;
spin_unlock_bh(&d->lock);
} | [
0,
0
] |
Linux Kernel | net/tipc/discover.c | void tipc_disc_remove_dest(struct tipc_discoverer *d) {
int intv, num;
spin_lock_bh(&d->lock);
d->num_nodes--;
num = d->num_nodes;
intv = d->timer_intv;
if (!num && (intv == TIPC_DISC_INACTIVE || intv > TIPC_DISC_FAST)) {
d->timer_intv = TIPC_DISC_INIT;
mod_timer(&d->timer, jiffies + d->timer_intv)... | [
0,
0
] |
Linux Kernel | net/tipc/discover.c | int tipc_disc_create(struct net *net, struct tipc_bearer *b,
struct tipc_media_addr *dest, struct sk_buff **skb) {
struct tipc_net *tn = tipc_net(net);
struct tipc_discoverer *d;
d = kmalloc(sizeof(*d), GFP_ATOMIC);
if (!d)
return -ENOMEM;
d->skb = tipc_buf_acquire(MAX_H_SIZE + NODE_... | [
1,
0
] |
Linux Kernel | net/tipc/eth_media.c | static int tipc_eth_addr2msg(char *msg, struct tipc_media_addr *addr) {
memset(msg, 0, TIPC_MEDIA_INFO_SIZE);
msg[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_ETH;
memcpy(msg + TIPC_MEDIA_ADDR_OFFSET, addr->value, ETH_ALEN);
return 0;
} | [
1,
0
] |
Linux Kernel | net/tipc/eth_media.c | static int tipc_eth_msg2addr(struct tipc_bearer *b,
struct tipc_media_addr *addr, char *msg) {
msg += TIPC_MEDIA_ADDR_OFFSET;
return tipc_eth_raw2addr(b, addr, msg);
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.