kernel/audit_tree.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "audit.h"
   3 #include <linux/fsnotify_backend.h>
   4 #include <linux/namei.h>
   5 #include <linux/mount.h>
   6 #include <linux/kthread.h>
   7 #include <linux/refcount.h>
   8 #include <linux/slab.h>
   9
  10 struct audit_tree;
  11 struct audit_chunk;
  12
  13 struct audit_tree {
  14         refcount_t count;
  15         int goner;
  16         struct audit_chunk *root;
  17         struct list_head chunks;
  18         struct list_head rules;
  19         struct list_head list;
  20         struct list_head same_root;
  21         struct rcu_head head;
  22         char pathname[];
  23 };
  24
  25 struct audit_chunk {
  26         struct list_head hash;
  27         unsigned long key;
  28         struct fsnotify_mark *mark;
  29         struct list_head trees;         /* with root here */
  30         int count;
  31         atomic_long_t refs;
  32         struct rcu_head head;
  33         struct audit_node {
  34                 struct list_head list;
  35                 struct audit_tree *owner;
  36                 unsigned index;         /* index; upper bit indicates 'will prune' */
  37         } owners[];
  38 };
  39
  40 struct audit_tree_mark {
  41         struct fsnotify_mark mark;
  42         struct audit_chunk *chunk;
  43 };
  44
  45 static LIST_HEAD(tree_list);
  46 static LIST_HEAD(prune_list);
  47 static struct task_struct *prune_thread;
  48
  49 /*
  50  * One struct chunk is attached to each inode of interest through
  51  * audit_tree_mark (fsnotify mark). We replace struct chunk on tagging /
  52  * untagging, the mark is stable as long as there is chunk attached. The
  53  * association between mark and chunk is protected by hash_lock and
  54  * audit_tree_group->mark_mutex. Thus as long as we hold
  55  * audit_tree_group->mark_mutex and check that the mark is alive by
  56  * FSNOTIFY_MARK_FLAG_ATTACHED flag check, we are sure the mark points to
  57  * the current chunk.
  58  *
  59  * Rules have pointer to struct audit_tree.
  60  * Rules have struct list_head rlist forming a list of rules over
  61  * the same tree.
  62  * References to struct chunk are collected at audit_inode{,_child}()
  63  * time and used in AUDIT_TREE rule matching.
  64  * These references are dropped at the same time we are calling
  65  * audit_free_names(), etc.
  66  *
  67  * Cyclic lists galore:
  68  * tree.chunks anchors chunk.owners[].list                      hash_lock
  69  * tree.rules anchors rule.rlist                                audit_filter_mutex
  70  * chunk.trees anchors tree.same_root                           hash_lock
  71  * chunk.hash is a hash with middle bits of watch.inode as
  72  * a hash function.                                             RCU, hash_lock
  73  *
  74  * tree is refcounted; one reference for "some rules on rules_list refer to
  75  * it", one for each chunk with pointer to it.
  76  *
  77  * chunk is refcounted by embedded .refs. Mark associated with the chunk holds
  78  * one chunk reference. This reference is dropped either when a mark is going
  79  * to be freed (corresponding inode goes away) or when chunk attached to the
  80  * mark gets replaced. This reference must be dropped using
  81  * audit_mark_put_chunk() to make sure the reference is dropped only after RCU
  82  * grace period as it protects RCU readers of the hash table.
  83  *
  84  * node.index allows to get from node.list to containing chunk.
  85  * MSB of that sucker is stolen to mark taggings that we might have to
  86  * revert - several operations have very unpleasant cleanup logics and
  87  * that makes a difference.  Some.
  88  */
  89
  90 static struct fsnotify_group *audit_tree_group;
  91 static struct kmem_cache *audit_tree_mark_cachep __read_mostly;
  92
  93 static struct audit_tree *alloc_tree(const char *s)
  94 {
  95         struct audit_tree *tree;
  96
  97         tree = kmalloc(struct_size(tree, pathname, strlen(s) + 1), GFP_KERNEL);
  98         if (tree) {
  99                 refcount_set(&tree->count, 1);
 100                 tree->goner = 0;
 101                 INIT_LIST_HEAD(&tree->chunks);
 102                 INIT_LIST_HEAD(&tree->rules);
 103                 INIT_LIST_HEAD(&tree->list);
 104                 INIT_LIST_HEAD(&tree->same_root);
 105                 tree->root = NULL;
 106                 strcpy(tree->pathname, s);
 107         }
 108         return tree;
 109 }
 110
 111 static inline void get_tree(struct audit_tree *tree)
 112 {
 113         refcount_inc(&tree->count);
 114 }
 115
 116 static inline void put_tree(struct audit_tree *tree)
 117 {
 118         if (refcount_dec_and_test(&tree->count))
 119                 kfree_rcu(tree, head);
 120 }
 121
 122 /* to avoid bringing the entire thing in audit.h */
 123 const char *audit_tree_path(struct audit_tree *tree)
 124 {
 125         return tree->pathname;
 126 }
 127
 128 static void free_chunk(struct audit_chunk *chunk)
 129 {
 130         int i;
 131
 132         for (i = 0; i < chunk->count; i++) {
 133                 if (chunk->owners[i].owner)
 134                         put_tree(chunk->owners[i].owner);
 135         }
 136         kfree(chunk);
 137 }
 138
 139 void audit_put_chunk(struct audit_chunk *chunk)
 140 {
 141         if (atomic_long_dec_and_test(&chunk->refs))
 142                 free_chunk(chunk);
 143 }
 144
 145 static void __put_chunk(struct rcu_head *rcu)
 146 {
 147         struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);
 148         audit_put_chunk(chunk);
 149 }
 150
 151 /*
 152  * Drop reference to the chunk that was held by the mark. This is the reference
 153  * that gets dropped after we've removed the chunk from the hash table and we
 154  * use it to make sure chunk cannot be freed before RCU grace period expires.
 155  */
 156 static void audit_mark_put_chunk(struct audit_chunk *chunk)
 157 {
 158         call_rcu(&chunk->head, __put_chunk);
 159 }
 160
 161 static inline struct audit_tree_mark *audit_mark(struct fsnotify_mark *mark)
 162 {
 163         return container_of(mark, struct audit_tree_mark, mark);
 164 }
 165
 166 static struct audit_chunk *mark_chunk(struct fsnotify_mark *mark)
 167 {
 168         return audit_mark(mark)->chunk;
 169 }
 170
 171 static void audit_tree_destroy_watch(struct fsnotify_mark *mark)
 172 {
 173         kmem_cache_free(audit_tree_mark_cachep, audit_mark(mark));
 174 }
 175
 176 static struct fsnotify_mark *alloc_mark(void)
 177 {
 178         struct audit_tree_mark *amark;
 179
 180         amark = kmem_cache_zalloc(audit_tree_mark_cachep, GFP_KERNEL);
 181         if (!amark)
 182                 return NULL;
 183         fsnotify_init_mark(&amark->mark, audit_tree_group);
 184         amark->mark.mask = FS_IN_IGNORED;
 185         return &amark->mark;
 186 }
 187
 188 static struct audit_chunk *alloc_chunk(int count)
 189 {
 190         struct audit_chunk *chunk;
 191         int i;
 192
 193         chunk = kzalloc(struct_size(chunk, owners, count), GFP_KERNEL);
 194         if (!chunk)
 195                 return NULL;
 196
 197         INIT_LIST_HEAD(&chunk->hash);
 198         INIT_LIST_HEAD(&chunk->trees);
 199         chunk->count = count;
 200         atomic_long_set(&chunk->refs, 1);
 201         for (i = 0; i < count; i++) {
 202                 INIT_LIST_HEAD(&chunk->owners[i].list);
 203                 chunk->owners[i].index = i;
 204         }
 205         return chunk;
 206 }
 207
 208 enum {HASH_SIZE = 128};
 209 static struct list_head chunk_hash_heads[HASH_SIZE];
 210 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock);
 211
 212 /* Function to return search key in our hash from inode. */
 213 static unsigned long inode_to_key(const struct inode *inode)
 214 {
 215         /* Use address pointed to by connector->obj as the key */
 216         return (unsigned long)&inode->i_fsnotify_marks;
 217 }
 218
 219 static inline struct list_head *chunk_hash(unsigned long key)
 220 {
 221         unsigned long n = key / L1_CACHE_BYTES;
 222         return chunk_hash_heads + n % HASH_SIZE;
 223 }
 224
 225 /* hash_lock & mark->group->mark_mutex is held by caller */
 226 static void insert_hash(struct audit_chunk *chunk)
 227 {
 228         struct list_head *list;
 229
 230         /*
 231          * Make sure chunk is fully initialized before making it visible in the
 232          * hash. Pairs with a data dependency barrier in READ_ONCE() in
 233          * audit_tree_lookup().
 234          */
 235         smp_wmb();
 236         WARN_ON_ONCE(!chunk->key);
 237         list = chunk_hash(chunk->key);
 238         list_add_rcu(&chunk->hash, list);
 239 }
 240
 241 /* called under rcu_read_lock */
 242 struct audit_chunk *audit_tree_lookup(const struct inode *inode)
 243 {
 244         unsigned long key = inode_to_key(inode);
 245         struct list_head *list = chunk_hash(key);
 246         struct audit_chunk *p;
 247
 248         list_for_each_entry_rcu(p, list, hash) {
 249                 /*
 250                  * We use a data dependency barrier in READ_ONCE() to make sure
 251                  * the chunk we see is fully initialized.
 252                  */
 253                 if (READ_ONCE(p->key) == key) {
 254                         atomic_long_inc(&p->refs);
 255                         return p;
 256                 }
 257         }
 258         return NULL;
 259 }
 260
 261 bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
 262 {
 263         int n;
 264         for (n = 0; n < chunk->count; n++)
 265                 if (chunk->owners[n].owner == tree)
 266                         return true;
 267         return false;
 268 }
 269
 270 /* tagging and untagging inodes with trees */
 271
 272 static struct audit_chunk *find_chunk(struct audit_node *p)
 273 {
 274         int index = p->index & ~(1U<<31);
 275         p -= index;
 276         return container_of(p, struct audit_chunk, owners[0]);
 277 }
 278
 279 static void replace_mark_chunk(struct fsnotify_mark *mark,
 280                                struct audit_chunk *chunk)
 281 {
 282         struct audit_chunk *old;
 283
 284         assert_spin_locked(&hash_lock);
 285         old = mark_chunk(mark);
 286         audit_mark(mark)->chunk = chunk;
 287         if (chunk)
 288                 chunk->mark = mark;
 289         if (old)
 290                 old->mark = NULL;
 291 }
 292
 293 static void replace_chunk(struct audit_chunk *new, struct audit_chunk *old)
 294 {
 295         struct audit_tree *owner;
 296         int i, j;
 297
 298         new->key = old->key;
 299         list_splice_init(&old->trees, &new->trees);
 300         list_for_each_entry(owner, &new->trees, same_root)
 301                 owner->root = new;
 302         for (i = j = 0; j < old->count; i++, j++) {
 303                 if (!old->owners[j].owner) {
 304                         i--;
 305                         continue;
 306                 }
 307                 owner = old->owners[j].owner;
 308                 new->owners[i].owner = owner;
 309                 new->owners[i].index = old->owners[j].index - j + i;
 310                 if (!owner) /* result of earlier fallback */
 311                         continue;
 312                 get_tree(owner);
 313                 list_replace_init(&old->owners[j].list, &new->owners[i].list);
 314         }
 315         replace_mark_chunk(old->mark, new);
 316         /*
 317          * Make sure chunk is fully initialized before making it visible in the
 318          * hash. Pairs with a data dependency barrier in READ_ONCE() in
 319          * audit_tree_lookup().
 320          */
 321         smp_wmb();
 322         list_replace_rcu(&old->hash, &new->hash);
 323 }
 324
 325 static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p)
 326 {
 327         struct audit_tree *owner = p->owner;
 328
 329         if (owner->root == chunk) {
 330                 list_del_init(&owner->same_root);
 331                 owner->root = NULL;
 332         }
 333         list_del_init(&p->list);
 334         p->owner = NULL;
 335         put_tree(owner);
 336 }
 337
 338 static int chunk_count_trees(struct audit_chunk *chunk)
 339 {
 340         int i;
 341         int ret = 0;
 342
 343         for (i = 0; i < chunk->count; i++)
 344                 if (chunk->owners[i].owner)
 345                         ret++;
 346         return ret;
 347 }
 348
 349 static void untag_chunk(struct audit_chunk *chunk, struct fsnotify_mark *mark)
 350 {
 351         struct audit_chunk *new;
 352         int size;
 353
 354         fsnotify_group_lock(audit_tree_group);
 355         /*
 356          * mark_mutex stabilizes chunk attached to the mark so we can check
 357          * whether it didn't change while we've dropped hash_lock.
 358          */
 359         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) ||
 360             mark_chunk(mark) != chunk)
 361                 goto out_mutex;
 362
 363         size = chunk_count_trees(chunk);
 364         if (!size) {
 365                 spin_lock(&hash_lock);
 366                 list_del_init(&chunk->trees);
 367                 list_del_rcu(&chunk->hash);
 368                 replace_mark_chunk(mark, NULL);
 369                 spin_unlock(&hash_lock);
 370                 fsnotify_detach_mark(mark);
 371                 fsnotify_group_unlock(audit_tree_group);
 372                 audit_mark_put_chunk(chunk);
 373                 fsnotify_free_mark(mark);
 374                 return;
 375         }
 376
 377         new = alloc_chunk(size);
 378         if (!new)
 379                 goto out_mutex;
 380
 381         spin_lock(&hash_lock);
 382         /*
 383          * This has to go last when updating chunk as once replace_chunk() is
 384          * called, new RCU readers can see the new chunk.
 385          */
 386         replace_chunk(new, chunk);
 387         spin_unlock(&hash_lock);
 388         fsnotify_group_unlock(audit_tree_group);
 389         audit_mark_put_chunk(chunk);
 390         return;
 391
 392 out_mutex:
 393         fsnotify_group_unlock(audit_tree_group);
 394 }
 395
 396 /* Call with group->mark_mutex held, releases it */
 397 static int create_chunk(struct inode *inode, struct audit_tree *tree)
 398 {
 399         struct fsnotify_mark *mark;
 400         struct audit_chunk *chunk = alloc_chunk(1);
 401
 402         if (!chunk) {
 403                 fsnotify_group_unlock(audit_tree_group);
 404                 return -ENOMEM;
 405         }
 406
 407         mark = alloc_mark();
 408         if (!mark) {
 409                 fsnotify_group_unlock(audit_tree_group);
 410                 kfree(chunk);
 411                 return -ENOMEM;
 412         }
 413
 414         if (fsnotify_add_inode_mark_locked(mark, inode, 0)) {
 415                 fsnotify_group_unlock(audit_tree_group);
 416                 fsnotify_put_mark(mark);
 417                 kfree(chunk);
 418                 return -ENOSPC;
 419         }
 420
 421         spin_lock(&hash_lock);
 422         if (tree->goner) {
 423                 spin_unlock(&hash_lock);
 424                 fsnotify_detach_mark(mark);
 425                 fsnotify_group_unlock(audit_tree_group);
 426                 fsnotify_free_mark(mark);
 427                 fsnotify_put_mark(mark);
 428                 kfree(chunk);
 429                 return 0;
 430         }
 431         replace_mark_chunk(mark, chunk);
 432         chunk->owners[0].index = (1U << 31);
 433         chunk->owners[0].owner = tree;
 434         get_tree(tree);
 435         list_add(&chunk->owners[0].list, &tree->chunks);
 436         if (!tree->root) {
 437                 tree->root = chunk;
 438                 list_add(&tree->same_root, &chunk->trees);
 439         }
 440         chunk->key = inode_to_key(inode);
 441         /*
 442          * Inserting into the hash table has to go last as once we do that RCU
 443          * readers can see the chunk.
 444          */
 445         insert_hash(chunk);
 446         spin_unlock(&hash_lock);
 447         fsnotify_group_unlock(audit_tree_group);
 448         /*
 449          * Drop our initial reference. When mark we point to is getting freed,
 450          * we get notification through ->freeing_mark callback and cleanup
 451          * chunk pointing to this mark.
 452          */
 453         fsnotify_put_mark(mark);
 454         return 0;
 455 }
 456
 457 /* the first tagged inode becomes root of tree */
 458 static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 459 {
 460         struct fsnotify_mark *mark;
 461         struct audit_chunk *chunk, *old;
 462         struct audit_node *p;
 463         int n;
 464
 465         fsnotify_group_lock(audit_tree_group);
 466         mark = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_tree_group);
 467         if (!mark)
 468                 return create_chunk(inode, tree);
 469
 470         /*
 471          * Found mark is guaranteed to be attached and mark_mutex protects mark
 472          * from getting detached and thus it makes sure there is chunk attached
 473          * to the mark.
 474          */
 475         /* are we already there? */
 476         spin_lock(&hash_lock);
 477         old = mark_chunk(mark);
 478         for (n = 0; n < old->count; n++) {
 479                 if (old->owners[n].owner == tree) {
 480                         spin_unlock(&hash_lock);
 481                         fsnotify_group_unlock(audit_tree_group);
 482                         fsnotify_put_mark(mark);
 483                         return 0;
 484                 }
 485         }
 486         spin_unlock(&hash_lock);
 487
 488         chunk = alloc_chunk(old->count + 1);
 489         if (!chunk) {
 490                 fsnotify_group_unlock(audit_tree_group);
 491                 fsnotify_put_mark(mark);
 492                 return -ENOMEM;
 493         }
 494
 495         spin_lock(&hash_lock);
 496         if (tree->goner) {
 497                 spin_unlock(&hash_lock);
 498                 fsnotify_group_unlock(audit_tree_group);
 499                 fsnotify_put_mark(mark);
 500                 kfree(chunk);
 501                 return 0;
 502         }
 503         p = &chunk->owners[chunk->count - 1];
 504         p->index = (chunk->count - 1) | (1U<<31);
 505         p->owner = tree;
 506         get_tree(tree);
 507         list_add(&p->list, &tree->chunks);
 508         if (!tree->root) {
 509                 tree->root = chunk;
 510                 list_add(&tree->same_root, &chunk->trees);
 511         }
 512         /*
 513          * This has to go last when updating chunk as once replace_chunk() is
 514          * called, new RCU readers can see the new chunk.
 515          */
 516         replace_chunk(chunk, old);
 517         spin_unlock(&hash_lock);
 518         fsnotify_group_unlock(audit_tree_group);
 519         fsnotify_put_mark(mark); /* pair to fsnotify_find_mark */
 520         audit_mark_put_chunk(old);
 521
 522         return 0;
 523 }
 524
 525 static void audit_tree_log_remove_rule(struct audit_context *context,
 526                                        struct audit_krule *rule)
 527 {
 528         struct audit_buffer *ab;
 529
 530         if (!audit_enabled)
 531                 return;
 532         ab = audit_log_start(context, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
 533         if (unlikely(!ab))
 534                 return;
 535         audit_log_format(ab, "op=remove_rule dir=");
 536         audit_log_untrustedstring(ab, rule->tree->pathname);
 537         audit_log_key(ab, rule->filterkey);
 538         audit_log_format(ab, " list=%d res=1", rule->listnr);
 539         audit_log_end(ab);
 540 }
 541
 542 static void kill_rules(struct audit_context *context, struct audit_tree *tree)
 543 {
 544         struct audit_krule *rule, *next;
 545         struct audit_entry *entry;
 546
 547         list_for_each_entry_safe(rule, next, &tree->rules, rlist) {
 548                 entry = container_of(rule, struct audit_entry, rule);
 549
 550                 list_del_init(&rule->rlist);
 551                 if (rule->tree) {
 552                         /* not a half-baked one */
 553                         audit_tree_log_remove_rule(context, rule);
 554                         if (entry->rule.exe)
 555                                 audit_remove_mark(entry->rule.exe);
 556                         rule->tree = NULL;
 557                         list_del_rcu(&entry->list);
 558                         list_del(&entry->rule.list);
 559                         call_rcu(&entry->rcu, audit_free_rule_rcu);
 560                 }
 561         }
 562 }
 563
 564 /*
 565  * Remove tree from chunks. If 'tagged' is set, remove tree only from tagged
 566  * chunks. The function expects tagged chunks are all at the beginning of the
 567  * chunks list.
 568  */
 569 static void prune_tree_chunks(struct audit_tree *victim, bool tagged)
 570 {
 571         spin_lock(&hash_lock);
 572         while (!list_empty(&victim->chunks)) {
 573                 struct audit_node *p;
 574                 struct audit_chunk *chunk;
 575                 struct fsnotify_mark *mark;
 576
 577                 p = list_first_entry(&victim->chunks, struct audit_node, list);
 578                 /* have we run out of marked? */
 579                 if (tagged && !(p->index & (1U<<31)))
 580                         break;
 581                 chunk = find_chunk(p);
 582                 mark = chunk->mark;
 583                 remove_chunk_node(chunk, p);
 584                 /* Racing with audit_tree_freeing_mark()? */
 585                 if (!mark)
 586                         continue;
 587                 fsnotify_get_mark(mark);
 588                 spin_unlock(&hash_lock);
 589
 590                 untag_chunk(chunk, mark);
 591                 fsnotify_put_mark(mark);
 592
 593                 spin_lock(&hash_lock);
 594         }
 595         spin_unlock(&hash_lock);
 596 }
 597
 598 /*
 599  * finish killing struct audit_tree
 600  */
 601 static void prune_one(struct audit_tree *victim)
 602 {
 603         prune_tree_chunks(victim, false);
 604         put_tree(victim);
 605 }
 606
 607 /* trim the uncommitted chunks from tree */
 608
 609 static void trim_marked(struct audit_tree *tree)
 610 {
 611         struct list_head *p, *q;
 612         spin_lock(&hash_lock);
 613         if (tree->goner) {
 614                 spin_unlock(&hash_lock);
 615                 return;
 616         }
 617         /* reorder */
 618         for (p = tree->chunks.next; p != &tree->chunks; p = q) {
 619                 struct audit_node *node = list_entry(p, struct audit_node, list);
 620                 q = p->next;
 621                 if (node->index & (1U<<31)) {
 622                         list_del_init(p);
 623                         list_add(p, &tree->chunks);
 624                 }
 625         }
 626         spin_unlock(&hash_lock);
 627
 628         prune_tree_chunks(tree, true);
 629
 630         spin_lock(&hash_lock);
 631         if (!tree->root && !tree->goner) {
 632                 tree->goner = 1;
 633                 spin_unlock(&hash_lock);
 634                 mutex_lock(&audit_filter_mutex);
 635                 kill_rules(audit_context(), tree);
 636                 list_del_init(&tree->list);
 637                 mutex_unlock(&audit_filter_mutex);
 638                 prune_one(tree);
 639         } else {
 640                 spin_unlock(&hash_lock);
 641         }
 642 }
 643
 644 static void audit_schedule_prune(void);
 645
 646 /* called with audit_filter_mutex */
 647 int audit_remove_tree_rule(struct audit_krule *rule)
 648 {
 649         struct audit_tree *tree;
 650         tree = rule->tree;
 651         if (tree) {
 652                 spin_lock(&hash_lock);
 653                 list_del_init(&rule->rlist);
 654                 if (list_empty(&tree->rules) && !tree->goner) {
 655                         tree->root = NULL;
 656                         list_del_init(&tree->same_root);
 657                         tree->goner = 1;
 658                         list_move(&tree->list, &prune_list);
 659                         rule->tree = NULL;
 660                         spin_unlock(&hash_lock);
 661                         audit_schedule_prune();
 662                         return 1;
 663                 }
 664                 rule->tree = NULL;
 665                 spin_unlock(&hash_lock);
 666                 return 1;
 667         }
 668         return 0;
 669 }
 670
 671 static int compare_root(struct vfsmount *mnt, void *arg)
 672 {
 673         return inode_to_key(d_backing_inode(mnt->mnt_root)) ==
 674                (unsigned long)arg;
 675 }
 676
 677 void audit_trim_trees(void)
 678 {
 679         struct list_head cursor;
 680
 681         mutex_lock(&audit_filter_mutex);
 682         list_add(&cursor, &tree_list);
 683         while (cursor.next != &tree_list) {
 684                 struct audit_tree *tree;
 685                 struct path path;
 686                 struct vfsmount *root_mnt;
 687                 struct audit_node *node;
 688                 int err;
 689
 690                 tree = container_of(cursor.next, struct audit_tree, list);
 691                 get_tree(tree);
 692                 list_move(&cursor, &tree->list);
 693                 mutex_unlock(&audit_filter_mutex);
 694
 695                 err = kern_path(tree->pathname, 0, &path);
 696                 if (err)
 697                         goto skip_it;
 698
 699                 root_mnt = collect_mounts(&path);
 700                 path_put(&path);
 701                 if (IS_ERR(root_mnt))
 702                         goto skip_it;
 703
 704                 spin_lock(&hash_lock);
 705                 list_for_each_entry(node, &tree->chunks, list) {
 706                         struct audit_chunk *chunk = find_chunk(node);
 707                         /* this could be NULL if the watch is dying else where... */
 708                         node->index |= 1U<<31;
 709                         if (iterate_mounts(compare_root,
 710                                            (void *)(chunk->key),
 711                                            root_mnt))
 712                                 node->index &= ~(1U<<31);
 713                 }
 714                 spin_unlock(&hash_lock);
 715                 trim_marked(tree);
 716                 drop_collected_mounts(root_mnt);
 717 skip_it:
 718                 put_tree(tree);
 719                 mutex_lock(&audit_filter_mutex);
 720         }
 721         list_del(&cursor);
 722         mutex_unlock(&audit_filter_mutex);
 723 }
 724
 725 int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op)
 726 {
 727
 728         if (pathname[0] != '/' ||
 729             (rule->listnr != AUDIT_FILTER_EXIT &&
 730              rule->listnr != AUDIT_FILTER_URING_EXIT) ||
 731             op != Audit_equal ||
 732             rule->inode_f || rule->watch || rule->tree)
 733                 return -EINVAL;
 734         rule->tree = alloc_tree(pathname);
 735         if (!rule->tree)
 736                 return -ENOMEM;
 737         return 0;
 738 }
 739
 740 void audit_put_tree(struct audit_tree *tree)
 741 {
 742         put_tree(tree);
 743 }
 744
 745 static int tag_mount(struct vfsmount *mnt, void *arg)
 746 {
 747         return tag_chunk(d_backing_inode(mnt->mnt_root), arg);
 748 }
 749
 750 /*
 751  * That gets run when evict_chunk() ends up needing to kill audit_tree.
 752  * Runs from a separate thread.
 753  */
 754 static int prune_tree_thread(void *unused)
 755 {
 756         for (;;) {
 757                 if (list_empty(&prune_list)) {
 758                         set_current_state(TASK_INTERRUPTIBLE);
 759                         schedule();
 760                 }
 761
 762                 audit_ctl_lock();
 763                 mutex_lock(&audit_filter_mutex);
 764
 765                 while (!list_empty(&prune_list)) {
 766                         struct audit_tree *victim;
 767
 768                         victim = list_entry(prune_list.next,
 769                                         struct audit_tree, list);
 770                         list_del_init(&victim->list);
 771
 772                         mutex_unlock(&audit_filter_mutex);
 773
 774                         prune_one(victim);
 775
 776                         mutex_lock(&audit_filter_mutex);
 777                 }
 778
 779                 mutex_unlock(&audit_filter_mutex);
 780                 audit_ctl_unlock();
 781         }
 782         return 0;
 783 }
 784
 785 static int audit_launch_prune(void)
 786 {
 787         if (prune_thread)
 788                 return 0;
 789         prune_thread = kthread_run(prune_tree_thread, NULL,
 790                                 "audit_prune_tree");
 791         if (IS_ERR(prune_thread)) {
 792                 pr_err("cannot start thread audit_prune_tree");
 793                 prune_thread = NULL;
 794                 return -ENOMEM;
 795         }
 796         return 0;
 797 }
 798
 799 /* called with audit_filter_mutex */
 800 int audit_add_tree_rule(struct audit_krule *rule)
 801 {
 802         struct audit_tree *seed = rule->tree, *tree;
 803         struct path path;
 804         struct vfsmount *mnt;
 805         int err;
 806
 807         rule->tree = NULL;
 808         list_for_each_entry(tree, &tree_list, list) {
 809                 if (!strcmp(seed->pathname, tree->pathname)) {
 810                         put_tree(seed);
 811                         rule->tree = tree;
 812                         list_add(&rule->rlist, &tree->rules);
 813                         return 0;
 814                 }
 815         }
 816         tree = seed;
 817         list_add(&tree->list, &tree_list);
 818         list_add(&rule->rlist, &tree->rules);
 819         /* do not set rule->tree yet */
 820         mutex_unlock(&audit_filter_mutex);
 821
 822         if (unlikely(!prune_thread)) {
 823                 err = audit_launch_prune();
 824                 if (err)
 825                         goto Err;
 826         }
 827
 828         err = kern_path(tree->pathname, 0, &path);
 829         if (err)
 830                 goto Err;
 831         mnt = collect_mounts(&path);
 832         path_put(&path);
 833         if (IS_ERR(mnt)) {
 834                 err = PTR_ERR(mnt);
 835                 goto Err;
 836         }
 837
 838         get_tree(tree);
 839         err = iterate_mounts(tag_mount, tree, mnt);
 840         drop_collected_mounts(mnt);
 841
 842         if (!err) {
 843                 struct audit_node *node;
 844                 spin_lock(&hash_lock);
 845                 list_for_each_entry(node, &tree->chunks, list)
 846                         node->index &= ~(1U<<31);
 847                 spin_unlock(&hash_lock);
 848         } else {
 849                 trim_marked(tree);
 850                 goto Err;
 851         }
 852
 853         mutex_lock(&audit_filter_mutex);
 854         if (list_empty(&rule->rlist)) {
 855                 put_tree(tree);
 856                 return -ENOENT;
 857         }
 858         rule->tree = tree;
 859         put_tree(tree);
 860
 861         return 0;
 862 Err:
 863         mutex_lock(&audit_filter_mutex);
 864         list_del_init(&tree->list);
 865         list_del_init(&tree->rules);
 866         put_tree(tree);
 867         return err;
 868 }
 869
 870 int audit_tag_tree(char *old, char *new)
 871 {
 872         struct list_head cursor, barrier;
 873         int failed = 0;
 874         struct path path1, path2;
 875         struct vfsmount *tagged;
 876         int err;
 877
 878         err = kern_path(new, 0, &path2);
 879         if (err)
 880                 return err;
 881         tagged = collect_mounts(&path2);
 882         path_put(&path2);
 883         if (IS_ERR(tagged))
 884                 return PTR_ERR(tagged);
 885
 886         err = kern_path(old, 0, &path1);
 887         if (err) {
 888                 drop_collected_mounts(tagged);
 889                 return err;
 890         }
 891
 892         mutex_lock(&audit_filter_mutex);
 893         list_add(&barrier, &tree_list);
 894         list_add(&cursor, &barrier);
 895
 896         while (cursor.next != &tree_list) {
 897                 struct audit_tree *tree;
 898                 int good_one = 0;
 899
 900                 tree = container_of(cursor.next, struct audit_tree, list);
 901                 get_tree(tree);
 902                 list_move(&cursor, &tree->list);
 903                 mutex_unlock(&audit_filter_mutex);
 904
 905                 err = kern_path(tree->pathname, 0, &path2);
 906                 if (!err) {
 907                         good_one = path_is_under(&path1, &path2);
 908                         path_put(&path2);
 909                 }
 910
 911                 if (!good_one) {
 912                         put_tree(tree);
 913                         mutex_lock(&audit_filter_mutex);
 914                         continue;
 915                 }
 916
 917                 failed = iterate_mounts(tag_mount, tree, tagged);
 918                 if (failed) {
 919                         put_tree(tree);
 920                         mutex_lock(&audit_filter_mutex);
 921                         break;
 922                 }
 923
 924                 mutex_lock(&audit_filter_mutex);
 925                 spin_lock(&hash_lock);
 926                 if (!tree->goner) {
 927                         list_move(&tree->list, &tree_list);
 928                 }
 929                 spin_unlock(&hash_lock);
 930                 put_tree(tree);
 931         }
 932
 933         while (barrier.prev != &tree_list) {
 934                 struct audit_tree *tree;
 935
 936                 tree = container_of(barrier.prev, struct audit_tree, list);
 937                 get_tree(tree);
 938                 list_move(&tree->list, &barrier);
 939                 mutex_unlock(&audit_filter_mutex);
 940
 941                 if (!failed) {
 942                         struct audit_node *node;
 943                         spin_lock(&hash_lock);
 944                         list_for_each_entry(node, &tree->chunks, list)
 945                                 node->index &= ~(1U<<31);
 946                         spin_unlock(&hash_lock);
 947                 } else {
 948                         trim_marked(tree);
 949                 }
 950
 951                 put_tree(tree);
 952                 mutex_lock(&audit_filter_mutex);
 953         }
 954         list_del(&barrier);
 955         list_del(&cursor);
 956         mutex_unlock(&audit_filter_mutex);
 957         path_put(&path1);
 958         drop_collected_mounts(tagged);
 959         return failed;
 960 }
 961
 962
 963 static void audit_schedule_prune(void)
 964 {
 965         wake_up_process(prune_thread);
 966 }
 967
 968 /*
 969  * ... and that one is done if evict_chunk() decides to delay until the end
 970  * of syscall.  Runs synchronously.
 971  */
 972 void audit_kill_trees(struct audit_context *context)
 973 {
 974         struct list_head *list = &context->killed_trees;
 975
 976         audit_ctl_lock();
 977         mutex_lock(&audit_filter_mutex);
 978
 979         while (!list_empty(list)) {
 980                 struct audit_tree *victim;
 981
 982                 victim = list_entry(list->next, struct audit_tree, list);
 983                 kill_rules(context, victim);
 984                 list_del_init(&victim->list);
 985
 986                 mutex_unlock(&audit_filter_mutex);
 987
 988                 prune_one(victim);
 989
 990                 mutex_lock(&audit_filter_mutex);
 991         }
 992
 993         mutex_unlock(&audit_filter_mutex);
 994         audit_ctl_unlock();
 995 }
 996
 997 /*
 998  *  Here comes the stuff asynchronous to auditctl operations
 999  */
