The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/compat/linux/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$");
   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/mount.h>
   39 #include <sys/jail.h>
   40 #include <sys/lock.h>
   41 #include <sys/mutex.h>
   42 #include <sys/sx.h>
   43 
   44 #include "opt_compat.h"
   45 
   46 #ifdef COMPAT_LINUX32
   47 #include <machine/../linux32/linux.h>
   48 #else
   49 #include <machine/../linux/linux.h>
   50 #endif
   51 #include <compat/linux/linux_mib.h>
   52 
   53 struct linux_prison {
   54         char    pr_osname[LINUX_MAX_UTSNAME];
   55         char    pr_osrelease[LINUX_MAX_UTSNAME];
   56         int     pr_oss_version;
   57         int     pr_osrel;
   58 };
   59 
   60 static struct linux_prison lprison0 = {
   61         .pr_osname =            "Linux",
   62         .pr_osrelease =         "2.6.16",
   63         .pr_oss_version =       0x030600,
   64         .pr_osrel =             2006016
   65 };
   66 
   67 static unsigned linux_osd_jail_slot;
   68 
   69 SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
   70             "Linux mode");
   71 
   72 static int
   73 linux_sysctl_osname(SYSCTL_HANDLER_ARGS)
   74 {
   75         char osname[LINUX_MAX_UTSNAME];
   76         int error;
   77 
   78         linux_get_osname(req->td, osname);
   79         error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
   80         if (error || req->newptr == NULL)
   81                 return (error);
   82         error = linux_set_osname(req->td, osname);
   83         return (error);
   84 }
   85 
   86 SYSCTL_PROC(_compat_linux, OID_AUTO, osname,
   87             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
   88             0, 0, linux_sysctl_osname, "A",
   89             "Linux kernel OS name");
   90 
   91 static int
   92 linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS)
   93 {
   94         char osrelease[LINUX_MAX_UTSNAME];
   95         int error;
   96 
   97         linux_get_osrelease(req->td, osrelease);
   98         error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
   99         if (error || req->newptr == NULL)
  100                 return (error);
  101         error = linux_set_osrelease(req->td, osrelease);
  102         return (error);
  103 }
  104 
  105 SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease,
  106             CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
  107             0, 0, linux_sysctl_osrelease, "A",
  108             "Linux kernel OS release");
  109 
  110 static int
  111 linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS)
  112 {
  113         int oss_version;
  114         int error;
  115 
  116         oss_version = linux_get_oss_version(req->td);
  117         error = sysctl_handle_int(oidp, &oss_version, 0, req);
  118         if (error || req->newptr == NULL)
  119                 return (error);
  120         error = linux_set_oss_version(req->td, oss_version);
  121         return (error);
  122 }
  123 
  124 SYSCTL_PROC(_compat_linux, OID_AUTO, oss_version,
  125             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
  126             0, 0, linux_sysctl_oss_version, "I",
  127             "Linux OSS version");
  128 
  129 /*
  130  * Map the osrelease into integer
  131  */
  132 static int
  133 linux_map_osrel(char *osrelease, int *osrel)
  134 {
  135         char *sep, *eosrelease;
  136         int len, v0, v1, v2, v;
  137 
  138         len = strlen(osrelease);
  139         eosrelease = osrelease + len;
  140         v0 = strtol(osrelease, &sep, 10);
  141         if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.')
  142                 return (EINVAL);
  143         osrelease = sep + 1;
  144         v1 = strtol(osrelease, &sep, 10);
  145         if (osrelease == sep || sep + 1 >= eosrelease || *sep != '.')
  146                 return (EINVAL);
  147         osrelease = sep + 1;
  148         v2 = strtol(osrelease, &sep, 10);
  149         if (osrelease == sep || sep != eosrelease)
  150                 return (EINVAL);
  151 
  152         v = v0 * 1000000 + v1 * 1000 + v2;
  153         if (v < 1000000)
  154                 return (EINVAL);
  155 
  156         *osrel = v;
  157         return (0);
  158 }
  159 
  160 /*
  161  * Find a prison with Linux info.
  162  * Return the Linux info and the (locked) prison.
  163  */
  164 static struct linux_prison *
  165 linux_find_prison(struct prison *spr, struct prison **prp)
  166 {
  167         struct prison *pr;
  168         struct linux_prison *lpr;
  169 
  170         if (!linux_osd_jail_slot)
  171                 /* In case osd_register failed. */
  172                 spr = &prison0;
  173         for (pr = spr;; pr = pr->pr_parent) {
  174                 mtx_lock(&pr->pr_mtx);
  175                 lpr = (pr == &prison0)
  176                     ? &lprison0
  177                     : osd_jail_get(pr, linux_osd_jail_slot);
  178                 if (lpr != NULL)
  179                         break;
  180                 mtx_unlock(&pr->pr_mtx);
  181         }
  182         *prp = pr;
  183         return (lpr);
  184 }
  185 
  186 /*
  187  * Ensure a prison has its own Linux info.  If lprp is non-null, point it to
  188  * the Linux info and lock the prison.
  189  */
  190 static int
  191 linux_alloc_prison(struct prison *pr, struct linux_prison **lprp)
  192 {
  193         struct prison *ppr;
  194         struct linux_prison *lpr, *nlpr;
  195         int error;
  196 
  197         /* If this prison already has Linux info, return that. */
  198         error = 0;
  199         lpr = linux_find_prison(pr, &ppr);
  200         if (ppr == pr)
  201                 goto done;
  202         /*
  203          * Allocate a new info record.  Then check again, in case something
  204          * changed during the allocation.
  205          */
  206         mtx_unlock(&ppr->pr_mtx);
  207         nlpr = malloc(sizeof(struct linux_prison), M_PRISON, M_WAITOK);
  208         lpr = linux_find_prison(pr, &ppr);
  209         if (ppr == pr) {
  210                 free(nlpr, M_PRISON);
  211                 goto done;
  212         }
  213         /* Inherit the initial values from the ancestor. */
  214         mtx_lock(&pr->pr_mtx);
  215         error = osd_jail_set(pr, linux_osd_jail_slot, nlpr);
  216         if (error == 0) {
  217                 bcopy(lpr, nlpr, sizeof(*lpr));
  218                 lpr = nlpr;
  219         } else {
  220                 free(nlpr, M_PRISON);
  221                 lpr = NULL;
  222         }
  223         mtx_unlock(&ppr->pr_mtx);
  224  done:
  225         if (lprp != NULL)
  226                 *lprp = lpr;
  227         else
  228                 mtx_unlock(&pr->pr_mtx);
  229         return (error);
  230 }
  231 
  232 /*
  233  * Jail OSD methods for Linux prison data.
  234  */
  235 static int
  236 linux_prison_create(void *obj, void *data)
  237 {
  238         struct prison *pr = obj;
  239         struct vfsoptlist *opts = data;
  240         int jsys;
  241 
  242         if (vfs_copyopt(opts, "linux", &jsys, sizeof(jsys)) == 0 &&
  243             jsys == JAIL_SYS_INHERIT)
  244                 return (0);
  245         /*
  246          * Inherit a prison's initial values from its parent
  247          * (different from JAIL_SYS_INHERIT which also inherits changes).
  248          */
  249         return linux_alloc_prison(pr, NULL);
  250 }
  251 
  252 static int
  253 linux_prison_check(void *obj __unused, void *data)
  254 {
  255         struct vfsoptlist *opts = data;
  256         char *osname, *osrelease;
  257         int error, jsys, len, osrel, oss_version;
  258 
  259         /* Check that the parameters are correct. */
  260         error = vfs_copyopt(opts, "linux", &jsys, sizeof(jsys));
  261         if (error != ENOENT) {
  262                 if (error != 0)
  263                         return (error);
  264                 if (jsys != JAIL_SYS_NEW && jsys != JAIL_SYS_INHERIT)
  265                         return (EINVAL);
  266         }
  267         error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
  268         if (error != ENOENT) {
  269                 if (error != 0)
  270                         return (error);
  271                 if (len == 0 || osname[len - 1] != '\0')
  272                         return (EINVAL);
  273                 if (len > LINUX_MAX_UTSNAME) {
  274                         vfs_opterror(opts, "linux.osname too long");
  275                         return (ENAMETOOLONG);
  276                 }
  277         }
  278         error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
  279         if (error != ENOENT) {
  280                 if (error != 0)
  281                         return (error);
  282                 if (len == 0 || osrelease[len - 1] != '\0')
  283                         return (EINVAL);
  284                 if (len > LINUX_MAX_UTSNAME) {
  285                         vfs_opterror(opts, "linux.osrelease too long");
  286                         return (ENAMETOOLONG);
  287                 }
  288                 error = linux_map_osrel(osrelease, &osrel);
  289                 if (error != 0) {
  290                         vfs_opterror(opts, "linux.osrelease format error");
  291                         return (error);
  292                 }
  293         }
  294         error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
  295             sizeof(oss_version));
  296         return (error == ENOENT ? 0 : error);
  297 }
  298 
  299 static int
  300 linux_prison_set(void *obj, void *data)
  301 {
  302         struct linux_prison *lpr;
  303         struct prison *pr = obj;
  304         struct vfsoptlist *opts = data;
  305         char *osname, *osrelease;
  306         int error, gotversion, jsys, len, oss_version;
  307 
  308         /* Set the parameters, which should be correct. */
  309         error = vfs_copyopt(opts, "linux", &jsys, sizeof(jsys));
  310         if (error == ENOENT)
  311                 jsys = -1;
  312         error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
  313         if (error == ENOENT)
  314                 osname = NULL;
  315         else
  316                 jsys = JAIL_SYS_NEW;
  317         error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
  318         if (error == ENOENT)
  319                 osrelease = NULL;
  320         else
  321                 jsys = JAIL_SYS_NEW;
  322         error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
  323             sizeof(oss_version));
  324         if (error == ENOENT)
  325                 gotversion = 0;
  326         else {
  327                 gotversion = 1;
  328                 jsys = JAIL_SYS_NEW;
  329         }
  330         switch (jsys) {
  331         case JAIL_SYS_INHERIT:
  332                 /* "linux=inherit": inherit the parent's Linux info. */
  333                 mtx_lock(&pr->pr_mtx);
  334                 osd_jail_del(pr, linux_osd_jail_slot);
  335                 mtx_unlock(&pr->pr_mtx);
  336                 break;
  337         case JAIL_SYS_NEW:
  338                 /*
  339                  * "linux=new" or "linux.*":
  340                  * the prison gets its own Linux info.
  341                  */
  342                 error = linux_alloc_prison(pr, &lpr);
  343                 if (error) {
  344                         mtx_unlock(&pr->pr_mtx);
  345                         return (error);
  346                 }
  347                 if (osrelease) {
  348                         error = linux_map_osrel(osrelease, &lpr->pr_osrel);
  349                         if (error) {
  350                                 mtx_unlock(&pr->pr_mtx);
  351                                 return (error);
  352                         }
  353                         strlcpy(lpr->pr_osrelease, osrelease,
  354                             LINUX_MAX_UTSNAME);
  355                 }
  356                 if (osname)
  357                         strlcpy(lpr->pr_osname, osname, LINUX_MAX_UTSNAME);
  358                 if (gotversion)
  359                         lpr->pr_oss_version = oss_version;
  360                 mtx_unlock(&pr->pr_mtx);
  361         }
  362         return (0);
  363 }
  364 
  365 SYSCTL_JAIL_PARAM_SYS_NODE(linux, CTLFLAG_RW, "Jail Linux parameters");
  366 SYSCTL_JAIL_PARAM_STRING(_linux, osname, CTLFLAG_RW, LINUX_MAX_UTSNAME,
  367     "Jail Linux kernel OS name");
  368 SYSCTL_JAIL_PARAM_STRING(_linux, osrelease, CTLFLAG_RW, LINUX_MAX_UTSNAME,
  369     "Jail Linux kernel OS release");
  370 SYSCTL_JAIL_PARAM(_linux, oss_version, CTLTYPE_INT | CTLFLAG_RW,
  371     "I", "Jail Linux OSS version");
  372 
  373 static int
  374 linux_prison_get(void *obj, void *data)
  375 {
  376         struct linux_prison *lpr;
  377         struct prison *ppr;
  378         struct prison *pr = obj;
  379         struct vfsoptlist *opts = data;
  380         int error, i;
  381 
  382         static int version0;
  383 
  384         /* See if this prison is the one with the Linux info. */
  385         lpr = linux_find_prison(pr, &ppr);
  386         i = (ppr == pr) ? JAIL_SYS_NEW : JAIL_SYS_INHERIT;
  387         error = vfs_setopt(opts, "linux", &i, sizeof(i));
  388         if (error != 0 && error != ENOENT)
  389                 goto done;
  390         if (i) {
  391                 error = vfs_setopts(opts, "linux.osname", lpr->pr_osname);
  392                 if (error != 0 && error != ENOENT)
  393                         goto done;
  394                 error = vfs_setopts(opts, "linux.osrelease", lpr->pr_osrelease);
  395                 if (error != 0 && error != ENOENT)
  396                         goto done;
  397                 error = vfs_setopt(opts, "linux.oss_version",
  398                     &lpr->pr_oss_version, sizeof(lpr->pr_oss_version));
  399                 if (error != 0 && error != ENOENT)
  400                         goto done;
  401         } else {
  402                 /*
  403                  * If this prison is inheriting its Linux info, report
  404                  * empty/zero parameters.
  405                  */
  406                 error = vfs_setopts(opts, "linux.osname", "");
  407                 if (error != 0 && error != ENOENT)
  408                         goto done;
  409                 error = vfs_setopts(opts, "linux.osrelease", "");
  410                 if (error != 0 && error != ENOENT)
  411                         goto done;
  412                 error = vfs_setopt(opts, "linux.oss_version", &version0,
  413                     sizeof(lpr->pr_oss_version));
  414                 if (error != 0 && error != ENOENT)
  415                         goto done;
  416         }
  417         error = 0;
  418 
  419  done:
  420         mtx_unlock(&ppr->pr_mtx);
  421         return (error);
  422 }
  423 
  424 static void
  425 linux_prison_destructor(void *data)
  426 {
  427 
  428         free(data, M_PRISON);
  429 }
  430 
  431 void
  432 linux_osd_jail_register(void)
  433 {
  434         struct prison *pr;
  435         osd_method_t methods[PR_MAXMETHOD] = {
  436             [PR_METHOD_CREATE] =        linux_prison_create,
  437             [PR_METHOD_GET] =           linux_prison_get,
  438             [PR_METHOD_SET] =           linux_prison_set,
  439             [PR_METHOD_CHECK] =         linux_prison_check
  440         };
  441 
  442         linux_osd_jail_slot =
  443             osd_jail_register(linux_prison_destructor, methods);
  444         if (linux_osd_jail_slot > 0) {
  445                 /* Copy the system linux info to any current prisons. */
  446                 sx_xlock(&allprison_lock);
  447                 TAILQ_FOREACH(pr, &allprison, pr_list)
  448                         (void)linux_alloc_prison(pr, NULL);
  449                 sx_xunlock(&allprison_lock);
  450         }
  451 }
  452 
  453 void
  454 linux_osd_jail_deregister(void)
  455 {
  456 
  457         if (linux_osd_jail_slot)
  458                 osd_jail_deregister(linux_osd_jail_slot);
  459 }
  460 
  461 void
  462 linux_get_osname(struct thread *td, char *dst)
  463 {
  464         struct prison *pr;
  465         struct linux_prison *lpr;
  466 
  467         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  468         bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME);
  469         mtx_unlock(&pr->pr_mtx);
  470 }
  471 
  472 int
  473 linux_set_osname(struct thread *td, char *osname)
  474 {
  475         struct prison *pr;
  476         struct linux_prison *lpr;
  477 
  478         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  479         strlcpy(lpr->pr_osname, osname, LINUX_MAX_UTSNAME);
  480         mtx_unlock(&pr->pr_mtx);
  481         return (0);
  482 }
  483 
  484 void
  485 linux_get_osrelease(struct thread *td, char *dst)
  486 {
  487         struct prison *pr;
  488         struct linux_prison *lpr;
  489 
  490         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  491         bcopy(lpr->pr_osrelease, dst, LINUX_MAX_UTSNAME);
  492         mtx_unlock(&pr->pr_mtx);
  493 }
  494 
  495 int
  496 linux_kernver(struct thread *td)
  497 {
  498         struct prison *pr;
  499         struct linux_prison *lpr;
  500         int osrel;
  501 
  502         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  503         osrel = lpr->pr_osrel;
  504         mtx_unlock(&pr->pr_mtx);
  505         return (osrel);
  506 }
  507 
  508 int
  509 linux_set_osrelease(struct thread *td, char *osrelease)
  510 {
  511         struct prison *pr;
  512         struct linux_prison *lpr;
  513         int error;
  514 
  515         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  516         error = linux_map_osrel(osrelease, &lpr->pr_osrel);
  517         if (error == 0)
  518                 strlcpy(lpr->pr_osrelease, osrelease, LINUX_MAX_UTSNAME);
  519         mtx_unlock(&pr->pr_mtx);
  520         return (error);
  521 }
  522 
  523 int
  524 linux_get_oss_version(struct thread *td)
  525 {
  526         struct prison *pr;
  527         struct linux_prison *lpr;
  528         int version;
  529 
  530         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  531         version = lpr->pr_oss_version;
  532         mtx_unlock(&pr->pr_mtx);
  533         return (version);
  534 }
  535 
  536 int
  537 linux_set_oss_version(struct thread *td, int oss_version)
  538 {
  539         struct prison *pr;
  540         struct linux_prison *lpr;
  541 
  542         lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
  543         lpr->pr_oss_version = oss_version;
  544         mtx_unlock(&pr->pr_mtx);
  545         return (0);
  546 }
  547 
  548 #if defined(DEBUG) || defined(KTR)
  549 
  550 u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
  551 
  552 static int
  553 linux_debug(int syscall, int toggle, int global)
  554 {
  555 
  556         if (global) {
  557                 char c = toggle ? 0 : 0xff;
  558 
  559                 memset(linux_debug_map, c, sizeof(linux_debug_map));
  560                 return (0);
  561         }
  562         if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL)
  563                 return (EINVAL);
  564         if (toggle)
  565                 clrbit(linux_debug_map, syscall);
  566         else
  567                 setbit(linux_debug_map, syscall);
  568         return (0);
  569 }
  570 
  571 /*
  572  * Usage: sysctl linux.debug=<syscall_nr>.<0/1>
  573  *
  574  *    E.g.: sysctl linux.debug=21.0
  575  *
  576  * As a special case, syscall "all" will apply to all syscalls globally.
  577  */
  578 #define LINUX_MAX_DEBUGSTR      16
  579 static int
  580 linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
  581 {
  582         char value[LINUX_MAX_DEBUGSTR], *p;
  583         int error, sysc, toggle;
  584         int global = 0;
  585 
  586         value[0] = '\0';
  587         error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
  588         if (error || req->newptr == NULL)
  589                 return (error);
  590         for (p = value; *p != '\0' && *p != '.'; p++);
  591         if (*p == '\0')
  592                 return (EINVAL);
  593         *p++ = '\0';
  594         sysc = strtol(value, NULL, 0);
  595         toggle = strtol(p, NULL, 0);
  596         if (strcmp(value, "all") == 0)
  597                 global = 1;
  598         error = linux_debug(sysc, toggle, global);
  599         return (error);
  600 }
  601 
  602 SYSCTL_PROC(_compat_linux, OID_AUTO, debug,
  603             CTLTYPE_STRING | CTLFLAG_RW,
  604             0, 0, linux_sysctl_debug, "A",
  605             "Linux debugging control");
  606 
  607 #endif /* DEBUG || KTR */

Cache object: 3bece9897d4a50a6f28395aaee02828e


[ 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.