2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/kern/kern_varsym.c,v 1.9 2007/04/30 07:18:54 dillon Exp $
38 * This module implements variable storage and management for variant
39 * symlinks. These variables may also be used for general purposes.
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/ucred.h>
46 #include <sys/resourcevar.h>
50 #include <sys/queue.h>
51 #include <sys/sysctl.h>
52 #include <sys/malloc.h>
53 #include <sys/varsym.h>
54 #include <sys/sysproto.h>
56 #include <sys/mplock2.h>
58 MALLOC_DEFINE(M_VARSYM
, "varsym", "variable sets for variant symlinks");
60 struct varsymset varsymset_sys
;
63 * Initialize the variant symlink subsystem
66 varsym_sysinit(void *dummy
)
68 varsymset_init(&varsymset_sys
, NULL
);
70 SYSINIT(announce
, SI_BOOT2_MACHDEP
, SI_ORDER_FIRST
, varsym_sysinit
, NULL
);
73 * varsymreplace() - called from namei
75 * Do variant symlink variable substitution
78 varsymreplace(char *cp
, int linklen
, int maxlen
)
88 if (cp
[0] == '$' && cp
[1] == '{') {
89 for (i
= 2; i
< linklen
; ++i
) {
94 (var
= varsymfind(VARSYM_ALL_MASK
, cp
+ 2, i
- 2)) != NULL
96 xlen
= i
+ 1; /* bytes to strike */
97 nlen
= strlen(var
->vs_data
); /* bytes to add */
98 if (linklen
+ nlen
- xlen
>= maxlen
) {
102 KKASSERT(linklen
>= xlen
);
104 bcopy(cp
+ xlen
, cp
+ nlen
, linklen
- xlen
);
105 bcopy(var
->vs_data
, cp
, nlen
);
106 linklen
+= nlen
- xlen
; /* new relative length */
107 rlen
+= nlen
- xlen
; /* returned total length */
108 cp
+= nlen
; /* adjust past replacement */
109 linklen
-= nlen
; /* adjust past replacement */
110 maxlen
-= nlen
; /* adjust past replacement */
113 * It's ok if i points to the '}', it will simply be
114 * skipped. i could also have hit linklen.
130 * varsym_set() system call
132 * (int level, const char *name, const char *data)
137 sys_varsym_set(struct varsym_set_args
*uap
)
139 char name
[MAXVARSYM_NAME
];
148 p
= lp
? lp
->lwp_proc
: NULL
;
150 if ((error
= copyinstr(uap
->name
, name
, sizeof(name
), NULL
)) != 0)
152 buf
= kmalloc(MAXVARSYM_DATA
, M_TEMP
, M_WAITOK
);
154 (error
= copyinstr(uap
->data
, buf
, MAXVARSYM_DATA
, NULL
)) != 0)
163 if (lp
!= NULL
&& td
->td_ucred
->cr_prison
!= NULL
)
164 uap
->level
= VARSYM_PRISON
;
167 (error
= priv_check_cred(td
->td_ucred
, PRIV_VARSYM_SYS
, 0)) != 0)
171 /* XXX check jail / implement per-jail user */
175 (void)varsymmake(uap
->level
, name
, NULL
);
176 error
= varsymmake(uap
->level
, name
, buf
);
178 error
= varsymmake(uap
->level
, name
, NULL
);
190 * varsym_get() system call
192 * (int mask, const char *wild, char *buf, int bufsize)
197 sys_varsym_get(struct varsym_get_args
*uap
)
199 char wild
[MAXVARSYM_NAME
];
205 if ((error
= copyinstr(uap
->wild
, wild
, sizeof(wild
), NULL
)) != 0)
207 sym
= varsymfind(uap
->mask
, wild
, strlen(wild
));
212 dlen
= strlen(sym
->vs_data
);
213 if (dlen
< uap
->bufsize
) {
214 copyout(sym
->vs_data
, uap
->buf
, dlen
+ 1);
215 } else if (uap
->bufsize
) {
216 copyout("", uap
->buf
, 1);
218 uap
->sysmsg_result
= dlen
+ 1;
226 * varsym_list() system call
228 * (int level, char *buf, int maxsize, int *marker)
233 sys_varsym_list(struct varsym_list_args
*uap
)
235 struct varsymset
*vss
;
236 struct varsyment
*ve
;
247 * Get the marker from userspace.
250 if ((error
= copyin(uap
->marker
, &marker
, sizeof(marker
))) != 0)
254 * Figure out the varsym set.
258 p
= lp
? lp
->lwp_proc
: NULL
;
262 switch (uap
->level
) {
265 vss
= &p
->p_varsymset
;
269 vss
= &td
->td_ucred
->cr_uidinfo
->ui_varsymset
;
272 vss
= &varsymset_sys
;
275 if (lp
&& td
->td_ucred
->cr_prison
)
276 vss
= &td
->td_ucred
->cr_prison
->pr_varsymset
;
285 * Loop through the variables and dump them to uap->buf
291 lockmgr(&vss
->vx_lock
, LK_SHARED
);
292 TAILQ_FOREACH(ve
, &vss
->vx_queue
, ve_entry
) {
293 varsym_t sym
= ve
->ve_sym
;
294 int namelen
= strlen(sym
->vs_name
);
295 int datalen
= strlen(sym
->vs_data
);
296 int totlen
= namelen
+ datalen
+ 2;
299 * Skip to our index point
307 * Stop if there is insufficient space in the user buffer.
308 * If we haven't stored anything yet return EOVERFLOW.
309 * Note that the marker index (i) does not change.
311 if (bytes
+ totlen
> uap
->maxsize
) {
318 error
= copyout(sym
->vs_name
, uap
->buf
+ bytes
, namelen
+ 1);
320 bytes
+= namelen
+ 1;
321 error
= copyout(sym
->vs_data
, uap
->buf
+ bytes
, datalen
+ 1);
323 bytes
+= datalen
+ 1;
325 bytes
-= namelen
+ 1; /* revert if error */
333 lockmgr(&vss
->vx_lock
, LK_RELEASE
);
336 * Save the marker back. If no error occured and earlyterm is clear
337 * the marker is set to -1 indicating that the variable list has been
338 * exhausted. If no error occured the number of bytes loaded into
339 * the buffer will be returned, otherwise the syscall code returns -1.
341 if (error
== 0 && earlyterm
== 0)
346 error
= copyout(&marker
, uap
->marker
, sizeof(marker
));
347 uap
->sysmsg_result
= bytes
;
354 * Lookup a variant symlink. XXX use a hash table.
358 varsymlookup(struct varsymset
*vss
, const char *name
, int namelen
)
360 struct varsyment
*ve
;
362 KKASSERT(lockstatus(&vss
->vx_lock
, curthread
) != 0);
363 TAILQ_FOREACH(ve
, &vss
->vx_queue
, ve_entry
) {
364 varsym_t var
= ve
->ve_sym
;
365 if (var
->vs_namelen
== namelen
&&
366 bcmp(name
, var
->vs_name
, namelen
) == 0
376 vsslock(struct varsymset
**vss
, struct varsymset
*n
)
379 lockmgr(&(*vss
)->vx_lock
, LK_RELEASE
);
381 lockmgr(&n
->vx_lock
, LK_SHARED
);
386 varsymfind(int mask
, const char *name
, int namelen
)
388 struct varsyment
*ve
= NULL
;
389 struct varsymset
*vss
= NULL
;
397 p
= lp
? lp
->lwp_proc
: NULL
;
399 if ((mask
& (VARSYM_PROC_MASK
|VARSYM_USER_MASK
)) && lp
!= NULL
) {
400 if (mask
& VARSYM_PROC_MASK
) {
401 vsslock(&vss
, &p
->p_varsymset
);
402 ve
= varsymlookup(vss
, name
, namelen
);
404 if (ve
== NULL
&& (mask
& VARSYM_USER_MASK
)) {
405 vsslock(&vss
, &td
->td_ucred
->cr_uidinfo
->ui_varsymset
);
406 ve
= varsymlookup(vss
, name
, namelen
);
409 if (ve
== NULL
&& (mask
& VARSYM_SYS_MASK
)) {
410 if (lp
!= NULL
&& td
->td_ucred
->cr_prison
) {
411 vsslock(&vss
, &td
->td_ucred
->cr_prison
->pr_varsymset
);
412 ve
= varsymlookup(vss
, name
, namelen
);
414 vsslock(&vss
, &varsymset_sys
);
415 ve
= varsymlookup(vss
, name
, namelen
);
420 atomic_add_int(&sym
->vs_refs
, 1);
425 lockmgr(&vss
->vx_lock
, LK_RELEASE
);
430 varsymmake(int level
, const char *name
, const char *data
)
432 struct varsymset
*vss
= NULL
;
433 struct varsyment
*ve
;
438 int namelen
= strlen(name
);
444 p
= lp
? lp
->lwp_proc
: NULL
;
449 vss
= &p
->p_varsymset
;
453 vss
= &td
->td_ucred
->cr_uidinfo
->ui_varsymset
;
456 vss
= &varsymset_sys
;
459 if (lp
&& td
->td_ucred
->cr_prison
)
460 vss
= &td
->td_ucred
->cr_prison
->pr_varsymset
;
466 lockmgr(&vss
->vx_lock
, LK_EXCLUSIVE
);
467 if (data
&& vss
->vx_setsize
>= MAXVARSYM_SET
) {
470 datalen
= strlen(data
);
471 ve
= kmalloc(sizeof(struct varsyment
), M_VARSYM
, M_WAITOK
|M_ZERO
);
472 sym
= kmalloc(sizeof(struct varsym
) + namelen
+ datalen
+ 2, M_VARSYM
, M_WAITOK
);
475 sym
->vs_namelen
= namelen
;
476 sym
->vs_name
= (char *)(sym
+ 1);
477 sym
->vs_data
= sym
->vs_name
+ namelen
+ 1;
478 strcpy(sym
->vs_name
, name
);
479 strcpy(sym
->vs_data
, data
);
480 TAILQ_INSERT_TAIL(&vss
->vx_queue
, ve
, ve_entry
);
481 vss
->vx_setsize
+= sizeof(struct varsyment
) + sizeof(struct varsym
) + namelen
+ datalen
+ 8;
484 if ((ve
= varsymlookup(vss
, name
, namelen
)) != NULL
) {
485 TAILQ_REMOVE(&vss
->vx_queue
, ve
, ve_entry
);
486 vss
->vx_setsize
-= sizeof(struct varsyment
) + sizeof(struct varsym
) + namelen
+ strlen(ve
->ve_sym
->vs_data
) + 8;
487 varsymdrop(ve
->ve_sym
);
494 lockmgr(&vss
->vx_lock
, LK_RELEASE
);
499 varsymdrop(varsym_t sym
)
501 KKASSERT(sym
->vs_refs
> 0);
502 if (atomic_fetchadd_int(&sym
->vs_refs
, -1) == 1) {
503 kfree(sym
, M_VARSYM
);
508 * Insert a duplicate of ve in vss. Does not do any locking,
509 * so it is the callers responsibility to make sure nobody
510 * else can mess with the TAILQ in vss at the same time.
513 varsymdup(struct varsymset
*vss
, struct varsyment
*ve
)
515 struct varsyment
*nve
;
517 nve
= kmalloc(sizeof(struct varsyment
), M_VARSYM
, M_WAITOK
|M_ZERO
);
518 nve
->ve_sym
= ve
->ve_sym
;
519 ++nve
->ve_sym
->vs_refs
; /* can't be reached, no need for atomic add */
521 * We're only called through varsymset_init() so vss is not yet reachable,
524 TAILQ_INSERT_TAIL(&vss
->vx_queue
, nve
, ve_entry
);
528 varsymset_init(struct varsymset
*vss
, struct varsymset
*copy
)
530 struct varsyment
*ve
;
532 TAILQ_INIT(&vss
->vx_queue
);
533 lockinit(&vss
->vx_lock
, "vx", 0, 0);
535 TAILQ_FOREACH(ve
, ©
->vx_queue
, ve_entry
) {
538 vss
->vx_setsize
= copy
->vx_setsize
;
543 varsymset_clean(struct varsymset
*vss
)
545 struct varsyment
*ve
;
547 lockmgr(&vss
->vx_lock
, LK_EXCLUSIVE
);
548 while ((ve
= TAILQ_FIRST(&vss
->vx_queue
)) != NULL
) {
549 TAILQ_REMOVE(&vss
->vx_queue
, ve
, ve_entry
);
550 varsymdrop(ve
->ve_sym
);
554 lockmgr(&vss
->vx_lock
, LK_RELEASE
);