1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <sys/errno.h>
30 #include <sys/param.h>
31 #include <sys/types.h>
32 #include <sys/user.h>
33 #include <sys/stat.h>
34 #include <sys/time.h>
35 #include <sys/vfs.h>
36 #include <sys/vnode.h>
37 #include <rpc/types.h>
38 #include <sys/mode.h>
39 #include <sys/cmn_err.h>
40 #include <sys/debug.h>
41 #include <sys/fs/cachefs_fs.h>
42
43 /*
44 * This is the loadable module wrapper.
45 */
46 #include <sys/systm.h>
47 #include <sys/modctl.h>
48 #include <sys/syscall.h>
49
50 extern time_t time;
51
52 static int cachefs_init(int, char *);
53 static void cachefs_fini();
54
55 static int cachefs_unloadable = 0; /* tunable */
56 static boolean_t cachefs_up = B_FALSE;
57
58 uint_t cachefs_max_apop_inqueue = CACHEFS_MAX_APOP_INQUEUE;
59
60 /*
61 * this is a list of possible hash table sizes, for the `double
62 * hashing' algorithm described in rosen's `elementary number theory
63 * and its applications'. minimally, this needs to be a list of
64 * increasing prime integers, terminated by a 0. ideally, they should
65 * be the larger of twin primes; i.e. P and P-2 are both prime.
66 */
67
68 int cachefs_hash_sizes[] = {5, 2029, 4093, 8089, 16363, 32719, 0};
69
70 /*
71 * Module linkage information for the kernel.
72 */
73
74 static vfsdef_t vfs_z = {
75 VFSDEF_VERSION,
76 CACHEFS_BASETYPE,
77 cachefs_init,
78 VSW_CANREMOUNT,
79 NULL
80 };
81
82 static struct modlfs modlfs = {
83 &mod_fsops,
84 "cache filesystem",
85 &vfs_z
86 };
87
88 static struct modlinkage modlinkage = {
89 MODREV_1, (void *)&modlfs, NULL
90 };
91
92 char _depends_on[] = "strmod/rpcmod";
93
94 int
_init(void)95 _init(void)
96 {
97 int status;
98
99 status = mod_install(&modlinkage);
100 if (status != 0) {
101 /*
102 * Could not load module, clean up the work performed
103 * by cachefs_init() which was indirectly called by
104 * mod_installfs() which in turn was called by mod_install().
105 */
106 cachefs_fini();
107 }
108
109 return (status);
110 }
111
112 int
_info(struct modinfo * modinfop)113 _info(struct modinfo *modinfop)
114 {
115 return (mod_info(&modlinkage, modinfop));
116 }
117
118 int
_fini(void)119 _fini(void)
120 {
121 int status;
122
123 if (!cachefs_unloadable)
124 return (EBUSY);
125
126 if ((status = mod_remove(&modlinkage)) == 0) {
127 /*
128 * Module has been unloaded, now clean up
129 */
130 cachefs_fini();
131 }
132
133 return (status);
134 }
135
136 extern kmutex_t cachefs_cachelock; /* Cache list mutex */
137 extern kmutex_t cachefs_newnum_lock;
138 extern kmutex_t cachefs_kstat_key_lock;
139 extern kmutex_t cachefs_rename_lock;
140 extern kmutex_t cachefs_minor_lock; /* Lock for minor device map */
141 extern kmutex_t cachefs_kmem_lock;
142 extern kmutex_t cachefs_async_lock; /* global async work count */
143 extern major_t cachefs_major;
144
145 /*
146 * Cache initialization routine. This routine should only be called
147 * once. It performs the following tasks:
148 * - Initalize all global locks
149 * - Call sub-initialization routines (localize access to variables)
150 */
151 static int
cachefs_init(int fstyp,char * name)152 cachefs_init(int fstyp, char *name)
153 {
154 kstat_t *ksp;
155 int error;
156
157 ASSERT(cachefs_up == B_FALSE);
158
159 error = cachefs_init_vfsops(fstyp);
160 if (error != 0)
161 return (error);
162
163 error = cachefs_init_vnops(name);
164 if (error != 0)
165 return (error);
166
167 mutex_init(&cachefs_cachelock, NULL, MUTEX_DEFAULT, NULL);
168 mutex_init(&cachefs_newnum_lock, NULL, MUTEX_DEFAULT, NULL);
169 mutex_init(&cachefs_kstat_key_lock, NULL, MUTEX_DEFAULT, NULL);
170 mutex_init(&cachefs_kmem_lock, NULL, MUTEX_DEFAULT, NULL);
171 mutex_init(&cachefs_rename_lock, NULL, MUTEX_DEFAULT, NULL);
172 mutex_init(&cachefs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
173 mutex_init(&cachefs_async_lock, NULL, MUTEX_DEFAULT, NULL);
174 #ifdef CFSRLDEBUG
175 mutex_init(&cachefs_rl_debug_mutex, NULL, MUTEX_DEFAULT, NULL);
176 #endif /* CFSRLDEBUG */
177
178 /*
179 * set up kmem_cache entities
180 */
181
182 cachefs_cnode_cache = kmem_cache_create("cachefs_cnode_cache",
183 sizeof (struct cnode), 0, NULL, NULL, NULL, NULL, NULL, 0);
184 cachefs_req_cache = kmem_cache_create("cachefs_async_request",
185 sizeof (struct cachefs_req), 0,
186 cachefs_req_create, cachefs_req_destroy, NULL, NULL, NULL, 0);
187 cachefs_fscache_cache = kmem_cache_create("cachefs_fscache",
188 sizeof (fscache_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
189 cachefs_filegrp_cache = kmem_cache_create("cachefs_filegrp",
190 sizeof (filegrp_t), 0,
191 filegrp_cache_create, filegrp_cache_destroy, NULL, NULL, NULL, 0);
192 cachefs_cache_kmcache = kmem_cache_create("cachefs_cache_t",
193 sizeof (cachefscache_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
194
195 /*
196 * set up the cachefs.0.key kstat
197 */
198
199 cachefs_kstat_key = NULL;
200 cachefs_kstat_key_n = 0;
201 ksp = kstat_create("cachefs", 0, "key", "misc", KSTAT_TYPE_RAW, 1,
202 KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_VAR_SIZE);
203 if (ksp != NULL) {
204 ksp->ks_data = &cachefs_kstat_key;
205 ksp->ks_update = cachefs_kstat_key_update;
206 ksp->ks_snapshot = cachefs_kstat_key_snapshot;
207 ksp->ks_lock = &cachefs_kstat_key_lock;
208 kstat_install(ksp);
209 }
210
211 /*
212 * Assign unique major number for all nfs mounts
213 */
214
215 if ((cachefs_major = getudev()) == -1) {
216 cmn_err(CE_WARN,
217 "cachefs: init: can't get unique device number");
218 cachefs_major = 0;
219 }
220 cachefs_up = B_TRUE;
221 #ifdef CFSRLDEBUG
222 cachefs_dbvalid = time;
223 #endif /* CFSRLDEBUG */
224
225 return (0);
226 }
227
228 /*
229 * Cache clean up routine. This routine is called if mod_install() failed
230 * and we have to clean up because the module could not be installed,
231 * or by _fini() when we're unloading the module.
232 */
233 static void
cachefs_fini()234 cachefs_fini()
235 {
236 extern int cachefsfstyp;
237 extern struct vnodeops *cachefs_vnodeops;
238
239 if (cachefs_up == B_FALSE) {
240 /*
241 * cachefs_init() was not called on _init(),
242 * nothing to deallocate.
243 */
244 return;
245 }
246
247 /*
248 * Clean up cachefs.0.key kstat.
249 * Currently, you can only do a
250 * modunload if cachefs_unloadable is nonzero, and that's
251 * pretty much just for debugging. however, if there ever
252 * comes a day when cachefs is more freely unloadable
253 * (e.g. the modunload daemon can do it normally), then we'll
254 * have to make changes in the stats_ API. this is because a
255 * stats_cookie_t holds the id # derived from here, and it
256 * will all go away at modunload time. thus, the API will
257 * need to somehow be more robust than is currently necessary.
258 */
259 kstat_delete_byname("cachefs", 0, "key");
260
261 if (cachefs_kstat_key != NULL) {
262 cachefs_kstat_key_t *key;
263 int i;
264
265 for (i = 0; i < cachefs_kstat_key_n; i++) {
266 key = cachefs_kstat_key + i;
267
268 cachefs_kmem_free((void *)(uintptr_t)key->ks_mountpoint,
269 strlen((char *)(uintptr_t)key->ks_mountpoint) + 1);
270 cachefs_kmem_free((void *)(uintptr_t)key->ks_backfs,
271 strlen((char *)(uintptr_t)key->ks_backfs) + 1);
272 cachefs_kmem_free((void *)(uintptr_t)key->ks_cachedir,
273 strlen((char *)(uintptr_t)key->ks_cachedir) + 1);
274 cachefs_kmem_free((void *)(uintptr_t)key->ks_cacheid,
275 strlen((char *)(uintptr_t)key->ks_cacheid) + 1);
276 }
277
278 cachefs_kmem_free(cachefs_kstat_key,
279 cachefs_kstat_key_n * sizeof (*cachefs_kstat_key));
280 }
281
282 /*
283 * Clean up kmem_cache entities
284 */
285 kmem_cache_destroy(cachefs_cache_kmcache);
286 kmem_cache_destroy(cachefs_filegrp_cache);
287 kmem_cache_destroy(cachefs_fscache_cache);
288 kmem_cache_destroy(cachefs_req_cache);
289 kmem_cache_destroy(cachefs_cnode_cache);
290 #ifdef CFSRLDEBUG
291 if (cachefs_rl_debug_cache != NULL)
292 kmem_cache_destroy(cachefs_rl_debug_cache);
293 #endif /* CFSRLDEBUG */
294
295 /*
296 * Clean up the operations structures
297 */
298 (void) vfs_freevfsops_by_type(cachefsfstyp);
299 vn_freevnodeops(cachefs_vnodeops);
300
301 /*
302 * Destroy mutexes
303 */
304 #ifdef CFSRLDEBUG
305 mutex_destroy(&cachefs_rl_debug_mutex);
306 #endif /* CFSRLDEBUG */
307 mutex_destroy(&cachefs_async_lock);
308 mutex_destroy(&cachefs_minor_lock);
309 mutex_destroy(&cachefs_rename_lock);
310 mutex_destroy(&cachefs_kmem_lock);
311 mutex_destroy(&cachefs_kstat_key_lock);
312 mutex_destroy(&cachefs_newnum_lock);
313 mutex_destroy(&cachefs_cachelock);
314 }
315