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: src/sys/compat/linux/linux_mib.c,v 1.7.2.2 2001/11/05 19:08:22 marcel Exp $
   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 <arch_linux/linux.h>
   40 #include "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->td));
   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->td, 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.6.16";
   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->td));
   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->td, 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->td);
  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->td, 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 thread *td)
  116 {
  117         struct prison *pr;
  118         struct linux_prison *lpr;
  119 
  120         KKASSERT(td->td_proc);
  121         pr = td->td_proc->p_ucred->cr_prison;
  122         if (pr == NULL)
  123                 return (NULL);
  124 
  125         if (pr->pr_linux == NULL) {
  126                 lpr = kmalloc(sizeof *lpr, 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(struct thread *td)
  135 {
  136         struct prison *pr;
  137         struct linux_prison *lpr;
  138 
  139         KKASSERT(td->td_proc);
  140         pr = td->td_proc->p_ucred->cr_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(struct thread *td, char *osname)
  152 {
  153         struct linux_prison *lpr;
  154 
  155         KKASSERT(td->td_proc);
  156         lpr = get_prison(td);
  157         if (lpr != NULL)
  158                 strcpy(lpr->pr_osname, osname);
  159         else
  160                 strcpy(linux_osname, osname);
  161 
  162         return (0);
  163 }
  164 
  165 char *
  166 linux_get_osrelease(struct thread *td)
  167 {
  168         struct prison *pr;
  169         struct linux_prison *lpr;
  170 
  171         KKASSERT(td->td_proc);
  172         pr = td->td_proc->p_ucred->cr_prison;
  173         if (pr != NULL && pr->pr_linux != NULL) {
  174                 lpr = pr->pr_linux;
  175                 if (lpr->pr_osrelease[0])
  176                         return (lpr->pr_osrelease);
  177         }
  178 
  179         return (linux_osrelease);
  180 }
  181 
  182 int
  183 linux_set_osrelease(struct thread *td, char *osrelease)
  184 {
  185         struct linux_prison *lpr;
  186 
  187         lpr = get_prison(td);
  188         if (lpr != NULL)
  189                 strcpy(lpr->pr_osrelease, osrelease);
  190         else
  191                 strcpy(linux_osrelease, osrelease);
  192 
  193         return (0);
  194 }
  195 
  196 int
  197 linux_get_oss_version(struct thread *td)
  198 {
  199         struct prison *pr;
  200         struct linux_prison *lpr;
  201 
  202         KKASSERT(td->td_proc);
  203         pr = td->td_proc->p_ucred->cr_prison;
  204         if (pr != NULL && pr->pr_linux != NULL) {
  205                 lpr = pr->pr_linux;
  206                 if (lpr->pr_oss_version)
  207                         return (lpr->pr_oss_version);
  208         }
  209 
  210         return (linux_oss_version);
  211 }
  212 
  213 int
  214 linux_set_oss_version(struct thread *td, int oss_version)
  215 {
  216         struct linux_prison *lpr;
  217 
  218         lpr = get_prison(td);
  219         if (lpr != NULL)
  220                 lpr->pr_oss_version = oss_version;
  221         else
  222                 linux_oss_version = oss_version;
  223 
  224         return (0);
  225 }
  226 
  227 #ifdef DEBUG
  228 
  229 u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
  230 
  231 static int
  232 linux_debug(int syscall, int toggle, int global)
  233 {
  234 
  235         if (global) {
  236                 char c = toggle ? 0 : 0xff;
  237 
  238                 memset(linux_debug_map, c, sizeof(linux_debug_map));
  239                 return (0);
  240         }
  241         if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
  242                 return (EINVAL);
  243         if (toggle)
  244                 clrbit(linux_debug_map, syscall);
  245         else
  246                 setbit(linux_debug_map, syscall);
  247         return (0);
  248 }
  249 
  250 /*
  251  * Usage: sysctl -w linux.debug=<syscall_nr>.<0/1>
  252  *
  253  *    E.g.: sysctl -w linux.debug=21.0
  254  *
  255  * As a special case, syscall "all" will apply to all syscalls globally.
  256  */
  257 #define LINUX_MAX_DEBUGSTR      16
  258 static int
  259 linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
  260 {
  261         char value[LINUX_MAX_DEBUGSTR], *p;
  262         int error, sysc, toggle;
  263         int global = 0;
  264 
  265         value[0] = '\0';
  266         error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
  267         if (error || req->newptr == NULL)
  268                 return (error);
  269         for (p = value; *p != '\0' && *p != '.'; p++);
  270         if (*p == '\0')
  271                 return (EINVAL);
  272         *p++ = '\0';
  273         sysc = strtol(value, NULL, 0);
  274         toggle = strtol(p, NULL, 0);
  275         if (strcmp(value, "all") == 0)
  276                 global = 1;
  277         error = linux_debug(sysc, toggle, global);
  278         return (error);
  279 }
  280 
  281 SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
  282             CTLTYPE_STRING | CTLFLAG_RW,
  283             0, 0, linux_sysctl_debug, "A",
  284             "Linux debugging control");
  285 
  286 #endif /* DEBUG */

Cache object: ad8062d81d31b364b0bd7bfad22dab1d

[ 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/emulation/linux/linux_mib.c

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