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