Patched in Tegra support.

1 files changed, 41 insertions, 78 deletions

diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 99bc85ff021..02eb4edf0ec 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -36,12 +36,9 @@
 #include <linux/slab.h>
 #include "nfsd.h"
 #include "state.h"
-#include "netns.h"
 
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 
-static void nfsd4_mark_cb_fault(struct nfs4_client *, int reason);
-
 #define NFSPROC4_CB_NULL 0
 #define NFSPROC4_CB_COMPOUND 1
 
@@ -354,7 +351,7 @@ static void encode_cb_recall4args(struct xdr_stream *xdr,
         __be32 *p;
 
         encode_nfs_cb_opnum4(xdr, OP_CB_RECALL);
-        encode_stateid4(xdr, &dp->dl_stid.sc_stateid);
+        encode_stateid4(xdr, &dp->dl_stateid);
 
         p = xdr_reserve_space(xdr, 4);
         *p++ = xdr_zero;                        /* truncate */
@@ -463,8 +460,6 @@ static int decode_cb_sequence4resok(struct xdr_stream *xdr,
          */
         status = 0;
 out:
-        if (status)
-                nfsd4_mark_cb_fault(cb->cb_clp, status);
         return status;
 out_overflow:
         print_overflow_msg(__func__, xdr);
@@ -606,85 +601,57 @@ static struct rpc_version nfs_cb_version4 = {
         .procs                  = nfs4_cb_procedures
 };
 
-static const struct rpc_version *nfs_cb_version[] = {
+static struct rpc_version *nfs_cb_version[] = {
         &nfs_cb_version4,
 };
 
-static const struct rpc_program cb_program;
+static struct rpc_program cb_program;
 
 static struct rpc_stat cb_stats = {
         .program                = &cb_program
 };
 
 #define NFS4_CALLBACK 0x40000000
-static const struct rpc_program cb_program = {
+static struct rpc_program cb_program = {
         .name                   = "nfs4_cb",
         .number                 = NFS4_CALLBACK,
         .nrvers                 = ARRAY_SIZE(nfs_cb_version),
         .version                = nfs_cb_version,
         .stats                  = &cb_stats,
-        .pipe_dir_name          = "nfsd4_cb",
+        .pipe_dir_name          = "/nfsd4_cb",
 };
 
-static int max_cb_time(struct net *net)
-{
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-        return max(nn->nfsd4_lease/10, (time_t)1) * HZ;
-}
-
-static struct rpc_cred *callback_cred;
-
-int set_callback_cred(void)
+static int max_cb_time(void)
 {
-        if (callback_cred)
-                return 0;
-        callback_cred = rpc_lookup_machine_cred("nfs");
-        if (!callback_cred)
-                return -ENOMEM;
-        return 0;
+        return max(nfsd4_lease/10, (time_t)1) * HZ;
 }
 
-static struct rpc_cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc_clnt *client, struct nfsd4_session *ses)
-{
-        if (clp->cl_minorversion == 0) {
-                return get_rpccred(callback_cred);
-        } else {
-                struct rpc_auth *auth = client->cl_auth;
-                struct auth_cred acred = {};
-
-                acred.uid = ses->se_cb_sec.uid;
-                acred.gid = ses->se_cb_sec.gid;
-                return auth->au_ops->lookup_cred(client->cl_auth, &acred, 0);
-        }
-}
 
 static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses)
 {
         struct rpc_timeout      timeparms = {
-                .to_initval     = max_cb_time(clp->net),
+                .to_initval     = max_cb_time(),
                 .to_retries     = 0,
         };
         struct rpc_create_args args = {
-                .net            = clp->net,
+                .net            = &init_net,
                 .address        = (struct sockaddr *) &conn->cb_addr,
                 .addrsize       = conn->cb_addrlen,
                 .saddress       = (struct sockaddr *) &conn->cb_saddr,
                 .timeout        = &timeparms,
                 .program        = &cb_program,
                 .version        = 0,
+                .authflavor     = clp->cl_flavor,
                 .flags          = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET),
         };
         struct rpc_clnt *client;
-        struct rpc_cred *cred;
 
         if (clp->cl_minorversion == 0) {
-                if (!clp->cl_cred.cr_principal &&
-                                (clp->cl_cred.cr_flavor >= RPC_AUTH_GSS_KRB5))
+                if (!clp->cl_principal && (clp->cl_flavor >= RPC_AUTH_GSS_KRB5))
                         return -EINVAL;
-                args.client_name = clp->cl_cred.cr_principal;
+                args.client_name = clp->cl_principal;
                 args.prognumber = conn->cb_prog,
                 args.protocol = XPRT_TRANSPORT_TCP;
-                args.authflavor = clp->cl_cred.cr_flavor;
                 clp->cl_cb_ident = conn->cb_ident;
         } else {
                 if (!conn->cb_xprt)
@@ -694,7 +661,6 @@ static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *c
                 args.bc_xprt = conn->cb_xprt;
                 args.prognumber = clp->cl_cb_session->se_cb_prog;
                 args.protocol = XPRT_TRANSPORT_BC_TCP;
-                args.authflavor = ses->se_cb_sec.flavor;
         }
         /* Create RPC client */
         client = rpc_create(&args);
@@ -703,14 +669,9 @@ static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *c
                         PTR_ERR(client));
                 return PTR_ERR(client);
         }
