int count;
        atomic_long_t refs;
        struct rcu_head head;
-       struct node {
+       struct audit_node {
                struct list_head list;
                struct audit_tree *owner;
                unsigned index;         /* index; upper bit indicates 'will prune' */
 
 /* tagging and untagging inodes with trees */
 
-static struct audit_chunk *find_chunk(struct node *p)
+static struct audit_chunk *find_chunk(struct audit_node *p)
 {
        int index = p->index & ~(1U<<31);
        p -= index;
        list_replace_rcu(&old->hash, &new->hash);
 }
 
-static void remove_chunk_node(struct audit_chunk *chunk, struct node *p)
+static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p)
 {
        struct audit_tree *owner = p->owner;
 
 {
        struct fsnotify_mark *mark;
        struct audit_chunk *chunk, *old;
-       struct node *p;
+       struct audit_node *p;
        int n;
 
        mutex_lock(&audit_tree_group->mark_mutex);
 {
        spin_lock(&hash_lock);
        while (!list_empty(&victim->chunks)) {
-               struct node *p;
+               struct audit_node *p;
                struct audit_chunk *chunk;
                struct fsnotify_mark *mark;
 
-               p = list_first_entry(&victim->chunks, struct node, list);
+               p = list_first_entry(&victim->chunks, struct audit_node, list);
                /* have we run out of marked? */
                if (tagged && !(p->index & (1U<<31)))
                        break;
        }
        /* reorder */
        for (p = tree->chunks.next; p != &tree->chunks; p = q) {
-               struct node *node = list_entry(p, struct node, list);
+               struct audit_node *node = list_entry(p, struct audit_node, list);
                q = p->next;
                if (node->index & (1U<<31)) {
                        list_del_init(p);
                struct audit_tree *tree;
                struct path path;
                struct vfsmount *root_mnt;
-               struct node *node;
+               struct audit_node *node;
                int err;
 
                tree = container_of(cursor.next, struct audit_tree, list);
        drop_collected_mounts(mnt);
 
        if (!err) {
-               struct node *node;
+               struct audit_node *node;
                spin_lock(&hash_lock);
                list_for_each_entry(node, &tree->chunks, list)
                        node->index &= ~(1U<<31);
                mutex_unlock(&audit_filter_mutex);
 
                if (!failed) {
-                       struct node *node;
+                       struct audit_node *node;
                        spin_lock(&hash_lock);
                        list_for_each_entry(node, &tree->chunks, list)
                                node->index &= ~(1U<<31);