libafs: update the volume setup time when the vldb is rechecked
[openafs.git] / src / afs / afs_analyze.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Implements:
12  */
13 #include <afsconfig.h>
14 #include "afs/param.h"
15
16
17 #include "afs/stds.h"
18 #include "afs/sysincludes.h"    /* Standard vendor system headers */
19
20 #ifndef UKERNEL
21 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
22 #include <net/if.h>
23 #include <netinet/in.h>
24 #endif
25
26 #ifdef AFS_SGI62_ENV
27 #include "h/hashing.h"
28 #endif
29 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN_ENV)
30 #include <netinet/in_var.h>
31 #endif
32 #endif /* !UKERNEL */
33
34 #include "afsincludes.h"        /* Afs-based standard headers */
35 #include "afs/afs_stats.h"      /* afs statistics */
36 #include "afs/afs_util.h"
37 #include "afs/unified_afs.h"
38
39 #if     defined(AFS_SUN5_ENV)
40 #include <inet/led.h>
41 #include <inet/common.h>
42 #include <netinet/ip6.h>
43 #include <inet/ip.h>
44 #endif
45
46 /* shouldn't do it this way, but for now will do */
47 #ifndef ERROR_TABLE_BASE_U
48 #define ERROR_TABLE_BASE_U      (5376L)
49 #endif /* ubik error base define */
50
51 /* shouldn't do it this way, but for now will do */
52 #ifndef ERROR_TABLE_BASE_uae
53 #define ERROR_TABLE_BASE_uae    (49733376L)
54 #endif /* unified afs error base define */
55
56 /* same hack for vlserver error base as for ubik error base */
57 #ifndef ERROR_TABLE_BASE_VL
58 #define ERROR_TABLE_BASE_VL     (363520L)
59 #define VL_NOENT                (363524L)
60 #endif /* vlserver error base define */
61
62
63 int afs_BusyWaitPeriod = 15;    /**< poll period, in seconds */
64
65 afs_int32 hm_retry_RO = 0;      /**< enable read-only hard-mount retry */
66 afs_int32 hm_retry_RW = 0;      /**< enable read-write hard-mount retry */
67 afs_int32 hm_retry_int = 0;     /**< hard-mount retry interval, in seconds */
68
69 #define VSleep(at)      afs_osi_Wait((at)*1000, 0, 0)
70
71
72 int lastcode;
73 #define DIFFERENT 0
74 #define SAME 1
75 #define DUNNO 2
76 /*!
77  * \brief
78  *      Request vldb record to determined if it has changed.
79  *
80  * \retval 0 if the vldb record for a specific volume is different from what
81  *           we have cached -- perhaps the volume has moved.
82  * \retval 1 if the vldb record is the same
83  * \retval 2 if we can't tell if it's the same or not.
84  *
85  * \note
86  *      If 0 returned, the caller will probably start over at the beginning of our
87  *      list of servers for this volume and try to find one that is up.  If
88  *      not 0, we will probably just keep plugging with what we have
89  *      cached.   If we fail to contact the VL server, we  should just keep
90  *      trying with the information we have, rather than failing.
91  */
92 static int
93 VLDB_Same(struct VenusFid *afid, struct vrequest *areq)
94 {
95     struct vrequest *treq = NULL;
96     struct afs_conn *tconn;
97     int i, type = 0;
98     union {
99         struct vldbentry tve;
100         struct nvldbentry ntve;
101         struct uvldbentry utve;
102     } *v;
103     struct volume *tvp;
104     struct cell *tcell;
105     char *bp, tbuf[CVBS];       /* biggest volume id is 2^32, ~ 4*10^9 */
106     unsigned int changed;
107     struct server *(oldhosts[NMAXNSERVERS]);
108     struct rx_connection *rxconn;
109
110     AFS_STATCNT(CheckVLDB);
111     afs_FinalizeReq(areq);
112
113     if ((i = afs_CreateReq(&treq, afs_osi_credp)))
114         return DUNNO;
115     v = afs_osi_Alloc(sizeof(*v));
116     osi_Assert(v != NULL);
117     tcell = afs_GetCell(afid->Cell, READ_LOCK);
118     bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);
119     do {
120         VSleep(2);              /* Better safe than sorry. */
121         tconn =
122             afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,
123                              treq, SHARED_LOCK, 0, &rxconn);
124         if (tconn) {
125             if ( tconn->parent->srvr->server->flags & SNO_LHOSTS) {
126                 type = 0;
127                 RX_AFS_GUNLOCK();
128                 i = VL_GetEntryByNameO(rxconn, bp, &v->tve);
129                 RX_AFS_GLOCK();
130             } else if (tconn->parent->srvr->server->flags & SYES_LHOSTS) {
131                 type = 1;
132                 RX_AFS_GUNLOCK();
133                 i = VL_GetEntryByNameN(rxconn, bp, &v->ntve);
134                 RX_AFS_GLOCK();
135             } else {
136                 type = 2;
137                 RX_AFS_GUNLOCK();
138                 i = VL_GetEntryByNameU(rxconn, bp, &v->utve);
139                 RX_AFS_GLOCK();
140                 if (!(tconn->parent->srvr->server->flags & SVLSRV_UUID)) {
141                     if (i == RXGEN_OPCODE) {
142                         type = 1;
143                         RX_AFS_GUNLOCK();
144                         i = VL_GetEntryByNameN(rxconn, bp, &v->ntve);
145                         RX_AFS_GLOCK();
146                         if (i == RXGEN_OPCODE) {
147                             type = 0;
148                             tconn->parent->srvr->server->flags |= SNO_LHOSTS;
149                             RX_AFS_GUNLOCK();
150                             i = VL_GetEntryByNameO(rxconn, bp, &v->tve);
151                             RX_AFS_GLOCK();
152                         } else if (!i)
153                             tconn->parent->srvr->server->flags |= SYES_LHOSTS;
154                     } else if (!i)
155                         tconn->parent->srvr->server->flags |= SVLSRV_UUID;
156                 }
157                 lastcode = i;
158             }
159         } else
160             i = -1;
161     } while (afs_Analyze(tconn, rxconn, i, NULL, treq, -1,      /* no op code for this */
162                          SHARED_LOCK, tcell));
163
164     afs_PutCell(tcell, READ_LOCK);
165     afs_Trace2(afs_iclSetp, CM_TRACE_CHECKVLDB, ICL_TYPE_FID, &afid,
166                ICL_TYPE_INT32, i);
167
168     if (i) {
169         afs_DestroyReq(treq);
170         afs_osi_Free(v, sizeof(*v));
171         return DUNNO;
172     }
173     /* have info, copy into serverHost array */
174     changed = 0;
175     tvp = afs_FindVolume(afid, WRITE_LOCK);
176     if (tvp) {
177         ObtainWriteLock(&tvp->lock, 107);
178         for (i = 0; i < NMAXNSERVERS && tvp->serverHost[i]; i++) {
179             oldhosts[i] = tvp->serverHost[i];
180         }
181         ReleaseWriteLock(&tvp->lock);
182
183         if (type == 2) {
184             LockAndInstallUVolumeEntry(tvp, &v->utve, afid->Cell, tcell, treq);
185         } else if (type == 1) {
186             LockAndInstallNVolumeEntry(tvp, &v->ntve, afid->Cell);
187         } else {
188             LockAndInstallVolumeEntry(tvp, &v->tve, afid->Cell);
189         }
190
191         if (i < NMAXNSERVERS && tvp->serverHost[i]) {
192             changed = 1;
193         }
194         for (--i; !changed && i >= 0; i--) {
195             if (tvp->serverHost[i] != oldhosts[i]) {
196                 changed = 1;    /* also happens if prefs change.  big deal. */
197             }
198         }
199
200         tvp->states &= ~VRecheck;     /* Just checked it. */
201         tvp->setupTime = osi_Time();  /* Time the vldb was checked. */
202
203         ReleaseWriteLock(&tvp->lock);
204         afs_PutVolume(tvp, WRITE_LOCK);
205     } else {                    /* can't find volume */
206         tvp = afs_GetVolume(afid, treq, WRITE_LOCK);
207         if (tvp) {
208             afs_PutVolume(tvp, WRITE_LOCK);
209             afs_DestroyReq(treq);
210             afs_osi_Free(v, sizeof(*v));
211             return DIFFERENT;
212         } else {
213             afs_DestroyReq(treq);
214             afs_osi_Free(v, sizeof(*v));
215             return DUNNO;
216         }
217     }
218
219     afs_DestroyReq(treq);
220     afs_osi_Free(v, sizeof(*v));
221     return (changed ? DIFFERENT : SAME);
222 }                               /*VLDB_Same */
223
224 /*!
225  * \brief
226  *      Mark a server as invalid for further attempts of this request only.
227  *
228  * \param[in,out] areq  The request record associated with this operation.
229  * \param[in]     afid  The FID of the file involved in the action.  This argument
230  *                      may be null if none was involved.
231  * \param[in,out] tsp   pointer to a server struct for the server we wish to
232  *                      blacklist.
233  *
234  * \returns
235  *      Non-zero value if further servers are available to try,
236  *      zero otherwise.
237  *
238  * \note
239  *      This routine is typically called in situations where we believe
240  *      one server out of a pool may have an error condition.
241  *
242  * \note
243  *      The afs_Conn* routines use the list of invalidated servers to
244  *      avoid reusing a server marked as invalid for this request.
245  */
246 static afs_int32
247 afs_BlackListOnce(struct vrequest *areq, struct VenusFid *afid,
248                   struct server *tsp)
249 {
250     struct volume *tvp;
251     afs_int32 i;
252     afs_int32 serversleft = 0;
253
254     if (afid) {
255         tvp = afs_FindVolume(afid, READ_LOCK);
256         if (tvp) {
257             for (i = 0; i < AFS_MAXHOSTS; i++) {
258                 if (tvp->serverHost[i] == tsp) {
259                     areq->skipserver[i] = 1;
260                 }
261                 if (tvp->serverHost[i] &&
262                     (tvp->serverHost[i]->addr->sa_flags &
263                       SRVR_ISDOWN)) {
264                     areq->skipserver[i] = 1;
265                 }
266             }
267             for (i = 0; i < AFS_MAXHOSTS; i++) {
268                 if (tvp->serverHost[i] && areq->skipserver[i] == 0) {
269                     serversleft = 1;
270                     break;
271                 }
272             }
273             afs_PutVolume(tvp, READ_LOCK);
274             return serversleft;
275         }
276     }
277     return serversleft;
278 }
279
280 /*!
281  * \brief
282  *      Clear any cached status for the target FID of a failed fileserver
283  *      write RPC.
284  *
285  * \param[in]     afid   The FID of the file involved in the action.  This argument
286  *                       may be null if none was involved.
287  * \param[in]     op     which RPC we are analyzing.
288  * \param[in,out] avp    A pointer to the struct volume, if we already have one.
289  *
290  * \returns
291  *      Non-zero value if the related RPC operation can be retried,
292  *      zero otherwise.
293  *
294  * \note
295  *      This routine is called when we got a network error,
296  *      and discards state if the operation was a data-mutating
297  *      operation.
298  */
299 static int
300 afs_ClearStatus(struct VenusFid *afid, int op, struct volume *avp)
301 {
302     struct volume *tvp = NULL;
303
304     /* if it's not a write op, we have nothing to veto and shouldn't clear. */
305     if (!AFS_STATS_FS_RPCIDXES_ISWRITE(op)) {
306         return 1;
307     }
308
309     if (avp)
310         tvp = avp;
311     else if (afid)
312         tvp = afs_FindVolume(afid, READ_LOCK);
313
314     /* don't assume just discarding will fix if no cached volume */
315     if (tvp) {
316         struct vcache *tvc;
317         ObtainReadLock(&afs_xvcache);
318         if ((tvc = afs_FindVCache(afid, 0, 0))) {
319             ReleaseReadLock(&afs_xvcache);
320             tvc->f.states &= ~(CStatd | CUnique);
321             afs_PutVCache(tvc);
322         } else {
323             ReleaseReadLock(&afs_xvcache);
324         }
325         if (!avp)
326             afs_PutVolume(tvp, READ_LOCK);
327     }
328
329     if (AFS_STATS_FS_RPCIDXES_WRITE_RETRIABLE(op))
330         return 1;
331
332     /* not retriable: we may have raced ourselves */
333     return 0;
334 }
335
336 /*!
337  * \brief
338  *      Print the last errors from the servers for the volume on
339  *      this request.
340  *
341  * \param[in] areq   The request record associated with this operation.
342  * \param[in] afid   The FID of the file involved in the action.  This argument
343  *                   may be null if none was involved.
344  *
345  * \return
346  *      None
347  *
348  * \note
349  *      This routine is called before a hard-mount retry, to display
350  *      the servers by primary address and the errors encountered.
351  */
352 static void
353 afs_PrintServerErrors(struct vrequest *areq, struct VenusFid *afid)
354 {
355     int i;
356     struct volume *tvp;
357     struct srvAddr *sa;
358     afs_uint32 address;
359     char *sep = " (";
360     char *term = "";
361
362     if (afid) {
363         tvp = afs_FindVolume(afid, READ_LOCK);
364         if (tvp) {
365             for (i = 0; i < AFS_MAXHOSTS; i++) {
366                 if (areq->lasterror[i] && tvp->serverHost[i]) {
367                     sa = tvp->serverHost[i]->addr;
368                     if (sa) {
369                         address = ntohl(sa->sa_ip);
370                         afs_warnuser("%s%d.%d.%d.%d code=%d", sep,
371                                      (address >> 24), (address >> 16) & 0xff,
372                                      (address >> 8) & 0xff, (address) & 0xff,
373                                      areq->lasterror[i]);
374                         sep = ", ";
375                         term = ")";
376                     }
377                 }
378             }
379             afs_PutVolume(tvp, READ_LOCK);
380         }
381     }
382     afs_warnuser("%s\n", term);
383 }
384
385 /*!
386  * \brief
387  *      Analyze the outcome of an RPC operation, taking whatever support
388  *      actions are necessary.
389  *
390  * \param[in]     aconn  Ptr to the relevant connection on which the call was made.
391  * \param[in]     rxconn Ptr to the rx_connection.
392  * \param[in]     acode  The return code experienced by the RPC.
393  * \param[in]     fid    The FID of the file involved in the action.  This argument
394  *                       may be null if none was involved.
395  * \param[in,out] areq   The request record associated with this operation.
396  * \param[in]     op     which RPC we are analyzing.
397  * \param[in]     cellp  pointer to a cell struct.  Must provide either fid or cell.
398  *
399  * \returns
400  *      Non-zero value if the related RPC operation should be retried,
401  *      zero otherwise.
402  *
403  * \note
404  *      This routine is typically called in a do-while loop, causing the
405  *      embedded RPC operation to be called repeatedly if appropriate
406  *      until whatever error condition (if any) is intolerable.
407  *
408  * \note
409  *      The retry return value is used by afs_StoreAllSegments to determine
410  *      if this is a temporary or permanent error.
411  */
412 int
413 afs_Analyze(struct afs_conn *aconn, struct rx_connection *rxconn,
414             afs_int32 acode, struct VenusFid *afid, struct vrequest *areq,
415             int op, afs_int32 locktype, struct cell *cellp)
416 {
417     afs_int32 i;
418     struct srvAddr *sa;
419     struct server *tsp;
420     struct volume *tvp = NULL;
421     afs_int32 shouldRetry = 0;
422     afs_int32 serversleft = 1;
423     struct afs_stats_RPCErrors *aerrP;
424     afs_uint32 address;
425
426     if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
427         /* On reconnection, act as connected. XXX: for now.... */
428         /* SXW - This may get very tired after a while. We should try and
429          *       intercept all RPCs before they get here ... */
430         /*printf("afs_Analyze: disconnected\n");*/
431         afs_FinalizeReq(areq);
432         if (aconn) {
433             /* SXW - I suspect that this will _never_ happen - we shouldn't
434              *       get a connection because we're disconnected !!!*/
435             afs_PutConn(aconn, rxconn, locktype);
436         }
437         return 0;
438     }
439
440     AFS_STATCNT(afs_Analyze);
441     afs_Trace4(afs_iclSetp, CM_TRACE_ANALYZE, ICL_TYPE_INT32, op,
442                ICL_TYPE_POINTER, aconn, ICL_TYPE_INT32, acode, ICL_TYPE_LONG,
443                areq->uid);
444
445     aerrP = (struct afs_stats_RPCErrors *)0;
446
447     if ((op >= 0) && (op < AFS_STATS_NUM_FS_RPC_OPS))
448         aerrP = &(afs_stats_cmfullperf.rpc.fsRPCErrors[op]);
449
450     afs_FinalizeReq(areq);
451     if (!aconn && areq->busyCount) {    /* one RPC or more got VBUSY/VRESTARTING */
452
453         tvp = afs_FindVolume(afid, READ_LOCK);
454         if (tvp) {
455             afs_warnuser("afs: Waiting for busy volume %u (%s) in cell %s\n",
456                          (afid ? afid->Fid.Volume : 0),
457                          (tvp->name ? tvp->name : ""),
458                          ((tvp->serverHost[0]
459                            && tvp->serverHost[0]->cell) ? tvp->serverHost[0]->
460                           cell->cellName : ""));
461
462             for (i = 0; i < AFS_MAXHOSTS; i++) {
463                 if (tvp->status[i] != not_busy && tvp->status[i] != offline) {
464                     tvp->status[i] = not_busy;
465                 }
466                 if (tvp->status[i] == not_busy)
467                     shouldRetry = 1;
468             }
469             afs_PutVolume(tvp, READ_LOCK);
470         } else {
471             afs_warnuser("afs: Waiting for busy volume %u\n",
472                          (afid ? afid->Fid.Volume : 0));
473         }
474
475         if (areq->busyCount > 100) {
476             if (aerrP)
477                 (aerrP->err_Volume)++;
478             areq->volumeError = VOLBUSY;
479             shouldRetry = 0;
480         } else {
481             VSleep(afs_BusyWaitPeriod); /* poll periodically */
482         }
483         if (shouldRetry != 0)
484             areq->busyCount++;
485
486         return shouldRetry;     /* should retry */
487     }
488
489     if (!aconn || !aconn->parent->srvr) {
490         if (!areq->volumeError) {
491             if (aerrP)
492                 (aerrP->err_Network)++;
493             if (hm_retry_int && !(areq->flags & O_NONBLOCK) &&  /* "hard" mount */
494                 ((afid && afs_IsPrimaryCellNum(afid->Cell))
495                  || (cellp && afs_IsPrimaryCell(cellp)))) {
496                 if (!afid) {
497                     static int afs_vl_hm = 0;
498                     int warn = 0;
499                     if (!afs_vl_hm) {
500                         afs_vl_hm = warn = 1;
501                     }
502                     if (warn) {
503                         afs_warnuser
504                             ("afs: hard-mount waiting for a vlserver to return to service\n");
505                     }
506                     VSleep(hm_retry_int);
507                     afs_CheckServers(1, cellp);
508                     shouldRetry = 1;
509
510                     if (warn) {
511                         afs_vl_hm = 0;
512                     }
513                 } else {
514                     static int afs_unknown_vhm = 0;
515                     int warn = 0, vp_vhm = 0;
516
517                     tvp = afs_FindVolume(afid, READ_LOCK);
518                     if (!tvp || (tvp->states & VRO)) {
519                         shouldRetry = hm_retry_RO;
520                     } else {
521                         shouldRetry = hm_retry_RW;
522                     }
523
524                     /* Set 'warn' if we should afs_warnuser. Only let one
525                      * caller call afs_warnuser per hm_retry_int interval per
526                      * volume. */
527                     if (shouldRetry) {
528                         if (tvp) {
529                             if (!(tvp->states & VHardMount)) {
530                                 tvp->states |= VHardMount;
531                                 warn = vp_vhm = 1;
532                             }
533                         } else {
534                             if (!afs_unknown_vhm) {
535                                 afs_unknown_vhm = 1;
536                                 warn = 1;
537                             }
538                         }
539                     }
540
541                     if (tvp)
542                         afs_PutVolume(tvp, READ_LOCK);
543
544                     if (shouldRetry) {
545                         if (warn) {
546                             afs_warnuser
547                                 ("afs: hard-mount waiting for volume %u",
548                                  afid->Fid.Volume);
549                             afs_PrintServerErrors(areq, afid);
550                         }
551
552                         VSleep(hm_retry_int);
553                         afs_CheckServers(1, cellp);
554                         /* clear the black listed servers on this request. */
555                         memset(areq->skipserver, 0, sizeof(areq->skipserver));
556
557                         if (vp_vhm) {
558                             tvp = afs_FindVolume(afid, READ_LOCK);
559                             if (tvp) {
560                                 tvp->states &= ~VHardMount;
561                                 afs_PutVolume(tvp, READ_LOCK);
562                             }
563                         } else if (warn) {
564                             afs_unknown_vhm = 0;
565                         }
566                     }
567                 }
568             } /* if (hm_retry_int ... */
569             else {
570                 if (acode == RX_MSGSIZE)
571                     shouldRetry = 1;
572                 else {
573                     areq->networkError = 1;
574                     /* do not promote to shouldRetry if not already */
575                     if (afs_ClearStatus(afid, op, NULL) == 0)
576                         shouldRetry = 0;
577                 }
578             }
579         }
580         if (aconn) /* simply lacking aconn->server doesn't absolve this */
581             afs_PutConn(aconn, rxconn, locktype);
582         return shouldRetry;
583     }
584
585     /* Find server associated with this connection. */
586     sa = aconn->parent->srvr;
587     tsp = sa->server;
588     address = ntohl(sa->sa_ip);
589
590     /* Before we do anything with acode, make sure we translate it back to
591      * a system error */
592     if ((acode & ~0xff) == ERROR_TABLE_BASE_uae)
593         acode = et_to_sys_error(acode);
594
595     if (acode == 0) {
596         /* If we previously took an error, mark this volume not busy */
597         if (areq->volumeError) {
598             tvp = afs_FindVolume(afid, READ_LOCK);
599             if (tvp) {
600                 for (i = 0; i < AFS_MAXHOSTS; i++) {
601                     if (tvp->serverHost[i] == tsp) {
602                         tvp->status[i] = not_busy;
603                     }
604                 }
605                 afs_PutVolume(tvp, READ_LOCK);
606             }
607         }
608
609         afs_PutConn(aconn, rxconn, locktype);
610         return 0;
611     }
612
613     /* Save the last code of this server on this request. */
614     tvp = afs_FindVolume(afid, READ_LOCK);
615     if (tvp) {
616         for (i = 0; i < AFS_MAXHOSTS; i++) {
617             if (tvp->serverHost[i] == tsp) {
618                 areq->lasterror[i] = acode;
619             }
620         }
621         afs_PutVolume(tvp, READ_LOCK);
622     }
623
624 #ifdef AFS_64BIT_CLIENT
625     if (acode == -455)
626         acode = 455;
627 #endif /* AFS_64BIT_CLIENT */
628     if (acode == RX_MSGSIZE) {
629         shouldRetry = 1;
630         goto out;
631     }
632     if (acode == RX_CALL_TIMEOUT || acode == VNOSERVICE) {
633         serversleft = afs_BlackListOnce(areq, afid, tsp);
634         if (afid)
635             tvp = afs_FindVolume(afid, READ_LOCK);
636         if ((serversleft == 0) && tvp &&
637             ((tvp->states & VRO) || (tvp->states & VBackup))) {
638             shouldRetry = 0;
639         } else {
640             shouldRetry = 1;
641         }
642         if (!afid || !tvp || (tvp->states & VRO))
643             areq->idleError++;
644         else if (afs_ClearStatus(afid, op, tvp) == 0)
645             shouldRetry = 0;
646
647         if (tvp)
648             afs_PutVolume(tvp, READ_LOCK);
649         /* By doing this, we avoid ever marking a server down
650          * in an idle timeout case. That's because the server is
651          * still responding and may only be letting a single vnode
652          * time out. We otherwise risk having the server continually
653          * be marked down, then up, then down again...
654          */
655         goto out;
656     }
657     /* If network troubles, mark server as having bogued out again. */
658     /* VRESTARTING is < 0 because of backward compatibility issues
659      * with 3.4 file servers and older cache managers */
660     if ((acode < 0) && (acode != VRESTARTING)) {
661         afs_ServerDown(sa, acode, rxconn);
662         ForceNewConnections(sa); /* multi homed clients lock:afs_xsrvAddr? */
663         if (aerrP)
664             (aerrP->err_Server)++;
665     }
666
667     if (acode == VBUSY || acode == VRESTARTING) {
668         if (acode == VBUSY) {
669             areq->busyCount++;
670             if (aerrP)
671                 (aerrP->err_VolumeBusies)++;
672         } else
673             areq->busyCount = 1;
674
675         tvp = afs_FindVolume(afid, READ_LOCK);
676         if (tvp) {
677             for (i = 0; i < AFS_MAXHOSTS; i++) {
678                 if (tvp->serverHost[i] == tsp) {
679                     tvp->status[i] = rdwr_busy; /* can't tell which yet */
680                     /* to tell which, have to look at the op code. */
681                 }
682             }
683             afs_PutVolume(tvp, READ_LOCK);
684         } else {
685             afs_warnuser("afs: Waiting for busy volume %u in cell %s (server %d.%d.%d.%d)\n",
686                          (afid ? afid->Fid.Volume : 0), tsp->cell->cellName,
687                          (address >> 24), (address >> 16) & 0xff,
688                          (address >> 8) & 0xff, (address) & 0xff);
689             VSleep(afs_BusyWaitPeriod); /* poll periodically */
690         }
691         shouldRetry = 1;
692         acode = 0;
693     } else if (acode == VICETOKENDEAD
694                || (acode & ~0xff) == ERROR_TABLE_BASE_RXK) {
695         /* any rxkad error is treated as token expiration */
696         struct unixuser *tu;
697         /*
698          * I'm calling these errors protection errors, since they involve
699          * faulty authentication.
700          */
701         if (aerrP)
702             (aerrP->err_Protection)++;
703
704         tu = afs_FindUser(areq->uid, tsp->cell->cellNum, READ_LOCK);
705         if (tu) {
706             if (acode == VICETOKENDEAD) {
707                 aconn->forceConnectFS = 1;
708             } else if (acode == RXKADEXPIRED) {
709                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
710                 aconn->parent->user->states |= UTokensBad;
711                 afs_NotifyUser(tu, UTokensDropped);
712                 afs_warnuser
713                     ("afs: Tokens for user of AFS id %d for cell %s have expired (server %d.%d.%d.%d)\n",
714                      tu->viceId, aconn->parent->srvr->server->cell->cellName,
715                      (address >> 24), (address >> 16) & 0xff,
716                      (address >> 8) & 0xff, (address) & 0xff);
717             } else {
718                 serversleft = afs_BlackListOnce(areq, afid, tsp);
719                 areq->tokenError++;
720
721                 if (serversleft) {
722                     afs_warnuser
723                         ("afs: Tokens for user of AFS id %d for cell %s: rxkad error=%d (server %d.%d.%d.%d)\n",
724                          tu->viceId, aconn->parent->srvr->server->cell->cellName, acode,
725                          (address >> 24), (address >> 16) & 0xff,
726                          (address >> 8) & 0xff, (address) & 0xff);
727                     shouldRetry = 1;
728                 } else {
729                     areq->tokenError = 0;
730                     aconn->forceConnectFS = 0;  /* don't check until new tokens set */
731                     aconn->parent->user->states |= UTokensBad;
732                     afs_NotifyUser(tu, UTokensDropped);
733                     afs_warnuser
734                         ("afs: Tokens for user of AFS id %d for cell %s are discarded (rxkad error=%d, server %d.%d.%d.%d)\n",
735                          tu->viceId, aconn->parent->srvr->server->cell->cellName, acode,
736                          (address >> 24), (address >> 16) & 0xff,
737                          (address >> 8) & 0xff, (address) & 0xff);
738                 }
739             }
740             afs_PutUser(tu, READ_LOCK);
741         } else {
742             /* The else case shouldn't be possible and should probably be replaced by a panic? */
743             if (acode == VICETOKENDEAD) {
744                 aconn->forceConnectFS = 1;
745             } else if (acode == RXKADEXPIRED) {
746                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
747                 aconn->parent->user->states |= UTokensBad;
748                 afs_NotifyUser(tu, UTokensDropped);
749                 afs_warnuser
750                     ("afs: Tokens for user %d for cell %s have expired (server %d.%d.%d.%d)\n",
751                      areq->uid, aconn->parent->srvr->server->cell->cellName,
752                      (address >> 24), (address >> 16) & 0xff,
753                      (address >> 8) & 0xff, (address) & 0xff);
754             } else {
755                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
756                 aconn->parent->user->states |= UTokensBad;
757                 afs_NotifyUser(tu, UTokensDropped);
758                 afs_warnuser
759                     ("afs: Tokens for user %d for cell %s are discarded (rxkad error = %d, server %d.%d.%d.%d)\n",
760                      areq->uid, aconn->parent->srvr->server->cell->cellName,
761                      acode,
762                      (address >> 24), (address >> 16) & 0xff,
763                      (address >> 8) & 0xff, (address) & 0xff);
764
765             }
766         }
767         shouldRetry = 1;        /* Try again (as root). */
768     }
769     /* Check for access violation. */
770     else if (acode == EACCES) {
771         /* should mark access error in non-existent per-user global structure */
772         if (aerrP)
773             (aerrP->err_Protection)++;
774         areq->accessError = 1;
775         if (op == AFS_STATS_FS_RPCIDX_STOREDATA)
776             areq->permWriteError = 1;
777         shouldRetry = 0;
778     }
779     /* check for ubik errors; treat them like crashed servers */
780     else if (acode >= ERROR_TABLE_BASE_U && acode < ERROR_TABLE_BASE_U + 255) {
781         afs_ServerDown(sa, acode, rxconn);
782         if (aerrP)
783             (aerrP->err_Server)++;
784         shouldRetry = 1;        /* retryable (maybe one is working) */
785         VSleep(1);              /* just in case */
786     }
787     /* Check for bad volume data base / missing volume. */
788     else if (acode == VSALVAGE || acode == VOFFLINE || acode == VNOVOL
789              || acode == VMOVED) {
790         struct cell *tcell;
791         int same;
792
793         shouldRetry = 1;
794         areq->volumeError = VOLMISSING;
795         if (aerrP)
796             (aerrP->err_Volume)++;
797         if (afid && (tcell = afs_GetCell(afid->Cell, 0))) {
798             same = VLDB_Same(afid, areq);
799             tvp = afs_FindVolume(afid, READ_LOCK);
800             if (tvp) {
801                 for (i = 0; i < AFS_MAXHOSTS && tvp->serverHost[i]; i++) {
802                     if (tvp->serverHost[i] == tsp) {
803                         if (tvp->status[i] == end_not_busy)
804                             tvp->status[i] = offline;
805                         else
806                             tvp->status[i]++;
807                     } else if (!same) {
808                         tvp->status[i] = not_busy;      /* reset the others */
809                     }
810                 }
811                 afs_PutVolume(tvp, READ_LOCK);
812             }
813         }
814     } else if (acode >= ERROR_TABLE_BASE_VL && acode <= ERROR_TABLE_BASE_VL + 255) {    /* vlserver errors */
815         shouldRetry = 0;
816         areq->volumeError = VOLMISSING;
817     } else if (acode >= 0) {
818         if (aerrP)
819             (aerrP->err_Other)++;
820         if (op == AFS_STATS_FS_RPCIDX_STOREDATA)
821             areq->permWriteError = 1;
822         shouldRetry = 0;        /* Other random Vice error. */
823     } else if (acode == RX_MSGSIZE) {   /* same meaning as EMSGSIZE... */
824         afs_warnuser
825             ("afs: Path MTU may have been exceeded, retrying (server %d.%d.%d.%d)\n",
826              (address >> 24), (address >> 16) & 0xff,
827              (address >> 8) & 0xff, (address) & 0xff);
828
829         VSleep(1);              /* Just a hack for desperate times. */
830         if (aerrP)
831             (aerrP->err_Other)++;
832         shouldRetry = 1;        /* packet was too big, please retry call */
833     }
834
835     if (acode < 0 && acode != RX_MSGSIZE && acode != VRESTARTING) {
836         /* If we get here, code < 0 and we have network/Server troubles.
837          * areq->networkError is not set here, since we always
838          * retry in case there is another server.  However, if we find
839          * no connection (aconn == 0) we set the networkError flag.
840          */
841         afs_ServerDown(sa, acode, rxconn);
842         if (aerrP)
843             (aerrP->err_Server)++;
844         VSleep(1);              /* Just a hack for desperate times. */
845         shouldRetry = 1;
846     }
847 out:
848     /* now unlock the connection and return */
849     afs_PutConn(aconn, rxconn, locktype);
850     return (shouldRetry);
851 }                               /*afs_Analyze */