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_SUN56_ENV)
  40 #include <inet/led.h>
  41 #include <inet/common.h>
  42 #if     defined(AFS_SUN58_ENV)
  43 #include <netinet/ip6.h>
  44 #endif
  45 #include <inet/ip.h>
  46 #endif
  47
  48
  49 /* shouldn't do it this way, but for now will do */
  50 #ifndef ERROR_TABLE_BASE_U
  51 #define ERROR_TABLE_BASE_U      (5376L)
  52 #endif /* ubik error base define */
  53
  54 /* shouldn't do it this way, but for now will do */
  55 #ifndef ERROR_TABLE_BASE_uae
  56 #define ERROR_TABLE_BASE_uae    (49733376L)
  57 #endif /* unified afs error base define */
  58
  59 /* same hack for vlserver error base as for ubik error base */
  60 #ifndef ERROR_TABLE_BASE_VL
  61 #define ERROR_TABLE_BASE_VL     (363520L)
  62 #define VL_NOENT                (363524L)
  63 #endif /* vlserver error base define */
  64
  65
  66 int afs_BusyWaitPeriod = 15;    /* poll every 15 seconds */
  67
  68 afs_int32 hm_retry_RO = 0;      /* don't wait */
  69 afs_int32 hm_retry_RW = 0;      /* don't wait */
  70 afs_int32 hm_retry_int = 0;     /* don't wait */
  71
  72 #define VSleep(at)      afs_osi_Wait((at)*1000, 0, 0)
  73
  74
  75 int lastcode;
  76 /* returns:
  77  * 0   if the vldb record for a specific volume is different from what
  78  *     we have cached -- perhaps the volume has moved.
  79  * 1   if the vldb record is the same
  80  * 2   if we can't tell if it's the same or not.
  81  *
  82  * If 0, the caller will probably start over at the beginning of our
  83  * list of servers for this volume and try to find one that is up.  If
  84  * not 0, we will probably just keep plugging with what we have
  85  * cached.   If we fail to contact the VL server, we  should just keep
  86  * trying with the information we have, rather than failing. */
  87 #define DIFFERENT 0
  88 #define SAME 1
  89 #define DUNNO 2
  90 static int
  91 VLDB_Same(struct VenusFid *afid, struct vrequest *areq)
  92 {
  93     struct vrequest treq;
  94     struct afs_conn *tconn;
  95     int i, type = 0;
  96     union {
  97         struct vldbentry tve;
  98         struct nvldbentry ntve;
  99         struct uvldbentry utve;
 100     } *v;
 101     struct volume *tvp;
 102     struct cell *tcell;
 103     char *bp, tbuf[CVBS];       /* biggest volume id is 2^32, ~ 4*10^9 */
 104     unsigned int changed;
 105     struct server *(oldhosts[NMAXNSERVERS]);
 106
 107     AFS_STATCNT(CheckVLDB);
 108     afs_FinalizeReq(areq);
 109
 110     if ((i = afs_InitReq(&treq, afs_osi_credp)))
 111         return DUNNO;
 112     v = afs_osi_Alloc(sizeof(*v));
 113     osi_Assert(v != NULL);
 114     tcell = afs_GetCell(afid->Cell, READ_LOCK);
 115     bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);
 116     do {
 117         VSleep(2);              /* Better safe than sorry. */
 118         tconn =
 119             afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,
 120                              &treq, SHARED_LOCK);
 121         if (tconn) {
 122             if (tconn->srvr->server->flags & SNO_LHOSTS) {
 123                 type = 0;
 124                 RX_AFS_GUNLOCK();
 125                 i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);
 126                 RX_AFS_GLOCK();
 127             } else if (tconn->srvr->server->flags & SYES_LHOSTS) {
 128                 type = 1;
 129                 RX_AFS_GUNLOCK();
 130                 i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);
 131                 RX_AFS_GLOCK();
 132             } else {
 133                 type = 2;
 134                 RX_AFS_GUNLOCK();
 135                 i = VL_GetEntryByNameU(tconn->id, bp, &v->utve);
 136                 RX_AFS_GLOCK();
 137                 if (!(tconn->srvr->server->flags & SVLSRV_UUID)) {
 138                     if (i == RXGEN_OPCODE) {
 139                         type = 1;
 140                         RX_AFS_GUNLOCK();
 141                         i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);
 142                         RX_AFS_GLOCK();
 143                         if (i == RXGEN_OPCODE) {
 144                             type = 0;
 145                             tconn->srvr->server->flags |= SNO_LHOSTS;
 146                             RX_AFS_GUNLOCK();
 147                             i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);
 148                             RX_AFS_GLOCK();
 149                         } else if (!i)
 150                             tconn->srvr->server->flags |= SYES_LHOSTS;
 151                     } else if (!i)
 152                         tconn->srvr->server->flags |= SVLSRV_UUID;
 153                 }
 154                 lastcode = i;
 155             }
 156         } else
 157             i = -1;
 158     } while (afs_Analyze(tconn, i, NULL, &treq, -1,     /* no op code for this */
 159                          SHARED_LOCK, tcell));
 160
 161     afs_PutCell(tcell, READ_LOCK);
 162     afs_Trace2(afs_iclSetp, CM_TRACE_CHECKVLDB, ICL_TYPE_FID, &afid,
 163                ICL_TYPE_INT32, i);
 164
 165     if (i) {
 166         afs_osi_Free(v, sizeof(*v));
 167         return DUNNO;
 168     }
 169     /* have info, copy into serverHost array */
 170     changed = 0;
 171     tvp = afs_FindVolume(afid, WRITE_LOCK);
 172     if (tvp) {
 173         ObtainWriteLock(&tvp->lock, 107);
 174         for (i = 0; i < NMAXNSERVERS && tvp->serverHost[i]; i++) {
 175             oldhosts[i] = tvp->serverHost[i];
 176         }
 177
 178         if (type == 2) {
 179             InstallUVolumeEntry(tvp, &v->utve, afid->Cell, tcell, &treq);
 180         } else if (type == 1) {
 181             InstallNVolumeEntry(tvp, &v->ntve, afid->Cell);
 182         } else {
 183             InstallVolumeEntry(tvp, &v->tve, afid->Cell);
 184         }
 185
 186         if (i < NMAXNSERVERS && tvp->serverHost[i]) {
 187             changed = 1;
 188         }
 189         for (--i; !changed && i >= 0; i--) {
 190             if (tvp->serverHost[i] != oldhosts[i]) {
 191                 changed = 1;    /* also happens if prefs change.  big deal. */
 192             }
 193         }
 194
 195         ReleaseWriteLock(&tvp->lock);
 196         afs_PutVolume(tvp, WRITE_LOCK);
 197     } else {                    /* can't find volume */
 198         tvp = afs_GetVolume(afid, &treq, WRITE_LOCK);
 199         if (tvp) {
 200             afs_PutVolume(tvp, WRITE_LOCK);
 201             afs_osi_Free(v, sizeof(*v));
 202             return DIFFERENT;
 203         } else {
 204             afs_osi_Free(v, sizeof(*v));
 205             return DUNNO;
 206         }
 207     }
 208
 209     afs_osi_Free(v, sizeof(*v));
 210     return (changed ? DIFFERENT : SAME);
 211 }                               /*VLDB_Same */
 212
 213 /*------------------------------------------------------------------------
 214  * afs_BlackListOnce
 215  *
 216  * Description:
 217  *      Mark a server as invalid for further attempts of this request only.
 218  *
 219  * Arguments:
 220  *      areq  : The request record associated with this operation.
 221  *      afid  : The FID of the file involved in the action.  This argument
 222  *              may be null if none was involved.
 223  *      tsp   : pointer to a server struct for the server we wish to
 224  *              blacklist.
 225  *
 226  * Returns:
 227  *      Non-zero value if further servers are available to try,
 228  *      zero otherwise.
 229  *
 230  * Environment:
 231  *      This routine is typically called in situations where we believe
 232  *      one server out of a pool may have an error condition.
 233  *
 234  * Side Effects:
 235  *      As advertised.
 236  *
 237  * NOTE:
 238  *      The afs_Conn* routines use the list of invalidated servers to
 239  *      avoid reusing a server marked as invalid for this request.
 240  *------------------------------------------------------------------------*/
 241 static afs_int32
 242 afs_BlackListOnce(struct vrequest *areq, struct VenusFid *afid,
 243                   struct server *tsp)
 244 {
 245     struct volume *tvp;
 246     afs_int32 i;
 247     afs_int32 serversleft = 0;
 248
 249     if (afid) {
 250         tvp = afs_FindVolume(afid, READ_LOCK);
 251         if (tvp) {
 252             for (i = 0; i < AFS_MAXHOSTS; i++) {
 253                 if (tvp->serverHost[i] == tsp) {
 254                     areq->skipserver[i] = 1;
 255                 }
 256                 if (tvp->serverHost[i] &&
 257                     (tvp->serverHost[i]->addr->sa_flags &
 258                       SRVR_ISDOWN)) {
 259                     areq->skipserver[i] = 1;
 260                 }
 261             }
 262             afs_PutVolume(tvp, READ_LOCK);
 263             for (i = 0; i < AFS_MAXHOSTS; i++) {
 264                 if (tvp->serverHost[i] && areq->skipserver[i] == 0) {
 265                     serversleft = 1;
 266                     break;
 267                 }
 268             }
 269             return serversleft;
 270         }
 271     }
 272     return serversleft;
 273 }
 274
 275
 276 /*------------------------------------------------------------------------
 277  * EXPORTED afs_Analyze
 278  *
 279  * Description:
 280  *      Analyze the outcome of an RPC operation, taking whatever support
 281  *      actions are necessary.
 282  *
 283  * Arguments:
 284  *      aconn : Ptr to the relevant connection on which the call was made.
 285  *      acode : The return code experienced by the RPC.
 286  *      afid  : The FID of the file involved in the action.  This argument
 287  *              may be null if none was involved.
 288  *      areq  : The request record associated with this operation.
 289  *      op    : which RPC we are analyzing.
 290  *      cellp : pointer to a cell struct.  Must provide either fid or cell.
 291  *
 292  * Returns:
 293  *      Non-zero value if the related RPC operation should be retried,
 294  *      zero otherwise.
 295  *
 296  * Environment:
 297  *      This routine is typically called in a do-while loop, causing the
 298  *      embedded RPC operation to be called repeatedly if appropriate
 299  *      until whatever error condition (if any) is intolerable.
 300  *
 301  * Side Effects:
 302  *      As advertised.
 303  *
 304  * NOTE:
 305  *      The retry return value is used by afs_StoreAllSegments to determine
 306  *      if this is a temporary or permanent error.
 307  *------------------------------------------------------------------------*/
 308 int
 309 afs_Analyze(struct afs_conn *aconn, afs_int32 acode,
 310             struct VenusFid *afid, struct vrequest *areq, int op,
 311             afs_int32 locktype, struct cell *cellp)
 312 {
 313     afs_int32 i;
 314     struct srvAddr *sa;
 315     struct server *tsp;
 316     struct volume *tvp = NULL;
 317     afs_int32 shouldRetry = 0;
 318     afs_int32 serversleft = 1;
 319     struct afs_stats_RPCErrors *aerrP;
 320     afs_int32 markeddown;
 321     afs_uint32 address;
 322
 323     if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
 324         /* On reconnection, act as connected. XXX: for now.... */
 325         /* SXW - This may get very tired after a while. We should try and
 326          *       intercept all RPCs before they get here ... */
 327         /*printf("afs_Analyze: disconnected\n");*/
 328         afs_FinalizeReq(areq);
 329         if (aconn) {
 330             /* SXW - I suspect that this will _never_ happen - we shouldn't
 331              *       get a connection because we're disconnected !!!*/
 332             afs_PutConn(aconn, locktype);
 333         }
 334         return 0;
 335     }
 336
 337     AFS_STATCNT(afs_Analyze);
 338     afs_Trace4(afs_iclSetp, CM_TRACE_ANALYZE, ICL_TYPE_INT32, op,
 339                ICL_TYPE_POINTER, aconn, ICL_TYPE_INT32, acode, ICL_TYPE_LONG,
 340                areq->uid);
 341
 342     aerrP = (struct afs_stats_RPCErrors *)0;
 343
 344     if ((op >= 0) && (op < AFS_STATS_NUM_FS_RPC_OPS))
 345         aerrP = &(afs_stats_cmfullperf.rpc.fsRPCErrors[op]);
 346
 347     afs_FinalizeReq(areq);
 348     if (!aconn && areq->busyCount) {    /* one RPC or more got VBUSY/VRESTARTING */
 349
 350         tvp = afs_FindVolume(afid, READ_LOCK);
 351         if (tvp) {
 352             afs_warnuser("afs: Waiting for busy volume %u (%s) in cell %s\n",
 353                          (afid ? afid->Fid.Volume : 0),
 354                          (tvp->name ? tvp->name : ""),
 355                          ((tvp->serverHost[0]
 356                            && tvp->serverHost[0]->cell) ? tvp->serverHost[0]->
 357                           cell->cellName : ""));
 358
 359             for (i = 0; i < AFS_MAXHOSTS; i++) {
 360                 if (tvp->status[i] != not_busy && tvp->status[i] != offline) {
 361                     tvp->status[i] = not_busy;
 362                 }
 363                 if (tvp->status[i] == not_busy)
 364                     shouldRetry = 1;
 365             }
 366             afs_PutVolume(tvp, READ_LOCK);
 367         } else {
 368             afs_warnuser("afs: Waiting for busy volume %u\n",
 369                          (afid ? afid->Fid.Volume : 0));
 370         }
 371
 372         if (areq->busyCount > 100) {
 373             if (aerrP)
 374                 (aerrP->err_Volume)++;
 375             areq->volumeError = VOLBUSY;
 376             shouldRetry = 0;
 377         } else {
 378             VSleep(afs_BusyWaitPeriod); /* poll periodically */
 379         }
 380         if (shouldRetry != 0)
 381             areq->busyCount++;
 382
 383         return shouldRetry;     /* should retry */
 384     }
 385
 386     if (!aconn || !aconn->srvr) {
 387         if (!areq->volumeError) {
 388             if (aerrP)
 389                 (aerrP->err_Network)++;
 390             if (hm_retry_int && !(areq->flags & O_NONBLOCK) &&  /* "hard" mount */
 391                 ((afid && afs_IsPrimaryCellNum(afid->Cell))
 392                  || (cellp && afs_IsPrimaryCell(cellp)))) {
 393                 if (!afid) {
 394                     afs_warnuser
 395                         ("afs: hard-mount waiting for a vlserver to return to service\n");
 396                     VSleep(hm_retry_int);
 397                     afs_CheckServers(1, cellp);
 398                     shouldRetry = 1;
 399                 } else {
 400                     tvp = afs_FindVolume(afid, READ_LOCK);
 401                     if (!tvp || (tvp->states & VRO)) {
 402                         shouldRetry = hm_retry_RO;
 403                     } else {
 404                         shouldRetry = hm_retry_RW;
 405                     }
 406                     if (tvp)
 407                         afs_PutVolume(tvp, READ_LOCK);
 408                     if (shouldRetry) {
 409                         afs_warnuser
 410                             ("afs: hard-mount waiting for volume %u\n",
 411                              afid->Fid.Volume);
 412                         VSleep(hm_retry_int);
 413                         afs_CheckServers(1, cellp);
 414                     }
 415                 }
 416             } /* if (hm_retry_int ... */
 417             else {
 418                 if (acode == RX_MSGSIZE)
 419                     shouldRetry = 1;
 420                 else
 421                     areq->networkError = 1;
 422             }
 423         }
 424         return shouldRetry;
 425     }
 426
 427     /* Find server associated with this connection. */
 428     sa = aconn->srvr;
 429     tsp = sa->server;
 430     address = ntohl(sa->sa_ip);
 431
 432     /* Before we do anything with acode, make sure we translate it back to
 433      * a system error */
 434     if ((acode & ~0xff) == ERROR_TABLE_BASE_uae)
 435         acode = et_to_sys_error(acode);
 436
 437     if (acode == 0) {
 438         /* If we previously took an error, mark this volume not busy */
 439         if (areq->volumeError) {
 440             tvp = afs_FindVolume(afid, READ_LOCK);
 441             if (tvp) {
 442                 for (i = 0; i < AFS_MAXHOSTS; i++) {
 443                     if (tvp->serverHost[i] == tsp) {
 444                         tvp->status[i] = not_busy;
 445                     }
 446                 }
 447                 afs_PutVolume(tvp, READ_LOCK);
 448             }
 449         }
 450
 451         afs_PutConn(aconn, locktype);
 452         return 0;
 453     }
 454
 455     /* If network troubles, mark server as having bogued out again. */
 456     /* VRESTARTING is < 0 because of backward compatibility issues
 457      * with 3.4 file servers and older cache managers */
 458 #ifdef AFS_64BIT_CLIENT
 459     if (acode == -455)
 460         acode = 455;
 461 #endif /* AFS_64BIT_CLIENT */
 462     if ((acode < 0) && (acode != VRESTARTING)) {
 463         if (acode == RX_MSGSIZE) {
 464             shouldRetry = 1;
 465             goto out;
 466         }
 467         if (acode == RX_CALL_TIMEOUT) {
 468             serversleft = afs_BlackListOnce(areq, afid, tsp);
 469             if (afid)
 470                 tvp = afs_FindVolume(afid, READ_LOCK);
 471             if (!afid || !tvp || (tvp->states & VRO))
 472                 areq->idleError++;
 473             if ((serversleft == 0) && tvp &&
 474                 ((tvp->states & VRO) || (tvp->states & VBackup))) {
 475                 shouldRetry = 0;
 476             } else {
 477                 shouldRetry = 1;
 478             }
 479             if (tvp)
 480                 afs_PutVolume(tvp, READ_LOCK);
 481             /* By doing this, we avoid ever marking a server down
 482              * in an idle timeout case. That's because the server is
 483              * still responding and may only be letting a single vnode
 484              * time out. We otherwise risk having the server continually
 485              * be marked down, then up, then down again...
 486              */
 487             goto out;
 488         }
 489         markeddown = afs_ServerDown(sa);
 490         ForceNewConnections(sa); /**multi homed clients lock:afs_xsrvAddr? */
 491         if (aerrP)
 492             (aerrP->err_Server)++;
 493 #if 0
 494         /* retry *once* when the server is timed out in case of NAT */
 495         if (markeddown && acode == RX_CALL_DEAD) {
 496             aconn->forceConnectFS = 1;
 497             shouldRetry = 1;
 498         }
 499 #endif
 500     }
 501
 502     if (acode == VBUSY || acode == VRESTARTING) {
 503         if (acode == VBUSY) {
 504             areq->busyCount++;
 505             if (aerrP)
 506                 (aerrP->err_VolumeBusies)++;
 507         } else
 508             areq->busyCount = 1;
 509
 510         tvp = afs_FindVolume(afid, READ_LOCK);
 511         if (tvp) {
 512             for (i = 0; i < AFS_MAXHOSTS; i++) {
 513                 if (tvp->serverHost[i] == tsp) {
 514                     tvp->status[i] = rdwr_busy; /* can't tell which yet */
 515                     /* to tell which, have to look at the op code. */
 516                 }
 517             }
 518             afs_PutVolume(tvp, READ_LOCK);
 519         } else {
 520             afs_warnuser("afs: Waiting for busy volume %u in cell %s (server %d.%d.%d.%d)\n",
 521                          (afid ? afid->Fid.Volume : 0), tsp->cell->cellName,
 522                          (address >> 24), (address >> 16) & 0xff,
 523                          (address >> 8) & 0xff, (address) & 0xff);
 524             VSleep(afs_BusyWaitPeriod); /* poll periodically */
 525         }
 526         shouldRetry = 1;
 527         acode = 0;
 528     } else if (acode == VICETOKENDEAD
 529                || (acode & ~0xff) == ERROR_TABLE_BASE_RXK) {
 530         /* any rxkad error is treated as token expiration */
 531         struct unixuser *tu;
 532         /*
 533          * I'm calling these errors protection errors, since they involve
 534          * faulty authentication.
 535          */
 536         if (aerrP)
 537             (aerrP->err_Protection)++;
 538
 539         tu = afs_FindUser(areq->uid, tsp->cell->cellNum, READ_LOCK);
 540         if (tu) {
 541             if (acode == VICETOKENDEAD) {
 542                 aconn->forceConnectFS = 1;
 543             } else if (acode == RXKADEXPIRED) {
 544                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
 545                 aconn->user->states |= UTokensBad;
 546                 afs_NotifyUser(tu, UTokensDropped);
 547                 afs_warnuser
 548                     ("afs: Tokens for user of AFS id %d for cell %s have expired (server %d.%d.%d.%d)\n",
 549                      tu->viceId, aconn->srvr->server->cell->cellName,
 550                      (address >> 24), (address >> 16) & 0xff,
 551                      (address >> 8) & 0xff, (address) & 0xff);
 552             } else {
 553                 serversleft = afs_BlackListOnce(areq, afid, tsp);
 554                 areq->tokenError++;
 555
 556                 if (serversleft) {
 557                     afs_warnuser
 558                         ("afs: Tokens for user of AFS id %d for cell %s: rxkad error=%d (server %d.%d.%d.%d)\n",
 559                          tu->viceId, aconn->srvr->server->cell->cellName, acode,
 560                          (address >> 24), (address >> 16) & 0xff,
 561                          (address >> 8) & 0xff, (address) & 0xff);
 562                     shouldRetry = 1;
 563                 } else {
 564                     areq->tokenError = 0;
 565                     aconn->forceConnectFS = 0;  /* don't check until new tokens set */
 566                     aconn->user->states |= UTokensBad;
 567                     afs_NotifyUser(tu, UTokensDropped);
 568                     afs_warnuser
 569                         ("afs: Tokens for user of AFS id %d for cell %s are discarded (rxkad error=%d, server %d.%d.%d.%d)\n",
 570                          tu->viceId, aconn->srvr->server->cell->cellName, acode,
 571                          (address >> 24), (address >> 16) & 0xff,
 572                          (address >> 8) & 0xff, (address) & 0xff);
 573                 }
 574             }
 575             afs_PutUser(tu, READ_LOCK);
 576         } else {
 577             /* The else case shouldn't be possible and should probably be replaced by a panic? */
 578             if (acode == VICETOKENDEAD) {
 579                 aconn->forceConnectFS = 1;
 580             } else if (acode == RXKADEXPIRED) {
 581                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
 582                 aconn->user->states |= UTokensBad;
 583                 afs_NotifyUser(tu, UTokensDropped);
 584                 afs_warnuser
 585                     ("afs: Tokens for user %d for cell %s have expired (server %d.%d.%d.%d)\n",
 586                      areq->uid, aconn->srvr->server->cell->cellName,
 587                      (address >> 24), (address >> 16) & 0xff,
 588                      (address >> 8) & 0xff, (address) & 0xff);
 589             } else {
 590                 aconn->forceConnectFS = 0;      /* don't check until new tokens set */
 591                 aconn->user->states |= UTokensBad;
 592                 afs_NotifyUser(tu, UTokensDropped);
 593                 afs_warnuser
 594                     ("afs: Tokens for user %d for cell %s are discarded (rxkad error = %d, server %d.%d.%d.%d)\n",
 595                      areq->uid, aconn->srvr->server->cell->cellName, acode,
 596                      (address >> 24), (address >> 16) & 0xff,
 597                      (address >> 8) & 0xff, (address) & 0xff);
 598
 599             }
 600         }
 601         shouldRetry = 1;        /* Try again (as root). */
 602     }
 603     /* Check for access violation. */
 604     else if (acode == EACCES) {
 605         /* should mark access error in non-existent per-user global structure */
 606         if (aerrP)
 607             (aerrP->err_Protection)++;
 608         areq->accessError = 1;
 609         if (op == AFS_STATS_FS_RPCIDX_STOREDATA)
 610             areq->permWriteError = 1;
 611         shouldRetry = 0;
 612     }
 613     /* check for ubik errors; treat them like crashed servers */
 614     else if (acode >= ERROR_TABLE_BASE_U && acode < ERROR_TABLE_BASE_U + 255) {
 615         afs_ServerDown(sa);
 616         if (aerrP)
 617             (aerrP->err_Server)++;
 618         shouldRetry = 1;        /* retryable (maybe one is working) */
 619         VSleep(1);              /* just in case */
 620     }
 621     /* Check for bad volume data base / missing volume. */
 622     else if (acode == VSALVAGE || acode == VOFFLINE || acode == VNOVOL
 623              || acode == VNOSERVICE || acode == VMOVED) {
 624         struct cell *tcell;
 625         int same;
 626
 627         shouldRetry = 1;
 628         areq->volumeError = VOLMISSING;
 629         if (aerrP)
 630             (aerrP->err_Volume)++;
 631         if (afid && (tcell = afs_GetCell(afid->Cell, 0))) {
 632             same = VLDB_Same(afid, areq);
 633             tvp = afs_FindVolume(afid, READ_LOCK);
 634             if (tvp) {
 635                 for (i = 0; i < AFS_MAXHOSTS && tvp->serverHost[i]; i++) {
 636                     if (tvp->serverHost[i] == tsp) {
 637                         if (tvp->status[i] == end_not_busy)
 638                             tvp->status[i] = offline;
 639                         else
 640                             tvp->status[i]++;
 641                     } else if (!same) {
 642                         tvp->status[i] = not_busy;      /* reset the others */
 643                     }
 644                 }
 645                 afs_PutVolume(tvp, READ_LOCK);
 646             }
 647         }
 648     } else if (acode >= ERROR_TABLE_BASE_VL && acode <= ERROR_TABLE_BASE_VL + 255) {    /* vlserver errors */
 649         shouldRetry = 0;
 650         areq->volumeError = VOLMISSING;
 651     } else if (acode >= 0) {
 652         if (aerrP)
 653             (aerrP->err_Other)++;
 654         if (op == AFS_STATS_FS_RPCIDX_STOREDATA)
 655             areq->permWriteError = 1;
 656         shouldRetry = 0;        /* Other random Vice error. */
 657     } else if (acode == RX_MSGSIZE) {   /* same meaning as EMSGSIZE... */
 658         afs_warnuser
 659             ("afs: Path MTU may have been exceeded, retrying (server %d.%d.%d.%d)\n",
 660              (address >> 24), (address >> 16) & 0xff,
 661              (address >> 8) & 0xff, (address) & 0xff);
 662
 663         VSleep(1);              /* Just a hack for desperate times. */
 664         if (aerrP)
 665             (aerrP->err_Other)++;
 666         shouldRetry = 1;        /* packet was too big, please retry call */
 667     }
 668
 669     if (acode < 0 && acode != RX_MSGSIZE && acode != VRESTARTING) {
 670         /* If we get here, code < 0 and we have network/Server troubles.
 671          * areq->networkError is not set here, since we always
 672          * retry in case there is another server.  However, if we find
 673          * no connection (aconn == 0) we set the networkError flag.
 674          */
 675         afs_MarkServerUpOrDown(sa, SRVR_ISDOWN);
 676         if (aerrP)
 677             (aerrP->err_Server)++;
 678         VSleep(1);              /* Just a hack for desperate times. */
 679         shouldRetry = 1;
 680     }
 681 out:
 682     /* now unlock the connection and return */
 683     afs_PutConn(aconn, locktype);
 684     return (shouldRetry);
 685 }                               /*afs_Analyze */