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