Merge tag 'rproc-v5.20' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc...

[linux-2.6-microblaze.git] / fs / nfs / callback.c

diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 86d856d..456af7d 100644 (file)
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -17,7 +17,6 @@
 #include <linux/errno.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
-#include <linux/kthread.h>
 #include <linux/sunrpc/svcauth_gss.h>
 #include <linux/sunrpc/bc_xprt.h>
 
@@ -45,18 +44,18 @@ static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net)
        int ret;
        struct nfs_net *nn = net_generic(net, nfs_net_id);
 
-       ret = svc_create_xprt(serv, "tcp", net, PF_INET,
-                               nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS,
-                               cred);
+       ret = svc_xprt_create(serv, "tcp", net, PF_INET,
+                             nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS,
+                             cred);
        if (ret <= 0)
                goto out_err;
        nn->nfs_callback_tcpport = ret;
        dprintk("NFS: Callback listener port = %u (af %u, net %x)\n",
                nn->nfs_callback_tcpport, PF_INET, net->ns.inum);
 
-       ret = svc_create_xprt(serv, "tcp", net, PF_INET6,
-                               nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS,
-                               cred);
+       ret = svc_xprt_create(serv, "tcp", net, PF_INET6,
+                             nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS,
+                             cred);
        if (ret > 0) {
                nn->nfs_callback_tcpport6 = ret;
                dprintk("NFS: Callback listener port = %u (af %u, net %x)\n",
@@ -92,8 +91,8 @@ nfs4_callback_svc(void *vrqstp)
                        continue;
                svc_process(rqstp);
        }
+
        svc_exit_thread(rqstp);
-       module_put_and_exit(0);
        return 0;
 }
 
@@ -136,8 +135,8 @@ nfs41_callback_svc(void *vrqstp)
                        finish_wait(&serv->sv_cb_waitq, &wq);
                }
        }
+
        svc_exit_thread(rqstp);
-       module_put_and_exit(0);
        return 0;
 }
 
@@ -169,12 +168,12 @@ static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,
        if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS)
                nrservs = NFS4_MIN_NR_CALLBACK_THREADS;
 
-       if (serv->sv_nrthreads-1 == nrservs)
+       if (serv->sv_nrthreads == nrservs)
                return 0;
 
-       ret = serv->sv_ops->svo_setup(serv, NULL, nrservs);
+       ret = svc_set_num_threads(serv, NULL, nrservs);
        if (ret) {
-               serv->sv_ops->svo_setup(serv, NULL, 0);
+               svc_set_num_threads(serv, NULL, 0);
                return ret;
        }
        dprintk("nfs_callback_up: service started\n");
@@ -189,7 +188,7 @@ static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struc
                return;
 
        dprintk("NFS: destroy per-net callback data; net=%x\n", net->ns.inum);
-       svc_shutdown_net(serv, net);
+       svc_xprt_destroy_all(serv, net);
 }
 
 static int nfs_callback_up_net(int minorversion, struct svc_serv *serv,
@@ -232,59 +231,17 @@ err_bind:
        return ret;
 }
 
-static const struct svc_serv_ops nfs40_cb_sv_ops = {
-       .svo_function           = nfs4_callback_svc,
-       .svo_enqueue_xprt       = svc_xprt_do_enqueue,
-       .svo_setup              = svc_set_num_threads_sync,
-       .svo_module             = THIS_MODULE,
-};
-#if defined(CONFIG_NFS_V4_1)
-static const struct svc_serv_ops nfs41_cb_sv_ops = {
-       .svo_function           = nfs41_callback_svc,
-       .svo_enqueue_xprt       = svc_xprt_do_enqueue,
-       .svo_setup              = svc_set_num_threads_sync,
-       .svo_module             = THIS_MODULE,
-};
-
-static const struct svc_serv_ops *nfs4_cb_sv_ops[] = {
-       [0] = &nfs40_cb_sv_ops,
-       [1] = &nfs41_cb_sv_ops,
-};
-#else
-static const struct svc_serv_ops *nfs4_cb_sv_ops[] = {
-       [0] = &nfs40_cb_sv_ops,
-       [1] = NULL,
-};
-#endif
-
 static struct svc_serv *nfs_callback_create_svc(int minorversion)
 {
        struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
-       const struct svc_serv_ops *sv_ops;
+       int (*threadfn)(void *data);
        struct svc_serv *serv;
 
        /*
         * Check whether we're already up and running.
         */
-       if (cb_info->serv) {
-               /*
-                * Note: increase service usage, because later in case of error
-                * svc_destroy() will be called.
-                */
-               svc_get(cb_info->serv);
-               return cb_info->serv;
-       }
-
-       switch (minorversion) {
-       case 0:
-               sv_ops = nfs4_cb_sv_ops[0];
-               break;
-       default:
-               sv_ops = nfs4_cb_sv_ops[1];
-       }
-
-       if (sv_ops == NULL)
-               return ERR_PTR(-ENOTSUPP);
+       if (cb_info->serv)
+               return svc_get(cb_info->serv);
 
        /*
         * Sanity check: if there's no task,
@@ -294,7 +251,16 @@ static struct svc_serv *nfs_callback_create_svc(int minorversion)
                printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
                        cb_info->users);
 
-       serv = svc_create_pooled(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, sv_ops);
+       threadfn = nfs4_callback_svc;
+#if defined(CONFIG_NFS_V4_1)
+       if (minorversion)
+               threadfn = nfs41_callback_svc;
+#else
+       if (minorversion)
+               return ERR_PTR(-ENOTSUPP);
+#endif
+       serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE,
+                         threadfn);
        if (!serv) {
                printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
                return ERR_PTR(-ENOMEM);
@@ -335,16 +301,10 @@ int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
                goto err_start;
 
        cb_info->users++;
-       /*
-        * svc_create creates the svc_serv with sv_nrthreads == 1, and then
-        * svc_prepare_thread increments that. So we need to call svc_destroy
-        * on both success and failure so that the refcount is 1 when the
-        * thread exits.
-        */
 err_net:
        if (!cb_info->users)
                cb_info->serv = NULL;
-       svc_destroy(serv);
+       svc_put(serv);
 err_create:
        mutex_unlock(&nfs_callback_mutex);
        return ret;
@@ -369,8 +329,8 @@ void nfs_callback_down(int minorversion, struct net *net)
        cb_info->users--;
        if (cb_info->users == 0) {
                svc_get(serv);
-               serv->sv_ops->svo_setup(serv, NULL, 0);
-               svc_destroy(serv);
+               svc_set_num_threads(serv, NULL, 0);
+               svc_put(serv);
                dprintk("nfs_callback_down: service destroyed\n");
                cb_info->serv = NULL;
        }