afs: Rename some fields

Rename the ->index and ->untried fields of the afs_vl_cursor and
afs_operation struct to ->server_index and ->untried_servers to avoid
confusion with address iteration fields when those get folded in.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index d00fda99f401a00988299360925c15a54c2d8b83..a321fb83aba1bbd0f26e25fee05bfefd6d4034c8 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -747,11 +747,11 @@ struct afs_vl_cursor {
        struct afs_vlserver_list *server_list;  /* Current server list (pins ref) */
        struct afs_vlserver     *server;        /* Server on which this resides */
        struct key              *key;           /* Key for the server */
-       unsigned long           untried;        /* Bitmask of untried servers */
+       unsigned long           untried_servers; /* Bitmask of untried servers */
        struct afs_error        cumul_error;    /* Cumulative error */
        s32                     call_abort_code;
-       short                   index;          /* Current server */
        short                   call_error;     /* Error from single call */
+       short                   server_index;   /* Current server */
        unsigned short          flags;
 #define AFS_VL_CURSOR_STOP     0x0001          /* Set to cease iteration */
 #define AFS_VL_CURSOR_RETRY    0x0002          /* Set to do a retry */
@@ -864,8 +864,8 @@ struct afs_operation {
        struct afs_server_list  *server_list;   /* Current server list (pins ref) */
        struct afs_server       *server;        /* Server we're using (ref pinned by server_list) */
        struct afs_call         *call;
-       unsigned long           untried;        /* Bitmask of untried servers */
-       short                   index;          /* Current server */
+       unsigned long           untried_servers; /* Bitmask of untried servers */
+       short                   server_index;   /* Current server */
        short                   nr_iterations;  /* Number of server iterations */
        bool                    call_responded; /* T if the current address responded */
 

diff --git a/fs/afs/rotate.c b/fs/afs/rotate.c
index fa2ba45a5941f9aa25497047f8001191a690651f..6c1aa9bafc822ed56ae1b40cb3ffcdcced29a312 100644 (file)
--- a/fs/afs/rotate.c
+++ b/fs/afs/rotate.c
@@ -32,8 +32,8 @@ static bool afs_start_fs_iteration(struct afs_operation *op,
                                          lockdep_is_held(&op->volume->servers_lock)));
        read_unlock(&op->volume->servers_lock);
 
-       op->untried = (1UL << op->server_list->nr_servers) - 1;
-       op->index = READ_ONCE(op->server_list->preferred);
+       op->untried_servers = (1UL << op->server_list->nr_servers) - 1;
+       op->server_index = READ_ONCE(op->server_list->preferred);
 
        cb_server = vnode->cb_server;
        if (cb_server) {
@@ -41,7 +41,7 @@ static bool afs_start_fs_iteration(struct afs_operation *op,
                for (i = 0; i < op->server_list->nr_servers; i++) {
                        server = op->server_list->servers[i].server;
                        if (server == cb_server) {
-                               op->index = i;
+                               op->server_index = i;
                                goto found_interest;
                        }
                }
@@ -120,7 +120,7 @@ bool afs_select_fileserver(struct afs_operation *op)
 
        _enter("OP=%x+%x,%llx,%lx[%d],%lx[%d],%d,%d",
               op->debug_id, op->nr_iterations, op->volume->vid,
-              op->untried, op->index,
+              op->untried_servers, op->server_index,
               op->ac.tried, op->ac.index,
               error, abort_code);
 
@@ -172,7 +172,7 @@ bool afs_select_fileserver(struct afs_operation *op)
                        }
 
                        write_lock(&op->volume->servers_lock);
-                       op->server_list->vnovol_mask |= 1 << op->index;
+                       op->server_list->vnovol_mask |= 1 << op->server_index;
                        write_unlock(&op->volume->servers_lock);
 
                        set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags);
@@ -419,9 +419,9 @@ start:
        _debug("__ VOL %llx __", op->volume->vid);
 
 pick_server:
-       _debug("pick [%lx]", op->untried);
+       _debug("pick [%lx]", op->untried_servers);
 
-       error = afs_wait_for_fs_probes(op->server_list, op->untried);
+       error = afs_wait_for_fs_probes(op->server_list, op->untried_servers);
        if (error < 0) {
                afs_op_set_error(op, error);
                goto failed;
@@ -431,40 +431,40 @@ pick_server:
         * callbacks, we stick with the server we're already using if we can.
         */
        if (op->server) {
-               _debug("server %u", op->index);
-               if (test_bit(op->index, &op->untried))
+               _debug("server %u", op->server_index);
+               if (test_bit(op->server_index, &op->untried_servers))
                        goto selected_server;
                op->server = NULL;
                _debug("no server");
        }
 
-       op->index = -1;
+       op->server_index = -1;
        rtt = UINT_MAX;
        for (i = 0; i < op->server_list->nr_servers; i++) {
                struct afs_server *s = op->server_list->servers[i].server;
 
-               if (!test_bit(i, &op->untried) ||
+               if (!test_bit(i, &op->untried_servers) ||
                    !test_bit(AFS_SERVER_FL_RESPONDING, &s->flags))
                        continue;
                if (s->probe.rtt <= rtt) {
-                       op->index = i;
+                       op->server_index = i;
                        rtt = s->probe.rtt;
                }
        }
 
-       if (op->index == -1)
+       if (op->server_index == -1)
                goto no_more_servers;
 
 selected_server:
-       _debug("use %d", op->index);
-       __clear_bit(op->index, &op->untried);
+       _debug("use %d", op->server_index);
+       __clear_bit(op->server_index, &op->untried_servers);
 
        /* We're starting on a different fileserver from the list.  We need to
         * check it, create a callback intercept, find its address list and
         * probe its capabilities before we use it.
         */
        ASSERTCMP(op->ac.alist, ==, NULL);
-       server = op->server_list->servers[op->index].server;
+       server = op->server_list->servers[op->server_index].server;
 
        if (!afs_check_server_record(op, server))
                goto failed;
@@ -506,7 +506,7 @@ iterate_address:
                goto out_of_addresses;
 
        _debug("address [%u] %u/%u %pISp",
-              op->index, op->ac.index, op->ac.alist->nr_addrs,
+              op->server_index, op->ac.index, op->ac.alist->nr_addrs,
               rxrpc_kernel_remote_addr(op->ac.alist->addrs[op->ac.index].peer));
 
        op->call_responded = false;
@@ -581,7 +581,7 @@ void afs_dump_edestaddrreq(const struct afs_operation *op)
                  op->file[0].cb_break_before,
                  op->file[1].cb_break_before, op->flags, op->cumul_error.error);
        pr_notice("OP: ut=%lx ix=%d ni=%u\n",
-                 op->untried, op->index, op->nr_iterations);
+                 op->untried_servers, op->server_index, op->nr_iterations);
        pr_notice("OP: call  er=%d ac=%d r=%u\n",
                  op->call_error, op->call_abort_code, op->call_responded);
 

diff --git a/fs/afs/vl_rotate.c b/fs/afs/vl_rotate.c
index e8fbbeb551bbba352f517a27acd1b641f739c68a..f895eb94129e24a84b3c50fe30e9076b1fe0920d 100644 (file)
--- a/fs/afs/vl_rotate.c
+++ b/fs/afs/vl_rotate.c
@@ -78,8 +78,8 @@ static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
        if (!vc->server_list->nr_servers)
                return false;
 
-       vc->untried = (1UL << vc->server_list->nr_servers) - 1;
-       vc->index = -1;
+       vc->untried_servers = (1UL << vc->server_list->nr_servers) - 1;
+       vc->server_index = -1;
        return true;
 }
 
