extern const struct rpc_authops        authunix_ops;
 extern const struct rpc_authops        authnull_ops;
 
-void __init            rpc_init_authunix(void);
-void __init            rpc_init_generic_auth(void);
-void __init            rpcauth_init_module(void);
+int __init             rpc_init_authunix(void);
+int __init             rpc_init_generic_auth(void);
+int __init             rpcauth_init_module(void);
 void __exit            rpcauth_remove_module(void);
 void __exit            rpc_destroy_generic_auth(void);
+void                   rpc_destroy_authunix(void);
 
 struct rpc_cred *      rpc_lookup_cred(void);
 struct rpc_cred *      rpc_lookup_machine_cred(void);
 
        .seeks = DEFAULT_SEEKS,
 };
 
-void __init rpcauth_init_module(void)
+int __init rpcauth_init_module(void)
 {
-       rpc_init_authunix();
-       rpc_init_generic_auth();
+       int err;
+
+       err = rpc_init_authunix();
+       if (err < 0)
+               goto out1;
+       err = rpc_init_generic_auth();
+       if (err < 0)
+               goto out2;
        register_shrinker(&rpc_cred_shrinker);
+       return 0;
+out2:
+       rpc_destroy_authunix();
+out1:
+       return err;
 }
 
 void __exit rpcauth_remove_module(void)
 {
+       rpc_destroy_authunix();
+       rpc_destroy_generic_auth();
        unregister_shrinker(&rpc_cred_shrinker);
 }
 
 };
 
 static struct rpc_auth generic_auth;
-static struct rpc_cred_cache generic_cred_cache;
 static const struct rpc_credops generic_credops;
 
 /*
        return 0;
 }
 
-void __init rpc_init_generic_auth(void)
+int __init rpc_init_generic_auth(void)
 {
-       spin_lock_init(&generic_cred_cache.lock);
+       return rpcauth_init_credcache(&generic_auth);
 }
 
 void __exit rpc_destroy_generic_auth(void)
 {
-       rpcauth_clear_credcache(&generic_cred_cache);
+       rpcauth_destroy_credcache(&generic_auth);
 }
 
-static struct rpc_cred_cache generic_cred_cache = {
-       {{ NULL, },},
-};
-
 static const struct rpc_authops generic_auth_ops = {
        .owner = THIS_MODULE,
        .au_name = "Generic",
 static struct rpc_auth generic_auth = {
        .au_ops = &generic_auth_ops,
        .au_count = ATOMIC_INIT(0),
-       .au_credcache = &generic_cred_cache,
 };
 
 static const struct rpc_credops generic_credops = {
 
 #endif
 
 static struct rpc_auth         unix_auth;
-static struct rpc_cred_cache   unix_cred_cache;
 static const struct rpc_credops        unix_credops;
 
 static struct rpc_auth *
        return p;
 }
 
-void __init rpc_init_authunix(void)
+int __init rpc_init_authunix(void)
 {
-       spin_lock_init(&unix_cred_cache.lock);
+       return rpcauth_init_credcache(&unix_auth);
+}
+
+void rpc_destroy_authunix(void)
+{
+       rpcauth_destroy_credcache(&unix_auth);
 }
 
 const struct rpc_authops authunix_ops = {
        .crcreate       = unx_create_cred,
 };
 
-static
-struct rpc_cred_cache  unix_cred_cache = {
-};
-
 static
 struct rpc_auth                unix_auth = {
        .au_cslack      = UNX_WRITESLACK,
        .au_ops         = &authunix_ops,
        .au_flavor      = RPC_AUTH_UNIX,
        .au_count       = ATOMIC_INIT(0),
-       .au_credcache   = &unix_cred_cache,
 };
 
 static
 
        if (err)
                goto out;
        err = rpc_init_mempool();
-       if (err) {
-               unregister_rpc_pipefs();
-               goto out;
-       }
+       if (err)
+               goto out2;
+       err = rpcauth_init_module();
+       if (err)
+               goto out3;
 #ifdef RPC_DEBUG
        rpc_register_sysctl();
 #endif
        cache_register(&unix_gid_cache);
        svc_init_xprt_sock();   /* svc sock transport */
        init_socket_xprt();     /* clnt sock transport */
-       rpcauth_init_module();
+       return 0;
+out3:
+       rpc_destroy_mempool();
+out2:
+       unregister_rpc_pipefs();
 out:
        return err;
 }