Merge tag 'pm-4.17-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

[linux-2.6-microblaze.git] / fs / dcache.c

diff --git a/fs/dcache.c b/fs/dcache.c
index 5930791..2acfc69 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -257,11 +257,25 @@ static void __d_free(struct rcu_head *head)
        kmem_cache_free(dentry_cache, dentry); 
 }
 
+static void __d_free_external_name(struct rcu_head *head)
+{
+       struct external_name *name = container_of(head, struct external_name,
+                                                 u.head);
+
+       mod_node_page_state(page_pgdat(virt_to_page(name)),
+                           NR_INDIRECTLY_RECLAIMABLE_BYTES,
+                           -ksize(name));
+
+       kfree(name);
+}
+
 static void __d_free_external(struct rcu_head *head)
 {
        struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
-       kfree(external_name(dentry));
-       kmem_cache_free(dentry_cache, dentry); 
+
+       __d_free_external_name(&external_name(dentry)->u.head);
+
+       kmem_cache_free(dentry_cache, dentry);
 }
 
 static inline int dname_external(const struct dentry *dentry)
@@ -291,7 +305,7 @@ void release_dentry_name_snapshot(struct name_snapshot *name)
                struct external_name *p;
                p = container_of(name->name, struct external_name, name[0]);
                if (unlikely(atomic_dec_and_test(&p->u.count)))
-                       kfree_rcu(p, u.head);
+                       call_rcu(&p->u.head, __d_free_external_name);
        }
 }
 EXPORT_SYMBOL(release_dentry_name_snapshot);
@@ -1038,6 +1052,8 @@ static void shrink_dentry_list(struct list_head *list)
        while (!list_empty(list)) {
                struct dentry *dentry, *parent;
 
+               cond_resched();
+
                dentry = list_entry(list->prev, struct dentry, d_lru);
                spin_lock(&dentry->d_lock);
                rcu_read_lock();
@@ -1191,7 +1207,6 @@ void shrink_dcache_sb(struct super_block *sb)
 
                this_cpu_sub(nr_dentry_unused, freed);
                shrink_dentry_list(&dispose);
-               cond_resched();
        } while (list_lru_count(&sb->s_dentry_lru) > 0);
 }
 EXPORT_SYMBOL(shrink_dcache_sb);
@@ -1473,7 +1488,6 @@ void shrink_dcache_parent(struct dentry *parent)
                        break;
 
                shrink_dentry_list(&data.dispose);
-               cond_resched();
        }
 }
 EXPORT_SYMBOL(shrink_dcache_parent);
@@ -1600,7 +1614,6 @@ void d_invalidate(struct dentry *dentry)
                        detach_mounts(data.mountpoint);
                        dput(data.mountpoint);
                }
-               cond_resched();
        }
 }
 EXPORT_SYMBOL(d_invalidate);
@@ -1617,6 +1630,7 @@ EXPORT_SYMBOL(d_invalidate);
  
 struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 {
+       struct external_name *ext = NULL;
        struct dentry *dentry;
        char *dname;
        int err;
@@ -1637,14 +1651,14 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
                dname = dentry->d_iname;
        } else if (name->len > DNAME_INLINE_LEN-1) {
                size_t size = offsetof(struct external_name, name[1]);
-               struct external_name *p = kmalloc(size + name->len,
-                                                 GFP_KERNEL_ACCOUNT);
-               if (!p) {
+
+               ext = kmalloc(size + name->len, GFP_KERNEL_ACCOUNT);
+               if (!ext) {
                        kmem_cache_free(dentry_cache, dentry); 
                        return NULL;
                }
-               atomic_set(&p->u.count, 1);
-               dname = p->name;
+               atomic_set(&ext->u.count, 1);
+               dname = ext->name;
        } else  {
                dname = dentry->d_iname;
        }       
@@ -1683,6 +1697,12 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
                }
        }
 
+       if (unlikely(ext)) {
+               pg_data_t *pgdat = page_pgdat(virt_to_page(ext));
+               mod_node_page_state(pgdat, NR_INDIRECTLY_RECLAIMABLE_BYTES,
+                                   ksize(ext));
+       }
+
        this_cpu_inc(nr_dentry);
 
        return dentry;
@@ -1879,6 +1899,28 @@ void d_instantiate(struct dentry *entry, struct inode * inode)
 }
 EXPORT_SYMBOL(d_instantiate);
 
+/*
+ * This should be equivalent to d_instantiate() + unlock_new_inode(),
+ * with lockdep-related part of unlock_new_inode() done before
+ * anything else.  Use that instead of open-coding d_instantiate()/
+ * unlock_new_inode() combinations.
+ */
+void d_instantiate_new(struct dentry *entry, struct inode *inode)
+{
+       BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
+       BUG_ON(!inode);
+       lockdep_annotate_inode_mutex_key(inode);
+       security_d_instantiate(entry, inode);
+       spin_lock(&inode->i_lock);
+       __d_instantiate(entry, inode);
+       WARN_ON(!(inode->i_state & I_NEW));
+       inode->i_state &= ~I_NEW;
+       smp_mb();
+       wake_up_bit(&inode->i_state, __I_NEW);
+       spin_unlock(&inode->i_lock);
+}
+EXPORT_SYMBOL(d_instantiate_new);
+
 /**
  * d_instantiate_no_diralias - instantiate a non-aliased dentry
  * @entry: dentry to complete
@@ -2770,7 +2812,7 @@ static void copy_name(struct dentry *dentry, struct dentry *target)
                dentry->d_name.hash_len = target->d_name.hash_len;
        }
        if (old_name && likely(atomic_dec_and_test(&old_name->u.count)))
-               kfree_rcu(old_name, u.head);
+               call_rcu(&old_name->u.head, __d_free_external_name);
 }
 
 /*