Unix CM: Remove erroneous comment
[openafs.git] / src / afs / afs_axscache.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 <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"      /* statistics */
17 #include "afs/stds.h"
18 static struct axscache *afs_axsfreelist = NULL;
19
20 #define NAXSs (1000 / sizeof(struct axscache))
21 static struct xfreelist {
22     struct xfreelist *next;
23     struct axscache data[NAXSs];
24 } *xfreemallocs = 0;
25 static int afs_xaxscnt = 0;
26 afs_rwlock_t afs_xaxs;
27
28 /* takes an address of an access cache & uid, returns ptr */
29 /* PRECONDITION: first field has been checked and doesn't match! 
30  * INVARIANT:  isparent(i,j) ^ isparent(j,i)  (ie, they switch around)
31  */
32 struct axscache *
33 afs_SlowFindAxs(struct axscache **cachep, afs_int32 id)
34 {
35     register struct axscache *i, *j;
36
37     j = (*cachep);
38     i = j->next;
39     while (i) {
40         if (i->uid == id) {
41             axs_Front(cachep, j, i);    /* maintain LRU queue */
42             return (i);
43         }
44
45         if ((j = i->next)) {    /* ASSIGNMENT HERE! */
46             if (j->uid == id) {
47                 axs_Front(cachep, i, j);
48                 return (j);
49             }
50         } else
51             return ((struct axscache *)NULL);
52         i = j->next;
53     }
54     return ((struct axscache *)NULL);
55 }
56
57
58 struct axscache *
59 axs_Alloc(void)
60 {
61     struct axscache *i, *j;
62     struct xfreelist *h, *xsp;
63     int k;
64
65     ObtainWriteLock(&afs_xaxs, 174);
66     if ((i = afs_axsfreelist)) {
67         afs_axsfreelist = i->next;
68         ReleaseWriteLock(&afs_xaxs);
69         return i;
70     } else {
71         h = afs_osi_Alloc(sizeof(struct xfreelist));
72         afs_xaxscnt++;
73         xsp = xfreemallocs;
74         xfreemallocs = h;
75         xfreemallocs->next = xsp;
76         i = j = h->data;
77         for (k = 0; k < NAXSs - 1; k++, i++) {
78             i->uid = -2;
79             i->axess = 0;
80             i->next = ++j;      /* need j because order of evaluation not defined */
81         }
82         i->uid = -2;
83         i->axess = 0;
84         i->next = NULL;
85         afs_axsfreelist = (h->data)->next;
86     }
87     ReleaseWriteLock(&afs_xaxs);
88     return (h->data);
89 }
90
91
92 #define axs_Free(axsp) { \
93  ObtainWriteLock(&afs_xaxs,175);             \
94  axsp->next = afs_axsfreelist;           \
95  afs_axsfreelist = axsp;                 \
96  ReleaseWriteLock(&afs_xaxs);            \
97 }
98
99
100 /* I optimize for speed on lookup, and don't give a RIP about delete.
101  */
102 void
103 afs_RemoveAxs(struct axscache **headp, struct axscache *axsp)
104 {
105     struct axscache *i, *j;
106
107     if (*headp && axsp) {       /* is bullet-proofing really neccessary? */
108         if (*headp == axsp) {   /* most common case, I think */
109             *headp = axsp->next;
110             axs_Free(axsp);
111             return;
112         }
113
114         i = *headp;
115         j = i->next;
116
117         while (j) {
118             if (j == axsp) {
119                 i->next = j->next;
120                 axs_Free(axsp);
121                 return;
122             }
123             if ((i = j->next)) {        /* ASSIGNMENT HERE! */
124                 j->next = i->next;
125                 axs_Free(axsp);
126                 return;
127             }
128         }
129     }
130     /* end of "if neither pointer is NULL" */
131     return;                     /* !#@  FAILED to find it! */
132 }
133
134
135 /* 
136  * Takes an entire list of access cache structs and prepends them, lock, stock,
137  * and barrel, to the front of the freelist.
138  */
139 void
140 afs_FreeAllAxs(struct axscache **headp)
141 {
142     struct axscache *i, *j;
143
144     i = *headp;
145     j = NULL;
146
147     while (i) {                 /* chase down the list 'til we reach the end */
148         j = i->next;
149         if (!j) {
150             ObtainWriteLock(&afs_xaxs, 176);
151             i->next = afs_axsfreelist;  /* tack on the freelist to the end */
152             afs_axsfreelist = *headp;
153             ReleaseWriteLock(&afs_xaxs);
154             *headp = NULL;
155             return;
156         }
157         i = j->next;
158     }
159
160     if (j) {                    /* we ran off the end of the list... */
161         ObtainWriteLock(&afs_xaxs, 177);
162         j->next = afs_axsfreelist;      /* tack on the freelist to the end */
163         afs_axsfreelist = *headp;
164         ReleaseWriteLock(&afs_xaxs);
165     }
166     *headp = NULL;
167     return;
168 }
169
170
171 void
172 shutdown_xscache(void)
173 {
174     struct xfreelist *xp, *nxp;
175
176     AFS_RWLOCK_INIT(&afs_xaxs, "afs_xaxs");
177     xp = xfreemallocs;
178     while (xp) {
179         nxp = xp->next;
180         afs_osi_Free(xp, sizeof(struct xfreelist));
181         xp = nxp;
182     }
183     afs_axsfreelist = NULL;
184     xfreemallocs = NULL;
185 }