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