sys/security/audit/audit_pipe.c

   1 /*-
   2  * Copyright (c) 2006 Robert N. M. Watson
   3  * Copyright (c) 2008-2009 Apple, Inc.
   4  * All rights reserved.
   5  *
   6  * This software was developed by Robert Watson for the TrustedBSD Project.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/condvar.h>
  35 #include <sys/conf.h>
  36 #include <sys/eventhandler.h>
  37 #include <sys/filio.h>
  38 #include <sys/kernel.h>
  39 #include <sys/lock.h>
  40 #include <sys/malloc.h>
  41 #include <sys/mutex.h>
  42 #include <sys/poll.h>
  43 #include <sys/proc.h>
  44 #include <sys/queue.h>
  45 #include <sys/rwlock.h>
  46 #include <sys/selinfo.h>
  47 #include <sys/sigio.h>
  48 #include <sys/signal.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/sx.h>
  51 #include <sys/systm.h>
  52 #include <sys/uio.h>
  53
  54 #include <security/audit/audit.h>
  55 #include <security/audit/audit_ioctl.h>
  56 #include <security/audit/audit_private.h>
  57
  58 /*
  59  * Implementation of a clonable special device providing a live stream of BSM
  60  * audit data.  Consumers receive a "tee" of the system audit trail by
  61  * default, but may also define alternative event selections using ioctls.
  62  * This interface provides unreliable but timely access to audit events.
  63  * Consumers should be very careful to avoid introducing event cycles.
  64  */
  65
  66 /*
  67  * Memory types.
  68  */
  69 static MALLOC_DEFINE(M_AUDIT_PIPE, "audit_pipe", "Audit pipes");
  70 static MALLOC_DEFINE(M_AUDIT_PIPE_ENTRY, "audit_pipeent",
  71     "Audit pipe entries and buffers");
  72 static MALLOC_DEFINE(M_AUDIT_PIPE_PRESELECT, "audit_pipe_presel",
  73     "Audit pipe preselection structure");
  74
  75 /*
  76  * Audit pipe buffer parameters.
  77  */
  78 #define AUDIT_PIPE_QLIMIT_DEFAULT       (128)
  79 #define AUDIT_PIPE_QLIMIT_MIN           (1)
  80 #define AUDIT_PIPE_QLIMIT_MAX           (1024)
  81
  82 /*
  83  * Description of an entry in an audit_pipe.
  84  */
  85 struct audit_pipe_entry {
  86         void                            *ape_record;
  87         u_int                            ape_record_len;
  88         TAILQ_ENTRY(audit_pipe_entry)    ape_queue;
  89 };
  90
  91 /*
  92  * Audit pipes allow processes to express "interest" in the set of records
  93  * that are delivered via the pipe.  They do this in a similar manner to the
  94  * mechanism for audit trail configuration, by expressing two global masks,
  95  * and optionally expressing per-auid masks.  The following data structure is
  96  * the per-auid mask description.  The global state is stored in the audit
  97  * pipe data structure.
  98  *
  99  * We may want to consider a more space/time-efficient data structure once
 100  * usage patterns for per-auid specifications are clear.
 101  */
 102 struct audit_pipe_preselect {
 103         au_id_t                                  app_auid;
 104         au_mask_t                                app_mask;
 105         TAILQ_ENTRY(audit_pipe_preselect)        app_list;
 106 };
 107
 108 /*
 109  * Description of an individual audit_pipe.  Consists largely of a bounded
 110  * length queue.
 111  */
 112 #define AUDIT_PIPE_ASYNC        0x00000001
 113 #define AUDIT_PIPE_NBIO         0x00000002
 114 struct audit_pipe {
 115         int                              ap_open;       /* Device open? */
 116         u_int                            ap_flags;
 117
 118         struct selinfo                   ap_selinfo;
 119         struct sigio                    *ap_sigio;
 120
 121         /*
 122          * Per-pipe mutex protecting most fields in this data structure.
 123          */
 124         struct mtx                       ap_mtx;
 125
 126         /*
 127          * Per-pipe sleep lock serializing user-generated reads and flushes.
 128          * uiomove() is called to copy out the current head record's data
 129          * while the record remains in the queue, so we prevent other threads
 130          * from removing it using this lock.
 131          */
 132         struct sx                        ap_sx;
 133
 134         /*
 135          * Condition variable to signal when data has been delivered to a
 136          * pipe.
 137          */
 138         struct cv                        ap_cv;
 139
 140         /*
 141          * Various queue-reated variables: qlen and qlimit are a count of
 142          * records in the queue; qbyteslen is the number of bytes of data
 143          * across all records, and qoffset is the amount read so far of the
 144          * first record in the queue.  The number of bytes available for
 145          * reading in the queue is qbyteslen - qoffset.
 146          */
 147         u_int                            ap_qlen;
 148         u_int                            ap_qlimit;
 149         u_int                            ap_qbyteslen;
 150         u_int                            ap_qoffset;
 151
 152         /*
 153          * Per-pipe operation statistics.
 154          */
 155         u_int64_t                        ap_inserts;    /* Records added. */
 156         u_int64_t                        ap_reads;      /* Records read. */
 157         u_int64_t                        ap_drops;      /* Records dropped. */
 158
 159         /*
 160          * Fields relating to pipe interest: global masks for unmatched
 161          * processes (attributable, non-attributable), and a list of specific
 162          * interest specifications by auid.
 163          */
 164         int                              ap_preselect_mode;
 165         au_mask_t                        ap_preselect_flags;
 166         au_mask_t                        ap_preselect_naflags;
 167         TAILQ_HEAD(, audit_pipe_preselect)      ap_preselect_list;
 168
 169         /*
 170          * Current pending record list.  Protected by a combination of ap_mtx
 171          * and ap_sx.  Note particularly that *both* locks are required to
 172          * remove a record from the head of the queue, as an in-progress read
 173          * may sleep while copying and therefore cannot hold ap_mtx.
 174          */
 175         TAILQ_HEAD(, audit_pipe_entry)   ap_queue;
 176
 177         /*
 178          * Global pipe list.
 179          */
 180         TAILQ_ENTRY(audit_pipe)          ap_list;
 181 };
 182
 183 #define AUDIT_PIPE_LOCK(ap)             mtx_lock(&(ap)->ap_mtx)
 184 #define AUDIT_PIPE_LOCK_ASSERT(ap)      mtx_assert(&(ap)->ap_mtx, MA_OWNED)
 185 #define AUDIT_PIPE_LOCK_DESTROY(ap)     mtx_destroy(&(ap)->ap_mtx)
 186 #define AUDIT_PIPE_LOCK_INIT(ap)        mtx_init(&(ap)->ap_mtx, \
 187                                             "audit_pipe_mtx", NULL, MTX_DEF)
 188 #define AUDIT_PIPE_UNLOCK(ap)           mtx_unlock(&(ap)->ap_mtx)
 189 #define AUDIT_PIPE_MTX(ap)              (&(ap)->ap_mtx)
 190
 191 #define AUDIT_PIPE_SX_LOCK_DESTROY(ap)  sx_destroy(&(ap)->ap_sx)
 192 #define AUDIT_PIPE_SX_LOCK_INIT(ap)     sx_init(&(ap)->ap_sx, "audit_pipe_sx")
 193 #define AUDIT_PIPE_SX_XLOCK_ASSERT(ap)  sx_assert(&(ap)->ap_sx, SA_XLOCKED)
 194 #define AUDIT_PIPE_SX_XLOCK_SIG(ap)     sx_xlock_sig(&(ap)->ap_sx)
 195 #define AUDIT_PIPE_SX_XUNLOCK(ap)       sx_xunlock(&(ap)->ap_sx)
 196
 197 /*
 198  * Global list of audit pipes, rwlock to protect it.  Individual record
 199  * queues on pipes are protected by per-pipe locks; these locks synchronize
 200  * between threads walking the list to deliver to individual pipes and add/
 201  * remove of pipes, and are mostly acquired for read.
 202  */
 203 static TAILQ_HEAD(, audit_pipe)  audit_pipe_list;
 204 static struct rwlock             audit_pipe_lock;
 205
 206 #define AUDIT_PIPE_LIST_LOCK_INIT()     rw_init(&audit_pipe_lock, \
 207                                             "audit_pipe_list_lock")
 208 #define AUDIT_PIPE_LIST_RLOCK()         rw_rlock(&audit_pipe_lock)
 209 #define AUDIT_PIPE_LIST_RUNLOCK()       rw_runlock(&audit_pipe_lock)
 210 #define AUDIT_PIPE_LIST_WLOCK()         rw_wlock(&audit_pipe_lock)
 211 #define AUDIT_PIPE_LIST_WLOCK_ASSERT()  rw_assert(&audit_pipe_lock, \
 212                                             RA_WLOCKED)
 213 #define AUDIT_PIPE_LIST_WUNLOCK()       rw_wunlock(&audit_pipe_lock)
 214
 215 /*
 216  * Cloning related variables and constants.
 217  */
 218 #define AUDIT_PIPE_NAME         "auditpipe"
 219 static eventhandler_tag          audit_pipe_eh_tag;
 220 static struct clonedevs         *audit_pipe_clones;
 221
 222 /*
 223  * Special device methods and definition.
 224  */
 225 static d_open_t         audit_pipe_open;
 226 static d_close_t        audit_pipe_close;
 227 static d_read_t         audit_pipe_read;
 228 static d_ioctl_t        audit_pipe_ioctl;
 229 static d_poll_t         audit_pipe_poll;
 230 static d_kqfilter_t     audit_pipe_kqfilter;
 231
 232 static struct cdevsw    audit_pipe_cdevsw = {
 233         .d_version =    D_VERSION,
 234         .d_flags =      D_PSEUDO | D_NEEDMINOR,
 235         .d_open =       audit_pipe_open,
 236         .d_close =      audit_pipe_close,
 237         .d_read =       audit_pipe_read,
 238         .d_ioctl =      audit_pipe_ioctl,
 239         .d_poll =       audit_pipe_poll,
 240         .d_kqfilter =   audit_pipe_kqfilter,
 241         .d_name =       AUDIT_PIPE_NAME,
 242 };
 243
 244 static int      audit_pipe_kqread(struct knote *note, long hint);
 245 static void     audit_pipe_kqdetach(struct knote *note);
 246
 247 static struct filterops audit_pipe_read_filterops = {
 248         .f_isfd =       1,
 249         .f_attach =     NULL,
 250         .f_detach =     audit_pipe_kqdetach,
 251         .f_event =      audit_pipe_kqread,
 252 };
 253
 254 /*
 255  * Some global statistics on audit pipes.
 256  */
 257 static int              audit_pipe_count;       /* Current number of pipes. */
 258 static u_int64_t        audit_pipe_ever;        /* Pipes ever allocated. */
 259 static u_int64_t        audit_pipe_records;     /* Records seen. */
 260 static u_int64_t        audit_pipe_drops;       /* Global record drop count. */
 261
 262 /*
 263  * Free an audit pipe entry.
 264  */
 265 static void
 266 audit_pipe_entry_free(struct audit_pipe_entry *ape)
 267 {
 268
 269         free(ape->ape_record, M_AUDIT_PIPE_ENTRY);
 270         free(ape, M_AUDIT_PIPE_ENTRY);
 271 }
 272
 273 /*
 274  * Find an audit pipe preselection specification for an auid, if any.
 275  */
 276 static struct audit_pipe_preselect *
 277 audit_pipe_preselect_find(struct audit_pipe *ap, au_id_t auid)
 278 {
 279         struct audit_pipe_preselect *app;
 280
 281         AUDIT_PIPE_LOCK_ASSERT(ap);
 282
 283         TAILQ_FOREACH(app, &ap->ap_preselect_list, app_list) {
 284                 if (app->app_auid == auid)
 285                         return (app);
 286         }
 287         return (NULL);
 288 }
 289
 290 /*
 291  * Query the per-pipe mask for a specific auid.
 292  */
 293 static int
 294 audit_pipe_preselect_get(struct audit_pipe *ap, au_id_t auid,
 295     au_mask_t *maskp)
 296 {
 297         struct audit_pipe_preselect *app;
 298         int error;
 299
 300         AUDIT_PIPE_LOCK(ap);
 301         app = audit_pipe_preselect_find(ap, auid);
 302         if (app != NULL) {
 303                 *maskp = app->app_mask;
 304                 error = 0;
 305         } else
 306                 error = ENOENT;
 307         AUDIT_PIPE_UNLOCK(ap);
 308         return (error);
 309 }
 310
 311 /*
 312  * Set the per-pipe mask for a specific auid.  Add a new entry if needed;
 313  * otherwise, update the current entry.
 314  */
 315 static void
 316 audit_pipe_preselect_set(struct audit_pipe *ap, au_id_t auid, au_mask_t mask)
 317 {
 318         struct audit_pipe_preselect *app, *app_new;
 319
 320         /*
 321          * Pessimistically assume that the auid doesn't already have a mask
 322          * set, and allocate.  We will free it if it is unneeded.
 323          */
 324         app_new = malloc(sizeof(*app_new), M_AUDIT_PIPE_PRESELECT, M_WAITOK);
 325         AUDIT_PIPE_LOCK(ap);
 326         app = audit_pipe_preselect_find(ap, auid);
 327         if (app == NULL) {
 328                 app = app_new;
 329                 app_new = NULL;
 330                 app->app_auid = auid;
 331                 TAILQ_INSERT_TAIL(&ap->ap_preselect_list, app, app_list);
 332         }
 333         app->app_mask = mask;
 334         AUDIT_PIPE_UNLOCK(ap);
 335         if (app_new != NULL)
 336                 free(app_new, M_AUDIT_PIPE_PRESELECT);
 337 }
 338
 339 /*
 340  * Delete a per-auid mask on an audit pipe.
 341  */
 342 static int
 343 audit_pipe_preselect_delete(struct audit_pipe *ap, au_id_t auid)
 344 {
 345         struct audit_pipe_preselect *app;
 346         int error;
 347
 348         AUDIT_PIPE_LOCK(ap);
 349         app = audit_pipe_preselect_find(ap, auid);
 350         if (app != NULL) {
 351                 TAILQ_REMOVE(&ap->ap_preselect_list, app, app_list);
 352                 error = 0;
 353         } else
 354                 error = ENOENT;
 355         AUDIT_PIPE_UNLOCK(ap);
 356         if (app != NULL)
 357                 free(app, M_AUDIT_PIPE_PRESELECT);
 358         return (error);
 359 }
 360
 361 /*
 362  * Delete all per-auid masks on an audit pipe.
 363  */
 364 static void
 365 audit_pipe_preselect_flush_locked(struct audit_pipe *ap)
 366 {
 367         struct audit_pipe_preselect *app;
 368
 369         AUDIT_PIPE_LOCK_ASSERT(ap);
 370
 371         while ((app = TAILQ_FIRST(&ap->ap_preselect_list)) != NULL) {
 372                 TAILQ_REMOVE(&ap->ap_preselect_list, app, app_list);
 373                 free(app, M_AUDIT_PIPE_PRESELECT);
 374         }
 375 }
 376
 377 static void
 378 audit_pipe_preselect_flush(struct audit_pipe *ap)
 379 {
 380
 381         AUDIT_PIPE_LOCK(ap);
 382         audit_pipe_preselect_flush_locked(ap);
 383         AUDIT_PIPE_UNLOCK(ap);
 384 }
 385
 386 /*-
 387  * Determine whether a specific audit pipe matches a record with these
 388  * properties.  Algorithm is as follows:
 389  *
 390  * - If the pipe is configured to track the default trail configuration, then
 391  *   use the results of global preselection matching.
 392  * - If not, search for a specifically configured auid entry matching the
 393  *   event.  If an entry is found, use that.
 394  * - Otherwise, use the default flags or naflags configured for the pipe.
 395  */
 396 static int
 397 audit_pipe_preselect_check(struct audit_pipe *ap, au_id_t auid,
 398     au_event_t event, au_class_t class, int sorf, int trail_preselect)
 399 {
 400         struct audit_pipe_preselect *app;
 401
 402         AUDIT_PIPE_LOCK_ASSERT(ap);
 403
 404         switch (ap->ap_preselect_mode) {
 405         case AUDITPIPE_PRESELECT_MODE_TRAIL:
 406                 return (trail_preselect);
 407
 408         case AUDITPIPE_PRESELECT_MODE_LOCAL:
 409                 app = audit_pipe_preselect_find(ap, auid);
 410                 if (app == NULL) {
 411                         if (auid == AU_DEFAUDITID)
 412                                 return (au_preselect(event, class,
 413                                     &ap->ap_preselect_naflags, sorf));
 414                         else
 415                                 return (au_preselect(event, class,
 416                                     &ap->ap_preselect_flags, sorf));
 417                 } else
 418                         return (au_preselect(event, class, &app->app_mask,
 419                             sorf));
 420
 421         default:
 422                 panic("audit_pipe_preselect_check: mode %d",
 423                     ap->ap_preselect_mode);
 424         }
 425
 426         return (0);
 427 }
 428
 429 /*
 430  * Determine whether there exists a pipe interested in a record with specific
 431  * properties.
 432  */
 433 int
 434 audit_pipe_preselect(au_id_t auid, au_event_t event, au_class_t class,
 435     int sorf, int trail_preselect)
 436 {
 437         struct audit_pipe *ap;
 438
 439         /* Lockless read to avoid acquiring the global lock if not needed. */
 440         if (TAILQ_EMPTY(&audit_pipe_list))
 441                 return (0);
 442
 443         AUDIT_PIPE_LIST_RLOCK();
 444         TAILQ_FOREACH(ap, &audit_pipe_list, ap_list) {
 445                 AUDIT_PIPE_LOCK(ap);
 446                 if (audit_pipe_preselect_check(ap, auid, event, class, sorf,
 447                     trail_preselect)) {
 448                         AUDIT_PIPE_UNLOCK(ap);
 449                         AUDIT_PIPE_LIST_RUNLOCK();
 450                         return (1);
 451                 }
 452                 AUDIT_PIPE_UNLOCK(ap);
 453         }
 454         AUDIT_PIPE_LIST_RUNLOCK();
 455         return (0);
 456 }
 457
 458 /*
 459  * Append individual record to a queue -- allocate queue-local buffer, and
 460  * add to the queue.  If the queue is full or we can't allocate memory, drop
 461  * the newest record.
 462  */
 463 static void
 464 audit_pipe_append(struct audit_pipe *ap, void *record, u_int record_len)
 465 {
 466         struct audit_pipe_entry *ape;
 467
 468         AUDIT_PIPE_LOCK_ASSERT(ap);
 469
 470         if (ap->ap_qlen >= ap->ap_qlimit) {
 471                 ap->ap_drops++;
 472                 audit_pipe_drops++;
 473                 return;
 474         }
 475
 476         ape = malloc(sizeof(*ape), M_AUDIT_PIPE_ENTRY, M_NOWAIT | M_ZERO);
 477         if (ape == NULL) {
 478                 ap->ap_drops++;
 479                 audit_pipe_drops++;
 480                 return;
 481         }
 482
 483         ape->ape_record = malloc(record_len, M_AUDIT_PIPE_ENTRY, M_NOWAIT);
 484         if (ape->ape_record == NULL) {
 485                 free(ape, M_AUDIT_PIPE_ENTRY);
 486                 ap->ap_drops++;
 487                 audit_pipe_drops++;
 488                 return;
 489         }
 490
 491         bcopy(record, ape->ape_record, record_len);
 492         ape->ape_record_len = record_len;
 493
 494         TAILQ_INSERT_TAIL(&ap->ap_queue, ape, ape_queue);
 495         ap->ap_inserts++;
 496         ap->ap_qlen++;
 497         ap->ap_qbyteslen += ape->ape_record_len;
 498         selwakeuppri(&ap->ap_selinfo, PSOCK);
 499         KNOTE_LOCKED(&ap->ap_selinfo.si_note, 0);
 500         if (ap->ap_flags & AUDIT_PIPE_ASYNC)
 501                 pgsigio(&ap->ap_sigio, SIGIO, 0);
 502         cv_broadcast(&ap->ap_cv);
 503 }
 504
 505 /*
 506  * audit_pipe_submit(): audit_worker submits audit records via this
 507  * interface, which arranges for them to be delivered to pipe queues.
 508  */
 509 void
 510 audit_pipe_submit(au_id_t auid, au_event_t event, au_class_t class, int sorf,
 511     int trail_select, void *record, u_int record_len)
 512 {
 513         struct audit_pipe *ap;
 514
 515         /*
 516          * Lockless read to avoid lock overhead if pipes are not in use.
 517          */
 518         if (TAILQ_FIRST(&audit_pipe_list) == NULL)
 519                 return;
 520
 521         AUDIT_PIPE_LIST_RLOCK();
 522         TAILQ_FOREACH(ap, &audit_pipe_list, ap_list) {
 523                 AUDIT_PIPE_LOCK(ap);
 524                 if (audit_pipe_preselect_check(ap, auid, event, class, sorf,
 525                     trail_select))
 526                         audit_pipe_append(ap, record, record_len);
 527                 AUDIT_PIPE_UNLOCK(ap);
 528         }
 529         AUDIT_PIPE_LIST_RUNLOCK();
 530
 531         /* Unlocked increment. */
 532         audit_pipe_records++;
 533 }
 534
 535 /*
 536  * audit_pipe_submit_user(): the same as audit_pipe_submit(), except that
 537  * since we don't currently have selection information available, it is
 538  * delivered to the pipe unconditionally.
 539  *
 540  * XXXRW: This is a bug.  The BSM check routine for submitting a user record
 541  * should parse that information and return it.
 542  */
 543 void
 544 audit_pipe_submit_user(void *record, u_int record_len)
 545 {
 546         struct audit_pipe *ap;
 547
 548         /*
 549          * Lockless read to avoid lock overhead if pipes are not in use.
 550          */
 551         if (TAILQ_FIRST(&audit_pipe_list) == NULL)
 552                 return;
 553
 554         AUDIT_PIPE_LIST_RLOCK();
 555         TAILQ_FOREACH(ap, &audit_pipe_list, ap_list) {
 556                 AUDIT_PIPE_LOCK(ap);
 557                 audit_pipe_append(ap, record, record_len);
 558                 AUDIT_PIPE_UNLOCK(ap);
 559         }
 560         AUDIT_PIPE_LIST_RUNLOCK();
 561
 562         /* Unlocked increment. */
 563         audit_pipe_records++;
 564 }
 565
 566 /*
 567  * Allocate a new audit pipe.  Connects the pipe, on success, to the global
 568  * list and updates statistics.
 569  */
 570 static struct audit_pipe *
 571 audit_pipe_alloc(void)
 572 {
 573         struct audit_pipe *ap;
 574
 575         AUDIT_PIPE_LIST_WLOCK_ASSERT();
 576
 577         ap = malloc(sizeof(*ap), M_AUDIT_PIPE, M_NOWAIT | M_ZERO);
 578         if (ap == NULL)
 579                 return (NULL);
 580         ap->ap_qlimit = AUDIT_PIPE_QLIMIT_DEFAULT;
 581         TAILQ_INIT(&ap->ap_queue);
 582         knlist_init_mtx(&ap->ap_selinfo.si_note, AUDIT_PIPE_MTX(ap));
 583         AUDIT_PIPE_LOCK_INIT(ap);
 584         AUDIT_PIPE_SX_LOCK_INIT(ap);
 585         cv_init(&ap->ap_cv, "audit_pipe");
 586
 587         /*
 588          * Default flags, naflags, and auid-specific preselection settings to
 589          * 0.  Initialize the mode to the global trail so that if praudit(1)
 590          * is run on /dev/auditpipe, it sees events associated with the
 591          * default trail.  Pipe-aware application can clear the flag, set
 592          * custom masks, and flush the pipe as needed.
 593          */
 594         bzero(&ap->ap_preselect_flags, sizeof(ap->ap_preselect_flags));
 595         bzero(&ap->ap_preselect_naflags, sizeof(ap->ap_preselect_naflags));
 596         TAILQ_INIT(&ap->ap_preselect_list);
 597         ap->ap_preselect_mode = AUDITPIPE_PRESELECT_MODE_TRAIL;
 598
 599         /*
 600          * Add to global list and update global statistics.
 601          */
 602         TAILQ_INSERT_HEAD(&audit_pipe_list, ap, ap_list);
 603         audit_pipe_count++;
 604         audit_pipe_ever++;
 605
 606         return (ap);
 607 }
 608
 609 /*
 610  * Flush all records currently present in an audit pipe; assume mutex is held.
 611  */
 612 static void
 613 audit_pipe_flush(struct audit_pipe *ap)
 614 {
 615         struct audit_pipe_entry *ape;
 616
 617         AUDIT_PIPE_LOCK_ASSERT(ap);
 618
 619         while ((ape = TAILQ_FIRST(&ap->ap_queue)) != NULL) {
 620                 TAILQ_REMOVE(&ap->ap_queue, ape, ape_queue);
 621                 ap->ap_qbyteslen -= ape->ape_record_len;
 622                 audit_pipe_entry_free(ape);
 623                 ap->ap_qlen--;
 624         }
 625         ap->ap_qoffset = 0;
 626
 627         KASSERT(ap->ap_qlen == 0, ("audit_pipe_free: ap_qbyteslen"));
 628         KASSERT(ap->ap_qbyteslen == 0, ("audit_pipe_flush: ap_qbyteslen"));
 629 }
 630
 631 /*
 632  * Free an audit pipe; this means freeing all preselection state and all
 633  * records in the pipe.  Assumes global write lock and pipe mutex are held to
 634  * prevent any new records from being inserted during the free, and that the
 635  * audit pipe is still on the global list.
 636  */
 637 static void
 638 audit_pipe_free(struct audit_pipe *ap)
 639 {
 640
 641         AUDIT_PIPE_LIST_WLOCK_ASSERT();
 642         AUDIT_PIPE_LOCK_ASSERT(ap);
 643
 644         audit_pipe_preselect_flush_locked(ap);
 645         audit_pipe_flush(ap);
 646         cv_destroy(&ap->ap_cv);
 647         AUDIT_PIPE_SX_LOCK_DESTROY(ap);
 648         AUDIT_PIPE_LOCK_DESTROY(ap);
 649         knlist_destroy(&ap->ap_selinfo.si_note);
 650         TAILQ_REMOVE(&audit_pipe_list, ap, ap_list);
 651         free(ap, M_AUDIT_PIPE);
 652         audit_pipe_count--;
 653 }
 654
 655 /*
 656  * Audit pipe clone routine -- provide specific requested audit pipe, or a
 657  * fresh one if a specific one is not requested.
 658  */
 659 static void
 660 audit_pipe_clone(void *arg, struct ucred *cred, char *name, int namelen,
 661     struct cdev **dev)
 662 {
 663         int i, u;
 664
 665         if (*dev != NULL)
 666                 return;
 667
 668         if (strcmp(name, AUDIT_PIPE_NAME) == 0)
 669                 u = -1;
 670         else if (dev_stdclone(name, NULL, AUDIT_PIPE_NAME, &u) != 1)
 671                 return;
 672
 673         i = clone_create(&audit_pipe_clones, &audit_pipe_cdevsw, &u, dev, 0);
 674         if (i) {
 675                 *dev = make_dev(&audit_pipe_cdevsw, u, UID_ROOT,
 676                     GID_WHEEL, 0600, "%s%d", AUDIT_PIPE_NAME, u);
 677                 if (*dev != NULL) {
 678                         dev_ref(*dev);
 679                         (*dev)->si_flags |= SI_CHEAPCLONE;
 680                 }
 681         }
 682 }
 683
 684 /*
 685  * Audit pipe open method.  Explicit privilege check isn't used as this
 686  * allows file permissions on the special device to be used to grant audit
 687  * review access.  Those file permissions should be managed carefully.
 688  */
 689 static int
 690 audit_pipe_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 691 {
 692         struct audit_pipe *ap;
 693
 694         AUDIT_PIPE_LIST_WLOCK();
 695         ap = dev->si_drv1;
 696         if (ap == NULL) {
 697                 ap = audit_pipe_alloc();
 698                 if (ap == NULL) {
 699                         AUDIT_PIPE_LIST_WUNLOCK();
 700                         return (ENOMEM);
 701                 }
 702                 dev->si_drv1 = ap;
 703         } else {
 704                 KASSERT(ap->ap_open, ("audit_pipe_open: ap && !ap_open"));
 705                 AUDIT_PIPE_LIST_WUNLOCK();
 706                 return (EBUSY);
 707         }
 708         ap->ap_open = 1;        /* No lock required yet. */
 709         AUDIT_PIPE_LIST_WUNLOCK();
 710         fsetown(td->td_proc->p_pid, &ap->ap_sigio);
 711         return (0);
 712 }
 713
 714 /*
 715  * Close audit pipe, tear down all records, etc.
 716  */
 717 static int
 718 audit_pipe_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
 719 {
 720         struct audit_pipe *ap;
 721
 722         ap = dev->si_drv1;
 723         KASSERT(ap != NULL, ("audit_pipe_close: ap == NULL"));
 724         KASSERT(ap->ap_open, ("audit_pipe_close: !ap_open"));
 725
 726         funsetown(&ap->ap_sigio);
 727         AUDIT_PIPE_LIST_WLOCK();
 728         AUDIT_PIPE_LOCK(ap);
 729         ap->ap_open = 0;
 730         audit_pipe_free(ap);
 731         dev->si_drv1 = NULL;
 732         AUDIT_PIPE_LIST_WUNLOCK();
 733         return (0);
 734 }
 735
 736 /*
 737  * Audit pipe ioctl() routine.  Handle file descriptor and audit pipe layer
 738  * commands.
 739  */
 740 static int
 741 audit_pipe_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag,
 742     struct thread *td)
 743 {
 744         struct auditpipe_ioctl_preselect *aip;
 745         struct audit_pipe *ap;
 746         au_mask_t *maskp;
 747         int error, mode;
 748         au_id_t auid;
 749
 750         ap = dev->si_drv1;
 751         KASSERT(ap != NULL, ("audit_pipe_ioctl: ap == NULL"));
 752
 753         /*
 754          * Audit pipe ioctls: first come standard device node ioctls, then
 755          * manipulation of pipe settings, and finally, statistics query
 756          * ioctls.
 757          */
 758         switch (cmd) {
 759         case FIONBIO:
 760                 AUDIT_PIPE_LOCK(ap);
 761                 if (*(int *)data)
 762                         ap->ap_flags |= AUDIT_PIPE_NBIO;
 763                 else
 764                         ap->ap_flags &= ~AUDIT_PIPE_NBIO;
 765                 AUDIT_PIPE_UNLOCK(ap);
 766                 error = 0;
 767                 break;
 768
 769         case FIONREAD:
 770                 AUDIT_PIPE_LOCK(ap);
 771                 *(int *)data = ap->ap_qbyteslen - ap->ap_qoffset;
 772                 AUDIT_PIPE_UNLOCK(ap);
 773                 error = 0;
 774                 break;
 775
 776         case FIOASYNC:
 777                 AUDIT_PIPE_LOCK(ap);
 778                 if (*(int *)data)
 779                         ap->ap_flags |= AUDIT_PIPE_ASYNC;
 780                 else
 781                         ap->ap_flags &= ~AUDIT_PIPE_ASYNC;
 782                 AUDIT_PIPE_UNLOCK(ap);
 783                 error = 0;
 784                 break;
 785
 786         case FIOSETOWN:
 787                 error = fsetown(*(int *)data, &ap->ap_sigio);
 788                 break;
 789
 790         case FIOGETOWN:
 791                 *(int *)data = fgetown(&ap->ap_sigio);
 792                 error = 0;
 793                 break;
 794
 795         case AUDITPIPE_GET_QLEN:
 796                 *(u_int *)data = ap->ap_qlen;
 797                 error = 0;
 798                 break;
 799
 800         case AUDITPIPE_GET_QLIMIT:
 801                 *(u_int *)data = ap->ap_qlimit;
 802                 error = 0;
 803                 break;
 804
 805         case AUDITPIPE_SET_QLIMIT:
 806                 /* Lockless integer write. */
 807                 if (*(u_int *)data >= AUDIT_PIPE_QLIMIT_MIN ||
 808                     *(u_int *)data <= AUDIT_PIPE_QLIMIT_MAX) {
 809                         ap->ap_qlimit = *(u_int *)data;
 810                         error = 0;
 811                 } else
 812                         error = EINVAL;
 813                 break;
 814
 815         case AUDITPIPE_GET_QLIMIT_MIN:
 816                 *(u_int *)data = AUDIT_PIPE_QLIMIT_MIN;
 817                 error = 0;
 818                 break;
 819
 820         case AUDITPIPE_GET_QLIMIT_MAX:
 821                 *(u_int *)data = AUDIT_PIPE_QLIMIT_MAX;
 822                 error = 0;
 823                 break;
 824
 825         case AUDITPIPE_GET_PRESELECT_FLAGS:
 826                 AUDIT_PIPE_LOCK(ap);
 827                 maskp = (au_mask_t *)data;
 828                 *maskp = ap->ap_preselect_flags;
 829                 AUDIT_PIPE_UNLOCK(ap);
 830                 error = 0;
 831                 break;
 832
 833         case AUDITPIPE_SET_PRESELECT_FLAGS:
 834                 AUDIT_PIPE_LOCK(ap);
 835                 maskp = (au_mask_t *)data;
 836                 ap->ap_preselect_flags = *maskp;
 837                 AUDIT_PIPE_UNLOCK(ap);
 838                 error = 0;
 839                 break;
 840
 841         case AUDITPIPE_GET_PRESELECT_NAFLAGS:
 842                 AUDIT_PIPE_LOCK(ap);
 843                 maskp = (au_mask_t *)data;
 844                 *maskp = ap->ap_preselect_naflags;
 845                 AUDIT_PIPE_UNLOCK(ap);
 846                 error = 0;
 847                 break;
 848
 849         case AUDITPIPE_SET_PRESELECT_NAFLAGS:
 850                 AUDIT_PIPE_LOCK(ap);
 851                 maskp = (au_mask_t *)data;
 852                 ap->ap_preselect_naflags = *maskp;
 853                 AUDIT_PIPE_UNLOCK(ap);
 854                 error = 0;
 855                 break;
 856
 857         case AUDITPIPE_GET_PRESELECT_AUID:
 858                 aip = (struct auditpipe_ioctl_preselect *)data;
 859                 error = audit_pipe_preselect_get(ap, aip->aip_auid,
 860                     &aip->aip_mask);
 861                 break;
 862
 863         case AUDITPIPE_SET_PRESELECT_AUID:
 864                 aip = (struct auditpipe_ioctl_preselect *)data;
 865                 audit_pipe_preselect_set(ap, aip->aip_auid, aip->aip_mask);
 866                 error = 0;
 867                 break;
 868
 869         case AUDITPIPE_DELETE_PRESELECT_AUID:
 870                 auid = *(au_id_t *)data;
 871                 error = audit_pipe_preselect_delete(ap, auid);
 872                 break;
 873
 874         case AUDITPIPE_FLUSH_PRESELECT_AUID:
 875                 audit_pipe_preselect_flush(ap);
 876                 error = 0;
 877                 break;
 878
 879         case AUDITPIPE_GET_PRESELECT_MODE:
 880                 AUDIT_PIPE_LOCK(ap);
 881                 *(int *)data = ap->ap_preselect_mode;
 882                 AUDIT_PIPE_UNLOCK(ap);
 883                 error = 0;
 884                 break;
 885
 886         case AUDITPIPE_SET_PRESELECT_MODE:
 887                 mode = *(int *)data;
 888                 switch (mode) {
 889                 case AUDITPIPE_PRESELECT_MODE_TRAIL:
 890                 case AUDITPIPE_PRESELECT_MODE_LOCAL:
 891                         AUDIT_PIPE_LOCK(ap);
 892                         ap->ap_preselect_mode = mode;
 893                         AUDIT_PIPE_UNLOCK(ap);
 894                         error = 0;
 895                         break;
 896
 897                 default:
 898                         error = EINVAL;
 899                 }
 900                 break;
 901
 902         case AUDITPIPE_FLUSH:
 903                 if (AUDIT_PIPE_SX_XLOCK_SIG(ap) != 0)
 904                         return (EINTR);
 905                 AUDIT_PIPE_LOCK(ap);
 906                 audit_pipe_flush(ap);
 907                 AUDIT_PIPE_UNLOCK(ap);
 908                 AUDIT_PIPE_SX_XUNLOCK(ap);
 909                 error = 0;
 910                 break;
 911
 912         case AUDITPIPE_GET_MAXAUDITDATA:
 913                 *(u_int *)data = MAXAUDITDATA;
 914                 error = 0;
 915                 break;
 916
 917         case AUDITPIPE_GET_INSERTS:
 918                 *(u_int *)data = ap->ap_inserts;
 919                 error = 0;
 920                 break;
 921
 922         case AUDITPIPE_GET_READS:
 923                 *(u_int *)data = ap->ap_reads;
 924                 error = 0;
 925                 break;
 926
 927         case AUDITPIPE_GET_DROPS:
 928                 *(u_int *)data = ap->ap_drops;
 929                 error = 0;
 930                 break;
 931
 932         case AUDITPIPE_GET_TRUNCATES:
 933                 *(u_int *)data = 0;
 934                 error = 0;
 935                 break;
 936
 937         default:
 938                 error = ENOTTY;
 939         }
 940         return (error);
 941 }
 942
 943 /*
 944  * Audit pipe read.  Read one or more partial or complete records to user
 945  * memory.
 946  */
 947 static int
 948 audit_pipe_read(struct cdev *dev, struct uio *uio, int flag)
 949 {
 950         struct audit_pipe_entry *ape;
 951         struct audit_pipe *ap;
 952         u_int toread;
 953         int error;
 954
 955         ap = dev->si_drv1;
 956         KASSERT(ap != NULL, ("audit_pipe_read: ap == NULL"));
 957
 958         /*
 959          * We hold an sx(9) lock over read and flush because we rely on the
 960          * stability of a record in the queue during uiomove(9).
 961          */
 962         if (AUDIT_PIPE_SX_XLOCK_SIG(ap) != 0)
 963                 return (EINTR);
 964         AUDIT_PIPE_LOCK(ap);
 965         while (TAILQ_EMPTY(&ap->ap_queue)) {
 966                 if (ap->ap_flags & AUDIT_PIPE_NBIO) {
 967                         AUDIT_PIPE_UNLOCK(ap);
 968                         AUDIT_PIPE_SX_XUNLOCK(ap);
 969                         return (EAGAIN);
 970                 }
 971                 error = cv_wait_sig(&ap->ap_cv, AUDIT_PIPE_MTX(ap));
 972                 if (error) {
 973                         AUDIT_PIPE_UNLOCK(ap);
 974                         AUDIT_PIPE_SX_XUNLOCK(ap);
 975                         return (error);
 976                 }
 977         }
 978
 979         /*
 980          * Copy as many remaining bytes from the current record to userspace
 981          * as we can.  Keep processing records until we run out of records in
 982          * the queue, or until the user buffer runs out of space.
 983          *
 984          * Note: we rely on the SX lock to maintain ape's stability here.
 985          */
 986         ap->ap_reads++;
 987         while ((ape = TAILQ_FIRST(&ap->ap_queue)) != NULL &&
 988             uio->uio_resid > 0) {
 989                 AUDIT_PIPE_LOCK_ASSERT(ap);
 990
 991                 KASSERT(ape->ape_record_len > ap->ap_qoffset,
 992                     ("audit_pipe_read: record_len > qoffset (1)"));
 993                 toread = MIN(ape->ape_record_len - ap->ap_qoffset,
 994                     uio->uio_resid);
 995                 AUDIT_PIPE_UNLOCK(ap);
 996                 error = uiomove((char *)ape->ape_record + ap->ap_qoffset,
 997                     toread, uio);
 998                 if (error) {
 999                         AUDIT_PIPE_SX_XUNLOCK(ap);
1000                         return (error);
1001                 }
1002
1003                 /*
1004                  * If the copy succeeded, update book-keeping, and if no
1005                  * bytes remain in the current record, free it.
1006                  */
1007                 AUDIT_PIPE_LOCK(ap);
1008                 KASSERT(TAILQ_FIRST(&ap->ap_queue) == ape,
1009                     ("audit_pipe_read: queue out of sync after uiomove"));
1010                 ap->ap_qoffset += toread;
1011                 KASSERT(ape->ape_record_len >= ap->ap_qoffset,
1012                     ("audit_pipe_read: record_len >= qoffset (2)"));
1013                 if (ap->ap_qoffset == ape->ape_record_len) {
1014                         TAILQ_REMOVE(&ap->ap_queue, ape, ape_queue);
1015                         ap->ap_qbyteslen -= ape->ape_record_len;
1016                         audit_pipe_entry_free(ape);
1017                         ap->ap_qlen--;
1018                         ap->ap_qoffset = 0;
1019                 }
1020         }
1021         AUDIT_PIPE_UNLOCK(ap);
1022         AUDIT_PIPE_SX_XUNLOCK(ap);
1023         return (0);
1024 }
1025
1026 /*
1027  * Audit pipe poll.
1028  */
1029 static int
1030 audit_pipe_poll(struct cdev *dev, int events, struct thread *td)
1031 {
1032         struct audit_pipe *ap;
1033         int revents;
1034
1035         revents = 0;
1036         ap = dev->si_drv1;
1037         KASSERT(ap != NULL, ("audit_pipe_poll: ap == NULL"));
1038
1039         if (events & (POLLIN | POLLRDNORM)) {
1040                 AUDIT_PIPE_LOCK(ap);
1041                 if (TAILQ_FIRST(&ap->ap_queue) != NULL)
1042                         revents |= events & (POLLIN | POLLRDNORM);
1043                 else
1044                         selrecord(td, &ap->ap_selinfo);
1045                 AUDIT_PIPE_UNLOCK(ap);
1046         }
1047         return (revents);
1048 }
1049
1050 /*
1051  * Audit pipe kqfilter.
1052  */
1053 static int
1054 audit_pipe_kqfilter(struct cdev *dev, struct knote *kn)
1055 {
1056         struct audit_pipe *ap;
1057
1058         ap = dev->si_drv1;
1059         KASSERT(ap != NULL, ("audit_pipe_kqfilter: ap == NULL"));
1060
1061         if (kn->kn_filter != EVFILT_READ)
1062                 return (EINVAL);
1063
1064         kn->kn_fop = &audit_pipe_read_filterops;
1065         kn->kn_hook = ap;
1066
1067         AUDIT_PIPE_LOCK(ap);
1068         knlist_add(&ap->ap_selinfo.si_note, kn, 1);
1069         AUDIT_PIPE_UNLOCK(ap);
1070         return (0);
1071 }
1072
1073 /*
1074  * Return true if there are records available for reading on the pipe.
1075  */
1076 static int
1077 audit_pipe_kqread(struct knote *kn, long hint)
1078 {
1079         struct audit_pipe *ap;
1080
1081         ap = (struct audit_pipe *)kn->kn_hook;
1082         KASSERT(ap != NULL, ("audit_pipe_kqread: ap == NULL"));
1083         AUDIT_PIPE_LOCK_ASSERT(ap);
1084
1085         if (ap->ap_qlen != 0) {
1086                 kn->kn_data = ap->ap_qbyteslen - ap->ap_qoffset;
1087                 return (1);
1088         } else {
1089                 kn->kn_data = 0;
1090                 return (0);
1091         }
1092 }
1093
1094 /*
1095  * Detach kqueue state from audit pipe.
1096  */
1097 static void
1098 audit_pipe_kqdetach(struct knote *kn)
1099 {
1100         struct audit_pipe *ap;
1101
1102         ap = (struct audit_pipe *)kn->kn_hook;
1103         KASSERT(ap != NULL, ("audit_pipe_kqdetach: ap == NULL"));
1104
1105         AUDIT_PIPE_LOCK(ap);
1106         knlist_remove(&ap->ap_selinfo.si_note, kn, 1);
1107         AUDIT_PIPE_UNLOCK(ap);
1108 }
1109
1110 /*
1111  * Initialize the audit pipe system.
1112  */
1113 static void
1114 audit_pipe_init(void *unused)
1115 {
1116
1117         TAILQ_INIT(&audit_pipe_list);
1118         AUDIT_PIPE_LIST_LOCK_INIT();
1119
1120         clone_setup(&audit_pipe_clones);
1121         audit_pipe_eh_tag = EVENTHANDLER_REGISTER(dev_clone,
1122             audit_pipe_clone, 0, 1000);
1123         if (audit_pipe_eh_tag == NULL)
1124                 panic("audit_pipe_init: EVENTHANDLER_REGISTER");
1125 }
1126
1127 SYSINIT(audit_pipe_init, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, audit_pipe_init,
1128     NULL);