Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/sunrpc/svc.c | static void __svc_unregister(struct net *net, const u32 program,
const u32 version, const char *progname) {
int error;
error = rpcb_v4_register(net, program, version, NULL, "");
if (error == -EPROTONOSUPPORT)
error = rpcb_register(net, program, version, 0, 0);
trace_svc_unreg... | [
0,
0
] |
Linux Kernel | net/sunrpc/svc.c | u32 svc_max_payload(const struct svc_rqst *rqstp) {
u32 max = rqstp->rq_xprt->xpt_class->xcl_max_payload;
if (rqstp->rq_server->sv_max_payload < max)
max = rqstp->rq_server->sv_max_payload;
return max;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svc.c | const char *svc_proc_name(const struct svc_rqst *rqstp) {
if (rqstp && rqstp->rq_procinfo)
return rqstp->rq_procinfo->pc_name;
return "unknown";
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svc.c | char *svc_fill_symlink_pathname(struct svc_rqst *rqstp, struct kvec *first,
void *p, size_t total) {
size_t len, remaining;
char *result, *dst;
result = kmalloc(total + 1, GFP_KERNEL);
if (!result)
return ERR_PTR(-ESERVERFAULT);
dst = result;
remaining = total;
len =... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcauth.c |
static void svc_put_auth_ops(struct auth_ops *aops) { module_put(aops->owner); } | [
0,
0
] |
Linux Kernel | net/sunrpc/svcauth.c |
int svc_authenticate(struct svc_rqst *rqstp) {
rpc_authflavor_t flavor;
struct auth_ops *aops;
rqstp->rq_auth_stat = rpc_auth_ok;
flavor = svc_getnl(&rqstp->rq_arg.head[0]);
dprintk("svc: svc_authenticate (%d)\n", flavor);
aops = svc_get_auth_ops(flavor);
if (aops == NULL) {
rqstp->rq_auth_stat =... | [
0,
0
] |
Linux Kernel | net/sunrpc/svcauth.c | void auth_domain_cleanup(void) {
int h;
struct auth_domain *hp;
for (h = 0; h < DN_HASHMAX; h++)
hlist_for_each_entry(hp, &auth_domain_table[h], hash)
pr_warn("svc: domain %s still present at module unload.\n", hp->name);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c |
static inline int hash_ip6(const struct in6_addr *ip) {
return hash_32(ipv6_addr_hash(ip), IP_HASHBITS);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c | static void ip_map_init(struct cache_head *cnew, struct cache_head *citem) {
struct ip_map *new = container_of(cnew, struct ip_map, h);
struct ip_map *item = container_of(citem, struct ip_map, h);
strcpy(new->m_class, item->m_class);
new->m_addr = item->m_addr;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c |
static struct ip_map *__ip_map_lookup(struct cache_detail *cd, char *class,
struct in6_addr *addr) {
struct ip_map ip;
struct cache_head *ch;
strcpy(ip.m_class, class);
ip.m_addr = *addr;
ch = sunrpc_cache_lookup_rcu(cd, &ip.h,
hash_str(c... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c |
static void unix_gid_request(struct cache_detail *cd, struct cache_head *h,
char **bpp, int *blen) {
char tuid[20];
struct unix_gid *ug = container_of(h, struct unix_gid, h);
snprintf(tuid, 20, "%u", from_kuid(&init_user_ns, ug->uid));
qword_add(bpp, blen, tuid);
(*bpp)[-1] = '\... | [
0,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c | static int unix_gid_parse(struct cache_detail *cd, char *mesg, int mlen) {
int id;
kuid_t uid;
int gids;
int rv;
int i;
int err;
time64_t expiry;
struct unix_gid ug, *ugp;
if (mesg[mlen - 1] != '\n')
return -EINVAL;
mesg[mlen - 1] = 0;
rv = get_int(&mesg, &id);
if (rv)
return -EINVAL;... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c | static int svcauth_null_accept(struct svc_rqst *rqstp) {
struct kvec *argv = &rqstp->rq_arg.head[0];
struct kvec *resv = &rqstp->rq_res.head[0];
struct svc_cred *cred = &rqstp->rq_cred;
if (argv->iov_len < 3 * 4)
return SVC_GARBAGE;
if (svc_getu32(argv) != 0) {
dprintk("svc: bad null cred\n");
r... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcauth_unix.c |
void ip_map_cache_destroy(struct net *net) {
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
struct cache_detail *cd = sn->ip_map_cache;
sn->ip_map_cache = NULL;
cache_purge(cd);
cache_unregister_net(cd, net);
cache_destroy_net(cd, net);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svcsock.c | static ssize_t svc_tcp_read_msg(struct svc_rqst *rqstp, size_t buflen,
size_t seek) {
struct svc_sock *svsk =
container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
struct bio_vec *bvec = rqstp->rq_bvec;
struct msghdr msg = {NULL};
unsigned int i;
ssize_t len;
size_t t... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcsock.c | static int svc_udp_get_dest_address(struct svc_rqst *rqstp,
struct cmsghdr *cmh) {
switch (cmh->cmsg_level) {
case SOL_IP:
return svc_udp_get_dest_address4(rqstp, cmh);
case SOL_IPV6:
return svc_udp_get_dest_address6(rqstp, cmh);
}
return 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svcsock.c |
static void svc_udp_kill_temp_xprt(struct svc_xprt *xprt) {} | [
0,
0
] |
Linux Kernel | net/sunrpc/svcsock.c |
static void svc_tcp_save_pages(struct svc_sock *svsk, struct svc_rqst *rqstp) {
unsigned int i, len, npages;
if (svsk->sk_datalen == 0)
return;
len = svsk->sk_datalen;
npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
for (i = 0; i < npages; i++) {
svsk->sk_pages[i] = rqstp->rq_pages[i];
rqstp->rq_p... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcsock.c | static ssize_t svc_tcp_read_marker(struct svc_sock *svsk,
struct svc_rqst *rqstp) {
ssize_t want, len;
if (svsk->sk_tcplen < sizeof(rpc_fraghdr)) {
struct msghdr msg = {NULL};
struct kvec iov;
want = sizeof(rpc_fraghdr) - svsk->sk_tcplen;
iov.iov_base = ((char *)... | [
1,
0
] |
Linux Kernel | net/sunrpc/svcsock.c |
void svc_init_xprt_sock(void) {
svc_reg_xprt_class(&svc_tcp_class);
svc_reg_xprt_class(&svc_udp_class);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
void svc_unreg_xprt_class(struct svc_xprt_class *xcl) {
dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
spin_lock(&svc_xprt_class_lock);
list_del_init(&xcl->xcl_list);
spin_unlock(&svc_xprt_class_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
void svc_xprt_put(struct svc_xprt *xprt) {
kref_put(&xprt->xpt_ref, svc_xprt_free);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
struct svc_serv *serv, struct net *net,
const int family,
const unsigned short port, int flags) {
struct sockaddr_in sin = {
... | [
1,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt) {
memcpy(&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen);
rqstp->rq_addrlen = xprt->xpt_remotelen;
memcpy(&rqstp->rq_daddr, &xprt->xpt_local, xprt->xpt_locallen);
rqstp->rq_daddrlen = xprt->xpt_locallen;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | char *svc_print_addr(struct svc_rqst *rqstp, char *buf, size_t len) {
return __svc_print_addr(svc_addr(rqstp), buf, len);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
static bool svc_xprt_slots_in_range(struct svc_xprt *xprt) {
unsigned int limit = svc_rpc_per_connection_limit;
int nrqsts = atomic_read(&xprt->xpt_nr_rqsts);
return limit == 0 || (nrqsts >= 0 && nrqsts < limit);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | void svc_xprt_enqueue(struct svc_xprt *xprt) {
struct svc_pool *pool;
struct svc_rqst *rqstp = NULL;
if (!svc_xprt_ready(xprt))
return;
if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
return;
pool = svc_pool_for_cpu(xprt->xpt_server);
atomic_long_inc(&pool->sp_stats.packets);
spin_lock_bh(&... | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
int svc_port_is_privileged(struct sockaddr *sin) {
switch (sin->sa_family) {
case AF_INET:
return ntohs(((struct sockaddr_in *)sin)->sin_port) < PROT_SOCK;
case AF_INET6:
return ntohs(((struct sockaddr_in6 *)sin)->sin6_port) < PROT_SOCK;
default:
return 0;
}
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | static int svc_alloc_arg(struct svc_rqst *rqstp) {
struct svc_serv *serv = rqstp->rq_server;
struct xdr_buf *arg = &rqstp->rq_arg;
unsigned long pages, filled, ret;
pagevec_init(&rqstp->rq_pvec);
pages = (serv->sv_max_mesg + 2 * PAGE_SIZE) >> PAGE_SHIFT;
if (pages > RPCSVC_MAXPAGES) {
pr_warn_once("sv... | [
1,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
static void call_xpt_users(struct svc_xprt *xprt) {
struct svc_xpt_user *u;
spin_lock(&xprt->xpt_lock);
while (!list_empty(&xprt->xpt_users)) {
u = list_first_entry(&xprt->xpt_users, struct svc_xpt_user, list);
list_del_init(&u->list);
u->callback(u);
}
spin_unlock(&xprt->xpt_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | void svc_xprt_close(struct svc_xprt *xprt) {
trace_svc_xprt_close(xprt);
set_bit(XPT_CLOSE, &xprt->xpt_flags);
if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
return;
/*
* We expect svc_close_xprt() to work even when no threads are
* running (e.g., while configuring the server before starting
* ... | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | static void svc_revisit(struct cache_deferred_req *dreq, int too_many) {
struct svc_deferred_req *dr =
container_of(dreq, struct svc_deferred_req, handle);
struct svc_xprt *xprt = dr->xprt;
spin_lock(&xprt->xpt_lock);
set_bit(XPT_DEFERRED, &xprt->xpt_flags);
if (too_many || test_bit(XPT_DEAD, &xprt->xp... | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c |
static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt) {
struct svc_deferred_req *dr = NULL;
if (!test_bit(XPT_DEFERRED, &xprt->xpt_flags))
return NULL;
spin_lock(&xprt->xpt_lock);
if (!list_empty(&xprt->xpt_deferred)) {
dr = list_entry(xprt->xpt_deferred.next, struct svc_deferre... | [
0,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
struct net *net, const sa_family_t af,
const unsigned short port) {
struct svc_xprt *xprt;
struct svc_xprt *found = NULL;
if (serv == NULL || xcl_name == NULL)
return foun... | [
1,
0
] |
Linux Kernel | net/sunrpc/svc_xprt.c | int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen) {
struct svc_xprt *xprt;
int len, totlen;
char *pos;
if (!serv)
return 0;
spin_lock_bh(&serv->sv_lock);
pos = buf;
totlen = 0;
list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
len = svc_one_xprt_name(xprt, pos, b... | [
0,
0
] |
Linux Kernel | net/sunrpc/sysctl.c |
static int proc_do_xprt(struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) {
char tmpbuf[256];
ssize_t len;
if (write || *ppos) {
*lenp = 0;
return 0;
}
len = svc_print_xprts(tmpbuf, sizeof(tmpbuf));
len = memory_read_from_buffer(buffer, *lenp, pp... | [
1,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static inline struct rpc_xprt *
rpc_sysfs_xprt_kobj_get_xprt(struct kobject *kobj) {
struct rpc_sysfs_xprt *x = container_of(kobj, struct rpc_sysfs_xprt, kobject);
return xprt_get(x->xprt);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static ssize_t rpc_sysfs_xprt_dstaddr_show(struct kobject *kobj,
struct kobj_attribute *attr,
char *buf) {
struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
ssize_t ret;
if (!xprt) {
ret = sprintf(buf, "<closed>\... | [
1,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static void rpc_sysfs_xprt_switch_release(struct kobject *kobj) {
struct rpc_sysfs_xprt_switch *xprt_switch;
xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject);
kfree(xprt_switch);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static const void *rpc_sysfs_client_namespace(struct kobject *kobj) {
return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static const void *rpc_sysfs_xprt_switch_namespace(struct kobject *kobj) {
return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static const void *rpc_sysfs_xprt_namespace(struct kobject *kobj) {
return container_of(kobj, struct rpc_sysfs_xprt, kobject)->xprt->xprt_net;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent,
struct rpc_xprt *xprt,
gfp_t gfp_flags) {
struct rpc_sysfs_xprt *p;
p = kzalloc(sizeof(*p), gfp_flags);
if (!p)
goto out;
p->kobj... | [
1,
0
] |
Linux Kernel | net/sunrpc/sysfs.c |
void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch) {
struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs;
if (rpc_xprt_switch) {
kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE);
kobject_del(&rpc_xprt_switch->kobject);
kobject_put(&rpc_xprt_switch->kobject... | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c | __be32 *xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj) {
unsigned int quadlen = XDR_QUADLEN(obj->len);
p[quadlen] = 0;
*p++ = cpu_to_be32(obj->len);
memcpy(p, obj->data, obj->len);
return p + XDR_QUADLEN(obj->len);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | __be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes) {
*p++ = cpu_to_be32(nbytes);
return xdr_encode_opaque_fixed(p, ptr, nbytes);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
int xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp) {
size_t i, n = xdr_buf_pagecount(buf);
if (n != 0 && buf->bvec == NULL) {
buf->bvec = kmalloc_array(n, sizeof(buf->bvec[0]), gfp);
if (!buf->bvec)
return -ENOMEM;
for (i = 0; i < n; i++) {
buf->bvec[i].bv_page = buf->pages[i];
buf->... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | void _copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len) {
struct page **pgfrom;
char *vfrom;
size_t copy;
if (!len)
return;
pgfrom = pages + (pgbase >> PAGE_SHIFT);
pgbase &= ~PAGE_MASK;
do {
copy = PAGE_SIZE - pgbase;
if (copy > len)
copy = len;
vfrom = km... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | static void xdr_buf_pages_zero(const struct xdr_buf *buf, unsigned int pgbase,
unsigned int len) {
struct page **pages = buf->pages;
struct page **page;
char *vpage;
unsigned int zero;
if (!len)
return;
if (pgbase >= buf->page_len) {
xdr_buf_iov_zero(buf->tail, pgbase... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static unsigned int xdr_buf_pages_fill_sparse(const struct xdr_buf *buf,
unsigned int buflen, gfp_t gfp) {
unsigned int i, npages, pagelen;
if (!(buf->flags & XDRBUF_SPARSE_PAGES))
return buflen;
if (buflen <= buf->head->iov_len)
return buflen;
pagelen = b... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | static void xdr_buf_try_expand(struct xdr_buf *buf, unsigned int len) {
struct kvec *head = buf->head;
struct kvec *tail = buf->tail;
unsigned int sum = head->iov_len + buf->page_len + tail->iov_len;
unsigned int free_space, newlen;
if (sum > buf->len) {
free_space = min_t(unsigned int, sum - buf->len, l... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | static void xdr_buf_pages_copy_left(const struct xdr_buf *buf,
unsigned int base, unsigned int len,
unsigned int shift) {
unsigned int pgto;
if (base >= buf->page_len)
return;
if (len > buf->page_len - base)
len = buf->page_len - bas... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static void xdr_buf_tail_shift_left(const struct xdr_buf *buf,
unsigned int base, unsigned int len,
unsigned int shift) {
if (!shift || !len)
return;
xdr_buf_tail_copy_left(buf, base, len, shift);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c | static unsigned int xdr_shrink_pagelen(struct xdr_buf *buf, unsigned int len) {
unsigned int shift, buflen = buf->len - buf->head->iov_len;
WARN_ON_ONCE(len > buf->page_len);
if (buf->head->iov_len >= buf->len || len > buflen)
buflen = len;
if (buf->page_len > buflen) {
buf->buflen -= buf->page_len - b... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p,
struct rpc_rqst *rqst) {
struct kvec *iov = buf->head;
int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
xdr_reset_scratch_buffer(xdr);
BUG_ON(scratch_len < 0);
xdr->buf = buf;
xdr->iov = i... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | int xdr_reserve_space_vec(struct xdr_stream *xdr, struct kvec *vec,
size_t nbytes) {
int thislen;
int v = 0;
__be32 *p;
if (xdr->iov == xdr->buf->head) {
xdr->iov = NULL;
xdr->end = xdr->p;
}
while (nbytes) {
thislen = xdr->buf->page_len % PAGE_SIZE;
thislen = min... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
unsigned int base, unsigned int len) {
struct xdr_buf *buf = xdr->buf;
struct kvec *tail = buf->tail;
buf->pages = pages;
buf->page_base = base;
buf->page_len = len;
tail->iov_base = xdr->p;
tail->iov_len = 0;
xdr->... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static unsigned int xdr_set_iov(struct xdr_stream *xdr, struct kvec *iov,
unsigned int base, unsigned int len) {
if (len > iov->iov_len)
len = iov->iov_len;
if (unlikely(base > len))
base = len;
xdr->p = (__be32 *)(iov->iov_base + base);
xdr->end = (__be32 *)(iov->iov_ba... | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static void xdr_set_page(struct xdr_stream *xdr, unsigned int base,
unsigned int len) {
if (xdr_set_page_base(xdr, base, len) == 0) {
base -= xdr->buf->page_len;
xdr_set_tail_base(xdr, base, len);
}
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static void xdr_set_next_page(struct xdr_stream *xdr) {
unsigned int newbase;
newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT;
newbase -= xdr->buf->page_base;
if (newbase < xdr->buf->page_len)
xdr_set_page_base(xdr, newbase, xdr_stream_remaining(xdr));
else
xdr_set_tail_base(xdr, 0, xd... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
void xdr_buf_from_iov(const struct kvec *iov, struct xdr_buf *buf) {
buf->head[0] = *iov;
buf->tail[0] = empty_iov;
buf->page_len = 0;
buf->buflen = buf->len = iov->iov_len;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c | int xdr_buf_subsegment(const struct xdr_buf *buf, struct xdr_buf *subbuf,
unsigned int base, unsigned int len) {
subbuf->buflen = subbuf->len = len;
if (base < buf->head[0].iov_len) {
subbuf->head[0].iov_base = buf->head[0].iov_base + base;
subbuf->head[0].iov_len =
min_t(unsi... | [
1,
0
] |
Linux Kernel | net/sunrpc/xdr.c | unsigned int xdr_stream_move_subsegment(struct xdr_stream *xdr,
unsigned int offset,
unsigned int target,
unsigned int length) {
struct xdr_buf buf;
unsigned int shift;
if (offset < target) {
... | [
0,
0
] |
Linux Kernel | net/sunrpc/xdr.c |
static void __read_bytes_from_xdr_buf(const struct xdr_buf *subbuf, void *obj,
unsigned int len) {
unsigned int this_len;
this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
memcpy(obj, subbuf->head[0].iov_base, this_len);
len -= this_len;
obj += this_len;
t... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static const struct xprt_class *xprt_class_find_by_ident(int ident) {
const struct xprt_class *t;
spin_lock(&xprt_list_lock);
t = xprt_class_find_by_ident_locked(ident);
spin_unlock(&xprt_list_lock);
return t;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | int xprt_find_transport_ident(const char *netid) {
const struct xprt_class *t;
int ret;
t = xprt_class_find_by_netid(netid);
if (!t)
return -ENOENT;
ret = t->ident;
xprt_class_release(t);
return ret;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_test_and_clear_congestion_window_wait(struct rpc_xprt *xprt) {
if (!RPCXPRT_CONGESTED(xprt))
clear_bit(XPRT_CWND_WAIT, &xprt->state);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) {
if (xprt->snd_task == task) {
xprt_clear_locked(xprt);
__xprt_lock_write_next_cong(xprt);
}
trace_xprt_release_cong(xprt, task);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task) {
if (xprt->snd_task != task)
return;
spin_lock(&xprt->transport_lock);
xprt->ops->release_xprt(xprt, task);
spin_unlock(&xprt->transport_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | static int __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req) {
if (req->rq_cong)
return 1;
trace_xprt_get_cong(xprt, req->rq_task);
if (RPCXPRT_CONGESTED(xprt)) {
xprt_set_congestion_window_wait(xprt);
return 0;
}
req->rq_cong = 1;
xprt->cong += RPC_CWNDSCALE;
return 1;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | static void xprt_clear_congestion_window_wait(struct rpc_xprt *xprt) {
if (test_and_clear_bit(XPRT_CWND_WAIT, &xprt->state)) {
spin_lock(&xprt->transport_lock);
__xprt_lock_write_next_cong(xprt);
spin_unlock(&xprt->transport_lock);
}
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status) {
if (status < 0)
rpc_wake_up_status(&xprt->pending, status);
else
rpc_wake_up(&xprt->pending);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | bool xprt_write_space(struct rpc_xprt *xprt) {
bool ret;
if (!test_bit(XPRT_WRITE_SPACE, &xprt->state))
return false;
spin_lock(&xprt->transport_lock);
ret = xprt_clear_write_space_locked(xprt);
spin_unlock(&xprt->transport_lock);
return ret;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static unsigned long xprt_calc_majortimeo(struct rpc_rqst *req) {
const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
unsigned long majortimeo = req->rq_timeout;
if (to->to_exponential)
majortimeo <<= to->to_retries;
else
majortimeo += to->to_increment * to->to_retries;
if (majortime... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_reset_minortimeo(struct rpc_rqst *req) {
req->rq_minortimeo += req->rq_timeout;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_force_disconnect(struct rpc_xprt *xprt) {
trace_xprt_disconnect_force(xprt);
spin_lock(&xprt->transport_lock);
xprt_schedule_autoclose_locked(xprt);
spin_unlock(&xprt->transport_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static bool xprt_request_retransmit_after_disconnect(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
return req->rq_connect_cookie != xprt_connect_cookie(xprt) ||
!xprt_connected(xprt);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie) {
spin_lock(&xprt->transport_lock);
if (cookie != xprt->connect_cookie)
goto out;
if (test_bit(XPRT_CLOSING, &xprt->state))
goto out;
xprt_schedule_autoclose_locked(xprt);
out:
spin_unlock(&xprt->transport_lock);
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | static void xprt_init_autodisconnect(struct timer_list *t) {
struct rpc_xprt *xprt = from_timer(xprt, t, timer);
if (!RB_EMPTY_ROOT(&xprt->recv_queue))
return;
xprt->last_used = jiffies;
if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
return;
queue_work(xprtiod_workqueue, &xprt->task_cleanup);
}
#... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie) {
spin_lock(&xprt->transport_lock);
if (xprt->snd_task != cookie)
goto out;
if (!test_bit(XPRT_LOCKED, &xprt->state))
goto out;
xprt->snd_task = NULL;
clear_bit(XPRT_SND_IS_COOKIE, &xprt->state);
xprt->ops->release_xprt(xprt, NULL);
xp... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_connect(struct rpc_task *task) {
struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
trace_xprt_connect(xprt);
if (!xprt_bound(xprt)) {
task->tk_status = -EAGAIN;
return;
}
if (!xprt_lock_write(xprt, task))
return;
if (!xprt_connected(xprt) && !test_bit(XPRT_CLOSE_WAIT, &xprt->state)) ... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | unsigned long xprt_reconnect_delay(const struct rpc_xprt *xprt) {
unsigned long start, now = jiffies;
start = xprt->stat.connect_start + xprt->reestablish_timeout;
if (time_after(start, now))
return start - now;
return 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | static enum xprt_xid_rb_cmp xprt_xid_cmp(__be32 xid1, __be32 xid2) {
if (xid1 == xid2)
return XID_RB_EQUAL;
if ((__force u32)xid1 < (__force u32)xid2)
return XID_RB_LEFT;
return XID_RB_RIGHT;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static struct rpc_rqst *xprt_request_rb_find(struct rpc_xprt *xprt,
__be32 xid) {
struct rb_node *n = xprt->recv_queue.rb_node;
struct rpc_rqst *req;
while (n != NULL) {
req = rb_entry(n, struct rpc_rqst, rq_recv);
switch (xprt_xid_cmp(xid, req->rq_xid)) {
... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid) {
struct rpc_rqst *entry;
entry = xprt_request_rb_find(xprt, xid);
if (entry != NULL) {
trace_xprt_lookup_rqst(xprt, xid, 0);
entry->rq_rtt = ktime_sub(ktime_get(), entry->rq_xtime);
return entry;
}
dprintk("RPC: xprt_loo... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_pin_rqst(struct rpc_rqst *req) { atomic_inc(&req->rq_pin); } | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_wait_on_pinned_rqst(struct rpc_rqst *req) {
wait_var_event(&req->rq_pin, !xprt_is_pinned_rqst(req));
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static bool xprt_request_need_enqueue_receive(struct rpc_task *task,
struct rpc_rqst *req) {
return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0;
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_update_rtt(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_rtt *rtt = task->tk_client->cl_rtt;
unsigned int timer = task->tk_msg.rpc_proc->p_timer;
long m = usecs_to_jiffies(ktime_to_us(req->rq_rtt));
if (timer) {
if (req->rq_ntrans == 1)
rpc_update_rtt(rtt, tim... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_timer(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
if (task->tk_status != -ETIMEDOUT)
return;
trace_xprt_timer(xprt, req->rq_xid, task->tk_status);
if (!req->rq_reply_bytes_recvd) {
if (xprt->ops->timer)
xprt->ops->time... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_wait_for_reply_request_def(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
xprt_request_timeout(req));
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_wait_for_reply_request_rtt(struct rpc_task *task) {
int timer = task->tk_msg.rpc_proc->p_timer;
struct rpc_clnt *clnt = task->tk_client;
struct rpc_rtt *rtt = clnt->cl_rtt;
struct rpc_rqst *req = task->tk_rqstp;
unsigned long max_timeout = clnt->cl_timeout->to_maxval;
unsigned long timeout;
tim... | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_request_wait_receive(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
return;
spin_lock(&xprt->queue_lock);
if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) {
xprt->ops->wait_fo... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_request_dequeue_xprt(struct rpc_task *task) {
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) ||
test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) ||
xprt_is_pinned_rqst(req)) {
spin_lock(&xprt->queue_lock)... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
void xprt_end_transmit(struct rpc_task *task) {
struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
xprt_inject_disconnect(xprt);
xprt_release_write(xprt, task);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req) {
spin_lock(&xprt->reserve_lock);
if (!xprt_wake_up_backlog(xprt, req) && !xprt_dynamic_free_slot(xprt, req)) {
memset(req, 0, sizeof(*req));
list_add(&req->rq_list, &xprt->free);
}
spin_unlock(&xprt->reserve_lock);
} | [
1,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static __be32 xprt_alloc_xid(struct rpc_xprt *xprt) {
__be32 xid;
spin_lock(&xprt->reserve_lock);
xid = (__force __be32)xprt->xid++;
spin_unlock(&xprt->reserve_lock);
return xid;
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_init_xid(struct rpc_xprt *xprt) {
xprt->xid = get_random_u32();
} | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c |
static void xprt_request_init(struct rpc_task *task) {
struct rpc_xprt *xprt = task->tk_xprt;
struct rpc_rqst *req = task->tk_rqstp;
req->rq_task = task;
req->rq_xprt = xprt;
req->rq_buffer = NULL;
req->rq_xid = xprt_alloc_xid(xprt);
xprt_init_connect_cookie(req, xprt);
req->rq_snd_buf.len = 0;
req-... | [
0,
0
] |
Linux Kernel | net/sunrpc/xprt.c | void xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task) {
struct xdr_buf *xbufp = &req->rq_snd_buf;
task->tk_rqstp = req;
req->rq_task = task;
xprt_init_connect_cookie(req, req->rq_xprt);
xbufp->len =
xbufp->head[0].iov_len + xbufp->page_len + xbufp->tail[0].iov_len;
}
#endif | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.