Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/packet/af_packet.c | static void packet_parse_headers(struct sk_buff *skb, struct socket *sock) {
int depth;
if ((!skb->protocol || skb->protocol == htons(ETH_P_ALL)) &&
sock->type == SOCK_RAW) {
skb_reset_mac_header(skb);
skb->protocol = dev_parse_header_protocol(skb);
}
if (likely(skb->dev->type == ARPHRD_ETHER) &... | [
0,
0
] |
Linux Kernel | net/packet/af_packet.c |
static int packet_rcv_vnet(struct msghdr *msg, const struct sk_buff *skb,
size_t *len) {
struct virtio_net_hdr vnet_hdr;
if (*len < sizeof(vnet_hdr))
return -EINVAL;
*len -= sizeof(vnet_hdr);
if (virtio_net_hdr_from_skb(skb, &vnet_hdr, vio_le(), true, 0))
return -EINVAL;
... | [
1,
0
] |
Linux Kernel | net/packet/af_packet.c |
static int tpacket_parse_header(struct packet_sock *po, void *frame,
int size_max, void **data) {
union tpacket_uhdr ph;
int tp_len, off;
ph.raw = frame;
switch (po->tp_version) {
case TPACKET_V3:
if (ph.h3->tp_next_offset != 0) {
pr_warn_once("variable sized slot ... | [
1,
0
] |
Linux Kernel | net/packet/af_packet.c | static struct sk_buff *packet_alloc_skb(struct sock *sk, size_t prepad,
size_t reserve, size_t len,
size_t linear, int noblock, int *err) {
struct sk_buff *skb;
if (prepad + len < PAGE_SIZE || !linear)
linear = len;
skb =
... | [
1,
0
] |
Linux Kernel | net/packet/diag.c |
static int pdiag_put_fanout(struct packet_sock *po, struct sk_buff *nlskb) {
int ret = 0;
mutex_lock(&fanout_mutex);
if (po->fanout) {
u32 val;
val = (u32)po->fanout->id | ((u32)po->fanout->type << 16);
ret = nla_put_u32(nlskb, PACKET_DIAG_FANOUT, val);
}
mutex_unlock(&fanout_mutex);
return ... | [
1,
0
] |
Linux Kernel | net/packet/diag.c |
static void __exit packet_diag_exit(void) {
sock_diag_unregister(&packet_diag_handler);
} | [
0,
0
] |
Linux Kernel | net/phonet/af_phonet.c |
static const struct phonet_protocol *phonet_proto_get(unsigned int protocol) {
const struct phonet_protocol *pp;
if (protocol >= PHONET_NPROTO)
return NULL;
rcu_read_lock();
pp = rcu_dereference(proto_tab[protocol]);
if (pp && !try_module_get(pp->prot->owner))
pp = NULL;
rcu_read_unlock();
ret... | [
1,
0
] |
Linux Kernel | net/phonet/af_phonet.c | static int pn_send(struct sk_buff *skb, struct net_device *dev, u16 dst,
u16 src, u8 res) {
struct phonethdr *ph;
int err;
if (skb->len + 2 > 0xffff || skb->len + sizeof(struct phonethdr) > dev->mtu) {
err = -EMSGSIZE;
goto drop;
}
/* Broadcast sending is not implemented */
if (... | [
1,
0
] |
Linux Kernel | net/phonet/af_phonet.c |
void phonet_proto_unregister(unsigned int protocol,
const struct phonet_protocol *pp) {
mutex_lock(&proto_tab_lock);
BUG_ON(proto_tab[protocol] != pp);
RCU_INIT_POINTER(proto_tab[protocol], NULL);
mutex_unlock(&proto_tab_lock);
synchronize_rcu();
proto_unregister(pp->prot);
} | [
0,
0
] |
Linux Kernel | net/phonet/af_phonet.c | static int __init phonet_init(void) {
int err;
err = phonet_device_init();
if (err)
return err;
pn_sock_init();
err = sock_register(&phonet_proto_family);
if (err) {
printk(KERN_ALERT "phonet protocol family initialization failed\n");
goto err_sock;
}
dev_add_pack(&phonet_packet_type);
... | [
0,
0
] |
Linux Kernel | net/phonet/datagram.c | static int pn_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) {
DECLARE_SOCKADDR(struct sockaddr_pn *, target, msg->msg_name);
struct sk_buff *skb;
int err;
if (msg->msg_flags &
~(MSG_DONTWAIT | MSG_EOR | MSG_NOSIGNAL | MSG_CMSG_COMPAT))
return -EOPNOTSUPP;
if (target == NULL)
return ... | [
1,
0
] |
Linux Kernel | net/phonet/datagram.c |
void __exit isi_unregister(void) {
phonet_proto_unregister(PN_PROTO_PHONET, &pn_dgram_proto);
} | [
0,
0
] |
Linux Kernel | net/phonet/pep-gprs.c | static int gprs_recv(struct gprs_dev *gp, struct sk_buff *skb) {
struct net_device *dev = gp->dev;
int err = 0;
__be16 protocol = gprs_type_trans(skb);
if (!protocol) {
err = -EINVAL;
goto drop;
}
if (skb_headroom(skb) & 3) {
struct sk_buff *rskb, *fs;
int flen = 0;
rskb = netdev_allo... | [
0,
0
] |
Linux Kernel | net/phonet/pep-gprs.c | static int gprs_open(struct net_device *dev) {
struct gprs_dev *gp = netdev_priv(dev);
gprs_writeable(gp);
return 0;
} | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | static int pipe_handler_request(struct sock *sk, u8 id, u8 code,
const void *data, int len) {
struct pep_sock *pn = pep_sk(sk);
struct pnpipehdr *ph;
struct sk_buff *skb;
skb = pep_alloc_skb(sk, data, len, GFP_KERNEL);
if (!skb)
return -ENOMEM;
ph = pnp_hdr(skb);
ph->... | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | static int pep_reject_conn(struct sock *sk, struct sk_buff *skb, u8 code,
gfp_t priority) {
static const u8 data[4] = {PAD, PAD, PAD, 0};
WARN_ON(code == PN_PIPE_NO_ERROR);
return pep_reply(sk, skb, code, data, sizeof(data), priority);
} | [
1,
0
] |
Linux Kernel | net/phonet/pep.c | static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
gfp_t priority) {
const struct pnpipehdr *oph = pnp_hdr(oskb);
struct sk_buff *skb;
struct pnpipehdr *ph;
struct sockaddr_pn dst;
u8 data[4] = {
oph->pep_type,
code, /* error code, at an unusu... | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | static void pipe_grant_credits(struct sock *sk, gfp_t priority) {
struct pep_sock *pn = pep_sk(sk);
BUG_ON(sk->sk_state != TCP_ESTABLISHED);
switch (pn->rx_fc) {
case PN_LEGACY_FLOW_CONTROL: /* TODO */
break;
case PN_ONE_CREDIT_FLOW_CONTROL:
if (pipe_snd_status(sk, PN_PEP_IND_FLOW_CONTROL, PEP_IND_R... | [
1,
1
] |
Linux Kernel | net/phonet/pep.c |
static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb) {
struct pep_sock *pn = pep_sk(sk);
struct pnpipehdr *hdr;
int wake = 0;
if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
return -EINVAL;
hdr = pnp_hdr(skb);
if (hdr->pep_type != PN_PEP_TYPE_COMMON) {
net_dbg_ratelimited("Phonet unknown P... | [
1,
0
] |
Linux Kernel | net/phonet/pep.c |
static int pipe_rcv_created(struct sock *sk, struct sk_buff *skb) {
struct pep_sock *pn = pep_sk(sk);
struct pnpipehdr *hdr = pnp_hdr(skb);
u8 n_sb = hdr->data0;
pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
__skb_pull(skb, sizeof(*hdr));
while (n_sb > 0) {
u8 type, buf[2], len = sizeof(buf);
u8... | [
1,
0
] |
Linux Kernel | net/phonet/pep.c | static int pep_enableresp_rcv(struct sock *sk, struct sk_buff *skb) {
struct pnpipehdr *hdr = pnp_hdr(skb);
if (hdr->error_code != PN_PIPE_NO_ERROR)
return -ECONNREFUSED;
return pep_indicate(sk, PNS_PIPE_ENABLED_IND, 0, NULL, 0, GFP_ATOMIC);
} | [
0,
0
] |
Linux Kernel | net/phonet/pep.c |
static void pipe_start_flow_control(struct sock *sk) {
struct pep_sock *pn = pep_sk(sk);
if (!pn_flow_safe(pn->tx_fc)) {
atomic_set(&pn->tx_credits, 1);
sk->sk_write_space(sk);
}
pipe_grant_credits(sk, GFP_ATOMIC);
} | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | static int pipe_handler_do_rcv(struct sock *sk, struct sk_buff *skb) {
struct pep_sock *pn = pep_sk(sk);
struct pnpipehdr *hdr = pnp_hdr(skb);
int err = NET_RX_SUCCESS;
switch (hdr->message_id) {
case PNS_PIPE_ALIGNED_DATA:
__skb_pull(skb, 1);
fallthrough;
case PNS_PIPE_DATA:
__skb_pull(skb, 3)... | [
1,
0
] |
Linux Kernel | net/phonet/pep.c |
static int pipe_do_remove(struct sock *sk) {
struct pep_sock *pn = pep_sk(sk);
struct pnpipehdr *ph;
struct sk_buff *skb;
skb = pep_alloc_skb(sk, NULL, 0, GFP_KERNEL);
if (!skb)
return -ENOMEM;
ph = pnp_hdr(skb);
ph->utid = 0;
ph->message_id = PNS_PIPE_REMOVE_REQ;
ph->pipe_handle = pn->pipe_han... | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | int pep_write(struct sock *sk, struct sk_buff *skb) {
struct sk_buff *rskb, *fs;
int flen = 0;
if (pep_sk(sk)->aligned)
return pipe_skb_send(sk, skb);
rskb = alloc_skb(MAX_PNPIPE_HEADER, GFP_ATOMIC);
if (!rskb) {
kfree_skb(skb);
return -ENOMEM;
}
skb_shinfo(rskb)->frag_list = skb;
rskb->le... | [
0,
0
] |
Linux Kernel | net/phonet/pep.c | static int pep_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
int flags, int *addr_len) {
struct sk_buff *skb;
int err;
if (flags & ~(MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_DONTWAIT | MSG_WAITALL |
MSG_NOSIGNAL | MSG_CMSG_COMPAT))
return -EOPNOTSUPP;
if (unli... | [
1,
0
] |
Linux Kernel | net/phonet/pn_dev.c |
static struct phonet_net *phonet_pernet(struct net *net) {
return net_generic(net, phonet_net_id);
} | [
0,
0
] |
Linux Kernel | net/phonet/pn_dev.c | static struct phonet_device *__phonet_device_alloc(struct net_device *dev) {
struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
struct phonet_device *pnd = kmalloc(sizeof(*pnd), GFP_ATOMIC);
if (pnd == NULL)
return NULL;
pnd->netdev = dev;
bitmap_zero(pnd->addrs, 64);
BUG_ON(!mutex_i... | [
0,
0
] |
Linux Kernel | net/phonet/pn_dev.c |
static struct phonet_device *__phonet_get(struct net_device *dev) {
struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
struct phonet_device *pnd;
BUG_ON(!mutex_is_locked(&pndevs->lock));
list_for_each_entry(pnd, &pndevs->list, list) {
if (pnd->netdev == dev)
return pnd;
}
retu... | [
0,
0
] |
Linux Kernel | net/phonet/pn_dev.c |
static struct phonet_device *__phonet_get_rcu(struct net_device *dev) {
struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
struct phonet_device *pnd;
list_for_each_entry_rcu(pnd, &pndevs->list, list) {
if (pnd->netdev == dev)
return pnd;
}
return NULL;
} | [
0,
0
] |
Linux Kernel | net/phonet/pn_dev.c |
struct net_device *phonet_device_get(struct net *net) {
struct phonet_device_list *pndevs = phonet_device_list(net);
struct phonet_device *pnd;
struct net_device *dev = NULL;
rcu_read_lock();
list_for_each_entry_rcu(pnd, &pndevs->list, list) {
dev = pnd->netdev;
BUG_ON(!dev);
if ((dev->reg_stat... | [
1,
0
] |
Linux Kernel | net/phonet/pn_dev.c | u8 phonet_address_get(struct net_device *dev, u8 daddr) {
struct phonet_device *pnd;
u8 saddr;
rcu_read_lock();
pnd = __phonet_get_rcu(dev);
if (pnd) {
BUG_ON(bitmap_empty(pnd->addrs, 64));
if (test_bit(daddr >> 2, pnd->addrs))
saddr = daddr;
else
saddr = find_first_bit(pnd->addrs, 6... | [
1,
0
] |
Linux Kernel | net/phonet/pn_dev.c | static int phonet_device_autoconf(struct net_device *dev) {
struct if_phonet_req req;
int ret;
if (!dev->netdev_ops->ndo_siocdevprivate)
return -EOPNOTSUPP;
ret = dev->netdev_ops->ndo_siocdevprivate(dev, (struct ifreq *)&req, NULL,
SIOCPNGAUTOCONF);
if (ret < ... | [
1,
0
] |
Linux Kernel | net/phonet/pn_dev.c | static int __net_init phonet_init_net(struct net *net) {
struct phonet_net *pnn = phonet_pernet(net);
if (!proc_create_net("phonet", 0, net->proc_net, &pn_sock_seq_ops,
sizeof(struct seq_net_private)))
return -ENOMEM;
INIT_LIST_HEAD(&pnn->pndevs.list);
mutex_init(&pnn->pndevs.lock);... | [
1,
0
] |
Linux Kernel | net/phonet/pn_netlink.c |
static int fill_addr(struct sk_buff *skb, struct net_device *dev, u8 addr,
u32 portid, u32 seq, int event) {
struct ifaddrmsg *ifm;
struct nlmsghdr *nlh;
nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), 0);
if (nlh == NULL)
return -EMSGSIZE;
ifm = nlmsg_data(nlh);
ifm->ifa_... | [
1,
0
] |
Linux Kernel | net/phonet/pn_netlink.c | static int fill_route(struct sk_buff *skb, struct net_device *dev, u8 dst,
u32 portid, u32 seq, int event) {
struct rtmsg *rtm;
struct nlmsghdr *nlh;
nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), 0);
if (nlh == NULL)
return -EMSGSIZE;
rtm = nlmsg_data(nlh);
rtm->rtm_fami... | [
1,
0
] |
Linux Kernel | net/phonet/pn_netlink.c |
static int route_dumpit(struct sk_buff *skb, struct netlink_callback *cb) {
struct net *net = sock_net(skb->sk);
u8 addr;
rcu_read_lock();
for (addr = cb->args[0]; addr < 64; addr++) {
struct net_device *dev = phonet_route_get_rcu(net, addr << 2);
if (!dev)
continue;
if (fill_route(skb, de... | [
1,
0
] |
Linux Kernel | net/phonet/pn_netlink.c | int __init phonet_netlink_register(void) {
int err = rtnl_register_module(THIS_MODULE, PF_PHONET, RTM_NEWADDR, addr_doit,
NULL, 0);
if (err)
return err;
rtnl_register_module(THIS_MODULE, PF_PHONET, RTM_DELADDR, addr_doit, NULL, 0);
rtnl_register_module(THIS_MODULE, PF_PHONE... | [
0,
0
] |
Linux Kernel | net/phonet/socket.c |
void __init pn_sock_init(void) {
unsigned int i;
for (i = 0; i < PN_HASHSIZE; i++)
INIT_HLIST_HEAD(pnsocks.hlist + i);
mutex_init(&pnsocks.lock);
} | [
0,
0
] |
Linux Kernel | net/phonet/socket.c |
static __poll_t pn_socket_poll(struct file *file, struct socket *sock,
poll_table *wait) {
struct sock *sk = sock->sk;
struct pep_sock *pn = pep_sk(sk);
__poll_t mask = 0;
poll_wait(file, sk_sleep(sk), wait);
if (sk->sk_state == TCP_CLOSE)
return EPOLLERR;
if (!skb_queu... | [
1,
0
] |
Linux Kernel | net/phonet/socket.c | struct sock *pn_find_sock_by_res(struct net *net, u8 res) {
struct sock *sk;
if (!net_eq(net, &init_net))
return NULL;
rcu_read_lock();
sk = rcu_dereference(pnres.sk[res]);
if (sk)
sock_hold(sk);
rcu_read_unlock();
return sk;
} | [
0,
0
] |
Linux Kernel | net/phonet/socket.c |
int pn_sock_bind_res(struct sock *sk, u8 res) {
int ret = -EADDRINUSE;
if (!net_eq(sock_net(sk), &init_net))
return -ENOIOCTLCMD;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (pn_socket_autobind(sk->sk_socket))
return -EAGAIN;
mutex_lock(&resource_mutex);
if (pnres.sk[res] == NULL) {
so... | [
0,
0
] |
Linux Kernel | net/phonet/socket.c |
static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
__acquires(resource_mutex) {
mutex_lock(&resource_mutex);
return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
} | [
0,
0
] |
Linux Kernel | net/phonet/sysctl.c |
void phonet_get_local_port_range(int *min, int *max) {
unsigned int seq;
do {
seq = read_seqbegin(&local_port_range_lock);
if (min)
*min = local_port_range[0];
if (max)
*max = local_port_range[1];
} while (read_seqretry(&local_port_range_lock, seq));
} | [
0,
0
] |
Linux Kernel | net/phonet/sysctl.c |
int __init phonet_sysctl_init(void) {
phonet_table_hrd = register_net_sysctl(&init_net, "net/phonet", phonet_table);
return phonet_table_hrd == NULL ? -ENOMEM : 0;
} | [
0,
0
] |
Linux Kernel | net/psample/psample.c |
static void psample_group_notify(struct psample_group *group,
enum psample_command cmd) {
struct sk_buff *msg;
int err;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
if (!msg)
return;
err = psample_group_nl_fill(msg, group, cmd, 0, 0, NLM_F_MULTI);
if (!err)
ge... | [
0,
0
] |
Linux Kernel | net/psample/psample.c |
struct psample_group *psample_group_get(struct net *net, u32 group_num) {
struct psample_group *group;
spin_lock_bh(&psample_groups_lock);
group = psample_group_lookup(net, group_num);
if (!group) {
group = psample_group_create(net, group_num);
if (!group)
goto out;
}
group->refcount++;
ou... | [
0,
0
] |
Linux Kernel | net/psample/psample.c |
void psample_group_take(struct psample_group *group) {
spin_lock_bh(&psample_groups_lock);
group->refcount++;
spin_unlock_bh(&psample_groups_lock);
} | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static void qrtr_tx_resume(struct qrtr_node *node, struct sk_buff *skb) {
struct qrtr_ctrl_pkt *pkt = (struct qrtr_ctrl_pkt *)skb->data;
u64 remote_node = le32_to_cpu(pkt->client.node);
u32 remote_port = le32_to_cpu(pkt->client.port);
struct qrtr_tx_flow *flow;
unsigned long key;
key = remote_node << 32 | ... | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static struct qrtr_node *qrtr_node_lookup(unsigned int nid) {
struct qrtr_node *node;
unsigned long flags;
spin_lock_irqsave(&qrtr_nodes_lock, flags);
node = radix_tree_lookup(&qrtr_nodes, nid);
node = qrtr_node_acquire(node);
spin_unlock_irqrestore(&qrtr_nodes_lock, flags);
return node;
} | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static void qrtr_node_assign(struct qrtr_node *node, unsigned int nid) {
unsigned long flags;
if (nid == QRTR_EP_NID_AUTO)
return;
spin_lock_irqsave(&qrtr_nodes_lock, flags);
radix_tree_insert(&qrtr_nodes, nid, node);
if (node->nid == QRTR_EP_NID_AUTO)
node->nid = nid;
spin_unlock_irqrestore(&qrtr... | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | int qrtr_endpoint_register(struct qrtr_endpoint *ep, unsigned int nid) {
struct qrtr_node *node;
if (!ep || !ep->xmit)
return -EINVAL;
node = kzalloc(sizeof(*node), GFP_KERNEL);
if (!node)
return -ENOMEM;
kref_init(&node->ref);
mutex_init(&node->ep_lock);
skb_queue_head_init(&node->rx_queue);
... | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static struct qrtr_sock *qrtr_port_lookup(int port) {
struct qrtr_sock *ipc;
if (port == QRTR_PORT_CTRL)
port = 0;
rcu_read_lock();
ipc = xa_load(&qrtr_ports, port);
if (ipc)
sock_hold(&ipc->sk);
rcu_read_unlock();
return ipc;
} | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static void qrtr_port_put(struct qrtr_sock *ipc) { sock_put(&ipc->sk); } | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static int qrtr_bind(struct socket *sock, struct sockaddr *saddr, int len) {
DECLARE_SOCKADDR(struct sockaddr_qrtr *, addr, saddr);
struct qrtr_sock *ipc = qrtr_sk(sock->sk);
struct sock *sk = sock->sk;
int rc;
if (len < sizeof(*addr) || addr->sq_family != AF_QIPCRTR)
return -EINVAL;
if (addr->sq_node... | [
1,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c | static int qrtr_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
int flags) {
DECLARE_SOCKADDR(struct sockaddr_qrtr *, addr, msg->msg_name);
struct sock *sk = sock->sk;
struct sk_buff *skb;
struct qrtr_cb *cb;
int copied, rc;
lock_sock(sk);
if (sock_flag(sk, SOCK_ZAP... | [
1,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c |
static int qrtr_ioctl(struct socket *sock, unsigned int cmd,
unsigned long arg) {
void __user *argp = (void __user *)arg;
struct qrtr_sock *ipc = qrtr_sk(sock->sk);
struct sock *sk = sock->sk;
struct sockaddr_qrtr *sq;
struct sk_buff *skb;
struct ifreq ifr;
long len = 0;
int rc = ... | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c |
static int qrtr_release(struct socket *sock) {
struct sock *sk = sock->sk;
struct qrtr_sock *ipc;
if (!sk)
return 0;
lock_sock(sk);
ipc = qrtr_sk(sk);
sk->sk_shutdown = SHUTDOWN_MASK;
if (!sock_flag(sk, SOCK_DEAD))
sk->sk_state_change(sk);
sock_set_flag(sk, SOCK_DEAD);
sock_orphan(sk);
... | [
0,
0
] |
Linux Kernel | net/qrtr/af_qrtr.c |
static int __init qrtr_proto_init(void) {
int rc;
rc = proto_register(&qrtr_proto, 1);
if (rc)
return rc;
rc = sock_register(&qrtr_family);
if (rc)
goto err_proto;
rc = qrtr_ns_init();
if (rc)
goto err_sock;
return 0;
err_sock:
sock_unregister(qrtr_family.family);
err_proto:
proto_... | [
0,
0
] |
Linux Kernel | net/qrtr/mhi.c | static int qcom_mhi_qrtr_send(struct qrtr_endpoint *ep, struct sk_buff *skb) {
struct qrtr_mhi_dev *qdev = container_of(ep, struct qrtr_mhi_dev, ep);
int rc;
if (skb->sk)
sock_hold(skb->sk);
rc = skb_linearize(skb);
if (rc)
goto free_skb;
rc = mhi_queue_skb(qdev->mhi_dev, DMA_TO_DEVICE, skb, skb-... | [
0,
0
] |
Linux Kernel | net/qrtr/mhi.c |
static void qcom_mhi_qrtr_remove(struct mhi_device *mhi_dev) {
struct qrtr_mhi_dev *qdev = dev_get_drvdata(&mhi_dev->dev);
qrtr_endpoint_unregister(&qdev->ep);
mhi_unprepare_from_transfer(mhi_dev);
dev_set_drvdata(&mhi_dev->dev, NULL);
} | [
0,
0
] |
Linux Kernel | net/qrtr/ns.c | static struct qrtr_node *node_get(unsigned int node_id) {
struct qrtr_node *node;
node = radix_tree_lookup(&nodes, node_id);
if (node)
return node;
node = kzalloc(sizeof(*node), GFP_KERNEL);
if (!node)
return NULL;
node->id = node_id;
radix_tree_insert(&nodes, node_id, node);
return node;
} | [
0,
0
] |
Linux Kernel | net/qrtr/ns.c | static int announce_servers(struct sockaddr_qrtr *sq) {
struct radix_tree_iter iter;
struct qrtr_server *srv;
struct qrtr_node *node;
void __rcu **slot;
int ret;
node = node_get(qrtr_ns.local_node);
if (!node)
return 0;
rcu_read_lock();
radix_tree_for_each_slot(slot, &node->servers, &iter, 0) {... | [
0,
0
] |
Linux Kernel | net/qrtr/ns.c | static int server_del(struct qrtr_node *node, unsigned int port) {
struct qrtr_lookup *lookup;
struct qrtr_server *srv;
struct list_head *li;
srv = radix_tree_lookup(&node->servers, port);
if (!srv)
return -ENOENT;
radix_tree_delete(&node->servers, port);
if (srv->node == qrtr_ns.local_node)
se... | [
1,
0
] |
Linux Kernel | net/qrtr/smd.c | static int qcom_smd_qrtr_send(struct qrtr_endpoint *ep, struct sk_buff *skb) {
struct qrtr_smd_dev *qdev = container_of(ep, struct qrtr_smd_dev, ep);
int rc;
rc = skb_linearize(skb);
if (rc)
goto out;
rc = rpmsg_send(qdev->channel, skb->data, skb->len);
out:
if (rc)
kfree_skb(skb);
else
con... | [
0,
0
] |
Linux Kernel | net/qrtr/tun.c |
static __poll_t qrtr_tun_poll(struct file *filp, poll_table *wait) {
struct qrtr_tun *tun = filp->private_data;
__poll_t mask = 0;
poll_wait(filp, &tun->readq, wait);
if (!skb_queue_empty(&tun->queue))
mask |= EPOLLIN | EPOLLRDNORM;
return mask;
} | [
0,
0
] |
Linux Kernel | net/qrtr/tun.c | static int qrtr_tun_release(struct inode *inode, struct file *filp) {
struct qrtr_tun *tun = filp->private_data;
qrtr_endpoint_unregister(&tun->ep);
skb_queue_purge(&tun->queue);
kfree(tun);
return 0;
} | [
0,
0
] |
Linux Kernel | net/qrtr/tun.c |
static int __init qrtr_tun_init(void) {
int ret;
ret = misc_register(&qrtr_tun_miscdev);
if (ret)
pr_err("failed to register Qualcomm IPC Router tun device\n");
return ret;
} | [
0,
0
] |
Linux Kernel | net/rds/af_rds.c |
static int rds_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) {
struct rds_sock *rs = rds_sk_to_rs(sock->sk);
rds_tos_t utos, tos = 0;
switch (cmd) {
case SIOCRDSSETTOS:
if (get_user(utos, (rds_tos_t __user *)arg))
return -EFAULT;
if (rs->rs_transport && rs->rs_transport->get_t... | [
1,
0
] |
Linux Kernel | net/rds/af_rds.c | static int rds_cancel_sent_to(struct rds_sock *rs, sockptr_t optval, int len) {
struct sockaddr_in6 sin6;
struct sockaddr_in sin;
int ret = 0;
if (ipv6_addr_any(&rs->rs_bound_addr)) {
ret = -ENOTCONN; /* XXX not a great errno */
goto out;
}
if (len < sizeof(struct sockaddr_in)) {
ret = -EINVAL... | [
1,
1
] |
Linux Kernel | net/rds/af_rds.c | static int rds_set_transport(struct rds_sock *rs, sockptr_t optval,
int optlen) {
int t_type;
if (rs->rs_transport)
return -EOPNOTSUPP;
if (optlen != sizeof(int))
return -EINVAL;
if (copy_from_sockptr(&t_type, optval, sizeof(t_type)))
return -EFAULT;
if (t_type < 0... | [
1,
0
] |
Linux Kernel | net/rds/af_rds.c |
static int rds_recv_track_latency(struct rds_sock *rs, sockptr_t optval,
int optlen) {
struct rds_rx_trace_so trace;
int i;
if (optlen != sizeof(struct rds_rx_trace_so))
return -EFAULT;
if (copy_from_sockptr(&trace, optval, sizeof(trace)))
return -EFAULT;
if (trac... | [
1,
0
] |
Linux Kernel | net/rds/af_rds.c | static void rds_sock_inc_info(struct socket *sock, unsigned int len,
struct rds_info_iterator *iter,
struct rds_info_lengths *lens) {
struct rds_sock *rs;
struct rds_incoming *inc;
unsigned int total = 0;
len /= sizeof(struct rds_info_message);
spi... | [
1,
1
] |
Linux Kernel | net/rds/af_rds.c |
static int __init rds_init(void) {
int ret;
net_get_random_once(&rds_gen_num, sizeof(rds_gen_num));
ret = rds_bind_lock_init();
if (ret)
goto out;
ret = rds_conn_init();
if (ret)
goto out_bind;
ret = rds_threads_init();
if (ret)
goto out_conn;
ret = rds_sysctl_init();
if (ret)
g... | [
1,
0
] |
Linux Kernel | net/rds/bind.c | static inline void __rds_create_bind_key(u8 *key, const struct in6_addr *addr,
__be16 port, __u32 scope_id) {
memcpy(key, addr, sizeof(*addr));
key += sizeof(*addr);
memcpy(key, &port, sizeof(port));
key += sizeof(port);
memcpy(key, &scope_id, sizeof(scope_id));
} | [
1,
0
] |
Linux Kernel | net/rds/bind.c | struct rds_sock *rds_find_bound(const struct in6_addr *addr, __be16 port,
__u32 scope_id) {
u8 key[RDS_BOUND_KEY_LEN];
struct rds_sock *rs;
__rds_create_bind_key(key, addr, port, scope_id);
rcu_read_lock();
rs = rhashtable_lookup(&bind_hash_table, key, ht_parms);
if (rs && (... | [
0,
0
] |
Linux Kernel | net/rds/bind.c |
int rds_bind_lock_init(void) {
return rhashtable_init(&bind_hash_table, &ht_parms);
} | [
0,
0
] |
Linux Kernel | net/rds/cong.c |
int rds_cong_get_maps(struct rds_connection *conn) {
conn->c_lcong = rds_cong_from_addr(&conn->c_laddr);
conn->c_fcong = rds_cong_from_addr(&conn->c_faddr);
if (!(conn->c_lcong && conn->c_fcong))
return -ENOMEM;
return 0;
} | [
1,
0
] |
Linux Kernel | net/rds/cong.c | void rds_cong_queue_updates(struct rds_cong_map *map) {
struct rds_connection *conn;
unsigned long flags;
spin_lock_irqsave(&rds_cong_lock, flags);
list_for_each_entry(conn, &map->m_conn_list, c_map_item) {
struct rds_conn_path *cp = &conn->c_path[0];
rcu_read_lock();
if (!test_and_set_bit(0, &co... | [
0,
0
] |
Linux Kernel | net/rds/cong.c |
int rds_cong_updated_since(unsigned long *recent) {
unsigned long gen = atomic_read(&rds_cong_generation);
if (likely(*recent == gen))
return 0;
*recent = gen;
return 1;
} | [
1,
0
] |
Linux Kernel | net/rds/cong.c | void rds_cong_set_bit(struct rds_cong_map *map, __be16 port) {
unsigned long i;
unsigned long off;
rdsdebug("setting congestion for %pI4:%u in map %p\n", &map->m_addr,
ntohs(port), map);
i = be16_to_cpu(port) / RDS_CONG_MAP_PAGE_BITS;
off = be16_to_cpu(port) % RDS_CONG_MAP_PAGE_BITS;
set_bit_l... | [
0,
0
] |
Linux Kernel | net/rds/cong.c | void rds_cong_remove_socket(struct rds_sock *rs) {
unsigned long flags;
struct rds_cong_map *map;
write_lock_irqsave(&rds_cong_monitor_lock, flags);
list_del_init(&rs->rs_cong_list);
write_unlock_irqrestore(&rds_cong_monitor_lock, flags);
spin_lock_irqsave(&rds_cong_lock, flags);
map = rds_cong_tree_wal... | [
0,
0
] |
Linux Kernel | net/rds/connection.c |
static struct hlist_head *rds_conn_bucket(const struct in6_addr *laddr,
const struct in6_addr *faddr) {
static u32 rds6_hash_secret __read_mostly;
static u32 rds_hash_secret __read_mostly;
u32 lhash, fhash, hash;
net_get_random_once(&rds_hash_secret, sizeof(rds_hash_... | [
1,
0
] |
Linux Kernel | net/rds/connection.c | static struct rds_connection *
rds_conn_lookup(struct net *net, struct hlist_head *head,
const struct in6_addr *laddr, const struct in6_addr *faddr,
struct rds_transport *trans, u8 tos, int dev_if) {
struct rds_connection *conn, *ret = NULL;
hlist_for_each_entry_rcu(conn, head, c_ha... | [
0,
0
] |
Linux Kernel | net/rds/connection.c | static void rds_conn_path_reset(struct rds_conn_path *cp) {
struct rds_connection *conn = cp->cp_conn;
rdsdebug("connection %pI6c to %pI6c reset\n", &conn->c_laddr, &conn->c_faddr);
rds_stats_inc(s_conn_reset);
rds_send_path_reset(cp);
cp->cp_flags = 0;
} | [
0,
0
] |
Linux Kernel | net/rds/connection.c |
struct rds_connection *rds_conn_create_outgoing(struct net *net,
const struct in6_addr *laddr,
const struct in6_addr *faddr,
struct rds_transport *trans,
... | [
0,
0
] |
Linux Kernel | net/rds/connection.c | static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
struct rds_info_iterator *iter,
struct rds_info_lengths *lens,
int want_send, bool isv6) {
struct hlist_head *head;
struct li... | [
1,
1
] |
Linux Kernel | net/rds/connection.c | static void rds6_conn_message_info_retrans(struct socket *sock,
unsigned int len,
struct rds_info_iterator *iter,
struct rds_info_lengths *lens) {
rds6_conn_message_info(sock, len, iter, le... | [
0,
0
] |
Linux Kernel | net/rds/connection.c | void rds_for_each_conn_info(struct socket *sock, unsigned int len,
struct rds_info_iterator *iter,
struct rds_info_lengths *lens,
int (*visitor)(struct rds_connection *, void *),
u64 *buffer, size_t item_len)... | [
0,
1
] |
Linux Kernel | net/rds/connection.c | static int rds_conn_info_visitor(struct rds_conn_path *cp, void *buffer) {
struct rds_info_connection *cinfo = buffer;
struct rds_connection *conn = cp->cp_conn;
if (conn->c_isv6)
return 0;
cinfo->next_tx_seq = cp->cp_next_tx_seq;
cinfo->next_rx_seq = cp->cp_next_rx_seq;
cinfo->laddr = conn->c_laddr.s... | [
1,
1
] |
Linux Kernel | net/rds/connection.c | static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer) {
struct rds6_info_connection *cinfo6 = buffer;
struct rds_connection *conn = cp->cp_conn;
cinfo6->next_tx_seq = cp->cp_next_tx_seq;
cinfo6->next_rx_seq = cp->cp_next_rx_seq;
cinfo6->laddr = conn->c_laddr;
cinfo6->faddr = conn->c_fad... | [
1,
1
] |
Linux Kernel | net/rds/connection.c | static void rds6_conn_info(struct socket *sock, unsigned int len,
struct rds_info_iterator *iter,
struct rds_info_lengths *lens) {
u64 buffer[(sizeof(struct rds6_info_connection) + 7) / 8];
rds_walk_conn_path_info(sock, len, iter, lens, rds6_conn_info_visitor, ... | [
1,
0
] |
Linux Kernel | net/rds/connection.c | void rds_conn_path_drop(struct rds_conn_path *cp, bool destroy) {
atomic_set(&cp->cp_state, RDS_CONN_ERROR);
rcu_read_lock();
if (!destroy && rds_destroy_pending(cp->cp_conn)) {
rcu_read_unlock();
return;
}
queue_work(rds_wq, &cp->cp_down_w);
rcu_read_unlock();
} | [
1,
0
] |
Linux Kernel | net/rds/connection.c |
void rds_conn_drop(struct rds_connection *conn) {
WARN_ON(conn->c_trans->t_mp_capable);
rds_conn_path_drop(&conn->c_path[0], false);
} | [
0,
0
] |
Linux Kernel | net/rds/connection.c |
void __rds_conn_path_error(struct rds_conn_path *cp, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
vprintk(fmt, ap);
va_end(ap);
rds_conn_path_drop(cp, false);
} | [
0,
0
] |
Linux Kernel | net/rds/ib.c | static int rds_ib_conn_info_visitor(struct rds_connection *conn, void *buffer) {
struct rds_info_rdma_connection *iinfo = buffer;
struct rds_ib_connection *ic = conn->c_transport_data;
if (conn->c_trans != &rds_ib_transport)
return 0;
if (conn->c_isv6)
return 0;
iinfo->src_addr = conn->c_laddr.s6_ad... | [
1,
0
] |
Linux Kernel | net/rds/ib.c | static int rds6_ib_conn_info_visitor(struct rds_connection *conn,
void *buffer) {
struct rds6_info_rdma_connection *iinfo6 = buffer;
struct rds_ib_connection *ic = conn->c_transport_data;
if (conn->c_trans != &rds_ib_transport)
return 0;
iinfo6->src_addr = conn->c_ladd... | [
1,
0
] |
Linux Kernel | net/rds/ib.c |
void rds_ib_exit(void) {
rds_ib_set_unloading();
synchronize_rcu();
rds_info_deregister_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
#if IS_ENABLED(CONFIG_IPV6)
rds_info_deregister_func(RDS6_INFO_IB_CONNECTIONS, rds6_ib_ic_info);
#endif
rds_ib_unregister_client();
rds_ib_destroy_nodev_conns();
rds_ib_s... | [
0,
0
] |
Linux Kernel | net/rds/ib_cm.c | static void rds_ib_set_flow_control(struct rds_connection *conn, u32 credits) {
struct rds_ib_connection *ic = conn->c_transport_data;
if (rds_ib_sysctl_flow_control && credits != 0) {
ic->i_flowctl = 1;
rds_ib_send_add_credits(conn, credits);
} else {
ic->i_flowctl = 0;
}
} | [
1,
0
] |
Linux Kernel | net/rds/ib_cm.c | static void rds_ib_cq_comp_handler_recv(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_recv_tasklet);
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.