sys/security/mac_test/mac_test.c

   1 /*-
   2  * Copyright (c) 1999-2002, 2007 Robert N. M. Watson
   3  * Copyright (c) 2001-2005 McAfee, Inc.
   4  * Copyright (c) 2006 SPARTA, Inc.
   5  * Copyright (c) 2008 Apple Inc.
   6  * All rights reserved.
   7  *
   8  * This software was developed by Robert Watson for the TrustedBSD Project.
   9  *
  10  * This software was developed for the FreeBSD Project in part by McAfee
  11  * Research, the Security Research Division of McAfee, Inc. under
  12  * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA
  13  * CHATS research program.
  14  *
  15  * This software was enhanced by SPARTA ISSO under SPAWAR contract
  16  * N66001-04-C-6019 ("SEFOS").
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  * $FreeBSD$
  40  */
  41
  42 /*
  43  * Developed by the TrustedBSD Project.
  44  *
  45  * MAC Test policy - tests MAC Framework labeling by assigning object class
  46  * magic numbers to each label and validates that each time an object label
  47  * is passed into the policy, it has a consistent object type, catching
  48  * incorrectly passed labels, labels passed after free, etc.
  49  */
  50
  51 #include <sys/param.h>
  52 #include <sys/acl.h>
  53 #include <sys/kdb.h>
  54 #include <sys/kernel.h>
  55 #include <sys/ksem.h>
  56 #include <sys/malloc.h>
  57 #include <sys/module.h>
  58 #include <sys/mount.h>
  59 #include <sys/msg.h>
  60 #include <sys/proc.h>
  61 #include <sys/vnode.h>
  62 #include <sys/sem.h>
  63 #include <sys/shm.h>
  64 #include <sys/socket.h>
  65 #include <sys/socketvar.h>
  66 #include <sys/sx.h>
  67 #include <sys/sysctl.h>
  68
  69 #include <fs/devfs/devfs.h>
  70
  71 #include <net/bpfdesc.h>
  72 #include <net/if.h>
  73 #include <net/if_types.h>
  74 #include <net/if_var.h>
  75
  76 #include <security/mac/mac_policy.h>
  77
  78 SYSCTL_DECL(_security_mac);
  79
  80 SYSCTL_NODE(_security_mac, OID_AUTO, test, CTLFLAG_RW, 0,
  81     "TrustedBSD mac_test policy controls");
  82
  83 #define MAGIC_BPF       0xfe1ad1b6
  84 #define MAGIC_DEVFS     0x9ee79c32
  85 #define MAGIC_IFNET     0xc218b120
  86 #define MAGIC_INPCB     0x4440f7bb
  87 #define MAGIC_IPQ       0x206188ef
  88 #define MAGIC_MBUF      0xbbefa5bb
  89 #define MAGIC_MOUNT     0xc7c46e47
  90 #define MAGIC_SOCKET    0x9199c6cd
  91 #define MAGIC_SYNCACHE  0x7fb838a8
  92 #define MAGIC_SYSV_MSG  0x8bbba61e
  93 #define MAGIC_SYSV_MSQ  0xea672391
  94 #define MAGIC_SYSV_SEM  0x896e8a0b
  95 #define MAGIC_SYSV_SHM  0x76119ab0
  96 #define MAGIC_PIPE      0xdc6c9919
  97 #define MAGIC_POSIX_SEM 0x78ae980c
  98 #define MAGIC_POSIX_SHM 0x4e853fc9
  99 #define MAGIC_PROC      0x3b4be98f
 100 #define MAGIC_CRED      0x9a5a4987
 101 #define MAGIC_VNODE     0x1a67a45c
 102 #define MAGIC_FREE      0x849ba1fd
 103
 104 #define SLOT(x) mac_label_get((x), test_slot)
 105 #define SLOT_SET(x, v)  mac_label_set((x), test_slot, (v))
 106
 107 static int      test_slot;
 108 SYSCTL_INT(_security_mac_test, OID_AUTO, slot, CTLFLAG_RD,
 109     &test_slot, 0, "Slot allocated by framework");
 110
 111 SYSCTL_NODE(_security_mac_test, OID_AUTO, counter, CTLFLAG_RW, 0,
 112     "TrustedBSD mac_test counters controls");
 113
 114 #define COUNTER_DECL(variable)                                          \
 115         static int counter_##variable;                                  \
 116         SYSCTL_INT(_security_mac_test_counter, OID_AUTO, variable,      \
 117         CTLFLAG_RD, &counter_##variable, 0, #variable)
 118
 119 #define COUNTER_INC(variable)   atomic_add_int(&counter_##variable, 1)
 120
 121 #ifdef KDB
 122 #define DEBUGGER(func, string)  kdb_enter(KDB_WHY_MAC, (string))
 123 #else
 124 #define DEBUGGER(func, string)  printf("mac_test: %s: %s\n", (func), (string))
 125 #endif
 126
 127 #define LABEL_CHECK(label, magic) do {                                  \
 128         if (label != NULL) {                                            \
 129                 KASSERT(SLOT(label) == magic || SLOT(label) == 0,       \
 130                     ("%s: bad %s label", __func__, #magic));            \
 131         }                                                               \
 132 } while (0)
 133
 134 #define LABEL_DESTROY(label, magic) do {                                \
 135         if (SLOT(label) == magic || SLOT(label) == 0) {                 \
 136                 SLOT_SET(label, MAGIC_FREE);                            \
 137         } else if (SLOT(label) == MAGIC_FREE) {                         \
 138                 DEBUGGER("%s: dup destroy", __func__);                  \
 139         } else {                                                        \
 140                 DEBUGGER("%s: corrupted label", __func__);              \
 141         }                                                               \
 142 } while (0)
 143
 144 #define LABEL_INIT(label, magic) do {                                   \
 145         SLOT_SET(label, magic);                                         \
 146 } while (0)
 147
 148 #define LABEL_NOTFREE(label) do {                                       \
 149         KASSERT(SLOT(label) != MAGIC_FREE,                              \
 150             ("%s: destroyed label", __func__));                         \
 151 } while (0)
 152
 153 /*
 154  * Object-specific entry point implementations are sorted alphabetically by
 155  * object type name and then by operation.
 156  */
 157 COUNTER_DECL(bpfdesc_check_receive);
 158 static int
 159 test_bpfdesc_check_receive(struct bpf_d *d, struct label *dlabel,
 160     struct ifnet *ifp, struct label *ifplabel)
 161 {
 162
 163         LABEL_CHECK(dlabel, MAGIC_BPF);
 164         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 165         COUNTER_INC(bpfdesc_check_receive);
 166
 167         return (0);
 168 }
 169
 170 COUNTER_DECL(bpfdesc_create);
 171 static void
 172 test_bpfdesc_create(struct ucred *cred, struct bpf_d *d,
 173     struct label *dlabel)
 174 {
 175
 176         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 177         LABEL_CHECK(dlabel, MAGIC_BPF);
 178         COUNTER_INC(bpfdesc_create);
 179 }
 180
 181 COUNTER_DECL(bpfdesc_create_mbuf);
 182 static void
 183 test_bpfdesc_create_mbuf(struct bpf_d *d, struct label *dlabel,
 184     struct mbuf *m, struct label *mlabel)
 185 {
 186
 187         LABEL_CHECK(dlabel, MAGIC_BPF);
 188         LABEL_CHECK(mlabel, MAGIC_MBUF);
 189         COUNTER_INC(bpfdesc_create_mbuf);
 190 }
 191
 192 COUNTER_DECL(bpfdesc_destroy_label);
 193 static void
 194 test_bpfdesc_destroy_label(struct label *label)
 195 {
 196
 197         LABEL_DESTROY(label, MAGIC_BPF);
 198         COUNTER_INC(bpfdesc_destroy_label);
 199 }
 200
 201 COUNTER_DECL(bpfdesc_init_label);
 202 static void
 203 test_bpfdesc_init_label(struct label *label)
 204 {
 205
 206         LABEL_INIT(label, MAGIC_BPF);
 207         COUNTER_INC(bpfdesc_init_label);
 208 }
 209
 210 COUNTER_DECL(cred_check_relabel);
 211 static int
 212 test_cred_check_relabel(struct ucred *cred, struct label *newlabel)
 213 {
 214
 215         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 216         LABEL_CHECK(newlabel, MAGIC_CRED);
 217         COUNTER_INC(cred_check_relabel);
 218
 219         return (0);
 220 }
 221
 222 COUNTER_DECL(cred_check_visible);
 223 static int
 224 test_cred_check_visible(struct ucred *u1, struct ucred *u2)
 225 {
 226
 227         LABEL_CHECK(u1->cr_label, MAGIC_CRED);
 228         LABEL_CHECK(u2->cr_label, MAGIC_CRED);
 229         COUNTER_INC(cred_check_visible);
 230
 231         return (0);
 232 }
 233
 234 COUNTER_DECL(cred_copy_label);
 235 static void
 236 test_cred_copy_label(struct label *src, struct label *dest)
 237 {
 238
 239         LABEL_CHECK(src, MAGIC_CRED);
 240         LABEL_CHECK(dest, MAGIC_CRED);
 241         COUNTER_INC(cred_copy_label);
 242 }
 243
 244 COUNTER_DECL(cred_destroy_label);
 245 static void
 246 test_cred_destroy_label(struct label *label)
 247 {
 248
 249         LABEL_DESTROY(label, MAGIC_CRED);
 250         COUNTER_INC(cred_destroy_label);
 251 }
 252
 253 COUNTER_DECL(cred_externalize_label);
 254 static int
 255 test_cred_externalize_label(struct label *label, char *element_name,
 256     struct sbuf *sb, int *claimed)
 257 {
 258
 259         LABEL_CHECK(label, MAGIC_CRED);
 260         COUNTER_INC(cred_externalize_label);
 261
 262         return (0);
 263 }
 264
 265 COUNTER_DECL(cred_init_label);
 266 static void
 267 test_cred_init_label(struct label *label)
 268 {
 269
 270         LABEL_INIT(label, MAGIC_CRED);
 271         COUNTER_INC(cred_init_label);
 272 }
 273
 274 COUNTER_DECL(cred_internalize_label);
 275 static int
 276 test_cred_internalize_label(struct label *label, char *element_name,
 277     char *element_data, int *claimed)
 278 {
 279
 280         LABEL_CHECK(label, MAGIC_CRED);
 281         COUNTER_INC(cred_internalize_label);
 282
 283         return (0);
 284 }
 285
 286 COUNTER_DECL(cred_relabel);
 287 static void
 288 test_cred_relabel(struct ucred *cred, struct label *newlabel)
 289 {
 290
 291         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 292         LABEL_CHECK(newlabel, MAGIC_CRED);
 293         COUNTER_INC(cred_relabel);
 294 }
 295
 296 COUNTER_DECL(devfs_create_device);
 297 static void
 298 test_devfs_create_device(struct ucred *cred, struct mount *mp,
 299     struct cdev *dev, struct devfs_dirent *de, struct label *delabel)
 300 {
 301
 302         if (cred != NULL)
 303                 LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 304         LABEL_CHECK(delabel, MAGIC_DEVFS);
 305         COUNTER_INC(devfs_create_device);
 306 }
 307
 308 COUNTER_DECL(devfs_create_directory);
 309 static void
 310 test_devfs_create_directory(struct mount *mp, char *dirname,
 311     int dirnamelen, struct devfs_dirent *de, struct label *delabel)
 312 {
 313
 314         LABEL_CHECK(delabel, MAGIC_DEVFS);
 315         COUNTER_INC(devfs_create_directory);
 316 }
 317
 318 COUNTER_DECL(devfs_create_symlink);
 319 static void
 320 test_devfs_create_symlink(struct ucred *cred, struct mount *mp,
 321     struct devfs_dirent *dd, struct label *ddlabel, struct devfs_dirent *de,
 322     struct label *delabel)
 323 {
 324
 325         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 326         LABEL_CHECK(ddlabel, MAGIC_DEVFS);
 327         LABEL_CHECK(delabel, MAGIC_DEVFS);
 328         COUNTER_INC(devfs_create_symlink);
 329 }
 330
 331 COUNTER_DECL(devfs_destroy_label);
 332 static void
 333 test_devfs_destroy_label(struct label *label)
 334 {
 335
 336         LABEL_DESTROY(label, MAGIC_DEVFS);
 337         COUNTER_INC(devfs_destroy_label);
 338 }
 339
 340 COUNTER_DECL(devfs_init_label);
 341 static void
 342 test_devfs_init_label(struct label *label)
 343 {
 344
 345         LABEL_INIT(label, MAGIC_DEVFS);
 346         COUNTER_INC(devfs_init_label);
 347 }
 348
 349 COUNTER_DECL(devfs_update);
 350 static void
 351 test_devfs_update(struct mount *mp, struct devfs_dirent *devfs_dirent,
 352     struct label *direntlabel, struct vnode *vp, struct label *vplabel)
 353 {
 354
 355         LABEL_CHECK(direntlabel, MAGIC_DEVFS);
 356         LABEL_CHECK(vplabel, MAGIC_VNODE);
 357         COUNTER_INC(devfs_update);
 358 }
 359
 360 COUNTER_DECL(devfs_vnode_associate);
 361 static void
 362 test_devfs_vnode_associate(struct mount *mp, struct label *mplabel,
 363     struct devfs_dirent *de, struct label *delabel, struct vnode *vp,
 364     struct label *vplabel)
 365 {
 366
 367         LABEL_CHECK(mplabel, MAGIC_MOUNT);
 368         LABEL_CHECK(delabel, MAGIC_DEVFS);
 369         LABEL_CHECK(vplabel, MAGIC_VNODE);
 370         COUNTER_INC(devfs_vnode_associate);
 371 }
 372
 373 COUNTER_DECL(ifnet_check_relabel);
 374 static int
 375 test_ifnet_check_relabel(struct ucred *cred, struct ifnet *ifp,
 376     struct label *ifplabel, struct label *newlabel)
 377 {
 378
 379         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 380         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 381         LABEL_CHECK(newlabel, MAGIC_IFNET);
 382         COUNTER_INC(ifnet_check_relabel);
 383
 384         return (0);
 385 }
 386
 387 COUNTER_DECL(ifnet_check_transmit);
 388 static int
 389 test_ifnet_check_transmit(struct ifnet *ifp, struct label *ifplabel,
 390     struct mbuf *m, struct label *mlabel)
 391 {
 392
 393         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 394         LABEL_CHECK(mlabel, MAGIC_MBUF);
 395         COUNTER_INC(ifnet_check_transmit);
 396
 397         return (0);
 398 }
 399
 400 COUNTER_DECL(ifnet_copy_label);
 401 static void
 402 test_ifnet_copy_label(struct label *src, struct label *dest)
 403 {
 404
 405         LABEL_CHECK(src, MAGIC_IFNET);
 406         LABEL_CHECK(dest, MAGIC_IFNET);
 407         COUNTER_INC(ifnet_copy_label);
 408 }
 409
 410 COUNTER_DECL(ifnet_create);
 411 static void
 412 test_ifnet_create(struct ifnet *ifp, struct label *ifplabel)
 413 {
 414
 415         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 416         COUNTER_INC(ifnet_create);
 417 }
 418
 419 COUNTER_DECL(ifnet_create_mbuf);
 420 static void
 421 test_ifnet_create_mbuf(struct ifnet *ifp, struct label *ifplabel,
 422     struct mbuf *m, struct label *mlabel)
 423 {
 424
 425         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 426         LABEL_CHECK(mlabel, MAGIC_MBUF);
 427         COUNTER_INC(ifnet_create_mbuf);
 428 }
 429
 430 COUNTER_DECL(ifnet_destroy_label);
 431 static void
 432 test_ifnet_destroy_label(struct label *label)
 433 {
 434
 435         LABEL_DESTROY(label, MAGIC_IFNET);
 436         COUNTER_INC(ifnet_destroy_label);
 437 }
 438
 439 COUNTER_DECL(ifnet_externalize_label);
 440 static int
 441 test_ifnet_externalize_label(struct label *label, char *element_name,
 442     struct sbuf *sb, int *claimed)
 443 {
 444
 445         LABEL_CHECK(label, MAGIC_IFNET);
 446         COUNTER_INC(ifnet_externalize_label);
 447
 448         return (0);
 449 }
 450
 451 COUNTER_DECL(ifnet_init_label);
 452 static void
 453 test_ifnet_init_label(struct label *label)
 454 {
 455
 456         LABEL_INIT(label, MAGIC_IFNET);
 457         COUNTER_INC(ifnet_init_label);
 458 }
 459
 460 COUNTER_DECL(ifnet_internalize_label);
 461 static int
 462 test_ifnet_internalize_label(struct label *label, char *element_name,
 463     char *element_data, int *claimed)
 464 {
 465
 466         LABEL_CHECK(label, MAGIC_IFNET);
 467         COUNTER_INC(ifnet_internalize_label);
 468
 469         return (0);
 470 }
 471
 472 COUNTER_DECL(ifnet_relabel);
 473 static void
 474 test_ifnet_relabel(struct ucred *cred, struct ifnet *ifp,
 475     struct label *ifplabel, struct label *newlabel)
 476 {
 477
 478         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 479         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 480         LABEL_CHECK(newlabel, MAGIC_IFNET);
 481         COUNTER_INC(ifnet_relabel);
 482 }
 483
 484 COUNTER_DECL(inpcb_check_deliver);
 485 static int
 486 test_inpcb_check_deliver(struct inpcb *inp, struct label *inplabel,
 487     struct mbuf *m, struct label *mlabel)
 488 {
 489
 490         LABEL_CHECK(inplabel, MAGIC_INPCB);
 491         LABEL_CHECK(mlabel, MAGIC_MBUF);
 492         COUNTER_INC(inpcb_check_deliver);
 493
 494         return (0);
 495 }
 496
 497 COUNTER_DECL(inpcb_check_visible);
 498 static int
 499 test_inpcb_check_visible(struct ucred *cred, struct inpcb *inp,
 500     struct label *inplabel)
 501 {
 502
 503         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 504         LABEL_CHECK(inplabel, MAGIC_INPCB);
 505         COUNTER_INC(inpcb_check_visible);
 506
 507         return (0);
 508 }
 509
 510 COUNTER_DECL(inpcb_create);
 511 static void
 512 test_inpcb_create(struct socket *so, struct label *solabel,
 513     struct inpcb *inp, struct label *inplabel)
 514 {
 515
 516         LABEL_CHECK(solabel, MAGIC_SOCKET);
 517         LABEL_CHECK(inplabel, MAGIC_INPCB);
 518         COUNTER_INC(inpcb_create);
 519 }
 520
 521 COUNTER_DECL(inpcb_create_mbuf);
 522 static void
 523 test_inpcb_create_mbuf(struct inpcb *inp, struct label *inplabel,
 524     struct mbuf *m, struct label *mlabel)
 525 {
 526
 527         LABEL_CHECK(inplabel, MAGIC_INPCB);
 528         LABEL_CHECK(mlabel, MAGIC_MBUF);
 529         COUNTER_INC(inpcb_create_mbuf);
 530 }
 531
 532 COUNTER_DECL(inpcb_destroy_label);
 533 static void
 534 test_inpcb_destroy_label(struct label *label)
 535 {
 536
 537         LABEL_DESTROY(label, MAGIC_INPCB);
 538         COUNTER_INC(inpcb_destroy_label);
 539 }
 540
 541 COUNTER_DECL(inpcb_init_label);
 542 static int
 543 test_inpcb_init_label(struct label *label, int flag)
 544 {
 545
 546         if (flag & M_WAITOK)
 547                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
 548                     "test_inpcb_init_label() at %s:%d", __FILE__,
 549                     __LINE__);
 550
 551         LABEL_INIT(label, MAGIC_INPCB);
 552         COUNTER_INC(inpcb_init_label);
 553         return (0);
 554 }
 555
 556 COUNTER_DECL(inpcb_sosetlabel);
 557 static void
 558 test_inpcb_sosetlabel(struct socket *so, struct label *solabel,
 559     struct inpcb *inp, struct label *inplabel)
 560 {
 561
 562         LABEL_CHECK(solabel, MAGIC_SOCKET);
 563         LABEL_CHECK(inplabel, MAGIC_INPCB);
 564         COUNTER_INC(inpcb_sosetlabel);
 565 }
 566
 567 COUNTER_DECL(ipq_create);
 568 static void
 569 test_ipq_create(struct mbuf *fragment, struct label *fragmentlabel,
 570     struct ipq *q, struct label *qlabel)
 571 {
 572
 573         LABEL_CHECK(fragmentlabel, MAGIC_MBUF);
 574         LABEL_CHECK(qlabel, MAGIC_IPQ);
 575         COUNTER_INC(ipq_create);
 576 }
 577
 578 COUNTER_DECL(ipq_destroy_label);
 579 static void
 580 test_ipq_destroy_label(struct label *label)
 581 {
 582
 583         LABEL_DESTROY(label, MAGIC_IPQ);
 584         COUNTER_INC(ipq_destroy_label);
 585 }
 586
 587 COUNTER_DECL(ipq_init_label);
 588 static int
 589 test_ipq_init_label(struct label *label, int flag)
 590 {
 591
 592         if (flag & M_WAITOK)
 593                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
 594                     "test_ipq_init_label() at %s:%d", __FILE__,
 595                     __LINE__);
 596
 597         LABEL_INIT(label, MAGIC_IPQ);
 598         COUNTER_INC(ipq_init_label);
 599         return (0);
 600 }
 601
 602 COUNTER_DECL(ipq_match);
 603 static int
 604 test_ipq_match(struct mbuf *fragment, struct label *fragmentlabel,
 605     struct ipq *q, struct label *qlabel)
 606 {
 607
 608         LABEL_CHECK(fragmentlabel, MAGIC_MBUF);
 609         LABEL_CHECK(qlabel, MAGIC_IPQ);
 610         COUNTER_INC(ipq_match);
 611
 612         return (1);
 613 }
 614
 615 COUNTER_DECL(ipq_reassemble);
 616 static void
 617 test_ipq_reassemble(struct ipq *q, struct label *qlabel, struct mbuf *m,
 618    struct label *mlabel)
 619 {
 620
 621         LABEL_CHECK(qlabel, MAGIC_IPQ);
 622         LABEL_CHECK(mlabel, MAGIC_MBUF);
 623         COUNTER_INC(ipq_reassemble);
 624 }
 625
 626 COUNTER_DECL(ipq_update);
 627 static void
 628 test_ipq_update(struct mbuf *m, struct label *mlabel, struct ipq *q,
 629     struct label *qlabel)
 630 {
 631
 632         LABEL_CHECK(mlabel, MAGIC_MBUF);
 633         LABEL_CHECK(qlabel, MAGIC_IPQ);
 634         COUNTER_INC(ipq_update);
 635 }
 636
 637 COUNTER_DECL(kenv_check_dump);
 638 static int
 639 test_kenv_check_dump(struct ucred *cred)
 640 {
 641
 642         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 643         COUNTER_INC(kenv_check_dump);
 644
 645         return (0);
 646 }
 647
 648 COUNTER_DECL(kenv_check_get);
 649 static int
 650 test_kenv_check_get(struct ucred *cred, char *name)
 651 {
 652
 653         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 654         COUNTER_INC(kenv_check_get);
 655
 656         return (0);
 657 }
 658
 659 COUNTER_DECL(kenv_check_set);
 660 static int
 661 test_kenv_check_set(struct ucred *cred, char *name, char *value)
 662 {
 663
 664         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 665         COUNTER_INC(kenv_check_set);
 666
 667         return (0);
 668 }
 669
 670 COUNTER_DECL(kenv_check_unset);
 671 static int
 672 test_kenv_check_unset(struct ucred *cred, char *name)
 673 {
 674
 675         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 676         COUNTER_INC(kenv_check_unset);
 677
 678         return (0);
 679 }
 680
 681 COUNTER_DECL(kld_check_load);
 682 static int
 683 test_kld_check_load(struct ucred *cred, struct vnode *vp,
 684     struct label *label)
 685 {
 686
 687         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 688         LABEL_CHECK(label, MAGIC_VNODE);
 689         COUNTER_INC(kld_check_load);
 690
 691         return (0);
 692 }
 693
 694 COUNTER_DECL(kld_check_stat);
 695 static int
 696 test_kld_check_stat(struct ucred *cred)
 697 {
 698
 699         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 700         COUNTER_INC(kld_check_stat);
 701
 702         return (0);
 703 }
 704
 705 COUNTER_DECL(mbuf_copy_label);
 706 static void
 707 test_mbuf_copy_label(struct label *src, struct label *dest)
 708 {
 709
 710         LABEL_CHECK(src, MAGIC_MBUF);
 711         LABEL_CHECK(dest, MAGIC_MBUF);
 712         COUNTER_INC(mbuf_copy_label);
 713 }
 714
 715 COUNTER_DECL(mbuf_destroy_label);
 716 static void
 717 test_mbuf_destroy_label(struct label *label)
 718 {
 719
 720         /*
 721          * If we're loaded dynamically, there may be mbufs in flight that
 722          * didn't have label storage allocated for them.  Handle this
 723          * gracefully.
 724          */
 725         if (label == NULL)
 726                 return;
 727
 728         LABEL_DESTROY(label, MAGIC_MBUF);
 729         COUNTER_INC(mbuf_destroy_label);
 730 }
 731
 732 COUNTER_DECL(mbuf_init_label);
 733 static int
 734 test_mbuf_init_label(struct label *label, int flag)
 735 {
 736
 737         if (flag & M_WAITOK)
 738                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
 739                     "test_mbuf_init_label() at %s:%d", __FILE__,
 740                     __LINE__);
 741
 742         LABEL_INIT(label, MAGIC_MBUF);
 743         COUNTER_INC(mbuf_init_label);
 744         return (0);
 745 }
 746
 747 COUNTER_DECL(mount_check_stat);
 748 static int
 749 test_mount_check_stat(struct ucred *cred, struct mount *mp,
 750     struct label *mplabel)
 751 {
 752
 753         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 754         LABEL_CHECK(mplabel, MAGIC_MOUNT);
 755         COUNTER_INC(mount_check_stat);
 756
 757         return (0);
 758 }
 759
 760 COUNTER_DECL(mount_create);
 761 static void
 762 test_mount_create(struct ucred *cred, struct mount *mp,
 763     struct label *mplabel)
 764 {
 765
 766         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 767         LABEL_CHECK(mplabel, MAGIC_MOUNT);
 768         COUNTER_INC(mount_create);
 769 }
 770
 771 COUNTER_DECL(mount_destroy_label);
 772 static void
 773 test_mount_destroy_label(struct label *label)
 774 {
 775
 776         LABEL_DESTROY(label, MAGIC_MOUNT);
 777         COUNTER_INC(mount_destroy_label);
 778 }
 779
 780 COUNTER_DECL(mount_init_label);
 781 static void
 782 test_mount_init_label(struct label *label)
 783 {
 784
 785         LABEL_INIT(label, MAGIC_MOUNT);
 786         COUNTER_INC(mount_init_label);
 787 }
 788
 789 COUNTER_DECL(netatalk_aarp_send);
 790 static void
 791 test_netatalk_aarp_send(struct ifnet *ifp, struct label *ifplabel,
 792     struct mbuf *m, struct label *mlabel)
 793 {
 794
 795         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 796         LABEL_CHECK(mlabel, MAGIC_MBUF);
 797         COUNTER_INC(netatalk_aarp_send);
 798 }
 799
 800 COUNTER_DECL(netinet_arp_send);
 801 static void
 802 test_netinet_arp_send(struct ifnet *ifp, struct label *ifplabel,
 803     struct mbuf *m, struct label *mlabel)
 804 {
 805
 806         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 807         LABEL_CHECK(mlabel, MAGIC_MBUF);
 808         COUNTER_INC(netinet_arp_send);
 809 }
 810
 811 COUNTER_DECL(netinet_fragment);
 812 static void
 813 test_netinet_fragment(struct mbuf *m, struct label *mlabel,
 814     struct mbuf *frag, struct label *fraglabel)
 815 {
 816
 817         LABEL_CHECK(mlabel, MAGIC_MBUF);
 818         LABEL_CHECK(fraglabel, MAGIC_MBUF);
 819         COUNTER_INC(netinet_fragment);
 820 }
 821
 822 COUNTER_DECL(netinet_icmp_reply);
 823 static void
 824 test_netinet_icmp_reply(struct mbuf *mrecv, struct label *mrecvlabel,
 825     struct mbuf *msend, struct label *msendlabel)
 826 {
 827
 828         LABEL_CHECK(mrecvlabel, MAGIC_MBUF);
 829         LABEL_CHECK(msendlabel, MAGIC_MBUF);
 830         COUNTER_INC(netinet_icmp_reply);
 831 }
 832
 833 COUNTER_DECL(netinet_icmp_replyinplace);
 834 static void
 835 test_netinet_icmp_replyinplace(struct mbuf *m, struct label *mlabel)
 836 {
 837
 838         LABEL_CHECK(mlabel, MAGIC_MBUF);
 839         COUNTER_INC(netinet_icmp_replyinplace);
 840 }
 841
 842 COUNTER_DECL(netinet_igmp_send);
 843 static void
 844 test_netinet_igmp_send(struct ifnet *ifp, struct label *ifplabel,
 845     struct mbuf *m, struct label *mlabel)
 846 {
 847
 848         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 849         LABEL_CHECK(mlabel, MAGIC_MBUF);
 850         COUNTER_INC(netinet_igmp_send);
 851 }
 852
 853 COUNTER_DECL(netinet_tcp_reply);
 854 static void
 855 test_netinet_tcp_reply(struct mbuf *m, struct label *mlabel)
 856 {
 857
 858         LABEL_CHECK(mlabel, MAGIC_MBUF);
 859         COUNTER_INC(netinet_tcp_reply);
 860 }
 861
 862 COUNTER_DECL(netinet6_nd6_send);
 863 static void
 864 test_netinet6_nd6_send(struct ifnet *ifp, struct label *ifplabel,
 865     struct mbuf *m, struct label *mlabel)
 866 {
 867
 868         LABEL_CHECK(ifplabel, MAGIC_IFNET);
 869         LABEL_CHECK(mlabel, MAGIC_MBUF);
 870         COUNTER_INC(netinet6_nd6_send);
 871 }
 872
 873 COUNTER_DECL(pipe_check_ioctl);
 874 static int
 875 test_pipe_check_ioctl(struct ucred *cred, struct pipepair *pp,
 876     struct label *pplabel, unsigned long cmd, void /* caddr_t */ *data)
 877 {
 878
 879         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 880         LABEL_CHECK(pplabel, MAGIC_PIPE);
 881         COUNTER_INC(pipe_check_ioctl);
 882
 883         return (0);
 884 }
 885
 886 COUNTER_DECL(pipe_check_poll);
 887 static int
 888 test_pipe_check_poll(struct ucred *cred, struct pipepair *pp,
 889     struct label *pplabel)
 890 {
 891
 892         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 893         LABEL_CHECK(pplabel, MAGIC_PIPE);
 894         COUNTER_INC(pipe_check_poll);
 895
 896         return (0);
 897 }
 898
 899 COUNTER_DECL(pipe_check_read);
 900 static int
 901 test_pipe_check_read(struct ucred *cred, struct pipepair *pp,
 902     struct label *pplabel)
 903 {
 904
 905         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 906         LABEL_CHECK(pplabel, MAGIC_PIPE);
 907         COUNTER_INC(pipe_check_read);
 908
 909         return (0);
 910 }
 911
 912 COUNTER_DECL(pipe_check_relabel);
 913 static int
 914 test_pipe_check_relabel(struct ucred *cred, struct pipepair *pp,
 915     struct label *pplabel, struct label *newlabel)
 916 {
 917
 918         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 919         LABEL_CHECK(pplabel, MAGIC_PIPE);
 920         LABEL_CHECK(newlabel, MAGIC_PIPE);
 921         COUNTER_INC(pipe_check_relabel);
 922
 923         return (0);
 924 }
 925
 926 COUNTER_DECL(pipe_check_stat);
 927 static int
 928 test_pipe_check_stat(struct ucred *cred, struct pipepair *pp,
 929     struct label *pplabel)
 930 {
 931
 932         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 933         LABEL_CHECK(pplabel, MAGIC_PIPE);
 934         COUNTER_INC(pipe_check_stat);
 935
 936         return (0);
 937 }
 938
 939 COUNTER_DECL(pipe_check_write);
 940 static int
 941 test_pipe_check_write(struct ucred *cred, struct pipepair *pp,
 942     struct label *pplabel)
 943 {
 944
 945         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 946         LABEL_CHECK(pplabel, MAGIC_PIPE);
 947         COUNTER_INC(pipe_check_write);
 948
 949         return (0);
 950 }
 951
 952 COUNTER_DECL(pipe_copy_label);
 953 static void
 954 test_pipe_copy_label(struct label *src, struct label *dest)
 955 {
 956
 957         LABEL_CHECK(src, MAGIC_PIPE);
 958         LABEL_CHECK(dest, MAGIC_PIPE);
 959         COUNTER_INC(pipe_copy_label);
 960 }
 961
 962 COUNTER_DECL(pipe_create);
 963 static void
 964 test_pipe_create(struct ucred *cred, struct pipepair *pp,
 965    struct label *pplabel)
 966 {
 967
 968         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
 969         LABEL_CHECK(pplabel, MAGIC_PIPE);
 970         COUNTER_INC(pipe_create);
 971 }
 972
 973 COUNTER_DECL(pipe_destroy_label);
 974 static void
 975 test_pipe_destroy_label(struct label *label)
 976 {
 977
 978         LABEL_DESTROY(label, MAGIC_PIPE);
 979         COUNTER_INC(pipe_destroy_label);
 980 }
 981
 982 COUNTER_DECL(pipe_externalize_label);
 983 static int
 984 test_pipe_externalize_label(struct label *label, char *element_name,
 985     struct sbuf *sb, int *claimed)
 986 {
 987
 988         LABEL_CHECK(label, MAGIC_PIPE);
 989         COUNTER_INC(pipe_externalize_label);
 990
 991         return (0);
 992 }
 993
 994 COUNTER_DECL(pipe_init_label);
 995 static void
 996 test_pipe_init_label(struct label *label)
 997 {
 998
 999         LABEL_INIT(label, MAGIC_PIPE);
1000         COUNTER_INC(pipe_init_label);
1001 }
1002
1003 COUNTER_DECL(pipe_internalize_label);
1004 static int
1005 test_pipe_internalize_label(struct label *label, char *element_name,
1006     char *element_data, int *claimed)
1007 {
1008
1009         LABEL_CHECK(label, MAGIC_PIPE);
1010         COUNTER_INC(pipe_internalize_label);
1011
1012         return (0);
1013 }
1014
1015 COUNTER_DECL(pipe_relabel);
1016 static void
1017 test_pipe_relabel(struct ucred *cred, struct pipepair *pp,
1018     struct label *pplabel, struct label *newlabel)
1019 {
1020
1021         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1022         LABEL_CHECK(pplabel, MAGIC_PIPE);
1023         LABEL_CHECK(newlabel, MAGIC_PIPE);
1024         COUNTER_INC(pipe_relabel);
1025 }
1026
1027 COUNTER_DECL(posixsem_check_getvalue);
1028 static int
1029 test_posixsem_check_getvalue(struct ucred *active_cred, struct ucred *file_cred,
1030     struct ksem *ks, struct label *kslabel)
1031 {
1032
1033         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1034         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1035         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1036         COUNTER_INC(posixsem_check_getvalue);
1037
1038         return (0);
1039 }
1040
1041 COUNTER_DECL(posixsem_check_open);
1042 static int
1043 test_posixsem_check_open(struct ucred *cred, struct ksem *ks,
1044     struct label *kslabel)
1045 {
1046
1047         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1048         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1049         COUNTER_INC(posixsem_check_open);
1050
1051         return (0);
1052 }
1053
1054 COUNTER_DECL(posixsem_check_post);
1055 static int
1056 test_posixsem_check_post(struct ucred *active_cred, struct ucred *file_cred,
1057     struct ksem *ks, struct label *kslabel)
1058 {
1059
1060         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1061         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1062         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1063         COUNTER_INC(posixsem_check_post);
1064
1065         return (0);
1066 }
1067
1068 COUNTER_DECL(posixsem_check_stat);
1069 static int
1070 test_posixsem_check_stat(struct ucred *active_cred,
1071     struct ucred *file_cred, struct ksem *ks, struct label *kslabel)
1072 {
1073
1074         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1075         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1076         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1077         COUNTER_INC(posixsem_check_stat);
1078         return (0);
1079 }
1080
1081 COUNTER_DECL(posixsem_check_unlink);
1082 static int
1083 test_posixsem_check_unlink(struct ucred *cred, struct ksem *ks,
1084     struct label *kslabel)
1085 {
1086
1087         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1088         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1089         COUNTER_INC(posixsem_check_unlink);
1090
1091         return (0);
1092 }
1093
1094 COUNTER_DECL(posixsem_check_wait);
1095 static int
1096 test_posixsem_check_wait(struct ucred *active_cred, struct ucred *file_cred,
1097     struct ksem *ks, struct label *kslabel)
1098 {
1099
1100         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1101         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1102         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1103         COUNTER_INC(posixsem_check_wait);
1104
1105         return (0);
1106 }
1107
1108 COUNTER_DECL(posixsem_create);
1109 static void
1110 test_posixsem_create(struct ucred *cred, struct ksem *ks,
1111    struct label *kslabel)
1112 {
1113
1114         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1115         LABEL_CHECK(kslabel, MAGIC_POSIX_SEM);
1116         COUNTER_INC(posixsem_create);
1117 }
1118
1119 COUNTER_DECL(posixsem_destroy_label);
1120 static void
1121 test_posixsem_destroy_label(struct label *label)
1122 {
1123
1124         LABEL_DESTROY(label, MAGIC_POSIX_SEM);
1125         COUNTER_INC(posixsem_destroy_label);
1126 }
1127
1128 COUNTER_DECL(posixsem_init_label);
1129 static void
1130 test_posixsem_init_label(struct label *label)
1131 {
1132
1133         LABEL_INIT(label, MAGIC_POSIX_SEM);
1134         COUNTER_INC(posixsem_init_label);
1135 }
1136
1137 COUNTER_DECL(posixshm_check_mmap);
1138 static int
1139 test_posixshm_check_mmap(struct ucred *cred, struct shmfd *shmfd,
1140     struct label *shmfdlabel, int prot, int flags)
1141 {
1142
1143         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1144         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1145         COUNTER_INC(posixshm_check_mmap);
1146         return (0);
1147 }
1148
1149 COUNTER_DECL(posixshm_check_open);
1150 static int
1151 test_posixshm_check_open(struct ucred *cred, struct shmfd *shmfd,
1152     struct label *shmfdlabel)
1153 {
1154
1155         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1156         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1157         COUNTER_INC(posixshm_check_open);
1158         return (0);
1159 }
1160
1161 COUNTER_DECL(posixshm_check_stat);
1162 static int
1163 test_posixshm_check_stat(struct ucred *active_cred,
1164     struct ucred *file_cred, struct shmfd *shmfd, struct label *shmfdlabel)
1165 {
1166
1167         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1168         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1169         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1170         COUNTER_INC(posixshm_check_stat);
1171         return (0);
1172 }
1173
1174 COUNTER_DECL(posixshm_check_truncate);
1175 static int
1176 test_posixshm_check_truncate(struct ucred *active_cred,
1177     struct ucred *file_cred, struct shmfd *shmfd, struct label *shmfdlabel)
1178 {
1179
1180         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
1181         LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
1182         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1183         COUNTER_INC(posixshm_check_truncate);
1184         return (0);
1185 }
1186
1187 COUNTER_DECL(posixshm_check_unlink);
1188 static int
1189 test_posixshm_check_unlink(struct ucred *cred, struct shmfd *shmfd,
1190     struct label *shmfdlabel)
1191 {
1192
1193         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1194         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1195         COUNTER_INC(posixshm_check_unlink);
1196         return (0);
1197 }
1198
1199 COUNTER_DECL(posixshm_create);
1200 static void
1201 test_posixshm_create(struct ucred *cred, struct shmfd *shmfd,
1202    struct label *shmfdlabel)
1203 {
1204
1205         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1206         LABEL_CHECK(shmfdlabel, MAGIC_POSIX_SHM);
1207         COUNTER_INC(posixshm_create);
1208 }
1209
1210 COUNTER_DECL(posixshm_destroy_label);
1211 static void
1212 test_posixshm_destroy_label(struct label *label)
1213 {
1214
1215         LABEL_DESTROY(label, MAGIC_POSIX_SHM);
1216         COUNTER_INC(posixshm_destroy_label);
1217 }
1218
1219 COUNTER_DECL(posixshm_init_label);
1220 static void
1221 test_posixshm_init_label(struct label *label)
1222 {
1223
1224         LABEL_INIT(label, MAGIC_POSIX_SHM);
1225         COUNTER_INC(posixshm_init_label);
1226 }
1227
1228 COUNTER_DECL(proc_check_debug);
1229 static int
1230 test_proc_check_debug(struct ucred *cred, struct proc *p)
1231 {
1232
1233         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1234         LABEL_CHECK(p->p_ucred->cr_label, MAGIC_CRED);
1235         COUNTER_INC(proc_check_debug);
1236
1237         return (0);
1238 }
1239
1240 COUNTER_DECL(proc_check_sched);
1241 static int
1242 test_proc_check_sched(struct ucred *cred, struct proc *p)
1243 {
1244
1245         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1246         LABEL_CHECK(p->p_ucred->cr_label, MAGIC_CRED);
1247         COUNTER_INC(proc_check_sched);
1248
1249         return (0);
1250 }
1251
1252 COUNTER_DECL(proc_check_signal);
1253 static int
1254 test_proc_check_signal(struct ucred *cred, struct proc *p, int signum)
1255 {
1256
1257         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1258         LABEL_CHECK(p->p_ucred->cr_label, MAGIC_CRED);
1259         COUNTER_INC(proc_check_signal);
1260
1261         return (0);
1262 }
1263
1264 COUNTER_DECL(proc_check_setaudit);
1265 static int
1266 test_proc_check_setaudit(struct ucred *cred, struct auditinfo *ai)
1267 {
1268
1269         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1270         COUNTER_INC(proc_check_setaudit);
1271
1272         return (0);
1273 }
1274
1275 COUNTER_DECL(proc_check_setaudit_addr);
1276 static int
1277 test_proc_check_setaudit_addr(struct ucred *cred,
1278     struct auditinfo_addr *aia)
1279 {
1280
1281         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1282         COUNTER_INC(proc_check_setaudit_addr);
1283
1284         return (0);
1285 }
1286
1287 COUNTER_DECL(proc_check_setauid);
1288 static int
1289 test_proc_check_setauid(struct ucred *cred, uid_t auid)
1290 {
1291
1292         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1293         COUNTER_INC(proc_check_setauid);
1294
1295         return (0);
1296 }
1297
1298 COUNTER_DECL(proc_check_setegid);
1299 static int
1300 test_proc_check_setegid(struct ucred *cred, gid_t egid)
1301 {
1302
1303         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1304         COUNTER_INC(proc_check_setegid);
1305
1306         return (0);
1307 }
1308
1309 COUNTER_DECL(proc_check_euid);
1310 static int
1311 test_proc_check_seteuid(struct ucred *cred, uid_t euid)
1312 {
1313
1314         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1315         COUNTER_INC(proc_check_euid);
1316
1317         return (0);
1318 }
1319
1320 COUNTER_DECL(proc_check_setregid);
1321 static int
1322 test_proc_check_setregid(struct ucred *cred, gid_t rgid, gid_t egid)
1323 {
1324
1325         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1326         COUNTER_INC(proc_check_setregid);
1327
1328         return (0);
1329 }
1330
1331 COUNTER_DECL(proc_check_setreuid);
1332 static int
1333 test_proc_check_setreuid(struct ucred *cred, uid_t ruid, uid_t euid)
1334 {
1335
1336         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1337         COUNTER_INC(proc_check_setreuid);
1338
1339         return (0);
1340 }
1341
1342 COUNTER_DECL(proc_check_setgid);
1343 static int
1344 test_proc_check_setgid(struct ucred *cred, gid_t gid)
1345 {
1346
1347         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1348         COUNTER_INC(proc_check_setgid);
1349
1350         return (0);
1351 }
1352
1353 COUNTER_DECL(proc_check_setgroups);
1354 static int
1355 test_proc_check_setgroups(struct ucred *cred, int ngroups,
1356         gid_t *gidset)
1357 {
1358
1359         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1360         COUNTER_INC(proc_check_setgroups);
1361
1362         return (0);
1363 }
1364
1365 COUNTER_DECL(proc_check_setresgid);
1366 static int
1367 test_proc_check_setresgid(struct ucred *cred, gid_t rgid, gid_t egid,
1368         gid_t sgid)
1369 {
1370
1371         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1372         COUNTER_INC(proc_check_setresgid);
1373
1374         return (0);
1375 }
1376
1377 COUNTER_DECL(proc_check_setresuid);
1378 static int
1379 test_proc_check_setresuid(struct ucred *cred, uid_t ruid, uid_t euid,
1380         uid_t suid)
1381 {
1382
1383         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1384         COUNTER_INC(proc_check_setresuid);
1385
1386         return (0);
1387 }
1388
1389 COUNTER_DECL(proc_check_setuid);
1390 static int
1391 test_proc_check_setuid(struct ucred *cred, uid_t uid)
1392 {
1393
1394         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1395         COUNTER_INC(proc_check_setuid);
1396
1397         return (0);
1398 }
1399
1400 COUNTER_DECL(proc_check_wait);
1401 static int
1402 test_proc_check_wait(struct ucred *cred, struct proc *p)
1403 {
1404
1405         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1406         LABEL_CHECK(p->p_ucred->cr_label, MAGIC_CRED);
1407         COUNTER_INC(proc_check_wait);
1408
1409         return (0);
1410 }
1411
1412 COUNTER_DECL(proc_create_init);
1413 static void
1414 test_proc_create_init(struct ucred *cred)
1415 {
1416
1417         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1418         COUNTER_INC(proc_create_init);
1419 }
1420
1421 COUNTER_DECL(proc_create_swapper);
1422 static void
1423 test_proc_create_swapper(struct ucred *cred)
1424 {
1425
1426         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1427         COUNTER_INC(proc_create_swapper);
1428 }
1429
1430 COUNTER_DECL(proc_destroy_label);
1431 static void
1432 test_proc_destroy_label(struct label *label)
1433 {
1434
1435         LABEL_DESTROY(label, MAGIC_PROC);
1436         COUNTER_INC(proc_destroy_label);
1437 }
1438
1439 COUNTER_DECL(proc_init_label);
1440 static void
1441 test_proc_init_label(struct label *label)
1442 {
1443
1444         LABEL_INIT(label, MAGIC_PROC);
1445         COUNTER_INC(proc_init_label);
1446 }
1447
1448 COUNTER_DECL(socket_check_accept);
1449 static int
1450 test_socket_check_accept(struct ucred *cred, struct socket *so,
1451     struct label *solabel)
1452 {
1453
1454         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1455         LABEL_CHECK(solabel, MAGIC_SOCKET);
1456         COUNTER_INC(socket_check_accept);
1457
1458         return (0);
1459 }
1460
1461 COUNTER_DECL(socket_check_bind);
1462 static int
1463 test_socket_check_bind(struct ucred *cred, struct socket *so,
1464     struct label *solabel, struct sockaddr *sa)
1465 {
1466
1467         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1468         LABEL_CHECK(solabel, MAGIC_SOCKET);
1469         COUNTER_INC(socket_check_bind);
1470
1471         return (0);
1472 }
1473
1474 COUNTER_DECL(socket_check_connect);
1475 static int
1476 test_socket_check_connect(struct ucred *cred, struct socket *so,
1477     struct label *solabel, struct sockaddr *sa)
1478 {
1479
1480         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1481         LABEL_CHECK(solabel, MAGIC_SOCKET);
1482         COUNTER_INC(socket_check_connect);
1483
1484         return (0);
1485 }
1486
1487 COUNTER_DECL(socket_check_deliver);
1488 static int
1489 test_socket_check_deliver(struct socket *so, struct label *solabel,
1490     struct mbuf *m, struct label *mlabel)
1491 {
1492
1493         LABEL_CHECK(solabel, MAGIC_SOCKET);
1494         LABEL_CHECK(mlabel, MAGIC_MBUF);
1495         COUNTER_INC(socket_check_deliver);
1496
1497         return (0);
1498 }
1499
1500 COUNTER_DECL(socket_check_listen);
1501 static int
1502 test_socket_check_listen(struct ucred *cred, struct socket *so,
1503     struct label *solabel)
1504 {
1505
1506         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1507         LABEL_CHECK(solabel, MAGIC_SOCKET);
1508         COUNTER_INC(socket_check_listen);
1509
1510         return (0);
1511 }
1512
1513 COUNTER_DECL(socket_check_poll);
1514 static int
1515 test_socket_check_poll(struct ucred *cred, struct socket *so,
1516     struct label *solabel)
1517 {
1518
1519         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1520         LABEL_CHECK(solabel, MAGIC_SOCKET);
1521         COUNTER_INC(socket_check_poll);
1522
1523         return (0);
1524 }
1525
1526 COUNTER_DECL(socket_check_receive);
1527 static int
1528 test_socket_check_receive(struct ucred *cred, struct socket *so,
1529     struct label *solabel)
1530 {
1531
1532         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1533         LABEL_CHECK(solabel, MAGIC_SOCKET);
1534         COUNTER_INC(socket_check_receive);
1535
1536         return (0);
1537 }
1538
1539 COUNTER_DECL(socket_check_relabel);
1540 static int
1541 test_socket_check_relabel(struct ucred *cred, struct socket *so,
1542     struct label *solabel, struct label *newlabel)
1543 {
1544
1545         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1546         LABEL_CHECK(solabel, MAGIC_SOCKET);
1547         LABEL_CHECK(newlabel, MAGIC_SOCKET);
1548         COUNTER_INC(socket_check_relabel);
1549
1550         return (0);
1551 }
1552
1553 COUNTER_DECL(socket_check_send);
1554 static int
1555 test_socket_check_send(struct ucred *cred, struct socket *so,
1556     struct label *solabel)
1557 {
1558
1559         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1560         LABEL_CHECK(solabel, MAGIC_SOCKET);
1561         COUNTER_INC(socket_check_send);
1562
1563         return (0);
1564 }
1565
1566 COUNTER_DECL(socket_check_stat);
1567 static int
1568 test_socket_check_stat(struct ucred *cred, struct socket *so,
1569     struct label *solabel)
1570 {
1571
1572         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1573         LABEL_CHECK(solabel, MAGIC_SOCKET);
1574         COUNTER_INC(socket_check_stat);
1575
1576         return (0);
1577 }
1578
1579 COUNTER_DECL(socket_check_visible);
1580 static int
1581 test_socket_check_visible(struct ucred *cred, struct socket *so,
1582     struct label *solabel)
1583 {
1584
1585         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1586         LABEL_CHECK(solabel, MAGIC_SOCKET);
1587         COUNTER_INC(socket_check_visible);
1588
1589         return (0);
1590 }
1591
1592 COUNTER_DECL(socket_copy_label);
1593 static void
1594 test_socket_copy_label(struct label *src, struct label *dest)
1595 {
1596
1597         LABEL_CHECK(src, MAGIC_SOCKET);
1598         LABEL_CHECK(dest, MAGIC_SOCKET);
1599         COUNTER_INC(socket_copy_label);
1600 }
1601
1602 COUNTER_DECL(socket_create);
1603 static void
1604 test_socket_create(struct ucred *cred, struct socket *so,
1605     struct label *solabel)
1606 {
1607
1608         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1609         LABEL_CHECK(solabel, MAGIC_SOCKET);
1610         COUNTER_INC(socket_create);
1611 }
1612
1613 COUNTER_DECL(socket_create_mbuf);
1614 static void
1615 test_socket_create_mbuf(struct socket *so, struct label *socketlabel,
1616     struct mbuf *m, struct label *mlabel)
1617 {
1618
1619         LABEL_CHECK(socketlabel, MAGIC_SOCKET);
1620         LABEL_CHECK(mlabel, MAGIC_MBUF);
1621         COUNTER_INC(socket_create_mbuf);
1622 }
1623
1624 COUNTER_DECL(socket_destroy_label);
1625 static void
1626 test_socket_destroy_label(struct label *label)
1627 {
1628
1629         LABEL_DESTROY(label, MAGIC_SOCKET);
1630         COUNTER_INC(socket_destroy_label);
1631 }
1632
1633 COUNTER_DECL(socket_externalize_label);
1634 static int
1635 test_socket_externalize_label(struct label *label, char *element_name,
1636     struct sbuf *sb, int *claimed)
1637 {
1638
1639         LABEL_CHECK(label, MAGIC_SOCKET);
1640         COUNTER_INC(socket_externalize_label);
1641
1642         return (0);
1643 }
1644
1645 COUNTER_DECL(socket_init_label);
1646 static int
1647 test_socket_init_label(struct label *label, int flag)
1648 {
1649
1650         if (flag & M_WAITOK)
1651                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1652                     "test_socket_init_label() at %s:%d", __FILE__,
1653                     __LINE__);
1654
1655         LABEL_INIT(label, MAGIC_SOCKET);
1656         COUNTER_INC(socket_init_label);
1657         return (0);
1658 }
1659
1660 COUNTER_DECL(socket_internalize_label);
1661 static int
1662 test_socket_internalize_label(struct label *label, char *element_name,
1663     char *element_data, int *claimed)
1664 {
1665
1666         LABEL_CHECK(label, MAGIC_SOCKET);
1667         COUNTER_INC(socket_internalize_label);
1668
1669         return (0);
1670 }
1671
1672 COUNTER_DECL(socket_newconn);
1673 static void
1674 test_socket_newconn(struct socket *oldso, struct label *oldsolabel,
1675     struct socket *newso, struct label *newsolabel)
1676 {
1677
1678         LABEL_CHECK(oldsolabel, MAGIC_SOCKET);
1679         LABEL_CHECK(newsolabel, MAGIC_SOCKET);
1680         COUNTER_INC(socket_newconn);
1681 }
1682
1683 COUNTER_DECL(socket_relabel);
1684 static void
1685 test_socket_relabel(struct ucred *cred, struct socket *so,
1686     struct label *solabel, struct label *newlabel)
1687 {
1688
1689         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1690         LABEL_CHECK(solabel, MAGIC_SOCKET);
1691         LABEL_CHECK(newlabel, MAGIC_SOCKET);
1692         COUNTER_INC(socket_relabel);
1693 }
1694
1695 COUNTER_DECL(socketpeer_destroy_label);
1696 static void
1697 test_socketpeer_destroy_label(struct label *label)
1698 {
1699
1700         LABEL_DESTROY(label, MAGIC_SOCKET);
1701         COUNTER_INC(socketpeer_destroy_label);
1702 }
1703
1704 COUNTER_DECL(socketpeer_externalize_label);
1705 static int
1706 test_socketpeer_externalize_label(struct label *label, char *element_name,
1707     struct sbuf *sb, int *claimed)
1708 {
1709
1710         LABEL_CHECK(label, MAGIC_SOCKET);
1711         COUNTER_INC(socketpeer_externalize_label);
1712
1713         return (0);
1714 }
1715
1716 COUNTER_DECL(socketpeer_init_label);
1717 static int
1718 test_socketpeer_init_label(struct label *label, int flag)
1719 {
1720
1721         if (flag & M_WAITOK)
1722                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1723                     "test_socketpeer_init_label() at %s:%d", __FILE__,
1724                     __LINE__);
1725
1726         LABEL_INIT(label, MAGIC_SOCKET);
1727         COUNTER_INC(socketpeer_init_label);
1728         return (0);
1729 }
1730
1731 COUNTER_DECL(socketpeer_set_from_mbuf);
1732 static void
1733 test_socketpeer_set_from_mbuf(struct mbuf *m, struct label *mlabel,
1734     struct socket *socket, struct label *socketpeerlabel)
1735 {
1736
1737         LABEL_CHECK(mlabel, MAGIC_MBUF);
1738         LABEL_CHECK(socketpeerlabel, MAGIC_SOCKET);
1739         COUNTER_INC(socketpeer_set_from_mbuf);
1740 }
1741
1742 COUNTER_DECL(socketpeer_set_from_socket);
1743 static void
1744 test_socketpeer_set_from_socket(struct socket *oldso,
1745     struct label *oldsolabel, struct socket *newso,
1746     struct label *newsopeerlabel)
1747 {
1748
1749         LABEL_CHECK(oldsolabel, MAGIC_SOCKET);
1750         LABEL_CHECK(newsopeerlabel, MAGIC_SOCKET);
1751         COUNTER_INC(socketpeer_set_from_socket);
1752 }
1753
1754 COUNTER_DECL(syncache_create);
1755 static void
1756 test_syncache_create(struct label *label, struct inpcb *inp)
1757 {
1758
1759         LABEL_CHECK(label, MAGIC_SYNCACHE);
1760         COUNTER_INC(syncache_create);
1761 }
1762
1763 COUNTER_DECL(syncache_create_mbuf);
1764 static void
1765 test_syncache_create_mbuf(struct label *sc_label, struct mbuf *m,
1766     struct label *mlabel)
1767 {
1768
1769         LABEL_CHECK(sc_label, MAGIC_SYNCACHE);
1770         LABEL_CHECK(mlabel, MAGIC_MBUF);
1771         COUNTER_INC(syncache_create_mbuf);
1772 }
1773
1774 COUNTER_DECL(syncache_destroy_label);
1775 static void
1776 test_syncache_destroy_label(struct label *label)
1777 {
1778
1779         LABEL_DESTROY(label, MAGIC_SYNCACHE);
1780         COUNTER_INC(syncache_destroy_label);
1781 }
1782
1783 COUNTER_DECL(syncache_init_label);
1784 static int
1785 test_syncache_init_label(struct label *label, int flag)
1786 {
1787
1788         if (flag & M_WAITOK)
1789                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1790                     "test_syncache_init_label() at %s:%d", __FILE__,
1791                     __LINE__);
1792         LABEL_INIT(label, MAGIC_SYNCACHE);
1793         COUNTER_INC(syncache_init_label);
1794         return (0);
1795 }
1796
1797 COUNTER_DECL(system_check_acct);
1798 static int
1799 test_system_check_acct(struct ucred *cred, struct vnode *vp,
1800     struct label *vplabel)
1801 {
1802
1803         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1804         LABEL_CHECK(vplabel, MAGIC_VNODE);
1805         COUNTER_INC(system_check_acct);
1806
1807         return (0);
1808 }
1809
1810 COUNTER_DECL(system_check_audit);
1811 static int
1812 test_system_check_audit(struct ucred *cred, void *record, int length)
1813 {
1814
1815         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1816         COUNTER_INC(system_check_audit);
1817
1818         return (0);
1819 }
1820
1821 COUNTER_DECL(system_check_auditctl);
1822 static int
1823 test_system_check_auditctl(struct ucred *cred, struct vnode *vp,
1824     struct label *vplabel)
1825 {
1826
1827         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1828         LABEL_CHECK(vplabel, MAGIC_VNODE);
1829         COUNTER_INC(system_check_auditctl);
1830
1831         return (0);
1832 }
1833
1834 COUNTER_DECL(system_check_auditon);
1835 static int
1836 test_system_check_auditon(struct ucred *cred, int cmd)
1837 {
1838
1839         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1840         COUNTER_INC(system_check_auditon);
1841
1842         return (0);
1843 }
1844
1845 COUNTER_DECL(system_check_reboot);
1846 static int
1847 test_system_check_reboot(struct ucred *cred, int how)
1848 {
1849
1850         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1851         COUNTER_INC(system_check_reboot);
1852
1853         return (0);
1854 }
1855
1856 COUNTER_DECL(system_check_swapoff);
1857 static int
1858 test_system_check_swapoff(struct ucred *cred, struct vnode *vp,
1859     struct label *vplabel)
1860 {
1861
1862         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1863         LABEL_CHECK(vplabel, MAGIC_VNODE);
1864         COUNTER_INC(system_check_swapoff);
1865
1866         return (0);
1867 }
1868
1869 COUNTER_DECL(system_check_swapon);
1870 static int
1871 test_system_check_swapon(struct ucred *cred, struct vnode *vp,
1872     struct label *vplabel)
1873 {
1874
1875         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1876         LABEL_CHECK(vplabel, MAGIC_VNODE);
1877         COUNTER_INC(system_check_swapon);
1878
1879         return (0);
1880 }
1881
1882 COUNTER_DECL(system_check_sysctl);
1883 static int
1884 test_system_check_sysctl(struct ucred *cred, struct sysctl_oid *oidp,
1885     void *arg1, int arg2, struct sysctl_req *req)
1886 {
1887
1888         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1889         COUNTER_INC(system_check_sysctl);
1890
1891         return (0);
1892 }
1893
1894 COUNTER_DECL(sysvmsg_cleanup);
1895 static void
1896 test_sysvmsg_cleanup(struct label *msglabel)
1897 {
1898
1899         LABEL_CHECK(msglabel, MAGIC_SYSV_MSG);
1900         COUNTER_INC(sysvmsg_cleanup);
1901 }
1902
1903 COUNTER_DECL(sysvmsg_create);
1904 static void
1905 test_sysvmsg_create(struct ucred *cred, struct msqid_kernel *msqkptr,
1906     struct label *msqlabel, struct msg *msgptr, struct label *msglabel)
1907 {
1908
1909         LABEL_CHECK(msglabel, MAGIC_SYSV_MSG);
1910         LABEL_CHECK(msqlabel, MAGIC_SYSV_MSQ);
1911         COUNTER_INC(sysvmsg_create);
1912 }
1913
1914 COUNTER_DECL(sysvmsg_destroy_label);
1915 static void
1916 test_sysvmsg_destroy_label(struct label *label)
1917 {
1918
1919         LABEL_DESTROY(label, MAGIC_SYSV_MSG);
1920         COUNTER_INC(sysvmsg_destroy_label);
1921 }
1922
1923 COUNTER_DECL(sysvmsg_init_label);
1924 static void
1925 test_sysvmsg_init_label(struct label *label)
1926 {
1927         LABEL_INIT(label, MAGIC_SYSV_MSG);
1928         COUNTER_INC(sysvmsg_init_label);
1929 }
1930
1931 COUNTER_DECL(sysvmsq_check_msgmsq);
1932 static int
1933 test_sysvmsq_check_msgmsq(struct ucred *cred, struct msg *msgptr,
1934     struct label *msglabel, struct msqid_kernel *msqkptr,
1935     struct label *msqklabel)
1936 {
1937
1938         LABEL_CHECK(msqklabel, MAGIC_SYSV_MSQ);
1939         LABEL_CHECK(msglabel, MAGIC_SYSV_MSG);
1940         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1941         COUNTER_INC(sysvmsq_check_msgmsq);
1942
1943         return (0);
1944 }
1945
1946 COUNTER_DECL(sysvmsq_check_msgrcv);
1947 static int
1948 test_sysvmsq_check_msgrcv(struct ucred *cred, struct msg *msgptr,
1949     struct label *msglabel)
1950 {
1951
1952         LABEL_CHECK(msglabel, MAGIC_SYSV_MSG);
1953         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1954         COUNTER_INC(sysvmsq_check_msgrcv);
1955
1956         return (0);
1957 }
1958
1959 COUNTER_DECL(sysvmsq_check_msgrmid);
1960 static int
1961 test_sysvmsq_check_msgrmid(struct ucred *cred, struct msg *msgptr,
1962     struct label *msglabel)
1963 {
1964
1965         LABEL_CHECK(msglabel, MAGIC_SYSV_MSG);
1966         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1967         COUNTER_INC(sysvmsq_check_msgrmid);
1968
1969         return (0);
1970 }
1971
1972 COUNTER_DECL(sysvmsq_check_msqget);
1973 static int
1974 test_sysvmsq_check_msqget(struct ucred *cred,
1975     struct msqid_kernel *msqkptr, struct label *msqklabel)
1976 {
1977
1978         LABEL_CHECK(msqklabel, MAGIC_SYSV_MSQ);
1979         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1980         COUNTER_INC(sysvmsq_check_msqget);
1981
1982         return (0);
1983 }
1984
1985 COUNTER_DECL(sysvmsq_check_msqsnd);
1986 static int
1987 test_sysvmsq_check_msqsnd(struct ucred *cred,
1988     struct msqid_kernel *msqkptr, struct label *msqklabel)
1989 {
1990
1991         LABEL_CHECK(msqklabel, MAGIC_SYSV_MSQ);
1992         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
1993         COUNTER_INC(sysvmsq_check_msqsnd);
1994
1995         return (0);
1996 }
1997
1998 COUNTER_DECL(sysvmsq_check_msqrcv);
1999 static int
2000 test_sysvmsq_check_msqrcv(struct ucred *cred,
2001     struct msqid_kernel *msqkptr, struct label *msqklabel)
2002 {
2003
2004         LABEL_CHECK(msqklabel, MAGIC_SYSV_MSQ);
2005         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2006         COUNTER_INC(sysvmsq_check_msqrcv);
2007
2008         return (0);
2009 }
2010
2011 COUNTER_DECL(sysvmsq_check_msqctl);
2012 static int
2013 test_sysvmsq_check_msqctl(struct ucred *cred,
2014     struct msqid_kernel *msqkptr, struct label *msqklabel, int cmd)
2015 {
2016
2017         LABEL_CHECK(msqklabel, MAGIC_SYSV_MSQ);
2018         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2019         COUNTER_INC(sysvmsq_check_msqctl);
2020
2021         return (0);
2022 }
2023
2024 COUNTER_DECL(sysvmsq_cleanup);
2025 static void
2026 test_sysvmsq_cleanup(struct label *msqlabel)
2027 {
2028
2029         LABEL_CHECK(msqlabel, MAGIC_SYSV_MSQ);
2030         COUNTER_INC(sysvmsq_cleanup);
2031 }
2032
2033 COUNTER_DECL(sysvmsq_create);
2034 static void
2035 test_sysvmsq_create(struct ucred *cred,
2036     struct msqid_kernel *msqkptr, struct label *msqlabel)
2037 {
2038
2039         LABEL_CHECK(msqlabel, MAGIC_SYSV_MSQ);
2040         COUNTER_INC(sysvmsq_create);
2041 }
2042
2043 COUNTER_DECL(sysvmsq_destroy_label);
2044 static void
2045 test_sysvmsq_destroy_label(struct label *label)
2046 {
2047
2048         LABEL_DESTROY(label, MAGIC_SYSV_MSQ);
2049         COUNTER_INC(sysvmsq_destroy_label);
2050 }
2051
2052 COUNTER_DECL(sysvmsq_init_label);
2053 static void
2054 test_sysvmsq_init_label(struct label *label)
2055 {
2056         LABEL_INIT(label, MAGIC_SYSV_MSQ);
2057         COUNTER_INC(sysvmsq_init_label);
2058 }
2059
2060 COUNTER_DECL(sysvsem_check_semctl);
2061 static int
2062 test_sysvsem_check_semctl(struct ucred *cred,
2063     struct semid_kernel *semakptr, struct label *semaklabel, int cmd)
2064 {
2065
2066         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2067         LABEL_CHECK(semaklabel, MAGIC_SYSV_SEM);
2068         COUNTER_INC(sysvsem_check_semctl);
2069
2070         return (0);
2071 }
2072
2073 COUNTER_DECL(sysvsem_check_semget);
2074 static int
2075 test_sysvsem_check_semget(struct ucred *cred,
2076     struct semid_kernel *semakptr, struct label *semaklabel)
2077 {
2078
2079         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2080         LABEL_CHECK(semaklabel, MAGIC_SYSV_SEM);
2081         COUNTER_INC(sysvsem_check_semget);
2082
2083         return (0);
2084 }
2085
2086 COUNTER_DECL(sysvsem_check_semop);
2087 static int
2088 test_sysvsem_check_semop(struct ucred *cred,
2089     struct semid_kernel *semakptr, struct label *semaklabel, size_t accesstype)
2090 {
2091
2092         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2093         LABEL_CHECK(semaklabel, MAGIC_SYSV_SEM);
2094         COUNTER_INC(sysvsem_check_semop);
2095
2096         return (0);
2097 }
2098
2099 COUNTER_DECL(sysvsem_cleanup);
2100 static void
2101 test_sysvsem_cleanup(struct label *semalabel)
2102 {
2103
2104         LABEL_CHECK(semalabel, MAGIC_SYSV_SEM);
2105         COUNTER_INC(sysvsem_cleanup);
2106 }
2107
2108 COUNTER_DECL(sysvsem_create);
2109 static void
2110 test_sysvsem_create(struct ucred *cred, struct semid_kernel *semakptr,
2111     struct label *semalabel)
2112 {
2113
2114         LABEL_CHECK(semalabel, MAGIC_SYSV_SEM);
2115         COUNTER_INC(sysvsem_create);
2116 }
2117
2118 COUNTER_DECL(sysvsem_destroy_label);
2119 static void
2120 test_sysvsem_destroy_label(struct label *label)
2121 {
2122
2123         LABEL_DESTROY(label, MAGIC_SYSV_SEM);
2124         COUNTER_INC(sysvsem_destroy_label);
2125 }
2126
2127 COUNTER_DECL(sysvsem_init_label);
2128 static void
2129 test_sysvsem_init_label(struct label *label)
2130 {
2131         LABEL_INIT(label, MAGIC_SYSV_SEM);
2132         COUNTER_INC(sysvsem_init_label);
2133 }
2134
2135 COUNTER_DECL(sysvshm_check_shmat);
2136 static int
2137 test_sysvshm_check_shmat(struct ucred *cred,
2138     struct shmid_kernel *shmsegptr, struct label *shmseglabel, int shmflg)
2139 {
2140
2141         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2142         LABEL_CHECK(shmseglabel, MAGIC_SYSV_SHM);
2143         COUNTER_INC(sysvshm_check_shmat);
2144
2145         return (0);
2146 }
2147
2148 COUNTER_DECL(sysvshm_check_shmctl);
2149 static int
2150 test_sysvshm_check_shmctl(struct ucred *cred,
2151     struct shmid_kernel *shmsegptr, struct label *shmseglabel, int cmd)
2152 {
2153
2154         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2155         LABEL_CHECK(shmseglabel, MAGIC_SYSV_SHM);
2156         COUNTER_INC(sysvshm_check_shmctl);
2157
2158         return (0);
2159 }
2160
2161 COUNTER_DECL(sysvshm_check_shmdt);
2162 static int
2163 test_sysvshm_check_shmdt(struct ucred *cred,
2164     struct shmid_kernel *shmsegptr, struct label *shmseglabel)
2165 {
2166
2167         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2168         LABEL_CHECK(shmseglabel, MAGIC_SYSV_SHM);
2169         COUNTER_INC(sysvshm_check_shmdt);
2170
2171         return (0);
2172 }
2173
2174 COUNTER_DECL(sysvshm_check_shmget);
2175 static int
2176 test_sysvshm_check_shmget(struct ucred *cred,
2177     struct shmid_kernel *shmsegptr, struct label *shmseglabel, int shmflg)
2178 {
2179
2180         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2181         LABEL_CHECK(shmseglabel, MAGIC_SYSV_SHM);
2182         COUNTER_INC(sysvshm_check_shmget);
2183
2184         return (0);
2185 }
2186
2187 COUNTER_DECL(sysvshm_cleanup);
2188 static void
2189 test_sysvshm_cleanup(struct label *shmlabel)
2190 {
2191
2192         LABEL_CHECK(shmlabel, MAGIC_SYSV_SHM);
2193         COUNTER_INC(sysvshm_cleanup);
2194 }
2195
2196 COUNTER_DECL(sysvshm_create);
2197 static void
2198 test_sysvshm_create(struct ucred *cred, struct shmid_kernel *shmsegptr,
2199     struct label *shmlabel)
2200 {
2201
2202         LABEL_CHECK(shmlabel, MAGIC_SYSV_SHM);
2203         COUNTER_INC(sysvshm_create);
2204 }
2205
2206 COUNTER_DECL(sysvshm_destroy_label);
2207 static void
2208 test_sysvshm_destroy_label(struct label *label)
2209 {
2210
2211         LABEL_DESTROY(label, MAGIC_SYSV_SHM);
2212         COUNTER_INC(sysvshm_destroy_label);
2213 }
2214
2215 COUNTER_DECL(sysvshm_init_label);
2216 static void
2217 test_sysvshm_init_label(struct label *label)
2218 {
2219         LABEL_INIT(label, MAGIC_SYSV_SHM);
2220         COUNTER_INC(sysvshm_init_label);
2221 }
2222
2223 COUNTER_DECL(thread_userret);
2224 static void
2225 test_thread_userret(struct thread *td)
2226 {
2227
2228         COUNTER_INC(thread_userret);
2229 }
2230
2231 COUNTER_DECL(vnode_associate_extattr);
2232 static int
2233 test_vnode_associate_extattr(struct mount *mp, struct label *mplabel,
2234     struct vnode *vp, struct label *vplabel)
2235 {
2236
2237         LABEL_CHECK(mplabel, MAGIC_MOUNT);
2238         LABEL_CHECK(vplabel, MAGIC_VNODE);
2239         COUNTER_INC(vnode_associate_extattr);
2240
2241         return (0);
2242 }
2243
2244 COUNTER_DECL(vnode_associate_singlelabel);
2245 static void
2246 test_vnode_associate_singlelabel(struct mount *mp, struct label *mplabel,
2247     struct vnode *vp, struct label *vplabel)
2248 {
2249
2250         LABEL_CHECK(mplabel, MAGIC_MOUNT);
2251         LABEL_CHECK(vplabel, MAGIC_VNODE);
2252         COUNTER_INC(vnode_associate_singlelabel);
2253 }
2254
2255 COUNTER_DECL(vnode_check_access);
2256 static int
2257 test_vnode_check_access(struct ucred *cred, struct vnode *vp,
2258     struct label *vplabel, int acc_mode)
2259 {
2260
2261         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2262         LABEL_CHECK(vplabel, MAGIC_VNODE);
2263         COUNTER_INC(vnode_check_access);
2264
2265         return (0);
2266 }
2267
2268 COUNTER_DECL(vnode_check_chdir);
2269 static int
2270 test_vnode_check_chdir(struct ucred *cred, struct vnode *dvp,
2271     struct label *dvplabel)
2272 {
2273
2274         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2275         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2276         COUNTER_INC(vnode_check_chdir);
2277
2278         return (0);
2279 }
2280
2281 COUNTER_DECL(vnode_check_chroot);
2282 static int
2283 test_vnode_check_chroot(struct ucred *cred, struct vnode *dvp,
2284     struct label *dvplabel)
2285 {
2286
2287         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2288         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2289         COUNTER_INC(vnode_check_chroot);
2290
2291         return (0);
2292 }
2293
2294 COUNTER_DECL(vnode_check_create);
2295 static int
2296 test_vnode_check_create(struct ucred *cred, struct vnode *dvp,
2297     struct label *dvplabel, struct componentname *cnp, struct vattr *vap)
2298 {
2299
2300         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2301         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2302         COUNTER_INC(vnode_check_create);
2303
2304         return (0);
2305 }
2306
2307 COUNTER_DECL(vnode_check_deleteacl);
2308 static int
2309 test_vnode_check_deleteacl(struct ucred *cred, struct vnode *vp,
2310     struct label *vplabel, acl_type_t type)
2311 {
2312
2313         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2314         LABEL_CHECK(vplabel, MAGIC_VNODE);
2315         COUNTER_INC(vnode_check_deleteacl);
2316
2317         return (0);
2318 }
2319
2320 COUNTER_DECL(vnode_check_deleteextattr);
2321 static int
2322 test_vnode_check_deleteextattr(struct ucred *cred, struct vnode *vp,
2323     struct label *vplabel, int attrnamespace, const char *name)
2324 {
2325
2326         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2327         LABEL_CHECK(vplabel, MAGIC_VNODE);
2328         COUNTER_INC(vnode_check_deleteextattr);
2329
2330         return (0);
2331 }
2332
2333 COUNTER_DECL(vnode_check_exec);
2334 static int
2335 test_vnode_check_exec(struct ucred *cred, struct vnode *vp,
2336     struct label *vplabel, struct image_params *imgp,
2337     struct label *execlabel)
2338 {
2339
2340         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2341         LABEL_CHECK(vplabel, MAGIC_VNODE);
2342         LABEL_CHECK(execlabel, MAGIC_CRED);
2343         COUNTER_INC(vnode_check_exec);
2344
2345         return (0);
2346 }
2347
2348 COUNTER_DECL(vnode_check_getacl);
2349 static int
2350 test_vnode_check_getacl(struct ucred *cred, struct vnode *vp,
2351     struct label *vplabel, acl_type_t type)
2352 {
2353
2354         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2355         LABEL_CHECK(vplabel, MAGIC_VNODE);
2356         COUNTER_INC(vnode_check_getacl);
2357
2358         return (0);
2359 }
2360
2361 COUNTER_DECL(vnode_check_getextattr);
2362 static int
2363 test_vnode_check_getextattr(struct ucred *cred, struct vnode *vp,
2364     struct label *vplabel, int attrnamespace, const char *name,
2365     struct uio *uio)
2366 {
2367
2368         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2369         LABEL_CHECK(vplabel, MAGIC_VNODE);
2370         COUNTER_INC(vnode_check_getextattr);
2371
2372         return (0);
2373 }
2374
2375 COUNTER_DECL(vnode_check_link);
2376 static int
2377 test_vnode_check_link(struct ucred *cred, struct vnode *dvp,
2378     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2379     struct componentname *cnp)
2380 {
2381
2382         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2383         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2384         LABEL_CHECK(vplabel, MAGIC_VNODE);
2385         COUNTER_INC(vnode_check_link);
2386
2387         return (0);
2388 }
2389
2390 COUNTER_DECL(vnode_check_listextattr);
2391 static int
2392 test_vnode_check_listextattr(struct ucred *cred, struct vnode *vp,
2393     struct label *vplabel, int attrnamespace)
2394 {
2395
2396         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2397         LABEL_CHECK(vplabel, MAGIC_VNODE);
2398         COUNTER_INC(vnode_check_listextattr);
2399
2400         return (0);
2401 }
2402
2403 COUNTER_DECL(vnode_check_lookup);
2404 static int
2405 test_vnode_check_lookup(struct ucred *cred, struct vnode *dvp,
2406     struct label *dvplabel, struct componentname *cnp)
2407 {
2408
2409         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2410         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2411         COUNTER_INC(vnode_check_lookup);
2412
2413         return (0);
2414 }
2415
2416 COUNTER_DECL(vnode_check_mmap);
2417 static int
2418 test_vnode_check_mmap(struct ucred *cred, struct vnode *vp,
2419     struct label *vplabel, int prot, int flags)
2420 {
2421
2422         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2423         LABEL_CHECK(vplabel, MAGIC_VNODE);
2424         COUNTER_INC(vnode_check_mmap);
2425
2426         return (0);
2427 }
2428
2429 COUNTER_DECL(vnode_check_open);
2430 static int
2431 test_vnode_check_open(struct ucred *cred, struct vnode *vp,
2432     struct label *vplabel, int acc_mode)
2433 {
2434
2435         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2436         LABEL_CHECK(vplabel, MAGIC_VNODE);
2437         COUNTER_INC(vnode_check_open);
2438
2439         return (0);
2440 }
2441
2442 COUNTER_DECL(vnode_check_poll);
2443 static int
2444 test_vnode_check_poll(struct ucred *active_cred, struct ucred *file_cred,
2445     struct vnode *vp, struct label *vplabel)
2446 {
2447
2448         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
2449         if (file_cred != NULL)
2450                 LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
2451         LABEL_CHECK(vplabel, MAGIC_VNODE);
2452         COUNTER_INC(vnode_check_poll);
2453
2454         return (0);
2455 }
2456
2457 COUNTER_DECL(vnode_check_read);
2458 static int
2459 test_vnode_check_read(struct ucred *active_cred, struct ucred *file_cred,
2460     struct vnode *vp, struct label *vplabel)
2461 {
2462
2463         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
2464         if (file_cred != NULL)
2465                 LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
2466         LABEL_CHECK(vplabel, MAGIC_VNODE);
2467         COUNTER_INC(vnode_check_read);
2468
2469         return (0);
2470 }
2471
2472 COUNTER_DECL(vnode_check_readdir);
2473 static int
2474 test_vnode_check_readdir(struct ucred *cred, struct vnode *dvp,
2475     struct label *dvplabel)
2476 {
2477
2478         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2479         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2480         COUNTER_INC(vnode_check_readdir);
2481
2482         return (0);
2483 }
2484
2485 COUNTER_DECL(vnode_check_readlink);
2486 static int
2487 test_vnode_check_readlink(struct ucred *cred, struct vnode *vp,
2488     struct label *vplabel)
2489 {
2490
2491         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2492         LABEL_CHECK(vplabel, MAGIC_VNODE);
2493         COUNTER_INC(vnode_check_readlink);
2494
2495         return (0);
2496 }
2497
2498 COUNTER_DECL(vnode_check_relabel);
2499 static int
2500 test_vnode_check_relabel(struct ucred *cred, struct vnode *vp,
2501     struct label *vplabel, struct label *newlabel)
2502 {
2503
2504         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2505         LABEL_CHECK(vplabel, MAGIC_VNODE);
2506         LABEL_CHECK(newlabel, MAGIC_VNODE);
2507         COUNTER_INC(vnode_check_relabel);
2508
2509         return (0);
2510 }
2511
2512 COUNTER_DECL(vnode_check_rename_from);
2513 static int
2514 test_vnode_check_rename_from(struct ucred *cred, struct vnode *dvp,
2515     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2516     struct componentname *cnp)
2517 {
2518
2519         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2520         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2521         LABEL_CHECK(vplabel, MAGIC_VNODE);
2522         COUNTER_INC(vnode_check_rename_from);
2523
2524         return (0);
2525 }
2526
2527 COUNTER_DECL(vnode_check_rename_to);
2528 static int
2529 test_vnode_check_rename_to(struct ucred *cred, struct vnode *dvp,
2530     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2531     int samedir, struct componentname *cnp)
2532 {
2533
2534         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2535         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2536         LABEL_CHECK(vplabel, MAGIC_VNODE);
2537         COUNTER_INC(vnode_check_rename_to);
2538
2539         return (0);
2540 }
2541
2542 COUNTER_DECL(vnode_check_revoke);
2543 static int
2544 test_vnode_check_revoke(struct ucred *cred, struct vnode *vp,
2545     struct label *vplabel)
2546 {
2547
2548         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2549         LABEL_CHECK(vplabel, MAGIC_VNODE);
2550         COUNTER_INC(vnode_check_revoke);
2551
2552         return (0);
2553 }
2554
2555 COUNTER_DECL(vnode_check_setacl);
2556 static int
2557 test_vnode_check_setacl(struct ucred *cred, struct vnode *vp,
2558     struct label *vplabel, acl_type_t type, struct acl *acl)
2559 {
2560
2561         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2562         LABEL_CHECK(vplabel, MAGIC_VNODE);
2563         COUNTER_INC(vnode_check_setacl);
2564
2565         return (0);
2566 }
2567
2568 COUNTER_DECL(vnode_check_setextattr);
2569 static int
2570 test_vnode_check_setextattr(struct ucred *cred, struct vnode *vp,
2571     struct label *vplabel, int attrnamespace, const char *name,
2572     struct uio *uio)
2573 {
2574
2575         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2576         LABEL_CHECK(vplabel, MAGIC_VNODE);
2577         COUNTER_INC(vnode_check_setextattr);
2578
2579         return (0);
2580 }
2581
2582 COUNTER_DECL(vnode_check_setflags);
2583 static int
2584 test_vnode_check_setflags(struct ucred *cred, struct vnode *vp,
2585     struct label *vplabel, u_long flags)
2586 {
2587
2588         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2589         LABEL_CHECK(vplabel, MAGIC_VNODE);
2590         COUNTER_INC(vnode_check_setflags);
2591
2592         return (0);
2593 }
2594
2595 COUNTER_DECL(vnode_check_setmode);
2596 static int
2597 test_vnode_check_setmode(struct ucred *cred, struct vnode *vp,
2598     struct label *vplabel, mode_t mode)
2599 {
2600
2601         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2602         LABEL_CHECK(vplabel, MAGIC_VNODE);
2603         COUNTER_INC(vnode_check_setmode);
2604
2605         return (0);
2606 }
2607
2608 COUNTER_DECL(vnode_check_setowner);
2609 static int
2610 test_vnode_check_setowner(struct ucred *cred, struct vnode *vp,
2611     struct label *vplabel, uid_t uid, gid_t gid)
2612 {
2613
2614         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2615         LABEL_CHECK(vplabel, MAGIC_VNODE);
2616         COUNTER_INC(vnode_check_setowner);
2617
2618         return (0);
2619 }
2620
2621 COUNTER_DECL(vnode_check_setutimes);
2622 static int
2623 test_vnode_check_setutimes(struct ucred *cred, struct vnode *vp,
2624     struct label *vplabel, struct timespec atime, struct timespec mtime)
2625 {
2626
2627         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2628         LABEL_CHECK(vplabel, MAGIC_VNODE);
2629         COUNTER_INC(vnode_check_setutimes);
2630
2631         return (0);
2632 }
2633
2634 COUNTER_DECL(vnode_check_stat);
2635 static int
2636 test_vnode_check_stat(struct ucred *active_cred, struct ucred *file_cred,
2637     struct vnode *vp, struct label *vplabel)
2638 {
2639
2640         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
2641         if (file_cred != NULL)
2642                 LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
2643         LABEL_CHECK(vplabel, MAGIC_VNODE);
2644         COUNTER_INC(vnode_check_stat);
2645
2646         return (0);
2647 }
2648
2649 COUNTER_DECL(vnode_check_unlink);
2650 static int
2651 test_vnode_check_unlink(struct ucred *cred, struct vnode *dvp,
2652     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2653     struct componentname *cnp)
2654 {
2655
2656         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2657         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2658         LABEL_CHECK(vplabel, MAGIC_VNODE);
2659         COUNTER_INC(vnode_check_unlink);
2660
2661         return (0);
2662 }
2663
2664 COUNTER_DECL(vnode_check_write);
2665 static int
2666 test_vnode_check_write(struct ucred *active_cred,
2667     struct ucred *file_cred, struct vnode *vp, struct label *vplabel)
2668 {
2669
2670         LABEL_CHECK(active_cred->cr_label, MAGIC_CRED);
2671         if (file_cred != NULL)
2672                 LABEL_CHECK(file_cred->cr_label, MAGIC_CRED);
2673         LABEL_CHECK(vplabel, MAGIC_VNODE);
2674         COUNTER_INC(vnode_check_write);
2675
2676         return (0);
2677 }
2678
2679 COUNTER_DECL(vnode_copy_label);
2680 static void
2681 test_vnode_copy_label(struct label *src, struct label *dest)
2682 {
2683
2684         LABEL_CHECK(src, MAGIC_VNODE);
2685         LABEL_CHECK(dest, MAGIC_VNODE);
2686         COUNTER_INC(vnode_copy_label);
2687 }
2688
2689 COUNTER_DECL(vnode_create_extattr);
2690 static int
2691 test_vnode_create_extattr(struct ucred *cred, struct mount *mp,
2692     struct label *mplabel, struct vnode *dvp, struct label *dvplabel,
2693     struct vnode *vp, struct label *vplabel, struct componentname *cnp)
2694 {
2695
2696         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2697         LABEL_CHECK(mplabel, MAGIC_MOUNT);
2698         LABEL_CHECK(dvplabel, MAGIC_VNODE);
2699         COUNTER_INC(vnode_create_extattr);
2700
2701         return (0);
2702 }
2703
2704 COUNTER_DECL(vnode_destroy_label);
2705 static void
2706 test_vnode_destroy_label(struct label *label)
2707 {
2708
2709         LABEL_DESTROY(label, MAGIC_VNODE);
2710         COUNTER_INC(vnode_destroy_label);
2711 }
2712
2713 COUNTER_DECL(vnode_execve_transition);
2714 static void
2715 test_vnode_execve_transition(struct ucred *old, struct ucred *new,
2716     struct vnode *vp, struct label *filelabel,
2717     struct label *interpvplabel, struct image_params *imgp,
2718     struct label *execlabel)
2719 {
2720
2721         LABEL_CHECK(old->cr_label, MAGIC_CRED);
2722         LABEL_CHECK(new->cr_label, MAGIC_CRED);
2723         LABEL_CHECK(filelabel, MAGIC_VNODE);
2724         LABEL_CHECK(interpvplabel, MAGIC_VNODE);
2725         LABEL_CHECK(execlabel, MAGIC_CRED);
2726         COUNTER_INC(vnode_execve_transition);
2727 }
2728
2729 COUNTER_DECL(vnode_execve_will_transition);
2730 static int
2731 test_vnode_execve_will_transition(struct ucred *old, struct vnode *vp,
2732     struct label *filelabel, struct label *interpvplabel,
2733     struct image_params *imgp, struct label *execlabel)
2734 {
2735
2736         LABEL_CHECK(old->cr_label, MAGIC_CRED);
2737         LABEL_CHECK(filelabel, MAGIC_VNODE);
2738         LABEL_CHECK(interpvplabel, MAGIC_VNODE);
2739         LABEL_CHECK(execlabel, MAGIC_CRED);
2740         COUNTER_INC(vnode_execve_will_transition);
2741
2742         return (0);
2743 }
2744
2745 COUNTER_DECL(vnode_externalize_label);
2746 static int
2747 test_vnode_externalize_label(struct label *label, char *element_name,
2748     struct sbuf *sb, int *claimed)
2749 {
2750
2751         LABEL_CHECK(label, MAGIC_VNODE);
2752         COUNTER_INC(vnode_externalize_label);
2753
2754         return (0);
2755 }
2756
2757 COUNTER_DECL(vnode_init_label);
2758 static void
2759 test_vnode_init_label(struct label *label)
2760 {
2761
2762         LABEL_INIT(label, MAGIC_VNODE);
2763         COUNTER_INC(vnode_init_label);
2764 }
2765
2766 COUNTER_DECL(vnode_internalize_label);
2767 static int
2768 test_vnode_internalize_label(struct label *label, char *element_name,
2769     char *element_data, int *claimed)
2770 {
2771
2772         LABEL_CHECK(label, MAGIC_VNODE);
2773         COUNTER_INC(vnode_internalize_label);
2774
2775         return (0);
2776 }
2777
2778 COUNTER_DECL(vnode_relabel);
2779 static void
2780 test_vnode_relabel(struct ucred *cred, struct vnode *vp,
2781     struct label *vplabel, struct label *label)
2782 {
2783
2784         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2785         LABEL_CHECK(vplabel, MAGIC_VNODE);
2786         LABEL_CHECK(label, MAGIC_VNODE);
2787         COUNTER_INC(vnode_relabel);
2788 }
2789
2790 COUNTER_DECL(vnode_setlabel_extattr);
2791 static int
2792 test_vnode_setlabel_extattr(struct ucred *cred, struct vnode *vp,
2793     struct label *vplabel, struct label *intlabel)
2794 {
2795
2796         LABEL_CHECK(cred->cr_label, MAGIC_CRED);
2797         LABEL_CHECK(vplabel, MAGIC_VNODE);
2798         LABEL_CHECK(intlabel, MAGIC_VNODE);
2799         COUNTER_INC(vnode_setlabel_extattr);
2800
2801         return (0);
2802 }
2803
2804 static struct mac_policy_ops test_ops =
2805 {
2806         .mpo_bpfdesc_check_receive = test_bpfdesc_check_receive,
2807         .mpo_bpfdesc_create = test_bpfdesc_create,
2808         .mpo_bpfdesc_create_mbuf = test_bpfdesc_create_mbuf,
2809         .mpo_bpfdesc_destroy_label = test_bpfdesc_destroy_label,
2810         .mpo_bpfdesc_init_label = test_bpfdesc_init_label,
2811
2812         .mpo_cred_check_relabel = test_cred_check_relabel,
2813         .mpo_cred_check_visible = test_cred_check_visible,
2814         .mpo_cred_copy_label = test_cred_copy_label,
2815         .mpo_cred_destroy_label = test_cred_destroy_label,
2816         .mpo_cred_externalize_label = test_cred_externalize_label,
2817         .mpo_cred_init_label = test_cred_init_label,
2818         .mpo_cred_internalize_label = test_cred_internalize_label,
2819         .mpo_cred_relabel = test_cred_relabel,
2820
2821         .mpo_devfs_create_device = test_devfs_create_device,
2822         .mpo_devfs_create_directory = test_devfs_create_directory,
2823         .mpo_devfs_create_symlink = test_devfs_create_symlink,
2824         .mpo_devfs_destroy_label = test_devfs_destroy_label,
2825         .mpo_devfs_init_label = test_devfs_init_label,
2826         .mpo_devfs_update = test_devfs_update,
2827         .mpo_devfs_vnode_associate = test_devfs_vnode_associate,
2828
2829         .mpo_ifnet_check_relabel = test_ifnet_check_relabel,
2830         .mpo_ifnet_check_transmit = test_ifnet_check_transmit,
2831         .mpo_ifnet_copy_label = test_ifnet_copy_label,
2832         .mpo_ifnet_create = test_ifnet_create,
2833         .mpo_ifnet_create_mbuf = test_ifnet_create_mbuf,
2834         .mpo_ifnet_destroy_label = test_ifnet_destroy_label,
2835         .mpo_ifnet_externalize_label = test_ifnet_externalize_label,
2836         .mpo_ifnet_init_label = test_ifnet_init_label,
2837         .mpo_ifnet_internalize_label = test_ifnet_internalize_label,
2838         .mpo_ifnet_relabel = test_ifnet_relabel,
2839
2840         .mpo_syncache_destroy_label = test_syncache_destroy_label,
2841         .mpo_syncache_init_label = test_syncache_init_label,
2842
2843         .mpo_sysvmsg_destroy_label = test_sysvmsg_destroy_label,
2844         .mpo_sysvmsg_init_label = test_sysvmsg_init_label,
2845
2846         .mpo_sysvmsq_destroy_label = test_sysvmsq_destroy_label,
2847         .mpo_sysvmsq_init_label = test_sysvmsq_init_label,
2848
2849         .mpo_sysvsem_destroy_label = test_sysvsem_destroy_label,
2850         .mpo_sysvsem_init_label = test_sysvsem_init_label,
2851
2852         .mpo_sysvshm_destroy_label = test_sysvshm_destroy_label,
2853         .mpo_sysvshm_init_label = test_sysvshm_init_label,
2854
2855         .mpo_inpcb_check_deliver = test_inpcb_check_deliver,
2856         .mpo_inpcb_check_visible = test_inpcb_check_visible,
2857         .mpo_inpcb_create = test_inpcb_create,
2858         .mpo_inpcb_create_mbuf = test_inpcb_create_mbuf,
2859         .mpo_inpcb_destroy_label = test_inpcb_destroy_label,
2860         .mpo_inpcb_init_label = test_inpcb_init_label,
2861         .mpo_inpcb_sosetlabel = test_inpcb_sosetlabel,
2862
2863         .mpo_ipq_create = test_ipq_create,
2864         .mpo_ipq_destroy_label = test_ipq_destroy_label,
2865         .mpo_ipq_init_label = test_ipq_init_label,
2866         .mpo_ipq_match = test_ipq_match,
2867         .mpo_ipq_reassemble = test_ipq_reassemble,
2868         .mpo_ipq_update = test_ipq_update,
2869
2870         .mpo_kenv_check_dump = test_kenv_check_dump,
2871         .mpo_kenv_check_get = test_kenv_check_get,
2872         .mpo_kenv_check_set = test_kenv_check_set,
2873         .mpo_kenv_check_unset = test_kenv_check_unset,
2874
2875         .mpo_kld_check_load = test_kld_check_load,
2876         .mpo_kld_check_stat = test_kld_check_stat,
2877
2878         .mpo_mbuf_copy_label = test_mbuf_copy_label,
2879         .mpo_mbuf_destroy_label = test_mbuf_destroy_label,
2880         .mpo_mbuf_init_label = test_mbuf_init_label,
2881
2882         .mpo_mount_check_stat = test_mount_check_stat,
2883         .mpo_mount_create = test_mount_create,
2884         .mpo_mount_destroy_label = test_mount_destroy_label,
2885         .mpo_mount_init_label = test_mount_init_label,
2886
2887         .mpo_netatalk_aarp_send = test_netatalk_aarp_send,
2888
2889         .mpo_netinet_arp_send = test_netinet_arp_send,
2890         .mpo_netinet_fragment = test_netinet_fragment,
2891         .mpo_netinet_icmp_reply = test_netinet_icmp_reply,
2892         .mpo_netinet_icmp_replyinplace = test_netinet_icmp_replyinplace,
2893         .mpo_netinet_igmp_send = test_netinet_igmp_send,
2894         .mpo_netinet_tcp_reply = test_netinet_tcp_reply,
2895
2896         .mpo_netinet6_nd6_send = test_netinet6_nd6_send,
2897
2898         .mpo_pipe_check_ioctl = test_pipe_check_ioctl,
2899         .mpo_pipe_check_poll = test_pipe_check_poll,
2900         .mpo_pipe_check_read = test_pipe_check_read,
2901         .mpo_pipe_check_relabel = test_pipe_check_relabel,
2902         .mpo_pipe_check_stat = test_pipe_check_stat,
2903         .mpo_pipe_check_write = test_pipe_check_write,
2904         .mpo_pipe_copy_label = test_pipe_copy_label,
2905         .mpo_pipe_create = test_pipe_create,
2906         .mpo_pipe_destroy_label = test_pipe_destroy_label,
2907         .mpo_pipe_externalize_label = test_pipe_externalize_label,
2908         .mpo_pipe_init_label = test_pipe_init_label,
2909         .mpo_pipe_internalize_label = test_pipe_internalize_label,
2910         .mpo_pipe_relabel = test_pipe_relabel,
2911
2912         .mpo_posixsem_check_getvalue = test_posixsem_check_getvalue,
2913         .mpo_posixsem_check_open = test_posixsem_check_open,
2914         .mpo_posixsem_check_post = test_posixsem_check_post,
2915         .mpo_posixsem_check_stat = test_posixsem_check_stat,
2916         .mpo_posixsem_check_unlink = test_posixsem_check_unlink,
2917         .mpo_posixsem_check_wait = test_posixsem_check_wait,
2918         .mpo_posixsem_create = test_posixsem_create,
2919         .mpo_posixsem_destroy_label = test_posixsem_destroy_label,
2920         .mpo_posixsem_init_label = test_posixsem_init_label,
2921
2922         .mpo_posixshm_check_mmap = test_posixshm_check_mmap,
2923         .mpo_posixshm_check_open = test_posixshm_check_open,
2924         .mpo_posixshm_check_stat = test_posixshm_check_stat,
2925         .mpo_posixshm_check_truncate = test_posixshm_check_truncate,
2926         .mpo_posixshm_check_unlink = test_posixshm_check_unlink,
2927         .mpo_posixshm_create = test_posixshm_create,
2928         .mpo_posixshm_destroy_label = test_posixshm_destroy_label,
2929         .mpo_posixshm_init_label = test_posixshm_init_label,
2930
2931         .mpo_proc_check_debug = test_proc_check_debug,
2932         .mpo_proc_check_sched = test_proc_check_sched,
2933         .mpo_proc_check_setaudit = test_proc_check_setaudit,
2934         .mpo_proc_check_setaudit_addr = test_proc_check_setaudit_addr,
2935         .mpo_proc_check_setauid = test_proc_check_setauid,
2936         .mpo_proc_check_seteuid = test_proc_check_seteuid,
2937         .mpo_proc_check_setegid = test_proc_check_setegid,
2938         .mpo_proc_check_setgid = test_proc_check_setgid,
2939         .mpo_proc_check_setgroups = test_proc_check_setgroups,
2940         .mpo_proc_check_setregid = test_proc_check_setregid,
2941         .mpo_proc_check_setresgid = test_proc_check_setresgid,
2942         .mpo_proc_check_setresuid = test_proc_check_setresuid,
2943         .mpo_proc_check_setreuid = test_proc_check_setreuid,
2944         .mpo_proc_check_setuid = test_proc_check_setuid,
2945         .mpo_proc_check_signal = test_proc_check_signal,
2946         .mpo_proc_check_wait = test_proc_check_wait,
2947         .mpo_proc_create_init = test_proc_create_init,
2948         .mpo_proc_create_swapper = test_proc_create_swapper,
2949         .mpo_proc_destroy_label = test_proc_destroy_label,
2950         .mpo_proc_init_label = test_proc_init_label,
2951
2952         .mpo_socket_check_accept = test_socket_check_accept,
2953         .mpo_socket_check_bind = test_socket_check_bind,
2954         .mpo_socket_check_connect = test_socket_check_connect,
2955         .mpo_socket_check_deliver = test_socket_check_deliver,
2956         .mpo_socket_check_listen = test_socket_check_listen,
2957         .mpo_socket_check_poll = test_socket_check_poll,
2958         .mpo_socket_check_receive = test_socket_check_receive,
2959         .mpo_socket_check_relabel = test_socket_check_relabel,
2960         .mpo_socket_check_send = test_socket_check_send,
2961         .mpo_socket_check_stat = test_socket_check_stat,
2962         .mpo_socket_check_visible = test_socket_check_visible,
2963         .mpo_socket_copy_label = test_socket_copy_label,
2964         .mpo_socket_create = test_socket_create,
2965         .mpo_socket_create_mbuf = test_socket_create_mbuf,
2966         .mpo_socket_destroy_label = test_socket_destroy_label,
2967         .mpo_socket_externalize_label = test_socket_externalize_label,
2968         .mpo_socket_init_label = test_socket_init_label,
2969         .mpo_socket_internalize_label = test_socket_internalize_label,
2970         .mpo_socket_newconn = test_socket_newconn,
2971         .mpo_socket_relabel = test_socket_relabel,
2972
2973         .mpo_socketpeer_destroy_label = test_socketpeer_destroy_label,
2974         .mpo_socketpeer_externalize_label = test_socketpeer_externalize_label,
2975         .mpo_socketpeer_init_label = test_socketpeer_init_label,
2976         .mpo_socketpeer_set_from_mbuf = test_socketpeer_set_from_mbuf,
2977         .mpo_socketpeer_set_from_socket = test_socketpeer_set_from_socket,
2978
2979         .mpo_syncache_create = test_syncache_create,
2980         .mpo_syncache_create_mbuf = test_syncache_create_mbuf,
2981
2982         .mpo_system_check_acct = test_system_check_acct,
2983         .mpo_system_check_audit = test_system_check_audit,
2984         .mpo_system_check_auditctl = test_system_check_auditctl,
2985         .mpo_system_check_auditon = test_system_check_auditon,
2986         .mpo_system_check_reboot = test_system_check_reboot,
2987         .mpo_system_check_swapoff = test_system_check_swapoff,
2988         .mpo_system_check_swapon = test_system_check_swapon,
2989         .mpo_system_check_sysctl = test_system_check_sysctl,
2990
2991         .mpo_vnode_check_access = test_vnode_check_access,
2992         .mpo_sysvmsg_cleanup = test_sysvmsg_cleanup,
2993         .mpo_sysvmsg_create = test_sysvmsg_create,
2994
2995         .mpo_sysvmsq_check_msgmsq = test_sysvmsq_check_msgmsq,
2996         .mpo_sysvmsq_check_msgrcv = test_sysvmsq_check_msgrcv,
2997         .mpo_sysvmsq_check_msgrmid = test_sysvmsq_check_msgrmid,
2998         .mpo_sysvmsq_check_msqget = test_sysvmsq_check_msqget,
2999         .mpo_sysvmsq_check_msqsnd = test_sysvmsq_check_msqsnd,
3000         .mpo_sysvmsq_check_msqrcv = test_sysvmsq_check_msqrcv,
3001         .mpo_sysvmsq_check_msqctl = test_sysvmsq_check_msqctl,
3002         .mpo_sysvmsq_cleanup = test_sysvmsq_cleanup,
3003         .mpo_sysvmsq_create = test_sysvmsq_create,
3004
3005         .mpo_sysvsem_check_semctl = test_sysvsem_check_semctl,
3006         .mpo_sysvsem_check_semget = test_sysvsem_check_semget,
3007         .mpo_sysvsem_check_semop = test_sysvsem_check_semop,
3008         .mpo_sysvsem_cleanup = test_sysvsem_cleanup,
3009         .mpo_sysvsem_create = test_sysvsem_create,
3010
3011         .mpo_sysvshm_check_shmat = test_sysvshm_check_shmat,
3012         .mpo_sysvshm_check_shmctl = test_sysvshm_check_shmctl,
3013         .mpo_sysvshm_check_shmdt = test_sysvshm_check_shmdt,
3014         .mpo_sysvshm_check_shmget = test_sysvshm_check_shmget,
3015         .mpo_sysvshm_cleanup = test_sysvshm_cleanup,
3016         .mpo_sysvshm_create = test_sysvshm_create,
3017
3018         .mpo_thread_userret = test_thread_userret,
3019
3020         .mpo_vnode_associate_extattr = test_vnode_associate_extattr,
3021         .mpo_vnode_associate_singlelabel = test_vnode_associate_singlelabel,
3022         .mpo_vnode_check_chdir = test_vnode_check_chdir,
3023         .mpo_vnode_check_chroot = test_vnode_check_chroot,
3024         .mpo_vnode_check_create = test_vnode_check_create,
3025         .mpo_vnode_check_deleteacl = test_vnode_check_deleteacl,
3026         .mpo_vnode_check_deleteextattr = test_vnode_check_deleteextattr,
3027         .mpo_vnode_check_exec = test_vnode_check_exec,
3028         .mpo_vnode_check_getacl = test_vnode_check_getacl,
3029         .mpo_vnode_check_getextattr = test_vnode_check_getextattr,
3030         .mpo_vnode_check_link = test_vnode_check_link,
3031         .mpo_vnode_check_listextattr = test_vnode_check_listextattr,
3032         .mpo_vnode_check_lookup = test_vnode_check_lookup,
3033         .mpo_vnode_check_mmap = test_vnode_check_mmap,
3034         .mpo_vnode_check_open = test_vnode_check_open,
3035         .mpo_vnode_check_poll = test_vnode_check_poll,
3036         .mpo_vnode_check_read = test_vnode_check_read,
3037         .mpo_vnode_check_readdir = test_vnode_check_readdir,
3038         .mpo_vnode_check_readlink = test_vnode_check_readlink,
3039         .mpo_vnode_check_relabel = test_vnode_check_relabel,
3040         .mpo_vnode_check_rename_from = test_vnode_check_rename_from,
3041         .mpo_vnode_check_rename_to = test_vnode_check_rename_to,
3042         .mpo_vnode_check_revoke = test_vnode_check_revoke,
3043         .mpo_vnode_check_setacl = test_vnode_check_setacl,
3044         .mpo_vnode_check_setextattr = test_vnode_check_setextattr,
3045         .mpo_vnode_check_setflags = test_vnode_check_setflags,
3046         .mpo_vnode_check_setmode = test_vnode_check_setmode,
3047         .mpo_vnode_check_setowner = test_vnode_check_setowner,
3048         .mpo_vnode_check_setutimes = test_vnode_check_setutimes,
3049         .mpo_vnode_check_stat = test_vnode_check_stat,
3050         .mpo_vnode_check_unlink = test_vnode_check_unlink,
3051         .mpo_vnode_check_write = test_vnode_check_write,
3052         .mpo_vnode_copy_label = test_vnode_copy_label,
3053         .mpo_vnode_create_extattr = test_vnode_create_extattr,
3054         .mpo_vnode_destroy_label = test_vnode_destroy_label,
3055         .mpo_vnode_execve_transition = test_vnode_execve_transition,
3056         .mpo_vnode_execve_will_transition = test_vnode_execve_will_transition,
3057         .mpo_vnode_externalize_label = test_vnode_externalize_label,
3058         .mpo_vnode_init_label = test_vnode_init_label,
3059         .mpo_vnode_internalize_label = test_vnode_internalize_label,
3060         .mpo_vnode_relabel = test_vnode_relabel,
3061         .mpo_vnode_setlabel_extattr = test_vnode_setlabel_extattr,
3062 };
3063
3064 #define TEST_OBJECTS    (MPC_OBJECT_CRED |                              \
3065                          MPC_OBJECT_PROC |                              \
3066                          MPC_OBJECT_VNODE |                             \
3067                          MPC_OBJECT_INPCB |                             \
3068                          MPC_OBJECT_SOCKET |                            \
3069                          MPC_OBJECT_DEVFS |                             \
3070                          MPC_OBJECT_MBUF |                              \
3071                          MPC_OBJECT_IPQ |                               \
3072                          MPC_OBJECT_IFNET |                             \
3073                          MPC_OBJECT_BPFDESC |                           \
3074                          MPC_OBJECT_PIPE |                              \
3075                          MPC_OBJECT_MOUNT |                             \
3076                          MPC_OBJECT_POSIXSEM |                          \
3077                          MPC_OBJECT_POSIXSHM |                          \
3078                          MPC_OBJECT_SYSVMSG |                           \
3079                          MPC_OBJECT_SYSVMSQ |                           \
3080                          MPC_OBJECT_SYSVSEM |                           \
3081                          MPC_OBJECT_SYSVSHM |                           \
3082                          MPC_OBJECT_SYNCACHE)
3083
3084 MAC_POLICY_SET(&test_ops, mac_test, "TrustedBSD MAC/Test",
3085     MPC_LOADTIME_FLAG_UNLOADOK, &test_slot, TEST_OBJECTS);