mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-31 04:01:48 -04:00
Merge branch 'for-2.6.30' of git://linux-nfs.org/~bfields/linux
* 'for-2.6.30' of git://linux-nfs.org/~bfields/linux: (81 commits)
nfsd41: define nfsd4_set_statp as noop for !CONFIG_NFSD_V4
nfsd41: define NFSD_DRC_SIZE_SHIFT in set_max_drc
nfsd41: Documentation/filesystems/nfs41-server.txt
nfsd41: CREATE_EXCLUSIVE4_1
nfsd41: SUPPATTR_EXCLCREAT attribute
nfsd41: support for 3-word long attribute bitmask
nfsd: dynamically skip encoded fattr bitmap in _nfsd4_verify
nfsd41: pass writable attrs mask to nfsd4_decode_fattr
nfsd41: provide support for minor version 1 at rpc level
nfsd41: control nfsv4.1 svc via /proc/fs/nfsd/versions
nfsd41: add OPEN4_SHARE_ACCESS_WANT nfs4_stateid bmap
nfsd41: access_valid
nfsd41: clientid handling
nfsd41: check encode size for sessions maxresponse cached
nfsd41: stateid handling
nfsd: pass nfsd4_compound_state* to nfs4_preprocess_{state,seq}id_op
nfsd41: destroy_session operation
nfsd41: non-page DRC for solo sequence responses
nfsd41: Add a create session replay cache
nfsd41: create_session operation
...
This commit is contained in:
Linus Torvalds
commit
a63856252d
29 changed files with 2997 additions and 555 deletions
|
|
@ -1008,6 +1008,8 @@ svc_process(struct svc_rqst *rqstp)
|
|||
rqstp->rq_res.tail[0].iov_len = 0;
|
||||
/* Will be turned off only in gss privacy case: */
|
||||
rqstp->rq_splice_ok = 1;
|
||||
/* Will be turned off only when NFSv4 Sessions are used */
|
||||
rqstp->rq_usedeferral = 1;
|
||||
|
||||
/* Setup reply header */
|
||||
rqstp->rq_xprt->xpt_ops->xpo_prep_reply_hdr(rqstp);
|
||||
|
|
@ -1078,7 +1080,6 @@ svc_process(struct svc_rqst *rqstp)
|
|||
procp = versp->vs_proc + proc;
|
||||
if (proc >= versp->vs_nproc || !procp->pc_func)
|
||||
goto err_bad_proc;
|
||||
rqstp->rq_server = serv;
|
||||
rqstp->rq_procinfo = procp;
|
||||
|
||||
/* Syntactic check complete */
|
||||
|
|
|
|||
|
|
@ -14,6 +14,8 @@
|
|||
|
||||
#define RPCDBG_FACILITY RPCDBG_SVCXPRT
|
||||
|
||||
#define SVC_MAX_WAKING 5
|
||||
|
||||
static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt);
|
||||
static int svc_deferred_recv(struct svc_rqst *rqstp);
|
||||
static struct cache_deferred_req *svc_defer(struct cache_req *req);
|
||||
|
|
@ -301,6 +303,7 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
|
|||
struct svc_pool *pool;
|
||||
struct svc_rqst *rqstp;
|
||||
int cpu;
|
||||
int thread_avail;
|
||||
|
||||
if (!(xprt->xpt_flags &
|
||||
((1<<XPT_CONN)|(1<<XPT_DATA)|(1<<XPT_CLOSE)|(1<<XPT_DEFERRED))))
|
||||
|
|
@ -312,18 +315,14 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
|
|||
|
||||
spin_lock_bh(&pool->sp_lock);
|
||||
|
||||
if (!list_empty(&pool->sp_threads) &&
|
||||
!list_empty(&pool->sp_sockets))
|
||||
printk(KERN_ERR
|
||||
"svc_xprt_enqueue: "
|
||||
"threads and transports both waiting??\n");
|
||||
|
||||
if (test_bit(XPT_DEAD, &xprt->xpt_flags)) {
|
||||
/* Don't enqueue dead transports */
|
||||
dprintk("svc: transport %p is dead, not enqueued\n", xprt);
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
pool->sp_stats.packets++;
|
||||
|
||||
/* Mark transport as busy. It will remain in this state until
|
||||
* the provider calls svc_xprt_received. We update XPT_BUSY
|
||||
* atomically because it also guards against trying to enqueue
|
||||
|
|
@ -356,7 +355,15 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
|
|||
}
|
||||
|
||||
process:
|
||||
if (!list_empty(&pool->sp_threads)) {
|
||||
/* Work out whether threads are available */
|
||||
thread_avail = !list_empty(&pool->sp_threads); /* threads are asleep */
|
||||
if (pool->sp_nwaking >= SVC_MAX_WAKING) {
|
||||
/* too many threads are runnable and trying to wake up */
|
||||
thread_avail = 0;
|
||||
pool->sp_stats.overloads_avoided++;
|
||||
}
|
||||
|
||||
if (thread_avail) {
|
||||
rqstp = list_entry(pool->sp_threads.next,
|
||||
struct svc_rqst,
|
||||
rq_list);
|
||||
|
|
@ -371,11 +378,15 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
|
|||
svc_xprt_get(xprt);
|
||||
rqstp->rq_reserved = serv->sv_max_mesg;
|
||||
atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
|
||||
rqstp->rq_waking = 1;
|
||||
pool->sp_nwaking++;
|
||||
pool->sp_stats.threads_woken++;
|
||||
BUG_ON(xprt->xpt_pool != pool);
|
||||
wake_up(&rqstp->rq_wait);
|
||||
} else {
|
||||
dprintk("svc: transport %p put into queue\n", xprt);
|
||||
list_add_tail(&xprt->xpt_ready, &pool->sp_sockets);
|
||||
pool->sp_stats.sockets_queued++;
|
||||
BUG_ON(xprt->xpt_pool != pool);
|
||||
}
|
||||
|
||||
|
|
@ -588,6 +599,7 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
|
|||
int pages;
|
||||
struct xdr_buf *arg;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
long time_left;
|
||||
|
||||
dprintk("svc: server %p waiting for data (to = %ld)\n",
|
||||
rqstp, timeout);
|
||||
|
|
@ -636,6 +648,11 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
|
|||
return -EINTR;
|
||||
|
||||
spin_lock_bh(&pool->sp_lock);
|
||||
if (rqstp->rq_waking) {
|
||||
rqstp->rq_waking = 0;
|
||||
pool->sp_nwaking--;
|
||||
BUG_ON(pool->sp_nwaking < 0);
|
||||
}
|
||||
xprt = svc_xprt_dequeue(pool);
|
||||
if (xprt) {
|
||||
rqstp->rq_xprt = xprt;
|
||||
|
|
@ -668,12 +685,14 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
|
|||
add_wait_queue(&rqstp->rq_wait, &wait);
|
||||
spin_unlock_bh(&pool->sp_lock);
|
||||
|
||||
schedule_timeout(timeout);
|
||||
time_left = schedule_timeout(timeout);
|
||||
|
||||
try_to_freeze();
|
||||
|
||||
spin_lock_bh(&pool->sp_lock);
|
||||
remove_wait_queue(&rqstp->rq_wait, &wait);
|
||||
if (!time_left)
|
||||
pool->sp_stats.threads_timedout++;
|
||||
|
||||
xprt = rqstp->rq_xprt;
|
||||
if (!xprt) {
|
||||
|
|
@ -958,7 +977,7 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req)
|
|||
struct svc_rqst *rqstp = container_of(req, struct svc_rqst, rq_chandle);
|
||||
struct svc_deferred_req *dr;
|
||||
|
||||
if (rqstp->rq_arg.page_len)
|
||||
if (rqstp->rq_arg.page_len || !rqstp->rq_usedeferral)
|
||||
return NULL; /* if more than a page, give up FIXME */
|
||||
if (rqstp->rq_deferred) {
|
||||
dr = rqstp->rq_deferred;
|
||||
|
|
@ -1112,3 +1131,93 @@ int svc_xprt_names(struct svc_serv *serv, char *buf, int buflen)
|
|||
return totlen;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(svc_xprt_names);
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
static void *svc_pool_stats_start(struct seq_file *m, loff_t *pos)
|
||||
{
|
||||
unsigned int pidx = (unsigned int)*pos;
|
||||
struct svc_serv *serv = m->private;
|
||||
|
||||
dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
|
||||
|
||||
lock_kernel();
|
||||
/* bump up the pseudo refcount while traversing */
|
||||
svc_get(serv);
|
||||
unlock_kernel();
|
||||
|
||||
if (!pidx)
|
||||
return SEQ_START_TOKEN;
|
||||
return (pidx > serv->sv_nrpools ? NULL : &serv->sv_pools[pidx-1]);
|
||||
}
|
||||
|
||||
static void *svc_pool_stats_next(struct seq_file *m, void *p, loff_t *pos)
|
||||
{
|
||||
struct svc_pool *pool = p;
|
||||
struct svc_serv *serv = m->private;
|
||||
|
||||
dprintk("svc_pool_stats_next, *pos=%llu\n", *pos);
|
||||
|
||||
if (p == SEQ_START_TOKEN) {
|
||||
pool = &serv->sv_pools[0];
|
||||
} else {
|
||||
unsigned int pidx = (pool - &serv->sv_pools[0]);
|
||||
if (pidx < serv->sv_nrpools-1)
|
||||
pool = &serv->sv_pools[pidx+1];
|
||||
else
|
||||
pool = NULL;
|
||||
}
|
||||
++*pos;
|
||||
return pool;
|
||||
}
|
||||
|
||||
static void svc_pool_stats_stop(struct seq_file *m, void *p)
|
||||
{
|
||||
struct svc_serv *serv = m->private;
|
||||
|
||||
lock_kernel();
|
||||
/* this function really, really should have been called svc_put() */
|
||||
svc_destroy(serv);
|
||||
unlock_kernel();
|
||||
}
|
||||
|
||||
static int svc_pool_stats_show(struct seq_file *m, void *p)
|
||||
{
|
||||
struct svc_pool *pool = p;
|
||||
|
||||
if (p == SEQ_START_TOKEN) {
|
||||
seq_puts(m, "# pool packets-arrived sockets-enqueued threads-woken overloads-avoided threads-timedout\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
seq_printf(m, "%u %lu %lu %lu %lu %lu\n",
|
||||
pool->sp_id,
|
||||
pool->sp_stats.packets,
|
||||
pool->sp_stats.sockets_queued,
|
||||
pool->sp_stats.threads_woken,
|
||||
pool->sp_stats.overloads_avoided,
|
||||
pool->sp_stats.threads_timedout);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct seq_operations svc_pool_stats_seq_ops = {
|
||||
.start = svc_pool_stats_start,
|
||||
.next = svc_pool_stats_next,
|
||||
.stop = svc_pool_stats_stop,
|
||||
.show = svc_pool_stats_show,
|
||||
};
|
||||
|
||||
int svc_pool_stats_open(struct svc_serv *serv, struct file *file)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = seq_open(file, &svc_pool_stats_seq_ops);
|
||||
if (!err)
|
||||
((struct seq_file *) file->private_data)->private = serv;
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL(svc_pool_stats_open);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -345,7 +345,6 @@ static void svc_sock_setbufsize(struct socket *sock, unsigned int snd,
|
|||
lock_sock(sock->sk);
|
||||
sock->sk->sk_sndbuf = snd * 2;
|
||||
sock->sk->sk_rcvbuf = rcv * 2;
|
||||
sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
|
||||
release_sock(sock->sk);
|
||||
#endif
|
||||
}
|
||||
|
|
@ -797,23 +796,6 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
|
|||
test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags),
|
||||
test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
|
||||
|
||||
if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
|
||||
/* sndbuf needs to have room for one request
|
||||
* per thread, otherwise we can stall even when the
|
||||
* network isn't a bottleneck.
|
||||
*
|
||||
* We count all threads rather than threads in a
|
||||
* particular pool, which provides an upper bound
|
||||
* on the number of threads which will access the socket.
|
||||
*
|
||||
* rcvbuf just needs to be able to hold a few requests.
|
||||
* Normally they will be removed from the queue
|
||||
* as soon a a complete request arrives.
|
||||
*/
|
||||
svc_sock_setbufsize(svsk->sk_sock,
|
||||
(serv->sv_nrthreads+3) * serv->sv_max_mesg,
|
||||
3 * serv->sv_max_mesg);
|
||||
|
||||
clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
|
||||
|
||||
/* Receive data. If we haven't got the record length yet, get
|
||||
|
|
@ -1061,15 +1043,6 @@ static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
|
|||
|
||||
tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
|
||||
|
||||
/* initialise setting must have enough space to
|
||||
* receive and respond to one request.
|
||||
* svc_tcp_recvfrom will re-adjust if necessary
|
||||
*/
|
||||
svc_sock_setbufsize(svsk->sk_sock,
|
||||
3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
|
||||
3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
|
||||
|
||||
set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
|
||||
set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
|
||||
if (sk->sk_state != TCP_ESTABLISHED)
|
||||
set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
|
||||
|
|
@ -1139,8 +1112,14 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
|
|||
/* Initialize the socket */
|
||||
if (sock->type == SOCK_DGRAM)
|
||||
svc_udp_init(svsk, serv);
|
||||
else
|
||||
else {
|
||||
/* initialise setting must have enough space to
|
||||
* receive and respond to one request.
|
||||
*/
|
||||
svc_sock_setbufsize(svsk->sk_sock, 4 * serv->sv_max_mesg,
|
||||
4 * serv->sv_max_mesg);
|
||||
svc_tcp_init(svsk, serv);
|
||||
}
|
||||
|
||||
dprintk("svc: svc_setup_socket created %p (inet %p)\n",
|
||||
svsk, svsk->sk_sk);
|
||||
|
|
|
|||
Loading…
Reference in a new issue