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);