Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/smc/smc_ib.c | int smc_ib_buf_map_sg(struct smc_link *lnk, struct smc_buf_desc *buf_slot,
enum dma_data_direction data_direction) {
int mapped_nents;
mapped_nents =
ib_dma_map_sg(lnk->smcibdev->ibdev, buf_slot->sgt[lnk->link_idx].sgl,
buf_slot->sgt[lnk->link_idx].orig_nents, data_d... | [
0,
0
] |
Linux Kernel | net/smc/smc_ib.c |
static void smc_copy_netdev_ifindex(struct smc_ib_device *smcibdev, int port) {
struct ib_device *ibdev = smcibdev->ibdev;
struct net_device *ndev;
if (!ibdev->ops.get_netdev)
return;
ndev = ibdev->ops.get_netdev(ibdev, port + 1);
if (ndev) {
smcibdev->ndev_ifidx[port] = ndev->ifindex;
dev_put(n... | [
0,
0
] |
Linux Kernel | net/smc/smc_ib.c | static void smc_ib_remove_dev(struct ib_device *ibdev, void *client_data) {
struct smc_ib_device *smcibdev = client_data;
mutex_lock(&smc_ib_devices.mutex);
list_del_init(&smcibdev->list);
mutex_unlock(&smc_ib_devices.mutex);
pr_warn_ratelimited("smc: removing ib device %s\n", smcibdev->ibdev->name);
smc_s... | [
0,
0
] |
Linux Kernel | net/smc/smc_ib.h |
static inline struct net *smc_ib_net(struct smc_ib_device *smcibdev) {
if (smcibdev && smcibdev->ibdev)
return read_pnet(&smcibdev->ibdev->coredev.rdma_net);
return NULL;
} | [
1,
0
] |
Linux Kernel | net/smc/smc_ism.c |
void smc_ism_get_system_eid(u8 **eid) {
if (!smc_ism_v2_capable)
*eid = NULL;
else
*eid = smc_ism_v2_system_eid;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_ism.c | void smc_ism_set_conn(struct smc_connection *conn) {
unsigned long flags;
spin_lock_irqsave(&conn->lgr->smcd->lock, flags);
conn->lgr->smcd->conn[conn->rmb_desc->sba_idx] = conn;
spin_unlock_irqrestore(&conn->lgr->smcd->lock, flags);
} | [
1,
0
] |
Linux Kernel | net/smc/smc_ism.c |
int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
struct smc_buf_desc *dmb_desc) {
struct smcd_dmb dmb;
int rc;
memset(&dmb, 0, sizeof(dmb));
dmb.dmb_len = dmb_len;
dmb.sba_idx = dmb_desc->sba_idx;
dmb.vlan_id = lgr->vlan_id;
dmb.rgid = lgr->peer_gid;
rc = lgr-... | [
1,
0
] |
Linux Kernel | net/smc/smc_ism.c |
void smcd_unregister_dev(struct smcd_dev *smcd) {
pr_warn_ratelimited("smc: removing smcd device %s\n", dev_name(&smcd->dev));
mutex_lock(&smcd_dev_list.mutex);
list_del_init(&smcd->list);
mutex_unlock(&smcd_dev_list.mutex);
smcd->going_away = 1;
smc_smcd_terminate_all(smcd);
destroy_workqueue(smcd->even... | [
0,
0
] |
Linux Kernel | net/smc/smc_ism.c |
void __init smc_ism_init(void) {
smc_ism_v2_capable = false;
memset(smc_ism_v2_system_eid, 0, SMC_MAX_EID_LEN);
} | [
1,
0
] |
Linux Kernel | net/smc/smc_ism.h |
static inline int smc_ism_write(struct smcd_dev *smcd, u64 dmb_tok,
unsigned int idx, bool sf, unsigned int offset,
void *data, size_t len) {
int rc;
rc = smcd->ops->move_data(smcd, dmb_tok, idx, sf, offset, data, len);
return rc < 0 ? rc : 0;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c |
void smc_llc_flow_qentry_del(struct smc_llc_flow *flow) {
struct smc_llc_qentry *qentry;
if (flow->qentry) {
qentry = flow->qentry;
flow->qentry = NULL;
kfree(qentry);
}
} | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_flow_parallel(struct smc_link_group *lgr, u8 flow_type,
struct smc_llc_qentry *qentry) {
u8 msg_type = qentry->msg.raw.hdr.common.llc_type;
if ((msg_type == SMC_LLC_ADD_LINK || msg_type == SMC_LLC_DELETE_LINK) &&
flow_type != msg_type && !lgr->delayed_eve... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | int smc_llc_flow_initiate(struct smc_link_group *lgr,
enum smc_llc_flowtype type) {
enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE;
int rc;
if (type == SMC_LLC_FLOW_RKEY)
allowed_remote = SMC_LLC_FLOW_RKEY;
again:
if (list_empty(&lgr->list))
return -ENODEV;
spin_lo... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c | void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow) {
spin_lock_bh(&lgr->llc_flow_lock);
memset(flow, 0, sizeof(*flow));
flow->type = SMC_LLC_FLOW_NONE;
spin_unlock_bh(&lgr->llc_flow_lock);
if (!list_empty(&lgr->list) && lgr->delayed_event &&
flow == &lgr->llc_flow_lcl)
sch... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static int smc_llc_add_pending_send(struct smc_link *link,
struct smc_wr_buf **wr_buf,
struct smc_wr_tx_pend_priv **pend) {
int rc;
rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL, pend);
if (rc < 0)
return rc;
BUIL... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16]) {
struct smc_llc_msg_test_link *testllc;
struct smc_wr_tx_pend_priv *pend;
struct smc_wr_buf *wr_buf;
int rc;
if (!smc_wr_tx_link_hold(link))
return -ENOLINK;
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
if (rc)
go... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf) {
struct smc_wr_tx_pend_priv *pend;
struct smc_wr_buf *wr_buf;
int rc;
if (!smc_wr_tx_link_hold(link))
return -ENOLINK;
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
if (rc)
goto put_out;
memcpy(wr_buf, llcbuf, sizeo... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c |
static int smc_llc_cli_rkey_exchange(struct smc_link *link,
struct smc_link *link_new) {
struct smc_llc_msg_add_link_cont *addc_llc;
struct smc_link_group *lgr = link->lgr;
u8 max, num_rkeys_send, num_rkeys_recv;
struct smc_llc_qentry *qentry;
struct smc_buf_desc *buf_pos... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_cli_add_link_invite(struct smc_link *link,
struct smc_llc_qentry *qentry) {
struct smc_link_group *lgr = smc_get_lgr(link);
struct smc_init_info *ini = NULL;
if (lgr->smc_version == SMC_V2) {
smc_llc_send_request_add_link(link);
goto out;
}
... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_delete_asym_link(struct smc_link_group *lgr) {
struct smc_link *lnk_new = NULL, *lnk_asym;
struct smc_llc_qentry *qentry;
int rc;
lnk_asym = smc_llc_find_asym_link(lgr);
if (!lnk_asym)
return;
if (!smc_link_downing(&lnk_asym->state))
return;
lnk_new = smc_switch_conns(lgr, lnk... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c |
static int smc_llc_srv_rkey_exchange(struct smc_link *link,
struct smc_link *link_new) {
struct smc_llc_msg_add_link_cont *addc_llc;
struct smc_link_group *lgr = link->lgr;
u8 max, num_rkeys_send, num_rkeys_recv;
struct smc_llc_qentry *qentry = NULL;
struct smc_buf_desc *... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c |
static void smc_llc_send_req_add_link_response(struct smc_llc_qentry *qentry) {
qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
smc_llc_init_msg_hdr(&qentry->msg.raw.hdr, qentry->link->lgr,
sizeof(qentry->msg));
memset(&qentry->msg.raw.data, 0, sizeof(qentry->msg.raw.data));
smc_llc_send... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_process_srv_add_link(struct smc_link_group *lgr) {
struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
struct smc_llc_qentry *qentry;
int rc;
qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
mutex_lock(&lgr->llc_conf_mutex);
rc = smc_llc_srv_add_link(link, qentry);
if (!rc &... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_add_link_work(struct work_struct *work) {
struct smc_link_group *lgr =
container_of(work, struct smc_link_group, llc_add_link_work);
if (list_empty(&lgr->list)) {
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
goto out;
}
if (lgr->role == SMC_CLNT)
smc_llc_process_cli_add_... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c | void smc_llc_srv_delete_link_local(struct smc_link *link, u8 del_link_id) {
struct smc_llc_msg_del_link del_llc = {};
del_llc.hd.common.llc_type = SMC_LLC_DELETE_LINK;
smc_llc_init_msg_hdr(&del_llc.hd, link->lgr, sizeof(del_llc));
del_llc.link_num = del_link_id;
del_llc.reason = htonl(SMC_LLC_DEL_LOST_PATH);... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | static void smc_llc_rx_handler(struct ib_wc *wc, void *buf) {
struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
union smc_llc_msg *llc = buf;
if (wc->byte_len < sizeof(*llc))
return;
if (!llc->raw.hdr.common.llc_version) {
if (llc->raw.hdr.length != sizeof(*llc))
return; /* invalid m... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c |
void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc) {
struct net *net = sock_net(smc->clcsock->sk);
INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work);
INIT_LIST_HEAD... | [
0,
0
] |
Linux Kernel | net/smc/smc_llc.c | void smc_llc_link_clear(struct smc_link *link, bool log) {
if (log)
pr_warn_ratelimited("smc: SMC-R lg %*phN net %llu link removed: id %*phN"
", peerid %*phN, ibdev %s, ibport %d\n",
SMC_LGR_ID_SIZE, &link->lgr->id,
link->lgr->net->net_cookie... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
struct smc_buf_desc *rmb_desc) {
struct smc_llc_qentry *qentry = NULL;
struct smc_link *send_link;
int rc = 0;
send_link = smc_llc_usable_link(lgr);
if (!send_link)
return -ENOLINK;
rc = smc_llc_send_delete_rkey(send_lin... | [
1,
0
] |
Linux Kernel | net/smc/smc_llc.c | void smc_llc_save_peer_uid(struct smc_llc_qentry *qentry) {
memcpy(qentry->link->peer_link_uid, qentry->msg.confirm_link.link_uid,
SMC_LGR_ID_SIZE);
} | [
1,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static struct smc_ib_device *smc_pnet_find_ib(char *ib_name) {
struct smc_ib_device *ibdev;
mutex_lock(&smc_ib_devices.mutex);
list_for_each_entry(ibdev, &smc_ib_devices.list, list) {
if (!strncmp(ibdev->ibdev->name, ib_name, sizeof(ibdev->ibdev->name)) ||
(ibdev->ibdev->dev.parent &&
!strnc... | [
1,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static struct smcd_dev *smc_pnet_find_smcd(char *smcd_name) {
struct smcd_dev *smcd_dev;
mutex_lock(&smcd_dev_list.mutex);
list_for_each_entry(smcd_dev, &smcd_dev_list.list, list) {
if (!strncmp(dev_name(&smcd_dev->dev), smcd_name, IB_DEVICE_NAME_MAX - 1))
goto out;
}
smcd_dev = NULL;
out:
mutex_... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static int smc_pnet_set_nla(struct sk_buff *msg,
struct smc_pnetentry *pnetelem) {
if (nla_put_string(msg, SMC_PNETID_NAME, pnetelem->pnet_name))
return -1;
if (pnetelem->type == SMC_PNET_ETH) {
if (nla_put_string(msg, SMC_PNETID_ETHNAME, pnetelem->eth_name))
return -1;
}... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
static int smc_pnet_dump_start(struct netlink_callback *cb) {
cb->args[0] = 0;
return 0;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
bool smc_pnet_is_ndev_pnetid(struct net *net, u8 *pnetid) {
struct smc_net *sn = net_generic(net, smc_net_id);
struct smc_pnetids_ndev_entry *pe;
bool rc = false;
read_lock(&sn->pnetids_ndev.lock);
list_for_each_entry(pe, &sn->pnetids_ndev.list, list) {
if (smc_pnet_match(pnetid, pe->pnetid)) {
rc... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
static int smc_pnet_add_pnetid(struct net *net, u8 *pnetid) {
struct smc_net *sn = net_generic(net, smc_net_id);
struct smc_pnetids_ndev_entry *pe, *pi;
pe = kzalloc(sizeof(*pe), GFP_KERNEL);
if (!pe)
return -ENOMEM;
write_lock(&sn->pnetids_ndev.lock);
list_for_each_entry(pi, &sn->pnetids_ndev.list, ... | [
1,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
static void smc_pnet_remove_pnetid(struct net *net, u8 *pnetid) {
struct smc_net *sn = net_generic(net, smc_net_id);
struct smc_pnetids_ndev_entry *pe, *pe2;
write_lock(&sn->pnetids_ndev.lock);
list_for_each_entry_safe(pe, pe2, &sn->pnetids_ndev.list, list) {
if (smc_pnet_match(pnetid, pe->pnetid)) {
... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static void smc_pnet_create_pnetids_list(struct net *net) {
u8 ndev_pnetid[SMC_MAX_PNETID_LEN];
struct net_device *dev;
rtnl_lock();
for_each_netdev(net, dev) smc_pnet_add_base_pnetid(net, dev, ndev_pnetid);
rtnl_unlock();
} | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
void smc_pnet_exit(void) {
unregister_netdevice_notifier(&smc_netdev_notifier);
genl_unregister_family(&smc_pnet_nl_family);
} | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static int smc_pnet_find_ndev_pnetid_by_table(struct net_device *ndev,
u8 *pnetid) {
struct smc_pnettable *pnettable;
struct net *net = dev_net(ndev);
struct smc_pnetentry *pnetelem;
struct smc_net *sn;
int rc = -ENOENT;
sn = net_generic(net, smc_net_id);
pne... | [
1,
0
] |
Linux Kernel | net/smc/smc_pnet.c |
static int smc_pnet_determine_gid(struct smc_ib_device *ibdev, int i,
struct smc_init_info *ini) {
if (!ini->check_smcrv2 &&
!smc_ib_determine_gid(ibdev, i, ini->vlan_id, ini->ib_gid, NULL, NULL)) {
ini->ib_dev = ibdev;
ini->ib_port = i;
return 0;
}
if (ini->ch... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static void _smc_pnet_find_roce_by_pnetid(u8 *pnet_id,
struct smc_init_info *ini,
struct smc_ib_device *known_dev,
struct net *net) {
struct smc_ib_device *ibdev;
int i;
mutex_lock(&smc_i... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | static void smc_pnet_find_roce_by_pnetid(struct net_device *ndev,
struct smc_init_info *ini) {
u8 ndev_pnetid[SMC_MAX_PNETID_LEN];
struct net *net;
ndev = pnet_find_base_ndev(ndev);
net = dev_net(ndev);
if (smc_pnetid_by_dev_port(ndev->dev.parent, ndev->dev_port, ndev... | [
0,
0
] |
Linux Kernel | net/smc/smc_pnet.c | int smc_pnetid_by_table_smcd(struct smcd_dev *smcddev) {
const char *ib_name = dev_name(&smcddev->dev);
struct smc_pnettable *pnettable;
struct smc_pnetentry *tmp_pe;
struct smc_net *sn;
int rc = -ENOENT;
sn = net_generic(&init_net, smc_net_id);
pnettable = &sn->pnettable;
mutex_lock(&pnettable->lock)... | [
0,
0
] |
Linux Kernel | net/smc/smc_rx.c | static void smc_rx_wake_up(struct sock *sk) {
struct socket_wq *wq;
/* called already in smc_listen_work() */
rcu_read_lock();
wq = rcu_dereference(sk->sk_wq);
if (skwq_has_sleeper(wq))
wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
EPOL... | [
0,
0
] |
Linux Kernel | net/smc/smc_rx.c | static int smc_rx_update_consumer(struct smc_sock *smc,
union smc_host_cursor cons, size_t len) {
struct smc_connection *conn = &smc->conn;
struct sock *sk = &smc->sk;
bool force = false;
int diff, rc = 0;
smc_curs_add(conn->rmb_desc->len, &cons, len);
if (conn->urg_state... | [
0,
0
] |
Linux Kernel | net/smc/smc_stats.c |
int smc_nl_get_fback_stats(struct sk_buff *skb, struct netlink_callback *cb) {
struct smc_nl_dmp_ctx *cb_ctx = smc_nl_dmp_ctx(cb);
struct net *net = sock_net(skb->sk);
int rc_srv = 0, rc_clnt = 0, k;
int skip_serv = cb_ctx->pos[1];
int snum = cb_ctx->pos[0];
bool is_srv = true;
mutex_lock(&net->smc.mute... | [
1,
0
] |
Linux Kernel | net/smc/smc_sysctl.c |
int __net_init smc_sysctl_net_init(struct net *net) {
struct ctl_table *table;
table = smc_table;
if (!net_eq(net, &init_net)) {
int i;
table = kmemdup(table, sizeof(smc_table), GFP_KERNEL);
if (!table)
goto err_alloc;
for (i = 0; i < ARRAY_SIZE(smc_table) - 1; i++)
table[i].data +... | [
1,
0
] |
Linux Kernel | net/smc/smc_sysctl.h |
static inline int smc_sysctl_net_init(struct net *net) {
net->smc.sysctl_autocorking_size = SMC_AUTOCORKING_DEFAULT_SIZE;
return 0;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_tx.c | static bool smc_tx_should_cork(struct smc_sock *smc, struct msghdr *msg) {
struct smc_connection *conn = &smc->conn;
if (smc_should_autocork(smc))
return true;
if ((msg->msg_flags & MSG_MORE || smc_tx_is_corked(smc) ||
msg->msg_flags & MSG_SENDPAGE_NOTLAST) &&
atomic_read(&conn->sndbuf_space))
... | [
0,
0
] |
Linux Kernel | net/smc/smc_tx.c |
void smc_tx_consumer_update(struct smc_connection *conn, bool force) {
union smc_host_cursor cfed, cons, prod;
int sender_free = conn->rmb_desc->len;
int to_confirm;
smc_curs_copy(&cons, &conn->local_tx_ctrl.cons, conn);
smc_curs_copy(&cfed, &conn->rx_curs_confirmed, conn);
to_confirm = smc_curs_diff(conn... | [
1,
0
] |
Linux Kernel | net/smc/smc_wr.c | void smc_wr_tx_wait_no_pending_sends(struct smc_link *link) {
wait_event(link->wr_tx_wait, !smc_wr_is_tx_pend(link));
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c | int smc_wr_tx_get_free_slot(struct smc_link *link, smc_wr_tx_handler handler,
struct smc_wr_buf **wr_buf,
struct smc_rdma_wr **wr_rdma_buf,
struct smc_wr_tx_pend_priv **wr_pend_priv) {
struct smc_link_group *lgr = smc_get_lgr(link);
... | [
1,
0
] |
Linux Kernel | net/smc/smc_wr.c | int smc_wr_tx_send(struct smc_link *link, struct smc_wr_tx_pend_priv *priv) {
struct smc_wr_tx_pend *pend;
int rc;
ib_req_notify_cq(link->smcibdev->roce_cq_send,
IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS);
pend = container_of(priv, struct smc_wr_tx_pend, priv);
rc = ib_post_send(link->r... | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c |
int smc_wr_tx_v2_send(struct smc_link *link, struct smc_wr_tx_pend_priv *priv,
int len) {
int rc;
link->wr_tx_v2_ib->sg_list[0].length = len;
ib_req_notify_cq(link->smcibdev->roce_cq_send,
IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS);
rc = ib_post_send(link->roce_qp, ... | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c | static inline void smc_wr_rx_process_cqes(struct ib_wc wc[], int num) {
struct smc_link *link;
int i;
for (i = 0; i < num; i++) {
link = wc[i].qp->qp_context;
link->wr_rx_id_compl = wc[i].wr_id;
if (wc[i].status == IB_WC_SUCCESS) {
link->wr_rx_tstamp = jiffies;
smc_wr_rx_demultiplex(&wc[i... | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c |
int smc_wr_rx_post_init(struct smc_link *link) {
u32 i;
int rc = 0;
for (i = 0; i < link->wr_rx_cnt; i++)
rc = smc_wr_rx_post(link);
return rc;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c |
void smc_wr_free_lgr_mem(struct smc_link_group *lgr) {
if (lgr->smc_version < SMC_V2)
return;
kfree(lgr->wr_rx_buf_v2);
lgr->wr_rx_buf_v2 = NULL;
kfree(lgr->wr_tx_buf_v2);
lgr->wr_tx_buf_v2 = NULL;
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.c |
void smc_wr_remove_dev(struct smc_ib_device *smcibdev) {
tasklet_kill(&smcibdev->recv_tasklet);
tasklet_kill(&smcibdev->send_tasklet);
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.h |
static inline void smc_wr_tx_link_put(struct smc_link *link) {
if (atomic_dec_and_test(&link->wr_tx_refcnt))
wake_up_all(&link->wr_tx_wait);
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.h |
static inline void smc_wr_wakeup_tx_wait(struct smc_link *lnk) {
wake_up_all(&lnk->wr_tx_wait);
} | [
0,
0
] |
Linux Kernel | net/smc/smc_wr.h | static inline int smc_wr_rx_post(struct smc_link *link) {
int rc;
u64 wr_id, temp_wr_id;
u32 index;
wr_id = ++link->wr_rx_id;
temp_wr_id = wr_id;
index = do_div(temp_wr_id, link->wr_rx_cnt);
link->wr_rx_ibs[index].wr_id = wr_id;
rc = ib_post_recv(link->roce_qp, &link->wr_rx_ibs[index], NULL);
return ... | [
1,
0
] |
Linux Kernel | net/socket.c | static void sock_show_fdinfo(struct seq_file *m, struct file *f) {
struct socket *sock = f->private_data;
if (sock->ops->show_fdinfo)
sock->ops->show_fdinfo(m, sock);
}
#else
#define sock_show_fdinfo NULL
#endif | [
0,
0
] |
Linux Kernel | net/socket.c |
static struct inode *sock_alloc_inode(struct super_block *sb) {
struct socket_alloc *ei;
ei = alloc_inode_sb(sb, sock_inode_cachep, GFP_KERNEL);
if (!ei)
return NULL;
init_waitqueue_head(&ei->socket.wq.wait);
ei->socket.wq.fasync_list = NULL;
ei->socket.wq.flags = 0;
ei->socket.state = SS_UNCONNECT... | [
0,
0
] |
Linux Kernel | net/socket.c |
static void sock_free_inode(struct inode *inode) {
struct socket_alloc *ei;
ei = container_of(inode, struct socket_alloc, vfs_inode);
kmem_cache_free(sock_inode_cachep, ei);
} | [
0,
0
] |
Linux Kernel | net/socket.c |
static void init_once(void *foo) {
struct socket_alloc *ei = (struct socket_alloc *)foo;
inode_init_once(&ei->vfs_inode);
} | [
0,
0
] |
Linux Kernel | net/socket.c | static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) {
return dynamic_dname(buffer, buflen, "socket:[%lu]", d_inode(dentry)->i_ino);
} | [
0,
0
] |
Linux Kernel | net/socket.c |
static int sockfs_xattr_get(const struct xattr_handler *handler,
struct dentry *dentry, struct inode *inode,
const char *suffix, void *value, size_t size) {
if (value) {
if (dentry->d_name.len + 1 > size)
return -ERANGE;
memcpy(value, dentry->d_na... | [
1,
0
] |
Linux Kernel | net/socket.c | struct file *sock_alloc_file(struct socket *sock, int flags,
const char *dname) {
struct file *file;
if (!dname)
dname = sock->sk ? sock->sk->sk_prot_creator->name : "";
file = alloc_file_pseudo(SOCK_INODE(sock), sock_mnt, dname,
O_RDWR | (flags & O_NO... | [
1,
0
] |
Linux Kernel | net/socket.c |
static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
size_t size) {
ssize_t len;
ssize_t used = 0;
len = security_inode_listsecurity(d_inode(dentry), buffer, size);
if (len < 0)
return len;
used += len;
if (buffer) {
if (size < used)
return -ER... | [
1,
0
] |
Linux Kernel | net/socket.c | static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg) {
int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg, inet_sendmsg,
sock, msg, msg_data_left(msg));
BUG_ON(ret == -EIOCBQUEUED);
return ret;
} | [
0,
0
] |
Linux Kernel | net/socket.c |
static ktime_t get_timestamp(struct sock *sk, struct sk_buff *skb,
int *if_index) {
bool cycles = sk->sk_tsflags & SOF_TIMESTAMPING_BIND_PHC;
struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
struct net_device *orig_dev;
ktime_t hwtstamp;
rcu_read_lock();
orig_dev... | [
0,
0
] |
Linux Kernel | net/socket.c |
static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb,
int if_index) {
struct scm_ts_pktinfo ts_pktinfo;
struct net_device *orig_dev;
if (!skb_mac_header_was_set(skb))
return;
memset(&ts_pktinfo, 0, sizeof(ts_pktinfo));
if (!if_index) {
rcu_read_lock();
... | [
1,
0
] |
Linux Kernel | net/socket.c |
static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
struct sk_buff *skb) {
if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL, sizeof(__u32),
&SOCK_SKB_CB(skb)->dropcount);
} | [
1,
0
] |
Linux Kernel | net/socket.c | static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
int flags) {
return INDIRECT_CALL_INET(sock->ops->recvmsg, inet6_recvmsg, inet_recvmsg,
sock, msg, msg_data_left(msg), flags);
} | [
0,
0
] |
Linux Kernel | net/socket.c |
static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from) {
struct file *file = iocb->ki_filp;
struct socket *sock = file->private_data;
struct msghdr msg = {.msg_iter = *from, .msg_iocb = iocb};
ssize_t res;
if (iocb->ki_pos != 0)
return -ESPIPE;
if (file->f_flags & O_NONBLOCK || (io... | [
1,
0
] |
Linux Kernel | net/socket.c | static long sock_do_ioctl(struct net *net, struct socket *sock,
unsigned int cmd, unsigned long arg) {
struct ifreq ifr;
bool need_copyout;
int err;
void __user *argp = (void __user *)arg;
void __user *data;
err = sock->ops->ioctl(sock, cmd, arg);
if (err != -ENOIOCTLCMD)
r... | [
1,
0
] |
Linux Kernel | net/socket.c |
static int sock_mmap(struct file *file, struct vm_area_struct *vma) {
struct socket *sock = file->private_data;
return sock->ops->mmap(file, sock, vma);
} | [
0,
0
] |
Linux Kernel | net/socket.c | static struct socket *__sys_socket_create(int family, int type, int protocol) {
struct socket *sock;
int retval;
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
... | [
1,
0
] |
Linux Kernel | net/socket.c | int __sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) {
struct socket *sock;
struct sockaddr_storage address;
int err, fput_needed;
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (sock) {
err = move_addr_to_kernel(umyaddr, addrlen, &address);
if (!err) {
err = security_so... | [
0,
0
] |
Linux Kernel | net/socket.c | int __sys_listen(int fd, int backlog) {
struct socket *sock;
int err, fput_needed;
int somaxconn;
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (sock) {
somaxconn = READ_ONCE(sock_net(sock->sk)->core.sysctl_somaxconn);
if ((unsigned int)backlog > somaxconn)
backlog = somaxconn;
er... | [
0,
0
] |
Linux Kernel | net/socket.c |
static int __sys_accept4_file(struct file *file,
struct sockaddr __user *upeer_sockaddr,
int __user *upeer_addrlen, int flags) {
struct file *newfile;
int newfd;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
if (SOCK_NONBLOCK != O... | [
1,
0
] |
Linux Kernel | net/socket.c | int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
int __user *upeer_addrlen, int flags) {
int ret = -EBADF;
struct fd f;
f = fdget(fd);
if (f.file) {
ret = __sys_accept4_file(f.file, upeer_sockaddr, upeer_addrlen, flags);
fdput(f);
}
return ret;
} | [
0,
0
] |
Linux Kernel | net/socket.c | int __sys_getsockname(int fd, struct sockaddr __user *usockaddr,
int __user *usockaddr_len) {
struct socket *sock;
struct sockaddr_storage address;
int err, fput_needed;
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (!sock)
goto out;
err = security_socket_getsockname(soc... | [
0,
0
] |
Linux Kernel | net/socket.c | int __sys_sendto(int fd, void __user *buff, size_t len, unsigned int flags,
struct sockaddr __user *addr, int addr_len) {
struct socket *sock;
struct sockaddr_storage address;
int err;
struct msghdr msg;
struct iovec iov;
int fput_needed;
err = import_single_range(ITER_SOURCE, buff, len,... | [
1,
0
] |
Linux Kernel | net/socket.c | int __sys_shutdown_sock(struct socket *sock, int how) {
int err;
err = security_socket_shutdown(sock, how);
if (!err)
err = sock->ops->shutdown(sock, how);
return err;
} | [
0,
0
] |
Linux Kernel | net/socket.c |
int sendmsg_copy_msghdr(struct msghdr *msg, struct user_msghdr __user *umsg,
unsigned flags, struct iovec **iov) {
int err;
if (flags & MSG_CMSG_COMPAT) {
struct compat_msghdr __user *msg_compat;
msg_compat = (struct compat_msghdr __user *)umsg;
err = get_compat_msghdr(msg, ms... | [
0,
0
] |
Linux Kernel | net/socket.c |
bool sock_is_registered(int family) {
return family < NPROTO && rcu_access_pointer(net_families[family]);
} | [
0,
0
] |
Linux Kernel | net/socket.c | static int __init sock_init(void) {
int err;
err = net_sysctl_init();
if (err)
goto out;
/*
* Initialize skbuff SLAB cache
*/
skb_init();
/*
* Initialize the protocols module.
*/
init_inodecache();
err = register_filesystem(&sock_fs_type);
if (err)
goto out;
sock_m... | [
0,
0
] |
Linux Kernel | net/socket.c | int get_user_ifreq(struct ifreq *ifr, void __user **ifrdata, void __user *arg) {
if (in_compat_syscall()) {
struct compat_ifreq *ifr32 = (struct compat_ifreq *)ifr;
memset(ifr, 0, sizeof(*ifr));
if (copy_from_user(ifr32, arg, sizeof(*ifr32)))
return -EFAULT;
if (ifrdata)
*ifrdata = compa... | [
1,
0
] |
Linux Kernel | net/socket.c | int kernel_listen(struct socket *sock, int backlog) {
return sock->ops->listen(sock, backlog);
} | [
0,
0
] |
Linux Kernel | net/socket.c | int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
int flags) {
return sock->ops->connect(sock, addr, addrlen, flags);
} | [
0,
0
] |
Linux Kernel | net/socket.c | int kernel_getsockname(struct socket *sock, struct sockaddr *addr) {
return sock->ops->getname(sock, addr, 0);
} | [
0,
0
] |
Linux Kernel | net/socket.c | int kernel_sendpage(struct socket *sock, struct page *page, int offset,
size_t size, int flags) {
if (sock->ops->sendpage) {
WARN_ONCE(!sendpage_ok(page), "improper page for zero-copy send");
return sock->ops->sendpage(sock, page, offset, size, flags);
}
return sock_no_sendpage(sock, ... | [
0,
0
] |
Linux Kernel | net/strparser/strparser.c |
static inline struct _strp_msg *_strp_msg(struct sk_buff *skb) {
return (struct _strp_msg *)((void *)skb->cb +
offsetof(struct sk_skb_cb, strp));
} | [
0,
0
] |
Linux Kernel | net/strparser/strparser.c |
static int strp_recv(read_descriptor_t *desc, struct sk_buff *orig_skb,
unsigned int orig_offset, size_t orig_len) {
struct strparser *strp = (struct strparser *)desc->arg.data;
return __strp_recv(desc, orig_skb, orig_offset, orig_len, strp->sk->sk_rcvbuf,
strp->sk->sk_rc... | [
1,
0
] |
Linux Kernel | net/strparser/strparser.c |
static void strp_sock_unlock(struct strparser *strp) { release_sock(strp->sk); } | [
0,
0
] |
Linux Kernel | net/strparser/strparser.c | void strp_unpause(struct strparser *strp) {
strp->paused = 0;
smp_mb();
queue_work(strp_wq, &strp->work);
} | [
0,
0
] |
Linux Kernel | net/strparser/strparser.c |
void strp_check_rcv(struct strparser *strp) {
queue_work(strp_wq, &strp->work);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/addr.c |
static size_t rpc_pton4(const char *buf, const size_t buflen,
struct sockaddr *sap, const size_t salen) {
struct sockaddr_in *sin = (struct sockaddr_in *)sap;
u8 *addr = (u8 *)&sin->sin_addr.s_addr;
if (buflen > INET_ADDRSTRLEN || salen < sizeof(struct sockaddr_in))
return 0;
mems... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.