hid: jarvis: Supress kernel debug prints in atvr_raw_event()
[linux-3.10.git] / 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 2005 Hewlett-Packard Development Company, L.P.
6  * Copyright (C) 2005, 2006 IBM Corporation
7  * All Rights Reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  *
23  * Written by Rickard E. (Rik) Faith <faith@redhat.com>
24  *
25  * Many of the ideas implemented here are from Stephen C. Tweedie,
26  * especially the idea of avoiding a copy by using getname.
27  *
28  * The method for actual interception of syscall entry and exit (not in
29  * this file -- see entry.S) is based on a GPL'd patch written by
30  * okir@suse.de and Copyright 2003 SuSE Linux AG.
31  *
32  * POSIX message queue support added by George Wilson <ltcgcw@us.ibm.com>,
33  * 2006.
34  *
35  * The support of additional filter rules compares (>, <, >=, <=) was
36  * added by Dustin Kirkland <dustin.kirkland@us.ibm.com>, 2005.
37  *
38  * Modified by Amy Griffis <amy.griffis@hp.com> to collect additional
39  * filesystem information.
40  *
41  * Subject and object context labeling support added by <danjones@us.ibm.com>
42  * and <dustin.kirkland@us.ibm.com> for LSPP certification compliance.
43  */
44
45 #include <linux/init.h>
46 #include <asm/types.h>
47 #include <linux/atomic.h>
48 #include <linux/fs.h>
49 #include <linux/namei.h>
50 #include <linux/mm.h>
51 #include <linux/export.h>
52 #include <linux/slab.h>
53 #include <linux/mount.h>
54 #include <linux/socket.h>
55 #include <linux/mqueue.h>
56 #include <linux/audit.h>
57 #include <linux/personality.h>
58 #include <linux/time.h>
59 #include <linux/netlink.h>
60 #include <linux/compiler.h>
61 #include <asm/unistd.h>
62 #include <linux/security.h>
63 #include <linux/list.h>
64 #include <linux/tty.h>
65 #include <linux/binfmts.h>
66 #include <linux/highmem.h>
67 #include <linux/syscalls.h>
68 #include <linux/capability.h>
69 #include <linux/fs_struct.h>
70 #include <linux/compat.h>
71 #include <linux/uaccess.h>
72
73 #include "audit.h"
74
75 /* flags stating the success for a syscall */
76 #define AUDITSC_INVALID 0
77 #define AUDITSC_SUCCESS 1
78 #define AUDITSC_FAILURE 2
79
80 /* no execve audit message should be longer than this (userspace limits),
81  * see the note near the top of audit_log_execve_info() about this value */
82 #define MAX_EXECVE_AUDIT_LEN 7500
83
84 /* number of audit rules */
85 int audit_n_rules;
86
87 /* determines whether we collect data for signals sent */
88 int audit_signals;
89
90 struct audit_aux_data {
91         struct audit_aux_data   *next;
92         int                     type;
93 };
94
95 #define AUDIT_AUX_IPCPERM       0
96
97 /* Number of target pids per aux struct. */
98 #define AUDIT_AUX_PIDS  16
99
100 struct audit_aux_data_execve {
101         struct audit_aux_data   d;
102         int argc;
103         int envc;
104         struct mm_struct *mm;
105 };
106
107 struct audit_aux_data_pids {
108         struct audit_aux_data   d;
109         pid_t                   target_pid[AUDIT_AUX_PIDS];
110         kuid_t                  target_auid[AUDIT_AUX_PIDS];
111         kuid_t                  target_uid[AUDIT_AUX_PIDS];
112         unsigned int            target_sessionid[AUDIT_AUX_PIDS];
113         u32                     target_sid[AUDIT_AUX_PIDS];
114         char                    target_comm[AUDIT_AUX_PIDS][TASK_COMM_LEN];
115         int                     pid_count;
116 };
117
118 struct audit_aux_data_bprm_fcaps {
119         struct audit_aux_data   d;
120         struct audit_cap_data   fcap;
121         unsigned int            fcap_ver;
122         struct audit_cap_data   old_pcap;
123         struct audit_cap_data   new_pcap;
124 };
125
126 struct audit_aux_data_capset {
127         struct audit_aux_data   d;
128         pid_t                   pid;
129         struct audit_cap_data   cap;
130 };
131
132 struct audit_tree_refs {
133         struct audit_tree_refs *next;
134         struct audit_chunk *c[31];
135 };
136
137 static inline int open_arg(int flags, int mask)
138 {
139         int n = ACC_MODE(flags);
140         if (flags & (O_TRUNC | O_CREAT))
141                 n |= AUDIT_PERM_WRITE;
142         return n & mask;
143 }
144
145 static int audit_match_perm(struct audit_context *ctx, int mask)
146 {
147         unsigned n;
148         if (unlikely(!ctx))
149                 return 0;
150         n = ctx->major;
151
152         switch (audit_classify_syscall(ctx->arch, n)) {
153         case 0: /* native */
154                 if ((mask & AUDIT_PERM_WRITE) &&
155                      audit_match_class(AUDIT_CLASS_WRITE, n))
156                         return 1;
157                 if ((mask & AUDIT_PERM_READ) &&
158                      audit_match_class(AUDIT_CLASS_READ, n))
159                         return 1;
160                 if ((mask & AUDIT_PERM_ATTR) &&
161                      audit_match_class(AUDIT_CLASS_CHATTR, n))
162                         return 1;
163                 return 0;
164         case 1: /* 32bit on biarch */
165                 if ((mask & AUDIT_PERM_WRITE) &&
166                      audit_match_class(AUDIT_CLASS_WRITE_32, n))
167                         return 1;
168                 if ((mask & AUDIT_PERM_READ) &&
169                      audit_match_class(AUDIT_CLASS_READ_32, n))
170                         return 1;
171                 if ((mask & AUDIT_PERM_ATTR) &&
172                      audit_match_class(AUDIT_CLASS_CHATTR_32, n))
173                         return 1;
174                 return 0;
175         case 2: /* open */
176                 return mask & ACC_MODE(ctx->argv[1]);
177         case 3: /* openat */
178                 return mask & ACC_MODE(ctx->argv[2]);
179         case 4: /* socketcall */
180                 return ((mask & AUDIT_PERM_WRITE) && ctx->argv[0] == SYS_BIND);
181         case 5: /* execve */
182                 return mask & AUDIT_PERM_EXEC;
183         default:
184                 return 0;
185         }
186 }
187
188 static int audit_match_filetype(struct audit_context *ctx, int val)
189 {
190         struct audit_names *n;
191         umode_t mode = (umode_t)val;
192
193         if (unlikely(!ctx))
194                 return 0;
195
196         list_for_each_entry(n, &ctx->names_list, list) {
197                 if ((n->ino != -1) &&
198                     ((n->mode & S_IFMT) == mode))
199                         return 1;
200         }
201
202         return 0;
203 }
204
205 /*
206  * We keep a linked list of fixed-sized (31 pointer) arrays of audit_chunk *;
207  * ->first_trees points to its beginning, ->trees - to the current end of data.
208  * ->tree_count is the number of free entries in array pointed to by ->trees.
209  * Original condition is (NULL, NULL, 0); as soon as it grows we never revert to NULL,
210  * "empty" becomes (p, p, 31) afterwards.  We don't shrink the list (and seriously,
211  * it's going to remain 1-element for almost any setup) until we free context itself.
212  * References in it _are_ dropped - at the same time we free/drop aux stuff.
213  */
214
215 #ifdef CONFIG_AUDIT_TREE
216 static void audit_set_auditable(struct audit_context *ctx)
217 {
218         if (!ctx->prio) {
219                 ctx->prio = 1;
220                 ctx->current_state = AUDIT_RECORD_CONTEXT;
221         }
222 }
223
224 static int put_tree_ref(struct audit_context *ctx, struct audit_chunk *chunk)
225 {
226         struct audit_tree_refs *p = ctx->trees;
227         int left = ctx->tree_count;
228         if (likely(left)) {
229                 p->c[--left] = chunk;
230                 ctx->tree_count = left;
231                 return 1;
232         }
233         if (!p)
234                 return 0;
235         p = p->next;
236         if (p) {
237                 p->c[30] = chunk;
238                 ctx->trees = p;
239                 ctx->tree_count = 30;
240                 return 1;
241         }
242         return 0;
243 }
244
245 static int grow_tree_refs(struct audit_context *ctx)
246 {
247         struct audit_tree_refs *p = ctx->trees;
248         ctx->trees = kzalloc(sizeof(struct audit_tree_refs), GFP_KERNEL);
249         if (!ctx->trees) {
250                 ctx->trees = p;
251                 return 0;
252         }
253         if (p)
254                 p->next = ctx->trees;
255         else
256                 ctx->first_trees = ctx->trees;
257         ctx->tree_count = 31;
258         return 1;
259 }
260 #endif
261
262 static void unroll_tree_refs(struct audit_context *ctx,
263                       struct audit_tree_refs *p, int count)
264 {
265 #ifdef CONFIG_AUDIT_TREE
266         struct audit_tree_refs *q;
267         int n;
268         if (!p) {
269                 /* we started with empty chain */
270                 p = ctx->first_trees;
271                 count = 31;
272                 /* if the very first allocation has failed, nothing to do */
273                 if (!p)
274                         return;
275         }
276         n = count;
277         for (q = p; q != ctx->trees; q = q->next, n = 31) {
278                 while (n--) {
279                         audit_put_chunk(q->c[n]);
280                         q->c[n] = NULL;
281                 }
282         }
283         while (n-- > ctx->tree_count) {
284                 audit_put_chunk(q->c[n]);
285                 q->c[n] = NULL;
286         }
287         ctx->trees = p;
288         ctx->tree_count = count;
289 #endif
290 }
291
292 static void free_tree_refs(struct audit_context *ctx)
293 {
294         struct audit_tree_refs *p, *q;
295         for (p = ctx->first_trees; p; p = q) {
296                 q = p->next;
297                 kfree(p);
298         }
299 }
300
301 static int match_tree_refs(struct audit_context *ctx, struct audit_tree *tree)
302 {
303 #ifdef CONFIG_AUDIT_TREE
304         struct audit_tree_refs *p;
305         int n;
306         if (!tree)
307                 return 0;
308         /* full ones */
309         for (p = ctx->first_trees; p != ctx->trees; p = p->next) {
310                 for (n = 0; n < 31; n++)
311                         if (audit_tree_match(p->c[n], tree))
312                                 return 1;
313         }
314         /* partial */
315         if (p) {
316                 for (n = ctx->tree_count; n < 31; n++)
317                         if (audit_tree_match(p->c[n], tree))
318                                 return 1;
319         }
320 #endif
321         return 0;
322 }
323
324 static int audit_compare_uid(kuid_t uid,
325                              struct audit_names *name,
326                              struct audit_field *f,
327                              struct audit_context *ctx)
328 {
329         struct audit_names *n;
330         int rc;
331  
332         if (name) {
333                 rc = audit_uid_comparator(uid, f->op, name->uid);
334                 if (rc)
335                         return rc;
336         }
337  
338         if (ctx) {
339                 list_for_each_entry(n, &ctx->names_list, list) {
340                         rc = audit_uid_comparator(uid, f->op, n->uid);
341                         if (rc)
342                                 return rc;
343                 }
344         }
345         return 0;
346 }
347
348 static int audit_compare_gid(kgid_t gid,
349                              struct audit_names *name,
350                              struct audit_field *f,
351                              struct audit_context *ctx)
352 {
353         struct audit_names *n;
354         int rc;
355  
356         if (name) {
357                 rc = audit_gid_comparator(gid, f->op, name->gid);
358                 if (rc)
359                         return rc;
360         }
361  
362         if (ctx) {
363                 list_for_each_entry(n, &ctx->names_list, list) {
364                         rc = audit_gid_comparator(gid, f->op, n->gid);
365                         if (rc)
366                                 return rc;
367                 }
368         }
369         return 0;
370 }
371
372 static int audit_field_compare(struct task_struct *tsk,
373                                const struct cred *cred,
374                                struct audit_field *f,
375                                struct audit_context *ctx,
376                                struct audit_names *name)
377 {
378         switch (f->val) {
379         /* process to file object comparisons */
380         case AUDIT_COMPARE_UID_TO_OBJ_UID:
381                 return audit_compare_uid(cred->uid, name, f, ctx);
382         case AUDIT_COMPARE_GID_TO_OBJ_GID:
383                 return audit_compare_gid(cred->gid, name, f, ctx);
384         case AUDIT_COMPARE_EUID_TO_OBJ_UID:
385                 return audit_compare_uid(cred->euid, name, f, ctx);
386         case AUDIT_COMPARE_EGID_TO_OBJ_GID:
387                 return audit_compare_gid(cred->egid, name, f, ctx);
388         case AUDIT_COMPARE_AUID_TO_OBJ_UID:
389                 return audit_compare_uid(tsk->loginuid, name, f, ctx);
390         case AUDIT_COMPARE_SUID_TO_OBJ_UID:
391                 return audit_compare_uid(cred->suid, name, f, ctx);
392         case AUDIT_COMPARE_SGID_TO_OBJ_GID:
393                 return audit_compare_gid(cred->sgid, name, f, ctx);
394         case AUDIT_COMPARE_FSUID_TO_OBJ_UID:
395                 return audit_compare_uid(cred->fsuid, name, f, ctx);
396         case AUDIT_COMPARE_FSGID_TO_OBJ_GID:
397                 return audit_compare_gid(cred->fsgid, name, f, ctx);
398         /* uid comparisons */
399         case AUDIT_COMPARE_UID_TO_AUID:
400                 return audit_uid_comparator(cred->uid, f->op, tsk->loginuid);
401         case AUDIT_COMPARE_UID_TO_EUID:
402                 return audit_uid_comparator(cred->uid, f->op, cred->euid);
403         case AUDIT_COMPARE_UID_TO_SUID:
404                 return audit_uid_comparator(cred->uid, f->op, cred->suid);
405         case AUDIT_COMPARE_UID_TO_FSUID:
406                 return audit_uid_comparator(cred->uid, f->op, cred->fsuid);
407         /* auid comparisons */
408         case AUDIT_COMPARE_AUID_TO_EUID:
409                 return audit_uid_comparator(tsk->loginuid, f->op, cred->euid);
410         case AUDIT_COMPARE_AUID_TO_SUID:
411                 return audit_uid_comparator(tsk->loginuid, f->op, cred->suid);
412         case AUDIT_COMPARE_AUID_TO_FSUID:
413                 return audit_uid_comparator(tsk->loginuid, f->op, cred->fsuid);
414         /* euid comparisons */
415         case AUDIT_COMPARE_EUID_TO_SUID:
416                 return audit_uid_comparator(cred->euid, f->op, cred->suid);
417         case AUDIT_COMPARE_EUID_TO_FSUID:
418                 return audit_uid_comparator(cred->euid, f->op, cred->fsuid);
419         /* suid comparisons */
420         case AUDIT_COMPARE_SUID_TO_FSUID:
421                 return audit_uid_comparator(cred->suid, f->op, cred->fsuid);
422         /* gid comparisons */
423         case AUDIT_COMPARE_GID_TO_EGID:
424                 return audit_gid_comparator(cred->gid, f->op, cred->egid);
425         case AUDIT_COMPARE_GID_TO_SGID:
426                 return audit_gid_comparator(cred->gid, f->op, cred->sgid);
427         case AUDIT_COMPARE_GID_TO_FSGID:
428                 return audit_gid_comparator(cred->gid, f->op, cred->fsgid);
429         /* egid comparisons */
430         case AUDIT_COMPARE_EGID_TO_SGID:
431                 return audit_gid_comparator(cred->egid, f->op, cred->sgid);
432         case AUDIT_COMPARE_EGID_TO_FSGID:
433                 return audit_gid_comparator(cred->egid, f->op, cred->fsgid);
434         /* sgid comparison */
435         case AUDIT_COMPARE_SGID_TO_FSGID:
436                 return audit_gid_comparator(cred->sgid, f->op, cred->fsgid);
437         default:
438                 WARN(1, "Missing AUDIT_COMPARE define.  Report as a bug\n");
439                 return 0;
440         }
441         return 0;
442 }
443
444 /* Determine if any context name data matches a rule's watch data */
445 /* Compare a task_struct with an audit_rule.  Return 1 on match, 0
446  * otherwise.
447  *
448  * If task_creation is true, this is an explicit indication that we are
449  * filtering a task rule at task creation time.  This and tsk == current are
450  * the only situations where tsk->cred may be accessed without an rcu read lock.
451  */
452 static int audit_filter_rules(struct task_struct *tsk,
453                               struct audit_krule *rule,
454                               struct audit_context *ctx,
455                               struct audit_names *name,
456                               enum audit_state *state,
457                               bool task_creation)
458 {
459         const struct cred *cred;
460         int i, need_sid = 1;
461         u32 sid;
462
463         cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation);
464
465         for (i = 0; i < rule->field_count; i++) {
466                 struct audit_field *f = &rule->fields[i];
467                 struct audit_names *n;
468                 int result = 0;
469
470                 switch (f->type) {
471                 case AUDIT_PID:
472                         result = audit_comparator(tsk->pid, f->op, f->val);
473                         break;
474                 case AUDIT_PPID:
475                         if (ctx) {
476                                 if (!ctx->ppid)
477                                         ctx->ppid = sys_getppid();
478                                 result = audit_comparator(ctx->ppid, f->op, f->val);
479                         }
480                         break;
481                 case AUDIT_UID:
482                         result = audit_uid_comparator(cred->uid, f->op, f->uid);
483                         break;
484                 case AUDIT_EUID:
485                         result = audit_uid_comparator(cred->euid, f->op, f->uid);
486                         break;
487                 case AUDIT_SUID:
488                         result = audit_uid_comparator(cred->suid, f->op, f->uid);
489                         break;
490                 case AUDIT_FSUID:
491                         result = audit_uid_comparator(cred->fsuid, f->op, f->uid);
492                         break;
493                 case AUDIT_GID:
494                         result = audit_gid_comparator(cred->gid, f->op, f->gid);
495                         if (f->op == Audit_equal) {
496                                 if (!result)
497                                         result = in_group_p(f->gid);
498                         } else if (f->op == Audit_not_equal) {
499                                 if (result)
500                                         result = !in_group_p(f->gid);
501                         }
502                         break;
503                 case AUDIT_EGID:
504                         result = audit_gid_comparator(cred->egid, f->op, f->gid);
505                         if (f->op == Audit_equal) {
506                                 if (!result)
507                                         result = in_egroup_p(f->gid);
508                         } else if (f->op == Audit_not_equal) {
509                                 if (result)
510                                         result = !in_egroup_p(f->gid);
511                         }
512                         break;
513                 case AUDIT_SGID:
514                         result = audit_gid_comparator(cred->sgid, f->op, f->gid);
515                         break;
516                 case AUDIT_FSGID:
517                         result = audit_gid_comparator(cred->fsgid, f->op, f->gid);
518                         break;
519                 case AUDIT_PERS:
520                         result = audit_comparator(tsk->personality, f->op, f->val);
521                         break;
522                 case AUDIT_ARCH:
523                         if (ctx)
524                                 result = audit_comparator(ctx->arch, f->op, f->val);
525                         break;
526
527                 case AUDIT_EXIT:
528                         if (ctx && ctx->return_valid)
529                                 result = audit_comparator(ctx->return_code, f->op, f->val);
530                         break;
531                 case AUDIT_SUCCESS:
532                         if (ctx && ctx->return_valid) {
533                                 if (f->val)
534                                         result = audit_comparator(ctx->return_valid, f->op, AUDITSC_SUCCESS);
535                                 else
536                                         result = audit_comparator(ctx->return_valid, f->op, AUDITSC_FAILURE);
537                         }
538                         break;
539                 case AUDIT_DEVMAJOR:
540                         if (name) {
541                                 if (audit_comparator(MAJOR(name->dev), f->op, f->val) ||
542                                     audit_comparator(MAJOR(name->rdev), f->op, f->val))
543                                         ++result;
544                         } else if (ctx) {
545                                 list_for_each_entry(n, &ctx->names_list, list) {
546                                         if (audit_comparator(MAJOR(n->dev), f->op, f->val) ||
547                                             audit_comparator(MAJOR(n->rdev), f->op, f->val)) {
548                                                 ++result;
549                                                 break;
550                                         }
551                                 }
552                         }
553                         break;
554                 case AUDIT_DEVMINOR:
555                         if (name) {
556                                 if (audit_comparator(MINOR(name->dev), f->op, f->val) ||
557                                     audit_comparator(MINOR(name->rdev), f->op, f->val))
558                                         ++result;
559                         } else if (ctx) {
560                                 list_for_each_entry(n, &ctx->names_list, list) {
561                                         if (audit_comparator(MINOR(n->dev), f->op, f->val) ||
562                                             audit_comparator(MINOR(n->rdev), f->op, f->val)) {
563                                                 ++result;
564                                                 break;
565                                         }
566                                 }
567                         }
568                         break;
569                 case AUDIT_INODE:
570                         if (name)
571                                 result = (name->ino == f->val);
572                         else if (ctx) {
573                                 list_for_each_entry(n, &ctx->names_list, list) {
574                                         if (audit_comparator(n->ino, f->op, f->val)) {
575                                                 ++result;
576                                                 break;
577                                         }
578                                 }
579                         }
580                         break;
581                 case AUDIT_OBJ_UID:
582                         if (name) {
583                                 result = audit_uid_comparator(name->uid, f->op, f->uid);
584                         } else if (ctx) {
585                                 list_for_each_entry(n, &ctx->names_list, list) {
586                                         if (audit_uid_comparator(n->uid, f->op, f->uid)) {
587                                                 ++result;
588                                                 break;
589                                         }
590                                 }
591                         }
592                         break;
593                 case AUDIT_OBJ_GID:
594                         if (name) {
595                                 result = audit_gid_comparator(name->gid, f->op, f->gid);
596                         } else if (ctx) {
597                                 list_for_each_entry(n, &ctx->names_list, list) {
598                                         if (audit_gid_comparator(n->gid, f->op, f->gid)) {
599                                                 ++result;
600                                                 break;
601                                         }
602                                 }
603                         }
604                         break;
605                 case AUDIT_WATCH:
606                         if (name)
607                                 result = audit_watch_compare(rule->watch, name->ino, name->dev);
608                         break;
609                 case AUDIT_DIR:
610                         if (ctx)
611                                 result = match_tree_refs(ctx, rule->tree);
612                         break;
613                 case AUDIT_LOGINUID:
614                         result = 0;
615                         if (ctx)
616                                 result = audit_uid_comparator(tsk->loginuid, f->op, f->uid);
617                         break;
618                 case AUDIT_LOGINUID_SET:
619                         result = audit_comparator(audit_loginuid_set(tsk), f->op, f->val);
620                         break;
621                 case AUDIT_SUBJ_USER:
622                 case AUDIT_SUBJ_ROLE:
623                 case AUDIT_SUBJ_TYPE:
624                 case AUDIT_SUBJ_SEN:
625                 case AUDIT_SUBJ_CLR:
626                         /* NOTE: this may return negative values indicating
627                            a temporary error.  We simply treat this as a
628                            match for now to avoid losing information that
629                            may be wanted.   An error message will also be
630                            logged upon error */
631                         if (f->lsm_rule) {
632                                 if (need_sid) {
633                                         security_task_getsecid(tsk, &sid);
634                                         need_sid = 0;
635                                 }
636                                 result = security_audit_rule_match(sid, f->type,
637                                                                   f->op,
638                                                                   f->lsm_rule,
639                                                                   ctx);
640                         }
641                         break;
642                 case AUDIT_OBJ_USER:
643                 case AUDIT_OBJ_ROLE:
644                 case AUDIT_OBJ_TYPE:
645                 case AUDIT_OBJ_LEV_LOW:
646                 case AUDIT_OBJ_LEV_HIGH:
647                         /* The above note for AUDIT_SUBJ_USER...AUDIT_SUBJ_CLR
648                            also applies here */
649                         if (f->lsm_rule) {
650                                 /* Find files that match */
651                                 if (name) {
652                                         result = security_audit_rule_match(
653                                                    name->osid, f->type, f->op,
654                                                    f->lsm_rule, ctx);
655                                 } else if (ctx) {
656                                         list_for_each_entry(n, &ctx->names_list, list) {
657                                                 if (security_audit_rule_match(n->osid, f->type,
658                                                                               f->op, f->lsm_rule,
659                                                                               ctx)) {
660                                                         ++result;
661                                                         break;
662                                                 }
663                                         }
664                                 }
665                                 /* Find ipc objects that match */
666                                 if (!ctx || ctx->type != AUDIT_IPC)
667                                         break;
668                                 if (security_audit_rule_match(ctx->ipc.osid,
669                                                               f->type, f->op,
670                                                               f->lsm_rule, ctx))
671                                         ++result;
672                         }
673                         break;
674                 case AUDIT_ARG0:
675                 case AUDIT_ARG1:
676                 case AUDIT_ARG2:
677                 case AUDIT_ARG3:
678                         if (ctx)
679                                 result = audit_comparator(ctx->argv[f->type-AUDIT_ARG0], f->op, f->val);
680                         break;
681                 case AUDIT_FILTERKEY:
682                         /* ignore this field for filtering */
683                         result = 1;
684                         break;
685                 case AUDIT_PERM:
686                         result = audit_match_perm(ctx, f->val);
687                         break;
688                 case AUDIT_FILETYPE:
689                         result = audit_match_filetype(ctx, f->val);
690                         break;
691                 case AUDIT_FIELD_COMPARE:
692                         result = audit_field_compare(tsk, cred, f, ctx, name);
693                         break;
694                 }
695                 if (!result)
696                         return 0;
697         }
698
699         if (ctx) {
700                 if (rule->prio <= ctx->prio)
701                         return 0;
702                 if (rule->filterkey) {
703                         kfree(ctx->filterkey);
704                         ctx->filterkey = kstrdup(rule->filterkey, GFP_ATOMIC);
705                 }
706                 ctx->prio = rule->prio;
707         }
708         switch (rule->action) {
709         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
710         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
711         }
712         return 1;
713 }
714
715 /* At process creation time, we can determine if system-call auditing is
716  * completely disabled for this task.  Since we only have the task
717  * structure at this point, we can only check uid and gid.
718  */
719 static enum audit_state audit_filter_task(struct task_struct *tsk, char **key)
720 {
721         struct audit_entry *e;
722         enum audit_state   state;
723
724         rcu_read_lock();
725         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
726                 if (audit_filter_rules(tsk, &e->rule, NULL, NULL,
727                                        &state, true)) {
728                         if (state == AUDIT_RECORD_CONTEXT)
729                                 *key = kstrdup(e->rule.filterkey, GFP_ATOMIC);
730                         rcu_read_unlock();
731                         return state;
732                 }
733         }
734         rcu_read_unlock();
735         return AUDIT_BUILD_CONTEXT;
736 }
737
738 static int audit_in_mask(const struct audit_krule *rule, unsigned long val)
739 {
740         int word, bit;
741
742         if (val > 0xffffffff)
743                 return false;
744
745         word = AUDIT_WORD(val);
746         if (word >= AUDIT_BITMASK_SIZE)
747                 return false;
748
749         bit = AUDIT_BIT(val);
750
751         return rule->mask[word] & bit;
752 }
753
754 /* At syscall entry and exit time, this filter is called if the
755  * audit_state is not low enough that auditing cannot take place, but is
756  * also not high enough that we already know we have to write an audit
757  * record (i.e., the state is AUDIT_SETUP_CONTEXT or AUDIT_BUILD_CONTEXT).
758  */
759 static enum audit_state audit_filter_syscall(struct task_struct *tsk,
760                                              struct audit_context *ctx,
761                                              struct list_head *list)
762 {
763         struct audit_entry *e;
764         enum audit_state state;
765
766         if (audit_pid && tsk->tgid == audit_pid)
767                 return AUDIT_DISABLED;
768
769         rcu_read_lock();
770         if (!list_empty(list)) {
771                 list_for_each_entry_rcu(e, list, list) {
772                         if (audit_in_mask(&e->rule, ctx->major) &&
773                             audit_filter_rules(tsk, &e->rule, ctx, NULL,
774                                                &state, false)) {
775                                 rcu_read_unlock();
776                                 ctx->current_state = state;
777                                 return state;
778                         }
779                 }
780         }
781         rcu_read_unlock();
782         return AUDIT_BUILD_CONTEXT;
783 }
784
785 /*
786  * Given an audit_name check the inode hash table to see if they match.
787  * Called holding the rcu read lock to protect the use of audit_inode_hash
788  */
789 static int audit_filter_inode_name(struct task_struct *tsk,
790                                    struct audit_names *n,
791                                    struct audit_context *ctx) {
792         int h = audit_hash_ino((u32)n->ino);
793         struct list_head *list = &audit_inode_hash[h];
794         struct audit_entry *e;
795         enum audit_state state;
796
797         if (list_empty(list))
798                 return 0;
799
800         list_for_each_entry_rcu(e, list, list) {
801                 if (audit_in_mask(&e->rule, ctx->major) &&
802                     audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) {
803                         ctx->current_state = state;
804                         return 1;
805                 }
806         }
807
808         return 0;
809 }
810
811 /* At syscall exit time, this filter is called if any audit_names have been
812  * collected during syscall processing.  We only check rules in sublists at hash
813  * buckets applicable to the inode numbers in audit_names.
814  * Regarding audit_state, same rules apply as for audit_filter_syscall().
815  */
816 void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx)
817 {
818         struct audit_names *n;
819
820         if (audit_pid && tsk->tgid == audit_pid)
821                 return;
822
823         rcu_read_lock();
824
825         list_for_each_entry(n, &ctx->names_list, list) {
826                 if (audit_filter_inode_name(tsk, n, ctx))
827                         break;
828         }
829         rcu_read_unlock();
830 }
831
832 static inline struct audit_context *audit_get_context(struct task_struct *tsk,
833                                                       int return_valid,
834                                                       long return_code)
835 {
836         struct audit_context *context = tsk->audit_context;
837
838         if (!context)
839                 return NULL;
840         context->return_valid = return_valid;
841
842         /*
843          * we need to fix up the return code in the audit logs if the actual
844          * return codes are later going to be fixed up by the arch specific
845          * signal handlers
846          *
847          * This is actually a test for:
848          * (rc == ERESTARTSYS ) || (rc == ERESTARTNOINTR) ||
849          * (rc == ERESTARTNOHAND) || (rc == ERESTART_RESTARTBLOCK)
850          *
851          * but is faster than a bunch of ||
852          */
853         if (unlikely(return_code <= -ERESTARTSYS) &&
854             (return_code >= -ERESTART_RESTARTBLOCK) &&
855             (return_code != -ENOIOCTLCMD))
856                 context->return_code = -EINTR;
857         else
858                 context->return_code  = return_code;
859
860         if (context->in_syscall && !context->dummy) {
861                 audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
862                 audit_filter_inodes(tsk, context);
863         }
864
865         tsk->audit_context = NULL;
866         return context;
867 }
868
869 static inline void audit_free_names(struct audit_context *context)
870 {
871         struct audit_names *n, *next;
872
873 #if AUDIT_DEBUG == 2
874         if (context->put_count + context->ino_count != context->name_count) {
875                 int i = 0;
876
877                 printk(KERN_ERR "%s:%d(:%d): major=%d in_syscall=%d"
878                        " name_count=%d put_count=%d"
879                        " ino_count=%d [NOT freeing]\n",
880                        __FILE__, __LINE__,
881                        context->serial, context->major, context->in_syscall,
882                        context->name_count, context->put_count,
883                        context->ino_count);
884                 list_for_each_entry(n, &context->names_list, list) {
885                         printk(KERN_ERR "names[%d] = %p = %s\n", i++,
886                                n->name, n->name->name ?: "(null)");
887                 }
888                 dump_stack();
889                 return;
890         }
891 #endif
892 #if AUDIT_DEBUG
893         context->put_count  = 0;
894         context->ino_count  = 0;
895 #endif
896
897         list_for_each_entry_safe(n, next, &context->names_list, list) {
898                 list_del(&n->list);
899                 if (n->name && n->name_put)
900                         final_putname(n->name);
901                 if (n->should_free)
902                         kfree(n);
903         }
904         context->name_count = 0;
905         path_put(&context->pwd);
906         context->pwd.dentry = NULL;
907         context->pwd.mnt = NULL;
908 }
909
910 static inline void audit_free_aux(struct audit_context *context)
911 {
912         struct audit_aux_data *aux;
913
914         while ((aux = context->aux)) {
915                 context->aux = aux->next;
916                 kfree(aux);
917         }
918         while ((aux = context->aux_pids)) {
919                 context->aux_pids = aux->next;
920                 kfree(aux);
921         }
922 }
923
924 static inline struct audit_context *audit_alloc_context(enum audit_state state)
925 {
926         struct audit_context *context;
927
928         context = kzalloc(sizeof(*context), GFP_KERNEL);
929         if (!context)
930                 return NULL;
931         context->state = state;
932         context->prio = state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
933         INIT_LIST_HEAD(&context->killed_trees);
934         INIT_LIST_HEAD(&context->names_list);
935         return context;
936 }
937
938 /**
939  * audit_alloc - allocate an audit context block for a task
940  * @tsk: task
941  *
942  * Filter on the task information and allocate a per-task audit context
943  * if necessary.  Doing so turns on system call auditing for the
944  * specified task.  This is called from copy_process, so no lock is
945  * needed.
946  */
947 int audit_alloc(struct task_struct *tsk)
948 {
949         struct audit_context *context;
950         enum audit_state     state;
951         char *key = NULL;
952
953         if (likely(!audit_ever_enabled))
954                 return 0; /* Return if not auditing. */
955
956         state = audit_filter_task(tsk, &key);
957         if (state == AUDIT_DISABLED)
958                 return 0;
959
960         if (!(context = audit_alloc_context(state))) {
961                 kfree(key);
962                 audit_log_lost("out of memory in audit_alloc");
963                 return -ENOMEM;
964         }
965         context->filterkey = key;
966
967         tsk->audit_context  = context;
968         set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
969         return 0;
970 }
971
972 static inline void audit_free_context(struct audit_context *context)
973 {
974         audit_free_names(context);
975         unroll_tree_refs(context, NULL, 0);
976         free_tree_refs(context);
977         audit_free_aux(context);
978         kfree(context->filterkey);
979         kfree(context->sockaddr);
980         kfree(context);
981 }
982
983 static int audit_log_pid_context(struct audit_context *context, pid_t pid,
984                                  kuid_t auid, kuid_t uid, unsigned int sessionid,
985                                  u32 sid, char *comm)
986 {
987         struct audit_buffer *ab;
988         char *ctx = NULL;
989         u32 len;
990         int rc = 0;
991
992         ab = audit_log_start(context, GFP_KERNEL, AUDIT_OBJ_PID);
993         if (!ab)
994                 return rc;
995
996         audit_log_format(ab, "opid=%d oauid=%d ouid=%d oses=%d", pid,
997                          from_kuid(&init_user_ns, auid),
998                          from_kuid(&init_user_ns, uid), sessionid);
999         if (sid) {
1000                 if (security_secid_to_secctx(sid, &ctx, &len)) {
1001                         audit_log_format(ab, " obj=(none)");
1002                         rc = 1;
1003                 } else {
1004                         audit_log_format(ab, " obj=%s", ctx);
1005                         security_release_secctx(ctx, len);
1006                 }
1007         }
1008         audit_log_format(ab, " ocomm=");
1009         audit_log_untrustedstring(ab, comm);
1010         audit_log_end(ab);
1011
1012         return rc;
1013 }
1014
1015 static void audit_log_execve_info(struct audit_context *context,
1016                                   struct audit_buffer **ab,
1017                                   struct audit_aux_data_execve *axi)
1018 {
1019         long len_max;
1020         long len_rem;
1021         long len_full;
1022         long len_buf;
1023         long len_abuf;
1024         long len_tmp;
1025         bool require_data;
1026         bool encode;
1027         unsigned int iter;
1028         unsigned int arg;
1029         char *buf_head;
1030         char *buf;
1031         const char __user *p;
1032
1033         /* NOTE: this buffer needs to be large enough to hold all the non-arg
1034          *       data we put in the audit record for this argument (see the
1035          *       code below) ... at this point in time 96 is plenty */
1036         char abuf[96];
1037
1038         if (axi->mm != current->mm)
1039                 return; /* execve failed, no additional info */
1040  
1041         p = (const char __user *)axi->mm->arg_start;
1042
1043         /* NOTE: we set MAX_EXECVE_AUDIT_LEN to a rather arbitrary limit, the
1044          *       current value of 7500 is not as important as the fact that it
1045          *       is less than 8k, a setting of 7500 gives us plenty of wiggle
1046          *       room if we go over a little bit in the logging below */
1047         WARN_ON_ONCE(MAX_EXECVE_AUDIT_LEN > 7500);
1048         len_max = MAX_EXECVE_AUDIT_LEN;
1049
1050         /* scratch buffer to hold the userspace args */
1051         buf_head = kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL);
1052         if (!buf_head) {
1053                 audit_panic("out of memory for argv string");
1054                 return;
1055         }
1056         buf = buf_head;
1057
1058         audit_log_format(*ab, "argc=%d", axi->argc);
1059
1060         len_rem = len_max;
1061         len_buf = 0;
1062         len_full = 0;
1063         require_data = true;
1064         encode = false;
1065         iter = 0;
1066         arg = 0;
1067         do {
1068                 /* NOTE: we don't ever want to trust this value for anything
1069                  *       serious, but the audit record format insists we
1070                  *       provide an argument length for really long arguments,
1071                  *       e.g. > MAX_EXECVE_AUDIT_LEN, so we have no choice but
1072                  *       to use strncpy_from_user() to obtain this value for
1073                  *       recording in the log, although we don't use it
1074                  *       anywhere here to avoid a double-fetch problem */
1075                 if (len_full == 0)
1076                         len_full = strnlen_user(p, MAX_ARG_STRLEN) - 1;
1077
1078                 /* read more data from userspace */
1079                 if (require_data) {
1080                         /* can we make more room in the buffer? */
1081                         if (buf != buf_head) {
1082                                 memmove(buf_head, buf, len_buf);
1083                                 buf = buf_head;
1084                         }
1085
1086                         /* fetch as much as we can of the argument */
1087                         len_tmp = strncpy_from_user(&buf_head[len_buf], p,
1088                                                     len_max - len_buf);
1089                         if (len_tmp == -EFAULT) {
1090                                 /* unable to copy from userspace */
1091                                 send_sig(SIGKILL, current, 0);
1092                                 goto out;
1093                         } else if (len_tmp == (len_max - len_buf)) {
1094                                 /* buffer is not large enough */
1095                                 require_data = true;
1096                                 /* NOTE: if we are going to span multiple
1097                                  *       buffers force the encoding so we stand
1098                                  *       a chance at a sane len_full value and
1099                                  *       consistent record encoding */
1100                                 encode = true;
1101                                 len_full = len_full * 2;
1102                                 p += len_tmp;
1103                         } else {
1104                                 require_data = false;
1105                                 if (!encode)
1106                                         encode = audit_string_contains_control(
1107                                                                 buf, len_tmp);
1108                                 /* try to use a trusted value for len_full */
1109                                 if (len_full < len_max)
1110                                         len_full = (encode ?
1111                                                     len_tmp * 2 : len_tmp);
1112                                 p += len_tmp + 1;
1113                         }
1114                         len_buf += len_tmp;
1115                         buf_head[len_buf] = '\0';
1116
1117                         /* length of the buffer in the audit record? */
1118                         len_abuf = (encode ? len_buf * 2 : len_buf + 2);
1119                 }
1120
1121                 /* write as much as we can to the audit log */
1122                 if (len_buf > 0) {
1123                         /* NOTE: some magic numbers here - basically if we
1124                          *       can't fit a reasonable amount of data into the
1125                          *       existing audit buffer, flush it and start with
1126                          *       a new buffer */
1127                         if ((sizeof(abuf) + 8) > len_rem) {
1128                                 len_rem = len_max;
1129                                 audit_log_end(*ab);
1130                                 *ab = audit_log_start(context,
1131                                                       GFP_KERNEL, AUDIT_EXECVE);
1132                                 if (!*ab)
1133                                         goto out;
1134                         }
1135
1136                         /* create the non-arg portion of the arg record */
1137                         len_tmp = 0;
1138                         if (require_data || (iter > 0) ||
1139                             ((len_abuf + sizeof(abuf)) > len_rem)) {
1140                                 if (iter == 0) {
1141                                         len_tmp += snprintf(&abuf[len_tmp],
1142                                                         sizeof(abuf) - len_tmp,
1143                                                         " a%d_len=%lu",
1144                                                         arg, len_full);
1145                                 }
1146                                 len_tmp += snprintf(&abuf[len_tmp],
1147                                                     sizeof(abuf) - len_tmp,
1148                                                     " a%d[%d]=", arg, iter++);
1149                         } else
1150                                 len_tmp += snprintf(&abuf[len_tmp],
1151                                                     sizeof(abuf) - len_tmp,
1152                                                     " a%d=", arg);
1153                         WARN_ON(len_tmp >= sizeof(abuf));
1154                         abuf[sizeof(abuf) - 1] = '\0';
1155
1156                         /* log the arg in the audit record */
1157                         audit_log_format(*ab, "%s", abuf);
1158                         len_rem -= len_tmp;
1159                         len_tmp = len_buf;
1160                         if (encode) {
1161                                 if (len_abuf > len_rem)
1162                                         len_tmp = len_rem / 2; /* encoding */
1163                                 audit_log_n_hex(*ab, buf, len_tmp);
1164                                 len_rem -= len_tmp * 2;
1165                                 len_abuf -= len_tmp * 2;
1166                         } else {
1167                                 if (len_abuf > len_rem)
1168                                         len_tmp = len_rem - 2; /* quotes */
1169                                 audit_log_n_string(*ab, buf, len_tmp);
1170                                 len_rem -= len_tmp + 2;
1171                                 /* don't subtract the "2" because we still need
1172                                  * to add quotes to the remaining string */
1173                                 len_abuf -= len_tmp;
1174                         }
1175                         len_buf -= len_tmp;
1176                         buf += len_tmp;
1177                 }
1178
1179                 /* ready to move to the next argument? */
1180                 if ((len_buf == 0) && !require_data) {
1181                         arg++;
1182                         iter = 0;
1183                         len_full = 0;
1184                         require_data = true;
1185                         encode = false;
1186                 }
1187         } while (arg < axi->argc);
1188
1189         /* NOTE: the caller handles the final audit_log_end() call */
1190
1191 out:
1192         kfree(buf_head);
1193 }
1194
1195 static void show_special(struct audit_context *context, int *call_panic)
1196 {
1197         struct audit_buffer *ab;
1198         int i;
1199
1200         ab = audit_log_start(context, GFP_KERNEL, context->type);
1201         if (!ab)
1202                 return;
1203
1204         switch (context->type) {
1205         case AUDIT_SOCKETCALL: {
1206                 int nargs = context->socketcall.nargs;
1207                 audit_log_format(ab, "nargs=%d", nargs);
1208                 for (i = 0; i < nargs; i++)
1209                         audit_log_format(ab, " a%d=%lx", i,
1210                                 context->socketcall.args[i]);
1211                 break; }
1212         case AUDIT_IPC: {
1213                 u32 osid = context->ipc.osid;
1214
1215                 audit_log_format(ab, "ouid=%u ogid=%u mode=%#ho",
1216                                  from_kuid(&init_user_ns, context->ipc.uid),
1217                                  from_kgid(&init_user_ns, context->ipc.gid),
1218                                  context->ipc.mode);
1219                 if (osid) {
1220                         char *ctx = NULL;
1221                         u32 len;
1222                         if (security_secid_to_secctx(osid, &ctx, &len)) {
1223                                 audit_log_format(ab, " osid=%u", osid);
1224                                 *call_panic = 1;
1225                         } else {
1226                                 audit_log_format(ab, " obj=%s", ctx);
1227                                 security_release_secctx(ctx, len);
1228                         }
1229                 }
1230                 if (context->ipc.has_perm) {
1231                         audit_log_end(ab);
1232                         ab = audit_log_start(context, GFP_KERNEL,
1233                                              AUDIT_IPC_SET_PERM);
1234                         if (unlikely(!ab))
1235                                 return;
1236                         audit_log_format(ab,
1237                                 "qbytes=%lx ouid=%u ogid=%u mode=%#ho",
1238                                 context->ipc.qbytes,
1239                                 context->ipc.perm_uid,
1240                                 context->ipc.perm_gid,
1241                                 context->ipc.perm_mode);
1242                 }
1243                 break; }
1244         case AUDIT_MQ_OPEN: {
1245                 audit_log_format(ab,
1246                         "oflag=0x%x mode=%#ho mq_flags=0x%lx mq_maxmsg=%ld "
1247                         "mq_msgsize=%ld mq_curmsgs=%ld",
1248                         context->mq_open.oflag, context->mq_open.mode,
1249                         context->mq_open.attr.mq_flags,
1250                         context->mq_open.attr.mq_maxmsg,
1251                         context->mq_open.attr.mq_msgsize,
1252                         context->mq_open.attr.mq_curmsgs);
1253                 break; }
1254         case AUDIT_MQ_SENDRECV: {
1255                 audit_log_format(ab,
1256                         "mqdes=%d msg_len=%zd msg_prio=%u "
1257                         "abs_timeout_sec=%ld abs_timeout_nsec=%ld",
1258                         context->mq_sendrecv.mqdes,
1259                         context->mq_sendrecv.msg_len,
1260                         context->mq_sendrecv.msg_prio,
1261                         context->mq_sendrecv.abs_timeout.tv_sec,
1262                         context->mq_sendrecv.abs_timeout.tv_nsec);
1263                 break; }
1264         case AUDIT_MQ_NOTIFY: {
1265                 audit_log_format(ab, "mqdes=%d sigev_signo=%d",
1266                                 context->mq_notify.mqdes,
1267                                 context->mq_notify.sigev_signo);
1268                 break; }
1269         case AUDIT_MQ_GETSETATTR: {
1270                 struct mq_attr *attr = &context->mq_getsetattr.mqstat;
1271                 audit_log_format(ab,
1272                         "mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
1273                         "mq_curmsgs=%ld ",
1274                         context->mq_getsetattr.mqdes,
1275                         attr->mq_flags, attr->mq_maxmsg,
1276                         attr->mq_msgsize, attr->mq_curmsgs);
1277                 break; }
1278         case AUDIT_CAPSET: {
1279                 audit_log_format(ab, "pid=%d", context->capset.pid);
1280                 audit_log_cap(ab, "cap_pi", &context->capset.cap.inheritable);
1281                 audit_log_cap(ab, "cap_pp", &context->capset.cap.permitted);
1282                 audit_log_cap(ab, "cap_pe", &context->capset.cap.effective);
1283                 break; }
1284         case AUDIT_MMAP: {
1285                 audit_log_format(ab, "fd=%d flags=0x%x", context->mmap.fd,
1286                                  context->mmap.flags);
1287                 break; }
1288         }
1289         audit_log_end(ab);
1290 }
1291
1292 static void audit_log_exit(struct audit_context *context, struct task_struct *tsk)
1293 {
1294         int i, call_panic = 0;
1295         struct audit_buffer *ab;
1296         struct audit_aux_data *aux;
1297         struct audit_names *n;
1298
1299         /* tsk == current */
1300         context->personality = tsk->personality;
1301
1302         ab = audit_log_start(context, GFP_KERNEL, AUDIT_SYSCALL);
1303         if (!ab)
1304                 return;         /* audit_panic has been called */
1305         audit_log_format(ab, "arch=%x syscall=%d",
1306                          context->arch, context->major);
1307         if (context->personality != PER_LINUX)
1308                 audit_log_format(ab, " per=%lx", context->personality);
1309         if (context->return_valid)
1310                 audit_log_format(ab, " success=%s exit=%ld",
1311                                  (context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
1312                                  context->return_code);
1313
1314         audit_log_format(ab,
1315                          " a0=%lx a1=%lx a2=%lx a3=%lx items=%d",
1316                          context->argv[0],
1317                          context->argv[1],
1318                          context->argv[2],
1319                          context->argv[3],
1320                          context->name_count);
1321
1322         audit_log_task_info(ab, tsk);
1323         audit_log_key(ab, context->filterkey);
1324         audit_log_end(ab);
1325
1326         for (aux = context->aux; aux; aux = aux->next) {
1327
1328                 ab = audit_log_start(context, GFP_KERNEL, aux->type);
1329                 if (!ab)
1330                         continue; /* audit_panic has been called */
1331
1332                 switch (aux->type) {
1333
1334                 case AUDIT_EXECVE: {
1335                         struct audit_aux_data_execve *axi = (void *)aux;
1336                         audit_log_execve_info(context, &ab, axi);
1337                         break; }
1338
1339                 case AUDIT_BPRM_FCAPS: {
1340                         struct audit_aux_data_bprm_fcaps *axs = (void *)aux;
1341                         audit_log_format(ab, "fver=%x", axs->fcap_ver);
1342                         audit_log_cap(ab, "fp", &axs->fcap.permitted);
1343                         audit_log_cap(ab, "fi", &axs->fcap.inheritable);
1344                         audit_log_format(ab, " fe=%d", axs->fcap.fE);
1345                         audit_log_cap(ab, "old_pp", &axs->old_pcap.permitted);
1346                         audit_log_cap(ab, "old_pi", &axs->old_pcap.inheritable);
1347                         audit_log_cap(ab, "old_pe", &axs->old_pcap.effective);
1348                         audit_log_cap(ab, "new_pp", &axs->new_pcap.permitted);
1349                         audit_log_cap(ab, "new_pi", &axs->new_pcap.inheritable);
1350                         audit_log_cap(ab, "new_pe", &axs->new_pcap.effective);
1351                         break; }
1352
1353                 }
1354                 audit_log_end(ab);
1355         }
1356
1357         if (context->type)
1358                 show_special(context, &call_panic);
1359
1360         if (context->fds[0] >= 0) {
1361                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_FD_PAIR);
1362                 if (ab) {
1363                         audit_log_format(ab, "fd0=%d fd1=%d",
1364                                         context->fds[0], context->fds[1]);
1365                         audit_log_end(ab);
1366                 }
1367         }
1368
1369         if (context->sockaddr_len) {
1370                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_SOCKADDR);
1371                 if (ab) {
1372                         audit_log_format(ab, "saddr=");
1373                         audit_log_n_hex(ab, (void *)context->sockaddr,
1374                                         context->sockaddr_len);
1375                         audit_log_end(ab);
1376                 }
1377         }
1378
1379         for (aux = context->aux_pids; aux; aux = aux->next) {
1380                 struct audit_aux_data_pids *axs = (void *)aux;
1381
1382                 for (i = 0; i < axs->pid_count; i++)
1383                         if (audit_log_pid_context(context, axs->target_pid[i],
1384                                                   axs->target_auid[i],
1385                                                   axs->target_uid[i],
1386                                                   axs->target_sessionid[i],
1387                                                   axs->target_sid[i],
1388                                                   axs->target_comm[i]))
1389                                 call_panic = 1;
1390         }
1391
1392         if (context->target_pid &&
1393             audit_log_pid_context(context, context->target_pid,
1394                                   context->target_auid, context->target_uid,
1395                                   context->target_sessionid,
1396                                   context->target_sid, context->target_comm))
1397                         call_panic = 1;
1398
1399         if (context->pwd.dentry && context->pwd.mnt) {
1400                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_CWD);
1401                 if (ab) {
1402                         audit_log_d_path(ab, " cwd=", &context->pwd);
1403                         audit_log_end(ab);
1404                 }
1405         }
1406
1407         i = 0;
1408         list_for_each_entry(n, &context->names_list, list) {
1409                 if (n->hidden)
1410                         continue;
1411                 audit_log_name(context, n, NULL, i++, &call_panic);
1412         }
1413
1414         /* Send end of event record to help user space know we are finished */
1415         ab = audit_log_start(context, GFP_KERNEL, AUDIT_EOE);
1416         if (ab)
1417                 audit_log_end(ab);
1418         if (call_panic)
1419                 audit_panic("error converting sid to string");
1420 }
1421
1422 /**
1423  * audit_free - free a per-task audit context
1424  * @tsk: task whose audit context block to free
1425  *
1426  * Called from copy_process and do_exit
1427  */
1428 void __audit_free(struct task_struct *tsk)
1429 {
1430         struct audit_context *context;
1431
1432         context = audit_get_context(tsk, 0, 0);
1433         if (!context)
1434                 return;
1435
1436         /* Check for system calls that do not go through the exit
1437          * function (e.g., exit_group), then free context block.
1438          * We use GFP_ATOMIC here because we might be doing this
1439          * in the context of the idle thread */
1440         /* that can happen only if we are called from do_exit() */
1441         if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
1442                 audit_log_exit(context, tsk);
1443         if (!list_empty(&context->killed_trees))
1444                 audit_kill_trees(&context->killed_trees);
1445
1446         audit_free_context(context);
1447 }
1448
1449 /**
1450  * audit_syscall_entry - fill in an audit record at syscall entry
1451  * @arch: architecture type
1452  * @major: major syscall type (function)
1453  * @a1: additional syscall register 1
1454  * @a2: additional syscall register 2
1455  * @a3: additional syscall register 3
1456  * @a4: additional syscall register 4
1457  *
1458  * Fill in audit context at syscall entry.  This only happens if the
1459  * audit context was created when the task was created and the state or
1460  * filters demand the audit context be built.  If the state from the
1461  * per-task filter or from the per-syscall filter is AUDIT_RECORD_CONTEXT,
1462  * then the record will be written at syscall exit time (otherwise, it
1463  * will only be written if another part of the kernel requests that it
1464  * be written).
1465  */
1466 void __audit_syscall_entry(int arch, int major,
1467                          unsigned long a1, unsigned long a2,
1468                          unsigned long a3, unsigned long a4)
1469 {
1470         struct task_struct *tsk = current;
1471         struct audit_context *context = tsk->audit_context;
1472         enum audit_state     state;
1473
1474         if (!context)
1475                 return;
1476
1477         BUG_ON(context->in_syscall || context->name_count);
1478
1479         if (!audit_enabled)
1480                 return;
1481
1482         context->arch       = arch;
1483         context->major      = major;
1484         context->argv[0]    = a1;
1485         context->argv[1]    = a2;
1486         context->argv[2]    = a3;
1487         context->argv[3]    = a4;
1488
1489         state = context->state;
1490         context->dummy = !audit_n_rules;
1491         if (!context->dummy && state == AUDIT_BUILD_CONTEXT) {
1492                 context->prio = 0;
1493                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
1494         }
1495         if (state == AUDIT_DISABLED)
1496                 return;
1497
1498         context->serial     = 0;
1499         context->ctime      = CURRENT_TIME;
1500         context->in_syscall = 1;
1501         context->current_state  = state;
1502         context->ppid       = 0;
1503 }
1504
1505 /**
1506  * audit_syscall_exit - deallocate audit context after a system call
1507  * @success: success value of the syscall
1508  * @return_code: return value of the syscall
1509  *
1510  * Tear down after system call.  If the audit context has been marked as
1511  * auditable (either because of the AUDIT_RECORD_CONTEXT state from
1512  * filtering, or because some other part of the kernel wrote an audit
1513  * message), then write out the syscall information.  In call cases,
1514  * free the names stored from getname().
1515  */
1516 void __audit_syscall_exit(int success, long return_code)
1517 {
1518         struct task_struct *tsk = current;
1519         struct audit_context *context;
1520
1521         if (success)
1522                 success = AUDITSC_SUCCESS;
1523         else
1524                 success = AUDITSC_FAILURE;
1525
1526         context = audit_get_context(tsk, success, return_code);
1527         if (!context)
1528                 return;
1529
1530         if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
1531                 audit_log_exit(context, tsk);
1532
1533         context->in_syscall = 0;
1534         context->prio = context->state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
1535
1536         if (!list_empty(&context->killed_trees))
1537                 audit_kill_trees(&context->killed_trees);
1538
1539         audit_free_names(context);
1540         unroll_tree_refs(context, NULL, 0);
1541         audit_free_aux(context);
1542         context->aux = NULL;
1543         context->aux_pids = NULL;
1544         context->target_pid = 0;
1545         context->target_sid = 0;
1546         context->sockaddr_len = 0;
1547         context->type = 0;
1548         context->fds[0] = -1;
1549         if (context->state != AUDIT_RECORD_CONTEXT) {
1550                 kfree(context->filterkey);
1551                 context->filterkey = NULL;
1552         }
1553         tsk->audit_context = context;
1554 }
1555
1556 static inline void handle_one(const struct inode *inode)
1557 {
1558 #ifdef CONFIG_AUDIT_TREE
1559         struct audit_context *context;
1560         struct audit_tree_refs *p;
1561         struct audit_chunk *chunk;
1562         int count;
1563         if (likely(hlist_empty(&inode->i_fsnotify_marks)))
1564                 return;
1565         context = current->audit_context;
1566         p = context->trees;
1567         count = context->tree_count;
1568         rcu_read_lock();
1569         chunk = audit_tree_lookup(inode);
1570         rcu_read_unlock();
1571         if (!chunk)
1572                 return;
1573         if (likely(put_tree_ref(context, chunk)))
1574                 return;
1575         if (unlikely(!grow_tree_refs(context))) {
1576                 printk(KERN_WARNING "out of memory, audit has lost a tree reference\n");
1577                 audit_set_auditable(context);
1578                 audit_put_chunk(chunk);
1579                 unroll_tree_refs(context, p, count);
1580                 return;
1581         }
1582         put_tree_ref(context, chunk);
1583 #endif
1584 }
1585
1586 static void handle_path(const struct dentry *dentry)
1587 {
1588 #ifdef CONFIG_AUDIT_TREE
1589         struct audit_context *context;
1590         struct audit_tree_refs *p;
1591         const struct dentry *d, *parent;
1592         struct audit_chunk *drop;
1593         unsigned long seq;
1594         int count;
1595
1596         context = current->audit_context;
1597         p = context->trees;
1598         count = context->tree_count;
1599 retry:
1600         drop = NULL;
1601         d = dentry;
1602         rcu_read_lock();
1603         seq = read_seqbegin(&rename_lock);
1604         for(;;) {
1605                 struct inode *inode = d->d_inode;
1606                 if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
1607                         struct audit_chunk *chunk;
1608                         chunk = audit_tree_lookup(inode);
1609                         if (chunk) {
1610                                 if (unlikely(!put_tree_ref(context, chunk))) {
1611                                         drop = chunk;
1612                                         break;
1613                                 }
1614                         }
1615                 }
1616                 parent = d->d_parent;
1617                 if (parent == d)
1618                         break;
1619                 d = parent;
1620         }
1621         if (unlikely(read_seqretry(&rename_lock, seq) || drop)) {  /* in this order */
1622                 rcu_read_unlock();
1623                 if (!drop) {
1624                         /* just a race with rename */
1625                         unroll_tree_refs(context, p, count);
1626                         goto retry;
1627                 }
1628                 audit_put_chunk(drop);
1629                 if (grow_tree_refs(context)) {
1630                         /* OK, got more space */
1631                         unroll_tree_refs(context, p, count);
1632                         goto retry;
1633                 }
1634                 /* too bad */
1635                 printk(KERN_WARNING
1636                         "out of memory, audit has lost a tree reference\n");
1637                 unroll_tree_refs(context, p, count);
1638                 audit_set_auditable(context);
1639                 return;
1640         }
1641         rcu_read_unlock();
1642 #endif
1643 }
1644
1645 static struct audit_names *audit_alloc_name(struct audit_context *context,
1646                                                 unsigned char type)
1647 {
1648         struct audit_names *aname;
1649
1650         if (context->name_count < AUDIT_NAMES) {
1651                 aname = &context->preallocated_names[context->name_count];
1652                 memset(aname, 0, sizeof(*aname));
1653         } else {
1654                 aname = kzalloc(sizeof(*aname), GFP_NOFS);
1655                 if (!aname)
1656                         return NULL;
1657                 aname->should_free = true;
1658         }
1659
1660         aname->ino = (unsigned long)-1;
1661         aname->type = type;
1662         list_add_tail(&aname->list, &context->names_list);
1663
1664         context->name_count++;
1665 #if AUDIT_DEBUG
1666         context->ino_count++;
1667 #endif
1668         return aname;
1669 }
1670
1671 /**
1672  * audit_reusename - fill out filename with info from existing entry
1673  * @uptr: userland ptr to pathname
1674  *
1675  * Search the audit_names list for the current audit context. If there is an
1676  * existing entry with a matching "uptr" then return the filename
1677  * associated with that audit_name. If not, return NULL.
1678  */
1679 struct filename *
1680 __audit_reusename(const __user char *uptr)
1681 {
1682         struct audit_context *context = current->audit_context;
1683         struct audit_names *n;
1684
1685         list_for_each_entry(n, &context->names_list, list) {
1686                 if (!n->name)
1687                         continue;
1688                 if (n->name->uptr == uptr)
1689                         return n->name;
1690         }
1691         return NULL;
1692 }
1693
1694 /**
1695  * audit_getname - add a name to the list
1696  * @name: name to add
1697  *
1698  * Add a name to the list of audit names for this context.
1699  * Called from fs/namei.c:getname().
1700  */
1701 void __audit_getname(struct filename *name)
1702 {
1703         struct audit_context *context = current->audit_context;
1704         struct audit_names *n;
1705
1706         if (!context->in_syscall) {
1707 #if AUDIT_DEBUG == 2
1708                 printk(KERN_ERR "%s:%d(:%d): ignoring getname(%p)\n",
1709                        __FILE__, __LINE__, context->serial, name);
1710                 dump_stack();
1711 #endif
1712                 return;
1713         }
1714
1715 #if AUDIT_DEBUG
1716         /* The filename _must_ have a populated ->name */
1717         BUG_ON(!name->name);
1718 #endif
1719
1720         n = audit_alloc_name(context, AUDIT_TYPE_UNKNOWN);
1721         if (!n)
1722                 return;
1723
1724         n->name = name;
1725         n->name_len = AUDIT_NAME_FULL;
1726         n->name_put = true;
1727         name->aname = n;
1728
1729         if (!context->pwd.dentry)
1730                 get_fs_pwd(current->fs, &context->pwd);
1731 }
1732
1733 /* audit_putname - intercept a putname request
1734  * @name: name to intercept and delay for putname
1735  *
1736  * If we have stored the name from getname in the audit context,
1737  * then we delay the putname until syscall exit.
1738  * Called from include/linux/fs.h:putname().
1739  */
1740 void audit_putname(struct filename *name)
1741 {
1742         struct audit_context *context = current->audit_context;
1743
1744         BUG_ON(!context);
1745         if (!context->in_syscall) {
1746 #if AUDIT_DEBUG == 2
1747                 printk(KERN_ERR "%s:%d(:%d): final_putname(%p)\n",
1748                        __FILE__, __LINE__, context->serial, name);
1749                 if (context->name_count) {
1750                         struct audit_names *n;
1751                         int i = 0;
1752
1753                         list_for_each_entry(n, &context->names_list, list)
1754                                 printk(KERN_ERR "name[%d] = %p = %s\n", i++,
1755                                        n->name, n->name->name ?: "(null)");
1756                         }
1757 #endif
1758                 final_putname(name);
1759         }
1760 #if AUDIT_DEBUG
1761         else {
1762                 ++context->put_count;
1763                 if (context->put_count > context->name_count) {
1764                         printk(KERN_ERR "%s:%d(:%d): major=%d"
1765                                " in_syscall=%d putname(%p) name_count=%d"
1766                                " put_count=%d\n",
1767                                __FILE__, __LINE__,
1768                                context->serial, context->major,
1769                                context->in_syscall, name->name,
1770                                context->name_count, context->put_count);
1771                         dump_stack();
1772                 }
1773         }
1774 #endif
1775 }
1776
1777 /**
1778  * __audit_inode - store the inode and device from a lookup
1779  * @name: name being audited
1780  * @dentry: dentry being audited
1781  * @flags: attributes for this particular entry
1782  */
1783 void __audit_inode(struct filename *name, const struct dentry *dentry,
1784                    unsigned int flags)
1785 {
1786         struct audit_context *context = current->audit_context;
1787         const struct inode *inode = dentry->d_inode;
1788         struct audit_names *n;
1789         bool parent = flags & AUDIT_INODE_PARENT;
1790
1791         if (!context->in_syscall)
1792                 return;
1793
1794         if (!name)
1795                 goto out_alloc;
1796
1797 #if AUDIT_DEBUG
1798         /* The struct filename _must_ have a populated ->name */
1799         BUG_ON(!name->name);
1800 #endif
1801         /*
1802          * If we have a pointer to an audit_names entry already, then we can
1803          * just use it directly if the type is correct.
1804          */
1805         n = name->aname;
1806         if (n) {
1807                 if (parent) {
1808                         if (n->type == AUDIT_TYPE_PARENT ||
1809                             n->type == AUDIT_TYPE_UNKNOWN)
1810                                 goto out;
1811                 } else {
1812                         if (n->type != AUDIT_TYPE_PARENT)
1813                                 goto out;
1814                 }
1815         }
1816
1817         list_for_each_entry_reverse(n, &context->names_list, list) {
1818                 /* does the name pointer match? */
1819                 if (!n->name || n->name->name != name->name)
1820                         continue;
1821
1822                 /* match the correct record type */
1823                 if (parent) {
1824                         if (n->type == AUDIT_TYPE_PARENT ||
1825                             n->type == AUDIT_TYPE_UNKNOWN)
1826                                 goto out;
1827                 } else {
1828                         if (n->type != AUDIT_TYPE_PARENT)
1829                                 goto out;
1830                 }
1831         }
1832
1833 out_alloc:
1834         /* unable to find the name from a previous getname(). Allocate a new
1835          * anonymous entry.
1836          */
1837         n = audit_alloc_name(context, AUDIT_TYPE_NORMAL);
1838         if (!n)
1839                 return;
1840 out:
1841         if (parent) {
1842                 n->name_len = n->name ? parent_len(n->name->name) : AUDIT_NAME_FULL;
1843                 n->type = AUDIT_TYPE_PARENT;
1844                 if (flags & AUDIT_INODE_HIDDEN)
1845                         n->hidden = true;
1846         } else {
1847                 n->name_len = AUDIT_NAME_FULL;
1848                 n->type = AUDIT_TYPE_NORMAL;
1849         }
1850         handle_path(dentry);
1851         audit_copy_inode(n, dentry, inode);
1852 }
1853
1854 /**
1855  * __audit_inode_child - collect inode info for created/removed objects
1856  * @parent: inode of dentry parent
1857  * @dentry: dentry being audited
1858  * @type:   AUDIT_TYPE_* value that we're looking for
1859  *
1860  * For syscalls that create or remove filesystem objects, audit_inode
1861  * can only collect information for the filesystem object's parent.
1862  * This call updates the audit context with the child's information.
1863  * Syscalls that create a new filesystem object must be hooked after
1864  * the object is created.  Syscalls that remove a filesystem object
1865  * must be hooked prior, in order to capture the target inode during
1866  * unsuccessful attempts.
1867  */
1868 void __audit_inode_child(const struct inode *parent,
1869                          const struct dentry *dentry,
1870                          const unsigned char type)
1871 {
1872         struct audit_context *context = current->audit_context;
1873         const struct inode *inode = dentry->d_inode;
1874         const char *dname = dentry->d_name.name;
1875         struct audit_names *n, *found_parent = NULL, *found_child = NULL;
1876
1877         if (!context->in_syscall)
1878                 return;
1879
1880         if (inode)
1881                 handle_one(inode);
1882
1883         /* look for a parent entry first */
1884         list_for_each_entry(n, &context->names_list, list) {
1885                 if (!n->name || n->type != AUDIT_TYPE_PARENT)
1886                         continue;
1887
1888                 if (n->ino == parent->i_ino &&
1889                     !audit_compare_dname_path(dname, n->name->name, n->name_len)) {
1890                         found_parent = n;
1891                         break;
1892                 }
1893         }
1894
1895         /* is there a matching child entry? */
1896         list_for_each_entry(n, &context->names_list, list) {
1897                 /* can only match entries that have a name */
1898                 if (!n->name || n->type != type)
1899                         continue;
1900
1901                 /* if we found a parent, make sure this one is a child of it */
1902                 if (found_parent && (n->name != found_parent->name))
1903                         continue;
1904
1905                 if (!strcmp(dname, n->name->name) ||
1906                     !audit_compare_dname_path(dname, n->name->name,
1907                                                 found_parent ?
1908                                                 found_parent->name_len :
1909                                                 AUDIT_NAME_FULL)) {
1910                         found_child = n;
1911                         break;
1912                 }
1913         }
1914
1915         if (!found_parent) {
1916                 /* create a new, "anonymous" parent record */
1917                 n = audit_alloc_name(context, AUDIT_TYPE_PARENT);
1918                 if (!n)
1919                         return;
1920                 audit_copy_inode(n, NULL, parent);
1921         }
1922
1923         if (!found_child) {
1924                 found_child = audit_alloc_name(context, type);
1925                 if (!found_child)
1926                         return;
1927
1928                 /* Re-use the name belonging to the slot for a matching parent
1929                  * directory. All names for this context are relinquished in
1930                  * audit_free_names() */
1931                 if (found_parent) {
1932                         found_child->name = found_parent->name;
1933                         found_child->name_len = AUDIT_NAME_FULL;
1934                         /* don't call __putname() */
1935                         found_child->name_put = false;
1936                 }
1937         }
1938         if (inode)
1939                 audit_copy_inode(found_child, dentry, inode);
1940         else
1941                 found_child->ino = (unsigned long)-1;
1942 }
1943 EXPORT_SYMBOL_GPL(__audit_inode_child);
1944
1945 /**
1946  * auditsc_get_stamp - get local copies of audit_context values
1947  * @ctx: audit_context for the task
1948  * @t: timespec to store time recorded in the audit_context
1949  * @serial: serial value that is recorded in the audit_context
1950  *
1951  * Also sets the context as auditable.
1952  */
1953 int auditsc_get_stamp(struct audit_context *ctx,
1954                        struct timespec *t, unsigned int *serial)
1955 {
1956         if (!ctx->in_syscall)
1957                 return 0;
1958         if (!ctx->serial)
1959                 ctx->serial = audit_serial();
1960         t->tv_sec  = ctx->ctime.tv_sec;
1961         t->tv_nsec = ctx->ctime.tv_nsec;
1962         *serial    = ctx->serial;
1963         if (!ctx->prio) {
1964                 ctx->prio = 1;
1965                 ctx->current_state = AUDIT_RECORD_CONTEXT;
1966         }
1967         return 1;
1968 }
1969
1970 /* global counter which is incremented every time something logs in */
1971 static atomic_t session_id = ATOMIC_INIT(0);
1972
1973 /**
1974  * audit_set_loginuid - set current task's audit_context loginuid
1975  * @loginuid: loginuid value
1976  *
1977  * Returns 0.
1978  *
1979  * Called (set) from fs/proc/base.c::proc_loginuid_write().
1980  */
1981 int audit_set_loginuid(kuid_t loginuid)
1982 {
1983         struct task_struct *task = current;
1984         struct audit_context *context = task->audit_context;
1985         unsigned int sessionid;
1986
1987 #ifdef CONFIG_AUDIT_LOGINUID_IMMUTABLE
1988         if (audit_loginuid_set(task))
1989                 return -EPERM;
1990 #else /* CONFIG_AUDIT_LOGINUID_IMMUTABLE */
1991         if (!capable(CAP_AUDIT_CONTROL))
1992                 return -EPERM;
1993 #endif  /* CONFIG_AUDIT_LOGINUID_IMMUTABLE */
1994
1995         sessionid = atomic_inc_return(&session_id);
1996         if (context && context->in_syscall) {
1997                 struct audit_buffer *ab;
1998
1999                 ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
2000                 if (ab) {
2001                         audit_log_format(ab, "login pid=%d uid=%u "
2002                                 "old auid=%u new auid=%u"
2003                                 " old ses=%u new ses=%u",
2004                                 task->pid,
2005                                 from_kuid(&init_user_ns, task_uid(task)),
2006                                 from_kuid(&init_user_ns, task->loginuid),
2007                                 from_kuid(&init_user_ns, loginuid),
2008                                 task->sessionid, sessionid);
2009                         audit_log_end(ab);
2010                 }
2011         }
2012         task->sessionid = sessionid;
2013         task->loginuid = loginuid;
2014         return 0;
2015 }
2016
2017 /**
2018  * __audit_mq_open - record audit data for a POSIX MQ open
2019  * @oflag: open flag
2020  * @mode: mode bits
2021  * @attr: queue attributes
2022  *
2023  */
2024 void __audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
2025 {
2026         struct audit_context *context = current->audit_context;
2027
2028         if (attr)
2029                 memcpy(&context->mq_open.attr, attr, sizeof(struct mq_attr));
2030         else
2031                 memset(&context->mq_open.attr, 0, sizeof(struct mq_attr));
2032
2033         context->mq_open.oflag = oflag;
2034         context->mq_open.mode = mode;
2035
2036         context->type = AUDIT_MQ_OPEN;
2037 }
2038
2039 /**
2040  * __audit_mq_sendrecv - record audit data for a POSIX MQ timed send/receive
2041  * @mqdes: MQ descriptor
2042  * @msg_len: Message length
2043  * @msg_prio: Message priority
2044  * @abs_timeout: Message timeout in absolute time
2045  *
2046  */
2047 void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
2048                         const struct timespec *abs_timeout)
2049 {
2050         struct audit_context *context = current->audit_context;
2051         struct timespec *p = &context->mq_sendrecv.abs_timeout;
2052
2053         if (abs_timeout)
2054                 memcpy(p, abs_timeout, sizeof(struct timespec));
2055         else
2056                 memset(p, 0, sizeof(struct timespec));
2057
2058         context->mq_sendrecv.mqdes = mqdes;
2059         context->mq_sendrecv.msg_len = msg_len;
2060         context->mq_sendrecv.msg_prio = msg_prio;
2061
2062         context->type = AUDIT_MQ_SENDRECV;
2063 }
2064
2065 /**
2066  * __audit_mq_notify - record audit data for a POSIX MQ notify
2067  * @mqdes: MQ descriptor
2068  * @notification: Notification event
2069  *
2070  */
2071
2072 void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
2073 {
2074         struct audit_context *context = current->audit_context;
2075
2076         if (notification)
2077                 context->mq_notify.sigev_signo = notification->sigev_signo;
2078         else
2079                 context->mq_notify.sigev_signo = 0;
2080
2081         context->mq_notify.mqdes = mqdes;
2082         context->type = AUDIT_MQ_NOTIFY;
2083 }
2084
2085 /**
2086  * __audit_mq_getsetattr - record audit data for a POSIX MQ get/set attribute
2087  * @mqdes: MQ descriptor
2088  * @mqstat: MQ flags
2089  *
2090  */
2091 void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
2092 {
2093         struct audit_context *context = current->audit_context;
2094         context->mq_getsetattr.mqdes = mqdes;
2095         context->mq_getsetattr.mqstat = *mqstat;
2096         context->type = AUDIT_MQ_GETSETATTR;
2097 }
2098
2099 /**
2100  * audit_ipc_obj - record audit data for ipc object
2101  * @ipcp: ipc permissions
2102  *
2103  */
2104 void __audit_ipc_obj(struct kern_ipc_perm *ipcp)
2105 {
2106         struct audit_context *context = current->audit_context;
2107         context->ipc.uid = ipcp->uid;
2108         context->ipc.gid = ipcp->gid;
2109         context->ipc.mode = ipcp->mode;
2110         context->ipc.has_perm = 0;
2111         security_ipc_getsecid(ipcp, &context->ipc.osid);
2112         context->type = AUDIT_IPC;
2113 }
2114
2115 /**
2116  * audit_ipc_set_perm - record audit data for new ipc permissions
2117  * @qbytes: msgq bytes
2118  * @uid: msgq user id
2119  * @gid: msgq group id
2120  * @mode: msgq mode (permissions)
2121  *
2122  * Called only after audit_ipc_obj().
2123  */
2124 void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode)
2125 {
2126         struct audit_context *context = current->audit_context;
2127
2128         context->ipc.qbytes = qbytes;
2129         context->ipc.perm_uid = uid;
2130         context->ipc.perm_gid = gid;
2131         context->ipc.perm_mode = mode;
2132         context->ipc.has_perm = 1;
2133 }
2134
2135 int __audit_bprm(struct linux_binprm *bprm)
2136 {
2137         struct audit_aux_data_execve *ax;
2138         struct audit_context *context = current->audit_context;
2139
2140         ax = kmalloc(sizeof(*ax), GFP_KERNEL);
2141         if (!ax)
2142                 return -ENOMEM;
2143
2144         ax->argc = bprm->argc;
2145         ax->envc = bprm->envc;
2146         ax->mm = bprm->mm;
2147         ax->d.type = AUDIT_EXECVE;
2148         ax->d.next = context->aux;
2149         context->aux = (void *)ax;
2150         return 0;
2151 }
2152
2153
2154 /**
2155  * audit_socketcall - record audit data for sys_socketcall
2156  * @nargs: number of args, which should not be more than AUDITSC_ARGS.
2157  * @args: args array
2158  *
2159  */
2160 int __audit_socketcall(int nargs, unsigned long *args)
2161 {
2162         struct audit_context *context = current->audit_context;
2163
2164         if (nargs <= 0 || nargs > AUDITSC_ARGS || !args)
2165                 return -EINVAL;
2166         context->type = AUDIT_SOCKETCALL;
2167         context->socketcall.nargs = nargs;
2168         memcpy(context->socketcall.args, args, nargs * sizeof(unsigned long));
2169         return 0;
2170 }
2171
2172 /**
2173  * __audit_fd_pair - record audit data for pipe and socketpair
2174  * @fd1: the first file descriptor
2175  * @fd2: the second file descriptor
2176  *
2177  */
2178 void __audit_fd_pair(int fd1, int fd2)
2179 {
2180         struct audit_context *context = current->audit_context;
2181         context->fds[0] = fd1;
2182         context->fds[1] = fd2;
2183 }
2184
2185 /**
2186  * audit_sockaddr - record audit data for sys_bind, sys_connect, sys_sendto
2187  * @len: data length in user space
2188  * @a: data address in kernel space
2189  *
2190  * Returns 0 for success or NULL context or < 0 on error.
2191  */
2192 int __audit_sockaddr(int len, void *a)
2193 {
2194         struct audit_context *context = current->audit_context;
2195
2196         if (!context->sockaddr) {
2197                 void *p = kmalloc(sizeof(struct sockaddr_storage), GFP_KERNEL);
2198                 if (!p)
2199                         return -ENOMEM;
2200                 context->sockaddr = p;
2201         }
2202
2203         context->sockaddr_len = len;
2204         memcpy(context->sockaddr, a, len);
2205         return 0;
2206 }
2207
2208 void __audit_ptrace(struct task_struct *t)
2209 {
2210         struct audit_context *context = current->audit_context;
2211
2212         context->target_pid = t->pid;
2213         context->target_auid = audit_get_loginuid(t);
2214         context->target_uid = task_uid(t);
2215         context->target_sessionid = audit_get_sessionid(t);
2216         security_task_getsecid(t, &context->target_sid);
2217         memcpy(context->target_comm, t->comm, TASK_COMM_LEN);
2218 }
2219
2220 /**
2221  * audit_signal_info - record signal info for shutting down audit subsystem
2222  * @sig: signal value
2223  * @t: task being signaled
2224  *
2225  * If the audit subsystem is being terminated, record the task (pid)
2226  * and uid that is doing that.
2227  */
2228 int __audit_signal_info(int sig, struct task_struct *t)
2229 {
2230         struct audit_aux_data_pids *axp;
2231         struct task_struct *tsk = current;
2232         struct audit_context *ctx = tsk->audit_context;
2233         kuid_t uid = current_uid(), t_uid = task_uid(t);
2234
2235         if (audit_pid && t->tgid == audit_pid) {
2236                 if (sig == SIGTERM || sig == SIGHUP || sig == SIGUSR1 || sig == SIGUSR2) {
2237                         audit_sig_pid = tsk->pid;
2238                         if (uid_valid(tsk->loginuid))
2239                                 audit_sig_uid = tsk->loginuid;
2240                         else
2241                                 audit_sig_uid = uid;
2242                         security_task_getsecid(tsk, &audit_sig_sid);
2243                 }
2244                 if (!audit_signals || audit_dummy_context())
2245                         return 0;
2246         }
2247
2248         /* optimize the common case by putting first signal recipient directly
2249          * in audit_context */
2250         if (!ctx->target_pid) {
2251                 ctx->target_pid = t->tgid;
2252                 ctx->target_auid = audit_get_loginuid(t);
2253                 ctx->target_uid = t_uid;
2254                 ctx->target_sessionid = audit_get_sessionid(t);
2255                 security_task_getsecid(t, &ctx->target_sid);
2256                 memcpy(ctx->target_comm, t->comm, TASK_COMM_LEN);
2257                 return 0;
2258         }
2259
2260         axp = (void *)ctx->aux_pids;
2261         if (!axp || axp->pid_count == AUDIT_AUX_PIDS) {
2262                 axp = kzalloc(sizeof(*axp), GFP_ATOMIC);
2263                 if (!axp)
2264                         return -ENOMEM;
2265
2266                 axp->d.type = AUDIT_OBJ_PID;
2267                 axp->d.next = ctx->aux_pids;
2268                 ctx->aux_pids = (void *)axp;
2269         }
2270         BUG_ON(axp->pid_count >= AUDIT_AUX_PIDS);
2271
2272         axp->target_pid[axp->pid_count] = t->tgid;
2273         axp->target_auid[axp->pid_count] = audit_get_loginuid(t);
2274         axp->target_uid[axp->pid_count] = t_uid;
2275         axp->target_sessionid[axp->pid_count] = audit_get_sessionid(t);
2276         security_task_getsecid(t, &axp->target_sid[axp->pid_count]);
2277         memcpy(axp->target_comm[axp->pid_count], t->comm, TASK_COMM_LEN);
2278         axp->pid_count++;
2279
2280         return 0;
2281 }
2282
2283 /**
2284  * __audit_log_bprm_fcaps - store information about a loading bprm and relevant fcaps
2285  * @bprm: pointer to the bprm being processed
2286  * @new: the proposed new credentials
2287  * @old: the old credentials
2288  *
2289  * Simply check if the proc already has the caps given by the file and if not
2290  * store the priv escalation info for later auditing at the end of the syscall
2291  *
2292  * -Eric
2293  */
2294 int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
2295                            const struct cred *new, const struct cred *old)
2296 {
2297         struct audit_aux_data_bprm_fcaps *ax;
2298         struct audit_context *context = current->audit_context;
2299         struct cpu_vfs_cap_data vcaps;
2300         struct dentry *dentry;
2301
2302         ax = kmalloc(sizeof(*ax), GFP_KERNEL);
2303         if (!ax)
2304                 return -ENOMEM;
2305
2306         ax->d.type = AUDIT_BPRM_FCAPS;
2307         ax->d.next = context->aux;
2308         context->aux = (void *)ax;
2309
2310         dentry = dget(bprm->file->f_dentry);
2311         get_vfs_caps_from_disk(dentry, &vcaps);
2312         dput(dentry);
2313
2314         ax->fcap.permitted = vcaps.permitted;
2315         ax->fcap.inheritable = vcaps.inheritable;
2316         ax->fcap.fE = !!(vcaps.magic_etc & VFS_CAP_FLAGS_EFFECTIVE);
2317         ax->fcap_ver = (vcaps.magic_etc & VFS_CAP_REVISION_MASK) >> VFS_CAP_REVISION_SHIFT;
2318
2319         ax->old_pcap.permitted   = old->cap_permitted;
2320         ax->old_pcap.inheritable = old->cap_inheritable;
2321         ax->old_pcap.effective   = old->cap_effective;
2322
2323         ax->new_pcap.permitted   = new->cap_permitted;
2324         ax->new_pcap.inheritable = new->cap_inheritable;
2325         ax->new_pcap.effective   = new->cap_effective;
2326         return 0;
2327 }
2328
2329 /**
2330  * __audit_log_capset - store information about the arguments to the capset syscall
2331  * @pid: target pid of the capset call
2332  * @new: the new credentials
2333  * @old: the old (current) credentials
2334  *
2335  * Record the aguments userspace sent to sys_capset for later printing by the
2336  * audit system if applicable
2337  */
2338 void __audit_log_capset(pid_t pid,
2339                        const struct cred *new, const struct cred *old)
2340 {
2341         struct audit_context *context = current->audit_context;
2342         context->capset.pid = pid;
2343         context->capset.cap.effective   = new->cap_effective;
2344         context->capset.cap.inheritable = new->cap_effective;
2345         context->capset.cap.permitted   = new->cap_permitted;
2346         context->type = AUDIT_CAPSET;
2347 }
2348
2349 void __audit_mmap_fd(int fd, int flags)
2350 {
2351         struct audit_context *context = current->audit_context;
2352         context->mmap.fd = fd;
2353         context->mmap.flags = flags;
2354         context->type = AUDIT_MMAP;
2355 }
2356
2357 static void audit_log_task(struct audit_buffer *ab)
2358 {
2359         kuid_t auid, uid;
2360         kgid_t gid;
2361         unsigned int sessionid;
2362
2363         auid = audit_get_loginuid(current);
2364         sessionid = audit_get_sessionid(current);
2365         current_uid_gid(&uid, &gid);
2366
2367         audit_log_format(ab, "auid=%u uid=%u gid=%u ses=%u",
2368                          from_kuid(&init_user_ns, auid),
2369                          from_kuid(&init_user_ns, uid),
2370                          from_kgid(&init_user_ns, gid),
2371                          sessionid);
2372         audit_log_task_context(ab);
2373         audit_log_format(ab, " pid=%d comm=", current->pid);
2374         audit_log_untrustedstring(ab, current->comm);
2375 }
2376
2377 static void audit_log_abend(struct audit_buffer *ab, char *reason, long signr)
2378 {
2379         audit_log_task(ab);
2380         audit_log_format(ab, " reason=");
2381         audit_log_string(ab, reason);
2382         audit_log_format(ab, " sig=%ld", signr);
2383 }
2384 /**
2385  * audit_core_dumps - record information about processes that end abnormally
2386  * @signr: signal value
2387  *
2388  * If a process ends with a core dump, something fishy is going on and we
2389  * should record the event for investigation.
2390  */
2391 void audit_core_dumps(long signr)
2392 {
2393         struct audit_buffer *ab;
2394
2395         if (!audit_enabled)
2396                 return;
2397
2398         if (signr == SIGQUIT)   /* don't care for those */
2399                 return;
2400
2401         ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_ANOM_ABEND);
2402         if (unlikely(!ab))
2403                 return;
2404         audit_log_abend(ab, "memory violation", signr);
2405         audit_log_end(ab);
2406 }
2407
2408 void __audit_seccomp(unsigned long syscall, long signr, int code)
2409 {
2410         struct audit_buffer *ab;
2411
2412         ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_SECCOMP);
2413         if (unlikely(!ab))
2414                 return;
2415         audit_log_task(ab);
2416         audit_log_format(ab, " sig=%ld", signr);
2417         audit_log_format(ab, " syscall=%ld", syscall);
2418         audit_log_format(ab, " compat=%d", is_compat_task());
2419         audit_log_format(ab, " ip=0x%lx", KSTK_EIP(current));
2420         audit_log_format(ab, " code=0x%x", code);
2421         audit_log_end(ab);
2422 }
2423
2424 struct list_head *audit_killed_trees(void)
2425 {
2426         struct audit_context *ctx = current->audit_context;
2427         if (likely(!ctx || !ctx->in_syscall))
2428                 return NULL;
2429         return &ctx->killed_trees;
2430 }