SUNRPC new rpc_credops to test credential expiry

This patch provides the RPC layer helper functions to allow NFS to manage
data in the face of expired credentials - such as avoiding buffered WRITEs
and COMMITs when the gss context will expire before the WRITEs are flushed
and COMMITs are sent.

These helper functions enable checking the expiration of an underlying
credential key for a generic rpc credential, e.g. the gss_cred gss context
gc_expiry which for Kerberos is set to the remaining TGT lifetime.

A new rpc_authops key_timeout is only defined for the generic auth.
A new rpc_credops crkey_to_expire is only defined for the generic cred.
A new rpc_credops crkey_timeout is only defined for the gss cred.

Set a credential key expiry watermark, RPC_KEY_EXPIRE_TIMEO set to 240 seconds
as a default and can be set via a module parameter as we need to ensure there
is time for any dirty data to be flushed.

If key_timeout is called on a credential with an underlying credential key that
will expire within watermark seconds, we set the RPC_CRED_KEY_EXPIRE_SOON
flag in the generic_cred acred so that the NFS layer can clean up prior to
key expiration.

Checking a generic credential's underlying credential involves a cred lookup.
To avoid this lookup in the normal case when the underlying credential has
a key that is valid (before the watermark), a notify flag is set in
the generic credential the first time the key_timeout is called. The
generic credential then stops checking the underlying credential key expiry, and
the underlying credential (gss_cred) match routine then checks the key
expiration upon each normal use and sets a flag in the associated generic
credential only when the key expiration is within the watermark.
This in turn signals the generic credential key_timeout to perform the extra
credential lookup thereafter.

Signed-off-by: Andy Adamson <andros@netapp.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

1 files changed, 16 insertions, 0 deletions

diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 6de26f2491e5..790be1472792 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -24,12 +24,21 @@
 
 struct rpcsec_gss_info;
 
+/* auth_cred ac_flags bits */
+enum {
+        RPC_CRED_NO_CRKEY_TIMEOUT = 0, /* underlying cred has no key timeout */
+        RPC_CRED_KEY_EXPIRE_SOON = 1, /* underlying cred key will expire soon */
+        RPC_CRED_NOTIFY_TIMEOUT = 2,   /* nofity generic cred when underlying
+                                        key will expire soon */
+};
+
 /* Work around the lack of a VFS credential */
 struct auth_cred {
         kuid_t  uid;
         kgid_t  gid;
         struct group_info *group_info;
         const char *principal;
+        unsigned long ac_flags;
         unsigned char machine_cred : 1;
 };
 
@@ -111,6 +120,8 @@ struct rpc_authops {
         rpc_authflavor_t        (*info2flavor)(struct rpcsec_gss_info *);
         int                     (*flavor2info)(rpc_authflavor_t,
                                                 struct rpcsec_gss_info *);
+        int                     (*key_timeout)(struct rpc_auth *,
+                                                struct rpc_cred *);
 };
 
 struct rpc_credops {
@@ -127,6 +138,8 @@ struct rpc_credops {
                                                 void *, __be32 *, void *);
         int                     (*crunwrap_resp)(struct rpc_task *, kxdrdproc_t,
                                                 void *, __be32 *, void *);
+        int                     (*crkey_timeout)(struct rpc_cred *);
+        bool                    (*crkey_to_expire)(struct rpc_cred *);
 };
 
 extern const struct rpc_authops authunix_ops;
@@ -166,6 +179,9 @@ int			rpcauth_uptodatecred(struct rpc_task *);
 int                     rpcauth_init_credcache(struct rpc_auth *);
 void                    rpcauth_destroy_credcache(struct rpc_auth *);
 void                    rpcauth_clear_credcache(struct rpc_cred_cache *);
+int                     rpcauth_key_timeout_notify(struct rpc_auth *,
+                                                struct rpc_cred *);
+bool                    rpcauth_cred_key_to_expire(struct rpc_cred *);
 
 static inline
 struct rpc_cred *       get_rpccred(struct rpc_cred *cred)