Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/sunrpc/xprt.c | struct rpc_xprt *xprt_create_transport(struct xprt_create *args) {
struct rpc_xprt *xprt;
const struct xprt_class *t;
t = xprt_class_find_by_ident(args->ident);
if (!t) {
dprintk("RPC: transport (%d) not supported\n", args->ident);
return ERR_PTR(-EIO);
}
xprt = t->setup(args);
xprt_class_releas... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c | void rpc_xprt_switch_add_xprt(struct rpc_xprt_switch *xps,
struct rpc_xprt *xprt) {
if (xprt == NULL)
return;
spin_lock(&xps->xps_lock);
if (xps->xps_net == xprt->xprt_net || xps->xps_net == NULL)
xprt_switch_add_xprt_locked(xps, xprt);
spin_unlock(&xps->xps_lock);
rpc_sy... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static void xprt_switch_free(struct kref *kref) {
struct rpc_xprt_switch *xps =
container_of(kref, struct rpc_xprt_switch, xps_kref);
xprt_switch_free_entries(xps);
rpc_sysfs_xprt_switch_destroy(xps);
xprt_switch_free_id(xps);
kfree_rcu(xps, xps_rcu);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c | void xprt_switch_put(struct rpc_xprt_switch *xps) {
if (xps != NULL)
kref_put(&xps->xps_kref, xprt_switch_free);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static const struct rpc_xprt_iter_ops *
xprt_iter_ops(const struct rpc_xprt_iter *xpi) {
if (xpi->xpi_ops != NULL)
return xpi->xpi_ops;
return rcu_dereference(xpi->xpi_xpswitch)->xps_iter_ops;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static struct rpc_xprt *xprt_iter_current_entry(struct rpc_xprt_iter *xpi) {
return _xprt_iter_current_entry(xpi, xprt_switch_find_first_entry,
xprt_switch_find_current_entry);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static struct rpc_xprt *
xprt_switch_find_current_entry_offline(struct list_head *head,
const struct rpc_xprt *cur) {
return _xprt_switch_find_current_entry(head, cur, false);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static struct rpc_xprt *
xprt_switch_set_next_cursor(struct rpc_xprt_switch *xps,
struct rpc_xprt **cursor,
xprt_switch_find_xprt_t find_next) {
struct rpc_xprt *pos, *old;
old = smp_load_acquire(cursor);
pos = find_next(xps, old);
smp_store_release(curs... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static struct rpc_xprt *
xprt_iter_next_entry_offline(struct rpc_xprt_iter *xpi) {
return xprt_iter_next_entry_multiple(xpi,
xprt_switch_find_next_entry_offline);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c |
static void __xprt_iter_init(struct rpc_xprt_iter *xpi,
struct rpc_xprt_switch *xps,
const struct rpc_xprt_iter_ops *ops) {
rcu_assign_pointer(xpi->xpi_xpswitch, xprt_switch_get(xps));
xpi->xpi_cursor = NULL;
xpi->xpi_ops = ops;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c | void xprt_iter_init_listall(struct rpc_xprt_iter *xpi,
struct rpc_xprt_switch *xps) {
__xprt_iter_init(xpi, xps, &rpc_xprt_iter_listall);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c | void xprt_iter_destroy(struct rpc_xprt_iter *xpi) {
xprt_switch_put(xprt_iter_xchg_switch(xpi, NULL));
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtmultipath.c | struct rpc_xprt *xprt_iter_get_next(struct rpc_xprt_iter *xpi) {
struct rpc_xprt *xprt;
rcu_read_lock();
xprt = xprt_iter_get_helper(xpi, xprt_iter_ops(xpi)->xpi_next);
rcu_read_unlock();
return xprt;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/backchannel.c | int xprt_rdma_bc_setup(struct rpc_xprt *xprt, unsigned int reqs) {
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
r_xprt->rx_buf.rb_bc_srv_max_requests = RPCRDMA_BACKWARD_WRS >> 1;
trace_xprtrdma_cb_setup(r_xprt, reqs);
return 0;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/backchannel.c | int xprt_rdma_bc_send_reply(struct rpc_rqst *rqst) {
struct rpc_xprt *xprt = rqst->rq_xprt;
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
int rc;
if (!xprt_connected(xprt))
return -ENOTCONN;
if (!xprt_request_get_cong(xprt, rqst))
return -EBADSLT... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/backchannel.c | void xprt_rdma_bc_free_rqst(struct rpc_rqst *rqst) {
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
struct rpcrdma_rep *rep = req->rl_reply;
struct rpc_xprt *xprt = rqst->rq_xprt;
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
rpcrdma_rep_put(&r_xprt->rx_buf, rep);
req->rl_reply = NULL;
spin_lock(&x... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/backchannel.c | static struct rpc_rqst *rpcrdma_bc_rqst_get(struct rpcrdma_xprt *r_xprt) {
struct rpc_xprt *xprt = &r_xprt->rx_xprt;
struct rpcrdma_req *req;
struct rpc_rqst *rqst;
size_t size;
spin_lock(&xprt->bc_pa_lock);
rqst = list_first_entry_or_null(&xprt->bc_pa_list, struct rpc_rqst,
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/frwr_ops.c | static void frwr_wc_fastreg(struct ib_cq *cq, struct ib_wc *wc) {
struct ib_cqe *cqe = wc->wr_cqe;
struct rpcrdma_mr *mr = container_of(cqe, struct rpcrdma_mr, mr_cqe);
trace_xprtrdma_wc_fastreg(wc, &mr->mr_cid);
rpcrdma_flush_disconnect(cq->cq_context, wc);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/frwr_ops.c |
static void frwr_mr_done(struct ib_wc *wc, struct rpcrdma_mr *mr) {
if (likely(wc->status == IB_WC_SUCCESS))
frwr_mr_put(mr);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/frwr_ops.c | static void frwr_wc_localinv(struct ib_cq *cq, struct ib_wc *wc) {
struct ib_cqe *cqe = wc->wr_cqe;
struct rpcrdma_mr *mr = container_of(cqe, struct rpcrdma_mr, mr_cqe);
trace_xprtrdma_wc_li(wc, &mr->mr_cid);
frwr_mr_done(wc, mr);
rpcrdma_flush_disconnect(cq->cq_context, wc);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/frwr_ops.c | static void frwr_wc_localinv_wake(struct ib_cq *cq, struct ib_wc *wc) {
struct ib_cqe *cqe = wc->wr_cqe;
struct rpcrdma_mr *mr = container_of(cqe, struct rpcrdma_mr, mr_cqe);
trace_xprtrdma_wc_li_wake(wc, &mr->mr_cid);
frwr_mr_done(wc, mr);
complete(&mr->mr_linv_done);
rpcrdma_flush_disconnect(cq->cq_cont... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/module.c |
static int __init rpc_rdma_init(void) {
int rc;
rc = svc_rdma_init();
if (rc)
goto out;
rc = xprt_rdma_init();
if (rc)
svc_rdma_cleanup();
out:
return rc;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | void rpcrdma_set_max_header_sizes(struct rpcrdma_ep *ep) {
unsigned int maxsegs = ep->re_max_rdma_segs;
ep->re_max_inline_send =
ep->re_inline_send - rpcrdma_max_call_header_size(maxsegs);
ep->re_max_inline_recv =
ep->re_inline_recv - rpcrdma_max_reply_header_size(maxsegs);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static noinline int rpcrdma_alloc_sparse_pages(struct xdr_buf *buf) {
struct page **ppages;
int len;
len = buf->page_len;
ppages = buf->pages + (buf->page_base >> PAGE_SHIFT);
while (len > 0) {
if (!*ppages)
*ppages = alloc_page(GFP_NOWAIT | __GFP_NOWARN);
if (!*ppages)
return -ENOBUFS;
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c |
static int encode_rdma_segment(struct xdr_stream *xdr, struct rpcrdma_mr *mr) {
__be32 *p;
p = xdr_reserve_space(xdr, 4 * sizeof(*p));
if (unlikely(!p))
return -EMSGSIZE;
xdr_encode_rdma_segment(p, mr->mr_handle, mr->mr_length, mr->mr_offset);
return 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static int encode_read_segment(struct xdr_stream *xdr, struct rpcrdma_mr *mr,
u32 position) {
__be32 *p;
p = xdr_reserve_space(xdr, 6 * sizeof(*p));
if (unlikely(!p))
return -EMSGSIZE;
*p++ = xdr_one;
xdr_encode_read_segment(p, position, mr->mr_handle, mr->mr_length,
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c |
static void rpcrdma_sendctx_done(struct kref *kref) {
struct rpcrdma_req *req = container_of(kref, struct rpcrdma_req, rl_kref);
struct rpcrdma_rep *rep = req->rl_reply;
rpcrdma_complete_rqst(rep);
rep->rr_rxprt->rx_stats.reply_waits_for_send++;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static bool rpcrdma_prepare_tail_iov(struct rpcrdma_req *req,
struct xdr_buf *xdr,
unsigned int page_base, unsigned int len) {
struct rpcrdma_sendctx *sc = req->rl_sendctx;
struct ib_sge *sge = &sc->sc_sges[req->rl_wr.num_sge++];
struct rpc... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static void rpcrdma_pullup_tail_iov(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_req *req,
struct xdr_buf *xdr) {
unsigned char *dst;
dst = (unsigned char *)xdr->head[0].iov_base;
dst += xdr->head[0].iov_len + xdr->page_len;
memmove(dst, xd... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static void rpcrdma_pullup_pagelist(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_req *req,
struct xdr_buf *xdr) {
unsigned int len, page_base, remaining;
struct page **ppages;
unsigned char *src, *dst;
dst = (unsigned char *)xdr->head[0].io... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | inline int rpcrdma_prepare_send_sges(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_req *req, u32 hdrlen,
struct xdr_buf *xdr,
enum rpcrdma_chunktype rtype) {
int ret;
ret = -EAGAIN;
req->rl_sendctx = rpcr... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c |
static void __rpcrdma_update_cwnd_locked(struct rpc_xprt *xprt,
struct rpcrdma_buffer *buf,
u32 grant) {
buf->rb_credits = grant;
xprt->cwnd = grant << RPC_CWNDSHIFT;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c |
static void rpcrdma_update_cwnd(struct rpcrdma_xprt *r_xprt, u32 grant) {
struct rpc_xprt *xprt = &r_xprt->rx_xprt;
spin_lock(&xprt->transport_lock);
__rpcrdma_update_cwnd_locked(xprt, &r_xprt->rx_buf, grant);
spin_unlock(&xprt->transport_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static bool rpcrdma_is_bcall(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_rep *rep)
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
{
struct rpc_xprt *xprt = &r_xprt->rx_xprt;
struct xdr_stream *xdr = &rep->rr_stream;
__be32 *p;
if (rep->rr_proc != rdma_msg)
return false;
p = xdr_inli... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static int decode_read_list(struct xdr_stream *xdr) {
__be32 *p;
p = xdr_inline_decode(xdr, sizeof(*p));
if (unlikely(!p))
return -EIO;
if (unlikely(xdr_item_is_present(p)))
return -EIO;
return 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static int decode_write_list(struct xdr_stream *xdr, u32 *length) {
u32 chunklen;
bool first;
__be32 *p;
*length = 0;
first = true;
do {
p = xdr_inline_decode(xdr, sizeof(*p));
if (unlikely(!p))
return -EIO;
if (xdr_item_is_absent(p))
break;
if (!first)
return -EIO;
i... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c |
static int decode_reply_chunk(struct xdr_stream *xdr, u32 *length) {
__be32 *p;
p = xdr_inline_decode(xdr, sizeof(*p));
if (unlikely(!p))
return -EIO;
*length = 0;
if (xdr_item_is_present(p))
if (decode_write_chunk(xdr, length))
return -EIO;
return 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | static int rpcrdma_decode_msg(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_rep *rep, struct rpc_rqst *rqst) {
struct xdr_stream *xdr = &rep->rr_stream;
u32 writelist, replychunk, rpclen;
char *base;
if (decode_read_list(xdr))
return -EIO;
if (decode_write_list(xdr, &writelist... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | void rpcrdma_unpin_rqst(struct rpcrdma_rep *rep) {
struct rpc_xprt *xprt = &rep->rr_rxprt->rx_xprt;
struct rpc_rqst *rqst = rep->rr_rqst;
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
req->rl_reply = NULL;
rep->rr_rqst = NULL;
spin_lock(&xprt->queue_lock);
xprt_unpin_rqst(rqst);
spin_unlock(&xprt->qu... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/rpc_rdma.c | void rpcrdma_complete_rqst(struct rpcrdma_rep *rep) {
struct rpcrdma_xprt *r_xprt = rep->rr_rxprt;
struct rpc_xprt *xprt = &r_xprt->rx_xprt;
struct rpc_rqst *rqst = rep->rr_rqst;
int status;
switch (rep->rr_proc) {
case rdma_msg:
status = rpcrdma_decode_msg(r_xprt, rep, rqst);
break;
case rdma_no... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma.c |
static void svc_rdma_proc_cleanup(void) {
if (!svcrdma_table_header)
return;
unregister_sysctl_table(svcrdma_table_header);
svcrdma_table_header = NULL;
percpu_counter_destroy(&svcrdma_stat_write);
percpu_counter_destroy(&svcrdma_stat_sq_starve);
percpu_counter_destroy(&svcrdma_stat_recv);
percpu_co... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_backchannel.c | void svc_rdma_handle_bc_reply(struct svc_rqst *rqstp,
struct svc_rdma_recv_ctxt *rctxt) {
struct svc_xprt *sxprt = rqstp->rq_xprt;
struct rpc_xprt *xprt = sxprt->xpt_bc_xprt;
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
struct xdr_buf *rcvbuf = &rqstp->rq_arg;
struct kvec *... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_backchannel.c | static int svc_rdma_bc_sendto(struct svcxprt_rdma *rdma, struct rpc_rqst *rqst,
struct svc_rdma_send_ctxt *sctxt) {
struct svc_rdma_recv_ctxt *rctxt;
int ret;
rctxt = svc_rdma_recv_ctxt_get(rdma);
if (!rctxt)
return -EIO;
ret = svc_rdma_map_reply_msg(rdma, sctxt, rctxt, &rq... | [
0,
1
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_backchannel.c | static struct rpc_xprt *xprt_setup_rdma_bc(struct xprt_create *args) {
struct rpc_xprt *xprt;
struct rpcrdma_xprt *new_xprt;
if (args->addrlen > sizeof(xprt->addr))
return ERR_PTR(-EBADF);
xprt = xprt_alloc(args->net, sizeof(*new_xprt), RPCRDMA_MAX_BC_REQUESTS,
RPCRDMA_MAX_BC_REQUESTS)... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_pcl.c | bool pcl_alloc_write(struct svc_rdma_recv_ctxt *rctxt, struct svc_rdma_pcl *pcl,
__be32 *p) {
struct svc_rdma_segment *segment;
struct svc_rdma_chunk *chunk;
unsigned int i, j;
u32 segcount;
for (i = 0; i < pcl->cl_count; i++) {
p++;
segcount = be32_to_cpup(p++);
chunk = pcl... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_pcl.c | int pcl_process_nonpayloads(const struct svc_rdma_pcl *pcl,
const struct xdr_buf *xdr,
int (*actor)(const struct xdr_buf *, void *),
void *data) {
struct svc_rdma_chunk *chunk, *next;
unsigned int start;
int ret;
chunk = pcl_fi... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c | void svc_rdma_recv_ctxts_destroy(struct svcxprt_rdma *rdma) {
struct svc_rdma_recv_ctxt *ctxt;
struct llist_node *node;
while ((node = llist_del_first(&rdma->sc_recv_ctxts))) {
ctxt = llist_entry(node, struct svc_rdma_recv_ctxt, rc_node);
svc_rdma_recv_ctxt_destroy(rdma, ctxt);
}
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c | void svc_rdma_release_rqst(struct svc_rqst *rqstp) {
struct svc_rdma_recv_ctxt *ctxt = rqstp->rq_xprt_ctxt;
struct svc_xprt *xprt = rqstp->rq_xprt;
struct svcxprt_rdma *rdma = container_of(xprt, struct svcxprt_rdma, sc_xprt);
rqstp->rq_xprt_ctxt = NULL;
if (ctxt)
svc_rdma_recv_ctxt_put(rdma, ctxt);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c |
static void svc_rdma_build_arg_xdr(struct svc_rqst *rqstp,
struct svc_rdma_recv_ctxt *ctxt) {
struct xdr_buf *arg = &rqstp->rq_arg;
arg->head[0].iov_base = ctxt->rc_recv_buf;
arg->head[0].iov_len = ctxt->rc_byte_len;
arg->tail[0].iov_base = NULL;
arg->tail[0].iov_len = 0;
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c | static bool xdr_check_write_chunk(struct svc_rdma_recv_ctxt *rctxt) {
u32 segcount;
__be32 *p;
if (xdr_stream_decode_u32(&rctxt->rc_stream, &segcount))
return false;
p = xdr_inline_decode(&rctxt->rc_stream,
segcount * rpcrdma_segment_maxsz * sizeof(*p));
return p != NULL;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c | static int svc_rdma_xdr_decode_req(struct xdr_buf *rq_arg,
struct svc_rdma_recv_ctxt *rctxt) {
__be32 *p, *rdma_argp;
unsigned int hdr_len;
rdma_argp = rq_arg->head[0].iov_base;
xdr_init_decode(&rctxt->rc_stream, rq_arg, rdma_argp, NULL);
p = xdr_inline_decode(&rctxt->rc_s... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_recvfrom.c |
static void svc_rdma_send_error(struct svcxprt_rdma *rdma,
struct svc_rdma_recv_ctxt *rctxt, int status) {
struct svc_rdma_send_ctxt *sctxt;
sctxt = svc_rdma_send_ctxt_get(rdma);
if (!sctxt)
return;
svc_rdma_send_error_msg(rdma, sctxt, rctxt, status);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c |
static inline struct svc_rdma_rw_ctxt *
svc_rdma_next_ctxt(struct list_head *list) {
return list_first_entry_or_null(list, struct svc_rdma_rw_ctxt, rw_list);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c |
static struct svc_rdma_rw_ctxt *svc_rdma_get_rw_ctxt(struct svcxprt_rdma *rdma,
unsigned int sges) {
struct svc_rdma_rw_ctxt *ctxt;
struct llist_node *node;
spin_lock(&rdma->sc_rw_ctxt_lock);
node = llist_del_first(&rdma->sc_rw_ctxts);
spin_unlock(&rdma->... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | void svc_rdma_destroy_rw_ctxts(struct svcxprt_rdma *rdma) {
struct svc_rdma_rw_ctxt *ctxt;
struct llist_node *node;
while ((node = llist_del_first(&rdma->sc_rw_ctxts)) != NULL) {
ctxt = llist_entry(node, struct svc_rdma_rw_ctxt, rw_node);
kfree(ctxt);
}
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | static void svc_rdma_cc_release(struct svc_rdma_chunk_ctxt *cc,
enum dma_data_direction dir) {
struct svcxprt_rdma *rdma = cc->cc_rdma;
struct llist_node *first, *last;
struct svc_rdma_rw_ctxt *ctxt;
LLIST_HEAD(free);
first = last = NULL;
while ((ctxt = svc_rdma_next_ctxt(&c... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c |
static struct svc_rdma_write_info *
svc_rdma_write_info_alloc(struct svcxprt_rdma *rdma,
const struct svc_rdma_chunk *chunk) {
struct svc_rdma_write_info *info;
info = kmalloc(sizeof(*info), GFP_KERNEL);
if (!info)
return info;
info->wi_chunk = chunk;
info->wi_seg_off = 0;
i... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | static int svc_rdma_post_chunk_ctxt(struct svc_rdma_chunk_ctxt *cc) {
struct svcxprt_rdma *rdma = cc->cc_rdma;
struct ib_send_wr *first_wr;
const struct ib_send_wr *bad_wr;
struct list_head *tmp;
struct ib_cqe *cqe;
int ret;
if (cc->cc_sqecount > rdma->sc_sq_depth)
return -EINVAL;
first_wr = NULL;... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | static int svc_rdma_build_writes(
struct svc_rdma_write_info *info,
void (*constructor)(struct svc_rdma_write_info *info, unsigned int len,
struct svc_rdma_rw_ctxt *ctxt),
unsigned int remaining) {
struct svc_rdma_chunk_ctxt *cc = &info->wi_cc;
struct svcxprt_rdma *rdma = cc->cc_... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | static int svc_rdma_xb_write(const struct xdr_buf *xdr, void *data) {
struct svc_rdma_write_info *info = data;
int ret;
if (xdr->head[0].iov_len) {
ret = svc_rdma_iov_write(info, &xdr->head[0]);
if (ret < 0)
return ret;
}
if (xdr->page_len) {
ret = svc_rdma_pages_write(info, xdr, xdr->head... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | int svc_rdma_send_write_chunk(struct svcxprt_rdma *rdma,
const struct svc_rdma_chunk *chunk,
const struct xdr_buf *xdr) {
struct svc_rdma_write_info *info;
struct svc_rdma_chunk_ctxt *cc;
int ret;
info = svc_rdma_write_info_alloc(rdma, chunk);
if (!... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_rw.c | static int svc_rdma_read_chunk_range(struct svc_rdma_read_info *info,
const struct svc_rdma_chunk *chunk,
unsigned int offset, unsigned int length) {
const struct svc_rdma_segment *segment;
int ret;
ret = -EINVAL;
pcl_for_each_segment(se... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | void svc_rdma_wake_send_waiters(struct svcxprt_rdma *rdma, int avail) {
atomic_add(avail, &rdma->sc_sq_avail);
smp_mb__after_atomic();
if (unlikely(waitqueue_active(&rdma->sc_send_wait)))
wake_up(&rdma->sc_send_wait);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | int svc_rdma_send(struct svcxprt_rdma *rdma, struct svc_rdma_send_ctxt *ctxt) {
struct ib_send_wr *wr = &ctxt->sc_send_wr;
int ret;
reinit_completion(&ctxt->sc_done);
ib_dma_sync_single_for_device(rdma->sc_pd->device, wr->sg_list[0].addr,
wr->sg_list[0].length, DMA_TO_DEVICE);
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | static ssize_t svc_rdma_encode_write_segment(struct svc_rdma_send_ctxt *sctxt,
const struct svc_rdma_chunk *chunk,
u32 *remaining,
unsigned int segno) {
const struct svc_rdma_segment ... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | static int svc_rdma_iov_dma_map(void *data, const struct kvec *iov) {
if (!iov->iov_len)
return 0;
return svc_rdma_page_dma_map(data, virt_to_page(iov->iov_base),
offset_in_page(iov->iov_base), iov->iov_len);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | static int svc_rdma_xb_count_sges(const struct xdr_buf *xdr, void *data) {
struct svc_rdma_pullup_data *args = data;
unsigned int remaining;
unsigned long offset;
if (xdr->head[0].iov_len)
++args->pd_num_sges;
offset = offset_in_page(xdr->page_base);
remaining = xdr->page_len;
while (remaining) {
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | static int svc_rdma_pull_up_reply_msg(const struct svcxprt_rdma *rdma,
struct svc_rdma_send_ctxt *sctxt,
const struct svc_rdma_recv_ctxt *rctxt,
const struct xdr_buf *xdr) {
struct svc_rdma_pullup_data ar... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_sendto.c | int svc_rdma_result_payload(struct svc_rqst *rqstp, unsigned int offset,
unsigned int length) {
struct svc_rdma_recv_ctxt *rctxt = rqstp->rq_xprt_ctxt;
struct svc_rdma_chunk *chunk;
struct svcxprt_rdma *rdma;
struct xdr_buf subbuf;
int ret;
chunk = rctxt->rc_cur_result_payload;
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c | static struct svcxprt_rdma *svc_rdma_create_xprt(struct svc_serv *serv,
struct net *net) {
struct svcxprt_rdma *cma_xprt = kzalloc(sizeof *cma_xprt, GFP_KERNEL);
if (!cma_xprt) {
dprintk("svcrdma: failed to create new transport\n");
return NULL;
}
svc_xp... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c |
static void svc_rdma_parse_connect_private(struct svcxprt_rdma *newxprt,
struct rdma_conn_param *param) {
const struct rpcrdma_connect_private *pmsg = param->private_data;
if (pmsg && pmsg->cp_magic == rpcrdma_cmp_magic &&
pmsg->cp_version == RPCRDMA_CMP_VERSION) {... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c | static int svc_rdma_listen_handler(struct rdma_cm_id *cma_id,
struct rdma_cm_event *event) {
switch (event->event) {
case RDMA_CM_EVENT_CONNECT_REQUEST:
handle_connect_req(cma_id, &event->param.conn);
break;
default:
break;
}
return 0;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c | static struct svc_xprt *svc_rdma_create(struct svc_serv *serv, struct net *net,
struct sockaddr *sa, int salen,
int flags) {
struct rdma_cm_id *listen_id;
struct svcxprt_rdma *cma_xprt;
int ret;
if (sa->sa_family != AF_INET && sa->... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c | static int svc_rdma_has_wspace(struct svc_xprt *xprt) {
struct svcxprt_rdma *rdma = container_of(xprt, struct svcxprt_rdma, sc_xprt);
if (waitqueue_active(&rdma->sc_send_wait))
return 0;
/* Otherwise return true. */
return 1;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/svc_rdma_transport.c |
static void svc_rdma_secure_port(struct svc_rqst *rqstp) {
__set_bit(RQ_SECURE, &rqstp->rq_flags);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c |
void xprt_rdma_format_addresses(struct rpc_xprt *xprt, struct sockaddr *sap) {
char buf[128];
switch (sap->sa_family) {
case AF_INET:
xprt_rdma_format_addresses4(xprt, sap);
break;
case AF_INET6:
xprt_rdma_format_addresses6(xprt, sap);
break;
default:
pr_err("rpcrdma: Unrecognized addres... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | void xprt_rdma_close(struct rpc_xprt *xprt) {
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
rpcrdma_xprt_disconnect(r_xprt);
xprt->reestablish_timeout = 0;
++xprt->connect_cookie;
xprt_disconnect_done(xprt);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static void xprt_rdma_set_port(struct rpc_xprt *xprt, u16 port) {
struct sockaddr *sap = (struct sockaddr *)&xprt->addr;
char buf[8];
rpc_set_port(sap, port);
kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
snprintf(buf, sizeof(buf), "%u", port);
xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static void xprt_rdma_timer(struct rpc_xprt *xprt, struct rpc_task *task) {
xprt_force_disconnect(xprt);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static void xprt_rdma_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *rqst) {
struct rpcrdma_xprt *r_xprt =
container_of(xprt, struct rpcrdma_xprt, rx_xprt);
rpcrdma_reply_put(&r_xprt->rx_buf, rpcr_to_rdmar(rqst));
if (!xprt_wake_up_backlog(xprt, rqst)) {
memset(rqst, 0, sizeof(*rqst));
rpcrdma_b... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c |
static bool rpcrdma_check_regbuf(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_regbuf *rb, size_t size,
gfp_t flags) {
if (unlikely(rdmab_length(rb) < size)) {
if (!rpcrdma_regbuf_realloc(rb, size, flags))
return false;
r_xprt->rx_stats.ha... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static int xprt_rdma_allocate(struct rpc_task *task) {
struct rpc_rqst *rqst = task->tk_rqstp;
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(rqst->rq_xprt);
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
gfp_t flags = rpc_task_gfp_mask();
if (!rpcrdma_check_regbuf(r_xprt, req->rl_sendbuf, rqst->rq_callsize, fl... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static void xprt_rdma_free(struct rpc_task *task) {
struct rpc_rqst *rqst = task->tk_rqstp;
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
if (unlikely(!list_empty(&req->rl_registered))) {
trace_xprtrdma_mrs_zap(task);
frwr_unmap_sync(rpcx_to_rdmax(rqst->rq_xprt), req);
}
/* XXX: If the RPC is compl... | [
0,
1
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c | static int xprt_rdma_send_request(struct rpc_rqst *rqst) {
struct rpc_xprt *xprt = rqst->rq_xprt;
struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
int rc = 0;
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
if (unlikely(!rqst->rq_buffer))
return xprt_rdma_bc_send_r... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/transport.c |
void xprt_rdma_cleanup(void) {
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
if (sunrpc_table_header) {
unregister_sysctl_table(sunrpc_table_header);
sunrpc_table_header = NULL;
}
#endif
xprt_unregister_transport(&xprt_rdma);
xprt_unregister_transport(&xprt_rdma_bc);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | void rpcrdma_flush_disconnect(struct rpcrdma_xprt *r_xprt, struct ib_wc *wc) {
if (wc->status != IB_WC_SUCCESS)
rpcrdma_force_disconnect(r_xprt->rx_ep);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c |
static void rpcrdma_ep_destroy(struct kref *kref) {
struct rpcrdma_ep *ep = container_of(kref, struct rpcrdma_ep, re_kref);
if (ep->re_id->qp) {
rdma_destroy_qp(ep->re_id);
ep->re_id->qp = NULL;
}
if (ep->re_attr.recv_cq)
ib_free_cq(ep->re_attr.recv_cq);
ep->re_attr.recv_cq = NULL;
if (ep->re... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static noinline int rpcrdma_ep_put(struct rpcrdma_ep *ep) {
return kref_put(&ep->re_kref, rpcrdma_ep_destroy);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | int rpcrdma_xprt_connect(struct rpcrdma_xprt *r_xprt) {
struct rpc_xprt *xprt = &r_xprt->rx_xprt;
struct rpcrdma_ep *ep;
int rc;
rc = rpcrdma_ep_create(r_xprt);
if (rc)
return rc;
ep = r_xprt->rx_ep;
xprt_clear_connected(xprt);
rpcrdma_reset_cwnd(r_xprt);
rpcrdma_ep_get(ep);
rpcrdma_post_recv... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static void rpcrdma_sendctxs_destroy(struct rpcrdma_xprt *r_xprt) {
struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
unsigned long i;
if (!buf->rb_sc_ctxs)
return;
for (i = 0; i <= buf->rb_sc_last; i++)
kfree(buf->rb_sc_ctxs[i]);
kfree(buf->rb_sc_ctxs);
buf->rb_sc_ctxs = NULL;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static int rpcrdma_sendctxs_create(struct rpcrdma_xprt *r_xprt) {
struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
struct rpcrdma_sendctx *sc;
unsigned long i;
i = r_xprt->rx_ep->re_max_requests + RPCRDMA_MAX_BC_REQUESTS;
buf->rb_sc_ctxs = kcalloc(i, sizeof(sc), XPRTRDMA_GFP_FLAGS);
if (!buf->rb_sc_ctxs)
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | struct rpcrdma_sendctx *
rpcrdma_sendctx_get_locked(struct rpcrdma_xprt *r_xprt) {
struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
struct rpcrdma_sendctx *sc;
unsigned long next_head;
next_head = rpcrdma_sendctx_next(buf, buf->rb_sc_head);
if (next_head == READ_ONCE(buf->rb_sc_tail))
goto out_emptyq;
s... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static void rpcrdma_sendctx_put_locked(struct rpcrdma_xprt *r_xprt,
struct rpcrdma_sendctx *sc) {
struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
unsigned long next_tail;
next_tail = buf->rb_sc_tail;
do {
next_tail = rpcrdma_sendctx_next(buf, next_tail);
/* ORDER: ... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static void rpcrdma_req_reset(struct rpcrdma_req *req) {
req->rl_slot.rq_cong = 0;
rpcrdma_regbuf_free(req->rl_rdmabuf);
req->rl_rdmabuf = NULL;
rpcrdma_regbuf_dma_unmap(req->rl_sendbuf);
rpcrdma_regbuf_dma_unmap(req->rl_recvbuf);
frwr_reset(req);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c |
void rpcrdma_rep_free(struct rpcrdma_rep *rep) {
rpcrdma_regbuf_free(rep->rr_rdmabuf);
kfree(rep);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | void rpcrdma_req_destroy(struct rpcrdma_req *req) {
struct rpcrdma_mr *mr;
list_del(&req->rl_all);
while ((mr = rpcrdma_mr_pop(&req->rl_free_mrs))) {
struct rpcrdma_buffer *buf = &mr->mr_xprt->rx_buf;
spin_lock(&buf->rb_lock);
list_del(&mr->mr_all);
spin_unlock(&buf->rb_lock);
frwr_mr_rele... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | void rpcrdma_reply_put(struct rpcrdma_buffer *buffers,
struct rpcrdma_req *req) {
if (req->rl_reply) {
rpcrdma_rep_put(buffers, req->rl_reply);
req->rl_reply = NULL;
}
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | struct rpcrdma_req *rpcrdma_buffer_get(struct rpcrdma_buffer *buffers) {
struct rpcrdma_req *req;
spin_lock(&buffers->rb_lock);
req = list_first_entry_or_null(&buffers->rb_send_bufs, struct rpcrdma_req,
rl_list);
if (req)
list_del_init(&req->rl_list);
spin_unlock(&buffers... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | static struct rpcrdma_regbuf *
rpcrdma_regbuf_alloc(size_t size, enum dma_data_direction direction) {
struct rpcrdma_regbuf *rb;
rb = kmalloc(sizeof(*rb), XPRTRDMA_GFP_FLAGS);
if (!rb)
return NULL;
rb->rg_data = kmalloc(size, XPRTRDMA_GFP_FLAGS);
if (!rb->rg_data) {
kfree(rb);
return NULL;
}
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprtrdma/verbs.c | void rpcrdma_post_recvs(struct rpcrdma_xprt *r_xprt, int needed, bool temp) {
struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
struct rpcrdma_ep *ep = r_xprt->rx_ep;
struct ib_recv_wr *wr, *bad_wr;
struct rpcrdma_rep *rep;
int count, rc;
rc = 0;
count = 0;
if (likely(ep->re_receive_count > needed))
g... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.