linux-warning-reduction-20090318
[openafs.git] / src / afs / afs_user.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  * Implements:
12  */
13 #include <afsconfig.h>
14 #include "afs/param.h"
15
16 RCSID
17     ("$Header$");
18
19 #include "afs/stds.h"
20 #include "afs/sysincludes.h"    /* Standard vendor system headers */
21
22 #if !defined(UKERNEL)
23 #if !defined(AFS_LINUX20_ENV)
24 #include <net/if.h>
25 #endif
26 #include <netinet/in.h>
27
28 #ifdef AFS_SGI62_ENV
29 #include "h/hashing.h"
30 #endif
31 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN60_ENV)
32 #include <netinet/in_var.h>
33 #endif /* ! AFS_HPUX110_ENV */
34 #endif /* !defined(UKERNEL) */
35
36 #include "afsincludes.h"        /* Afs-based standard headers */
37 #include "afs/afs_stats.h"      /* afs statistics */
38
39 #if     defined(AFS_SUN56_ENV)
40 #include <inet/led.h>
41 #include <inet/common.h>
42 #if   defined(AFS_SUN58_ENV)
43 #include <netinet/ip6.h>
44 #endif
45 #include <inet/ip.h>
46 #endif
47
48
49 /* Exported variables */
50 afs_rwlock_t afs_xuser;
51 struct unixuser *afs_users[NUSERS];
52
53
54 #ifndef AFS_PAG_MANAGER
55 /* Forward declarations */
56 void afs_ResetAccessCache(afs_int32 uid, int alock);
57
58 /*
59  * Called with afs_xuser, afs_xserver and afs_xconn locks held, to delete
60  * appropriate conn structures for au
61  */
62 static void
63 RemoveUserConns(register struct unixuser *au)
64 {
65     register int i;
66     register struct server *ts;
67     register struct srvAddr *sa;
68     register struct afs_conn *tc, **lc;
69
70     AFS_STATCNT(RemoveUserConns);
71     for (i = 0; i < NSERVERS; i++) {
72         for (ts = afs_servers[i]; ts; ts = ts->next) {
73             for (sa = ts->addr; sa; sa = sa->next_sa) {
74                 lc = &sa->conns;
75                 for (tc = *lc; tc; lc = &tc->next, tc = *lc) {
76                     if (tc->user == au && tc->refCount == 0) {
77                         *lc = tc->next;
78                         AFS_GUNLOCK();
79                         rx_DestroyConnection(tc->id);
80                         AFS_GLOCK();
81                         afs_osi_Free(tc, sizeof(struct afs_conn));
82                         break;  /* at most one instance per server */
83                     }           /*Found unreferenced connection for user */
84                 }               /*For each connection on the server */
85             }
86         }                       /*For each server on chain */
87     }                           /*For each chain */
88
89 }                               /*RemoveUserConns */
90 #endif /* !AFS_PAG_MANAGER */
91
92
93 /* Called from afs_Daemon to garbage collect unixusers no longer using system,
94  * and their conns.  The aforce parameter tells the function to flush all
95  * *unauthenticated* conns, no matter what their expiration time; it exists
96  * because after we choose our final rx epoch, we want to stop using calls with
97  * other epochs as soon as possible (old file servers act bizarrely when they
98  * see epoch changes).
99  */
100 void
101 afs_GCUserData(int aforce)
102 {
103     register struct unixuser *tu, **lu, *nu;
104     register int i;
105     afs_int32 now, delFlag;
106
107     AFS_STATCNT(afs_GCUserData);
108     /* Obtain locks in valid order */
109     ObtainWriteLock(&afs_xuser, 95);
110 #ifndef AFS_PAG_MANAGER
111     ObtainReadLock(&afs_xserver);
112     ObtainWriteLock(&afs_xconn, 96);
113 #endif
114     now = osi_Time();
115     for (i = 0; i < NUSERS; i++) {
116         for (lu = &afs_users[i], tu = *lu; tu; tu = nu) {
117             delFlag = 0;        /* should we delete this dude? */
118             /* Don't garbage collect users in use now (refCount) */
119             if (tu->refCount == 0) {
120                 if (tu->states & UHasTokens) {
121                     /*
122                      * Give ourselves a little extra slack, in case we
123                      * reauthenticate
124                      */
125                     if (tu->ct.EndTimestamp < now - NOTOKTIMEOUT)
126                         delFlag = 1;
127                 } else {
128                     if (aforce || (tu->tokenTime < now - NOTOKTIMEOUT))
129                         delFlag = 1;
130                 }
131             }
132             nu = tu->next;
133             if (delFlag) {
134                 *lu = tu->next;
135 #ifndef AFS_PAG_MANAGER
136                 RemoveUserConns(tu);
137 #endif
138                 if (tu->stp)
139                     afs_osi_Free(tu->stp, tu->stLen);
140                 if (tu->exporter)
141                     EXP_RELE(tu->exporter);
142                 afs_osi_Free(tu, sizeof(struct unixuser));
143             } else {
144                 lu = &tu->next;
145             }
146         }
147     }
148 #ifndef AFS_PAG_MANAGER
149     ReleaseWriteLock(&afs_xconn);
150 #endif
151 #ifndef AFS_PAG_MANAGER
152     ReleaseReadLock(&afs_xserver);
153 #endif
154     ReleaseWriteLock(&afs_xuser);
155
156 }                               /*afs_GCUserData */
157
158
159 #ifndef AFS_PAG_MANAGER
160 /*
161  * Check for unixusers who encountered bad tokens, and reset the access
162  * cache for these guys.  Can't do this when token expiration detected,
163  * since too many locks are set then.
164  */
165 void
166 afs_CheckTokenCache(void)
167 {
168     register int i;
169     register struct unixuser *tu;
170     afs_int32 now;
171
172     AFS_STATCNT(afs_CheckCacheResets);
173     ObtainReadLock(&afs_xvcache);
174     ObtainReadLock(&afs_xuser);
175     now = osi_Time();
176     for (i = 0; i < NUSERS; i++) {
177         for (tu = afs_users[i]; tu; tu = tu->next) {
178             register afs_int32 uid;
179
180             /*
181              * If tokens are still good and user has Kerberos tickets,
182              * check expiration
183              */
184             if (!(tu->states & UTokensBad) && tu->vid != UNDEFVID) {
185                 if (tu->ct.EndTimestamp < now) {
186                     /*
187                      * This token has expired, warn users and reset access
188                      * cache.
189                      */
190 #ifdef notdef
191                     /* I really hate this message - MLK */
192                     afs_warn
193                         ("afs: Tokens for user of AFS id %d for cell %s expired now\n",
194                          tu->vid, afs_GetCell(tu->cell)->cellName);
195 #endif
196                     tu->states |= (UTokensBad | UNeedsReset);
197                 }
198             }
199             if (tu->states & UNeedsReset) {
200                 tu->states &= ~UNeedsReset;
201                 uid = tu->uid;
202                 afs_ResetAccessCache(uid, 0);
203             }
204         }
205     }
206     ReleaseReadLock(&afs_xuser);
207     ReleaseReadLock(&afs_xvcache);
208
209 }                               /*afs_CheckTokenCache */
210
211
212 void
213 afs_ResetAccessCache(afs_int32 uid, int alock)
214 {
215     register int i;
216     register struct vcache *tvc;
217     struct axscache *ac;
218
219     AFS_STATCNT(afs_ResetAccessCache);
220     if (alock)
221         ObtainReadLock(&afs_xvcache);
222     for (i = 0; i < VCSIZE; i++) {
223         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
224             /* really should do this under cache write lock, but that.
225              * is hard to under locking hierarchy */
226             if (tvc->Access && (ac = afs_FindAxs(tvc->Access, uid))) {
227                 afs_RemoveAxs(&tvc->Access, ac);
228             }
229         }
230     }
231     if (alock)
232         ReleaseReadLock(&afs_xvcache);
233
234 }                               /*afs_ResetAccessCache */
235
236
237 /*
238  * Ensure all connections make use of new tokens.  Discard incorrectly-cached
239  * access info.
240  */
241 void
242 afs_ResetUserConns(register struct unixuser *auser)
243 {
244     int i;
245     struct srvAddr *sa;
246     struct afs_conn *tc;
247
248     AFS_STATCNT(afs_ResetUserConns);
249     ObtainReadLock(&afs_xsrvAddr);
250     ObtainWriteLock(&afs_xconn, 98);
251
252     for (i = 0; i < NSERVERS; i++) {
253         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
254             for (tc = sa->conns; tc; tc = tc->next) {
255                 if (tc->user == auser) {
256                     tc->forceConnectFS = 1;
257                 }
258             }
259         }
260     }
261
262     ReleaseWriteLock(&afs_xconn);
263     ReleaseReadLock(&afs_xsrvAddr);
264     afs_ResetAccessCache(auser->uid, 1);
265     auser->states &= ~UNeedsReset;
266 }                               /*afs_ResetUserConns */
267 #endif /* !AFS_PAG_MANAGER */
268
269
270 struct unixuser *
271 afs_FindUser(afs_int32 auid, afs_int32 acell, afs_int32 locktype)
272 {
273     register struct unixuser *tu;
274     register afs_int32 i;
275
276     AFS_STATCNT(afs_FindUser);
277     i = UHash(auid);
278     ObtainWriteLock(&afs_xuser, 99);
279     for (tu = afs_users[i]; tu; tu = tu->next) {
280         if (tu->uid == auid && ((tu->cell == acell) || (acell == -1))) {
281             tu->refCount++;
282             ReleaseWriteLock(&afs_xuser);
283             return tu;
284         }
285     }
286     ReleaseWriteLock(&afs_xuser);
287     return NULL;
288
289 }                               /*afs_FindUser */
290
291
292 /*------------------------------------------------------------------------
293  * EXPORTED afs_ComputePAGStats
294  *
295  * Description:
296  *      Compute a set of stats concerning PAGs used by this machine.
297  *
298  * Arguments:
299  *      None.
300  *
301  * Returns:
302  *      Nothing.
303  *
304  * Environment:
305  *      The results are put in the structure responsible for keeping
306  *      detailed CM stats.  Note: entries corresponding to a single PAG
307  *      will appear on the identical hash chain, so sweeping the chain
308  *      will find all entries related to a single PAG.
309  *
310  * Side Effects:
311  *      As advertised.
312  *------------------------------------------------------------------------*/
313
314 void
315 afs_ComputePAGStats(void)
316 {
317     register struct unixuser *currPAGP; /*Ptr to curr PAG */
318     register struct unixuser *cmpPAGP;  /*Ptr to PAG being compared */
319     register struct afs_stats_AuthentInfo *authP;       /*Ptr to stats area */
320     int curr_Record;            /*Curr record */
321     int currChain;              /*Curr hash chain */
322     int currChainLen;           /*Length of curr hash chain */
323     int currPAGRecords;         /*# records in curr PAG */
324
325     /*
326      * Lock out everyone else from scribbling on the PAG entries.
327      */
328     ObtainReadLock(&afs_xuser);
329
330     /*
331      * Initialize the tallies, then sweep through each hash chain.  We
332      * can't bzero the structure, since some fields are cumulative over
333      * the CM's lifetime.
334      */
335     curr_Record = 0;
336     authP = &(afs_stats_cmfullperf.authent);
337     authP->curr_PAGs = 0;
338     authP->curr_Records = 0;
339     authP->curr_AuthRecords = 0;
340     authP->curr_UnauthRecords = 0;
341     authP->curr_MaxRecordsInPAG = 0;
342     authP->curr_LongestChain = 0;
343
344     for (currChain = 0; currChain < NUSERS; currChain++) {
345         currChainLen = 0;
346         for (currPAGP = afs_users[currChain]; currPAGP;
347              currPAGP = currPAGP->next) {
348             /*
349              * Bump the number of records on this current chain, along with
350              * the total number of records in existence.
351              */
352             currChainLen++;
353             curr_Record++;
354             /*
355              * We've found a previously-uncounted PAG.  If it's been deleted
356              * but just not garbage-collected yet, we step over it.
357              */
358             if (currPAGP->vid == UNDEFVID)
359                 continue;
360
361             /*
362              * If this PAG record has already been ``counted', namely
363              * associated with a PAG and tallied, clear its bit and move on.
364              */
365             (authP->curr_Records)++;
366             if (currPAGP->states & UPAGCounted) {
367                 currPAGP->states &= ~UPAGCounted;
368                 continue;
369             }
370
371
372
373             /*We've counted this one already */
374             /*
375              * Jot initial info down, then sweep down the rest of the hash
376              * chain, looking for matching PAG entries.  Note: to properly
377              * ``count'' the current record, we first compare it to itself
378              * in the following loop.
379              */
380             (authP->curr_PAGs)++;
381             currPAGRecords = 0;
382
383             for (cmpPAGP = currPAGP; cmpPAGP; cmpPAGP = cmpPAGP->next) {
384                 if (currPAGP->uid == cmpPAGP->uid) {
385                     /*
386                      * The records belong to the same PAG.  First, mark the
387                      * new record as ``counted'' and bump the PAG size.
388                      * Then, record the state of its ticket, if any.
389                      */
390                     cmpPAGP->states |= UPAGCounted;
391                     currPAGRecords++;
392                     if ((cmpPAGP->states & UHasTokens)
393                         && !(cmpPAGP->states & UTokensBad))
394                         (authP->curr_AuthRecords)++;
395                     else
396                         (authP->curr_UnauthRecords)++;
397                 }               /*Records belong to same PAG */
398             }                   /*Compare to rest of PAG records in chain */
399
400             /*
401              * In the above comparisons, the current PAG record has been
402              * marked as counted.  Erase this mark before moving on.
403              */
404             currPAGP->states &= ~UPAGCounted;
405
406             /*
407              * We've compared our current PAG record with all remaining
408              * PAG records in the hash chain.  Update our tallies, and
409              * perhaps even our lifetime high water marks.  After that,
410              * remove our search mark and advance to the next comparison
411              * pair.
412              */
413             if (currPAGRecords > authP->curr_MaxRecordsInPAG) {
414                 authP->curr_MaxRecordsInPAG = currPAGRecords;
415                 if (currPAGRecords > authP->HWM_MaxRecordsInPAG)
416                     authP->HWM_MaxRecordsInPAG = currPAGRecords;
417             }
418         }                       /*Sweep a hash chain */
419
420         /*
421          * If the chain we just finished zipping through is the longest we've
422          * seen yet, remember this fact before advancing to the next chain.
423          */
424         if (currChainLen > authP->curr_LongestChain) {
425             authP->curr_LongestChain = currChainLen;
426             if (currChainLen > authP->HWM_LongestChain)
427                 authP->HWM_LongestChain = currChainLen;
428         }
429
430     }                           /*For each hash chain in afs_user */
431
432     /*
433      * Now that we've counted everything up, we can consider all-time
434      * numbers.
435      */
436     if (authP->curr_PAGs > authP->HWM_PAGs)
437         authP->HWM_PAGs = authP->curr_PAGs;
438     if (authP->curr_Records > authP->HWM_Records)
439         authP->HWM_Records = authP->curr_Records;
440
441     /*
442      * People are free to manipulate the PAG structures now.
443      */
444     ReleaseReadLock(&afs_xuser);
445
446 }                               /*afs_ComputePAGStats */
447
448
449 struct unixuser *
450 afs_GetUser(register afs_int32 auid, afs_int32 acell, afs_int32 locktype)
451 {
452     register struct unixuser *tu, *pu = 0;
453     register afs_int32 i;
454     register afs_int32 RmtUser = 0;
455
456     AFS_STATCNT(afs_GetUser);
457     i = UHash(auid);
458     ObtainWriteLock(&afs_xuser, 104);
459     for (tu = afs_users[i]; tu; tu = tu->next) {
460         if (tu->uid == auid) {
461             RmtUser = 0;
462             pu = NULL;
463             if (tu->exporter) {
464                 RmtUser = 1;
465                 pu = tu;
466             }
467             if (tu->cell == -1 && acell != -1) {
468                 /* Here we setup the real cell for the client */
469                 tu->cell = acell;
470                 tu->refCount++;
471                 ReleaseWriteLock(&afs_xuser);
472                 return tu;
473             } else if (tu->cell == acell || acell == -1) {
474                 tu->refCount++;
475                 ReleaseWriteLock(&afs_xuser);
476                 return tu;
477             }
478         }
479     }
480     tu = (struct unixuser *)afs_osi_Alloc(sizeof(struct unixuser));
481 #ifndef AFS_NOSTATS
482     afs_stats_cmfullperf.authent.PAGCreations++;
483 #endif /* AFS_NOSTATS */
484     memset((char *)tu, 0, sizeof(struct unixuser));
485     tu->next = afs_users[i];
486     afs_users[i] = tu;
487     if (RmtUser) {
488         /*
489          * This is for the case where an additional unixuser struct is
490          * created because the remote client is accessing a different cell;
491          * we simply rerecord relevant information from the original
492          * structure
493          */
494         if (pu && pu->exporter) {
495             (void)EXP_HOLD(tu->exporter = pu->exporter);
496         }
497     }
498     tu->uid = auid;
499     tu->cell = acell;
500     tu->vid = UNDEFVID;
501     tu->refCount = 1;
502     tu->tokenTime = osi_Time();
503     ReleaseWriteLock(&afs_xuser);
504     return tu;
505
506 }                               /*afs_GetUser */
507
508
509 void
510 afs_PutUser(register struct unixuser *au, afs_int32 locktype)
511 {
512     AFS_STATCNT(afs_PutUser);
513     --au->refCount;
514 }                               /*afs_PutUser */
515
516
517 /*
518  * Set the primary flag on a unixuser structure, ensuring that exactly one
519  * dude has the flag set at any time for a particular unix uid.
520  */
521 void
522 afs_SetPrimary(register struct unixuser *au, register int aflag)
523 {
524     register struct unixuser *tu;
525     register int i;
526     struct unixuser *pu;
527
528     AFS_STATCNT(afs_SetPrimary);
529     i = UHash(au->uid);
530     pu = NULL;
531     ObtainWriteLock(&afs_xuser, 105);
532     /*
533      * See if anyone is this uid's primary cell yet; recording in pu the
534      * corresponding user
535      */
536     for (tu = afs_users[i]; tu; tu = tu->next) {
537         if (tu->uid == au->uid && (tu->states & UPrimary)) {
538             pu = tu;
539         }
540     }
541     if (pu && !(pu->states & UHasTokens)) {
542         /*
543          * Primary user has unlogged, don't treat him as primary any longer;
544          * note that we want to treat him as primary until now, so that
545          * people see a primary identity until now.
546          */
547         pu->states &= ~UPrimary;
548         pu = NULL;
549     }
550     if (aflag == 1) {
551         /* setting au to be primary */
552         if (pu)
553             pu->states &= ~UPrimary;
554         au->states |= UPrimary;
555     } else if (aflag == 0) {
556         /* we don't know if we're supposed to be primary or not */
557         if (!pu || au == pu) {
558             au->states |= UPrimary;
559         } else
560             au->states &= ~UPrimary;
561     }
562     ReleaseWriteLock(&afs_xuser);
563
564 }                               /*afs_SetPrimary */
565
566
567 #if AFS_GCPAGS
568
569 /*
570  * Called by osi_TraverseProcTable (from afs_GCPAGs) for each 
571  * process in the system.
572  * If the specified process uses a PAG, clear that PAG's temporary
573  * 'deleteme' flag.
574  */
575
576 /*
577  * This variable keeps track of the number of UID-base
578  * tokens in the afs_users table. When it's zero
579  * the per process loop in GCPAGs doesn't have to
580  * check processes without pags against the afs_users table.
581  */
582 static afs_int32 afs_GCPAGs_UIDBaseTokenCount = 0;
583
584 /*
585  * These variables keep track of the number of times
586  * afs_GCPAGs_perproc_func() is called.  If it is not called at all when
587  * walking the process table, there is something wrong and we should not
588  * prematurely expire any tokens.
589  */
590 static size_t afs_GCPAGs_perproc_count = 0;
591 static size_t afs_GCPAGs_cred_count = 0;
592
593 /*
594  * LOCKS: afs_GCPAGs_perproc_func requires write lock on afs_xuser
595  */
596 void
597 afs_GCPAGs_perproc_func(AFS_PROC * pproc)
598 {
599     afs_int32 pag, hash, uid;
600     struct AFS_UCRED *pcred;
601
602     afs_GCPAGs_perproc_count++;
603
604     pcred = afs_osi_proc2cred(pproc);
605     if (!pcred)
606         return;
607
608     afs_GCPAGs_cred_count++;
609
610     pag = PagInCred(pcred);
611 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD40_ENV) || defined(AFS_LINUX22_ENV)
612     uid = (pag != NOPAG ? pag : pcred->cr_uid);
613 #elif defined(AFS_SUN510_ENV)
614     uid = (pag != NOPAG ? pag : crgetruid(pcred));
615 #else
616     uid = (pag != NOPAG ? pag : pcred->cr_ruid);
617 #endif
618     hash = UHash(uid);
619
620     /* if this token is PAG based, or it's UID based and 
621      * UID-based tokens exist */
622     if ((pag != NOPAG) || (afs_GCPAGs_UIDBaseTokenCount)) {
623         /* find the entries for this uid in all cells and clear the not
624          * referenced flag.  Can't use afs_FindUser, because it just returns
625          * the specific cell asked for, or the first one found. 
626          */
627         struct unixuser *pu;
628         for (pu = afs_users[hash]; pu; pu = pu->next) {
629             if (pu->uid == uid) {
630                 if (pu->states & TMP_UPAGNotReferenced) {
631                     /* clear the 'deleteme' flag for this entry */
632                     pu->states &= ~TMP_UPAGNotReferenced;
633                     if (pag == NOPAG) {
634                         /* This is a uid based token that hadn't 
635                          * previously been cleared, so decrement the
636                          * outstanding uid based token count */
637                         afs_GCPAGs_UIDBaseTokenCount--;
638                     }
639                 }
640             }
641         }
642     }
643 }
644
645 /*
646  * Go through the process table, find all unused PAGs 
647  * and cause them to be deleted during the next GC.
648  *
649  * returns the number of PAGs marked for deletion
650  *
651  * On AIX we free PAGs when the last accessing process exits,
652  * so this routine is not needed.
653  *
654  * In AFS WebSecure, we explicitly call unlog when we remove
655  * an entry in the login cache, so this routine is not needed.
656  */
657
658 afs_int32
659 afs_GCPAGs(afs_int32 * ReleasedCount)
660 {
661     struct unixuser *pu;
662     int i;
663
664     if (afs_gcpags != AFS_GCPAGS_OK) {
665         return 0;
666     }
667
668     *ReleasedCount = 0;
669
670     /* first, loop through afs_users, setting the temporary 'deleteme' flag */
671     ObtainWriteLock(&afs_xuser, 419);
672     afs_GCPAGs_UIDBaseTokenCount = 0;
673     for (i = 0; i < NUSERS; i++) {
674         for (pu = afs_users[i]; pu; pu = pu->next) {
675             pu->states |= TMP_UPAGNotReferenced;
676             if (((pu->uid >> 24) & 0xff) != 'A') {
677                 /* this is a uid-based token, */
678                 /* increment the count */
679                 afs_GCPAGs_UIDBaseTokenCount++;
680             }
681         }
682     }
683
684     /* Now, iterate through the systems process table, 
685      * for each process, mark it's PAGs (if any) in use.
686      * i.e. clear the temporary deleteme flag.
687      */
688     afs_GCPAGs_perproc_count = 0;
689     afs_GCPAGs_cred_count = 0;
690
691     afs_osi_TraverseProcTable();
692
693     /* If there is an internal problem and afs_GCPAGs_perproc_func()
694      * does not get called, disable gcpags so that we do not
695      * accidentally expire all the tokens in the system.
696      */
697     if (afs_gcpags == AFS_GCPAGS_OK && !afs_GCPAGs_perproc_count) {
698         afs_gcpags = AFS_GCPAGS_EPROCWALK;
699     }
700
701     if (afs_gcpags == AFS_GCPAGS_OK && !afs_GCPAGs_cred_count) {
702         afs_gcpags = AFS_GCPAGS_ECREDWALK;
703     }
704
705     /* Now, go through afs_users again, any that aren't in use
706      * (temp deleteme flag still set) will be marked for later deletion,
707      * by setting their expire times to 0.
708      */
709     for (i = 0; i < NUSERS; i++) {
710         for (pu = afs_users[i]; pu; pu = pu->next) {
711             if (pu->states & TMP_UPAGNotReferenced) {
712
713                 /* clear the temp flag */
714                 pu->states &= ~TMP_UPAGNotReferenced;
715
716                 /* Is this entry on behalf of a 'remote' user ?
717                  * i.e. nfs translator, etc.
718                  */
719                 if (!pu->exporter && afs_gcpags == AFS_GCPAGS_OK) {
720                     /* set the expire times to 0, causes 
721                      * afs_GCUserData to remove this entry 
722                      */
723                     pu->ct.EndTimestamp = 0;
724                     pu->tokenTime = 0;
725
726                     (*ReleasedCount)++; /* remember how many we marked (info only) */
727                 }
728             }
729         }
730     }
731
732     ReleaseWriteLock(&afs_xuser);
733
734     return 0;
735 }
736
737 #endif /* AFS_GCPAGS */