audit.h

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  * SPDX-License-Identifier: BSD-3-Clause
    3  *
    4  * Copyright (c) 1999-2005 Apple Inc.
    5  * Copyright (c) 2016-2018 Robert N. M. Watson
    6  * All rights reserved.
    7  *
    8  * This software was developed by BAE Systems, the University of Cambridge
    9  * Computer Laboratory, and Memorial University under DARPA/AFRL contract
   10  * FA8650-15-C-7558 ("CADETS"), as part of the DARPA Transparent Computing
   11  * (TC) research program.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1.  Redistributions of source code must retain the above copyright
   17  *     notice, this list of conditions and the following disclaimer.
   18  * 2.  Redistributions in binary form must reproduce the above copyright
   19  *     notice, this list of conditions and the following disclaimer in the
   20  *     documentation and/or other materials provided with the distribution.
   21  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
   22  *     its contributors may be used to endorse or promote products derived
   23  *     from this software without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
   29  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   33  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
   34  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   35  * POSSIBILITY OF SUCH DAMAGE.
   36  *
   37  * $FreeBSD$
   38  */
   39 
   40 /*
   41  * This header includes function prototypes and type definitions that are
   42  * necessary for the kernel as a whole to interact with the audit subsystem.
   43  */
   44 
   45 #ifndef _SECURITY_AUDIT_KERNEL_H_
   46 #define _SECURITY_AUDIT_KERNEL_H_
   47 
   48 #ifndef _KERNEL
   49 #error "no user-serviceable parts inside"
   50 #endif
   51 
   52 #include <bsm/audit.h>
   53 
   54 #include <sys/file.h>
   55 #include <sys/sysctl.h>
   56 
   57 /*
   58  * Audit subsystem condition flags.  The audit_trail_enabled flag is set and
   59  * removed automatically as a result of configuring log files, and can be
   60  * observed but should not be directly manipulated.  The audit suspension
   61  * flag permits audit to be temporarily disabled without reconfiguring the
   62  * audit target.
   63  *
   64  * As DTrace can also request system-call auditing, a further
   65  * audit_syscalls_enabled flag tracks whether newly entering system calls
   66  * should be considered for auditing or not.
   67  *
   68  * XXXRW: Move trail flags to audit_private.h, as they no longer need to be
   69  * visible outside the audit code...?
   70  */
   71 extern u_int    audit_dtrace_enabled;
   72 extern int      audit_trail_enabled;
   73 extern int      audit_trail_suspended;
   74 extern bool     audit_syscalls_enabled;
   75 
   76 void     audit_syscall_enter(unsigned short code, struct thread *td);
   77 void     audit_syscall_exit(int error, struct thread *td);
   78 
   79 /*
   80  * The remaining kernel functions are conditionally compiled in as they are
   81  * wrapped by a macro, and the macro should be the only place in the source
   82  * tree where these functions are referenced.
   83  */
   84 #ifdef AUDIT
   85 struct ipc_perm;
   86 struct sockaddr;
   87 union auditon_udata;
   88 void     audit_arg_addr(void * addr);
   89 void     audit_arg_exit(int status, int retval);
   90 void     audit_arg_len(int len);
   91 void     audit_arg_atfd1(int atfd);
   92 void     audit_arg_atfd2(int atfd);
   93 void     audit_arg_fd(int fd);
   94 void     audit_arg_fflags(int fflags);
   95 void     audit_arg_gid(gid_t gid);
   96 void     audit_arg_uid(uid_t uid);
   97 void     audit_arg_egid(gid_t egid);
   98 void     audit_arg_euid(uid_t euid);
   99 void     audit_arg_rgid(gid_t rgid);
  100 void     audit_arg_ruid(uid_t ruid);
  101 void     audit_arg_sgid(gid_t sgid);
  102 void     audit_arg_suid(uid_t suid);
  103 void     audit_arg_groupset(gid_t *gidset, u_int gidset_size);
  104 void     audit_arg_login(char *login);
  105 void     audit_arg_ctlname(int *name, int namelen);
  106 void     audit_arg_mask(int mask);
  107 void     audit_arg_mode(mode_t mode);
  108 void     audit_arg_dev(int dev);
  109 void     audit_arg_value(long value);
  110 void     audit_arg_owner(uid_t uid, gid_t gid);
  111 void     audit_arg_pid(pid_t pid);
  112 void     audit_arg_process(struct proc *p);
  113 void     audit_arg_signum(u_int signum);
  114 void     audit_arg_socket(int sodomain, int sotype, int soprotocol);
  115 void     audit_arg_sockaddr(struct thread *td, int dirfd, struct sockaddr *sa);
  116 void     audit_arg_auid(uid_t auid);
  117 void     audit_arg_auditinfo(struct auditinfo *au_info);
  118 void     audit_arg_auditinfo_addr(struct auditinfo_addr *au_info);
  119 void     audit_arg_upath1(struct thread *td, int dirfd, char *upath);
  120 void     audit_arg_upath1_canon(char *upath);
  121 void     audit_arg_upath2(struct thread *td, int dirfd, char *upath);
  122 void     audit_arg_upath2_canon(char *upath);
  123 void     audit_arg_upath1_vp(struct thread *td, struct vnode *rdir,
  124             struct vnode *cdir, char *upath);
  125 void     audit_arg_upath2_vp(struct thread *td, struct vnode *rdir,
  126             struct vnode *cdir, char *upath);
  127 void     audit_arg_vnode1(struct vnode *vp);
  128 void     audit_arg_vnode2(struct vnode *vp);
  129 void     audit_arg_text(const char *text);
  130 void     audit_arg_cmd(int cmd);
  131 void     audit_arg_svipc_cmd(int cmd);
  132 void     audit_arg_svipc_perm(struct ipc_perm *perm);
  133 void     audit_arg_svipc_id(int id);
  134 void     audit_arg_svipc_addr(void *addr);
  135 void     audit_arg_svipc_which(int which);
  136 void     audit_arg_posix_ipc_perm(uid_t uid, gid_t gid, mode_t mode);
  137 void     audit_arg_auditon(union auditon_udata *udata);
  138 void     audit_arg_file(struct proc *p, struct file *fp);
  139 void     audit_arg_argv(char *argv, int argc, int length);
  140 void     audit_arg_envv(char *envv, int envc, int length);
  141 void     audit_arg_rights(cap_rights_t *rightsp);
  142 void     audit_arg_fcntl_rights(uint32_t fcntlrights);
  143 void     audit_sysclose(struct thread *td, int fd, struct file *fp);
  144 void     audit_cred_copy(struct ucred *src, struct ucred *dest);
  145 void     audit_cred_destroy(struct ucred *cred);
  146 void     audit_cred_init(struct ucred *cred);
  147 void     audit_cred_kproc0(struct ucred *cred);
  148 void     audit_cred_proc1(struct ucred *cred);
  149 void     audit_proc_coredump(struct thread *td, char *path, int errcode);
  150 void     audit_thread_alloc(struct thread *td);
  151 void     audit_thread_free(struct thread *td);
  152 
  153 /*
  154  * Define macros to wrap the audit_arg_* calls by checking the global
  155  * audit_syscalls_enabled flag before performing the actual call.
  156  */
  157 #define AUDITING_TD(td)         (__predict_false((td)->td_pflags & TDP_AUDITREC))
  158 
  159 #define AUDIT_ARG_ADDR(addr) do {                                       \
  160         if (AUDITING_TD(curthread))                                     \
  161                 audit_arg_addr((addr));                                 \
  162 } while (0)
  163 
  164 #define AUDIT_ARG_ARGV(argv, argc, length) do {                         \
  165         if (AUDITING_TD(curthread))                                     \
  166                 audit_arg_argv((argv), (argc), (length));               \
  167 } while (0)
  168 
  169 #define AUDIT_ARG_ATFD1(atfd) do {                                      \
  170         if (AUDITING_TD(curthread))                                     \
  171                 audit_arg_atfd1((atfd));                                \
  172 } while (0)
  173 
  174 #define AUDIT_ARG_ATFD2(atfd) do {                                      \
  175         if (AUDITING_TD(curthread))                                     \
  176                 audit_arg_atfd2((atfd));                                \
  177 } while (0)
  178 
  179 #define AUDIT_ARG_AUDITON(udata) do {                                   \
  180         if (AUDITING_TD(curthread))                                     \
  181                 audit_arg_auditon((udata));                             \
  182 } while (0)
  183 
  184 #define AUDIT_ARG_CMD(cmd) do {                                         \
  185         if (AUDITING_TD(curthread))                                     \
  186                 audit_arg_cmd((cmd));                                   \
  187 } while (0)
  188 
  189 #define AUDIT_ARG_DEV(dev) do {                                         \
  190         if (AUDITING_TD(curthread))                                     \
  191                 audit_arg_dev((dev));                                   \
  192 } while (0)
  193 
  194 #define AUDIT_ARG_EGID(egid) do {                                       \
  195         if (AUDITING_TD(curthread))                                     \
  196                 audit_arg_egid((egid));                                 \
  197 } while (0)
  198 
  199 #define AUDIT_ARG_ENVV(envv, envc, length) do {                         \
  200         if (AUDITING_TD(curthread))                                     \
  201                 audit_arg_envv((envv), (envc), (length));               \
  202 } while (0)
  203 
  204 #define AUDIT_ARG_EXIT(status, retval) do {                             \
  205         if (AUDITING_TD(curthread))                                     \
  206                 audit_arg_exit((status), (retval));                     \
  207 } while (0)
  208 
  209 #define AUDIT_ARG_EUID(euid) do {                                       \
  210         if (AUDITING_TD(curthread))                                     \
  211                 audit_arg_euid((euid));                                 \
  212 } while (0)
  213 
  214 #define AUDIT_ARG_FD(fd) do {                                           \
  215         if (AUDITING_TD(curthread))                                     \
  216                 audit_arg_fd((fd));                                     \
  217 } while (0)
  218 
  219 #define AUDIT_ARG_FILE(p, fp) do {                                      \
  220         if (AUDITING_TD(curthread))                                     \
  221                 audit_arg_file((p), (fp));                              \
  222 } while (0)
  223 
  224 #define AUDIT_ARG_FFLAGS(fflags) do {                                   \
  225         if (AUDITING_TD(curthread))                                     \
  226                 audit_arg_fflags((fflags));                             \
  227 } while (0)
  228 
  229 #define AUDIT_ARG_GID(gid) do {                                         \
  230         if (AUDITING_TD(curthread))                                     \
  231                 audit_arg_gid((gid));                                   \
  232 } while (0)
  233 
  234 #define AUDIT_ARG_GROUPSET(gidset, gidset_size) do {                    \
  235         if (AUDITING_TD(curthread))                                     \
  236                 audit_arg_groupset((gidset), (gidset_size));            \
  237 } while (0)
  238 
  239 #define AUDIT_ARG_LOGIN(login) do {                                     \
  240         if (AUDITING_TD(curthread))                                     \
  241                 audit_arg_login((login));                               \
  242 } while (0)
  243 
  244 #define AUDIT_ARG_MODE(mode) do {                                       \
  245         if (AUDITING_TD(curthread))                                     \
  246                 audit_arg_mode((mode));                                 \
  247 } while (0)
  248 
  249 #define AUDIT_ARG_OWNER(uid, gid) do {                                  \
  250         if (AUDITING_TD(curthread))                                     \
  251                 audit_arg_owner((uid), (gid));                          \
  252 } while (0)
  253 
  254 #define AUDIT_ARG_PID(pid) do {                                         \
  255         if (AUDITING_TD(curthread))                                     \
  256                 audit_arg_pid((pid));                                   \
  257 } while (0)
  258 
  259 #define AUDIT_ARG_POSIX_IPC_PERM(uid, gid, mode) do {                   \
  260         if (AUDITING_TD(curthread))                                     \
  261                 audit_arg_posix_ipc_perm((uid), (gid), (mod));          \
  262 } while (0)
  263 
  264 #define AUDIT_ARG_PROCESS(p) do {                                       \
  265         if (AUDITING_TD(curthread))                                     \
  266                 audit_arg_process((p));                                 \
  267 } while (0)
  268 
  269 #define AUDIT_ARG_RGID(rgid) do {                                       \
  270         if (AUDITING_TD(curthread))                                     \
  271                 audit_arg_rgid((rgid));                                 \
  272 } while (0)
  273 
  274 #define AUDIT_ARG_RIGHTS(rights) do {                                   \
  275         if (AUDITING_TD(curthread))                                     \
  276                 audit_arg_rights((rights));                             \
  277 } while (0)
  278 
  279 #define AUDIT_ARG_FCNTL_RIGHTS(fcntlrights) do {                        \
  280         if (AUDITING_TD(curthread))                                     \
  281                 audit_arg_fcntl_rights((fcntlrights));                  \
  282 } while (0)
  283 
  284 #define AUDIT_ARG_RUID(ruid) do {                                       \
  285         if (AUDITING_TD(curthread))                                     \
  286                 audit_arg_ruid((ruid));                                 \
  287 } while (0)
  288 
  289 #define AUDIT_ARG_SIGNUM(signum) do {                                   \
  290         if (AUDITING_TD(curthread))                                     \
  291                 audit_arg_signum((signum));                             \
  292 } while (0)
  293 
  294 #define AUDIT_ARG_SGID(sgid) do {                                       \
  295         if (AUDITING_TD(curthread))                                     \
  296                 audit_arg_sgid((sgid));                                 \
  297 } while (0)
  298 
  299 #define AUDIT_ARG_SOCKET(sodomain, sotype, soprotocol) do {             \
  300         if (AUDITING_TD(curthread))                                     \
  301                 audit_arg_socket((sodomain), (sotype), (soprotocol));   \
  302 } while (0)
  303 
  304 #define AUDIT_ARG_SOCKADDR(td, dirfd, sa) do {                          \
  305         if (AUDITING_TD(curthread))                                     \
  306                 audit_arg_sockaddr((td), (dirfd), (sa));                \
  307 } while (0)
  308 
  309 #define AUDIT_ARG_SUID(suid) do {                                       \
  310         if (AUDITING_TD(curthread))                                     \
  311                 audit_arg_suid((suid));                                 \
  312 } while (0)
  313 
  314 #define AUDIT_ARG_SVIPC_CMD(cmd) do {                                   \
  315         if (AUDITING_TD(curthread))                                     \
  316                 audit_arg_svipc_cmd((cmd));                             \
  317 } while (0)
  318 
  319 #define AUDIT_ARG_SVIPC_PERM(perm) do {                                 \
  320         if (AUDITING_TD(curthread))                                     \
  321                 audit_arg_svipc_perm((perm));                           \
  322 } while (0)
  323 
  324 #define AUDIT_ARG_SVIPC_ID(id) do {                                     \
  325         if (AUDITING_TD(curthread))                                     \
  326                 audit_arg_svipc_id((id));                               \
  327 } while (0)
  328 
  329 #define AUDIT_ARG_SVIPC_ADDR(addr) do {                                 \
  330         if (AUDITING_TD(curthread))                                     \
  331                 audit_arg_svipc_addr((addr));                           \
  332 } while (0)
  333 
  334 #define AUDIT_ARG_SVIPC_WHICH(which) do {                               \
  335         if (AUDITING_TD(curthread))                                     \
  336                 audit_arg_svipc_which((which));                         \
  337 } while (0)
  338 
  339 #define AUDIT_ARG_TEXT(text) do {                                       \
  340         if (AUDITING_TD(curthread))                                     \
  341                 audit_arg_text((text));                                 \
  342 } while (0)
  343 
  344 #define AUDIT_ARG_UID(uid) do {                                         \
  345         if (AUDITING_TD(curthread))                                     \
  346                 audit_arg_uid((uid));                                   \
  347 } while (0)
  348 
  349 #define AUDIT_ARG_UPATH1(td, dirfd, upath) do {                         \
  350         if (AUDITING_TD(curthread))                                     \
  351                 audit_arg_upath1((td), (dirfd), (upath));               \
  352 } while (0)
  353 
  354 #define AUDIT_ARG_UPATH1_CANON(upath) do {                              \
  355         if (AUDITING_TD(curthread))                                     \
  356                 audit_arg_upath1_canon((upath));                        \
  357 } while (0)
  358 
  359 #define AUDIT_ARG_UPATH2(td, dirfd, upath) do {                         \
  360         if (AUDITING_TD(curthread))                                     \
  361                 audit_arg_upath2((td), (dirfd), (upath));               \
  362 } while (0)
  363 
  364 #define AUDIT_ARG_UPATH2_CANON(upath) do {                              \
  365         if (AUDITING_TD(curthread))                                     \
  366                 audit_arg_upath2_canon((upath));                        \
  367 } while (0)
  368 
  369 #define AUDIT_ARG_UPATH1_VP(td, rdir, cdir, upath) do {                 \
  370         if (AUDITING_TD(curthread))                                     \
  371                 audit_arg_upath1_vp((td), (rdir), (cdir), (upath));     \
  372 } while (0)
  373 
  374 #define AUDIT_ARG_UPATH2_VP(td, rdir, cdir, upath) do {                 \
  375         if (AUDITING_TD(curthread))                                     \
  376                 audit_arg_upath2_vp((td), (rdir), (cdir), (upath));     \
  377 } while (0)
  378 
  379 #define AUDIT_ARG_VALUE(value) do {                                     \
  380         if (AUDITING_TD(curthread))                                     \
  381                 audit_arg_value((value));                               \
  382 } while (0)
  383 
  384 #define AUDIT_ARG_VNODE1(vp) do {                                       \
  385         if (AUDITING_TD(curthread))                                     \
  386                 audit_arg_vnode1((vp));                                 \
  387 } while (0)
  388 
  389 #define AUDIT_ARG_VNODE2(vp) do {                                       \
  390         if (AUDITING_TD(curthread))                                     \
  391                 audit_arg_vnode2((vp));                                 \
  392 } while (0)
  393 
  394 #define AUDIT_SYSCALL_ENTER(code, td)   ({                              \
  395         bool _audit_entered = false;                                    \
  396         if (__predict_false(audit_syscalls_enabled)) {                  \
  397                 audit_syscall_enter(code, td);                          \
  398                 _audit_entered = true;                                  \
  399         }                                                               \
  400         _audit_entered;                                                 \
  401 })
  402 
  403 /*
  404  * Wrap the audit_syscall_exit() function so that it is called only when
  405  * we have a audit record on the thread.  Audit records can persist after
  406  * auditing is disabled, so we don't just check audit_syscalls_enabled here.
  407  */
  408 #define AUDIT_SYSCALL_EXIT(error, td)   do {                            \
  409         if (AUDITING_TD(td))                                            \
  410                 audit_syscall_exit(error, td);                          \
  411 } while (0)
  412 
  413 /*
  414  * A Macro to wrap the audit_sysclose() function.
  415  */
  416 #define AUDIT_SYSCLOSE(td, fd)  do {                                    \
  417         if (AUDITING_TD(td))                                            \
  418                 audit_sysclose(td, fd);                                 \
  419 } while (0)
  420 
  421 #else /* !AUDIT */
  422 
  423 #define AUDIT_ARG_ADDR(addr)
  424 #define AUDIT_ARG_ARGV(argv, argc, length)
  425 #define AUDIT_ARG_ATFD1(atfd)
  426 #define AUDIT_ARG_ATFD2(atfd)
  427 #define AUDIT_ARG_AUDITON(udata)
  428 #define AUDIT_ARG_CMD(cmd)
  429 #define AUDIT_ARG_DEV(dev)
  430 #define AUDIT_ARG_EGID(egid)
  431 #define AUDIT_ARG_ENVV(envv, envc, length)
  432 #define AUDIT_ARG_EXIT(status, retval)
  433 #define AUDIT_ARG_EUID(euid)
  434 #define AUDIT_ARG_FD(fd)
  435 #define AUDIT_ARG_FILE(p, fp)
  436 #define AUDIT_ARG_FFLAGS(fflags)
  437 #define AUDIT_ARG_GID(gid)
  438 #define AUDIT_ARG_GROUPSET(gidset, gidset_size)
  439 #define AUDIT_ARG_LOGIN(login)
  440 #define AUDIT_ARG_MODE(mode)
  441 #define AUDIT_ARG_OWNER(uid, gid)
  442 #define AUDIT_ARG_PID(pid)
  443 #define AUDIT_ARG_POSIX_IPC_PERM(uid, gid, mode)
  444 #define AUDIT_ARG_PROCESS(p)
  445 #define AUDIT_ARG_RGID(rgid)
  446 #define AUDIT_ARG_RIGHTS(rights)
  447 #define AUDIT_ARG_FCNTL_RIGHTS(fcntlrights)
  448 #define AUDIT_ARG_RUID(ruid)
  449 #define AUDIT_ARG_SIGNUM(signum)
  450 #define AUDIT_ARG_SGID(sgid)
  451 #define AUDIT_ARG_SOCKET(sodomain, sotype, soprotocol)
  452 #define AUDIT_ARG_SOCKADDR(td, dirfd, sa)
  453 #define AUDIT_ARG_SUID(suid)
  454 #define AUDIT_ARG_SVIPC_CMD(cmd)
  455 #define AUDIT_ARG_SVIPC_PERM(perm)
  456 #define AUDIT_ARG_SVIPC_ID(id)
  457 #define AUDIT_ARG_SVIPC_ADDR(addr)
  458 #define AUDIT_ARG_SVIPC_WHICH(which)
  459 #define AUDIT_ARG_TEXT(text)
  460 #define AUDIT_ARG_UID(uid)
  461 #define AUDIT_ARG_UPATH1(td, dirfd, upath)
  462 #define AUDIT_ARG_UPATH1_CANON(upath)
  463 #define AUDIT_ARG_UPATH2(td, dirfd, upath)
  464 #define AUDIT_ARG_UPATH2_CANON(upath)
  465 #define AUDIT_ARG_UPATH1_VP(td, rdir, cdir, upath)
  466 #define AUDIT_ARG_UPATH2_VP(td, rdir, cdir, upath)
  467 #define AUDIT_ARG_VALUE(value)
  468 #define AUDIT_ARG_VNODE1(vp)
  469 #define AUDIT_ARG_VNODE2(vp)
  470 
  471 #define AUDITING_TD(td)         0
  472 
  473 #define AUDIT_SYSCALL_ENTER(code, td)   0
  474 #define AUDIT_SYSCALL_EXIT(error, td)
  475 
  476 #define AUDIT_SYSCLOSE(p, fd)
  477 
  478 #endif /* AUDIT */
  479 
  480 #endif /* !_SECURITY_AUDIT_KERNEL_H_ */
Cache object: 471262373b94207ca5d7b27f3cd5a96a
[ 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/security/audit/audit.h

FreeBSD/Linux Kernel Cross Reference
sys/security/audit/audit.h
