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  * $FreeBSD$
   29  */
   30 
   31 #include <sys/param.h>
   32 #include <sys/kernel.h>
   33 #include <sys/systm.h>
   34 #include <sys/sysctl.h>
   35 #include <sys/proc.h>
   36 #include <sys/malloc.h>
   37 #include <sys/jail.h>
   38 
   39 #include <machine/../linux/linux.h>
   40 #include <compat/linux/linux_mib.h>
   41 
   42 struct linux_prison {
   43         char    pr_osname[LINUX_MAX_UTSNAME];
   44         char    pr_osrelease[LINUX_MAX_UTSNAME];
   45         int     pr_oss_version;
   46 };
   47 
   48 SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
   49             "Linux mode");
   50 
   51 static char     linux_osname[LINUX_MAX_UTSNAME] = "Linux";
   52 
   53 static int
   54 linux_sysctl_osname(SYSCTL_HANDLER_ARGS)
   55 {
   56         char osname[LINUX_MAX_UTSNAME];
   57         int error;
   58 
   59         strcpy(osname, linux_get_osname(req->p));
   60         error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
   61         if (error || req->newptr == NULL)
   62                 return (error);
   63         error = linux_set_osname(req->p, osname);
   64         return (error);
   65 }
   66 
   67 SYSCTL_PROC(_compat_linux, OID_AUTO, osname,
   68             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON,
   69             0, 0, linux_sysctl_osname, "A",
   70             "Linux kernel OS name");
   71 
   72 static char     linux_osrelease[LINUX_MAX_UTSNAME] = "2.4.2";
   73 
   74 static int
   75 linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS)
   76 {
   77         char osrelease[LINUX_MAX_UTSNAME];
   78         int error;
   79 
   80         strcpy(osrelease, linux_get_osrelease(req->p));
   81         error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
   82         if (error || req->newptr == NULL)
   83                 return (error);
   84         error = linux_set_osrelease(req->p, osrelease);
   85         return (error);
   86 }
   87 
   88 SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease,
   89             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON,
   90             0, 0, linux_sysctl_osrelease, "A",
   91             "Linux kernel OS release");
   92 
   93 static int      linux_oss_version = 0x030600;
   94 
   95 static int
   96 linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS)
   97 {
   98         int oss_version;
   99         int error;
  100 
  101         oss_version = linux_get_oss_version(req->p);
  102         error = sysctl_handle_int(oidp, &oss_version, 0, req);
  103         if (error || req->newptr == NULL)
  104                 return (error);
  105         error = linux_set_oss_version(req->p, oss_version);
  106         return (error);
  107 }
  108 
  109 SYSCTL_PROC(_compat_linux, OID_AUTO, oss_version,
  110             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_PRISON,
  111             0, 0, linux_sysctl_oss_version, "I",
  112             "Linux OSS version");
  113 
  114 static struct linux_prison *
  115 get_prison(struct proc *p)
  116 {
  117         register struct prison *pr;
  118         register struct linux_prison *lpr;
  119 
  120         pr = p->p_prison;
  121         if (pr == NULL)
  122                 return (NULL);
  123 
  124         if (pr->pr_linux == NULL) {
  125                 MALLOC(lpr, struct linux_prison *, sizeof *lpr,
  126                     M_PRISON, M_WAITOK|M_ZERO);
  127                 pr->pr_linux = lpr;
  128         }
  129 
  130         return (pr->pr_linux);
  131 }
  132 
  133 char *
  134 linux_get_osname(p)
  135         struct proc *p;
  136 {
  137         register struct prison *pr;
  138         register struct linux_prison *lpr;
  139 
  140         pr = p->p_prison;
  141         if (pr != NULL && pr->pr_linux != NULL) {
  142                 lpr = pr->pr_linux;
  143                 if (lpr->pr_osname[0])
  144                         return (lpr->pr_osname);
  145         }
  146 
  147         return (linux_osname);
  148 }
  149 
  150 int
  151 linux_set_osname(p, osname)
  152         struct proc *p;
  153         char *osname;
  154 {
  155         register struct linux_prison *lpr;
  156 
  157         lpr = get_prison(p);
  158         if (lpr != NULL)
  159                 strcpy(lpr->pr_osname, osname);
  160         else
  161                 strcpy(linux_osname, osname);
  162 
  163         return (0);
  164 }
  165 
  166 char *
  167 linux_get_osrelease(p)
  168         struct proc *p;
  169 {
  170         register struct prison *pr;
  171         register struct linux_prison *lpr;
  172 
  173         pr = p->p_prison;
  174         if (pr != NULL && pr->pr_linux != NULL) {
  175                 lpr = pr->pr_linux;
  176                 if (lpr->pr_osrelease[0])
  177                         return (lpr->pr_osrelease);
  178         }
  179 
  180         return (linux_osrelease);
  181 }
  182 
  183 int
  184 linux_set_osrelease(p, osrelease)
  185         struct proc *p;
  186         char *osrelease;
  187 {
  188         register struct linux_prison *lpr;
  189 
  190         lpr = get_prison(p);
  191         if (lpr != NULL)
  192                 strcpy(lpr->pr_osrelease, osrelease);
  193         else
  194                 strcpy(linux_osrelease, osrelease);
  195 
  196         return (0);
  197 }
  198 
  199 int
  200 linux_get_oss_version(p)
  201         struct proc *p;
  202 {
  203         register struct prison *pr;
  204         register struct linux_prison *lpr;
  205 
  206         pr = p->p_prison;
  207         if (pr != NULL && pr->pr_linux != NULL) {
  208                 lpr = pr->pr_linux;
  209                 if (lpr->pr_oss_version)
  210                         return (lpr->pr_oss_version);
  211         }
  212 
  213         return (linux_oss_version);
  214 }
  215 
  216 int
  217 linux_set_oss_version(p, oss_version)
  218         struct proc *p;
  219         int oss_version;
  220 {
  221         register struct linux_prison *lpr;
  222 
  223         lpr = get_prison(p);
  224         if (lpr != NULL)
  225                 lpr->pr_oss_version = oss_version;
  226         else
  227                 linux_oss_version = oss_version;
  228 
  229         return (0);
  230 }
  231 
  232 #ifdef DEBUG
  233 
  234 u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
  235 
  236 static int
  237 linux_debug(int syscall, int toggle, int global)
  238 {
  239 
  240         if (global) {
  241                 char c = toggle ? 0 : 0xff;
  242 
  243                 memset(linux_debug_map, c, sizeof(linux_debug_map));
  244                 return (0);
  245         }
  246         if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
  247                 return (EINVAL);
  248         if (toggle)
  249                 clrbit(linux_debug_map, syscall);
  250         else
  251                 setbit(linux_debug_map, syscall);
  252         return (0);
  253 }
  254 
  255 /*
  256  * Usage: sysctl -w linux.debug=<syscall_nr>.<0/1>
  257  *
  258  *    E.g.: sysctl -w linux.debug=21.0
  259  *
  260  * As a special case, syscall "all" will apply to all syscalls globally.
  261  */
  262 #define LINUX_MAX_DEBUGSTR      16
  263 static int
  264 linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
  265 {
  266         char value[LINUX_MAX_DEBUGSTR], *p;
  267         int error, sysc, toggle;
  268         int global = 0;
  269 
  270         value[0] = '\0';
  271         error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
  272         if (error || req->newptr == NULL)
  273                 return (error);
  274         for (p = value; *p != '\0' && *p != '.'; p++);
  275         if (*p == '\0')
  276                 return (EINVAL);
  277         *p++ = '\0';
  278         sysc = strtol(value, NULL, 0);
  279         toggle = strtol(p, NULL, 0);
  280         if (strcmp(value, "all") == 0)
  281                 global = 1;
  282         error = linux_debug(sysc, toggle, global);
  283         return (error);
  284 }
  285 
  286 SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
  287             CTLTYPE_STRING | CTLFLAG_RW,
  288             0, 0, linux_sysctl_debug, "A",
  289             "Linux debugging control");
  290 
  291 #endif /* DEBUG */

Cache object: c83b178617c5296e7a0c4440b3c16592

[ 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