static struct svc_serv_ops nfsd_sv_ops = {
        .svo_shutdown = nfsd_last_thread,
        .svo_function = nfsd,
+       .svo_module = THIS_MODULE,
 };
 
 int nfsd_create_serv(struct net *net)
                nfsd_max_blksize = nfsd_get_default_max_blksize();
        nfsd_reset_versions();
        nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
-                                     &nfsd_sv_ops, THIS_MODULE);
+                                               &nfsd_sv_ops);
        if (nn->nfsd_serv == NULL)
                return -ENOMEM;
 
 
 struct svc_serv_ops {
        /* Callback to use when last thread exits. */
        void            (*svo_shutdown)(struct svc_serv *, struct net *);
+
+       /* function for service threads to run */
        int             (*svo_function)(void *);
+
+       /* optional module to count when adding threads (pooled svcs only) */
+       struct module   *svo_module;
 };
 
 /*
        unsigned int            sv_nrpools;     /* number of thread pools */
        struct svc_pool *       sv_pools;       /* array of thread pools */
        struct svc_serv_ops     *sv_ops;        /* server operations */
-       struct module *         sv_module;      /* optional module to count when
-                                                * adding threads */
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
        struct list_head        sv_cb_list;     /* queue for callback requests
                                                 * that arrive over the same
                                        struct svc_pool *pool, int node);
 void              svc_exit_thread(struct svc_rqst *);
 struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
-                       struct svc_serv_ops *, struct module *);
+                       struct svc_serv_ops *);
 int               svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
 int               svc_pool_stats_open(struct svc_serv *serv, struct file *file);
 void              svc_destroy(struct svc_serv *);
 
 
 struct svc_serv *
 svc_create_pooled(struct svc_program *prog, unsigned int bufsize,
-                 struct svc_serv_ops *ops, struct module *mod)
+                 struct svc_serv_ops *ops)
 {
        struct svc_serv *serv;
        unsigned int npools = svc_pool_map_get();
        serv = __svc_create(prog, bufsize, npools, ops);
        if (!serv)
                goto out_err;
-
-       serv->sv_module = mod;
        return serv;
 out_err:
        svc_pool_map_put();
                        break;
                }
 
-               __module_get(serv->sv_module);
+               __module_get(serv->sv_ops->svo_module);
                task = kthread_create_on_node(serv->sv_ops->svo_function, rqstp,
                                              node, "%s", serv->sv_name);
                if (IS_ERR(task)) {
                        error = PTR_ERR(task);
-                       module_put(serv->sv_module);
+                       module_put(serv->sv_ops->svo_module);
                        svc_exit_thread(rqstp);
                        break;
                }