src/WINNT/afsd/cm_callback.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 #include <afs/param.h>
  11 #include <afs/afs_args.h>
  12 #include <afs/stds.h>
  13
  14 #include <windows.h>
  15 #include <winsock2.h>
  16 #include <malloc.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19
  20 #include "afsd.h"
  21 #include "smb.h"
  22 #include <osi.h>
  23 #include <rx_pthread.h>
  24
  25 #include <WINNT/syscfg.h>
  26 #include <WINNT/afsreg.h>
  27
  28 /*extern void afsi_log(char *pattern, ...);*/
  29
  30 /* read/write lock for all global storage in this module */
  31 osi_rwlock_t cm_callbackLock;
  32
  33 afs_int32 cm_OfflineROIsValid = 0;
  34
  35 afs_int32 cm_giveUpAllCBs = 0;
  36
  37 #ifdef AFS_FREELANCE_CLIENT
  38 extern osi_mutex_t cm_Freelance_Lock;
  39 #endif
  40
  41 /* count of # of callback breaking messages received by this CM so far.  We use
  42  * this count in determining whether there have been any callback breaks that
  43  * apply to a call that returned a new callback.  If the counter doesn't
  44  * increase during a call, then we know that no callbacks were broken during
  45  * that call, and thus that the callback that was just returned is still valid.
  46  */
  47 long cm_callbackCount;
  48
  49 /* count of number of RPCs potentially returning a callback executing now.
  50  * When this counter hits zero, we can clear out the racing revokes list, since
  51  * at that time, we know that none of the just-executed callback revokes will
  52  * apply to any future call that returns a callback (since the latter hasn't
  53  * even started execution yet).
  54  */
  55 long cm_activeCallbackGrantingCalls;
  56
  57 /* list of callbacks that have been broken recently.  If a call returning a
  58  * callback is executing and a callback revoke runs immediately after it at the
  59  * server, the revoke may end up being processed before the response to the
  60  * original callback granting call.  We detect this by keeping a list of
  61  * callback revokes that have been received since we *started* the callback
  62  * granting call, and discarding any callbacks received for the same file ID,
  63  * even if the callback revoke was received before the callback grant.
  64  */
  65 cm_racingRevokes_t *cm_racingRevokesp;
  66
  67 /* record a (potentially) racing revoke for this file ID; null means for all
  68  * file IDs, and is used by InitCallBackState.
  69  *
  70  * The cancelFlags describe whether we're just discarding callbacks for the same
  71  * file ID, the same volume, or all from the same server.
  72  *
  73  * Called with no locks held.
  74  */
  75 void cm_RecordRacingRevoke(cm_fid_t *fidp, long cancelFlags)
  76 {
  77     cm_racingRevokes_t *rp;
  78
  79     lock_ObtainWrite(&cm_callbackLock);
  80
  81     osi_Log3(afsd_logp, "RecordRacingRevoke Volume %d Flags %lX activeCalls %d",
  82                 fidp ? fidp->volume : 0, cancelFlags, cm_activeCallbackGrantingCalls);
  83
  84     if (cm_activeCallbackGrantingCalls > 0) {
  85         rp = malloc(sizeof(*rp));
  86         memset(rp, 0, sizeof(*rp));
  87         osi_QAdd((osi_queue_t **) &cm_racingRevokesp, &rp->q);
  88         rp->flags |= (cancelFlags & CM_RACINGFLAG_ALL);
  89         if (fidp) rp->fid = *fidp;
  90         rp->callbackCount = ++cm_callbackCount;
  91     }
  92     lock_ReleaseWrite(&cm_callbackLock);
  93 }
  94
  95 /*
  96  * When we lose a callback, may have to send change notification replies.
  97  * Do not call with a lock on the scp.
  98  */
  99 void cm_CallbackNotifyChange(cm_scache_t *scp)
 100 {
 101     DWORD dwDelay = 0;
 102     HKEY  hKey;
 103     DWORD dummyLen;
 104
 105     /* why does this have to query the registry each time? */
 106         if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
 107                       AFSREG_CLT_OPENAFS_SUBKEY,
 108                       0,
 109                       KEY_READ|KEY_QUERY_VALUE,
 110                       &hKey) == ERROR_SUCCESS) {
 111
 112         dummyLen = sizeof(DWORD);
 113         RegQueryValueEx(hKey, "CallBack Notify Change Delay", NULL, NULL,
 114                         (BYTE *) &dwDelay, &dummyLen);
 115         RegCloseKey(hKey);
 116     }
 117
 118     if (dwDelay > 5000)    /* do not allow a delay of more then 5 seconds */
 119         dwDelay = 5000;
 120
 121     osi_Log3(afsd_logp, "CallbackNotifyChange FileType %d Flags %lX Delay %dms",
 122               scp->fileType, scp->flags, dwDelay);
 123
 124     if (dwDelay)
 125         Sleep(dwDelay);
 126
 127     /* for directories, this sends a change notification on the dir itself */
 128     if (scp->fileType == CM_SCACHETYPE_DIRECTORY) {
 129         if (scp->flags & CM_SCACHEFLAG_ANYWATCH)
 130             smb_NotifyChange(0,
 131                              FILE_NOTIFY_GENERIC_DIRECTORY_FILTER,
 132                              scp, NULL, NULL, TRUE);
 133     } else {
 134         /* and for files, this sends a change notification on the file's parent dir */
 135         cm_fid_t tfid;
 136         cm_scache_t *dscp;
 137
 138         cm_SetFid(&tfid, scp->fid.cell, scp->fid.volume, scp->parentVnode, scp->parentUnique);
 139         dscp = cm_FindSCache(&tfid);
 140         if ( dscp &&
 141              dscp->flags & CM_SCACHEFLAG_ANYWATCH )
 142             smb_NotifyChange( 0,
 143                               FILE_NOTIFY_GENERIC_FILE_FILTER,
 144                               dscp, NULL, NULL, TRUE);
 145         if (dscp)
 146             cm_ReleaseSCache(dscp);
 147     }
 148 }
 149
 150 /* called with no locks held for every file ID that is revoked directly by
 151  * a callback revoke call.  Does not have to handle volume callback breaks,
 152  * since those have already been split out.
 153  *
 154  * The callp parameter is currently unused.
 155  */
 156 void cm_RevokeCallback(struct rx_call *callp, cm_cell_t * cellp, AFSFid *fidp)
 157 {
 158     cm_fid_t tfid;
 159     cm_scache_t *scp;
 160     long hash;
 161
 162     /* don't bother setting cell, since we won't be checking it (to aid
 163      * in working with multi-homed servers: we don't know the cell if we
 164      * don't recognize the IP address).
 165      */
 166     tfid.cell = 0;
 167     tfid.volume = fidp->Volume;
 168     tfid.vnode = fidp->Vnode;
 169     tfid.unique = fidp->Unique;
 170     hash = CM_SCACHE_HASH(&tfid);
 171
 172     osi_Log3(afsd_logp, "RevokeCallback vol %u vn %u uniq %u",
 173              fidp->Volume, fidp->Vnode, fidp->Unique);
 174
 175     /* do this first, so that if we're executing a callback granting call
 176      * at this moment, we kill it before it can be merged in.  Otherwise,
 177      * it could complete while we're doing the scan below, and get missed
 178      * by both the scan and by this code.
 179      */
 180     cm_RecordRacingRevoke(&tfid, 0);
 181
 182     lock_ObtainWrite(&cm_scacheLock);
 183     /* do all in the hash bucket, since we don't know how many we'll find with
 184      * varying cells.
 185      */
 186     for (scp = cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
 187         if (scp->fid.volume == tfid.volume &&
 188              scp->fid.vnode == tfid.vnode &&
 189              scp->fid.unique == tfid.unique &&
 190              (cellp == NULL || scp->fid.cell == cellp->cellID) &&
 191              scp->cbExpires > 0 &&
 192              scp->cbServerp != NULL)
 193         {
 194             cm_HoldSCacheNoLock(scp);
 195             lock_ReleaseWrite(&cm_scacheLock);
 196             osi_Log4(afsd_logp, "RevokeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u",
 197                      scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
 198
 199             lock_ObtainWrite(&scp->rw);
 200             cm_DiscardSCache(scp);
 201             lock_ReleaseWrite(&scp->rw);
 202
 203             cm_CallbackNotifyChange(scp);
 204
 205             lock_ObtainWrite(&cm_scacheLock);
 206             cm_ReleaseSCacheNoLock(scp);
 207         }
 208     }
 209     lock_ReleaseWrite(&cm_scacheLock);
 210
 211     osi_Log3(afsd_logp, "RevokeCallback Complete vol %u vn %u uniq %u",
 212              fidp->Volume, fidp->Vnode, fidp->Unique);
 213 }
 214
 215 /* called to revoke a volume callback, which is typically issued when a volume
 216  * is moved from one server to another.
 217  *
 218  * Called with no locks held.
 219  */
 220 void cm_RevokeVolumeCallback(struct rx_call *callp, cm_cell_t *cellp, AFSFid *fidp)
 221 {
 222     unsigned long hash;
 223     cm_scache_t *scp;
 224     cm_fid_t tfid;
 225
 226     osi_Log1(afsd_logp, "RevokeVolumeCallback vol %d", fidp->Volume);
 227
 228     /* do this first, so that if we're executing a callback granting call
 229      * at this moment, we kill it before it can be merged in.  Otherwise,
 230      * it could complete while we're doing the scan below, and get missed
 231      * by both the scan and by this code.
 232      */
 233     tfid.cell = tfid.vnode = tfid.unique = 0;
 234     tfid.volume = fidp->Volume;
 235     cm_RecordRacingRevoke(&tfid, CM_RACINGFLAG_CANCELVOL);
 236
 237     lock_ObtainWrite(&cm_scacheLock);
 238     for (hash = 0; hash < cm_data.scacheHashTableSize; hash++) {
 239         for(scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
 240             if (scp->fid.volume == fidp->Volume &&
 241                 (cellp == NULL || scp->fid.cell == cellp->cellID) &&
 242                  scp->cbExpires > 0 &&
 243                  scp->cbServerp != NULL) {
 244                 cm_HoldSCacheNoLock(scp);
 245                 lock_ReleaseWrite(&cm_scacheLock);
 246
 247                 lock_ObtainWrite(&scp->rw);
 248                 osi_Log4(afsd_logp, "RevokeVolumeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u",
 249                           scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
 250                 cm_DiscardSCache(scp);
 251                 lock_ReleaseWrite(&scp->rw);
 252
 253                 cm_CallbackNotifyChange(scp);
 254                 lock_ObtainWrite(&cm_scacheLock);
 255                 cm_ReleaseSCacheNoLock(scp);
 256                 if (scp->flags & CM_SCACHEFLAG_PURERO) {
 257                     cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
 258                     if (volp) {
 259                         volp->cbExpiresRO = 0;
 260                         cm_PutVolume(volp);
 261                     }
 262                 }
 263             }
 264         }       /* search one hash bucket */
 265     }   /* search all hash buckets */
 266
 267     lock_ReleaseWrite(&cm_scacheLock);
 268
 269     osi_Log1(afsd_logp, "RevokeVolumeCallback Complete vol %d", fidp->Volume);
 270 }
 271
 272 /*
 273  * afs_data_pointer_to_int32() - returns least significant afs_int32 of the
 274  * given data pointer, without triggering "cast truncates pointer"
 275  * warnings.  We use this where we explicitly don't care whether a
 276  * pointer is truncated -- it loses information where a pointer is
 277  * larger than an afs_int32.
 278  */
 279
 280 static afs_int32
 281 afs_data_pointer_to_int32(const void *p)
 282 {
 283     union {
 284         afs_int32 i32[sizeof(void *) / sizeof(afs_int32)];
 285         const void *p;
 286     } ip;
 287
 288     int i32_sub;                /* subscript of least significant afs_int32 in ip.i32[] */
 289
 290     /* set i32_sub */
 291
 292     {
 293         /* used to determine the byte order of the system */
 294
 295         union {
 296             char c[sizeof(int) / sizeof(char)];
 297             int i;
 298         } ci;
 299
 300         ci.i = 1;
 301         if (ci.c[0] == 1) {
 302             /* little-endian system */
 303             i32_sub = 0;
 304         } else {
 305             /* big-endian system */
 306             i32_sub = (sizeof ip.i32 / sizeof ip.i32[0]) - 1;
 307         }
 308     }
 309
 310     ip.p = p;
 311     return ip.i32[i32_sub];
 312 }
 313 /*------------------------------------------------------------------------
 314  * EXPORTED SRXAFSCB_CallBack
 315  *
 316  * Description:
 317  *      Routine called by the server-side callback RPC interface to
 318  *      implement passing in callback information.
 319  *      table.
 320  *
 321  * Arguments:
 322  *      rx_call    : Ptr to Rx call on which this request came in.
 323  *      fidsArrayp : Ptr to array of fids involved.
 324  *      cbsArrayp  : Ptr to matching callback info for the fids.
 325  *
 326  * Returns:
 327  *      0 (always).
 328  *
 329  * Environment:
 330  *      Nothing interesting.
 331  *
 332  * Side Effects:
 333  *      As advertised.
 334  *------------------------------------------------------------------------*/
 335 /* handle incoming RPC callback breaking message.
 336  * Called with no locks held.
 337  */
 338 int
 339 SRXAFSCB_CallBack(struct rx_call *callp, AFSCBFids *fidsArrayp, AFSCBs *cbsArrayp)
 340 {
 341     int i;
 342     AFSFid *tfidp;
 343     struct rx_connection *connp;
 344     struct rx_peer *peerp;
 345     unsigned long host = 0;
 346     unsigned short port = 0;
 347     cm_server_t *tsp = NULL;
 348     cm_cell_t* cellp = NULL;
 349
 350     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 351         host = rx_HostOf(peerp);
 352         port = rx_PortOf(peerp);
 353
 354         tsp = cm_FindServerByIP(host, CM_SERVER_FILE);
 355         if (tsp)
 356             cellp = tsp->cellp;
 357
 358         if (!cellp)
 359             osi_Log2(afsd_logp, "SRXAFSCB_CallBack from host 0x%x port %d",
 360                      ntohl(host),
 361                      ntohs(port));
 362         else
 363             osi_Log3(afsd_logp, "SRXAFSCB_CallBack from host 0x%x port %d for cell %s",
 364                      ntohl(host),
 365                      ntohs(port),
 366                      cellp->name /* does not need to be saved, doesn't change */);
 367     } else {
 368         osi_Log0(afsd_logp, "SRXAFSCB_CallBack from unknown host");
 369     }
 370
 371
 372     for (i=0; i < (long) fidsArrayp->AFSCBFids_len; i++) {
 373         tfidp = &fidsArrayp->AFSCBFids_val[i];
 374
 375         if (tfidp->Volume == 0)
 376             continue;   /* means don't do anything */
 377         else if (tfidp->Vnode == 0)
 378             cm_RevokeVolumeCallback(callp, cellp, tfidp);
 379         else
 380             cm_RevokeCallback(callp, cellp, tfidp);
 381     }
 382     return 0;
 383 }
 384
 385 /*------------------------------------------------------------------------
 386  * EXPORTED SRXAFSCB_InitCallBackState
 387  *
 388  * Description:
 389  *      Routine called by the server-side callback RPC interface to
 390  *      implement clearing all callbacks from this host.
 391  *
 392  * Arguments:
 393  *      rx_call : Ptr to Rx call on which this request came in.
 394  *
 395  * Returns:
 396  *      0 (always).
 397  *
 398  * Environment:
 399  *      Nothing interesting.
 400  *
 401  * Side Effects:
 402  *      As advertised.
 403  *------------------------------------------------------------------------*/
 404 /* called with no locks by RPC system when a server indicates that it has never
 405  * heard from us, or for other reasons has had to discard callbacks from us
 406  * without telling us, e.g. a network partition.
 407  */
 408 int
 409 SRXAFSCB_InitCallBackState(struct rx_call *callp)
 410 {
 411     struct sockaddr_in taddr;
 412     cm_server_t *tsp;
 413     cm_scache_t *scp;
 414     afs_uint32 hash;
 415     int discarded;
 416     struct rx_connection *connp;
 417     struct rx_peer *peerp;
 418     unsigned long host = 0;
 419     unsigned short port = 0;
 420
 421     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 422         host = rx_HostOf(peerp);
 423         port = rx_PortOf(peerp);
 424     }
 425
 426     osi_Log2(afsd_logp, "SRXAFSCB_InitCallBackState from host 0x%x port %d",
 427               ntohl(host),
 428               ntohs(port));
 429
 430     if ((rx_ConnectionOf(callp)) && (rx_PeerOf(rx_ConnectionOf(callp)))) {
 431         taddr.sin_family = AF_INET;
 432         taddr.sin_addr.s_addr = rx_HostOf(rx_PeerOf(rx_ConnectionOf(callp)));
 433
 434         tsp = cm_FindServer(&taddr, CM_SERVER_FILE);
 435
 436         osi_Log1(afsd_logp, "Init Callback State server %x", tsp);
 437
 438         /* record the callback in the racing revokes structure.  This
 439          * shouldn't be necessary, since we shouldn't be making callback
 440          * granting calls while we're going to get an initstate call,
 441          * but there probably are some obscure races, so better safe
 442          * than sorry.
 443          *
 444          * We do this first since we don't hold the cm_scacheLock and vnode
 445          * locks over the entire callback scan operation below.  The
 446          * big loop below is guaranteed to hit any callback already
 447          * processed.  The call to RecordRacingRevoke is guaranteed
 448          * to kill any callback that is currently being returned.
 449          * Anything that sneaks past both must start
 450          * after the call to RecordRacingRevoke.
 451          */
 452         cm_RecordRacingRevoke(NULL, CM_RACINGFLAG_CANCELALL);
 453
 454         /* now search all vnodes looking for guys with this callback, if we
 455          * found it, or guys with any callbacks, if we didn't find the server
 456          * (that's how multihomed machines will appear and how we'll handle
 457          * them, albeit a little inefficiently).  That is, we're discarding all
 458          * callbacks from all hosts if we get an initstate call from an unknown
 459          * host.  Since these calls are rare, and multihomed servers
 460          * are "rare," hopefully this won't be a problem.
 461          */
 462         lock_ObtainWrite(&cm_scacheLock);
 463         for (hash = 0; hash < cm_data.scacheHashTableSize; hash++) {
 464             for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
 465                 cm_HoldSCacheNoLock(scp);
 466                 lock_ReleaseWrite(&cm_scacheLock);
 467                 lock_ObtainWrite(&scp->rw);
 468                 discarded = 0;
 469                 if (scp->cbExpires > 0 && scp->cbServerp != NULL) {
 470                     /* we have a callback, now decide if we should clear it */
 471                     if (scp->cbServerp == tsp || tsp == NULL) {
 472                         osi_Log4(afsd_logp, "InitCallbackState Discarding SCache scp 0x%p vol %u vn %u uniq %u",
 473                                   scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
 474                         cm_DiscardSCache(scp);
 475                         discarded = 1;
 476                     }
 477                 }
 478                 lock_ReleaseWrite(&scp->rw);
 479                 if (discarded)
 480                     cm_CallbackNotifyChange(scp);
 481                 lock_ObtainWrite(&cm_scacheLock);
 482                 cm_ReleaseSCacheNoLock(scp);
 483
 484                 if (discarded && (scp->flags & CM_SCACHEFLAG_PURERO)) {
 485                     cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
 486                     if (volp) {
 487                         if (volp->cbExpiresRO != 0)
 488                             volp->cbExpiresRO = 0;
 489                         cm_PutVolume(volp);
 490                     }
 491                 }
 492
 493             }   /* search one hash bucket */
 494         }       /* search all hash buckets */
 495
 496         lock_ReleaseWrite(&cm_scacheLock);
 497
 498         if (tsp) {
 499             /* reset the No flags on the server */
 500             cm_SetServerNo64Bit(tsp, 0);
 501             cm_SetServerNoInlineBulk(tsp, 0);
 502
 503             /* we're done with the server structure */
 504             cm_PutServer(tsp);
 505         }
 506     }
 507     return 0;
 508 }
 509
 510 /*------------------------------------------------------------------------
 511  * EXPORTED SRXAFSCB_Probe
 512  *
 513  * Description:
 514  *      Routine called by the server-side callback RPC interface to
 515  *      implement ``probing'' the Cache Manager, just making sure it's
 516  *      still there.
 517  *
 518  * Arguments:
 519  *      rx_call : Ptr to Rx call on which this request came in.
 520  *
 521  * Returns:
 522  *      0 (always).
 523  *
 524  * Environment:
 525  *      Nothing interesting.
 526  *
 527  * Side Effects:
 528  *      As advertised.
 529  *------------------------------------------------------------------------*/
 530 int
 531 SRXAFSCB_Probe(struct rx_call *callp)
 532 {
 533     struct rx_connection *connp;
 534     struct rx_peer *peerp;
 535     unsigned long host = 0;
 536     unsigned short port = 0;
 537
 538     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 539         host = rx_HostOf(peerp);
 540         port = rx_PortOf(peerp);
 541     }
 542
 543     osi_Log2(afsd_logp, "SRXAFSCB_Probe from host 0x%x port %d",
 544               ntohl(host),
 545               ntohs(port));
 546
 547     return 0;
 548 }
 549
 550 /*------------------------------------------------------------------------
 551  * EXPORTED SRXAFSCB_GetLock
 552  *
 553  * Description:
 554  *      Routine called by the server-side callback RPC interface to
 555  *      implement pulling out the contents of a lock in the lock
 556  *      table.
 557  *
 558  * Arguments:
 559  *      a_call   : Ptr to Rx call on which this request came in.
 560  *      a_index  : Index of desired lock.
 561  *      a_result : Ptr to a buffer for the given lock.
 562  *
 563  * Returns:
 564  *      0 if everything went fine,
 565  *      1 if we were given a bad index.
 566  *
 567  * Environment:
 568  *      Nothing interesting.
 569  *
 570  * Side Effects:
 571  *      As advertised.
 572  *------------------------------------------------------------------------*/
 573 /* debug interface */
 574
 575 extern osi_rwlock_t cm_aclLock;
 576 extern osi_rwlock_t buf_globalLock;
 577 extern osi_rwlock_t cm_cellLock;
 578 extern osi_rwlock_t cm_connLock;
 579 extern osi_rwlock_t cm_daemonLock;
 580 extern osi_rwlock_t cm_dnlcLock;
 581 extern osi_rwlock_t cm_scacheLock;
 582 extern osi_rwlock_t cm_serverLock;
 583 extern osi_rwlock_t cm_syscfgLock;
 584 extern osi_rwlock_t cm_userLock;
 585 extern osi_rwlock_t cm_utilsLock;
 586 extern osi_rwlock_t cm_volumeLock;
 587 extern osi_rwlock_t smb_globalLock;
 588 extern osi_rwlock_t smb_rctLock;
 589
 590 extern osi_mutex_t cm_Freelance_Lock;
 591 extern osi_mutex_t cm_bufGetMutex;
 592 extern osi_mutex_t cm_Afsdsbmt_Lock;
 593 extern osi_mutex_t tokenEventLock;
 594 extern osi_mutex_t  smb_ListenerLock;
 595 extern osi_mutex_t smb_RawBufLock;
 596 extern osi_mutex_t smb_Dir_Watch_Lock;
 597
 598 #define LOCKTYPE_RW     1
 599 #define LOCKTYPE_MUTEX  2
 600 static struct _ltable {
 601     char *name;
 602     char *addr;
 603     int  type;
 604 } ltable[] = {
 605     {"cm_scacheLock",    (char*)&cm_scacheLock,         LOCKTYPE_RW},
 606     {"buf_globalLock",   (char*)&buf_globalLock,        LOCKTYPE_RW},
 607     {"cm_serverLock",    (char*)&cm_serverLock,         LOCKTYPE_RW},
 608     {"cm_callbackLock",  (char*)&cm_callbackLock,       LOCKTYPE_RW},
 609     {"cm_syscfgLock",    (char*)&cm_syscfgLock,         LOCKTYPE_RW},
 610     {"cm_aclLock",       (char*)&cm_aclLock,            LOCKTYPE_RW},
 611     {"cm_cellLock",      (char*)&cm_cellLock,           LOCKTYPE_RW},
 612     {"cm_connLock",      (char*)&cm_connLock,           LOCKTYPE_RW},
 613     {"cm_userLock",      (char*)&cm_userLock,           LOCKTYPE_RW},
 614     {"cm_volumeLock",    (char*)&cm_volumeLock,         LOCKTYPE_RW},
 615     {"cm_daemonLock",    (char*)&cm_daemonLock,         LOCKTYPE_RW},
 616     {"cm_dnlcLock",      (char*)&cm_dnlcLock,           LOCKTYPE_RW},
 617     {"cm_utilsLock",     (char*)&cm_utilsLock,          LOCKTYPE_RW},
 618     {"smb_globalLock",   (char*)&smb_globalLock,        LOCKTYPE_RW},
 619     {"smb_rctLock",      (char*)&smb_rctLock,           LOCKTYPE_RW},
 620     {"cm_Freelance_Lock",(char*)&cm_Freelance_Lock,     LOCKTYPE_MUTEX},
 621     {"cm_bufGetMutex",   (char*)&cm_bufGetMutex,        LOCKTYPE_MUTEX},
 622     {"cm_Afsdsbmt_Lock", (char*)&cm_Afsdsbmt_Lock,      LOCKTYPE_MUTEX},
 623     {"tokenEventLock",   (char*)&tokenEventLock,        LOCKTYPE_MUTEX},
 624     {"smb_ListenerLock", (char*)&smb_ListenerLock,      LOCKTYPE_MUTEX},
 625     {"smb_RawBufLock",   (char*)&smb_RawBufLock,        LOCKTYPE_MUTEX},
 626     {"smb_Dir_Watch_Lock",(char*)&smb_Dir_Watch_Lock,   LOCKTYPE_MUTEX}
 627 };
 628
 629 int
 630 SRXAFSCB_GetLock(struct rx_call *callp, long index, AFSDBLock *lockp)
 631 {
 632     struct _ltable *tl;          /*Ptr to lock table entry */
 633     osi_rwlock_t  *rwp;
 634     osi_mutex_t   *mtxp;
 635     int nentries;               /*Num entries in table */
 636     int code;                   /*Return code */
 637     struct rx_connection *connp;
 638     struct rx_peer *peerp;
 639     unsigned long host = 0;
 640     unsigned short port = 0;
 641
 642     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 643         host = rx_HostOf(peerp);
 644         port = rx_PortOf(peerp);
 645     }
 646
 647     osi_Log3(afsd_logp, "SRXAFSCB_GetLock(%d) from host 0x%x port %d",
 648              index, ntohl(host), ntohs(port));
 649
 650     nentries = sizeof(ltable) / sizeof(struct _ltable);
 651     if (index < 0 || index >= nentries) {
 652         /*
 653          * Past EOF
 654          */
 655         code = 1;
 656     } else {
 657         /*
 658          * Found it - copy out its contents.
 659          */
 660         tl = &ltable[index];
 661         strncpy(lockp->name, tl->name, sizeof(lockp->name));
 662         lockp->name[sizeof(lockp->name)-1] = '\0';
 663         lockp->lock.waitStates = 0;
 664         switch ( tl->type ) {
 665         case LOCKTYPE_RW:
 666             rwp = (osi_rwlock_t *)tl->addr;
 667             lockp->lock.exclLocked = rwp->flags;
 668             lockp->lock.readersReading = rwp->readers;
 669             lockp->lock.numWaiting = rwp->waiters;
 670             break;
 671         case LOCKTYPE_MUTEX:
 672             mtxp = (osi_mutex_t *)tl->addr;
 673             lockp->lock.exclLocked = mtxp->flags;
 674             lockp->lock.readersReading = 0;
 675             lockp->lock.numWaiting = mtxp->waiters;
 676             break;
 677         }
 678         lockp->lock.pid_last_reader = 0;
 679         lockp->lock.pid_writer = 0;
 680         lockp->lock.src_indicator = 0;
 681         code = 0;
 682     }
 683
 684     return code;
 685 }
 686
 687 /* debug interface */
 688 int
 689 SRXAFSCB_GetCE(struct rx_call *callp, long index, AFSDBCacheEntry *cep)
 690 {
 691     afs_uint32 i;
 692     cm_scache_t * scp;
 693     int code;
 694     struct rx_connection *connp;
 695     struct rx_peer *peerp;
 696     unsigned long host = 0;
 697     unsigned short port = 0;
 698
 699     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 700         host = rx_HostOf(peerp);
 701         port = rx_PortOf(peerp);
 702     }
 703
 704     osi_Log2(afsd_logp, "SRXAFSCB_GetCE from host 0x%x port %d",
 705              ntohl(host), ntohs(port));
 706
 707     lock_ObtainRead(&cm_scacheLock);
 708     for (i = 0; i < cm_data.scacheHashTableSize; i++) {
 709         for (scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp) {
 710             if (index == 0)
 711                 goto searchDone;
 712             index--;
 713         }                       /*Zip through current hash chain */
 714     }                           /*Zip through hash chains */
 715
 716   searchDone:
 717     if (scp == NULL) {
 718         /*Past EOF */
 719         code = 1;
 720         goto fcnDone;
 721     }
 722
 723     /*
 724      * Copy out the located entry.
 725      */
 726     memset(cep, 0, sizeof(AFSDBCacheEntry));
 727     cep->addr = afs_data_pointer_to_int32(scp);
 728     cep->cell = scp->fid.cell;
 729     cep->netFid.Volume = scp->fid.volume;
 730     cep->netFid.Vnode = scp->fid.vnode;
 731     cep->netFid.Unique = scp->fid.unique;
 732     cep->lock.waitStates = 0;
 733     cep->lock.exclLocked = scp->rw.flags;
 734     cep->lock.readersReading = 0;
 735     cep->lock.numWaiting = scp->rw.waiters;
 736     cep->lock.pid_last_reader = 0;
 737     cep->lock.pid_writer = 0;
 738     cep->lock.src_indicator = 0;
 739     cep->Length = scp->length.LowPart;
 740     cep->DataVersion = (afs_uint32)(scp->dataVersion & 0xFFFFFFFF);
 741     cep->callback = afs_data_pointer_to_int32(scp->cbServerp);
 742     if (scp->flags & CM_SCACHEFLAG_PURERO) {
 743         cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
 744         if (volp) {
 745             cep->cbExpires = volp->cbExpiresRO;
 746             cm_PutVolume(volp);
 747         }
 748     } else {
 749         /* TODO: deal with time_t below */
 750         cep->cbExpires = (afs_int32) scp->cbExpires;
 751     }
 752     cep->refCount = scp->refCount;
 753     cep->opens = scp->openReads;
 754     cep->writers = scp->openWrites;
 755     switch (scp->fileType) {
 756     case CM_SCACHETYPE_FILE:
 757         cep->mvstat = 0;
 758         break;
 759     case CM_SCACHETYPE_MOUNTPOINT:
 760         cep->mvstat = 1;
 761         break;
 762     case CM_SCACHETYPE_DIRECTORY:
 763         if (scp->fid.vnode == 1 && scp->fid.unique == 1)
 764             cep->mvstat = 2;
 765         else
 766             cep->mvstat = 3;
 767         break;
 768     case CM_SCACHETYPE_SYMLINK:
 769         cep->mvstat = 4;
 770         break;
 771     case CM_SCACHETYPE_DFSLINK:
 772         cep->mvstat = 5;
 773         break;
 774     case CM_SCACHETYPE_INVALID:
 775         cep->mvstat = 6;
 776         break;
 777     }
 778     cep->states = 0;
 779     if (scp->flags & CM_SCACHEFLAG_STATD)
 780         cep->states |= 1;
 781     if (scp->flags & CM_SCACHEFLAG_RO || scp->flags & CM_SCACHEFLAG_PURERO)
 782         cep->states |= 4;
 783     if (scp->fileType == CM_SCACHETYPE_MOUNTPOINT &&
 784         scp->mountPointStringp[0])
 785         cep->states |= 8;
 786     if (scp->flags & CM_SCACHEFLAG_WAITING)
 787         cep->states |= 0x40;
 788     code = 0;
 789
 790     /*
 791      * Return our results.
 792      */
 793   fcnDone:
 794     lock_ReleaseRead(&cm_scacheLock);
 795
 796     return (code);
 797 }
 798
 799 /* debug interface */
 800 int
 801 SRXAFSCB_GetCE64(struct rx_call *callp, long index, AFSDBCacheEntry64 *cep)
 802 {
 803     afs_uint32 i;
 804     cm_scache_t * scp;
 805     int code;
 806     struct rx_connection *connp;
 807     struct rx_peer *peerp;
 808     unsigned long host = 0;
 809     unsigned short port = 0;
 810
 811     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 812         host = rx_HostOf(peerp);
 813         port = rx_PortOf(peerp);
 814     }
 815
 816     osi_Log2(afsd_logp, "SRXAFSCB_GetCE64 from host 0x%x port %d",
 817              ntohl(host), ntohs(port));
 818
 819     lock_ObtainRead(&cm_scacheLock);
 820     for (i = 0; i < cm_data.scacheHashTableSize; i++) {
 821         for (scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp) {
 822             if (index == 0)
 823                 goto searchDone;
 824             index--;
 825         }                       /*Zip through current hash chain */
 826     }                           /*Zip through hash chains */
 827
 828   searchDone:
 829     if (scp == NULL) {
 830         /*Past EOF */
 831         code = 1;
 832         goto fcnDone;
 833     }
 834
 835     /*
 836      * Copy out the located entry.
 837      */
 838     memset(cep, 0, sizeof(AFSDBCacheEntry64));
 839     cep->addr = afs_data_pointer_to_int32(scp);
 840     cep->cell = scp->fid.cell;
 841     cep->netFid.Volume = scp->fid.volume;
 842     cep->netFid.Vnode = scp->fid.vnode;
 843     cep->netFid.Unique = scp->fid.unique;
 844     cep->lock.waitStates = 0;
 845     cep->lock.exclLocked = scp->rw.flags;
 846     cep->lock.readersReading = 0;
 847     cep->lock.numWaiting = scp->rw.waiters;
 848     cep->lock.pid_last_reader = 0;
 849     cep->lock.pid_writer = 0;
 850     cep->lock.src_indicator = 0;
 851 #if !defined(AFS_64BIT_ENV)
 852     cep->Length.high = scp->length.HighPart;
 853     cep->Length.low = scp->length.LowPart;
 854 #else
 855     cep->Length = (afs_int64) scp->length.QuadPart;
 856 #endif
 857     cep->DataVersion = (afs_uint32)(scp->dataVersion & 0xFFFFFFFF);
 858     cep->callback = afs_data_pointer_to_int32(scp->cbServerp);
 859     if (scp->flags & CM_SCACHEFLAG_PURERO) {
 860         cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
 861         if (volp) {
 862             cep->cbExpires = volp->cbExpiresRO;
 863             cm_PutVolume(volp);
 864         }
 865     } else {
 866         /* TODO: handle time_t */
 867         cep->cbExpires = (afs_int32) scp->cbExpires;
 868     }
 869     cep->refCount = scp->refCount;
 870     cep->opens = scp->openReads;
 871     cep->writers = scp->openWrites;
 872     switch (scp->fileType) {
 873     case CM_SCACHETYPE_FILE:
 874         cep->mvstat = 0;
 875         break;
 876     case CM_SCACHETYPE_MOUNTPOINT:
 877         cep->mvstat = 1;
 878         break;
 879     case CM_SCACHETYPE_DIRECTORY:
 880         if (scp->fid.vnode == 1 && scp->fid.unique == 1)
 881             cep->mvstat = 2;
 882         else
 883             cep->mvstat = 3;
 884         break;
 885     case CM_SCACHETYPE_SYMLINK:
 886         cep->mvstat = 4;
 887         break;
 888     case CM_SCACHETYPE_DFSLINK:
 889         cep->mvstat = 5;
 890         break;
 891     case CM_SCACHETYPE_INVALID:
 892         cep->mvstat = 6;
 893         break;
 894     }
 895     cep->states = 0;
 896     if (scp->flags & CM_SCACHEFLAG_STATD)
 897         cep->states |= 1;
 898     if (scp->flags & CM_SCACHEFLAG_RO || scp->flags & CM_SCACHEFLAG_PURERO)
 899         cep->states |= 4;
 900     if (scp->fileType == CM_SCACHETYPE_MOUNTPOINT &&
 901         scp->mountPointStringp[0])
 902         cep->states |= 8;
 903     if (scp->flags & CM_SCACHEFLAG_WAITING)
 904         cep->states |= 0x40;
 905     code = 0;
 906
 907     /*
 908      * Return our results.
 909      */
 910   fcnDone:
 911     lock_ReleaseRead(&cm_scacheLock);
 912
 913     return (code);
 914 }
 915
 916 /* debug interface: not implemented */
 917 int
 918 SRXAFSCB_XStatsVersion(struct rx_call *callp, long *vp)
 919 {
 920     struct rx_connection *connp;
 921     struct rx_peer *peerp;
 922     unsigned long host = 0;
 923     unsigned short port = 0;
 924
 925     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 926         host = rx_HostOf(peerp);
 927         port = rx_PortOf(peerp);
 928     }
 929
 930     osi_Log2(afsd_logp, "SRXAFSCB_XStatsVersion from host 0x%x port %d - not implemented",
 931              ntohl(host), ntohs(port));
 932     *vp = -1;
 933
 934     return RXGEN_OPCODE;
 935 }
 936
 937 /* debug interface: not implemented */
 938 int
 939 SRXAFSCB_GetXStats(struct rx_call *callp, long cvn, long coln, long *srvp, long *timep,
 940                    AFSCB_CollData *datap)
 941 {
 942     struct rx_connection *connp;
 943     struct rx_peer *peerp;
 944     unsigned long host = 0;
 945     unsigned short port = 0;
 946
 947     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 948         host = rx_HostOf(peerp);
 949         port = rx_PortOf(peerp);
 950     }
 951
 952     osi_Log2(afsd_logp, "SRXAFSCB_GetXStats from host 0x%x port %d - not implemented",
 953              ntohl(host), ntohs(port));
 954
 955     return RXGEN_OPCODE;
 956 }
 957
 958 int
 959 SRXAFSCB_InitCallBackState2(struct rx_call *callp, struct interfaceAddr* addr)
 960 {
 961     osi_Log0(afsd_logp, "SRXAFSCB_InitCallBackState2 ->");
 962
 963     return SRXAFSCB_InitCallBackState(callp);
 964 }
 965
 966 /* debug interface */
 967 int
 968 SRXAFSCB_WhoAreYou(struct rx_call *callp, struct interfaceAddr* addr)
 969 {
 970     int i;
 971     long code;
 972     struct rx_connection *connp;
 973     struct rx_peer *peerp;
 974     unsigned long host = 0;
 975     unsigned short port = 0;
 976
 977     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
 978         host = rx_HostOf(peerp);
 979         port = rx_PortOf(peerp);
 980     }
 981
 982     osi_Log2(afsd_logp, "SRXAFSCB_WhoAreYou from host 0x%x port %d",
 983               ntohl(host),
 984               ntohs(port));
 985
 986     lock_ObtainRead(&cm_syscfgLock);
 987     if (cm_LanAdapterChangeDetected) {
 988         lock_ConvertRToW(&cm_syscfgLock);
 989         if (cm_LanAdapterChangeDetected) {
 990             /* get network related info */
 991             cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 992             code = syscfg_GetIFInfo(&cm_noIPAddr,
 993                                      cm_IPAddr, cm_SubnetMask,
 994                                      cm_NetMtu, cm_NetFlags);
 995             cm_LanAdapterChangeDetected = 0;
 996         }
 997         lock_ConvertWToR(&cm_syscfgLock);
 998     }
 999
