src/afs/afs_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 /*
  11  * afs_callback.c:
  12  *      Exported routines (and their private support) to implement
  13  *      the callback RPC interface.
  14  */
  15
  16 #include <afsconfig.h>
  17 #include "afs/param.h"
  18
  19
  20 #include "afs/sysincludes.h"    /*Standard vendor system headers */
  21 #include "afsincludes.h"        /*AFS-based standard headers */
  22 #include "afs/afs_stats.h"      /*Cache Manager stats */
  23 #include "afs/afs_args.h"
  24
  25 afs_int32 afs_allCBs = 0;       /*Break callbacks on all objects */
  26 afs_int32 afs_oddCBs = 0;       /*Break callbacks on dirs */
  27 afs_int32 afs_evenCBs = 0;      /*Break callbacks received on files */
  28 afs_int32 afs_allZaps = 0;      /*Objects entries deleted */
  29 afs_int32 afs_oddZaps = 0;      /*Dir cache entries deleted */
  30 afs_int32 afs_evenZaps = 0;     /*File cache entries deleted */
  31 afs_int32 afs_connectBacks = 0;
  32
  33 /*
  34  * Some debugging aids.
  35  */
  36 static struct ltable {
  37     char *name;
  38     char *addr;
  39 } ltable[] = {
  40     {
  41     "afs_xvcache", (char *)&afs_xvcache}, {
  42     "afs_xdcache", (char *)&afs_xdcache}, {
  43     "afs_xserver", (char *)&afs_xserver}, {
  44     "afs_xvcb", (char *)&afs_xvcb}, {
  45     "afs_xbrs", (char *)&afs_xbrs}, {
  46     "afs_xcell", (char *)&afs_xcell}, {
  47     "afs_xconn", (char *)&afs_xconn}, {
  48     "afs_xuser", (char *)&afs_xuser}, {
  49     "afs_xvolume", (char *)&afs_xvolume}, {
  50     "puttofile", (char *)&afs_puttofileLock}, {
  51     "afs_ftf", (char *)&afs_ftf}, {
  52     "afs_xcbhash", (char *)&afs_xcbhash}, {
  53     "afs_xaxs", (char *)&afs_xaxs}, {
  54     "afs_xinterface", (char *)&afs_xinterface},
  55 #ifndef UKERNEL
  56     {
  57     "afs_xosi", (char *)&afs_xosi},
  58 #endif
  59     {
  60       "afs_xsrvAddr", (char *)&afs_xsrvAddr},
  61     {
  62       "afs_xvreclaim", (char *)&afs_xvreclaim},
  63     { "afsdb_client_lock", (char *)&afsdb_client_lock},
  64     { "afsdb_req_lock", (char *)&afsdb_req_lock},
  65     { "afs_discon_lock", (char *)&afs_discon_lock},
  66     { "afs_disconDirtyLock", (char *)&afs_disconDirtyLock},
  67     { "afs_discon_vc_dirty", (char *)&afs_xvcdirty},
  68     { "afs_dynrootDirLock", (char *)&afs_dynrootDirLock},
  69     { "afs_dynSymlinkLock", (char *)&afs_dynSymlinkLock},
  70 };
  71 unsigned long lastCallBack_vnode;
  72 unsigned int lastCallBack_dv;
  73 osi_timeval_t lastCallBack_time;
  74
  75 /* these are for storing alternate interface addresses */
  76 struct interfaceAddr afs_cb_interface;
  77
  78 /*------------------------------------------------------------------------
  79  * EXPORTED SRXAFSCB_GetCE
  80  *
  81  * Description:
  82  *      Routine called by the server-side callback RPC interface to
  83  *      implement pulling out the contents of the i'th cache entry.
  84  *
  85  * Arguments:
  86  *      a_call   : Ptr to Rx call on which this request came in.
  87  *      a_index  : Index of desired cache entry.
  88  *      a_result : Ptr to a buffer for the given cache entry.
  89  *
  90  * Returns:
  91  *      0 if everything went fine,
  92  *      1 if we were given a bad index.
  93  *
  94  * Environment:
  95  *      Nothing interesting.
  96  *
  97  * Side Effects:
  98  *      As advertised.
  99  *------------------------------------------------------------------------*/
 100
 101 int
 102 SRXAFSCB_GetCE(struct rx_call *a_call, afs_int32 a_index,
 103                struct AFSDBCacheEntry *a_result)
 104 {
 105
 106     int i;              /*Loop variable */
 107     struct vcache *tvc; /*Ptr to current cache entry */
 108     int code;                   /*Return code */
 109     XSTATS_DECLS;
 110
 111     RX_AFS_GLOCK();
 112
 113     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETCE);
 114
 115     AFS_STATCNT(SRXAFSCB_GetCE);
 116     for (i = 0; i < VCSIZE; i++) {
 117         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
 118             if (a_index == 0)
 119                 goto searchDone;
 120             a_index--;
 121         }                       /*Zip through current hash chain */
 122     }                           /*Zip through hash chains */
 123
 124   searchDone:
 125     if (tvc == NULL) {
 126         /*Past EOF */
 127         code = 1;
 128         goto fcnDone;
 129     }
 130
 131     /*
 132      * Copy out the located entry.
 133      */
 134     a_result->addr = afs_data_pointer_to_int32(tvc);
 135     a_result->cell = tvc->f.fid.Cell;
 136     a_result->netFid.Volume = tvc->f.fid.Fid.Volume;
 137     a_result->netFid.Vnode = tvc->f.fid.Fid.Vnode;
 138     a_result->netFid.Unique = tvc->f.fid.Fid.Unique;
 139     a_result->lock.waitStates = tvc->lock.wait_states;
 140     a_result->lock.exclLocked = tvc->lock.excl_locked;
 141     a_result->lock.readersReading = tvc->lock.readers_reading;
 142     a_result->lock.numWaiting = tvc->lock.num_waiting;
 143 #if defined(INSTRUMENT_LOCKS)
 144     a_result->lock.pid_last_reader = MyPidxx2Pid(tvc->lock.pid_last_reader);
 145     a_result->lock.pid_writer = MyPidxx2Pid(tvc->lock.pid_writer);
 146     a_result->lock.src_indicator = tvc->lock.src_indicator;
 147 #else
 148     /* On osf20 , the vcache does not maintain these three fields */
 149     a_result->lock.pid_last_reader = 0;
 150     a_result->lock.pid_writer = 0;
 151     a_result->lock.src_indicator = 0;
 152 #endif /* INSTRUMENT_LOCKS */
 153 #ifdef AFS_64BIT_CLIENT
 154     a_result->Length = (afs_int32) tvc->f.m.Length & 0xffffffff;
 155 #else /* AFS_64BIT_CLIENT */
 156     a_result->Length = tvc->f.m.Length;
 157 #endif /* AFS_64BIT_CLIENT */
 158     a_result->DataVersion = hgetlo(tvc->f.m.DataVersion);
 159     a_result->callback = afs_data_pointer_to_int32(tvc->callback);      /* XXXX Now a pointer; change it XXXX */
 160     a_result->cbExpires = tvc->cbExpires;
 161     if (tvc->f.states & CVInit) {
 162         a_result->refCount = 1;
 163     } else {
 164 #ifdef AFS_DARWIN80_ENV
 165     a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
 166 #else
 167     a_result->refCount = VREFCOUNT(tvc);
 168 #endif
 169     }
 170     a_result->opens = tvc->opens;
 171     a_result->writers = tvc->execsOrWriters;
 172     a_result->mvstat = tvc->mvstat;
 173     a_result->states = tvc->f.states;
 174     code = 0;
 175
 176     /*
 177      * Return our results.
 178      */
 179   fcnDone:
 180     XSTATS_END_TIME;
 181
 182     RX_AFS_GUNLOCK();
 183
 184     return (code);
 185
 186 }                               /*SRXAFSCB_GetCE */
 187
 188 int
 189 SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
 190                  struct AFSDBCacheEntry64 *a_result)
 191 {
 192     int i;              /*Loop variable */
 193     struct vcache *tvc; /*Ptr to current cache entry */
 194     int code;                   /*Return code */
 195     XSTATS_DECLS;
 196
 197     RX_AFS_GLOCK();
 198
 199     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETCE);
 200
 201     AFS_STATCNT(SRXAFSCB_GetCE64);
 202     for (i = 0; i < VCSIZE; i++) {
 203         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
 204             if (a_index == 0)
 205                 goto searchDone;
 206             a_index--;
 207         }                       /*Zip through current hash chain */
 208     }                           /*Zip through hash chains */
 209
 210   searchDone:
 211     if (tvc == NULL) {
 212         /*Past EOF */
 213         code = 1;
 214         goto fcnDone;
 215     }
 216
 217     /*
 218      * Copy out the located entry.
 219      */
 220     a_result->addr = afs_data_pointer_to_int32(tvc);
 221     a_result->cell = tvc->f.fid.Cell;
 222     a_result->netFid.Volume = tvc->f.fid.Fid.Volume;
 223     a_result->netFid.Vnode = tvc->f.fid.Fid.Vnode;
 224     a_result->netFid.Unique = tvc->f.fid.Fid.Unique;
 225     a_result->lock.waitStates = tvc->lock.wait_states;
 226     a_result->lock.exclLocked = tvc->lock.excl_locked;
 227     a_result->lock.readersReading = tvc->lock.readers_reading;
 228     a_result->lock.numWaiting = tvc->lock.num_waiting;
 229 #if defined(INSTRUMENT_LOCKS)
 230     a_result->lock.pid_last_reader = MyPidxx2Pid(tvc->lock.pid_last_reader);
 231     a_result->lock.pid_writer = MyPidxx2Pid(tvc->lock.pid_writer);
 232     a_result->lock.src_indicator = tvc->lock.src_indicator;
 233 #else
 234     /* On osf20 , the vcache does not maintain these three fields */
 235     a_result->lock.pid_last_reader = 0;
 236     a_result->lock.pid_writer = 0;
 237     a_result->lock.src_indicator = 0;
 238 #endif /* INSTRUMENT_LOCKS */
 239     a_result->Length = tvc->f.m.Length;
 240     a_result->DataVersion = hgetlo(tvc->f.m.DataVersion);
 241     a_result->callback = afs_data_pointer_to_int32(tvc->callback);      /* XXXX Now a pointer; change it XXXX */
 242     a_result->cbExpires = tvc->cbExpires;
 243     if (tvc->f.states & CVInit) {
 244         a_result->refCount = 1;
 245     } else {
 246 #ifdef AFS_DARWIN80_ENV
 247     a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
 248 #else
 249     a_result->refCount = VREFCOUNT(tvc);
 250 #endif
 251     }
 252     a_result->opens = tvc->opens;
 253     a_result->writers = tvc->execsOrWriters;
 254     a_result->mvstat = tvc->mvstat;
 255     a_result->states = tvc->f.states;
 256     code = 0;
 257
 258     /*
 259      * Return our results.
 260      */
 261   fcnDone:
 262     XSTATS_END_TIME;
 263
 264     RX_AFS_GUNLOCK();
 265
 266     return (code);
 267
 268 }                               /*SRXAFSCB_GetCE64 */
 269
 270
 271 /*------------------------------------------------------------------------
 272  * EXPORTED SRXAFSCB_GetLock
 273  *
 274  * Description:
 275  *      Routine called by the server-side callback RPC interface to
 276  *      implement pulling out the contents of a lock in the lock
 277  *      table.
 278  *
 279  * Arguments:
 280  *      a_call   : Ptr to Rx call on which this request came in.
 281  *      a_index  : Index of desired lock.
 282  *      a_result : Ptr to a buffer for the given lock.
 283  *
 284  * Returns:
 285  *      0 if everything went fine,
 286  *      1 if we were given a bad index.
 287  *
 288  * Environment:
 289  *      Nothing interesting.
 290  *
 291  * Side Effects:
 292  *      As advertised.
 293  *------------------------------------------------------------------------*/
 294
 295 int
 296 SRXAFSCB_GetLock(struct rx_call *a_call, afs_int32 a_index,
 297                  struct AFSDBLock *a_result)
 298 {
 299     struct ltable *tl;          /*Ptr to lock table entry */
 300     int nentries;               /*Num entries in table */
 301     int code;                   /*Return code */
 302     XSTATS_DECLS;
 303
 304     RX_AFS_GLOCK();
 305
 306     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETLOCK);
 307
 308     AFS_STATCNT(SRXAFSCB_GetLock);
 309     nentries = sizeof(ltable) / sizeof(struct ltable);
 310     if (a_index < 0 || a_index >= nentries+afs_cellindex) {
 311         /*
 312          * Past EOF
 313          */
 314         code = 1;
 315     } else if (a_index >= nentries) {
 316         struct cell *tc = afs_GetCellByIndex(a_index-nentries, 0);
 317         strcpy(a_result->name, tc->cellName);
 318         a_result->lock.waitStates =
 319             ((struct afs_lock *)&(tc->lock))->wait_states;
 320         a_result->lock.exclLocked =
 321             ((struct afs_lock *)&(tc->lock))->excl_locked;
 322         a_result->lock.readersReading =
 323             ((struct afs_lock *)&(tc->lock))->readers_reading;
 324         a_result->lock.numWaiting =
 325             ((struct afs_lock *)&(tc->lock))->num_waiting;
 326 #ifdef INSTRUMENT_LOCKS
 327         a_result->lock.pid_last_reader =
 328             MyPidxx2Pid(((struct afs_lock *)&(tc->lock))->pid_last_reader);
 329         a_result->lock.pid_writer =
 330             MyPidxx2Pid(((struct afs_lock *)&(tc->lock))->pid_writer);
 331         a_result->lock.src_indicator =
 332             ((struct afs_lock *)&(tc->lock))->src_indicator;
 333 #else
 334         a_result->lock.pid_last_reader = 0;
 335         a_result->lock.pid_writer = 0;
 336         a_result->lock.src_indicator = 0;
 337 #endif
 338         code = 0;
 339     } else {
 340         /*
 341          * Found it - copy out its contents.
 342          */
 343         tl = &ltable[a_index];
 344         strcpy(a_result->name, tl->name);
 345         a_result->lock.waitStates =
 346             ((struct afs_lock *)(tl->addr))->wait_states;
 347         a_result->lock.exclLocked =
 348             ((struct afs_lock *)(tl->addr))->excl_locked;
 349         a_result->lock.readersReading =
 350             ((struct afs_lock *)(tl->addr))->readers_reading;
 351         a_result->lock.numWaiting =
 352             ((struct afs_lock *)(tl->addr))->num_waiting;
 353 #ifdef INSTRUMENT_LOCKS
 354         a_result->lock.pid_last_reader =
 355             MyPidxx2Pid(((struct afs_lock *)(tl->addr))->pid_last_reader);
 356         a_result->lock.pid_writer =
 357             MyPidxx2Pid(((struct afs_lock *)(tl->addr))->pid_writer);
 358         a_result->lock.src_indicator =
 359             ((struct afs_lock *)(tl->addr))->src_indicator;
 360 #else
 361         a_result->lock.pid_last_reader = 0;
 362         a_result->lock.pid_writer = 0;
 363         a_result->lock.src_indicator = 0;
 364 #endif
 365         code = 0;
 366     }
 367
 368     XSTATS_END_TIME;
 369
 370     RX_AFS_GUNLOCK();
 371
 372     return (code);
 373
 374 }                               /*SRXAFSCB_GetLock */
 375
 376
 377 /*------------------------------------------------------------------------
 378  * static ClearCallBack
 379  *
 380  * Description:
 381  *      Clear out callback information for the specified file, or
 382  *      even a whole volume.  Used to worry about callback was from
 383  *      within the particular cell or not.  Now we don't bother with
 384  *      that anymore; it's not worth the time.
 385  *
 386  * Arguments:
 387  *      a_conn : Ptr to Rx connection involved.
 388  *      a_fid  : Ptr to AFS fid being cleared.
 389  *
 390  * Returns:
 391  *      0 (always)
 392  *
 393  * Environment:
 394  *      Nothing interesting.
 395  *
 396  * Side Effects:
 397  *      As advertised.
 398
 399 Appears to need to be called with GLOCK held, as the icl_Event4 stuff asserts otherwise
 400
 401  *------------------------------------------------------------------------*/
 402
 403 static int
 404 ClearCallBack(struct rx_connection *a_conn,
 405               struct AFSFid *a_fid)
 406 {
 407     struct vcache *tvc;
 408     int i;
 409     struct VenusFid localFid;
 410     struct volume *tv;
 411 #ifdef AFS_DARWIN80_ENV
 412     vnode_t vp;
 413 #endif
 414
 415     AFS_STATCNT(ClearCallBack);
 416
 417     AFS_ASSERT_GLOCK();
 418
 419     /*
 420      * XXXX Don't hold any server locks here because of callback protocol XXX
 421      */
 422     localFid.Cell = 0;
 423     localFid.Fid.Volume = a_fid->Volume;
 424     localFid.Fid.Vnode = a_fid->Vnode;
 425     localFid.Fid.Unique = a_fid->Unique;
 426
 427     /*
 428      * Volume ID of zero means don't do anything.
 429      */
 430     if (a_fid->Volume != 0) {
 431         if (a_fid->Vnode == 0) {
 432                 struct afs_q *tq, *uq;
 433             /*
 434              * Clear callback for the whole volume.  Zip through the
 435              * hash chain, nullifying entries whose volume ID matches.
 436              */
 437 loop1:
 438                 ObtainReadLock(&afs_xvcache);
 439                 i = VCHashV(&localFid);
 440                 for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
 441                     uq = QPrev(tq);
 442                     tvc = QTOVH(tq);
 443                     if (tvc->f.fid.Fid.Volume == a_fid->Volume) {
 444                         tvc->callback = NULL;
 445                         if (!localFid.Cell)
 446                             localFid.Cell = tvc->f.fid.Cell;
 447                         tvc->dchint = NULL;     /* invalidate hints */
 448                         if (tvc->f.states & CVInit) {
 449                             ReleaseReadLock(&afs_xvcache);
 450                             afs_osi_Sleep(&tvc->f.states);
 451                             goto loop1;
 452                         }
 453 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)  || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
 454                         AFS_FAST_HOLD(tvc);
 455 #else
 456 #ifdef AFS_DARWIN80_ENV
 457                         if (tvc->f.states & CDeadVnode) {
 458                             ReleaseReadLock(&afs_xvcache);
 459                             afs_osi_Sleep(&tvc->f.states);
 460                             goto loop1;
 461                         }
 462                         vp = AFSTOV(tvc);
 463                         if (vnode_get(vp))
 464                             continue;
 465                         if (vnode_ref(vp)) {
 466                             AFS_GUNLOCK();
 467                             vnode_put(vp);
 468                             AFS_GLOCK();
 469                             continue;
 470                         }
 471 #else
 472                         AFS_FAST_HOLD(tvc);
 473 #endif
 474 #endif
 475                         ReleaseReadLock(&afs_xvcache);
 476                         ObtainWriteLock(&afs_xcbhash, 449);
 477                         afs_DequeueCallback(tvc);
 478                         tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
 479                         afs_allCBs++;
 480                         if (tvc->f.fid.Fid.Vnode & 1)
 481                             afs_oddCBs++;
 482                         else
 483                             afs_evenCBs++;
 484                         ReleaseWriteLock(&afs_xcbhash);
 485                         if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
 486                             osi_dnlc_purgedp(tvc);
 487                         afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
 488                                    ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
 489                                    tvc->f.states, ICL_TYPE_INT32,
 490                                    a_fid->Volume);
 491 #ifdef AFS_DARWIN80_ENV
 492                         vnode_put(AFSTOV(tvc));
 493 #endif
 494                         ObtainReadLock(&afs_xvcache);
 495                         uq = QPrev(tq);
 496                         AFS_FAST_RELE(tvc);
 497                     } else if ((tvc->f.states & CMValid)
 498                                && (tvc->mvid.target_root->Fid.Volume == a_fid->Volume)) {
 499                         tvc->f.states &= ~CMValid;
 500                         if (!localFid.Cell)
 501                             localFid.Cell = tvc->mvid.target_root->Cell;
 502                     }
 503                 }
 504                 ReleaseReadLock(&afs_xvcache);
 505
 506             /*
 507              * XXXX Don't hold any locks here XXXX
 508              */
 509             tv = afs_FindVolume(&localFid, 0);
 510             if (tv) {
 511                 afs_ResetVolumeInfo(tv);
 512                 afs_PutVolume(tv, 0);
 513                 /* invalidate mtpoint? */
 514             }
 515         } /*Clear callbacks for whole volume */
 516         else {
 517             /*
 518              * Clear callbacks just for the one file.
 519              */
 520             struct vcache *uvc;
 521             afs_allCBs++;
 522             if (a_fid->Vnode & 1)
 523                 afs_oddCBs++;   /*Could do this on volume basis, too */
 524             else
 525                 afs_evenCBs++;  /*A particular fid was specified */
 526 loop2:
 527             ObtainReadLock(&afs_xvcache);
 528             i = VCHash(&localFid);
 529             for (tvc = afs_vhashT[i]; tvc; tvc = uvc) {
 530                 uvc = tvc->hnext;
 531                 if (tvc->f.fid.Fid.Vnode == a_fid->Vnode
 532                     && tvc->f.fid.Fid.Volume == a_fid->Volume
 533                     && tvc->f.fid.Fid.Unique == a_fid->Unique) {
 534                     tvc->callback = NULL;
 535                     tvc->dchint = NULL; /* invalidate hints */
 536                     if (tvc->f.states & CVInit) {
 537                         ReleaseReadLock(&afs_xvcache);
 538                         afs_osi_Sleep(&tvc->f.states);
 539                         goto loop2;
 540                     }
 541 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)  || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
 542                     AFS_FAST_HOLD(tvc);
 543 #else
 544 #ifdef AFS_DARWIN80_ENV
 545                     if (tvc->f.states & CDeadVnode) {
 546                         ReleaseReadLock(&afs_xvcache);
 547                         afs_osi_Sleep(&tvc->f.states);
 548                         goto loop2;
 549                     }
 550                     vp = AFSTOV(tvc);
 551                     if (vnode_get(vp))
 552                         continue;
 553                     if (vnode_ref(vp)) {
 554                         AFS_GUNLOCK();
 555                         vnode_put(vp);
 556                         AFS_GLOCK();
 557                         continue;
 558                     }
 559 #else
 560                     AFS_FAST_HOLD(tvc);
 561 #endif
 562 #endif
 563                     ReleaseReadLock(&afs_xvcache);
 564                     ObtainWriteLock(&afs_xcbhash, 450);
 565                     afs_DequeueCallback(tvc);
 566                     tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
 567                     ReleaseWriteLock(&afs_xcbhash);
 568                     if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
 569                         osi_dnlc_purgedp(tvc);
 570                     afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
 571                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
 572                                tvc->f.states, ICL_TYPE_LONG, 0);
 573 #ifdef CBDEBUG
 574                     lastCallBack_vnode = afid->Vnode;
 575                     lastCallBack_dv = tvc->mstat.DataVersion.low;
 576                     osi_GetuTime(&lastCallBack_time);
 577 #endif /* CBDEBUG */
 578 #ifdef AFS_DARWIN80_ENV
 579                     vnode_put(AFSTOV(tvc));
 580 #endif
 581                     ObtainReadLock(&afs_xvcache);
 582                     uvc = tvc->hnext;
 583                     AFS_FAST_RELE(tvc);
 584                 }
 585             }                   /*Walk through hash table */
 586             ReleaseReadLock(&afs_xvcache);
 587         }                       /*Clear callbacks for one file */
 588     }
 589
 590     /*Fid has non-zero volume ID */
 591     /*
 592      * Always return a predictable value.
 593      */
 594     return (0);
 595
 596 }                               /*ClearCallBack */
 597
 598
 599 /*------------------------------------------------------------------------
 600  * EXPORTED SRXAFSCB_CallBack
 601  *
 602  * Description:
 603  *      Routine called by the server-side callback RPC interface to
 604  *      implement passing in callback information.
 605  *      table.
 606  *
 607  * Arguments:
 608  *      a_call      : Ptr to Rx call on which this request came in.
 609  *      a_fids      : Ptr to array of fids involved.
 610  *      a_callbacks : Ptr to matching callback info for the fids.
 611  *
 612  * Returns:
 613  *      0 (always).
 614  *
 615  * Environment:
 616  *      Nothing interesting.
 617  *
 618  * Side Effects:
 619  *      As advertised.
 620  *------------------------------------------------------------------------*/
 621
 622 int
 623 SRXAFSCB_CallBack(struct rx_call *a_call, struct AFSCBFids *a_fids,
 624                   struct AFSCBs *a_callbacks)
 625 {
 626     int i;              /*Loop variable */
 627     struct AFSFid *tfid;        /*Ptr to current fid */
 628     struct rx_connection *tconn;        /*Call's connection */
 629     int code = 0;
 630     XSTATS_DECLS;
 631
 632     RX_AFS_GLOCK();
 633
 634     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_CALLBACK);
 635
 636     AFS_STATCNT(SRXAFSCB_CallBack);
 637     if (!(tconn = rx_ConnectionOf(a_call)))
 638         return (0);
 639     tfid = (struct AFSFid *)a_fids->AFSCBFids_val;
 640
 641     /*
 642      * For now, we ignore callbacks, since the File Server only *breaks*
 643      * callbacks at present.
 644      */
 645     for (i = 0; i < a_fids->AFSCBFids_len; i++)
 646         ClearCallBack(tconn, &tfid[i]);
 647
 648     XSTATS_END_TIME;
 649
 650     RX_AFS_GUNLOCK();
 651
 652     return (0);
 653
 654 }                               /*SRXAFSCB_CallBack */
 655
 656
 657 /*------------------------------------------------------------------------
 658  * EXPORTED SRXAFSCB_Probe
 659  *
 660  * Description:
 661  *      Routine called by the server-side callback RPC interface to
 662  *      implement ``probing'' the Cache Manager, just making sure it's
 663  *      still there.
 664  *
 665  * Arguments:
 666  *      a_call : Ptr to Rx call on which this request came in.
 667  *
 668  * Returns:
 669  *      0 (always).
 670  *
 671  * Environment:
 672  *      Nothing interesting.
 673  *
 674  * Side Effects:
 675  *      As advertised.
 676  *------------------------------------------------------------------------*/
 677
 678 int
 679 SRXAFSCB_Probe(struct rx_call *a_call)
 680 {
 681     int code = 0;
 682     XSTATS_DECLS;
 683
 684     RX_AFS_GLOCK();
 685     AFS_STATCNT(SRXAFSCB_Probe);
 686
 687     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_PROBE);
 688     XSTATS_END_TIME;
 689
 690     RX_AFS_GUNLOCK();
 691
 692     return (0);
 693
 694 }                               /*SRXAFSCB_Probe */
 695
 696
 697 /*------------------------------------------------------------------------
 698  * EXPORTED SRXAFSCB_InitCallBackState
 699  *
 700  * Description:
 701  *      Routine called by the server-side callback RPC interface to
 702  *      implement clearing all callbacks from this host.
 703  *
 704  * Arguments:
 705  *      a_call : Ptr to Rx call on which this request came in.
 706  *
 707  * Returns:
 708  *      0 (always).
 709  *
 710  * Environment:
 711  *      Nothing interesting.
 712  *
 713  * Side Effects:
 714  *      As advertised.
 715  *------------------------------------------------------------------------*/
 716
 717 int
 718 SRXAFSCB_InitCallBackState(struct rx_call *a_call)
 719 {
 720     int i;
 721     struct vcache *tvc;
 722     struct rx_connection *tconn;
 723     struct rx_peer *peer;
 724     struct server *ts;
 725     int code = 0;
 726     XSTATS_DECLS;
 727
 728     RX_AFS_GLOCK();
 729
 730     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_INITCALLBACKSTATE);
 731     AFS_STATCNT(SRXAFSCB_InitCallBackState);
 732
 733     /*
 734      * Find the address of the host making this call
 735      */
 736     if ((tconn = rx_ConnectionOf(a_call)) && (peer = rx_PeerOf(tconn))) {
 737
 738         afs_allCBs++;
 739         afs_oddCBs++;           /*Including any missed via create race */
 740         afs_evenCBs++;          /*Including any missed via create race */
 741
 742         ts = afs_FindServer(rx_HostOf(peer), rx_PortOf(peer), (afsUUID *) 0,
 743                             0);
 744         if (ts) {
 745             for (i = 0; i < VCSIZE; i++)
 746                 for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
 747                     if (tvc->callback == ts) {
 748                         ObtainWriteLock(&afs_xcbhash, 451);
 749                         afs_DequeueCallback(tvc);
 750                         tvc->callback = NULL;
 751                         tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
 752                         ReleaseWriteLock(&afs_xcbhash);
 753                     }
 754                 }
 755
 756             /* capabilities need be requested again */
 757             ts->flags &= ~SCAPS_KNOWN;
 758         }
 759
 760
 761
 762         /* find any volumes residing on this server and flush their state */
 763         {
 764             struct volume *tv;
 765             int j;
 766
 767             for (i = 0; i < NVOLS; i++)
 768                 for (tv = afs_volumes[i]; tv; tv = tv->next) {
 769                     for (j = 0; j < AFS_MAXHOSTS; j++)
 770                         if (tv->serverHost[j] == ts)
 771                             afs_ResetVolumeInfo(tv);
 772                 }
 773         }
 774         osi_dnlc_purge();       /* may be a little bit extreme */
 775     }
 776
 777     XSTATS_END_TIME;
 778
 779     RX_AFS_GUNLOCK();
 780
 781     return (0);
 782
 783 }                               /*SRXAFSCB_InitCallBackState */
 784
 785
 786 /*------------------------------------------------------------------------
 787  * EXPORTED SRXAFSCB_XStatsVersion
 788  *
 789  * Description:
 790  *      Routine called by the server-side callback RPC interface to
 791  *      implement pulling out the xstat version number for the Cache
 792  *      Manager.
 793  *
 794  * Arguments:
 795  *      a_versionP : Ptr to the version number variable to set.
 796  *
 797  * Returns:
 798  *      0 (always)
 799  *
 800  * Environment:
 801  *      Nothing interesting.
 802  *
 803  * Side Effects:
 804  *      As advertised.
 805  *------------------------------------------------------------------------*/
 806
 807 int
 808 SRXAFSCB_XStatsVersion(struct rx_call *a_call, afs_int32 * a_versionP)
 809 {
 810     int code = 0;
 811
 812     XSTATS_DECLS;
 813
 814     RX_AFS_GLOCK();
 815     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_XSTATSVERSION);
 816
 817     *a_versionP = AFSCB_XSTAT_VERSION;
 818
 819     XSTATS_END_TIME;
 820
 821     RX_AFS_GUNLOCK();
 822
 823     return (0);
 824 }                               /*SRXAFSCB_XStatsVersion */
 825
 826
 827 /*------------------------------------------------------------------------
 828  * EXPORTED SRXAFSCB_GetXStats
 829  *
 830  * Description:
 831  *      Routine called by the server-side callback RPC interface to
 832  *      implement getting the given data collection from the extended
 833  *      Cache Manager statistics.
 834  *
 835  * Arguments:
 836  *      a_call              : Ptr to Rx call on which this request came in.
 837  *      a_clientVersionNum  : Client version number.
 838  *      a_opCode            : Desired operation.
 839  *      a_serverVersionNumP : Ptr to version number to set.
 840  *      a_timeP             : Ptr to time value (seconds) to set.
 841  *      a_dataArray         : Ptr to variable array structure to return
 842  *                            stuff in.
 843  *
 844  * Returns:
 845  *      0 (always).
 846  *
 847  * Environment:
 848  *      Nothing interesting.
 849  *
 850  * Side Effects:
 851  *      As advertised.
 852  *------------------------------------------------------------------------*/
 853
 854 int
 855 SRXAFSCB_GetXStats(struct rx_call *a_call, afs_int32 a_clientVersionNum,
 856                    afs_int32 a_collectionNumber, afs_int32 * a_srvVersionNumP,
 857                    afs_int32 * a_timeP, AFSCB_CollData * a_dataP)
 858 {
 859     int code;           /*Return value */
 860     afs_int32 *dataBuffP;       /*Ptr to data to be returned */
 861     afs_int32 dataBytes;        /*Bytes in data buffer */
 862     XSTATS_DECLS;
 863
 864     RX_AFS_GLOCK();
 865
 866     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETXSTATS);
 867
 868     /*
 869      * Record the time of day and the server version number.
 870      */
 871     *a_srvVersionNumP = AFSCB_XSTAT_VERSION;
 872     *a_timeP = osi_Time();
 873
 874     /*
 875      * Stuff the appropriate data in there (assume victory)
 876      */
 877     code = 0;
 878
 879 #ifdef AFS_NOSTATS
 880     /*
 881      * We're not keeping stats, so just return successfully with
 882      * no data.
 883      */
 884     a_dataP->AFSCB_CollData_len = 0;
 885     a_dataP->AFSCB_CollData_val = NULL;
 886 #else
 887     switch (a_collectionNumber) {
 888     case AFSCB_XSTATSCOLL_CALL_INFO:
 889         /*
 890          * Pass back all the call-count-related data.
 891          *
 892          * >>> We are forced to allocate a separate area in which to
 893          * >>> put this stuff in by the RPC stub generator, since it
 894          * >>> will be freed at the tail end of the server stub code.
 895          */
 896         dataBytes = sizeof(struct afs_CMStats);
 897         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
 898         osi_Assert(dataBuffP != NULL);
 899         memcpy((char *)dataBuffP, (char *)&afs_cmstats, dataBytes);
 900         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
 901         a_dataP->AFSCB_CollData_val = dataBuffP;
 902         break;
 903
 904     case AFSCB_XSTATSCOLL_PERF_INFO:
 905         /*
 906          * Update and then pass back all the performance-related data.
 907          * Note: the only performance fields that need to be computed
 908          * at this time are the number of accesses for this collection
 909          * and the current server record info.
 910          *
 911          * >>> We are forced to allocate a separate area in which to
 912          * >>> put this stuff in by the RPC stub generator, since it
 913          * >>> will be freed at the tail end of the server stub code.
 914          */
 915         afs_stats_cmperf.numPerfCalls++;
 916         afs_CountServers();
 917         dataBytes = sizeof(afs_stats_cmperf);
 918         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
 919         osi_Assert(dataBuffP != NULL);
 920         memcpy((char *)dataBuffP, (char *)&afs_stats_cmperf, dataBytes);
 921         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
 922         a_dataP->AFSCB_CollData_val = dataBuffP;
 923         break;
 924
 925     case AFSCB_XSTATSCOLL_FULL_PERF_INFO:
 926         /*
 927          * Pass back the full range of performance and statistical
 928          * data available.  We have to bring the normal performance
 929          * data collection up to date, then copy that data into
 930          * the full collection.
 931          *
 932          * >>> We are forced to allocate a separate area in which to
 933          * >>> put this stuff in by the RPC stub generator, since it
 934          * >>> will be freed at the tail end of the server stub code.
 935          */
 936         afs_stats_cmperf.numPerfCalls++;
 937         afs_CountServers();
 938         memcpy((char *)(&(afs_stats_cmfullperf.perf)),
 939                (char *)(&afs_stats_cmperf), sizeof(struct afs_stats_CMPerf));
 940         afs_stats_cmfullperf.numFullPerfCalls++;
 941
 942         dataBytes = sizeof(afs_stats_cmfullperf);
 943         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
 944         osi_Assert(dataBuffP != NULL);
 945         memcpy((char *)dataBuffP, (char *)(&afs_stats_cmfullperf), dataBytes);
 946         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
 947         a_dataP->AFSCB_CollData_val = dataBuffP;
 948         break;
 949
 950     default:
 951         /*
 952          * Illegal collection number.
 953          */
 954         a_dataP->AFSCB_CollData_len = 0;
 955         a_dataP->AFSCB_CollData_val = NULL;
 956         code = 1;
 957     }                           /*Switch on collection number */
 958 #endif /* AFS_NOSTATS */
 959
 960     XSTATS_END_TIME;
 961
 962     RX_AFS_GUNLOCK();
 963
 964     return (code);
 965
 966 }                               /*SRXAFSCB_GetXStats */
 967
 968
 969 /*------------------------------------------------------------------------
 970  * EXPORTED afs_RXCallBackServer
 971  *
 972  * Description:
 973  *      Body of the thread supporting callback services.
 974  *
 975  * Arguments:
 976  *      None.
 977  *
 978  * Returns:
 979  *      0 (always).
 980  *
 981  * Environment:
 982  *      Nothing interesting.
 983  *
 984  * Side Effects:
 985  *      As advertised.
 986  *------------------------------------------------------------------------*/
 987
 988 int
 989 afs_RXCallBackServer(void)
 990 {
 991     AFS_STATCNT(afs_RXCallBackServer);
 992
 993     while (1) {
 994         if (afs_server)
 995             break;
 996         afs_osi_Sleep(&afs_server);
 997     }
 998
 999     /*
1000      * Donate this process to Rx.
1001      */
1002     rx_ServerProc(NULL);
1003     return (0);
1004
1005 }                               /*afs_RXCallBackServer */
1006
1007
1008 /*------------------------------------------------------------------------
1009  * EXPORTED shutdown_CB
1010  *
1011  * Description:
1012  *      Zero out important Cache Manager data structures.
1013  *
1014  * Arguments:
1015  *      None.
1016  *
1017  * Returns:
1018  *      0 (always).
1019  *
1020  * Environment:
1021  *      Nothing interesting.
1022  *
1023  * Side Effects:
1024  *      As advertised.
1025  *------------------------------------------------------------------------*/
1026
1027 int
1028 shutdown_CB(void)
1029 {
1030     AFS_STATCNT(shutdown_CB);
1031
1032     if (afs_cold_shutdown) {
1033         afs_oddCBs = afs_evenCBs = afs_allCBs = afs_allZaps = afs_oddZaps =
1034             afs_evenZaps = afs_connectBacks = 0;
1035     }
1036
1037     return (0);
1038
1039 }                               /*shutdown_CB */
1040
1041 /*------------------------------------------------------------------------
1042  * EXPORTED SRXAFSCB_InitCallBackState2
1043  *
1044  * Description:
1045  *      This routine was used in the AFS 3.5 beta release, but not anymore.
1046  *      It has since been replaced by SRXAFSCB_InitCallBackState3.
1047  *
1048  * Arguments:
1049  *      a_call : Ptr to Rx call on which this request came in.
1050  *
1051  * Returns:
1052  *      RXGEN_OPCODE (always).
1053  *
1054  * Environment:
1055  *      Nothing interesting.
1056  *
1057  * Side Effects:
1058  *      None
1059  *------------------------------------------------------------------------*/
1060
1061 int
1062 SRXAFSCB_InitCallBackState2(struct rx_call *a_call,
1063                             struct interfaceAddr *addr)
1064 {
1065     return RXGEN_OPCODE;
1066 }
1067
1068 /*------------------------------------------------------------------------
1069  * EXPORTED SRXAFSCB_WhoAreYou
1070  *
1071  * Description:
1072  *      Routine called by the server-side callback RPC interface to
1073  *      obtain a unique identifier for the client. The server uses
1074  *      this identifier to figure out whether or not two RX connections
1075  *      are from the same client, and to find out which addresses go
1076  *      with which clients.
1077  *
1078  * Arguments:
1079  *      a_call : Ptr to Rx call on which this request came in.
1080  *      addr: Ptr to return the list of interfaces for this client.
1081  *
1082  * Returns:
1083  *      0 (Always)
1084  *
1085  * Environment:
1086  *      Nothing interesting.
1087  *
1088  * Side Effects:
1089  *      As advertised.
1090  *------------------------------------------------------------------------*/
1091
1092 int
1093 SRXAFSCB_WhoAreYou(struct rx_call *a_call, struct interfaceAddr *addr)
1094 {
1095     int i;
1096     int code = 0;
1097
1098     RX_AFS_GLOCK();
1099
1100     AFS_STATCNT(SRXAFSCB_WhoAreYou);
1101
1102     memset(addr, 0, sizeof(*addr));
1103
1104     ObtainReadLock(&afs_xinterface);
1105
1106     /* return all network interface addresses */
1107     addr->numberOfInterfaces = afs_cb_interface.numberOfInterfaces;
1108     addr->uuid = afs_cb_interface.uuid;
1109     for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1110         addr->addr_in[i] = ntohl(afs_cb_interface.addr_in[i]);
1111         addr->subnetmask[i] = ntohl(afs_cb_interface.subnetmask[i]);
1112         addr->mtu[i] = ntohl(afs_cb_interface.mtu[i]);
1113     }
1114
1115     ReleaseReadLock(&afs_xinterface);
1116
1117     RX_AFS_GUNLOCK();
1118
1119     return code;
1120 }
1121
1122
1123 /*------------------------------------------------------------------------
1124  * EXPORTED SRXAFSCB_InitCallBackState3
1125  *
1126  * Description:
1127  *      Routine called by the server-side callback RPC interface to
1128  *      implement clearing all callbacks from this host.
1129  *
1130  * Arguments:
1131  *      a_call : Ptr to Rx call on which this request came in.
1132  *
1133  * Returns:
1134  *      0 (always).
1135  *
1136  * Environment:
1137  *      Nothing interesting.
1138  *
1139  * Side Effects:
1140  *      As advertised.
1141  *------------------------------------------------------------------------*/
1142
1143 int
1144 SRXAFSCB_InitCallBackState3(struct rx_call *a_call, afsUUID * a_uuid)
1145 {
1146     int code;
1147
1148     /*
1149      * TBD: Lookup the server by the UUID instead of its IP address.
1150      */
1151     code = SRXAFSCB_InitCallBackState(a_call);
1152
1153     return code;
1154 }
1155
1156
1157 /*------------------------------------------------------------------------
1158  * EXPORTED SRXAFSCB_ProbeUuid
1159  *
1160  * Description:
1161  *      Routine called by the server-side callback RPC interface to
1162  *      implement ``probing'' the Cache Manager, just making sure it's
1163  *      still there is still the same client it used to be.
1164  *
1165  * Arguments:
1166  *      a_call : Ptr to Rx call on which this request came in.
1167  *      a_uuid : Ptr to UUID that must match the client's UUID.
1168  *
1169  * Returns:
1170  *      0 if a_uuid matches the UUID for this client
1171  *      Non-zero otherwize
1172  *
1173  * Environment:
1174  *      Nothing interesting.
1175  *
1176  * Side Effects:
1177  *      As advertised.
1178  *------------------------------------------------------------------------*/
1179
1180 int
1181 SRXAFSCB_ProbeUuid(struct rx_call *a_call, afsUUID * a_uuid)
1182 {
1183     int code = 0;
1184     XSTATS_DECLS;
1185
1186     RX_AFS_GLOCK();
1187     AFS_STATCNT(SRXAFSCB_Probe);
1188
1189     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_PROBE);
1190     if (!afs_uuid_equal(a_uuid, &afs_cb_interface.uuid))
1191         code = 1;               /* failure */
1192     XSTATS_END_TIME;
1193
1194     RX_AFS_GUNLOCK();
1195
1196     return code;
1197 }
1198
1199
1200 /*------------------------------------------------------------------------
1201  * EXPORTED SRXAFSCB_GetServerPrefs
1202  *
1203  * Description:
1204  *      Routine to list server preferences used by this client.
1205  *
1206  * Arguments:
1207  *      a_call  : Ptr to Rx call on which this request came in.
1208  *      a_index : Input server index
1209  *      a_srvr_addr  : Output server address in host byte order
1210  *                     (0xffffffff on last server)
1211  *      a_srvr_rank  : Output server rank
1212  *
1213  * Returns:
1214  *      0 on success
1215  *
1216  * Environment:
1217  *      Nothing interesting.
1218  *
1219  * Side Effects:
1220  *      As advertised.
1221  *------------------------------------------------------------------------*/
1222
1223 int
1224 SRXAFSCB_GetServerPrefs(struct rx_call *a_call, afs_int32 a_index,
1225                         afs_int32 * a_srvr_addr, afs_int32 * a_srvr_rank)
1226 {
1227     int i, j;
1228     struct srvAddr *sa;
1229
1230     RX_AFS_GLOCK();
1231     AFS_STATCNT(SRXAFSCB_GetServerPrefs);
1232
1233     ObtainReadLock(&afs_xserver);
1234
1235     /* Search the hash table for the server with this index */
1236     *a_srvr_addr = 0xffffffff;
1237     *a_srvr_rank = 0xffffffff;
1238     for (i = 0, j = 0; j < NSERVERS && i <= a_index; j++) {
1239         for (sa = afs_srvAddrs[j]; sa && i <= a_index; sa = sa->next_bkt, i++) {
1240             if (i == a_index) {
1241                 *a_srvr_addr = ntohl(sa->sa_ip);
1242                 *a_srvr_rank = sa->sa_iprank;
1243             }
1244         }
1245     }
1246
1247     ReleaseReadLock(&afs_xserver);
1248
1249     RX_AFS_GUNLOCK();
1250
1251     return 0;
1252 }
1253
1254
1255 /*------------------------------------------------------------------------
1256  * EXPORTED SRXAFSCB_GetCellServDB
1257  *
1258  * Description:
1259  *      Routine to list cells configured for this client
1260  *
1261  * Arguments:
1262  *      a_call  : Ptr to Rx call on which this request came in.
1263  *      a_index : Input cell index
1264  *      a_name  : Output cell name ("" on last cell)
1265  *      a_hosts : Output cell database servers in host byte order.
1266  *
1267  * Returns:
1268  *      0 on success
1269  *
1270  * Environment:
1271  *      Nothing interesting.
1272  *
1273  * Side Effects:
1274  *      As advertised.
1275  *------------------------------------------------------------------------*/
1276
1277 int
1278 SRXAFSCB_GetCellServDB(struct rx_call *a_call, afs_int32 a_index,
1279                        char **a_name, serverList * a_hosts)
1280 {
1281     afs_int32 i, j = 0;
1282     struct cell *tcell;
1283     char *t_name, *p_name = NULL;
1284
1285     RX_AFS_GLOCK();
1286     AFS_STATCNT(SRXAFSCB_GetCellServDB);
1287
1288     tcell = afs_GetCellByIndex(a_index, READ_LOCK);
1289
1290     if (!tcell) {
1291         i = 0;
1292         a_hosts->serverList_val = 0;
1293         a_hosts->serverList_len = 0;
1294     } else {
1295         p_name = tcell->cellName;
1296         for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++);
1297         i = strlen(p_name);
1298         a_hosts->serverList_val = afs_osi_Alloc(j * sizeof(afs_int32));
1299         osi_Assert(a_hosts->serverList_val != NULL);
1300         a_hosts->serverList_len = j;
1301         for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++)
1302             a_hosts->serverList_val[j] =
1303                 ntohl(tcell->cellHosts[j]->addr->sa_ip);
1304         afs_PutCell(tcell, READ_LOCK);
1305     }
1306
1307     t_name = afs_osi_Alloc(i + 1);
1308     if (t_name == NULL) {
1309         if (tcell != NULL)
1310             afs_osi_Free(a_hosts->serverList_val, (j * sizeof(afs_int32)));
1311         RX_AFS_GUNLOCK();
1312         return ENOMEM;
1313     }
1314
1315     t_name[i] = '\0';
1316     if (p_name)
1317         memcpy(t_name, p_name, i);
1318
1319     RX_AFS_GUNLOCK();
1320
1321     *a_name = t_name;
1322     return 0;
1323 }
1324
1325
1326 /*------------------------------------------------------------------------
1327  * EXPORTED SRXAFSCB_GetLocalCell
1328  *
1329  * Description:
1330  *      Routine to return name of client's local cell
1331  *
1332  * Arguments:
1333  *      a_call  : Ptr to Rx call on which this request came in.
1334  *      a_name  : Output cell name
1335  *
1336  * Returns:
1337  *      0 on success
1338  *
1339  * Environment:
1340  *      Nothing interesting.
1341  *
1342  * Side Effects:
1343  *      As advertised.
1344  *------------------------------------------------------------------------*/
1345
1346 int
1347 SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
1348 {
1349     int plen;
1350     struct cell *tcell;
1351     char *t_name, *p_name = NULL;
1352
1353     RX_AFS_GLOCK();
1354     AFS_STATCNT(SRXAFSCB_GetLocalCell);
1355
1356     /* Search the list for the primary cell. Cell number 1 is only
1357      * the primary cell is when no other cell is explicitly marked as
1358      * the primary cell.  */
1359     tcell = afs_GetPrimaryCell(READ_LOCK);
1360     if (tcell)
1361         p_name = tcell->cellName;
1362     if (p_name)
1363         plen = strlen(p_name);
1364     else
1365         plen = 0;
1366     t_name = afs_osi_Alloc(plen + 1);
1367     if (t_name == NULL) {
1368         if (tcell)
1369             afs_PutCell(tcell, READ_LOCK);
1370         RX_AFS_GUNLOCK();
1371         return ENOMEM;
1372     }
1373
1374     t_name[plen] = '\0';
1375     if (p_name)
1376         memcpy(t_name, p_name, plen);
1377
1378     RX_AFS_GUNLOCK();
1379
1380     *a_name = t_name;
1381     if (tcell)
1382         afs_PutCell(tcell, READ_LOCK);
1383     return 0;
1384 }
1385
1386
1387 /*
1388  * afs_MarshallCacheConfig - marshall client cache configuration
1389  *
1390  * PARAMETERS
1391  *
1392  * IN callerVersion - the rpc stat version of the caller.
1393  *
1394  * IN config - client cache configuration.
1395  *
1396  * OUT ptr - buffer where configuration is marshalled.
1397  *
1398  * RETURN CODES
1399  *
1400  * Returns void.
1401  */
1402 static void
1403 afs_MarshallCacheConfig(afs_uint32 callerVersion, cm_initparams_v1 * config,
1404                         afs_uint32 * ptr)
1405 {
1406     AFS_STATCNT(afs_MarshallCacheConfig);
1407     /*
1408      * We currently only support version 1.
1409      */
1410     *(ptr++) = config->nChunkFiles;
1411     *(ptr++) = config->nStatCaches;
1412     *(ptr++) = config->nDataCaches;
1413     *(ptr++) = config->nVolumeCaches;
1414     *(ptr++) = config->firstChunkSize;
1415     *(ptr++) = config->otherChunkSize;
1416     *(ptr++) = config->cacheSize;
1417     *(ptr++) = config->setTime;
1418     *(ptr++) = config->memCache;
1419 }
1420
1421
1422 /*------------------------------------------------------------------------
1423  * EXPORTED SRXAFSCB_GetCacheConfig
1424  *
1425  * Description:
1426  *      Routine to return parameters used to initialize client cache.
1427  *      Client may request any format version. Server may not return
1428  *      format version greater than version requested by client.
1429  *
1430  * Arguments:
1431  *      a_call:        Ptr to Rx call on which this request came in.
1432  *      callerVersion: Data format version desired by the client.
1433  *      serverVersion: Data format version of output data.
1434  *      configCount:   Number bytes allocated for output data.
1435  *      config:        Client cache configuration.
1436  *
1437  * Returns:
1438  *      0 on success
1439  *
1440  * Environment:
1441  *      Nothing interesting.
1442  *
1443  * Side Effects:
1444  *      As advertised.
1445  *------------------------------------------------------------------------*/
1446
1447 int
1448 SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
1449                         afs_uint32 * serverVersion, afs_uint32 * configCount,
1450                         cacheConfig * config)
1451 {
1452     afs_uint32 *t_config;
1453     size_t allocsize;
1454     cm_initparams_v1 cm_config;
1455
1456     RX_AFS_GLOCK();
1457     AFS_STATCNT(SRXAFSCB_GetCacheConfig);
1458
1459     /*
1460      * Currently only support version 1
1461      */
1462     allocsize = sizeof(cm_initparams_v1);
1463     t_config = afs_osi_Alloc(allocsize);
1464     if (t_config == NULL) {
1465         RX_AFS_GUNLOCK();
1466         return ENOMEM;
1467     }
1468
1469     cm_config.nChunkFiles = cm_initParams.cmi_nChunkFiles;
1470     cm_config.nStatCaches = cm_initParams.cmi_nStatCaches;
1471     cm_config.nDataCaches = cm_initParams.cmi_nDataCaches;
1472     cm_config.nVolumeCaches = cm_initParams.cmi_nVolumeCaches;
1473     cm_config.firstChunkSize = cm_initParams.cmi_firstChunkSize;
1474     cm_config.otherChunkSize = cm_initParams.cmi_otherChunkSize;
1475     cm_config.cacheSize = cm_initParams.cmi_cacheSize;
1476     cm_config.setTime = cm_initParams.cmi_setTime;
1477     cm_config.memCache = cm_initParams.cmi_memCache;
1478
1479     afs_MarshallCacheConfig(callerVersion, &cm_config, t_config);
1480
1481     *serverVersion = AFS_CLIENT_RETRIEVAL_FIRST_EDITION;
1482     *configCount = allocsize;
1483     config->cacheConfig_val = t_config;
1484     config->cacheConfig_len = allocsize / sizeof(afs_uint32);
1485
1486     RX_AFS_GUNLOCK();
1487
1488     return 0;
1489 }
1490
1491 /*------------------------------------------------------------------------
1492  * EXPORTED SRXAFSCB_FetchData
1493  *
1494  * Description:
1495  *      Routine to do third party move from a remioserver to the original
1496  *      issuer of an ArchiveData request. Presently supported only by the
1497  *      "fs" command, not by the AFS client.
1498  *
1499  * Arguments:
1500  *      rxcall:        Ptr to Rx call on which this request came in.
1501  *      Fid:           pointer to AFSFid structure.
1502  *      Fd:            File descriptor inside fs command.
1503  *      Position:      Offset in the file.
1504  *      Length:        Data length to transfer.
1505  *      TotalLength:   Pointer to total file length field
1506  *
1507  * Returns:
1508  *      0 on success
1509  *
1510  * Environment:
1511  *      Nothing interesting.
1512  *
1513  * Side Effects:
1514  *------------------------------------------------------------------------*/
1515 int
1516 SRXAFSCB_FetchData(struct rx_call *rxcall, struct AFSFid *Fid, afs_int32 Fd,
1517                    afs_int64 Position, afs_int64 Length,
1518                    afs_int64 * TotalLength)
1519 {
1520     return ENOSYS;
1521 }
1522
1523 /*------------------------------------------------------------------------
1524  * EXPORTED SRXAFSCB_StoreData
1525  *
1526  * Description:
1527  *      Routine to do third party move from a remioserver to the original
1528  *      issuer of a RetrieveData request. Presently supported only by the
1529  *      "fs" command, not by the AFS client.
1530  *
1531  * Arguments:
1532  *      rxcall:        Ptr to Rx call on which this request came in.
1533  *      Fid:           pointer to AFSFid structure.
1534  *      Fd:            File descriptor inside fs command.
1535  *      Position:      Offset in the file.
1536  *      Length:        Data length to transfer.
1537  *      TotalLength:   Pointer to total file length field
1538  *
1539  * Returns:
1540  *      0 on success
1541  *
1542  * Environment:
1543  *      Nothing interesting.
1544  *
1545  * Side Effects:
1546  *      As advertised.
1547  *------------------------------------------------------------------------*/
1548 int
1549 SRXAFSCB_StoreData(struct rx_call *rxcall, struct AFSFid *Fid, afs_int32 Fd,
1550                    afs_int64 Position, afs_int64 Length,
1551                    afs_int64 * TotalLength)
1552 {
1553     return ENOSYS;
1554 }
1555
1556 /*------------------------------------------------------------------------
1557  * EXPORTED SRXAFSCB_GetCellByNum
1558  *
1559  * Description:
1560  *      Routine to get information about a cell specified by its
1561  *      cell number (returned by GetCE/GetCE64).
1562  *
1563  * Arguments:
1564  *      a_call    : Ptr to Rx call on which this request came in.
1565  *      a_cellnum : Input cell number
1566  *      a_name    : Output cell name (one zero byte when no such cell).
1567  *      a_hosts   : Output cell database servers in host byte order.
1568  *
1569  * Returns:
1570  *      0 on success
1571  *
1572  * Environment:
1573  *      Nothing interesting.
1574  *
1575  * Side Effects:
1576  *      As advertised.
1577  *------------------------------------------------------------------------*/
1578
1579 int
1580 SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_cellnum,
1581                       char **a_name, serverList * a_hosts)
1582 {
1583     afs_int32 i, sn;
1584     struct cell *tcell;
1585
1586     RX_AFS_GLOCK();
1587     AFS_STATCNT(SRXAFSCB_GetCellByNum);
1588
1589     a_hosts->serverList_val = 0;
1590     a_hosts->serverList_len = 0;
1591
1592     tcell = afs_GetCellStale(a_cellnum, READ_LOCK);
1593     if (!tcell) {
1594         *a_name = afs_strdup("");
1595         RX_AFS_GUNLOCK();
1596         return 0;
1597     }
1598
1599     ObtainReadLock(&tcell->lock);
1600     *a_name = afs_strdup(tcell->cellName);
1601
1602     for (sn = 0; sn < AFSMAXCELLHOSTS && tcell->cellHosts[sn]; sn++);
1603     a_hosts->serverList_len = sn;
1604     a_hosts->serverList_val = afs_osi_Alloc(sn * sizeof(afs_int32));
1605     osi_Assert(a_hosts->serverList_val != NULL);
1606
1607     for (i = 0; i < sn; i++)
1608         a_hosts->serverList_val[i] = ntohl(tcell->cellHosts[i]->addr->sa_ip);
1609     ReleaseReadLock(&tcell->lock);
1610     afs_PutCell(tcell, READ_LOCK);
1611
1612     RX_AFS_GUNLOCK();
1613     return 0;
1614 }
1615
1616 int
1617 SRXAFSCB_TellMeAboutYourself(struct rx_call *a_call,
1618                              struct interfaceAddr *addr,
1619                              Capabilities * capabilities)
1620 {
1621     int i;
1622     int code = 0;
1623     afs_uint32 *dataBuffP;
1624     afs_int32 dataBytes;
1625
1626     RX_AFS_GLOCK();
1627
1628     AFS_STATCNT(SRXAFSCB_WhoAreYou);
1629
1630     ObtainReadLock(&afs_xinterface);
1631
1632     /* return all network interface addresses */
1633     addr->numberOfInterfaces = afs_cb_interface.numberOfInterfaces;
1634     addr->uuid = afs_cb_interface.uuid;
1635     for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1636         addr->addr_in[i] = ntohl(afs_cb_interface.addr_in[i]);
1637         addr->subnetmask[i] = ntohl(afs_cb_interface.subnetmask[i]);
1638         addr->mtu[i] = ntohl(afs_cb_interface.mtu[i]);
1639     }
1640
1641     ReleaseReadLock(&afs_xinterface);
1642
1643     RX_AFS_GUNLOCK();
1644
1645     dataBytes = 1 * sizeof(afs_uint32);
1646     dataBuffP = afs_osi_Alloc(dataBytes);
1647     osi_Assert(dataBuffP != NULL);
1648     dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
1649     capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
1650     capabilities->Capabilities_val = dataBuffP;
1651
1652     return code;
1653 }
1654
1655
1656 #if 0 && defined(AFS_LINUX24_ENV)
1657 extern struct vcache *afs_globalVp;
1658
1659 int recurse_dcache_parent(parent, a_index, addr, inode, flags, time, fileName)
1660      struct dentry * parent;
1661     afs_int32 a_index;
1662     afs_int32 *addr;
1663     afs_int32 *inode;
1664     afs_int32 *flags;
1665     afs_int32 *time;
1666     char ** fileName;
1667 {
1668         struct dentry *this_parent = parent;
1669         struct list_head *next;
1670         int found = 0;
1671         struct dentry *dentry;
1672
1673 repeat:
1674         next = this_parent->d_subdirs.next;
1675 resume:
1676         while (next != &this_parent->d_subdirs) {
1677                 struct list_head *tmp = next;
1678                 dentry = list_entry(tmp, struct dentry, d_child);
1679                 if (a_index == 0)
1680                   goto searchdone3;
1681                 a_index--;
1682                 next = tmp->next;
1683                 /*
1684                  * Descend a level if the d_subdirs list is non-empty.
1685                  */
1686                 if (!list_empty(&dentry->d_subdirs)) {
1687                         this_parent = dentry;
1688                         goto repeat;
1689                 }
1690         }
1691         /*
1692          * All done at this level ... ascend and resume the search.
1693          */
1694         if (this_parent != parent) {
1695                 next = this_parent->d_child.next;
1696                 this_parent = this_parent->d_parent;
1697                 goto resume;
1698         }
1699         goto ret;
1700
1701  searchdone3:
1702     if (d_unhashed(dentry))
1703       *flags = 1;
1704     else
1705       *flags = 0;
1706
1707     *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
1708     *inode = ITOAFS(dentry->d_inode);
1709     *addr = atomic_read(&(dentry)->d_count);
1710     *time = dentry->d_time;
1711
1712     return 0;
1713  ret:
1714     return 1;
1715 }
1716 #endif
1717
1718 int
1719 SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
1720                afs_int32 *inode, afs_int32 *flags, afs_int32 *time,
1721                char ** fileName)
1722 { /*SRXAFSCB_GetDE*/
1723     int code = 0;                               /*Return code*/
1724 #if 0 && defined(AFS_LINUX24_ENV)
1725     int i;                      /*Loop variable*/
1726     struct vcache *tvc = afs_globalVp;
1727     struct dentry *dentry;
1728     struct list_head *cur, *head = &(AFSTOI(tvc))->i_dentry;
1729
1730 #ifdef RX_ENABLE_LOCKS
1731     AFS_GLOCK();
1732 #endif /* RX_ENABLE_LOCKS */
1733
1734 #if defined(AFS_LINUX24_ENV)
1735     spin_lock(&dcache_lock);
1736 #endif
1737
1738     cur = head;
1739     while ((cur = cur->next) != head) {
1740       dentry = list_entry(cur, struct dentry, d_alias);
1741
1742       dget_locked(dentry);
1743
1744 #if defined(AFS_LINUX24_ENV)
1745       spin_unlock(&dcache_lock);
1746 #endif
1747       if (a_index == 0)
1748         goto searchdone2;
1749       a_index--;
1750
1751       if (recurse_dcache_parent(dentry, a_index, addr, inode, flags, time, fileName) == 0) {
1752         dput(dentry);
1753         code = 0;
1754         goto fcnDone;
1755       }
1756       dput(dentry);
1757     }
1758  searchdone2:
1759     if (cur == head) {
1760         /*Past EOF*/
1761         code = 1;
1762         *fileName = afs_strdup("");
1763         goto fcnDone;
1764     }
1765
1766     if (d_unhashed(dentry))
1767       *flags = 1;
1768     else
1769       *flags = 0;
1770
1771     *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
1772     *inode = ITOAFS(dentry->d_inode);
1773     *addr = atomic_read(&(dentry)->d_count);
1774     *time = dentry->d_time;
1775
1776     dput(dentry);
1777     code = 0;
1778
1779 fcnDone:
1780
1781 #ifdef RX_ENABLE_LOCKS
1782     AFS_GUNLOCK();
1783 #endif /* RX_ENABLE_LOCKS */
1784 #endif
1785     return(code);
1786
1787 } /*SRXAFSCB_GetDE*/