-        cred = get_backchannel_cred(clp, client, ses);
-        if (IS_ERR(cred)) {
-                rpc_shutdown_client(client);
-                return PTR_ERR(cred);
-        }
         clp->cl_cb_client = client;
-        clp->cl_cb_cred = cred;
         return 0;
+
 }
 
 static void warn_no_callback_path(struct nfs4_client *clp, int reason)
@@ -725,12 +686,6 @@ static void nfsd4_mark_cb_down(struct nfs4_client *clp, int reason)
         warn_no_callback_path(clp, reason);
 }
 
-static void nfsd4_mark_cb_fault(struct nfs4_client *clp, int reason)
-{
-        clp->cl_cb_state = NFSD4_CB_FAULT;
-        warn_no_callback_path(clp, reason);
-}
-
 static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata)
 {
         struct nfs4_client *clp = container_of(calldata, struct nfs4_client, cl_cb_null);
@@ -747,6 +702,18 @@ static const struct rpc_call_ops nfsd4_cb_probe_ops = {
         .rpc_call_done = nfsd4_cb_probe_done,
 };
 
+static struct rpc_cred *callback_cred;
+
+int set_callback_cred(void)
+{
+        if (callback_cred)
+                return 0;
+        callback_cred = rpc_lookup_machine_cred();
+        if (!callback_cred)
+                return -ENOMEM;
+        return 0;
+}
+
 static struct workqueue_struct *callback_wq;
 
 static void run_nfsd4_cb(struct nfsd4_callback *cb)
@@ -764,6 +731,7 @@ static void do_probe_callback(struct nfs4_client *clp)
         cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL];
         cb->cb_msg.rpc_argp = NULL;
         cb->cb_msg.rpc_resp = NULL;
+        cb->cb_msg.rpc_cred = callback_cred;
 
         cb->cb_ops = &nfsd4_cb_probe_ops;
 
@@ -776,8 +744,9 @@ static void do_probe_callback(struct nfs4_client *clp)
  */
 void nfsd4_probe_callback(struct nfs4_client *clp)
 {
+        /* XXX: atomicity?  Also, should we be using cl_cb_flags? */
         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
-        set_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags);
+        set_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
         do_probe_callback(clp);
 }
 
