linux_mib.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1999 Marcel Moolenaar
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer 
   10  *    in this position and unchanged.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. The name of the author may not be used to endorse or promote products
   15  *    derived from this software without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/5.2/sys/compat/linux/linux_mib.c 116173 2003-06-10 21:29:12Z obrien $");
   31 
   32 #include <sys/param.h>
   33 #include <sys/kernel.h>
   34 #include <sys/systm.h>
   35 #include <sys/sysctl.h>
   36 #include <sys/proc.h>
   37 #include <sys/malloc.h>
   38 #include <sys/jail.h>
   39 #include <sys/lock.h>
   40 #include <sys/mutex.h>
   41 
   42 #include <machine/../linux/linux.h>
   43 #include <compat/linux/linux_mib.h>
   44 
   45 struct linux_prison {
   46         char    pr_osname[LINUX_MAX_UTSNAME];
   47         char    pr_osrelease[LINUX_MAX_UTSNAME];
   48         int     pr_oss_version;
   49 };
   50 
   51 SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
   52             "Linux mode");
   53 
   54 static struct mtx osname_lock;
   55 MTX_SYSINIT(linux_osname, &osname_lock, "linux osname", MTX_DEF);
   56 
   57 static char     linux_osname[LINUX_MAX_UTSNAME] = "Linux";
   58 
   59 static int
   60 linux_sysctl_osname(SYSCTL_HANDLER_ARGS)
   61 {
   62         char osname[LINUX_MAX_UTSNAME];
   63         int error;
   64 
   65         linux_get_osname(req->td, osname);
   66         error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
   67         if (error || req->newptr == NULL)
   68                 return (error);
   69         error = linux_set_osname(req->td, osname);
   70         return (error);
   71 }
   72 
   73 SYSCTL_PROC(_compat_linux, OID_AUTO, osname,
   74             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON,
   75             0, 0, linux_sysctl_osname, "A",
   76             "Linux kernel OS name");
   77 
   78 static char     linux_osrelease[LINUX_MAX_UTSNAME] = "2.4.2";
   79 
   80 static int
   81 linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS)
   82 {
   83         char osrelease[LINUX_MAX_UTSNAME];
   84         int error;
   85 
   86         linux_get_osrelease(req->td, osrelease);
   87         error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
   88         if (error || req->newptr == NULL)
   89                 return (error);
   90         error = linux_set_osrelease(req->td, osrelease);
   91         return (error);
   92 }
   93 
   94 SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease,
   95             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON,
   96             0, 0, linux_sysctl_osrelease, "A",
   97             "Linux kernel OS release");
   98 
   99 static int      linux_oss_version = 0x030600;
  100 
  101 static int
  102 linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS)
  103 {
  104         int oss_version;
  105         int error;
  106 
  107         oss_version = linux_get_oss_version(req->td);
  108         error = sysctl_handle_int(oidp, &oss_version, 0, req);
  109         if (error || req->newptr == NULL)
  110                 return (error);
  111         error = linux_set_oss_version(req->td, oss_version);
  112         return (error);
  113 }
  114 
  115 SYSCTL_PROC(_compat_linux, OID_AUTO, oss_version,
  116             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_PRISON,
  117             0, 0, linux_sysctl_oss_version, "I",
  118             "Linux OSS version");
  119 
  120 /*
  121  * Returns holding the prison mutex if return non-NULL.
  122  */
  123 static struct prison *
  124 linux_get_prison(struct thread *td)
  125 {
  126         register struct prison *pr;
  127         register struct linux_prison *lpr;
  128 
  129         KASSERT(td == curthread, ("linux_get_prison() called on !curthread"));
  130         if (!jailed(td->td_ucred))
  131                 return (NULL);
  132         pr = td->td_ucred->cr_prison;
  133         mtx_lock(&pr->pr_mtx);
  134         if (pr->pr_linux == NULL) {
  135                 /*
  136                  * If we don't have a linux prison structure yet, allocate
  137                  * one.  We have to handle the race where another thread
  138                  * could be adding a linux prison to this process already.
  139                  */
  140                 mtx_unlock(&pr->pr_mtx);
  141                 lpr = malloc(sizeof(struct linux_prison), M_PRISON,
  142                     M_WAITOK | M_ZERO);
  143                 mtx_lock(&pr->pr_mtx);
  144                 if (pr->pr_linux == NULL)
  145                         pr->pr_linux = lpr;
  146                 else
  147                         free(lpr, M_PRISON);
  148         }
  149         return (pr);
  150 }
  151 
  152 void
  153 linux_mib_destroy(void)
  154 {
  155 
  156         mtx_destroy(&osname_lock);
  157 }
  158 
  159 void
  160 linux_get_osname(struct thread *td, char *dst)
  161 {
  162         register struct prison *pr;
  163         register struct linux_prison *lpr;
  164 
  165         pr = td->td_ucred->cr_prison;
  166         if (pr != NULL) {
  167                 mtx_lock(&pr->pr_mtx);
  168                 if (pr->pr_linux != NULL) {
  169                         lpr = (struct linux_prison *)pr->pr_linux;
  170                         if (lpr->pr_osname[0]) {
  171                                 bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME);
  172                                 mtx_unlock(&pr->pr_mtx);
  173                                 return;
  174                         }
  175                 }
  176                 mtx_unlock(&pr->pr_mtx);
  177         }
  178 
  179         mtx_lock(&osname_lock);
  180         bcopy(linux_osname, dst, LINUX_MAX_UTSNAME);
  181         mtx_unlock(&osname_lock);
  182 }
  183 
  184 int
  185 linux_set_osname(struct thread *td, char *osname)
  186 {
  187         struct prison *pr;
  188         struct linux_prison *lpr;
  189 
  190         pr = linux_get_prison(td);
  191         if (pr != NULL) {
  192                 lpr = (struct linux_prison *)pr->pr_linux;
  193                 strcpy(lpr->pr_osname, osname);
  194                 mtx_unlock(&pr->pr_mtx);
  195         } else {
  196                 mtx_lock(&osname_lock);
  197                 strcpy(linux_osname, osname);
  198                 mtx_unlock(&osname_lock);
  199         }
  200 
  201         return (0);
  202 }
  203 
  204 void
  205 linux_get_osrelease(struct thread *td, char *dst)
  206 {
  207         register struct prison *pr;
  208         struct linux_prison *lpr;
  209 
  210         pr = td->td_ucred->cr_prison;
  211         if (pr != NULL) {
  212                 mtx_lock(&pr->pr_mtx);
  213                 if (pr->pr_linux != NULL) {
  214                         lpr = (struct linux_prison *)pr->pr_linux;
  215                         if (lpr->pr_osrelease[0]) {
  216                                 bcopy(lpr->pr_osrelease, dst,
  217                                     LINUX_MAX_UTSNAME);
  218                                 mtx_unlock(&pr->pr_mtx);
  219                                 return;
  220                         }
  221                 }
  222                 mtx_unlock(&pr->pr_mtx);
  223         }
  224 
  225         mtx_lock(&osname_lock);
  226         bcopy(linux_osrelease, dst, LINUX_MAX_UTSNAME);
  227         mtx_unlock(&osname_lock);
  228 }
  229 
  230 int
  231 linux_set_osrelease(struct thread *td, char *osrelease)
  232 {
  233         struct prison *pr;
  234         struct linux_prison *lpr;
  235 
  236         pr = linux_get_prison(td);
  237         if (pr != NULL) {
  238                 lpr = (struct linux_prison *)pr->pr_linux;
  239                 strcpy(lpr->pr_osrelease, osrelease);
  240                 mtx_unlock(&pr->pr_mtx);
  241         } else {
  242                 mtx_lock(&osname_lock);
  243                 strcpy(linux_osrelease, osrelease);
  244                 mtx_unlock(&osname_lock);
  245         }
  246 
  247         return (0);
  248 }
  249 
  250 int
  251 linux_get_oss_version(struct thread *td)
  252 {
  253         register struct prison *pr;
  254         register struct linux_prison *lpr;
  255         int version;
  256 
  257         pr = td->td_ucred->cr_prison;
  258         if (pr != NULL) {
  259                 mtx_lock(&pr->pr_mtx);
  260                 if (pr->pr_linux != NULL) {
  261                         lpr = (struct linux_prison *)pr->pr_linux;
  262                         if (lpr->pr_oss_version) {
  263                                 version = lpr->pr_oss_version;
  264                                 mtx_unlock(&pr->pr_mtx);
  265                                 return (version);
  266                         }
  267                 }
  268                 mtx_unlock(&pr->pr_mtx);
  269         }
  270 
  271         mtx_lock(&osname_lock);
  272         version = linux_oss_version;
  273         mtx_unlock(&osname_lock);
  274         return (version);
  275 }
  276 
  277 int
  278 linux_set_oss_version(struct thread *td, int oss_version)
  279 {
  280         struct prison *pr;
  281         struct linux_prison *lpr;
  282 
  283         pr = linux_get_prison(td);
  284         if (pr != NULL) {
  285                 lpr = (struct linux_prison *)pr->pr_linux;
  286                 lpr->pr_oss_version = oss_version;
  287                 mtx_unlock(&pr->pr_mtx);
  288         } else {
  289                 mtx_lock(&osname_lock);
  290                 linux_oss_version = oss_version;
  291                 mtx_unlock(&osname_lock);
  292         }
  293 
  294         return (0);
  295 }
  296 
  297 #ifdef DEBUG
  298 
  299 u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
  300 
  301 static int
  302 linux_debug(int syscall, int toggle, int global)
  303 {
  304 
  305         if (global) {
  306                 char c = toggle ? 0 : 0xff;
  307 
  308                 memset(linux_debug_map, c, sizeof(linux_debug_map));
  309                 return (0);
  310         }
  311         if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
  312                 return (EINVAL);
  313         if (toggle)
  314                 clrbit(linux_debug_map, syscall);
  315         else
  316                 setbit(linux_debug_map, syscall);
  317         return (0);
  318 }
  319 
  320 /*
  321  * Usage: sysctl linux.debug=<syscall_nr>.<0/1>
  322  *
  323  *    E.g.: sysctl linux.debug=21.0
  324  *
  325  * As a special case, syscall "all" will apply to all syscalls globally.
  326  */
  327 #define LINUX_MAX_DEBUGSTR      16
  328 static int
  329 linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
  330 {
  331         char value[LINUX_MAX_DEBUGSTR], *p;
  332         int error, sysc, toggle;
  333         int global = 0;
  334 
  335         value[0] = '\0';
  336         error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
  337         if (error || req->newptr == NULL)
  338                 return (error);
  339         for (p = value; *p != '\0' && *p != '.'; p++);
  340         if (*p == '\0')
  341                 return (EINVAL);
  342         *p++ = '\0';
  343         sysc = strtol(value, NULL, 0);
  344         toggle = strtol(p, NULL, 0);
  345         if (strcmp(value, "all") == 0)
  346                 global = 1;
  347         error = linux_debug(sysc, toggle, global);
  348         return (error);
  349 }
  350 
  351 SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
  352             CTLTYPE_STRING | CTLFLAG_RW,
  353             0, 0, linux_sysctl_debug, "A",
  354             "Linux debugging control");
  355 
  356 #endif /* DEBUG */
Cache object: bbcb6368a19e06ace4077d5302ccd32a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/compat/linux/linux_mib.c

FreeBSD/Linux Kernel Cross Reference
sys/compat/linux/linux_mib.c
