vfs_acl.c revision 172930 
1/*-
2 * Copyright (c) 1999-2006 Robert N. M. Watson
3 * All rights reserved.
4 *
5 * This software was developed by Robert Watson for the TrustedBSD Project.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28/*
29 * Developed by the TrustedBSD Project.
30 *
31 * ACL system calls and other functions common across different ACL types.
32 * Type-specific routines go into subr_acl_<type>.c.
33 */
34
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: head/sys/kern/vfs_acl.c 172930 2007-10-24 19:04:04Z rwatson $");
37
38#include "opt_mac.h"
39
40#include <sys/param.h>
41#include <sys/systm.h>
42#include <sys/sysproto.h>
43#include <sys/kernel.h>
44#include <sys/malloc.h>
45#include <sys/mount.h>
46#include <sys/vnode.h>
47#include <sys/lock.h>
48#include <sys/mutex.h>
49#include <sys/namei.h>
50#include <sys/file.h>
51#include <sys/filedesc.h>
52#include <sys/proc.h>
53#include <sys/sysent.h>
54#include <sys/acl.h>
55
56#include <security/mac/mac_framework.h>
57
58#include <vm/uma.h>
59
60uma_zone_t	acl_zone;
61static int	vacl_set_acl(struct thread *td, struct vnode *vp,
62		    acl_type_t type, struct acl *aclp);
63static int	vacl_get_acl(struct thread *td, struct vnode *vp,
64		    acl_type_t type, struct acl *aclp);
65static int	vacl_aclcheck(struct thread *td, struct vnode *vp,
66		    acl_type_t type, struct acl *aclp);
67
68/*
69 * These calls wrap the real vnode operations, and are called by the syscall
70 * code once the syscall has converted the path or file descriptor to a vnode
71 * (unlocked).  The aclp pointer is assumed still to point to userland, so
72 * this should not be consumed within the kernel except by syscall code.
73 * Other code should directly invoke VOP_{SET,GET}ACL.
74 */
75
76/*
77 * Given a vnode, set its ACL.
78 */
79static int
80vacl_set_acl(struct thread *td, struct vnode *vp, acl_type_t type,
81    struct acl *aclp)
82{
83	struct acl inkernacl;
84	struct mount *mp;
85	int error;
86
87	error = copyin(aclp, &inkernacl, sizeof(struct acl));
88	if (error)
89		return(error);
90	error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
91	if (error != 0)
92		return (error);
93	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
94	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
95#ifdef MAC
96	error = mac_vnode_check_setacl(td->td_ucred, vp, type, &inkernacl);
97	if (error != 0)
98		goto out;
99#endif
100	error = VOP_SETACL(vp, type, &inkernacl, td->td_ucred, td);
101#ifdef MAC
102out:
103#endif
104	VOP_UNLOCK(vp, 0, td);
105	vn_finished_write(mp);
106	return(error);
107}
108
109/*
110 * Given a vnode, get its ACL.
111 */
112static int
113vacl_get_acl(struct thread *td, struct vnode *vp, acl_type_t type,
114    struct acl *aclp)
115{
116	struct acl inkernelacl;
117	int error;
118
119	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
120	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
121#ifdef MAC
122	error = mac_vnode_check_getacl(td->td_ucred, vp, type);
123	if (error != 0)
124		goto out;
125#endif
126	error = VOP_GETACL(vp, type, &inkernelacl, td->td_ucred, td);
127#ifdef MAC
128out:
129#endif
130	VOP_UNLOCK(vp, 0, td);
131	if (error == 0)
132		error = copyout(&inkernelacl, aclp, sizeof(struct acl));
133	return (error);
134}
135
136/*
137 * Given a vnode, delete its ACL.
138 */
139static int
140vacl_delete(struct thread *td, struct vnode *vp, acl_type_t type)
141{
142	struct mount *mp;
143	int error;
144
145	error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
146	if (error)
147		return (error);
148	VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
149	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
150#ifdef MAC
151	error = mac_vnode_check_deleteacl(td->td_ucred, vp, type);
152	if (error)
153		goto out;
154#endif
155	error = VOP_SETACL(vp, type, 0, td->td_ucred, td);
156#ifdef MAC
157out:
158#endif
159	VOP_UNLOCK(vp, 0, td);
160	vn_finished_write(mp);
161	return (error);
162}
163
164/*
165 * Given a vnode, check whether an ACL is appropriate for it
166 */
167static int
168vacl_aclcheck(struct thread *td, struct vnode *vp, acl_type_t type,
169    struct acl *aclp)
170{
171	struct acl inkernelacl;
172	int error;
173
174	error = copyin(aclp, &inkernelacl, sizeof(struct acl));
175	if (error)
176		return(error);
177	error = VOP_ACLCHECK(vp, type, &inkernelacl, td->td_ucred, td);
178	return (error);
179}
180
181/*
182 * syscalls -- convert the path/fd to a vnode, and call vacl_whatever.  Don't
183 * need to lock, as the vacl_ code will get/release any locks required.
184 */
185
186/*
187 * Given a file path, get an ACL for it
188 */
189int
190__acl_get_file(struct thread *td, struct __acl_get_file_args *uap)
191{
192	struct nameidata nd;
193	int vfslocked, error;
194
195	NDINIT(&nd, LOOKUP, MPSAFE|FOLLOW, UIO_USERSPACE, uap->path, td);
196	error = namei(&nd);
197	vfslocked = NDHASGIANT(&nd);
198	if (error == 0) {
199		error = vacl_get_acl(td, nd.ni_vp, uap->type, uap->aclp);
200		NDFREE(&nd, 0);
201	}
202	VFS_UNLOCK_GIANT(vfslocked);
203	return (error);
204}
205
206/*
207 * Given a file path, get an ACL for it; don't follow links.
208 */
209int
210__acl_get_link(struct thread *td, struct __acl_get_link_args *uap)
211{
212	struct nameidata nd;
213	int vfslocked, error;
214
215	NDINIT(&nd, LOOKUP, MPSAFE|NOFOLLOW, UIO_USERSPACE, uap->path, td);
216	error = namei(&nd);
217	vfslocked = NDHASGIANT(&nd);
218	if (error == 0) {
219		error = vacl_get_acl(td, nd.ni_vp, uap->type, uap->aclp);
220		NDFREE(&nd, 0);
221	}
222	VFS_UNLOCK_GIANT(vfslocked);
223	return (error);
224}
225
226/*
227 * Given a file path, set an ACL for it.
228 */
229int
230__acl_set_file(struct thread *td, struct __acl_set_file_args *uap)
231{
232	struct nameidata nd;
233	int vfslocked, error;
234
235	NDINIT(&nd, LOOKUP, MPSAFE|FOLLOW, UIO_USERSPACE, uap->path, td);
236	error = namei(&nd);
237	vfslocked = NDHASGIANT(&nd);
238	if (error == 0) {
239		error = vacl_set_acl(td, nd.ni_vp, uap->type, uap->aclp);
240		NDFREE(&nd, 0);
241	}
242	VFS_UNLOCK_GIANT(vfslocked);
243	return (error);
244}
245
246/*
247 * Given a file path, set an ACL for it; don't follow links.
248 */
249int
250__acl_set_link(struct thread *td, struct __acl_set_link_args *uap)
251{
252	struct nameidata nd;
253	int vfslocked, error;
254
255	NDINIT(&nd, LOOKUP, MPSAFE|NOFOLLOW, UIO_USERSPACE, uap->path, td);
256	error = namei(&nd);
257	vfslocked = NDHASGIANT(&nd);
258	if (error == 0) {
259		error = vacl_set_acl(td, nd.ni_vp, uap->type, uap->aclp);
260		NDFREE(&nd, 0);
261	}
262	VFS_UNLOCK_GIANT(vfslocked);
263	return (error);
264}
265
266/*
267 * Given a file descriptor, get an ACL for it.
268 */
269int
270__acl_get_fd(struct thread *td, struct __acl_get_fd_args *uap)
271{
272	struct file *fp;
273	int vfslocked, error;
274
275	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
276	if (error == 0) {
277		vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
278		error = vacl_get_acl(td, fp->f_vnode, uap->type, uap->aclp);
279		fdrop(fp, td);
280		VFS_UNLOCK_GIANT(vfslocked);
281	}
282	return (error);
283}
284
285/*
286 * Given a file descriptor, set an ACL for it.
287 */
288int
289__acl_set_fd(struct thread *td, struct __acl_set_fd_args *uap)
290{
291	struct file *fp;
292	int vfslocked, error;
293
294	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
295	if (error == 0) {
296		vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
297		error = vacl_set_acl(td, fp->f_vnode, uap->type, uap->aclp);
298		fdrop(fp, td);
299		VFS_UNLOCK_GIANT(vfslocked);
300	}
301	return (error);
302}
303
304/*
305 * Given a file path, delete an ACL from it.
306 */
307int
308__acl_delete_file(struct thread *td, struct __acl_delete_file_args *uap)
309{
310	struct nameidata nd;
311	int vfslocked, error;
312
313	NDINIT(&nd, LOOKUP, MPSAFE|FOLLOW, UIO_USERSPACE, uap->path, td);
314	error = namei(&nd);
315	vfslocked = NDHASGIANT(&nd);
316	if (error == 0) {
317		error = vacl_delete(td, nd.ni_vp, uap->type);
318		NDFREE(&nd, 0);
319	}
320	VFS_UNLOCK_GIANT(vfslocked);
321	return (error);
322}
323
324/*
325 * Given a file path, delete an ACL from it; don't follow links.
326 */
327int
328__acl_delete_link(struct thread *td, struct __acl_delete_link_args *uap)
329{
330	struct nameidata nd;
331	int vfslocked, error;
332
333	NDINIT(&nd, LOOKUP, MPSAFE|NOFOLLOW, UIO_USERSPACE, uap->path, td);
334	error = namei(&nd);
335	vfslocked = NDHASGIANT(&nd);
336	if (error == 0) {
337		error = vacl_delete(td, nd.ni_vp, uap->type);
338		NDFREE(&nd, 0);
339	}
340	VFS_UNLOCK_GIANT(vfslocked);
341	return (error);
342}
343
344/*
345 * Given a file path, delete an ACL from it.
346 */
347int
348__acl_delete_fd(struct thread *td, struct __acl_delete_fd_args *uap)
349{
350	struct file *fp;
351	int vfslocked, error;
352
353	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
354	if (error == 0) {
355		vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
356		error = vacl_delete(td, fp->f_vnode, uap->type);
357		fdrop(fp, td);
358		VFS_UNLOCK_GIANT(vfslocked);
359	}
360	return (error);
361}
362
363/*
364 * Given a file path, check an ACL for it.
365 */
366int
367__acl_aclcheck_file(struct thread *td, struct __acl_aclcheck_file_args *uap)
368{
369	struct nameidata	nd;
370	int vfslocked, error;
371
372	NDINIT(&nd, LOOKUP, MPSAFE|FOLLOW, UIO_USERSPACE, uap->path, td);
373	error = namei(&nd);
374	vfslocked = NDHASGIANT(&nd);
375	if (error == 0) {
376		error = vacl_aclcheck(td, nd.ni_vp, uap->type, uap->aclp);
377		NDFREE(&nd, 0);
378	}
379	VFS_UNLOCK_GIANT(vfslocked);
380	return (error);
381}
382
383/*
384 * Given a file path, check an ACL for it; don't follow links.
385 */
386int
387__acl_aclcheck_link(struct thread *td, struct __acl_aclcheck_link_args *uap)
388{
389	struct nameidata	nd;
390	int vfslocked, error;
391
392	NDINIT(&nd, LOOKUP, MPSAFE|NOFOLLOW, UIO_USERSPACE, uap->path, td);
393	error = namei(&nd);
394	vfslocked = NDHASGIANT(&nd);
395	if (error == 0) {
396		error = vacl_aclcheck(td, nd.ni_vp, uap->type, uap->aclp);
397		NDFREE(&nd, 0);
398	}
399	VFS_UNLOCK_GIANT(vfslocked);
400	return (error);
401}
402
403/*
404 * Given a file descriptor, check an ACL for it.
405 */
406int
407__acl_aclcheck_fd(struct thread *td, struct __acl_aclcheck_fd_args *uap)
408{
409	struct file *fp;
410	int vfslocked, error;
411
412	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
413	if (error == 0) {
414		vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
415		error = vacl_aclcheck(td, fp->f_vnode, uap->type, uap->aclp);
416		fdrop(fp, td);
417		VFS_UNLOCK_GIANT(vfslocked);
418	}
419	return (error);
420}
421
422/* ARGUSED */
423
424static void
425aclinit(void *dummy __unused)
426{
427
428	acl_zone = uma_zcreate("ACL UMA zone", sizeof(struct acl),
429	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
430}
431SYSINIT(acls, SI_SUB_ACL, SI_ORDER_FIRST, aclinit, NULL)
432