d9d24f8f49ffd61fcbd5e8b4119674d2bf5be8bc
[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                             if (!(tvc->f.states & CBulkFetching)) {
457                                 ReleaseReadLock(&afs_xvcache);
458                                 afs_osi_Sleep(&tvc->f.states);
459                                 goto loop1;
460                             }
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                         if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
472                             AFS_GUNLOCK();
473                             vnode_recycle(AFSTOV(tvc));
474                             AFS_GLOCK();
475                         }
476 #else
477                         AFS_FAST_HOLD(tvc);
478 #endif
479 #endif
480                         ReleaseReadLock(&afs_xvcache);
481                         ObtainWriteLock(&afs_xcbhash, 449);
482                         afs_DequeueCallback(tvc);
483                         tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
484                         afs_allCBs++;
485                         if (tvc->f.fid.Fid.Vnode & 1)
486                             afs_oddCBs++;
487                         else
488                             afs_evenCBs++;
489                         ReleaseWriteLock(&afs_xcbhash);
490                         if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
491                             osi_dnlc_purgedp(tvc);
492                         afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
493                                    ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
494                                    tvc->f.states, ICL_TYPE_INT32,
495                                    a_fid->Volume);
496 #ifdef AFS_DARWIN80_ENV
497                         vnode_put(AFSTOV(tvc));
498 #endif
499                         ObtainReadLock(&afs_xvcache);
500                         uq = QPrev(tq);
501                         AFS_FAST_RELE(tvc);
502                     } else if ((tvc->f.states & CMValid)
503                                && (tvc->mvid->Fid.Volume == a_fid->Volume)) {
504                         tvc->f.states &= ~CMValid;
505                         if (!localFid.Cell)
506                             localFid.Cell = tvc->mvid->Cell;
507                     }
508                 }
509                 ReleaseReadLock(&afs_xvcache);
510
511             /*
512              * XXXX Don't hold any locks here XXXX
513              */
514             tv = afs_FindVolume(&localFid, 0);
515             if (tv) {
516                 afs_ResetVolumeInfo(tv);
517                 afs_PutVolume(tv, 0);
518                 /* invalidate mtpoint? */
519             }
520         } /*Clear callbacks for whole volume */
521         else {
522             /*
523              * Clear callbacks just for the one file.
524              */
525             struct vcache *uvc;
526             afs_allCBs++;
527             if (a_fid->Vnode & 1)
528                 afs_oddCBs++;   /*Could do this on volume basis, too */
529             else
530                 afs_evenCBs++;  /*A particular fid was specified */
531 loop2:
532             ObtainReadLock(&afs_xvcache);
533             i = VCHash(&localFid);
534             for (tvc = afs_vhashT[i]; tvc; tvc = uvc) {
535                 uvc = tvc->hnext;
536                 if (tvc->f.fid.Fid.Vnode == a_fid->Vnode
537                     && tvc->f.fid.Fid.Volume == a_fid->Volume
538                     && tvc->f.fid.Fid.Unique == a_fid->Unique) {
539                     tvc->callback = NULL;
540                     tvc->dchint = NULL; /* invalidate hints */
541                     if (tvc->f.states & CVInit) {
542                         ReleaseReadLock(&afs_xvcache);
543                         afs_osi_Sleep(&tvc->f.states);
544                         goto loop2;
545                     }
546 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)  || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
547                     AFS_FAST_HOLD(tvc);
548 #else
549 #ifdef AFS_DARWIN80_ENV
550                     if (tvc->f.states & CDeadVnode) {
551                         if (!(tvc->f.states & CBulkFetching)) {
552                             ReleaseReadLock(&afs_xvcache);
553                             afs_osi_Sleep(&tvc->f.states);
554                             goto loop2;
555                         }
556                     }
557                     vp = AFSTOV(tvc);
558                     if (vnode_get(vp))
559                         continue;
560                     if (vnode_ref(vp)) {
561                         AFS_GUNLOCK();
562                         vnode_put(vp);
563                         AFS_GLOCK();
564                         continue;
565                     }
566                     if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
567                         AFS_GUNLOCK();
568                         vnode_recycle(AFSTOV(tvc));
569                         AFS_GLOCK();
570                     }
571 #else
572                     AFS_FAST_HOLD(tvc);
573 #endif
574 #endif
575                     ReleaseReadLock(&afs_xvcache);
576                     ObtainWriteLock(&afs_xcbhash, 450);
577                     afs_DequeueCallback(tvc);
578                     tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
579                     ReleaseWriteLock(&afs_xcbhash);
580                     if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
581                         osi_dnlc_purgedp(tvc);
582                     afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
583                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
584                                tvc->f.states, ICL_TYPE_LONG, 0);
585 #ifdef CBDEBUG
586                     lastCallBack_vnode = afid->Vnode;
587                     lastCallBack_dv = tvc->mstat.DataVersion.low;
588                     osi_GetuTime(&lastCallBack_time);
589 #endif /* CBDEBUG */
590 #ifdef AFS_DARWIN80_ENV
591                     vnode_put(AFSTOV(tvc));
592 #endif
593                     ObtainReadLock(&afs_xvcache);
594                     uvc = tvc->hnext;
595                     AFS_FAST_RELE(tvc);
596                 }
597             }                   /*Walk through hash table */
598             ReleaseReadLock(&afs_xvcache);
599         }                       /*Clear callbacks for one file */
600     }
601
602     /*Fid has non-zero volume ID */
603     /*
604      * Always return a predictable value.
605      */
606     return (0);
607
608 }                               /*ClearCallBack */
609
610
611 /*------------------------------------------------------------------------
612  * EXPORTED SRXAFSCB_CallBack
613  *
614  * Description:
615  *      Routine called by the server-side callback RPC interface to
616  *      implement passing in callback information.
617  *      table.
618  *
619  * Arguments:
620  *      a_call      : Ptr to Rx call on which this request came in.
621  *      a_fids      : Ptr to array of fids involved.
622  *      a_callbacks : Ptr to matching callback info for the fids.
623  *
624  * Returns:
625  *      0 (always).
626  *
627  * Environment:
628  *      Nothing interesting.
629  *
630  * Side Effects:
631  *      As advertised.
632  *------------------------------------------------------------------------*/
633
634 int
635 SRXAFSCB_CallBack(struct rx_call *a_call, struct AFSCBFids *a_fids,
636                   struct AFSCBs *a_callbacks)
637 {
638     int i;              /*Loop variable */
639     struct AFSFid *tfid;        /*Ptr to current fid */
640     struct rx_connection *tconn;        /*Call's connection */
641     int code = 0;
642     XSTATS_DECLS;
643
644     RX_AFS_GLOCK();
645
646     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_CALLBACK);
647
648     AFS_STATCNT(SRXAFSCB_CallBack);
649     if (!(tconn = rx_ConnectionOf(a_call)))
650         return (0);
651     tfid = (struct AFSFid *)a_fids->AFSCBFids_val;
652
653     /*
654      * For now, we ignore callbacks, since the File Server only *breaks*
655      * callbacks at present.
656      */
657     for (i = 0; i < a_fids->AFSCBFids_len; i++)
658         ClearCallBack(tconn, &tfid[i]);
659
660     XSTATS_END_TIME;
661
662     RX_AFS_GUNLOCK();
663
664     return (0);
665
666 }                               /*SRXAFSCB_CallBack */
667
668
669 /*------------------------------------------------------------------------
670  * EXPORTED SRXAFSCB_Probe
671  *
672  * Description:
673  *      Routine called by the server-side callback RPC interface to
674  *      implement ``probing'' the Cache Manager, just making sure it's
675  *      still there.
676  *
677  * Arguments:
678  *      a_call : Ptr to Rx call on which this request came in.
679  *
680  * Returns:
681  *      0 (always).
682  *
683  * Environment:
684  *      Nothing interesting.
685  *
686  * Side Effects:
687  *      As advertised.
688  *------------------------------------------------------------------------*/
689
690 int
691 SRXAFSCB_Probe(struct rx_call *a_call)
692 {
693     int code = 0;
694     XSTATS_DECLS;
695
696     RX_AFS_GLOCK();
697     AFS_STATCNT(SRXAFSCB_Probe);
698
699     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_PROBE);
700     XSTATS_END_TIME;
701
702     RX_AFS_GUNLOCK();
703
704     return (0);
705
706 }                               /*SRXAFSCB_Probe */
707
708
709 /*------------------------------------------------------------------------
710  * EXPORTED SRXAFSCB_InitCallBackState
711  *
712  * Description:
713  *      Routine called by the server-side callback RPC interface to
714  *      implement clearing all callbacks from this host.
715  *
716  * Arguments:
717  *      a_call : Ptr to Rx call on which this request came in.
718  *
719  * Returns:
720  *      0 (always).
721  *
722  * Environment:
723  *      Nothing interesting.
724  *
725  * Side Effects:
726  *      As advertised.
727  *------------------------------------------------------------------------*/
728
729 int
730 SRXAFSCB_InitCallBackState(struct rx_call *a_call)
731 {
732     int i;
733     struct vcache *tvc;
734     struct rx_connection *tconn;
735     struct rx_peer *peer;
736     struct server *ts;
737     int code = 0;
738     XSTATS_DECLS;
739
740     RX_AFS_GLOCK();
741
742     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_INITCALLBACKSTATE);
743     AFS_STATCNT(SRXAFSCB_InitCallBackState);
744
745     /*
746      * Find the address of the host making this call
747      */
748     if ((tconn = rx_ConnectionOf(a_call)) && (peer = rx_PeerOf(tconn))) {
749
750         afs_allCBs++;
751         afs_oddCBs++;           /*Including any missed via create race */
752         afs_evenCBs++;          /*Including any missed via create race */
753
754         ts = afs_FindServer(rx_HostOf(peer), rx_PortOf(peer), (afsUUID *) 0,
755                             0);
756         if (ts) {
757             for (i = 0; i < VCSIZE; i++)
758                 for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
759                     if (tvc->callback == ts) {
760                         ObtainWriteLock(&afs_xcbhash, 451);
761                         afs_DequeueCallback(tvc);
762                         tvc->callback = NULL;
763                         tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
764                         ReleaseWriteLock(&afs_xcbhash);
765                     }
766                 }
767
768             /* capabilities need be requested again */
769             ts->flags &= ~SCAPS_KNOWN;
770         }
771
772
773
774         /* find any volumes residing on this server and flush their state */
775         {
776             struct volume *tv;
777             int j;
778
779             for (i = 0; i < NVOLS; i++)
780                 for (tv = afs_volumes[i]; tv; tv = tv->next) {
781                     for (j = 0; j < AFS_MAXHOSTS; j++)
782                         if (tv->serverHost[j] == ts)
783                             afs_ResetVolumeInfo(tv);
784                 }
785         }
786         osi_dnlc_purge();       /* may be a little bit extreme */
787     }
788
789     XSTATS_END_TIME;
790
791     RX_AFS_GUNLOCK();
792
793     return (0);
794
795 }                               /*SRXAFSCB_InitCallBackState */
796
797
798 /*------------------------------------------------------------------------
799  * EXPORTED SRXAFSCB_XStatsVersion
800  *
801  * Description:
802  *      Routine called by the server-side callback RPC interface to
803  *      implement pulling out the xstat version number for the Cache
804  *      Manager.
805  *
806  * Arguments:
807  *      a_versionP : Ptr to the version number variable to set.
808  *
809  * Returns:
810  *      0 (always)
811  *
812  * Environment:
813  *      Nothing interesting.
814  *
815  * Side Effects:
816  *      As advertised.
817  *------------------------------------------------------------------------*/
818
819 int
820 SRXAFSCB_XStatsVersion(struct rx_call *a_call, afs_int32 * a_versionP)
821 {
822     int code = 0;
823
824     XSTATS_DECLS;
825
826     RX_AFS_GLOCK();
827     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_XSTATSVERSION);
828
829     *a_versionP = AFSCB_XSTAT_VERSION;
830
831     XSTATS_END_TIME;
832
833     RX_AFS_GUNLOCK();
834
835     return (0);
836 }                               /*SRXAFSCB_XStatsVersion */
837
838
839 /*------------------------------------------------------------------------
840  * EXPORTED SRXAFSCB_GetXStats
841  *
842  * Description:
843  *      Routine called by the server-side callback RPC interface to
844  *      implement getting the given data collection from the extended
845  *      Cache Manager statistics.
846  *
847  * Arguments:
848  *      a_call              : Ptr to Rx call on which this request came in.
849  *      a_clientVersionNum  : Client version number.
850  *      a_opCode            : Desired operation.
851  *      a_serverVersionNumP : Ptr to version number to set.
852  *      a_timeP             : Ptr to time value (seconds) to set.
853  *      a_dataArray         : Ptr to variable array structure to return
854  *                            stuff in.
855  *
856  * Returns:
857  *      0 (always).
858  *
859  * Environment:
860  *      Nothing interesting.
861  *
862  * Side Effects:
863  *      As advertised.
864  *------------------------------------------------------------------------*/
865
866 int
867 SRXAFSCB_GetXStats(struct rx_call *a_call, afs_int32 a_clientVersionNum,
868                    afs_int32 a_collectionNumber, afs_int32 * a_srvVersionNumP,
869                    afs_int32 * a_timeP, AFSCB_CollData * a_dataP)
870 {
871     int code;           /*Return value */
872     afs_int32 *dataBuffP;       /*Ptr to data to be returned */
873     afs_int32 dataBytes;        /*Bytes in data buffer */
874     XSTATS_DECLS;
875
876     RX_AFS_GLOCK();
877
878     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETXSTATS);
879
880     /*
881      * Record the time of day and the server version number.
882      */
883     *a_srvVersionNumP = AFSCB_XSTAT_VERSION;
884     *a_timeP = osi_Time();
885
886     /*
887      * Stuff the appropriate data in there (assume victory)
888      */
889     code = 0;
890
891 #ifdef AFS_NOSTATS
892     /*
893      * We're not keeping stats, so just return successfully with
894      * no data.
895      */
896     a_dataP->AFSCB_CollData_len = 0;
897     a_dataP->AFSCB_CollData_val = NULL;
898 #else
899     switch (a_collectionNumber) {
900     case AFSCB_XSTATSCOLL_CALL_INFO:
901         /*
902          * Pass back all the call-count-related data.
903          *
904          * >>> We are forced to allocate a separate area in which to
905          * >>> put this stuff in by the RPC stub generator, since it
906          * >>> will be freed at the tail end of the server stub code.
907          */
908         dataBytes = sizeof(struct afs_CMStats);
909         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
910         osi_Assert(dataBuffP != NULL);
911         memcpy((char *)dataBuffP, (char *)&afs_cmstats, dataBytes);
912         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
913         a_dataP->AFSCB_CollData_val = dataBuffP;
914         break;
915
916     case AFSCB_XSTATSCOLL_PERF_INFO:
917         /*
918          * Update and then pass back all the performance-related data.
919          * Note: the only performance fields that need to be computed
920          * at this time are the number of accesses for this collection
921          * and the current server record info.
922          *
923          * >>> We are forced to allocate a separate area in which to
924          * >>> put this stuff in by the RPC stub generator, since it
925          * >>> will be freed at the tail end of the server stub code.
926          */
927         afs_stats_cmperf.numPerfCalls++;
928         afs_CountServers();
929         dataBytes = sizeof(afs_stats_cmperf);
930         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
931         osi_Assert(dataBuffP != NULL);
932         memcpy((char *)dataBuffP, (char *)&afs_stats_cmperf, dataBytes);
933         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
934         a_dataP->AFSCB_CollData_val = dataBuffP;
935         break;
936
937     case AFSCB_XSTATSCOLL_FULL_PERF_INFO:
938         /*
939          * Pass back the full range of performance and statistical
940          * data available.  We have to bring the normal performance
941          * data collection up to date, then copy that data into
942          * the full collection.
943          *
944          * >>> We are forced to allocate a separate area in which to
945          * >>> put this stuff in by the RPC stub generator, since it
946          * >>> will be freed at the tail end of the server stub code.
947          */
948         afs_stats_cmperf.numPerfCalls++;
949         afs_CountServers();
950         memcpy((char *)(&(afs_stats_cmfullperf.perf)),
951                (char *)(&afs_stats_cmperf), sizeof(struct afs_stats_CMPerf));
952         afs_stats_cmfullperf.numFullPerfCalls++;
953
954         dataBytes = sizeof(afs_stats_cmfullperf);
955         dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
956         osi_Assert(dataBuffP != NULL);
957         memcpy((char *)dataBuffP, (char *)(&afs_stats_cmfullperf), dataBytes);
958         a_dataP->AFSCB_CollData_len = dataBytes >> 2;
959         a_dataP->AFSCB_CollData_val = dataBuffP;
960         break;
961
962     default:
963         /*
964          * Illegal collection number.
965          */
966         a_dataP->AFSCB_CollData_len = 0;
967         a_dataP->AFSCB_CollData_val = NULL;
968         code = 1;
969     }                           /*Switch on collection number */
970 #endif /* AFS_NOSTATS */
971
972     XSTATS_END_TIME;
973
974     RX_AFS_GUNLOCK();
975
976     return (code);
977
978 }                               /*SRXAFSCB_GetXStats */
979
980
981 /*------------------------------------------------------------------------
982  * EXPORTED afs_RXCallBackServer
983  *
984  * Description:
985  *      Body of the thread supporting callback services.
986  *
987  * Arguments:
988  *      None.
989  *
990  * Returns:
991  *      0 (always).
992  *
993  * Environment:
994  *      Nothing interesting.
995  *
996  * Side Effects:
997  *      As advertised.
998  *------------------------------------------------------------------------*/
999
1000 int
1001 afs_RXCallBackServer(void)
1002 {
1003     AFS_STATCNT(afs_RXCallBackServer);
1004
1005     while (1) {
1006         if (afs_server)
1007             break;
1008         afs_osi_Sleep(&afs_server);
1009     }
1010
1011     /*
1012      * Donate this process to Rx.
1013      */
1014     rx_ServerProc(NULL);
1015     return (0);
1016
1017 }                               /*afs_RXCallBackServer */
1018
1019
1020 /*------------------------------------------------------------------------
1021  * EXPORTED shutdown_CB
1022  *
1023  * Description:
1024  *      Zero out important Cache Manager data structures.
1025  *
1026  * Arguments:
1027  *      None.
1028  *
1029  * Returns:
1030  *      0 (always).
1031  *
1032  * Environment:
1033  *      Nothing interesting.
1034  *
1035  * Side Effects:
1036  *      As advertised.
1037  *------------------------------------------------------------------------*/
1038
1039 int
1040 shutdown_CB(void)
1041 {
1042     AFS_STATCNT(shutdown_CB);
1043
1044     if (afs_cold_shutdown) {
1045         afs_oddCBs = afs_evenCBs = afs_allCBs = afs_allZaps = afs_oddZaps =
1046             afs_evenZaps = afs_connectBacks = 0;
1047     }
1048
1049     return (0);
1050
1051 }                               /*shutdown_CB */
1052
1053 /*------------------------------------------------------------------------
1054  * EXPORTED SRXAFSCB_InitCallBackState2
1055  *
1056  * Description:
1057  *      This routine was used in the AFS 3.5 beta release, but not anymore.
1058  *      It has since been replaced by SRXAFSCB_InitCallBackState3.
1059  *
1060  * Arguments:
1061  *      a_call : Ptr to Rx call on which this request came in.
1062  *
1063  * Returns:
1064  *      RXGEN_OPCODE (always).
1065  *
1066  * Environment:
1067  *      Nothing interesting.
1068  *
1069  * Side Effects:
1070  *      None
1071  *------------------------------------------------------------------------*/
1072
1073 int
1074 SRXAFSCB_InitCallBackState2(struct rx_call *a_call,
1075                             struct interfaceAddr *addr)
1076 {
1077     return RXGEN_OPCODE;
1078 }
1079
1080 /*------------------------------------------------------------------------
1081  * EXPORTED SRXAFSCB_WhoAreYou
1082  *
1083  * Description:
1084  *      Routine called by the server-side callback RPC interface to
1085  *      obtain a unique identifier for the client. The server uses
1086  *      this identifier to figure out whether or not two RX connections
1087  *      are from the same client, and to find out which addresses go
1088  *      with which clients.
1089  *
1090  * Arguments:
1091  *      a_call : Ptr to Rx call on which this request came in.
1092  *      addr: Ptr to return the list of interfaces for this client.
1093  *
1094  * Returns:
1095  *      0 (Always)
1096  *
1097  * Environment:
1098  *      Nothing interesting.
1099  *
1100  * Side Effects:
1101  *      As advertised.
1102  *------------------------------------------------------------------------*/
1103
1104 int
1105 SRXAFSCB_WhoAreYou(struct rx_call *a_call, struct interfaceAddr *addr)
1106 {
1107     int i;
1108     int code = 0;
1109
1110     RX_AFS_GLOCK();
1111
1112     AFS_STATCNT(SRXAFSCB_WhoAreYou);
1113
1114     memset(addr, 0, sizeof(*addr));
1115
1116     ObtainReadLock(&afs_xinterface);
1117
1118     /* return all network interface addresses */
1119     addr->numberOfInterfaces = afs_cb_interface.numberOfInterfaces;
1120     addr->uuid = afs_cb_interface.uuid;
1121     for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1122         addr->addr_in[i] = ntohl(afs_cb_interface.addr_in[i]);
1123         addr->subnetmask[i] = ntohl(afs_cb_interface.subnetmask[i]);
1124         addr->mtu[i] = ntohl(afs_cb_interface.mtu[i]);
1125     }
1126
1127     ReleaseReadLock(&afs_xinterface);
1128
1129     RX_AFS_GUNLOCK();
1130
1131     return code;
1132 }
1133
1134
1135 /*------------------------------------------------------------------------
1136  * EXPORTED SRXAFSCB_InitCallBackState3
1137  *
1138  * Description:
1139  *      Routine called by the server-side callback RPC interface to
1140  *      implement clearing all callbacks from this host.
1141  *
1142  * Arguments:
1143  *      a_call : Ptr to Rx call on which this request came in.
1144  *
1145  * Returns:
1146  *      0 (always).
1147  *
1148  * Environment:
1149  *      Nothing interesting.
1150  *
1151  * Side Effects:
1152  *      As advertised.
1153  *------------------------------------------------------------------------*/
1154
1155 int
1156 SRXAFSCB_InitCallBackState3(struct rx_call *a_call, afsUUID * a_uuid)
1157 {
1158     int code;
1159
1160     /*
1161      * TBD: Lookup the server by the UUID instead of its IP address.
1162      */
1163     code = SRXAFSCB_InitCallBackState(a_call);
1164
1165     return code;
1166 }
1167
1168
1169 /*------------------------------------------------------------------------
1170  * EXPORTED SRXAFSCB_ProbeUuid
1171  *
1172  * Description:
1173  *      Routine called by the server-side callback RPC interface to
1174  *      implement ``probing'' the Cache Manager, just making sure it's
1175  *      still there is still the same client it used to be.
1176  *
1177  * Arguments:
1178  *      a_call : Ptr to Rx call on which this request came in.
1179  *      a_uuid : Ptr to UUID that must match the client's UUID.
1180  *
1181  * Returns:
1182  *      0 if a_uuid matches the UUID for this client
1183  *      Non-zero otherwize
1184  *
1185  * Environment:
1186  *      Nothing interesting.
1187  *
1188  * Side Effects:
1189  *      As advertised.
1190  *------------------------------------------------------------------------*/
1191
1192 int
1193 SRXAFSCB_ProbeUuid(struct rx_call *a_call, afsUUID * a_uuid)
1194 {
1195     int code = 0;
1196     XSTATS_DECLS;
1197
1198     RX_AFS_GLOCK();
1199     AFS_STATCNT(SRXAFSCB_Probe);
1200
1201     XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_PROBE);
1202     if (!afs_uuid_equal(a_uuid, &afs_cb_interface.uuid))
1203         code = 1;               /* failure */
1204     XSTATS_END_TIME;
1205
1206     RX_AFS_GUNLOCK();
1207
1208     return code;
1209 }
1210
1211
1212 /*------------------------------------------------------------------------
1213  * EXPORTED SRXAFSCB_GetServerPrefs
1214  *
1215  * Description:
1216  *      Routine to list server preferences used by this client.
1217  *
1218  * Arguments:
1219  *      a_call  : Ptr to Rx call on which this request came in.
1220  *      a_index : Input server index
1221  *      a_srvr_addr  : Output server address in host byte order
1222  *                     (0xffffffff on last server)
1223  *      a_srvr_rank  : Output server rank
1224  *
1225  * Returns:
1226  *      0 on success
1227  *
1228  * Environment:
1229  *      Nothing interesting.
1230  *
1231  * Side Effects:
1232  *      As advertised.
1233  *------------------------------------------------------------------------*/
1234
1235 int
1236 SRXAFSCB_GetServerPrefs(struct rx_call *a_call, afs_int32 a_index,
1237                         afs_int32 * a_srvr_addr, afs_int32 * a_srvr_rank)
1238 {
1239     int i, j;
1240     struct srvAddr *sa;
1241
1242     RX_AFS_GLOCK();
1243     AFS_STATCNT(SRXAFSCB_GetServerPrefs);
1244
1245     ObtainReadLock(&afs_xserver);
1246
1247     /* Search the hash table for the server with this index */
1248     *a_srvr_addr = 0xffffffff;
1249     *a_srvr_rank = 0xffffffff;
1250     for (i = 0, j = 0; j < NSERVERS && i <= a_index; j++) {
1251         for (sa = afs_srvAddrs[j]; sa && i <= a_index; sa = sa->next_bkt, i++) {
1252             if (i == a_index) {
1253                 *a_srvr_addr = ntohl(sa->sa_ip);
1254                 *a_srvr_rank = sa->sa_iprank;
1255             }
1256         }
1257     }
1258
1259     ReleaseReadLock(&afs_xserver);
1260
1261     RX_AFS_GUNLOCK();
1262
1263     return 0;
1264 }
1265
1266
1267 /*------------------------------------------------------------------------
1268  * EXPORTED SRXAFSCB_GetCellServDB
1269  *
1270  * Description:
1271  *      Routine to list cells configured for this client
1272  *
1273  * Arguments:
1274  *      a_call  : Ptr to Rx call on which this request came in.
1275  *      a_index : Input cell index
1276  *      a_name  : Output cell name ("" on last cell)
1277  *      a_hosts : Output cell database servers in host byte order.
1278  *
1279  * Returns:
1280  *      0 on success
1281  *
1282  * Environment:
1283  *      Nothing interesting.
1284  *
1285  * Side Effects:
1286  *      As advertised.
1287  *------------------------------------------------------------------------*/
1288
1289 int
1290 SRXAFSCB_GetCellServDB(struct rx_call *a_call, afs_int32 a_index,
1291                        char **a_name, serverList * a_hosts)
1292 {
1293     afs_int32 i, j = 0;
1294     struct cell *tcell;
1295     char *t_name, *p_name = NULL;
1296
1297     RX_AFS_GLOCK();
1298     AFS_STATCNT(SRXAFSCB_GetCellServDB);
1299
1300     tcell = afs_GetCellByIndex(a_index, READ_LOCK);
1301
1302     if (!tcell) {
1303         i = 0;
1304         a_hosts->serverList_val = 0;
1305         a_hosts->serverList_len = 0;
1306     } else {
1307         p_name = tcell->cellName;
1308         for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++);
1309         i = strlen(p_name);
1310         a_hosts->serverList_val = afs_osi_Alloc(j * sizeof(afs_int32));
1311         osi_Assert(a_hosts->serverList_val != NULL);
1312         a_hosts->serverList_len = j;
1313         for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++)
1314             a_hosts->serverList_val[j] =
1315                 ntohl(tcell->cellHosts[j]->addr->sa_ip);
1316         afs_PutCell(tcell, READ_LOCK);
1317     }
1318
1319     t_name = afs_osi_Alloc(i + 1);
1320     if (t_name == NULL) {
1321         afs_osi_Free(a_hosts->serverList_val, (j * sizeof(afs_int32)));
1322         RX_AFS_GUNLOCK();
1323         return ENOMEM;
1324     }
1325
1326     t_name[i] = '\0';
1327     if (p_name)
1328         memcpy(t_name, p_name, i);
1329
1330     RX_AFS_GUNLOCK();
1331
1332     *a_name = t_name;
1333     return 0;
1334 }
1335
1336
1337 /*------------------------------------------------------------------------
1338  * EXPORTED SRXAFSCB_GetLocalCell
1339  *
1340  * Description:
1341  *      Routine to return name of client's local cell
1342  *
1343  * Arguments:
1344  *      a_call  : Ptr to Rx call on which this request came in.
1345  *      a_name  : Output cell name
1346  *
1347  * Returns:
1348  *      0 on success
1349  *
1350  * Environment:
1351  *      Nothing interesting.
1352  *
1353  * Side Effects:
1354  *      As advertised.
1355  *------------------------------------------------------------------------*/
1356
1357 int
1358 SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
1359 {
1360     int plen;
1361     struct cell *tcell;
1362     char *t_name, *p_name = NULL;
1363
1364     RX_AFS_GLOCK();
1365     AFS_STATCNT(SRXAFSCB_GetLocalCell);
1366
1367     /* Search the list for the primary cell. Cell number 1 is only
1368      * the primary cell is when no other cell is explicitly marked as
1369      * the primary cell.  */
1370     tcell = afs_GetPrimaryCell(READ_LOCK);
1371     if (tcell)
1372         p_name = tcell->cellName;
1373     if (p_name)
1374         plen = strlen(p_name);
1375     else
1376         plen = 0;
1377     t_name = afs_osi_Alloc(plen + 1);
1378     if (t_name == NULL) {
1379         if (tcell)
1380             afs_PutCell(tcell, READ_LOCK);
1381         RX_AFS_GUNLOCK();
1382         return ENOMEM;
1383     }
1384
1385     t_name[plen] = '\0';
1386     if (p_name)
1387         memcpy(t_name, p_name, plen);
1388
1389     RX_AFS_GUNLOCK();
1390
1391     *a_name = t_name;
1392     if (tcell)
1393         afs_PutCell(tcell, READ_LOCK);
1394     return 0;
1395 }
1396
1397
1398 /*
1399  * afs_MarshallCacheConfig - marshall client cache configuration
1400  *
1401  * PARAMETERS
1402  *
1403  * IN callerVersion - the rpc stat version of the caller.
1404  *
1405  * IN config - client cache configuration.
1406  *
1407  * OUT ptr - buffer where configuration is marshalled.
1408  *
1409  * RETURN CODES
1410  *
1411  * Returns void.
1412  */
1413 static void
1414 afs_MarshallCacheConfig(afs_uint32 callerVersion, cm_initparams_v1 * config,
1415                         afs_uint32 * ptr)
1416 {
1417     AFS_STATCNT(afs_MarshallCacheConfig);
1418     /*
1419      * We currently only support version 1.
1420      */
1421     *(ptr++) = config->nChunkFiles;
1422     *(ptr++) = config->nStatCaches;
1423     *(ptr++) = config->nDataCaches;
1424     *(ptr++) = config->nVolumeCaches;
1425     *(ptr++) = config->firstChunkSize;
1426     *(ptr++) = config->otherChunkSize;
1427     *(ptr++) = config->cacheSize;
1428     *(ptr++) = config->setTime;
1429     *(ptr++) = config->memCache;
1430 }
1431
1432
1433 /*------------------------------------------------------------------------
1434  * EXPORTED SRXAFSCB_GetCacheConfig
1435  *
1436  * Description:
1437  *      Routine to return parameters used to initialize client cache.
1438  *      Client may request any format version. Server may not return
1439  *      format version greater than version requested by client.
1440  *
1441  * Arguments:
1442  *      a_call:        Ptr to Rx call on which this request came in.
1443  *      callerVersion: Data format version desired by the client.
1444  *      serverVersion: Data format version of output data.
1445  *      configCount:   Number bytes allocated for output data.
1446  *      config:        Client cache configuration.
1447  *
1448  * Returns:
1449  *      0 on success
1450  *
1451  * Environment:
1452  *      Nothing interesting.
1453  *
1454  * Side Effects:
1455  *      As advertised.
1456  *------------------------------------------------------------------------*/
1457
1458 int
1459 SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
1460                         afs_uint32 * serverVersion, afs_uint32 * configCount,
1461                         cacheConfig * config)
1462 {
1463     afs_uint32 *t_config;
1464     size_t allocsize;
1465     cm_initparams_v1 cm_config;
1466
1467     RX_AFS_GLOCK();
1468     AFS_STATCNT(SRXAFSCB_GetCacheConfig);
1469
1470     /*
1471      * Currently only support version 1
1472      */
1473     allocsize = sizeof(cm_initparams_v1);
1474     t_config = afs_osi_Alloc(allocsize);
1475     if (t_config == NULL) {
1476         RX_AFS_GUNLOCK();
1477         return ENOMEM;
1478     }
1479
1480     cm_config.nChunkFiles = cm_initParams.cmi_nChunkFiles;
1481     cm_config.nStatCaches = cm_initParams.cmi_nStatCaches;
1482     cm_config.nDataCaches = cm_initParams.cmi_nDataCaches;
1483     cm_config.nVolumeCaches = cm_initParams.cmi_nVolumeCaches;
1484     cm_config.firstChunkSize = cm_initParams.cmi_firstChunkSize;
1485     cm_config.otherChunkSize = cm_initParams.cmi_otherChunkSize;
1486     cm_config.cacheSize = cm_initParams.cmi_cacheSize;
1487     cm_config.setTime = cm_initParams.cmi_setTime;
1488     cm_config.memCache = cm_initParams.cmi_memCache;
1489
1490     afs_MarshallCacheConfig(callerVersion, &cm_config, t_config);
1491
1492     *serverVersion = AFS_CLIENT_RETRIEVAL_FIRST_EDITION;
1493     *configCount = allocsize;
1494     config->cacheConfig_val = t_config;
1495     config->cacheConfig_len = allocsize / sizeof(afs_uint32);
1496
1497     RX_AFS_GUNLOCK();
1498
1499     return 0;
1500 }
1501
1502 /*------------------------------------------------------------------------
1503  * EXPORTED SRXAFSCB_FetchData
1504  *
1505  * Description:
1506  *      Routine to do third party move from a remioserver to the original
1507  *      issuer of an ArchiveData request. Presently supported only by the
1508  *      "fs" command, not by the AFS client.
1509  *
1510  * Arguments:
1511  *      rxcall:        Ptr to Rx call on which this request came in.
1512  *      Fid:           pointer to AFSFid structure.
1513  *      Fd:            File descriptor inside fs command.
1514  *      Position:      Offset in the file.
1515  *      Length:        Data length to transfer.
1516  *      TotalLength:   Pointer to total file length field
1517  *
1518  * Returns:
1519  *      0 on success
1520  *
1521  * Environment:
1522  *      Nothing interesting.
1523  *
1524  * Side Effects:
1525  *------------------------------------------------------------------------*/
1526 int
1527 SRXAFSCB_FetchData(struct rx_call *rxcall, struct AFSFid *Fid, afs_int32 Fd,
1528                    afs_int64 Position, afs_int64 Length,
1529                    afs_int64 * TotalLength)
1530 {
1531     return ENOSYS;
1532 }
1533
1534 /*------------------------------------------------------------------------
1535  * EXPORTED SRXAFSCB_StoreData
1536  *
1537  * Description:
1538  *      Routine to do third party move from a remioserver to the original
1539  *      issuer of a RetrieveData request. Presently supported only by the
1540  *      "fs" command, not by the AFS client.
1541  *
1542  * Arguments:
1543  *      rxcall:        Ptr to Rx call on which this request came in.
1544  *      Fid:           pointer to AFSFid structure.
1545  *      Fd:            File descriptor inside fs command.
1546  *      Position:      Offset in the file.
1547  *      Length:        Data length to transfer.
1548  *      TotalLength:   Pointer to total file length field
1549  *
1550  * Returns:
1551  *      0 on success
1552  *
1553  * Environment:
1554  *      Nothing interesting.
1555  *
1556  * Side Effects:
1557  *      As advertised.
1558  *------------------------------------------------------------------------*/
1559 int
1560 SRXAFSCB_StoreData(struct rx_call *rxcall, struct AFSFid *Fid, afs_int32 Fd,
1561                    afs_int64 Position, afs_int64 Length,
1562                    afs_int64 * TotalLength)
1563 {
1564     return ENOSYS;
1565 }
1566
1567 /*------------------------------------------------------------------------
1568  * EXPORTED SRXAFSCB_GetCellByNum
1569  *
1570  * Description:
1571  *      Routine to get information about a cell specified by its
1572  *      cell number (returned by GetCE/GetCE64).
1573  *
1574  * Arguments:
1575  *      a_call    : Ptr to Rx call on which this request came in.
1576  *      a_cellnum : Input cell number
1577  *      a_name    : Output cell name (one zero byte when no such cell).
1578  *      a_hosts   : Output cell database servers in host byte order.
1579  *
1580  * Returns:
1581  *      0 on success
1582  *
1583  * Environment:
1584  *      Nothing interesting.
1585  *
1586  * Side Effects:
1587  *      As advertised.
1588  *------------------------------------------------------------------------*/
1589
1590 int
1591 SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_cellnum,
1592                       char **a_name, serverList * a_hosts)
1593 {
1594     afs_int32 i, sn;
1595     struct cell *tcell;
1596
1597     RX_AFS_GLOCK();
1598     AFS_STATCNT(SRXAFSCB_GetCellByNum);
1599
1600     a_hosts->serverList_val = 0;
1601     a_hosts->serverList_len = 0;
1602
1603     tcell = afs_GetCellStale(a_cellnum, READ_LOCK);
1604     if (!tcell) {
1605         *a_name = afs_strdup("");
1606         RX_AFS_GUNLOCK();
1607         return 0;
1608     }
1609
1610     ObtainReadLock(&tcell->lock);
1611     *a_name = afs_strdup(tcell->cellName);
1612
1613     for (sn = 0; sn < AFSMAXCELLHOSTS && tcell->cellHosts[sn]; sn++);
1614     a_hosts->serverList_len = sn;
1615     a_hosts->serverList_val = afs_osi_Alloc(sn * sizeof(afs_int32));
1616     osi_Assert(a_hosts->serverList_val != NULL);
1617
1618     for (i = 0; i < sn; i++)
1619         a_hosts->serverList_val[i] = ntohl(tcell->cellHosts[i]->addr->sa_ip);
1620     ReleaseReadLock(&tcell->lock);
1621     afs_PutCell(tcell, READ_LOCK);
1622
1623     RX_AFS_GUNLOCK();
1624     return 0;
1625 }
1626
1627 int
1628 SRXAFSCB_TellMeAboutYourself(struct rx_call *a_call,
1629                              struct interfaceAddr *addr,
1630                              Capabilities * capabilities)
1631 {
1632     int i;
1633     int code = 0;
1634     afs_uint32 *dataBuffP;
1635     afs_int32 dataBytes;
1636
1637     RX_AFS_GLOCK();
1638
1639     AFS_STATCNT(SRXAFSCB_WhoAreYou);
1640
1641     ObtainReadLock(&afs_xinterface);
1642
1643     /* return all network interface addresses */
1644     addr->numberOfInterfaces = afs_cb_interface.numberOfInterfaces;
1645     addr->uuid = afs_cb_interface.uuid;
1646     for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1647         addr->addr_in[i] = ntohl(afs_cb_interface.addr_in[i]);
1648         addr->subnetmask[i] = ntohl(afs_cb_interface.subnetmask[i]);
1649         addr->mtu[i] = ntohl(afs_cb_interface.mtu[i]);
1650     }
1651
1652     ReleaseReadLock(&afs_xinterface);
1653
1654     RX_AFS_GUNLOCK();
1655
1656     dataBytes = 1 * sizeof(afs_uint32);
1657     dataBuffP = afs_osi_Alloc(dataBytes);
1658     osi_Assert(dataBuffP != NULL);
1659     dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
1660     capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
1661     capabilities->Capabilities_val = dataBuffP;
1662
1663     return code;
1664 }
1665
1666
1667 #if 0 && defined(AFS_LINUX24_ENV)
1668 extern struct vcache *afs_globalVp;
1669
1670 int recurse_dcache_parent(parent, a_index, addr, inode, flags, time, fileName)
1671      struct dentry * parent;
1672     afs_int32 a_index;
1673     afs_int32 *addr;
1674     afs_int32 *inode;
1675     afs_int32 *flags;
1676     afs_int32 *time;
1677     char ** fileName;
1678 {
1679         struct dentry *this_parent = parent;
1680         struct list_head *next;
1681         int found = 0;
1682         struct dentry *dentry;
1683
1684 repeat:
1685         next = this_parent->d_subdirs.next;
1686 resume:
1687         while (next != &this_parent->d_subdirs) {
1688                 struct list_head *tmp = next;
1689                 dentry = list_entry(tmp, struct dentry, d_child);
1690                 if (a_index == 0)
1691                   goto searchdone3;
1692                 a_index--;
1693                 next = tmp->next;
1694                 /*
1695                  * Descend a level if the d_subdirs list is non-empty.
1696                  */
1697                 if (!list_empty(&dentry->d_subdirs)) {
1698                         this_parent = dentry;
1699                         goto repeat;
1700                 }
1701         }
1702         /*
1703          * All done at this level ... ascend and resume the search.
1704          */
1705         if (this_parent != parent) {
1706                 next = this_parent->d_child.next;
1707                 this_parent = this_parent->d_parent;
1708                 goto resume;
1709         }
1710         goto ret;
1711
1712  searchdone3:
1713     if (d_unhashed(dentry))
1714       *flags = 1;
1715     else
1716       *flags = 0;
1717
1718     *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
1719     *inode = ITOAFS(dentry->d_inode);
1720     *addr = atomic_read(&(dentry)->d_count);
1721     *time = dentry->d_time;
1722
1723     return 0;
1724  ret:
1725     return 1;
1726 }
1727 #endif
1728
1729 int
1730 SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
1731                afs_int32 *inode, afs_int32 *flags, afs_int32 *time,
1732                char ** fileName)
1733 { /*SRXAFSCB_GetDE*/
1734     int code = 0;                               /*Return code*/
1735 #if 0 && defined(AFS_LINUX24_ENV)
1736     int i;                      /*Loop variable*/
1737     struct vcache *tvc = afs_globalVp;
1738     struct dentry *dentry;
1739     struct list_head *cur, *head = &(AFSTOI(tvc))->i_dentry;
1740
1741 #ifdef RX_ENABLE_LOCKS
1742     AFS_GLOCK();
1743 #endif /* RX_ENABLE_LOCKS */
1744
1745 #if defined(AFS_LINUX24_ENV)
1746     spin_lock(&dcache_lock);
1747 #endif
1748
1749     cur = head;
1750     while ((cur = cur->next) != head) {
1751       dentry = list_entry(cur, struct dentry, d_alias);
1752
1753       dget_locked(dentry);
1754
1755 #if defined(AFS_LINUX24_ENV)
1756       spin_unlock(&dcache_lock);
1757 #endif
1758       if (a_index == 0)
1759         goto searchdone2;
1760       a_index--;
1761
1762       if (recurse_dcache_parent(dentry, a_index, addr, inode, flags, time, fileName) == 0) {
1763         dput(dentry);
1764         code = 0;
1765         goto fcnDone;
1766       }
1767       dput(dentry);
1768     }
1769  searchdone2:
1770     if (cur == head) {
1771         /*Past EOF*/
1772         code = 1;
1773         *fileName = afs_strdup("");
1774         goto fcnDone;
1775     }
1776
1777     if (d_unhashed(dentry))
1778       *flags = 1;
1779     else
1780       *flags = 0;
1781
1782     *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
1783     *inode = ITOAFS(dentry->d_inode);
1784     *addr = atomic_read(&(dentry)->d_count);
1785     *time = dentry->d_time;
1786
1787     dput(dentry);
1788     code = 0;
1789
1790 fcnDone:
1791
1792 #ifdef RX_ENABLE_LOCKS
1793     AFS_GUNLOCK();
1794 #endif /* RX_ENABLE_LOCKS */
1795 #endif
1796     return(code);
1797
1798 } /*SRXAFSCB_GetDE*/