1000     /* return all network interface addresses */
1001     addr->numberOfInterfaces = cm_noIPAddr;
1002     addr->uuid = cm_data.Uuid;
1003     for ( i=0; i < cm_noIPAddr; i++ ) {
1004         addr->addr_in[i] = cm_IPAddr[i];
1005         addr->subnetmask[i] = cm_SubnetMask[i];
1006         addr->mtu[i] = (rx_mtu == -1 || (rx_mtu != -1 && cm_NetMtu[i] < rx_mtu)) ?
1007             cm_NetMtu[i] : rx_mtu;
1008     }
1009
1010     lock_ReleaseRead(&cm_syscfgLock);
1011
1012     return 0;
1013 }
1014
1015 int
1016 SRXAFSCB_InitCallBackState3(struct rx_call *callp, afsUUID* serverUuid)
1017 {
1018     char *p = NULL;
1019
1020     if (UuidToString((UUID *)serverUuid, &p) == RPC_S_OK) {
1021         osi_Log1(afsd_logp, "SRXAFSCB_InitCallBackState3 %s ->",osi_LogSaveString(afsd_logp,p));
1022         RpcStringFree(&p);
1023     } else
1024         osi_Log0(afsd_logp, "SRXAFSCB_InitCallBackState3 - no server Uuid ->");
1025
1026     return SRXAFSCB_InitCallBackState(callp);
1027 }
1028
1029 /* debug interface */
1030 int
1031 SRXAFSCB_ProbeUuid(struct rx_call *callp, afsUUID* clientUuid)
1032 {
1033     struct rx_connection *connp;
1034     struct rx_peer *peerp;
1035     unsigned long host = 0;
1036     unsigned short port = 0;
1037     char *p,*q;
1038     int code = 0;
1039
1040     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1041         host = rx_HostOf(peerp);
1042         port = rx_PortOf(peerp);
1043     }
1044
1045     if ( !afs_uuid_equal(&cm_data.Uuid, clientUuid) ) {
1046         UuidToString((UUID *)&cm_data.Uuid, &p);
1047         UuidToString((UUID *)clientUuid, &q);
1048         osi_Log4(afsd_logp, "SRXAFSCB_ProbeUuid %s != %s from host 0x%x port %d",
1049                   osi_LogSaveString(afsd_logp,p),
1050                   osi_LogSaveString(afsd_logp,q),
1051                   ntohl(host),
1052                   ntohs(port));
1053         RpcStringFree(&p);
1054         RpcStringFree(&q);
1055
1056         code = 1;       /* failure */
1057     } else
1058         osi_Log2(afsd_logp, "SRXAFSCB_ProbeUuid (success) from host 0x%x port %d",
1059                   ntohl(host),
1060                   ntohs(port));
1061
1062     return code;
1063 }
1064
1065 /* debug interface */
1066 static int
1067 GetCellCommon(afs_int32 a_cellnum, char **a_name, serverList *a_hosts)
1068 {
1069     afs_int32 sn;
1070     cm_cell_t * cellp;
1071     cm_serverRef_t * serverRefp;
1072
1073     cellp = cm_FindCellByID(a_cellnum, CM_FLAG_NOPROBE);
1074     if (!cellp) {
1075         *a_name = strdup("");
1076         return 0;
1077     }
1078
1079     lock_ObtainRead(&cm_serverLock);
1080     *a_name = strdup(cellp->name);
1081
1082     for ( sn = 0, serverRefp = cellp->vlServersp;
1083           sn < AFSMAXCELLHOSTS && serverRefp;
1084           sn++, serverRefp = serverRefp->next);
1085
1086     a_hosts->serverList_len = sn;
1087     a_hosts->serverList_val = (afs_int32 *)osi_Alloc(sn * sizeof(afs_int32));
1088
1089     for ( sn = 0, serverRefp = cellp->vlServersp;
1090           sn < AFSMAXCELLHOSTS && serverRefp;
1091           sn++, serverRefp = serverRefp->next)
1092     {
1093         a_hosts->serverList_val[sn] = ntohl(serverRefp->server->addr.sin_addr.s_addr);
1094     }
1095
1096     lock_ReleaseRead(&cm_serverLock);
1097     return 0;
1098 }
1099
1100 /* debug interface */
1101 int
1102 SRXAFSCB_GetCellByNum(struct rx_call *callp, afs_int32 a_cellnum,
1103                       char **a_name, serverList *a_hosts)
1104 {
1105     struct rx_connection *connp;
1106     struct rx_peer *peerp;
1107     unsigned long host = 0;
1108     unsigned short port = 0;
1109     int rc;
1110
1111     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1112         host = rx_HostOf(peerp);
1113         port = rx_PortOf(peerp);
1114     }
1115
1116     osi_Log3(afsd_logp, "SRXAFSCB_GetCellByNum(%d) from host 0x%x port %d",
1117              a_cellnum, ntohl(host), ntohs(port));
1118
1119     a_hosts->serverList_val = 0;
1120     a_hosts->serverList_len = 0;
1121
1122
1123     rc = GetCellCommon(a_cellnum, a_name, a_hosts);
1124
1125     return rc;
1126 }
1127
1128 /* debug interface */
1129 int
1130 SRXAFSCB_TellMeAboutYourself( struct rx_call *callp,
1131                               struct interfaceAddr *addr,
1132                               Capabilities * capabilities)
1133 {
1134     int i;
1135     afs_int32 *dataBuffP;
1136     afs_int32 dataBytes;
1137     long code;
1138     struct rx_connection *connp;
1139     struct rx_peer *peerp;
1140     unsigned long host = 0;
1141     unsigned short port = 0;
1142
1143     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1144         host = rx_HostOf(peerp);
1145         port = rx_PortOf(peerp);
1146     }
1147
1148     osi_Log2(afsd_logp, "SRXAFSCB_TellMeAboutYourself from host 0x%x port %d",
1149               ntohl(host),
1150               ntohs(port));
1151
1152     lock_ObtainRead(&cm_syscfgLock);
1153     if (cm_LanAdapterChangeDetected) {
1154         lock_ConvertRToW(&cm_syscfgLock);
1155         if (cm_LanAdapterChangeDetected) {
1156             /* get network related info */
1157             cm_noIPAddr = CM_MAXINTERFACE_ADDR;
1158             code = syscfg_GetIFInfo(&cm_noIPAddr,
1159                                      cm_IPAddr, cm_SubnetMask,
1160                                      cm_NetMtu, cm_NetFlags);
1161             cm_LanAdapterChangeDetected = 0;
1162         }
1163         lock_ConvertWToR(&cm_syscfgLock);
1164     }
1165
1166     /* return all network interface addresses */
1167     addr->numberOfInterfaces = cm_noIPAddr;
1168     addr->uuid = cm_data.Uuid;
1169     for ( i=0; i < cm_noIPAddr; i++ ) {
1170         addr->addr_in[i] = cm_IPAddr[i];
1171         addr->subnetmask[i] = cm_SubnetMask[i];
1172         addr->mtu[i] = (rx_mtu == -1 || (rx_mtu != -1 && cm_NetMtu[i] < rx_mtu)) ?
1173             cm_NetMtu[i] : rx_mtu;
1174     }
1175     lock_ReleaseRead(&cm_syscfgLock);
1176
1177     dataBytes = 1 * sizeof(afs_int32);
1178     dataBuffP = (afs_int32 *) osi_Alloc(dataBytes);
1179     dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
1180     capabilities->Capabilities_len = dataBytes / sizeof(afs_int32);
1181     capabilities->Capabilities_val = dataBuffP;
1182
1183     return 0;
1184 }
1185
1186 /*------------------------------------------------------------------------
1187  * EXPORTED SRXAFSCB_GetServerPrefs
1188  *
1189  * Description:
1190  *      Routine to list server preferences used by this client.
1191  *
1192  * Arguments:
1193  *      a_call  : Ptr to Rx call on which this request came in.
1194  *      a_index : Input server index
1195  *      a_srvr_addr  : Output server address (0xffffffff on last server)
1196  *      a_srvr_rank  : Output server rank
1197  *
1198  * Returns:
1199  *      0 on success
1200  *
1201  * Environment:
1202  *      Nothing interesting.
1203  *
1204  * Side Effects:
1205  *      As advertised.
1206  *------------------------------------------------------------------------*/
1207
1208 int SRXAFSCB_GetServerPrefs(
1209     struct rx_call *callp,
1210     afs_int32 a_index,
1211     afs_int32 *a_srvr_addr,
1212     afs_int32 *a_srvr_rank)
1213 {
1214     struct rx_connection *connp;
1215     struct rx_peer *peerp;
1216     unsigned long host = 0;
1217     unsigned short port = 0;
1218
1219     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1220         host = rx_HostOf(peerp);
1221         port = rx_PortOf(peerp);
1222     }
1223
1224     osi_Log2(afsd_logp, "SRXAFSCB_GetServerPrefs from host 0x%x port %d - not implemented",
1225               ntohl(host),
1226               ntohs(port));
1227
1228     *a_srvr_addr = 0xffffffff;
1229     *a_srvr_rank = 0xffffffff;
1230
1231     return 0;
1232 }
1233
1234 /*------------------------------------------------------------------------
1235  * EXPORTED SRXAFSCB_GetCellServDB
1236  *
1237  * Description:
1238  *      Routine to list cells configured for this client
1239  *
1240  * Arguments:
1241  *      a_call  : Ptr to Rx call on which this request came in.
1242  *      a_index : Input cell index
1243  *      a_name  : Output cell name ("" on last cell)
1244  *      a_hosts : Output cell database servers
1245  *
1246  * Returns:
1247  *      0 on success
1248  *
1249  * Environment:
1250  *      Nothing interesting.
1251  *
1252  * Side Effects:
1253  *      As advertised.
1254  *------------------------------------------------------------------------*/
1255
1256 int SRXAFSCB_GetCellServDB(struct rx_call *callp, afs_int32 index, char **a_name,
1257                            serverList *a_hosts)
1258 {
1259     struct rx_connection *connp;
1260     struct rx_peer *peerp;
1261     unsigned long host = 0;
1262     unsigned short port = 0;
1263     int rc;
1264
1265     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1266         host = rx_HostOf(peerp);
1267         port = rx_PortOf(peerp);
1268     }
1269
1270     osi_Log2(afsd_logp, "SRXAFSCB_GetCellServDB from host 0x%x port %d - not implemented",
1271              ntohl(host), ntohs(port));
1272
1273 #ifdef AFS_FREELANCE_CLIENT
1274     if (cm_freelanceEnabled && index == 0) {
1275         rc = GetCellCommon(AFS_FAKE_ROOT_CELL_ID, a_name, a_hosts);
1276     } else
1277 #endif
1278     {
1279         rc = GetCellCommon(index+1, a_name, a_hosts);
1280     }
1281     return 0;
1282 }
1283
1284 /*------------------------------------------------------------------------
1285  * EXPORTED SRXAFSCB_GetLocalCell
1286  *
1287  * Description:
1288  *      Routine to return name of client's local cell
1289  *
1290  * Arguments:
1291  *      a_call  : Ptr to Rx call on which this request came in.
1292  *      a_name  : Output cell name
1293  *
1294  * Returns:
1295  *      0 on success
1296  *
1297  * Environment:
1298  *      Nothing interesting.
1299  *
1300  * Side Effects:
1301  *      As advertised.
1302  *------------------------------------------------------------------------*/
1303
1304 int SRXAFSCB_GetLocalCell(struct rx_call *callp, char **a_name)
1305 {
1306     char *t_name;
1307     struct rx_connection *connp;
1308     struct rx_peer *peerp;
1309     unsigned long host = 0;
1310     unsigned short port = 0;
1311
1312     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1313         host = rx_HostOf(peerp);
1314         port = rx_PortOf(peerp);
1315     }
1316
1317     osi_Log2(afsd_logp, "SRXAFSCB_GetLocalCell from host 0x%x port %d",
1318              ntohl(host), ntohs(port));
1319
1320     if (cm_data.rootCellp) {
1321         t_name = strdup(cm_data.rootCellp->name);
1322     } else {
1323         t_name = (char *)malloc(1);
1324         t_name[0] = '\0';
1325     }
1326     *a_name = t_name;
1327
1328     return 0;
1329 }
1330
1331
1332 /*
1333  * afs_MarshallCacheConfig - marshall client cache configuration
1334  *
1335  * PARAMETERS
1336  *
1337  * IN callerVersion - the rpc stat version of the caller.
1338  *
1339  * IN config - client cache configuration.
1340  *
1341  * OUT ptr - buffer where configuration is marshalled.
1342  *
1343  * RETURN CODES
1344  *
1345  * Returns void.
1346  */
1347 static void afs_MarshallCacheConfig(
1348     afs_uint32 callerVersion,
1349     cm_initparams_v1 *config,
1350     afs_uint32 *ptr)
1351 {
1352     /*
1353      * We currently only support version 1.
1354      */
1355     *(ptr++) = config->nChunkFiles;
1356     *(ptr++) = config->nStatCaches;
1357     *(ptr++) = config->nDataCaches;
1358     *(ptr++) = config->nVolumeCaches;
1359     *(ptr++) = config->firstChunkSize;
1360     *(ptr++) = config->otherChunkSize;
1361     *(ptr++) = config->cacheSize;
1362     *(ptr++) = config->setTime;
1363     *(ptr++) = config->memCache;
1364
1365 }
1366
1367
1368 /*------------------------------------------------------------------------
1369  * EXPORTED SRXAFSCB_GetCacheConfig
1370  *
1371  * Description:
1372  *      Routine to return parameters used to initialize client cache.
1373  *      Client may request any format version. Server may not return
1374  *      format version greater than version requested by client.
1375  *
1376  * Arguments:
1377  *      a_call:        Ptr to Rx call on which this request came in.
1378  *      callerVersion: Data format version desired by the client.
1379  *      serverVersion: Data format version of output data.
1380  *      configCount:   Number bytes allocated for output data.
1381  *      config:        Client cache configuration.
1382  *
1383  * Returns:
1384  *      0 on success
1385  *
1386  * Environment:
1387  *      Nothing interesting.
1388  *
1389  * Side Effects:
1390  *      As advertised.
1391  *------------------------------------------------------------------------*/
1392
1393 int SRXAFSCB_GetCacheConfig(struct rx_call *callp,
1394                             afs_uint32 callerVersion,
1395                             afs_uint32 *serverVersion,
1396                             afs_uint32 *configCount,
1397                             cacheConfig *config)
1398 {
1399     afs_uint32 *t_config;
1400     size_t allocsize;
1401     extern cm_initparams_v1 cm_initParams;
1402     struct rx_connection *connp;
1403     struct rx_peer *peerp;
1404     unsigned long host = 0;
1405     unsigned short port = 0;
1406
1407     if ((connp = rx_ConnectionOf(callp)) && (peerp = rx_PeerOf(connp))) {
1408         host = rx_HostOf(peerp);
1409         port = rx_PortOf(peerp);
1410     }
1411
1412     osi_Log2(afsd_logp, "SRXAFSCB_GetCacheConfig from host 0x%x port %d - version 1 only",
1413              ntohl(host), ntohs(port));
1414
1415     /*
1416      * Currently only support version 1
1417      */
1418     allocsize = sizeof(cm_initparams_v1);
1419     t_config = (afs_uint32 *)malloc(allocsize);
1420
1421     afs_MarshallCacheConfig(callerVersion, &cm_initParams, t_config);
1422
1423     *serverVersion = AFS_CLIENT_RETRIEVAL_FIRST_EDITION;
1424 #ifdef DEBUG
1425 #ifndef SIZE_MAX
1426 #define SIZE_MAX UINT_MAX
1427 #endif
1428     osi_assertx(allocsize < SIZE_MAX, "allocsize >= SIZE_MAX");
1429 #endif
1430     *configCount = (afs_uint32)allocsize;
1431     config->cacheConfig_val = t_config;
1432     config->cacheConfig_len = (*configCount)/sizeof(afs_uint32);
1433
1434     return 0;
1435 }
1436
1437 /* called by afsd without any locks to initialize this module */
1438 void cm_InitCallback(void)
1439 {
1440     lock_InitializeRWLock(&cm_callbackLock, "cm_callbackLock");
1441     cm_activeCallbackGrantingCalls = 0;
1442 }
1443
1444 /* called with locked scp; tells us whether we've got a callback.
1445  * Expirations are checked by a background daemon so as to make
1446  * this function as inexpensive as possible
1447  */
1448 int cm_HaveCallback(cm_scache_t *scp)
1449 {
1450 #ifdef AFS_FREELANCE_CLIENT
1451     // yj: we handle callbacks specially for callbacks on the root directory
1452     // Since it's local, we almost always say that we have callback on it
1453     // The only time we send back a 0 is if we're need to initialize or
1454     // reinitialize the fake directory
1455
1456     // There are 2 state variables cm_fakeGettingCallback and cm_fakeDirCallback
1457     // cm_fakeGettingCallback is 1 if we're in the process of initialization and
1458     // hence should return false. it's 0 otherwise
1459     // cm_fakeDirCallback is 0 if we haven't loaded the fake directory, it's 1
1460     // if the fake directory is loaded and this is the first time cm_HaveCallback
1461     // is called since then. We return false in this case to allow cm_GetCallback
1462     // to be called because cm_GetCallback has some initialization work to do.
1463     // If cm_fakeDirCallback is 2, then it means that the fake directory is in
1464     // good shape and we simply return true, provided no change is detected.
1465     int fdc, fgc;
1466
1467     if (cm_freelanceEnabled &&
1468          scp->fid.cell==AFS_FAKE_ROOT_CELL_ID && scp->fid.volume==AFS_FAKE_ROOT_VOL_ID) {
1469         lock_ObtainMutex(&cm_Freelance_Lock);
1470         fdc = cm_fakeDirCallback;
1471         fgc = cm_fakeGettingCallback;
1472         lock_ReleaseMutex(&cm_Freelance_Lock);
1473
1474         if (fdc==1) {   // first call since init
1475             return 0;
1476         } else if (fdc==2 && !fgc) {    // we're in good shape
1477             if (cm_getLocalMountPointChange()) {        // check for changes
1478                 cm_clearLocalMountPointChange(); // clear the changefile
1479                 lock_ReleaseWrite(&scp->rw);      // this is re-locked in reInitLocalMountPoints
1480                 cm_reInitLocalMountPoints();    // start reinit
1481                 lock_ObtainWrite(&scp->rw);      // now get the lock back
1482                 return 0;
1483             }
1484             return 1;                   // no change
1485         }
1486         return 0;
1487     }
1488 #endif
1489
1490     if (scp->cbServerp != NULL) {
1491         return 1;
1492     } else if (cm_OfflineROIsValid) {
1493         cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
1494         if (volp) {
1495             switch (cm_GetVolumeStatus(volp, scp->fid.volume)) {
1496             case vl_offline:
1497             case vl_alldown:
1498             case vl_unknown:
1499                 cm_PutVolume(volp);
1500                 return 1;
1501             default:
1502                 cm_PutVolume(volp);
1503                 return 0;
1504             }
1505         }
1506         return 1;
1507     }
1508     return 0;
1509 }
1510
1511 /* need to detect a broken callback that races with our obtaining a callback.
1512  * Need to be able to do this even if we don't know the file ID of the file
1513  * we're breaking the callback on at the time we start the acquisition of the
1514  * callback (as in the case where we are creating a file).
1515  *
1516  * So, we start by writing down the count of the # of callbacks we've received
1517  * so far, and bumping a global counter of the # of callback granting calls
1518  * outstanding (all done under cm_callbackLock).
1519  *
1520  * When we're back from the call, we look at all of the callback revokes with
1521  * counter numbers greater than the one we recorded in our caller's structure,
1522  * and replay those that are higher than when we started the call.
1523  *
1524  * We free all the structures in the queue when the count of the # of outstanding
1525  * callback-granting calls drops to zero.
1526  *
1527  * We call this function with the scp locked, too, but in its current implementation,
1528  * this knowledge is not used.
1529  */
1530 void cm_StartCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp)
1531 {
1532     lock_ObtainWrite(&cm_callbackLock);
1533     cbrp->callbackCount = cm_callbackCount;
1534     cm_activeCallbackGrantingCalls++;
1535     cbrp->startTime = time(NULL);
1536     cbrp->serverp = NULL;
1537     lock_ReleaseWrite(&cm_callbackLock);
1538 }
1539
1540 /* Called at the end of a callback-granting call, to remove the callback
1541  * info from the scache entry, if necessary.
1542  *
1543  * Called with scp write locked, so we can discard the callbacks easily with
1544  * this locking hierarchy.
1545  */
1546 void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
1547                                 AFSCallBack *cbp, long flags)
1548 {
1549     cm_racingRevokes_t *revp;           /* where we are */
1550     cm_racingRevokes_t *nrevp;          /* where we'll be next */
1551     int freeFlag;
1552     cm_server_t * serverp = NULL;
1553     int discardScp = 0, discardVolCB = 0;
1554
1555     lock_ObtainWrite(&cm_callbackLock);
1556     if (flags & CM_CALLBACK_MAINTAINCOUNT) {
1557         osi_assertx(cm_activeCallbackGrantingCalls > 0,
1558                     "CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
1559     }
1560     else {
1561         osi_assertx(cm_activeCallbackGrantingCalls-- > 0,
1562                     "!CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
1563     }
1564     if (cm_activeCallbackGrantingCalls == 0)
1565         freeFlag = 1;
1566     else
1567         freeFlag = 0;
1568
1569     /* record the callback; we'll clear it below if we really lose it */
1570     if (cbrp) {
1571         if (scp) {
1572             if (scp->cbServerp != cbrp->serverp) {
1573                 serverp = scp->cbServerp;
1574                 if (!freeFlag)
1575                     cm_GetServer(cbrp->serverp);
1576                 scp->cbServerp = cbrp->serverp;
1577             } else {
1578                 if (freeFlag)
1579                     serverp = cbrp->serverp;
1580             }
1581             scp->cbExpires = cbrp->startTime + cbp->ExpirationTime;
1582             if (scp->flags & CM_SCACHEFLAG_PURERO) {
1583                 cm_volume_t * volp = cm_GetVolumeByFID(&scp->fid);
1584                 if (volp) {
1585                     volp->cbExpiresRO = scp->cbExpires;
1586                     cm_PutVolume(volp);
1587                 }
1588             }
1589         } else {
1590             if (freeFlag)
1591                 serverp = cbrp->serverp;
1592         }
1593         if (freeFlag)
1594             cbrp->serverp = NULL;
1595     }
1596
1597     /* a callback was actually revoked during our granting call, so
1598      * run down the list of revoked fids, looking for ours.
1599      * If activeCallbackGrantingCalls is zero, free the elements, too.
1600      *
1601      * May need to go through entire list just to do the freeing.
1602      */
1603     for (revp = cm_racingRevokesp; revp; revp = nrevp) {
1604         nrevp = (cm_racingRevokes_t *) osi_QNext(&revp->q);
1605         /* if this callback came in later than when we started the
1606          * callback-granting call, and if this fid is the right fid,
1607          * then clear the callback.
1608          */
1609         if (scp && cbrp && cbrp->callbackCount != cm_callbackCount
1610              && revp->callbackCount > cbrp->callbackCount
1611              && (( scp->fid.volume == revp->fid.volume &&
1612                    scp->fid.vnode == revp->fid.vnode &&
1613                    scp->fid.unique == revp->fid.unique)
1614                   ||
1615                   ((revp->flags & CM_RACINGFLAG_CANCELVOL) &&
1616                     scp->fid.volume == revp->fid.volume)
1617                   ||
1618                   (revp->flags & CM_RACINGFLAG_CANCELALL))) {
1619             /* this one matches */
1620             osi_Log4(afsd_logp,
1621                       "Racing revoke scp 0x%p old cbc %d rev cbc %d cur cbc %d",
1622                       scp,
1623                       cbrp->callbackCount, revp->callbackCount,
1624                       cm_callbackCount);
1625             discardScp = 1;
1626             if ((scp->flags & CM_SCACHEFLAG_PURERO) &&
1627                  (revp->flags & (CM_RACINGFLAG_CANCELVOL | CM_RACINGFLAG_CANCELALL))) {
1628                 cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
1629                 if (volp) {
1630                     volp->cbExpiresRO = 0;
1631                     cm_PutVolume(volp);
1632                 }
1633             }
1634         }
1635         if (freeFlag)
1636             free(revp);
1637     }
1638
1639     /* if we freed the list, zap the pointer to it */
1640     if (freeFlag)
1641         cm_racingRevokesp = NULL;
1642
1643     lock_ReleaseWrite(&cm_callbackLock);
1644
1645     if ( discardScp ) {
1646         cm_DiscardSCache(scp);
1647         lock_ReleaseWrite(&scp->rw);
1648         cm_CallbackNotifyChange(scp);
1649         lock_ObtainWrite(&scp->rw);
1650     }
1651
1652     if ( serverp ) {
1653         lock_ObtainWrite(&cm_serverLock);
1654         cm_FreeServer(serverp);
1655         lock_ReleaseWrite(&cm_serverLock);
1656     }
1657 }
1658
1659 /* if flags is 1, we want to force the code to make one call, anyway.
1660  * called with locked scp; returns with same.
1661  */
1662 long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp,
1663                     struct cm_req *reqp, long flags)
1664 {
1665     long code = 0;
1666     cm_conn_t *connp = NULL;
1667     AFSFetchStatus afsStatus;
1668     AFSVolSync volSync;
1669     AFSCallBack callback;
1670     AFSFid tfid;
1671     cm_callbackRequest_t cbr;
1672     int mustCall;
1673     cm_fid_t sfid;
1674     struct rx_connection * rxconnp = NULL;
1675     int syncop_done = 0;
1676
1677     osi_Log4(afsd_logp, "GetCallback scp 0x%p cell %d vol %d flags %lX",
1678              scp, scp->fid.cell, scp->fid.volume, flags);
1679
1680 #ifdef AFS_FREELANCE_CLIENT
1681     // The case where a callback is needed on /afs is handled
1682     // specially. We need to fetch the status by calling
1683     // cm_MergeStatus and mark that cm_fakeDirCallback is 2
1684     if (cm_freelanceEnabled) {
1685         if (scp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
1686              scp->fid.volume==AFS_FAKE_ROOT_VOL_ID &&
1687              scp->fid.unique==0x1 &&
1688              scp->fid.vnode==0x1) {
1689
1690             // Start by indicating that we're in the process
1691             // of fetching the callback
1692             lock_ObtainMutex(&cm_Freelance_Lock);
1693             osi_Log0(afsd_logp,"cm_getGetCallback fakeGettingCallback=1");
1694             cm_fakeGettingCallback = 1;
1695             lock_ReleaseMutex(&cm_Freelance_Lock);
1696
1697             // Fetch the status info
1698             cm_MergeStatus(NULL, scp, &afsStatus, &volSync, userp, 0);
1699
1700             // Indicate that the callback is not done
1701             lock_ObtainMutex(&cm_Freelance_Lock);
1702             osi_Log0(afsd_logp,"cm_getGetCallback fakeDirCallback=2");
1703             cm_fakeDirCallback = 2;
1704
1705             // Indicate that we're no longer fetching the callback
1706             osi_Log0(afsd_logp,"cm_getGetCallback fakeGettingCallback=0");
1707             cm_fakeGettingCallback = 0;
1708             lock_ReleaseMutex(&cm_Freelance_Lock);
1709
1710             return 0;
1711         }
1712
1713         if (scp->fid.cell==AFS_FAKE_ROOT_CELL_ID && scp->fid.volume==AFS_FAKE_ROOT_VOL_ID) {
1714             osi_Log0(afsd_logp,"cm_getcallback should NEVER EVER get here... ");
1715         }
1716     }
1717 #endif /* AFS_FREELANCE_CLIENT */
1718
1719     mustCall = (flags & 1);
1720     cm_AFSFidFromFid(&tfid, &scp->fid);
1721     while (1) {
1722         if (!mustCall && cm_HaveCallback(scp))
1723             break;
1724
1725         /* turn off mustCall, since it has now forced us past the check above */
1726         mustCall = 0;
1727
1728         /* otherwise, we have to make an RPC to get the status */
1729         if (!syncop_done) {
1730             code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1731                              CM_SCACHESYNC_FETCHSTATUS | CM_SCACHESYNC_GETCALLBACK);
1732             if (code)
1733                 break;
1734             syncop_done = 1;
1735         }
1736         cm_StartCallbackGrantingCall(scp, &cbr);
1737         sfid = scp->fid;
1738         lock_ReleaseWrite(&scp->rw);
1739
1740         /* now make the RPC */
1741         osi_Log4(afsd_logp, "CALL FetchStatus scp 0x%p vol %u vn %u uniq %u",
1742                  scp, sfid.volume, sfid.vnode, sfid.unique);
1743         do {
1744             code = cm_ConnFromFID(&sfid, userp, reqp, &connp);
1745             if (code)
1746                 continue;
1747
1748             rxconnp = cm_GetRxConn(connp);
1749             code = RXAFS_FetchStatus(rxconnp, &tfid,
1750                                      &afsStatus, &callback, &volSync);
1751             rx_PutConnection(rxconnp);
1752
1753         } while (cm_Analyze(connp, userp, reqp, &sfid, &volSync, NULL,
1754                             &cbr, code));
1755         code = cm_MapRPCError(code, reqp);
1756         if (code)
1757             osi_Log4(afsd_logp, "CALL FetchStatus FAILURE code 0x%x scp 0x%p vol %u vn %u",
1758                      code, scp, scp->fid.volume, scp->fid.vnode);
1759         else
1760             osi_Log4(afsd_logp, "CALL FetchStatus SUCCESS scp 0x%p vol %u vn %u uniq %u",
1761                      scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
1762
1763         lock_ObtainWrite(&scp->rw);
1764         if (code == 0) {
1765             cm_EndCallbackGrantingCall(scp, &cbr, &callback, 0);
1766             cm_MergeStatus(NULL, scp, &afsStatus, &volSync, userp, 0);
1767         } else {
1768             cm_EndCallbackGrantingCall(NULL, &cbr, NULL, 0);
1769         }
1770
1771         /* if we got an error, return to caller */
1772         if (code)
1773             break;
1774     }
1775
1776     if (syncop_done)
1777         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_FETCHSTATUS | CM_SCACHESYNC_GETCALLBACK);
1778
1779     if (code) {
1780         osi_Log2(afsd_logp, "GetCallback Failed code 0x%x scp 0x%p -->",code, scp);
1781         osi_Log4(afsd_logp, "            cell %u vol %u vn %u uniq %u",
1782                  scp->fid.cell, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
1783     } else {
1784         osi_Log3(afsd_logp, "GetCallback Complete scp 0x%p cell %d vol %d",
1785                   scp, scp->fid.cell, scp->fid.volume);
1786     }
1787
1788     return code;
1789 }
1790
1791
1792 /* called with cm_scacheLock held */
1793 long cm_CBServersUp(cm_scache_t *scp, time_t * downTime)
1794 {
1795     cm_vol_state_t *statep;
1796     cm_volume_t * volp;
1797     afs_uint32 volID = scp->fid.volume;
1798     cm_serverRef_t *tsrp;
1799     int found;
1800
1801     *downTime = 0;
1802
1803     if (scp->cbServerp == NULL)
1804         return 1;
1805
1806     volp = cm_GetVolumeByFID(&scp->fid);
1807     if (!volp)
1808         return 1;
1809
1810     statep = cm_VolumeStateByID(volp, volID);
1811     cm_PutVolume(volp);
1812     if (statep->state == vl_online)
1813         return 1;
1814
1815     for (found = 0,tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
1816         if (tsrp->server == scp->cbServerp)
1817             found = 1;
1818         if (tsrp->server->downTime > *downTime)
1819             *downTime = tsrp->server->downTime;
1820     }
1821
1822     /* if the cbServerp does not match the current volume server list
1823      * we report the callback server as up so the callback can be
1824      * expired.
1825      */
1826     return(found ? 0 : 1);
1827 }
1828
1829 /* called periodically by cm_daemon to shut down use of expired callbacks */
1830 void cm_CheckCBExpiration(void)
1831 {
1832     afs_uint32 i;
1833     cm_scache_t *scp;
1834     time_t now, downTime;
1835
1836     osi_Log0(afsd_logp, "CheckCBExpiration");
1837
1838     now = time(NULL);
1839     lock_ObtainWrite(&cm_scacheLock);
1840     for (i=0; i<cm_data.scacheHashTableSize; i++) {
1841         for (scp = cm_data.scacheHashTablep[i]; scp; scp=scp->nextp) {
1842             downTime = 0;
1843             if (scp->flags & CM_SCACHEFLAG_PURERO) {
1844                 cm_volume_t *volp = cm_GetVolumeByFID(&scp->fid);
1845                 if (volp) {
1846                     if (volp->cbExpiresRO > scp->cbExpires && scp->cbExpires > 0)
1847                         scp->cbExpires = volp->cbExpiresRO;
1848                     cm_PutVolume(volp);
1849                 }
1850             }
1851             if (scp->cbServerp && scp->cbExpires > 0 && now > scp->cbExpires &&
1852                  (cm_CBServersUp(scp, &downTime) || downTime == 0 || downTime >= scp->cbExpires))
1853             {
1854                 cm_HoldSCacheNoLock(scp);
1855                 lock_ReleaseWrite(&cm_scacheLock);
1856
1857                 osi_Log4(afsd_logp, "Callback Expiration Discarding SCache scp 0x%p vol %u vn %u uniq %u",
1858                           scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
1859                 lock_ObtainWrite(&scp->rw);
1860                 cm_DiscardSCache(scp);
1861                 lock_ReleaseWrite(&scp->rw);
1862                 cm_CallbackNotifyChange(scp);
1863
1864                 lock_ObtainWrite(&cm_scacheLock);
1865                 cm_ReleaseSCacheNoLock(scp);
1866             }
1867         }
1868     }
1869     lock_ReleaseWrite(&cm_scacheLock);
1870
1871     osi_Log0(afsd_logp, "CheckCBExpiration Complete");
1872 }
1873
1874
1875 void
1876 cm_GiveUpAllCallbacks(cm_server_t *tsp, afs_int32 markDown)
1877 {
1878     long code;
1879     cm_conn_t *connp;
1880     struct rx_connection * rxconnp;
1881
1882     if ((tsp->type == CM_SERVER_FILE) && !(tsp->flags & CM_SERVERFLAG_DOWN))
1883     {
1884         code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
1885         if (code == 0) {
1886             rxconnp = cm_GetRxConn(connp);
1887             rx_SetConnDeadTime(rxconnp, 10);
1888             code = RXAFS_GiveUpAllCallBacks(rxconnp);
1889             rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
1890             rx_PutConnection(rxconnp);
1891         }
1892
1893         if (markDown) {
1894             cm_server_vols_t * tsrvp;
1895             cm_volume_t * volp;
1896             int i;
1897
1898             lock_ObtainMutex(&tsp->mx);
1899             if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
1900                 tsp->flags |= CM_SERVERFLAG_DOWN;
1901                 tsp->downTime = time(NULL);
1902             }
1903             cm_ForceNewConnections(tsp);
1904
1905             /* Now update the volume status */
1906             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1907                 for (i=0; i<NUM_SERVER_VOLS; i++) {
1908                     if (tsrvp->ids[i] != 0) {
1909                         cm_req_t req;
1910
1911                         cm_InitReq(&req);
1912
1913                         code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
1914                                                  &req, CM_GETVOL_FLAG_NO_LRU_UPDATE | CM_GETVOL_FLAG_NO_RESET, &volp);
1915                         if (code == 0) {
1916                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
1917                             cm_PutVolume(volp);
1918                         }
1919                     }
1920                 }
1921             }
1922             lock_ReleaseMutex(&tsp->mx);
1923         }
1924     }
1925 }
1926
1927 void
1928 cm_GiveUpAllCallbacksAllServers(afs_int32 markDown)
1929 {
1930     cm_server_t *tsp;
1931
1932     if (!cm_giveUpAllCBs)
1933         return;
1934
1935     lock_ObtainWrite(&cm_serverLock);
1936     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
1937         cm_GetServerNoLock(tsp);
1938         lock_ReleaseWrite(&cm_serverLock);
1939         cm_GiveUpAllCallbacks(tsp, markDown);
1940         lock_ObtainWrite(&cm_serverLock);
1941         cm_PutServerNoLock(tsp);
1942     }
1943     lock_ReleaseWrite(&cm_serverLock);
1944 }
1945
1946