@@ -98,7 +98,7 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
        vc->nr_iterations++;
 
        _enter("%lx[%d],%lx[%d],%d,%d",
-              vc->untried, vc->index,
+              vc->untried_servers, vc->server_index,
               vc->ac.tried, vc->ac.index,
               error, abort_code);
 
@@ -131,7 +131,7 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
                        /* The server went weird. */
                        afs_prioritise_error(&vc->cumul_error, -EREMOTEIO, abort_code);
                        //write_lock(&vc->cell->vl_servers_lock);
-                       //vc->server_list->weird_mask |= 1 << vc->index;
+                       //vc->server_list->weird_mask |= 1 << vc->server_index;
                        //write_unlock(&vc->cell->vl_servers_lock);
                        goto next_server;
 
@@ -184,46 +184,46 @@ start:
        }
 
 pick_server:
-       _debug("pick [%lx]", vc->untried);
+       _debug("pick [%lx]", vc->untried_servers);
 
-       error = afs_wait_for_vl_probes(vc->server_list, vc->untried);
+       error = afs_wait_for_vl_probes(vc->server_list, vc->untried_servers);
        if (error < 0) {
                afs_prioritise_error(&vc->cumul_error, error, 0);
                goto failed;
        }
 
        /* Pick the untried server with the lowest RTT. */
-       vc->index = vc->server_list->preferred;
-       if (test_bit(vc->index, &vc->untried))
+       vc->server_index = vc->server_list->preferred;
+       if (test_bit(vc->server_index, &vc->untried_servers))
                goto selected_server;
 
-       vc->index = -1;
+       vc->server_index = -1;
        rtt = UINT_MAX;
        for (i = 0; i < vc->server_list->nr_servers; i++) {
                struct afs_vlserver *s = vc->server_list->servers[i].server;
 
-               if (!test_bit(i, &vc->untried) ||
+               if (!test_bit(i, &vc->untried_servers) ||
                    !test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
                        continue;
                if (s->probe.rtt <= rtt) {
-                       vc->index = i;
+                       vc->server_index = i;
                        rtt = s->probe.rtt;
                }
        }
 
-       if (vc->index == -1)
+       if (vc->server_index == -1)
                goto no_more_servers;
 
 selected_server:
-       _debug("use %d", vc->index);
-       __clear_bit(vc->index, &vc->untried);
+       _debug("use %d", vc->server_index);
+       __clear_bit(vc->server_index, &vc->untried_servers);
 
        /* We're starting on a different vlserver from the list.  We need to
         * check it, find its address list and probe its capabilities before we
         * use it.
         */
        ASSERTCMP(vc->ac.alist, ==, NULL);
-       vlserver = vc->server_list->servers[vc->index].server;
+       vlserver = vc->server_list->servers[vc->server_index].server;
        vc->server = vlserver;
 
        _debug("USING VLSERVER: %s", vlserver->name);
@@ -299,7 +299,7 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
        pr_notice("DNS: src=%u st=%u lc=%x\n",
                  cell->dns_source, cell->dns_status, cell->dns_lookup_count);
        pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",
-                 vc->untried, vc->index, vc->nr_iterations, vc->flags,
+                 vc->untried_servers, vc->server_index, vc->nr_iterations, vc->flags,
                  vc->cumul_error.error);
        pr_notice("VC: call  er=%d ac=%d r=%u\n",
                  vc->call_error, vc->call_abort_code, vc->call_responded);