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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/types32.h>
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <rpc/types.h>
31 #include <sys/vfs.h>
32 #include <sys/siginfo.h>
33 #include <sys/proc.h>		/* for exit() declaration */
34 #include <sys/kmem.h>
35 #include <sys/pathname.h>
36 #include <sys/debug.h>
37 #include <sys/vtrace.h>
38 #include <sys/cmn_err.h>
39 #include <sys/atomic.h>
40 #include <sys/policy.h>
41 
42 #include <sharefs/sharefs.h>
43 
44 /*
45  * A macro to avoid cut-and-paste errors on getting a string field
46  * from user-land.
47  */
48 #define	SHARETAB_COPYIN(field)						\
49 	if (copyinstr(STRUCT_FGETP(u_sh, sh_##field),			\
50 			buf,						\
51 			bufsz + 1,	/* Add one for extra NUL */	\
52 			&len)) {					\
53 		error = EFAULT;						\
54 		goto cleanup;						\
55 	}								\
56 	/*								\
57 	 * Need to remove 1 because copyinstr() counts the NUL.		\
58 	 */								\
59 	len--;								\
60 	sh->sh_##field = kmem_alloc(len + 1, KM_SLEEP);			\
61 	bcopy(buf, sh->sh_##field, len);				\
62 	sh->sh_##field[len] = '\0';					\
63 	shl.shl_##field = (int)len;					\
64 	sh->sh_size += shl.shl_##field;	/* Debug counting */
65 
66 #define	SHARETAB_DELETE_FIELD(field)					\
67 	if (sh->sh_##field) {						\
68 		kmem_free(sh->sh_##field,				\
69 			shl ? shl->shl_##field + 1 :			\
70 			strlen(sh->sh_##field) + 1);			\
71 	}
72 
73 sharetab_t	*sharefs_sharetab = NULL;	/* The incore sharetab. */
74 size_t		sharetab_size;
75 uint_t		sharetab_count;
76 
77 krwlock_t	sharetab_lock;	/* lock to protect the cached sharetab */
78 
79 krwlock_t	sharefs_lock;	/* lock to protect the vnode ops */
80 
81 timestruc_t	sharetab_mtime;
82 timestruc_t	sharetab_snap_time;
83 
84 uint_t		sharetab_generation;	/* Only increments and wraps! */
85 
86 /*
87  * Take care of cleaning up a share.
88  * If passed in a length array, use it to determine how much
89  * space to clean up. Else, figure that out.
90  */
91 static void
92 sharefree(share_t *sh, sharefs_lens_t *shl)
93 {
94 	if (!sh)
95 		return;
96 
97 	SHARETAB_DELETE_FIELD(path);
98 	SHARETAB_DELETE_FIELD(res);
99 	SHARETAB_DELETE_FIELD(fstype);
100 	SHARETAB_DELETE_FIELD(opts);
101 	SHARETAB_DELETE_FIELD(descr);
102 
103 	kmem_free(sh, sizeof (share_t));
104 }
105 
106 /*
107  * If there is no error, then this function is responsible for
108  * cleaning up the memory associated with the share argument.
109  */
110 static int
111 sharefs_remove(share_t *sh, sharefs_lens_t *shl)
112 {
113 	int		iHash;
114 	sharetab_t	*sht;
115 	share_t		*s, *p;
116 	int		iPath;
117 
118 	if (!sh)
119 		return (ENOENT);
120 
121 	rw_enter(&sharetab_lock, RW_WRITER);
122 	for (sht = sharefs_sharetab; sht != NULL; sht = sht->s_next) {
123 		if (strcmp(sh->sh_fstype, sht->s_fstype) == 0) {
124 			break;
125 		}
126 	}
127 
128 	/*
129 	 * There does not exist a fstype in memory which
130 	 * matches the share passed in.
131 	 */
132 	if (!sht) {
133 		rw_exit(&sharetab_lock);
134 		return (ENOENT);
135 	}
136 
137 	iPath = shl ? shl->shl_path : strlen(sh->sh_path);
138 	iHash = pkp_tab_hash(sh->sh_path, strlen(sh->sh_path));
139 
140 	/*
141 	 * Now walk down the hash table and find the entry to free!
142 	 */
143 	for (p = NULL, s = sht->s_buckets[iHash].ssh_sh;
144 	    s != NULL; s = s->sh_next) {
145 		/*
146 		 * We need exact matches.
147 		 */
148 		if (strcmp(sh->sh_path, s->sh_path) == 0 &&
149 		    strlen(s->sh_path) == iPath) {
150 			if (p) {
151 				p->sh_next = s->sh_next;
152 			} else {
153 				sht->s_buckets[iHash].ssh_sh = s->sh_next;
154 			}
155 
156 			ASSERT(sht->s_buckets[iHash].ssh_count != 0);
157 			atomic_dec_32(&sht->s_buckets[iHash].ssh_count);
158 			atomic_dec_32(&sht->s_count);
159 			atomic_dec_32(&sharetab_count);
160 
161 			ASSERT(sharetab_size >= s->sh_size);
162 			sharetab_size -= s->sh_size;
163 
164 			gethrestime(&sharetab_mtime);
165 			atomic_inc_32(&sharetab_generation);
166 
167 			break;
168 		}
169 
170 		p = s;
171 	}
172 
173 	rw_exit(&sharetab_lock);
174 
175 	if (!s) {
176 		return (ENOENT);
177 	}
178 
179 	s->sh_next = NULL;
180 	sharefree(s, NULL);
181 
182 	/*
183 	 * We need to free the share for the caller.
184 	 */
185 	sharefree(sh, shl);
186 
187 	return (0);
188 }
189 
190 /*
191  * The caller must have allocated memory for us to use.
192  */
193 static int
194 sharefs_add(share_t *sh, sharefs_lens_t *shl)
195 {
196 	int		iHash;
197 	sharetab_t	*sht;
198 	share_t		*s, *p;
199 	int		iPath;
200 	int		n;
201 
202 	if (!sh) {
203 		return (ENOENT);
204 	}
205 
206 	/*
207 	 * We need to find the hash buckets for the fstype.
208 	 */
209 	rw_enter(&sharetab_lock, RW_WRITER);
210 	for (sht = sharefs_sharetab; sht != NULL; sht = sht->s_next) {
211 		if (strcmp(sh->sh_fstype, sht->s_fstype) == 0) {
212 			break;
213 		}
214 	}
215 
216 	/*
217 	 * Did not exist, so allocate one and add it to the
218 	 * sharetab.
219 	 */
220 	if (!sht) {
221 		sht = kmem_zalloc(sizeof (*sht), KM_SLEEP);
222 		n = strlen(sh->sh_fstype);
223 		sht->s_fstype = kmem_zalloc(n + 1, KM_SLEEP);
224 		(void) strncpy(sht->s_fstype, sh->sh_fstype, n);
225 
226 		sht->s_next = sharefs_sharetab;
227 		sharefs_sharetab = sht;
228 	}
229 
230 	/*
231 	 * Now we need to find where we have to add the entry.
232 	 */
233 	iHash = pkp_tab_hash(sh->sh_path, strlen(sh->sh_path));
234 
235 	iPath = shl ? shl->shl_path : strlen(sh->sh_path);
236 
237 	if (shl) {
238 		sh->sh_size = shl->shl_path + shl->shl_res +
239 		    shl->shl_fstype + shl->shl_opts + shl->shl_descr;
240 	} else {
241 		sh->sh_size = strlen(sh->sh_path) +
242 		    strlen(sh->sh_res) + strlen(sh->sh_fstype) +
243 		    strlen(sh->sh_opts) + strlen(sh->sh_descr);
244 	}
245 
246 	/*
247 	 * We need to account for field seperators and
248 	 * the EOL.
249 	 */
250 	sh->sh_size += 5;
251 
252 	/*
253 	 * Now walk down the hash table and add the new entry!
254 	 */
255 	for (p = NULL, s = sht->s_buckets[iHash].ssh_sh;
256 	    s != NULL; s = s->sh_next) {
257 		/*
258 		 * We need exact matches.
259 		 *
260 		 * We found a matching path. Either we have a
261 		 * duplicate path in a share command or we are
262 		 * being asked to replace an existing entry.
263 		 */
264 		if (strcmp(sh->sh_path, s->sh_path) == 0 &&
265 		    strlen(s->sh_path) == iPath) {
266 			if (p) {
267 				p->sh_next = sh;
268 			} else {
269 				sht->s_buckets[iHash].ssh_sh = sh;
270 			}
271 
272 			sh->sh_next = s->sh_next;
273 
274 			ASSERT(sharetab_size >= s->sh_size);
275 			sharetab_size -= s->sh_size;
276 			sharetab_size += sh->sh_size;
277 
278 			/*
279 			 * Get rid of the old node.
280 			 */
281 			sharefree(s, NULL);
282 
283 			gethrestime(&sharetab_mtime);
284 			atomic_inc_32(&sharetab_generation);
285 
286 			ASSERT(sht->s_buckets[iHash].ssh_count != 0);
287 			rw_exit(&sharetab_lock);
288 
289 			return (0);
290 		}
291 
292 		p = s;
293 	}
294 
295 	/*
296 	 * Okay, we have gone through the entire hash chain and not
297 	 * found a match. We just need to add this node.
298 	 */
299 	sh->sh_next = sht->s_buckets[iHash].ssh_sh;
300 	sht->s_buckets[iHash].ssh_sh = sh;
301 	atomic_inc_32(&sht->s_buckets[iHash].ssh_count);
302 	atomic_inc_32(&sht->s_count);
303 	atomic_inc_32(&sharetab_count);
304 	sharetab_size += sh->sh_size;
305 
306 	gethrestime(&sharetab_mtime);
307 	atomic_inc_32(&sharetab_generation);
308 
309 	rw_exit(&sharetab_lock);
310 
311 	return (0);
312 }
313 
314 void
315 sharefs_sharetab_init(void)
316 {
317 	rw_init(&sharetab_lock, NULL, RW_DEFAULT, NULL);
318 	rw_init(&sharefs_lock, NULL, RW_DEFAULT, NULL);
319 
320 	sharetab_size = 0;
321 	sharetab_count = 0;
322 	sharetab_generation = 1;
323 
324 	gethrestime(&sharetab_mtime);
325 	gethrestime(&sharetab_snap_time);
326 }
327 
328 int
329 sharefs_impl(enum sharefs_sys_op opcode, share_t *sh_in, uint32_t iMaxLen)
330 {
331 	int		error = 0;
332 	size_t		len;
333 	size_t		bufsz;
334 	share_t		*sh;
335 
336 	sharefs_lens_t	shl;
337 
338 	model_t		model;
339 
340 	char		*buf = NULL;
341 
342 	STRUCT_DECL(share, u_sh);
343 
344 	bufsz = iMaxLen;
345 
346 	/*
347 	 * Before we do anything, lets make sure we have
348 	 * a sharetab in memory if we need one.
349 	 */
350 	rw_enter(&sharetab_lock, RW_READER);
351 	switch (opcode) {
352 	case (SHAREFS_REMOVE) :
353 	case (SHAREFS_REPLACE) :
354 		if (!sharefs_sharetab) {
355 			rw_exit(&sharetab_lock);
356 			return (set_errno(ENOENT));
357 		}
358 		break;
359 	case (SHAREFS_ADD) :
360 	default :
361 		break;
362 	}
363 	rw_exit(&sharetab_lock);
364 
365 	model = get_udatamodel();
366 
367 	/*
368 	 * Initialize the data pointers.
369 	 */
370 	STRUCT_INIT(u_sh, model);
371 	if (copyin(sh_in, STRUCT_BUF(u_sh), STRUCT_SIZE(u_sh))) {
372 		return (set_errno(EFAULT));
373 	}
374 
375 	/*
376 	 * Get the share.
377 	 */
378 	sh = kmem_zalloc(sizeof (share_t), KM_SLEEP);
379 
380 	/*
381 	 * Get some storage for copying in the strings.
382 	 */
383 	buf = kmem_zalloc(bufsz + 1, KM_SLEEP);
384 	bzero(&shl, sizeof (sharefs_lens_t));
385 
386 	/*
387 	 * Only grab these two until we know what we want.
388 	 */
389 	SHARETAB_COPYIN(path);
390 	SHARETAB_COPYIN(fstype);
391 
392 	switch (opcode) {
393 	case (SHAREFS_ADD) :
394 	case (SHAREFS_REPLACE) :
395 		SHARETAB_COPYIN(res);
396 		SHARETAB_COPYIN(opts);
397 		SHARETAB_COPYIN(descr);
398 
399 		error = sharefs_add(sh, &shl);
400 		break;
401 
402 	case (SHAREFS_REMOVE) :
403 
404 		error = sharefs_remove(sh, &shl);
405 		break;
406 
407 	default:
408 		error = EINVAL;
409 		break;
410 	}
411 
412 cleanup:
413 
414 	/*
415 	 * If there is no error, then we have stashed the structure
416 	 * away in the sharetab hash table or have deleted it.
417 	 *
418 	 * Either way, the only reason to blow away the data is if
419 	 * there was an error.
420 	 */
421 	if (error != 0) {
422 		sharefree(sh, &shl);
423 	}
424 
425 	if (buf) {
426 		kmem_free(buf, bufsz + 1);
427 	}
428 
429 	return ((error != 0) ? set_errno(error) : 0);
430 }
431 
432 int
433 sharefs(enum sharefs_sys_op opcode, share_t *sh_in, uint32_t iMaxLen)
434 {
435 	if (secpolicy_sys_config(CRED(), B_FALSE) != 0)
436 		return (set_errno(EPERM));
437 
438 	return (sharefs_impl(opcode, sh_in, iMaxLen));
439 }
440