afs: Use the operation issue time instead of the reply time for callbacks

[ Upstream commit 7903192c4b4a82d792cb0dc5e2779a2efe60d45b ]

rxrpc and kafs between them try to use the receive timestamp on the first
data packet (ie. the one with sequence number 1) as a base from which to
calculate the time at which callback promise and lock expiration occurs.

However, we don't know how long it took for the server to send us the reply
from it having completed the basic part of the operation - it might then,
for instance, have to send a bunch of a callback breaks, depending on the
particular operation.

Fix this by using the time at which the operation is issued on the client
as a base instead.  That should never be longer than the server's idea of
the expiry time.

Fixes: 781070551c26 ("afs: Fix calculation of callback expiry time")
Fixes: 2070a3e44962 ("rxrpc: Allow the reply time to be obtained on a client call")
Suggested-by: Jeffrey E Altman <jaltman@auristor.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/afs/flock.c b/fs/afs/flock.c
index cb3054c7843ea49355409eec8acb68de82ef4679..466ad609f2057f4d1395ebb0978a1b4f576c6ef1 100644 (file)
--- a/fs/afs/flock.c
+++ b/fs/afs/flock.c
@@ -76,7 +76,7 @@ void afs_lock_op_done(struct afs_call *call)
        if (call->error == 0) {
                spin_lock(&vnode->lock);
                trace_afs_flock_ev(vnode, NULL, afs_flock_timestamp, 0);
-               vnode->locked_at = call->reply_time;
+               vnode->locked_at = call->issue_time;
                afs_schedule_lock_extension(vnode);
                spin_unlock(&vnode->lock);
        }

diff --git a/fs/afs/fsclient.c b/fs/afs/fsclient.c
index 1d95ed9dd86e601f6068ec3bf500ebcc08b9d8e9..0048a32cb040e62588f752ce877614c90bcbd24c 100644 (file)
--- a/fs/afs/fsclient.c
+++ b/fs/afs/fsclient.c
@@ -130,7 +130,7 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
 
 static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
 {
-       return ktime_divns(call->reply_time, NSEC_PER_SEC) + expiry;
+       return ktime_divns(call->issue_time, NSEC_PER_SEC) + expiry;
 }
 
 static void xdr_decode_AFSCallBack(const __be32 **_bp,

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index dc08a3d9b3a8b591e54a984426eca0f0f9b12666..637cbe549397c69ac14f0720c54a1c41250a8986 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -135,7 +135,6 @@ struct afs_call {
        bool                    need_attention; /* T if RxRPC poked us */
        bool                    async;          /* T if asynchronous */
        bool                    upgrade;        /* T to request service upgrade */
-       bool                    have_reply_time; /* T if have got reply_time */
        bool                    intr;           /* T if interruptible */
        bool                    unmarshalling_error; /* T if an unmarshalling error occurred */
        u16                     service_id;     /* Actual service ID (after upgrade) */
@@ -149,7 +148,7 @@ struct afs_call {
                } __attribute__((packed));
                __be64          tmp64;
        };
-       ktime_t                 reply_time;     /* Time of first reply packet */
+       ktime_t                 issue_time;     /* Time of issue of operation */
 };
 
 struct afs_call_type {

diff --git a/fs/afs/rxrpc.c b/fs/afs/rxrpc.c
index efe0fb3ad8bdc0d7d5119065ff075b235cd75780..535d28b44bca35794cd6ce7ffe60793686d70df2 100644 (file)
--- a/fs/afs/rxrpc.c
+++ b/fs/afs/rxrpc.c
@@ -429,6 +429,7 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
        if (call->max_lifespan)
                rxrpc_kernel_set_max_life(call->net->socket, rxcall,
                                          call->max_lifespan);
+       call->issue_time = ktime_get_real();
 
        /* send the request */
        iov[0].iov_base = call->request;
@@ -533,12 +534,6 @@ static void afs_deliver_to_call(struct afs_call *call)
                        return;
                }
 
-               if (!call->have_reply_time &&
-                   rxrpc_kernel_get_reply_time(call->net->socket,
-                                               call->rxcall,
-                                               &call->reply_time))
-                       call->have_reply_time = true;
-
                ret = call->type->deliver(call);
                state = READ_ONCE(call->state);
                if (ret == 0 && call->unmarshalling_error)

diff --git a/fs/afs/yfsclient.c b/fs/afs/yfsclient.c
index bd787e71a657f9b683922eeb7cd2ac5b655eb620..5b2ef5ffd716fafce99313412e7e2e177c5af84e 100644 (file)
--- a/fs/afs/yfsclient.c
+++ b/fs/afs/yfsclient.c
@@ -239,8 +239,7 @@ static void xdr_decode_YFSCallBack(const __be32 **_bp,
        struct afs_callback *cb = &scb->callback;
        ktime_t cb_expiry;
 
-       cb_expiry = call->reply_time;
-       cb_expiry = ktime_add(cb_expiry, xdr_to_u64(x->expiration_time) * 100);
+       cb_expiry = ktime_add(call->issue_time, xdr_to_u64(x->expiration_time) * 100);
        cb->expires_at  = ktime_divns(cb_expiry, NSEC_PER_SEC);
        scb->have_cb    = true;
        *_bp += xdr_size(x);