@@ -818,7 +787,7 @@ static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata)
 {
         struct nfsd4_callback *cb = calldata;
         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
-        struct nfs4_client *clp = dp->dl_stid.sc_client;
+        struct nfs4_client *clp = dp->dl_client;
         u32 minorversion = clp->cl_minorversion;
 
         cb->cb_minorversion = minorversion;
@@ -840,7 +809,7 @@ static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
 {
         struct nfsd4_callback *cb = calldata;
         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
-        struct nfs4_client *clp = dp->dl_stid.sc_client;
+        struct nfs4_client *clp = dp->dl_client;
 
         dprintk("%s: minorversion=%d\n", __func__,
                 clp->cl_minorversion);
@@ -863,7 +832,7 @@ static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
 {
         struct nfsd4_callback *cb = calldata;
         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
-        struct nfs4_client *clp = dp->dl_stid.sc_client;
+        struct nfs4_client *clp = dp->dl_client;
         struct rpc_clnt *current_rpc_client = clp->cl_cb_client;
 
         nfsd4_cb_done(task, calldata);
@@ -936,7 +905,7 @@ void nfsd4_destroy_callback_queue(void)
 /* must be called under the state lock */
 void nfsd4_shutdown_callback(struct nfs4_client *clp)
 {
-        set_bit(NFSD4_CLIENT_CB_KILL, &clp->cl_flags);
+        set_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags);
         /*
          * Note this won't actually result in a null callback;
          * instead, nfsd4_do_callback_rpc() will detect the killed
@@ -982,22 +951,20 @@ static void nfsd4_process_cb_update(struct nfsd4_callback *cb)
         if (clp->cl_cb_client) {
                 rpc_shutdown_client(clp->cl_cb_client);
                 clp->cl_cb_client = NULL;
-                put_rpccred(clp->cl_cb_cred);
-                clp->cl_cb_cred = NULL;
         }
         if (clp->cl_cb_conn.cb_xprt) {
                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
                 clp->cl_cb_conn.cb_xprt = NULL;
         }
-        if (test_bit(NFSD4_CLIENT_CB_KILL, &clp->cl_flags))
+        if (test_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags))
                 return;
         spin_lock(&clp->cl_lock);
         /*
          * Only serialized callback code is allowed to clear these
          * flags; main nfsd code can only set them:
          */
-        BUG_ON(!(clp->cl_flags & NFSD4_CLIENT_CB_FLAG_MASK));
-        clear_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags);
+        BUG_ON(!clp->cl_cb_flags);
+        clear_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
         memcpy(&conn, &cb->cb_clp->cl_cb_conn, sizeof(struct nfs4_cb_conn));
         c = __nfsd4_find_backchannel(clp);
         if (c) {
@@ -1009,7 +976,7 @@ static void nfsd4_process_cb_update(struct nfsd4_callback *cb)
 
         err = setup_callback_client(clp, &conn, ses);
         if (err) {
-                nfsd4_mark_cb_down(clp, err);
+                warn_no_callback_path(clp, err);
                 return;
         }
         /* Yay, the callback channel's back! Restart any callbacks: */
@@ -1017,13 +984,13 @@ static void nfsd4_process_cb_update(struct nfsd4_callback *cb)
                 run_nfsd4_cb(cb);
 }
 
-static void nfsd4_do_callback_rpc(struct work_struct *w)
+void nfsd4_do_callback_rpc(struct work_struct *w)
 {
         struct nfsd4_callback *cb = container_of(w, struct nfsd4_callback, cb_work);
         struct nfs4_client *clp = cb->cb_clp;
         struct rpc_clnt *clnt;
 
-        if (clp->cl_flags & NFSD4_CLIENT_CB_FLAG_MASK)
+        if (clp->cl_cb_flags)
                 nfsd4_process_cb_update(cb);
 
         clnt = clp->cl_cb_client;
@@ -1032,20 +999,14 @@ static void nfsd4_do_callback_rpc(struct work_struct *w)
                 nfsd4_release_cb(cb);
                 return;
         }
-        cb->cb_msg.rpc_cred = clp->cl_cb_cred;
         rpc_call_async(clnt, &cb->cb_msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
                         cb->cb_ops, cb);
 }
 
-void nfsd4_init_callback(struct nfsd4_callback *cb)
-{
-        INIT_WORK(&cb->cb_work, nfsd4_do_callback_rpc);
-}
-
 void nfsd4_cb_recall(struct nfs4_delegation *dp)
 {
         struct nfsd4_callback *cb = &dp->dl_recall;
-        struct nfs4_client *clp = dp->dl_stid.sc_client;
+        struct nfs4_client *clp = dp->dl_client;
 
         dp->dl_retries = 1;
         cb->cb_op = dp;
@@ -1053,8 +1014,10 @@ void nfsd4_cb_recall(struct nfs4_delegation *dp)
         cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL];
         cb->cb_msg.rpc_argp = cb;
         cb->cb_msg.rpc_resp = cb;
+        cb->cb_msg.rpc_cred = callback_cred;
 
         cb->cb_ops = &nfsd4_cb_recall_ops;
+        dp->dl_retries = 1;
 
         INIT_LIST_HEAD(&cb->cb_per_client);
         cb->cb_done = true;