kernel/auditsc.c

   1 /* auditsc.c -- System-call auditing support
   2  * Handles all system-call specific auditing features.
   3  *
   4  * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
   5  * Copyright (C) 2005 IBM Corporation
   6  * All Rights Reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * Written by Rickard E. (Rik) Faith <faith@redhat.com>
  23  *
  24  * Many of the ideas implemented here are from Stephen C. Tweedie,
  25  * especially the idea of avoiding a copy by using getname.
  26  *
  27  * The method for actual interception of syscall entry and exit (not in
  28  * this file -- see entry.S) is based on a GPL'd patch written by
  29  * okir@suse.de and Copyright 2003 SuSE Linux AG.
  30  *
  31  * The support of additional filter rules compares (>, <, >=, <=) was
  32  * added by Dustin Kirkland <dustin.kirkland@us.ibm.com>, 2005.
  33  *
  34  */
  35
  36 #include <linux/init.h>
  37 #include <asm/types.h>
  38 #include <asm/atomic.h>
  39 #include <linux/mm.h>
  40 #include <linux/module.h>
  41 #include <linux/mount.h>
  42 #include <linux/socket.h>
  43 #include <linux/audit.h>
  44 #include <linux/personality.h>
  45 #include <linux/time.h>
  46 #include <linux/kthread.h>
  47 #include <linux/netlink.h>
  48 #include <linux/compiler.h>
  49 #include <asm/unistd.h>
  50
  51 /* 0 = no checking
  52    1 = put_count checking
  53    2 = verbose put_count checking
  54 */
  55 #define AUDIT_DEBUG 0
  56
  57 /* No syscall auditing will take place unless audit_enabled != 0. */
  58 extern int audit_enabled;
  59
  60 /* AUDIT_NAMES is the number of slots we reserve in the audit_context
  61  * for saving names from getname(). */
  62 #define AUDIT_NAMES    20
  63
  64 /* AUDIT_NAMES_RESERVED is the number of slots we reserve in the
  65  * audit_context from being used for nameless inodes from
  66  * path_lookup. */
  67 #define AUDIT_NAMES_RESERVED 7
  68
  69 /* At task start time, the audit_state is set in the audit_context using
  70    a per-task filter.  At syscall entry, the audit_state is augmented by
  71    the syscall filter. */
  72 enum audit_state {
  73         AUDIT_DISABLED,         /* Do not create per-task audit_context.
  74                                  * No syscall-specific audit records can
  75                                  * be generated. */
  76         AUDIT_SETUP_CONTEXT,    /* Create the per-task audit_context,
  77                                  * but don't necessarily fill it in at
  78                                  * syscall entry time (i.e., filter
  79                                  * instead). */
  80         AUDIT_BUILD_CONTEXT,    /* Create the per-task audit_context,
  81                                  * and always fill it in at syscall
  82                                  * entry time.  This makes a full
  83                                  * syscall record available if some
  84                                  * other part of the kernel decides it
  85                                  * should be recorded. */
  86         AUDIT_RECORD_CONTEXT    /* Create the per-task audit_context,
  87                                  * always fill it in at syscall entry
  88                                  * time, and always write out the audit
  89                                  * record at syscall exit time.  */
  90 };
  91
  92 /* When fs/namei.c:getname() is called, we store the pointer in name and
  93  * we don't let putname() free it (instead we free all of the saved
  94  * pointers at syscall exit time).
  95  *
  96  * Further, in fs/namei.c:path_lookup() we store the inode and device. */
  97 struct audit_names {
  98         const char      *name;
  99         unsigned long   ino;
 100         dev_t           dev;
 101         umode_t         mode;
 102         uid_t           uid;
 103         gid_t           gid;
 104         dev_t           rdev;
 105         unsigned        flags;
 106 };
 107
 108 struct audit_aux_data {
 109         struct audit_aux_data   *next;
 110         int                     type;
 111 };
 112
 113 #define AUDIT_AUX_IPCPERM       0
 114
 115 struct audit_aux_data_ipcctl {
 116         struct audit_aux_data   d;
 117         struct ipc_perm         p;
 118         unsigned long           qbytes;
 119         uid_t                   uid;
 120         gid_t                   gid;
 121         mode_t                  mode;
 122 };
 123
 124 struct audit_aux_data_socketcall {
 125         struct audit_aux_data   d;
 126         int                     nargs;
 127         unsigned long           args[0];
 128 };
 129
 130 struct audit_aux_data_sockaddr {
 131         struct audit_aux_data   d;
 132         int                     len;
 133         char                    a[0];
 134 };
 135
 136 struct audit_aux_data_path {
 137         struct audit_aux_data   d;
 138         struct dentry           *dentry;
 139         struct vfsmount         *mnt;
 140 };
 141
 142 /* The per-task audit context. */
 143 struct audit_context {
 144         int                 in_syscall; /* 1 if task is in a syscall */
 145         enum audit_state    state;
 146         unsigned int        serial;     /* serial number for record */
 147         struct timespec     ctime;      /* time of syscall entry */
 148         uid_t               loginuid;   /* login uid (identity) */
 149         int                 major;      /* syscall number */
 150         unsigned long       argv[4];    /* syscall arguments */
 151         int                 return_valid; /* return code is valid */
 152         long                return_code;/* syscall return code */
 153         int                 auditable;  /* 1 if record should be written */
 154         int                 name_count;
 155         struct audit_names  names[AUDIT_NAMES];
 156         struct dentry *     pwd;
 157         struct vfsmount *   pwdmnt;
 158         struct audit_context *previous; /* For nested syscalls */
 159         struct audit_aux_data *aux;
 160
 161                                 /* Save things to print about task_struct */
 162         pid_t               pid;
 163         uid_t               uid, euid, suid, fsuid;
 164         gid_t               gid, egid, sgid, fsgid;
 165         unsigned long       personality;
 166         int                 arch;
 167
 168 #if AUDIT_DEBUG
 169         int                 put_count;
 170         int                 ino_count;
 171 #endif
 172 };
 173
 174                                 /* Public API */
 175 /* There are three lists of rules -- one to search at task creation
 176  * time, one to search at syscall entry time, and another to search at
 177  * syscall exit time. */
 178 static struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
 179         LIST_HEAD_INIT(audit_filter_list[0]),
 180         LIST_HEAD_INIT(audit_filter_list[1]),
 181         LIST_HEAD_INIT(audit_filter_list[2]),
 182         LIST_HEAD_INIT(audit_filter_list[3]),
 183         LIST_HEAD_INIT(audit_filter_list[4]),
 184 #if AUDIT_NR_FILTERS != 5
 185 #error Fix audit_filter_list initialiser
 186 #endif
 187 };
 188
 189 struct audit_entry {
 190         struct list_head  list;
 191         struct rcu_head   rcu;
 192         struct audit_rule rule;
 193 };
 194
 195 extern int audit_pid;
 196
 197 /* Copy rule from user-space to kernel-space.  Called from
 198  * audit_add_rule during AUDIT_ADD. */
 199 static inline int audit_copy_rule(struct audit_rule *d, struct audit_rule *s)
 200 {
 201         int i;
 202
 203         if (s->action != AUDIT_NEVER
 204             && s->action != AUDIT_POSSIBLE
 205             && s->action != AUDIT_ALWAYS)
 206                 return -1;
 207         if (s->field_count < 0 || s->field_count > AUDIT_MAX_FIELDS)
 208                 return -1;
 209         if ((s->flags & ~AUDIT_FILTER_PREPEND) >= AUDIT_NR_FILTERS)
 210                 return -1;
 211
 212         d->flags        = s->flags;
 213         d->action       = s->action;
 214         d->field_count  = s->field_count;
 215         for (i = 0; i < d->field_count; i++) {
 216                 d->fields[i] = s->fields[i];
 217                 d->values[i] = s->values[i];
 218         }
 219         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) d->mask[i] = s->mask[i];
 220         return 0;
 221 }
 222
 223 /* Check to see if two rules are identical.  It is called from
 224  * audit_add_rule during AUDIT_ADD and
 225  * audit_del_rule during AUDIT_DEL. */
 226 static inline int audit_compare_rule(struct audit_rule *a, struct audit_rule *b)
 227 {
 228         int i;
 229
 230         if (a->flags != b->flags)
 231                 return 1;
 232
 233         if (a->action != b->action)
 234                 return 1;
 235
 236         if (a->field_count != b->field_count)
 237                 return 1;
 238
 239         for (i = 0; i < a->field_count; i++) {
 240                 if (a->fields[i] != b->fields[i]
 241                     || a->values[i] != b->values[i])
 242                         return 1;
 243         }
 244
 245         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
 246                 if (a->mask[i] != b->mask[i])
 247                         return 1;
 248
 249         return 0;
 250 }
 251
 252 /* Note that audit_add_rule and audit_del_rule are called via
 253  * audit_receive() in audit.c, and are protected by
 254  * audit_netlink_sem. */
 255 static inline int audit_add_rule(struct audit_rule *rule,
 256                                   struct list_head *list)
 257 {
 258         struct audit_entry  *entry;
 259         int i;
 260
 261         /* Do not use the _rcu iterator here, since this is the only
 262          * addition routine. */
 263         list_for_each_entry(entry, list, list) {
 264                 if (!audit_compare_rule(rule, &entry->rule)) {
 265                         return -EEXIST;
 266                 }
 267         }
 268
 269         for (i = 0; i < rule->field_count; i++) {
 270                 if (rule->fields[i] & AUDIT_UNUSED_BITS)
 271                         return -EINVAL;
 272                 if ( rule->fields[i] & AUDIT_NEGATE )
 273                         rule->fields[i] |= AUDIT_NOT_EQUAL;
 274                 else if ( (rule->fields[i] & AUDIT_OPERATORS) == 0 )
 275                         rule->fields[i] |= AUDIT_EQUAL;
 276                 rule->fields[i] &= (~AUDIT_NEGATE);
 277         }
 278
 279         if (!(entry = kmalloc(sizeof(*entry), GFP_KERNEL)))
 280                 return -ENOMEM;
 281         if (audit_copy_rule(&entry->rule, rule)) {
 282                 kfree(entry);
 283                 return -EINVAL;
 284         }
 285
 286         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
 287                 entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
 288                 list_add_rcu(&entry->list, list);
 289         } else {
 290                 list_add_tail_rcu(&entry->list, list);
 291         }
 292
 293         return 0;
 294 }
 295
 296 static inline void audit_free_rule(struct rcu_head *head)
 297 {
 298         struct audit_entry *e = container_of(head, struct audit_entry, rcu);
 299         kfree(e);
 300 }
 301
 302 /* Note that audit_add_rule and audit_del_rule are called via
 303  * audit_receive() in audit.c, and are protected by
 304  * audit_netlink_sem. */
 305 static inline int audit_del_rule(struct audit_rule *rule,
 306                                  struct list_head *list)
 307 {
 308         struct audit_entry  *e;
 309
 310         /* Do not use the _rcu iterator here, since this is the only
 311          * deletion routine. */
 312         list_for_each_entry(e, list, list) {
 313                 if (!audit_compare_rule(rule, &e->rule)) {
 314                         list_del_rcu(&e->list);
 315                         call_rcu(&e->rcu, audit_free_rule);
 316                         return 0;
 317                 }
 318         }
 319         return -ENOENT;         /* No matching rule */
 320 }
 321
 322 static int audit_list_rules(void *_dest)
 323 {
 324         int pid, seq;
 325         int *dest = _dest;
 326         struct audit_entry *entry;
 327         int i;
 328
 329         pid = dest[0];
 330         seq = dest[1];
 331         kfree(dest);
 332
 333         down(&audit_netlink_sem);
 334
 335         /* The *_rcu iterators not needed here because we are
 336            always called with audit_netlink_sem held. */
 337         for (i=0; i<AUDIT_NR_FILTERS; i++) {
 338                 list_for_each_entry(entry, &audit_filter_list[i], list)
 339                         audit_send_reply(pid, seq, AUDIT_LIST, 0, 1,
 340                                          &entry->rule, sizeof(entry->rule));
 341         }
 342         audit_send_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
 343
 344         up(&audit_netlink_sem);
 345         return 0;
 346 }
 347
 348 /**
 349  * audit_receive_filter - apply all rules to the specified message type
 350  * @type: audit message type
 351  * @pid: target pid for netlink audit messages
 352  * @uid: target uid for netlink audit messages
 353  * @seq: netlink audit message sequence (serial) number
 354  * @data: payload data
 355  * @loginuid: loginuid of sender
 356  */
 357 int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
 358                                                         uid_t loginuid)
 359 {
 360         struct task_struct *tsk;
 361         int *dest;
 362         int                err = 0;
 363         unsigned listnr;
 364
 365         switch (type) {
 366         case AUDIT_LIST:
 367                 /* We can't just spew out the rules here because we might fill
 368                  * the available socket buffer space and deadlock waiting for
 369                  * auditctl to read from it... which isn't ever going to
 370                  * happen if we're actually running in the context of auditctl
 371                  * trying to _send_ the stuff */
 372
 373                 dest = kmalloc(2 * sizeof(int), GFP_KERNEL);
 374                 if (!dest)
 375                         return -ENOMEM;
 376                 dest[0] = pid;
 377                 dest[1] = seq;
 378
 379                 tsk = kthread_run(audit_list_rules, dest, "audit_list_rules");
 380                 if (IS_ERR(tsk)) {
 381                         kfree(dest);
 382                         err = PTR_ERR(tsk);
 383                 }
 384                 break;
 385         case AUDIT_ADD:
 386                 listnr =((struct audit_rule *)data)->flags & ~AUDIT_FILTER_PREPEND;
 387                 if (listnr >= AUDIT_NR_FILTERS)
 388                         return -EINVAL;
 389
 390                 err = audit_add_rule(data, &audit_filter_list[listnr]);
 391                 if (!err)
 392                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 393                                   "auid=%u added an audit rule\n", loginuid);
 394                 break;
 395         case AUDIT_DEL:
 396                 listnr =((struct audit_rule *)data)->flags & ~AUDIT_FILTER_PREPEND;
 397                 if (listnr >= AUDIT_NR_FILTERS)
 398                         return -EINVAL;
 399
 400                 err = audit_del_rule(data, &audit_filter_list[listnr]);
 401                 if (!err)
 402                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 403                                   "auid=%u removed an audit rule\n", loginuid);
 404                 break;
 405         default:
 406                 return -EINVAL;
 407         }
 408
 409         return err;
 410 }
 411
 412 static int audit_comparator(const u32 left, const u32 op, const u32 right)
 413 {
 414         switch (op) {
 415         case AUDIT_EQUAL:
 416                 return (left == right);
 417         case AUDIT_NOT_EQUAL:
 418                 return (left != right);
 419         case AUDIT_LESS_THAN:
 420                 return (left < right);
 421         case AUDIT_LESS_THAN_OR_EQUAL:
 422                 return (left <= right);
 423         case AUDIT_GREATER_THAN:
 424                 return (left > right);
 425         case AUDIT_GREATER_THAN_OR_EQUAL:
 426                 return (left >= right);
 427         default:
 428                 return -EINVAL;
 429         }
 430 }
 431
 432 /* Compare a task_struct with an audit_rule.  Return 1 on match, 0
 433  * otherwise. */
 434 static int audit_filter_rules(struct task_struct *tsk,
 435                               struct audit_rule *rule,
 436                               struct audit_context *ctx,
 437                               enum audit_state *state)
 438 {
 439         int i, j;
 440
 441         for (i = 0; i < rule->field_count; i++) {
 442                 u32 field  = rule->fields[i] & ~AUDIT_OPERATORS;
 443                 u32 op  = rule->fields[i] & AUDIT_OPERATORS;
 444                 u32 value  = rule->values[i];
 445                 int result = 0;
 446
 447                 switch (field) {
 448                 case AUDIT_PID:
 449                         result = audit_comparator(tsk->pid, op, value);
 450                         break;
 451                 case AUDIT_UID:
 452                         result = audit_comparator(tsk->uid, op, value);
 453                         break;
 454                 case AUDIT_EUID:
 455                         result = audit_comparator(tsk->euid, op, value);
 456                         break;
 457                 case AUDIT_SUID:
 458                         result = audit_comparator(tsk->suid, op, value);
 459                         break;
 460                 case AUDIT_FSUID:
 461                         result = audit_comparator(tsk->fsuid, op, value);
 462                         break;
 463                 case AUDIT_GID:
 464                         result = audit_comparator(tsk->gid, op, value);
 465                         break;
 466                 case AUDIT_EGID:
 467                         result = audit_comparator(tsk->egid, op, value);
 468                         break;
 469                 case AUDIT_SGID:
 470                         result = audit_comparator(tsk->sgid, op, value);
 471                         break;
 472                 case AUDIT_FSGID:
 473                         result = audit_comparator(tsk->fsgid, op, value);
 474                         break;
 475                 case AUDIT_PERS:
 476                         result = audit_comparator(tsk->personality, op, value);
 477                         break;
 478                 case AUDIT_ARCH:
 479                         if (ctx)
 480                                 result = audit_comparator(ctx->arch, op, value);
 481                         break;
 482
 483                 case AUDIT_EXIT:
 484                         if (ctx && ctx->return_valid)
 485                                 result = audit_comparator(ctx->return_code, op, value);
 486                         break;
 487                 case AUDIT_SUCCESS:
 488                         if (ctx && ctx->return_valid) {
 489                                 if (value)
 490                                         result = audit_comparator(ctx->return_valid, op, AUDITSC_SUCCESS);
 491                                 else
 492                                         result = audit_comparator(ctx->return_valid, op, AUDITSC_FAILURE);
 493                         }
 494                         break;
 495                 case AUDIT_DEVMAJOR:
 496                         if (ctx) {
 497                                 for (j = 0; j < ctx->name_count; j++) {
 498                                         if (audit_comparator(MAJOR(ctx->names[j].dev),  op, value)) {
 499                                                 ++result;
 500                                                 break;
 501                                         }
 502                                 }
 503                         }
 504                         break;
 505                 case AUDIT_DEVMINOR:
 506                         if (ctx) {
 507                                 for (j = 0; j < ctx->name_count; j++) {
 508                                         if (audit_comparator(MINOR(ctx->names[j].dev), op, value)) {
 509                                                 ++result;
 510                                                 break;
 511                                         }
 512                                 }
 513                         }
 514                         break;
 515                 case AUDIT_INODE:
 516                         if (ctx) {
 517                                 for (j = 0; j < ctx->name_count; j++) {
 518                                         if (audit_comparator(ctx->names[j].ino, op, value)) {
 519                                                 ++result;
 520                                                 break;
 521                                         }
 522                                 }
 523                         }
 524                         break;
 525                 case AUDIT_LOGINUID:
 526                         result = 0;
 527                         if (ctx)
 528                                 result = audit_comparator(ctx->loginuid, op, value);
 529                         break;
 530                 case AUDIT_ARG0:
 531                 case AUDIT_ARG1:
 532                 case AUDIT_ARG2:
 533                 case AUDIT_ARG3:
 534                         if (ctx)
 535                                 result = audit_comparator(ctx->argv[field-AUDIT_ARG0], op, value);
 536                         break;
 537                 }
 538
 539                 if (!result)
 540                         return 0;
 541         }
 542         switch (rule->action) {
 543         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
 544         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
 545         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
 546         }
 547         return 1;
 548 }
 549
 550 /* At process creation time, we can determine if system-call auditing is
 551  * completely disabled for this task.  Since we only have the task
 552  * structure at this point, we can only check uid and gid.
 553  */
 554 static enum audit_state audit_filter_task(struct task_struct *tsk)
 555 {
 556         struct audit_entry *e;
 557         enum audit_state   state;
 558
 559         rcu_read_lock();
 560         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
 561                 if (audit_filter_rules(tsk, &e->rule, NULL, &state)) {
 562                         rcu_read_unlock();
 563                         return state;
 564                 }
 565         }
 566         rcu_read_unlock();
 567         return AUDIT_BUILD_CONTEXT;
 568 }
 569
 570 /* At syscall entry and exit time, this filter is called if the
 571  * audit_state is not low enough that auditing cannot take place, but is
 572  * also not high enough that we already know we have to write an audit
 573  * record (i.e., the state is AUDIT_SETUP_CONTEXT or AUDIT_BUILD_CONTEXT).
 574  */
 575 static enum audit_state audit_filter_syscall(struct task_struct *tsk,
 576                                              struct audit_context *ctx,
 577                                              struct list_head *list)
 578 {
 579         struct audit_entry *e;
 580         enum audit_state state;
 581
 582         if (audit_pid && tsk->tgid == audit_pid)
 583                 return AUDIT_DISABLED;
 584
 585         rcu_read_lock();
 586         if (!list_empty(list)) {
 587                 int word = AUDIT_WORD(ctx->major);
 588                 int bit  = AUDIT_BIT(ctx->major);
 589
 590                 list_for_each_entry_rcu(e, list, list) {
 591                         if ((e->rule.mask[word] & bit) == bit
 592                                         && audit_filter_rules(tsk, &e->rule, ctx, &state)) {
 593                                 rcu_read_unlock();
 594                                 return state;
 595                         }
 596                 }
 597         }
 598         rcu_read_unlock();
 599         return AUDIT_BUILD_CONTEXT;
 600 }
 601
 602 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
 603                                    struct audit_rule *rule,
 604                                    enum audit_state *state)
 605 {
 606         int i;
 607
 608         for (i = 0; i < rule->field_count; i++) {
 609                 u32 field  = rule->fields[i] & ~AUDIT_OPERATORS;
 610                 u32 op  = rule->fields[i] & AUDIT_OPERATORS;
 611                 u32 value  = rule->values[i];
 612                 int result = 0;
 613
 614                 switch (field) {
 615                 case AUDIT_PID:
 616                         result = audit_comparator(cb->creds.pid, op, value);
 617                         break;
 618                 case AUDIT_UID:
 619                         result = audit_comparator(cb->creds.uid, op, value);
 620                         break;
 621                 case AUDIT_GID:
 622                         result = audit_comparator(cb->creds.gid, op, value);
 623                         break;
 624                 case AUDIT_LOGINUID:
 625                         result = audit_comparator(cb->loginuid, op, value);
 626                         break;
 627                 }
 628
 629                 if (!result)
 630                         return 0;
 631         }
 632         switch (rule->action) {
 633         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
 634         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
 635         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
 636         }
 637         return 1;
 638 }
 639
 640 int audit_filter_user(struct netlink_skb_parms *cb, int type)
 641 {
 642         struct audit_entry *e;
 643         enum audit_state   state;
 644         int ret = 1;
 645
 646         rcu_read_lock();
 647         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_USER], list) {
 648                 if (audit_filter_user_rules(cb, &e->rule, &state)) {
 649                         if (state == AUDIT_DISABLED)
 650                                 ret = 0;
 651                         break;
 652                 }
 653         }
 654         rcu_read_unlock();
 655
 656         return ret; /* Audit by default */
 657 }
 658
 659 /* This should be called with task_lock() held. */
 660 static inline struct audit_context *audit_get_context(struct task_struct *tsk,
 661                                                       int return_valid,
 662                                                       int return_code)
 663 {
 664         struct audit_context *context = tsk->audit_context;
 665
 666         if (likely(!context))
 667                 return NULL;
 668         context->return_valid = return_valid;
 669         context->return_code  = return_code;
 670
 671         if (context->in_syscall && !context->auditable) {
 672                 enum audit_state state;
 673                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
 674                 if (state == AUDIT_RECORD_CONTEXT)
 675                         context->auditable = 1;
 676         }
 677
 678         context->pid = tsk->pid;
 679         context->uid = tsk->uid;
 680         context->gid = tsk->gid;
 681         context->euid = tsk->euid;
 682         context->suid = tsk->suid;
 683         context->fsuid = tsk->fsuid;
 684         context->egid = tsk->egid;
 685         context->sgid = tsk->sgid;
 686         context->fsgid = tsk->fsgid;
 687         context->personality = tsk->personality;
 688         tsk->audit_context = NULL;
 689         return context;
 690 }
 691
 692 static inline void audit_free_names(struct audit_context *context)
 693 {
 694         int i;
 695
 696 #if AUDIT_DEBUG == 2
 697         if (context->auditable
 698             ||context->put_count + context->ino_count != context->name_count) {
 699                 printk(KERN_ERR "audit.c:%d(:%d): major=%d in_syscall=%d"
 700                        " name_count=%d put_count=%d"
 701                        " ino_count=%d [NOT freeing]\n",
 702                        __LINE__,
 703                        context->serial, context->major, context->in_syscall,
 704                        context->name_count, context->put_count,
 705                        context->ino_count);
 706                 for (i = 0; i < context->name_count; i++)
 707                         printk(KERN_ERR "names[%d] = %p = %s\n", i,
 708                                context->names[i].name,
 709                                context->names[i].name);
 710                 dump_stack();
 711                 return;
 712         }
 713 #endif
 714 #if AUDIT_DEBUG
 715         context->put_count  = 0;
 716         context->ino_count  = 0;
 717 #endif
 718
 719         for (i = 0; i < context->name_count; i++)
 720                 if (context->names[i].name)
 721                         __putname(context->names[i].name);
 722         context->name_count = 0;
 723         if (context->pwd)
 724                 dput(context->pwd);
 725         if (context->pwdmnt)
 726                 mntput(context->pwdmnt);
 727         context->pwd = NULL;
 728         context->pwdmnt = NULL;
 729 }
 730
 731 static inline void audit_free_aux(struct audit_context *context)
 732 {
 733         struct audit_aux_data *aux;
 734
 735         while ((aux = context->aux)) {
 736                 if (aux->type == AUDIT_AVC_PATH) {
 737                         struct audit_aux_data_path *axi = (void *)aux;
 738                         dput(axi->dentry);
 739                         mntput(axi->mnt);
 740                 }
 741                 context->aux = aux->next;
 742                 kfree(aux);
 743         }
 744 }
 745
 746 static inline void audit_zero_context(struct audit_context *context,
 747                                       enum audit_state state)
 748 {
 749         uid_t loginuid = context->loginuid;
 750
 751         memset(context, 0, sizeof(*context));
 752         context->state      = state;
 753         context->loginuid   = loginuid;
 754 }
 755
 756 static inline struct audit_context *audit_alloc_context(enum audit_state state)
 757 {
 758         struct audit_context *context;
 759
 760         if (!(context = kmalloc(sizeof(*context), GFP_KERNEL)))
 761                 return NULL;
 762         audit_zero_context(context, state);
 763         return context;
 764 }
 765
 766 /**
 767  * audit_alloc - allocate an audit context block for a task
 768  * @tsk: task
 769  *
 770  * Filter on the task information and allocate a per-task audit context
 771  * if necessary.  Doing so turns on system call auditing for the
 772  * specified task.  This is called from copy_process, so no lock is
 773  * needed.
 774  */
 775 int audit_alloc(struct task_struct *tsk)
 776 {
 777         struct audit_context *context;
 778         enum audit_state     state;
 779
 780         if (likely(!audit_enabled))
 781                 return 0; /* Return if not auditing. */
 782
 783         state = audit_filter_task(tsk);
 784         if (likely(state == AUDIT_DISABLED))
 785                 return 0;
 786
 787         if (!(context = audit_alloc_context(state))) {
 788                 audit_log_lost("out of memory in audit_alloc");
 789                 return -ENOMEM;
 790         }
 791
 792                                 /* Preserve login uid */
 793         context->loginuid = -1;
 794         if (current->audit_context)
 795                 context->loginuid = current->audit_context->loginuid;
 796
 797         tsk->audit_context  = context;
 798         set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
 799         return 0;
 800 }
 801
 802 static inline void audit_free_context(struct audit_context *context)
 803 {
 804         struct audit_context *previous;
 805         int                  count = 0;
 806
 807         do {
 808                 previous = context->previous;
 809                 if (previous || (count &&  count < 10)) {
 810                         ++count;
 811                         printk(KERN_ERR "audit(:%d): major=%d name_count=%d:"
 812                                " freeing multiple contexts (%d)\n",
 813                                context->serial, context->major,
 814                                context->name_count, count);
 815                 }
 816                 audit_free_names(context);
 817                 audit_free_aux(context);
 818                 kfree(context);
 819                 context  = previous;
 820         } while (context);
 821         if (count >= 10)
 822                 printk(KERN_ERR "audit: freed %d contexts\n", count);
 823 }
 824
 825 static void audit_log_task_info(struct audit_buffer *ab)
 826 {
 827         char name[sizeof(current->comm)];
 828         struct mm_struct *mm = current->mm;
 829         struct vm_area_struct *vma;
 830
 831         get_task_comm(name, current);
 832         audit_log_format(ab, " comm=");
 833         audit_log_untrustedstring(ab, name);
 834
 835         if (!mm)
 836                 return;
 837
 838         down_read(&mm->mmap_sem);
 839         vma = mm->mmap;
 840         while (vma) {
 841                 if ((vma->vm_flags & VM_EXECUTABLE) &&
 842                     vma->vm_file) {
 843                         audit_log_d_path(ab, "exe=",
 844                                          vma->vm_file->f_dentry,
 845                                          vma->vm_file->f_vfsmnt);
 846                         break;
 847                 }
 848                 vma = vma->vm_next;
 849         }
 850         up_read(&mm->mmap_sem);
 851 }
 852
 853 static void audit_log_exit(struct audit_context *context, gfp_t gfp_mask)
 854 {
 855         int i;
 856         struct audit_buffer *ab;
 857         struct audit_aux_data *aux;
 858
 859         ab = audit_log_start(context, gfp_mask, AUDIT_SYSCALL);
 860         if (!ab)
 861                 return;         /* audit_panic has been called */
 862         audit_log_format(ab, "arch=%x syscall=%d",
 863                          context->arch, context->major);
 864         if (context->personality != PER_LINUX)
 865                 audit_log_format(ab, " per=%lx", context->personality);
 866         if (context->return_valid)
 867                 audit_log_format(ab, " success=%s exit=%ld",
 868                                  (context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
 869                                  context->return_code);
 870         audit_log_format(ab,
 871                   " a0=%lx a1=%lx a2=%lx a3=%lx items=%d"
 872                   " pid=%d auid=%u uid=%u gid=%u"
 873                   " euid=%u suid=%u fsuid=%u"
 874                   " egid=%u sgid=%u fsgid=%u",
 875                   context->argv[0],
 876                   context->argv[1],
 877                   context->argv[2],
 878                   context->argv[3],
 879                   context->name_count,
 880                   context->pid,
 881                   context->loginuid,
 882                   context->uid,
 883                   context->gid,
 884                   context->euid, context->suid, context->fsuid,
 885                   context->egid, context->sgid, context->fsgid);
 886         audit_log_task_info(ab);
 887         audit_log_end(ab);
 888
 889         for (aux = context->aux; aux; aux = aux->next) {
 890
 891                 ab = audit_log_start(context, gfp_mask, aux->type);
 892                 if (!ab)
 893                         continue; /* audit_panic has been called */
 894
 895                 switch (aux->type) {
 896                 case AUDIT_IPC: {
 897                         struct audit_aux_data_ipcctl *axi = (void *)aux;
 898                         audit_log_format(ab,
 899                                          " qbytes=%lx iuid=%u igid=%u mode=%x",
 900                                          axi->qbytes, axi->uid, axi->gid, axi->mode);
 901                         break; }
 902
 903                 case AUDIT_SOCKETCALL: {
 904                         int i;
 905                         struct audit_aux_data_socketcall *axs = (void *)aux;
 906                         audit_log_format(ab, "nargs=%d", axs->nargs);
 907                         for (i=0; i<axs->nargs; i++)
 908                                 audit_log_format(ab, " a%d=%lx", i, axs->args[i]);
 909                         break; }
 910
 911                 case AUDIT_SOCKADDR: {
 912                         struct audit_aux_data_sockaddr *axs = (void *)aux;
 913
 914                         audit_log_format(ab, "saddr=");
 915                         audit_log_hex(ab, axs->a, axs->len);
 916                         break; }
 917
 918                 case AUDIT_AVC_PATH: {
 919                         struct audit_aux_data_path *axi = (void *)aux;
 920                         audit_log_d_path(ab, "path=", axi->dentry, axi->mnt);
 921                         break; }
 922
 923                 }
 924                 audit_log_end(ab);
 925         }
 926
 927         if (context->pwd && context->pwdmnt) {
 928                 ab = audit_log_start(context, gfp_mask, AUDIT_CWD);
 929                 if (ab) {
 930                         audit_log_d_path(ab, "cwd=", context->pwd, context->pwdmnt);
 931                         audit_log_end(ab);
 932                 }
 933         }
 934         for (i = 0; i < context->name_count; i++) {
 935                 ab = audit_log_start(context, gfp_mask, AUDIT_PATH);
 936                 if (!ab)
 937                         continue; /* audit_panic has been called */
 938
 939                 audit_log_format(ab, "item=%d", i);
 940                 if (context->names[i].name) {
 941                         audit_log_format(ab, " name=");
 942                         audit_log_untrustedstring(ab, context->names[i].name);
 943                 }
 944                 audit_log_format(ab, " flags=%x\n", context->names[i].flags);
 945
 946                 if (context->names[i].ino != (unsigned long)-1)
 947                         audit_log_format(ab, " inode=%lu dev=%02x:%02x mode=%#o"
 948                                              " ouid=%u ogid=%u rdev=%02x:%02x",
 949                                          context->names[i].ino,
 950                                          MAJOR(context->names[i].dev),
 951                                          MINOR(context->names[i].dev),
 952                                          context->names[i].mode,
 953                                          context->names[i].uid,
 954                                          context->names[i].gid,
 955                                          MAJOR(context->names[i].rdev),
 956                                          MINOR(context->names[i].rdev));
 957                 audit_log_end(ab);
 958         }
 959 }
 960
 961 /**
 962  * audit_free - free a per-task audit context
 963  * @tsk: task whose audit context block to free
 964  *
 965  * Called from copy_process and __put_task_struct.
 966  */
 967 void audit_free(struct task_struct *tsk)
 968 {
 969         struct audit_context *context;
 970
 971         task_lock(tsk);
 972         context = audit_get_context(tsk, 0, 0);
 973         task_unlock(tsk);
 974
 975         if (likely(!context))
 976                 return;
 977
 978         /* Check for system calls that do not go through the exit
 979          * function (e.g., exit_group), then free context block.
 980          * We use GFP_ATOMIC here because we might be doing this
 981          * in the context of the idle thread */
 982         if (context->in_syscall && context->auditable)
 983                 audit_log_exit(context, GFP_ATOMIC);
 984
 985         audit_free_context(context);
 986 }
 987
 988 /**
 989  * audit_syscall_entry - fill in an audit record at syscall entry
 990  * @tsk: task being audited
 991  * @arch: architecture type
 992  * @major: major syscall type (function)
 993  * @a1: additional syscall register 1
 994  * @a2: additional syscall register 2
 995  * @a3: additional syscall register 3
 996  * @a4: additional syscall register 4
 997  *
 998  * Fill in audit context at syscall entry.  This only happens if the
 999  * audit context was created when the task was created and the state or
1000  * filters demand the audit context be built.  If the state from the
1001  * per-task filter or from the per-syscall filter is AUDIT_RECORD_CONTEXT,
1002  * then the record will be written at syscall exit time (otherwise, it
1003  * will only be written if another part of the kernel requests that it
1004  * be written).
1005  */
1006 void audit_syscall_entry(struct task_struct *tsk, int arch, int major,
1007                          unsigned long a1, unsigned long a2,
1008                          unsigned long a3, unsigned long a4)
1009 {
1010         struct audit_context *context = tsk->audit_context;
1011         enum audit_state     state;
1012
1013         BUG_ON(!context);
1014
1015         /*
1016          * This happens only on certain architectures that make system
1017          * calls in kernel_thread via the entry.S interface, instead of
1018          * with direct calls.  (If you are porting to a new
1019          * architecture, hitting this condition can indicate that you
1020          * got the _exit/_leave calls backward in entry.S.)
1021          *
1022          * i386     no
1023          * x86_64   no
1024          * ppc64    yes (see arch/ppc64/kernel/misc.S)
1025          *
1026          * This also happens with vm86 emulation in a non-nested manner
1027          * (entries without exits), so this case must be caught.
1028          */
1029         if (context->in_syscall) {
1030                 struct audit_context *newctx;
1031
1032 #if AUDIT_DEBUG
1033                 printk(KERN_ERR
1034                        "audit(:%d) pid=%d in syscall=%d;"
1035                        " entering syscall=%d\n",
1036                        context->serial, tsk->pid, context->major, major);
1037 #endif
1038                 newctx = audit_alloc_context(context->state);
1039                 if (newctx) {
1040                         newctx->previous   = context;
1041                         context            = newctx;
1042                         tsk->audit_context = newctx;
1043                 } else  {
1044                         /* If we can't alloc a new context, the best we
1045                          * can do is to leak memory (any pending putname
1046                          * will be lost).  The only other alternative is
1047                          * to abandon auditing. */
1048                         audit_zero_context(context, context->state);
1049                 }
1050         }
1051         BUG_ON(context->in_syscall || context->name_count);
1052
1053         if (!audit_enabled)
1054                 return;
1055
1056         context->arch       = arch;
1057         context->major      = major;
1058         context->argv[0]    = a1;
1059         context->argv[1]    = a2;
1060         context->argv[2]    = a3;
1061         context->argv[3]    = a4;
1062
1063         state = context->state;
1064         if (state == AUDIT_SETUP_CONTEXT || state == AUDIT_BUILD_CONTEXT)
1065                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
1066         if (likely(state == AUDIT_DISABLED))
1067                 return;
1068
1069         context->serial     = 0;
1070         context->ctime      = CURRENT_TIME;
1071         context->in_syscall = 1;
1072         context->auditable  = !!(state == AUDIT_RECORD_CONTEXT);
1073 }
1074
1075 /**
1076  * audit_syscall_exit - deallocate audit context after a system call
1077  * @tsk: task being audited
1078  * @valid: success/failure flag
1079  * @return_code: syscall return value
1080  *
1081  * Tear down after system call.  If the audit context has been marked as
1082  * auditable (either because of the AUDIT_RECORD_CONTEXT state from
1083  * filtering, or because some other part of the kernel write an audit
1084  * message), then write out the syscall information.  In call cases,
1085  * free the names stored from getname().
1086  */
1087 void audit_syscall_exit(struct task_struct *tsk, int valid, long return_code)
1088 {
1089         struct audit_context *context;
1090
1091         get_task_struct(tsk);
1092         task_lock(tsk);
1093         context = audit_get_context(tsk, valid, return_code);
1094         task_unlock(tsk);
1095
1096         /* Not having a context here is ok, since the parent may have
1097          * called __put_task_struct. */
1098         if (likely(!context))
1099                 goto out;
1100
1101         if (context->in_syscall && context->auditable)
1102                 audit_log_exit(context, GFP_KERNEL);
1103
1104         context->in_syscall = 0;
1105         context->auditable  = 0;
1106
1107         if (context->previous) {
1108                 struct audit_context *new_context = context->previous;
1109                 context->previous  = NULL;
1110                 audit_free_context(context);
1111                 tsk->audit_context = new_context;
1112         } else {
1113                 audit_free_names(context);
1114                 audit_free_aux(context);
1115                 tsk->audit_context = context;
1116         }
1117  out:
1118         put_task_struct(tsk);
1119 }
1120
1121 /**
1122  * audit_getname - add a name to the list
1123  * @name: name to add
1124  *
1125  * Add a name to the list of audit names for this context.
1126  * Called from fs/namei.c:getname().
1127  */
1128 void audit_getname(const char *name)
1129 {
1130         struct audit_context *context = current->audit_context;
1131
1132         if (!context || IS_ERR(name) || !name)
1133                 return;
1134
1135         if (!context->in_syscall) {
1136 #if AUDIT_DEBUG == 2
1137                 printk(KERN_ERR "%s:%d(:%d): ignoring getname(%p)\n",
1138                        __FILE__, __LINE__, context->serial, name);
1139                 dump_stack();
1140 #endif
1141                 return;
1142         }
1143         BUG_ON(context->name_count >= AUDIT_NAMES);
1144         context->names[context->name_count].name = name;
1145         context->names[context->name_count].ino  = (unsigned long)-1;
1146         ++context->name_count;
1147         if (!context->pwd) {
1148                 read_lock(&current->fs->lock);
1149                 context->pwd = dget(current->fs->pwd);
1150                 context->pwdmnt = mntget(current->fs->pwdmnt);
1151                 read_unlock(&current->fs->lock);
1152         }
1153
1154 }
1155
1156 /* audit_putname - intercept a putname request
1157  * @name: name to intercept and delay for putname
1158  *
1159  * If we have stored the name from getname in the audit context,
1160  * then we delay the putname until syscall exit.
1161  * Called from include/linux/fs.h:putname().
1162  */
1163 void audit_putname(const char *name)
1164 {
1165         struct audit_context *context = current->audit_context;
1166
1167         BUG_ON(!context);
1168         if (!context->in_syscall) {
1169 #if AUDIT_DEBUG == 2
1170                 printk(KERN_ERR "%s:%d(:%d): __putname(%p)\n",
1171                        __FILE__, __LINE__, context->serial, name);
1172                 if (context->name_count) {
1173                         int i;
1174                         for (i = 0; i < context->name_count; i++)
1175                                 printk(KERN_ERR "name[%d] = %p = %s\n", i,
1176                                        context->names[i].name,
1177                                        context->names[i].name);
1178                 }
1179 #endif
1180                 __putname(name);
1181         }
1182 #if AUDIT_DEBUG
1183         else {
1184                 ++context->put_count;
1185                 if (context->put_count > context->name_count) {
1186                         printk(KERN_ERR "%s:%d(:%d): major=%d"
1187                                " in_syscall=%d putname(%p) name_count=%d"
1188                                " put_count=%d\n",
1189                                __FILE__, __LINE__,
1190                                context->serial, context->major,
1191                                context->in_syscall, name, context->name_count,
1192                                context->put_count);
1193                         dump_stack();
1194                 }
1195         }
1196 #endif
1197 }
1198
1199 /**
1200  * audit_inode - store the inode and device from a lookup
1201  * @name: name being audited
1202  * @inode: inode being audited
1203  * @flags: lookup flags (as used in path_lookup())
1204  *
1205  * Called from fs/namei.c:path_lookup().
1206  */
1207 void audit_inode(const char *name, const struct inode *inode, unsigned flags)
1208 {
1209         int idx;
1210         struct audit_context *context = current->audit_context;
1211
1212         if (!context->in_syscall)
1213                 return;
1214         if (context->name_count
1215             && context->names[context->name_count-1].name
1216             && context->names[context->name_count-1].name == name)
1217                 idx = context->name_count - 1;
1218         else if (context->name_count > 1
1219                  && context->names[context->name_count-2].name
1220                  && context->names[context->name_count-2].name == name)
1221                 idx = context->name_count - 2;
1222         else {
1223                 /* FIXME: how much do we care about inodes that have no
1224                  * associated name? */
1225                 if (context->name_count >= AUDIT_NAMES - AUDIT_NAMES_RESERVED)
1226                         return;
1227                 idx = context->name_count++;
1228                 context->names[idx].name = NULL;
1229 #if AUDIT_DEBUG
1230                 ++context->ino_count;
1231 #endif
1232         }
1233         context->names[idx].flags = flags;
1234         context->names[idx].ino   = inode->i_ino;
1235         context->names[idx].dev   = inode->i_sb->s_dev;
1236         context->names[idx].mode  = inode->i_mode;
1237         context->names[idx].uid   = inode->i_uid;
1238         context->names[idx].gid   = inode->i_gid;
1239         context->names[idx].rdev  = inode->i_rdev;
1240 }
1241
1242 /**
1243  * auditsc_get_stamp - get local copies of audit_context values
1244  * @ctx: audit_context for the task
1245  * @t: timespec to store time recorded in the audit_context
1246  * @serial: serial value that is recorded in the audit_context
1247  *
1248  * Also sets the context as auditable.
1249  */
1250 void auditsc_get_stamp(struct audit_context *ctx,
1251                        struct timespec *t, unsigned int *serial)
1252 {
1253         if (!ctx->serial)
1254                 ctx->serial = audit_serial();
1255         t->tv_sec  = ctx->ctime.tv_sec;
1256         t->tv_nsec = ctx->ctime.tv_nsec;
1257         *serial    = ctx->serial;
1258         ctx->auditable = 1;
1259 }
1260
1261 /**
1262  * audit_set_loginuid - set a task's audit_context loginuid
1263  * @task: task whose audit context is being modified
1264  * @loginuid: loginuid value
1265  *
1266  * Returns 0.
1267  *
1268  * Called (set) from fs/proc/base.c::proc_loginuid_write().
1269  */
1270 int audit_set_loginuid(struct task_struct *task, uid_t loginuid)
1271 {
1272         if (task->audit_context) {
1273                 struct audit_buffer *ab;
1274
1275                 ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
1276                 if (ab) {
1277                         audit_log_format(ab, "login pid=%d uid=%u "
1278                                 "old auid=%u new auid=%u",
1279                                 task->pid, task->uid,
1280                                 task->audit_context->loginuid, loginuid);
1281                         audit_log_end(ab);
1282                 }
1283                 task->audit_context->loginuid = loginuid;
1284         }
1285         return 0;
1286 }
1287
1288 /**
1289  * audit_get_loginuid - get the loginuid for an audit_context
1290  * @ctx: the audit_context
1291  *
1292  * Returns the context's loginuid or -1 if @ctx is NULL.
1293  */
1294 uid_t audit_get_loginuid(struct audit_context *ctx)
1295 {
1296         return ctx ? ctx->loginuid : -1;
1297 }
1298
1299 /**
1300  * audit_ipc_perms - record audit data for ipc
1301  * @qbytes: msgq bytes
1302  * @uid: msgq user id
1303  * @gid: msgq group id
1304  * @mode: msgq mode (permissions)
1305  *
1306  * Returns 0 for success or NULL context or < 0 on error.
1307  */
1308 int audit_ipc_perms(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
1309 {
1310         struct audit_aux_data_ipcctl *ax;
1311         struct audit_context *context = current->audit_context;
1312
1313         if (likely(!context))
1314                 return 0;
1315
1316         ax = kmalloc(sizeof(*ax), GFP_KERNEL);
1317         if (!ax)
1318                 return -ENOMEM;
1319
1320         ax->qbytes = qbytes;
1321         ax->uid = uid;
1322         ax->gid = gid;
1323         ax->mode = mode;
1324
1325         ax->d.type = AUDIT_IPC;
1326         ax->d.next = context->aux;
1327         context->aux = (void *)ax;
1328         return 0;
1329 }
1330
1331 /**
1332  * audit_socketcall - record audit data for sys_socketcall
1333  * @nargs: number of args
1334  * @args: args array
1335  *
1336  * Returns 0 for success or NULL context or < 0 on error.
1337  */
1338 int audit_socketcall(int nargs, unsigned long *args)
1339 {
1340         struct audit_aux_data_socketcall *ax;
1341         struct audit_context *context = current->audit_context;
1342
1343         if (likely(!context))
1344                 return 0;
1345
1346         ax = kmalloc(sizeof(*ax) + nargs * sizeof(unsigned long), GFP_KERNEL);
1347         if (!ax)
1348                 return -ENOMEM;
1349
1350         ax->nargs = nargs;
1351         memcpy(ax->args, args, nargs * sizeof(unsigned long));
1352
1353         ax->d.type = AUDIT_SOCKETCALL;
1354         ax->d.next = context->aux;
1355         context->aux = (void *)ax;
1356         return 0;
1357 }
1358
1359 /**
1360  * audit_sockaddr - record audit data for sys_bind, sys_connect, sys_sendto
1361  * @len: data length in user space
1362  * @a: data address in kernel space
1363  *
1364  * Returns 0 for success or NULL context or < 0 on error.
1365  */
1366 int audit_sockaddr(int len, void *a)
1367 {
1368         struct audit_aux_data_sockaddr *ax;
1369         struct audit_context *context = current->audit_context;
1370
1371         if (likely(!context))
1372                 return 0;
1373
1374         ax = kmalloc(sizeof(*ax) + len, GFP_KERNEL);
1375         if (!ax)
1376                 return -ENOMEM;
1377
1378         ax->len = len;
1379         memcpy(ax->a, a, len);
1380
1381         ax->d.type = AUDIT_SOCKADDR;
1382         ax->d.next = context->aux;
1383         context->aux = (void *)ax;
1384         return 0;
1385 }
1386
1387 /**
1388  * audit_avc_path - record the granting or denial of permissions
1389  * @dentry: dentry to record
1390  * @mnt: mnt to record
1391  *
1392  * Returns 0 for success or NULL context or < 0 on error.
1393  *
1394  * Called from security/selinux/avc.c::avc_audit()
1395  */
1396 int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt)
1397 {
1398         struct audit_aux_data_path *ax;
1399         struct audit_context *context = current->audit_context;
1400
1401         if (likely(!context))
1402                 return 0;
1403
1404         ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
1405         if (!ax)
1406                 return -ENOMEM;
1407
1408         ax->dentry = dget(dentry);
1409         ax->mnt = mntget(mnt);
1410
1411         ax->d.type = AUDIT_AVC_PATH;
1412         ax->d.next = context->aux;
1413         context->aux = (void *)ax;
1414         return 0;
1415 }
1416
1417 /**
1418  * audit_signal_info - record signal info for shutting down audit subsystem
1419  * @sig: signal value
1420  * @t: task being signaled
1421  *
1422  * If the audit subsystem is being terminated, record the task (pid)
1423  * and uid that is doing that.
1424  */
1425 void audit_signal_info(int sig, struct task_struct *t)
1426 {
1427         extern pid_t audit_sig_pid;
1428         extern uid_t audit_sig_uid;
1429
1430         if (unlikely(audit_pid && t->tgid == audit_pid)) {
1431                 if (sig == SIGTERM || sig == SIGHUP) {
1432                         struct audit_context *ctx = current->audit_context;
1433                         audit_sig_pid = current->pid;
1434                         if (ctx)
1435                                 audit_sig_uid = ctx->loginuid;
1436                         else
1437                                 audit_sig_uid = current->uid;
1438                 }
1439         }
1440 }