1000
1001 static void evict_chunk(struct audit_chunk *chunk)
1002 {
1003         struct audit_tree *owner;
1004         struct list_head *postponed = audit_killed_trees();
1005         int need_prune = 0;
1006         int n;
1007
1008         mutex_lock(&audit_filter_mutex);
1009         spin_lock(&hash_lock);
1010         while (!list_empty(&chunk->trees)) {
1011                 owner = list_entry(chunk->trees.next,
1012                                    struct audit_tree, same_root);
1013                 owner->goner = 1;
1014                 owner->root = NULL;
1015                 list_del_init(&owner->same_root);
1016                 spin_unlock(&hash_lock);
1017                 if (!postponed) {
1018                         kill_rules(audit_context(), owner);
1019                         list_move(&owner->list, &prune_list);
1020                         need_prune = 1;
1021                 } else {
1022                         list_move(&owner->list, postponed);
1023                 }
1024                 spin_lock(&hash_lock);
1025         }
1026         list_del_rcu(&chunk->hash);
1027         for (n = 0; n < chunk->count; n++)
1028                 list_del_init(&chunk->owners[n].list);
1029         spin_unlock(&hash_lock);
1030         mutex_unlock(&audit_filter_mutex);
1031         if (need_prune)
1032                 audit_schedule_prune();
1033 }
1034
1035 static int audit_tree_handle_event(struct fsnotify_mark *mark, u32 mask,
1036                                    struct inode *inode, struct inode *dir,
1037                                    const struct qstr *file_name, u32 cookie)
1038 {
1039         return 0;
1040 }
1041
1042 static void audit_tree_freeing_mark(struct fsnotify_mark *mark,
1043                                     struct fsnotify_group *group)
1044 {
1045         struct audit_chunk *chunk;
1046
1047         fsnotify_group_lock(mark->group);
1048         spin_lock(&hash_lock);
1049         chunk = mark_chunk(mark);
1050         replace_mark_chunk(mark, NULL);
1051         spin_unlock(&hash_lock);
1052         fsnotify_group_unlock(mark->group);
1053         if (chunk) {
1054                 evict_chunk(chunk);
1055                 audit_mark_put_chunk(chunk);
1056         }
1057
1058         /*
1059          * We are guaranteed to have at least one reference to the mark from
1060          * either the inode or the caller of fsnotify_destroy_mark().
1061          */
1062         BUG_ON(refcount_read(&mark->refcnt) < 1);
1063 }
1064
1065 static const struct fsnotify_ops audit_tree_ops = {
1066         .handle_inode_event = audit_tree_handle_event,
1067         .freeing_mark = audit_tree_freeing_mark,
1068         .free_mark = audit_tree_destroy_watch,
1069 };
1070
1071 static int __init audit_tree_init(void)
1072 {
1073         int i;
1074
1075         audit_tree_mark_cachep = KMEM_CACHE(audit_tree_mark, SLAB_PANIC);
1076
1077         audit_tree_group = fsnotify_alloc_group(&audit_tree_ops, 0);
1078         if (IS_ERR(audit_tree_group))
1079                 audit_panic("cannot initialize fsnotify group for rectree watches");
1080
1081         for (i = 0; i < HASH_SIZE; i++)
1082                 INIT_LIST_HEAD(&chunk_hash_heads[i]);
1083
1084         return 0;
1085 }
1086 __initcall(audit_tree_init);