[PATCH] dcache: fix indirectly reclaimable memory accounting for CONFIG_SLOB

[Roman Gushchin]

Indirectly reclaimable memory accounting uses
kmalloc_size()/kmalloc_index() functions to estimate
amount of consumed memory. kmalloc_size() always returns 0
and kmalloc_index() is not defined for CONFIG_SLOB,
and so it breaks the build.

Fix this by using ksize() function instead.

Slub:
$ cat /proc/meminfo | grep Avail
MemAvailable:    7857112 kB
$ python indirect.py
$ cat /proc/meminfo | grep Avail
MemAvailable:    7781312 kB

Slob:
$ cat /proc/meminfo | grep Avail
MemAvailable:    7853272 kB
$ python indirect.py
$ cat /proc/meminfo | grep Avail
MemAvailable:    7616644 kB

indirect.py:
  import os

  for iter in range (0, 1000000):
      try:
          name = ("/some_long_name_%d" % iter) + "_" * 220
          os.stat(name)
      except Exception:
          pass

Signed-off-by: Roman Gushchin <g...@fb.com>
Cc: Andrew Morton <a...@linux-foundation.org>
Cc: Alexander Viro <v...@zeniv.linux.org.uk>
Cc: Michal Hocko <mho...@suse.com>
Cc: Johannes Weiner <han...@cmpxchg.org>
Cc: Tony Lindgren <t...@atomide.com>
Cc: linux-fsde...@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux...@kvack.org
Cc: kernel-t...@fb.com
---
 fs/dcache.c | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/fs/dcache.c b/fs/dcache.c
index 135297a2d40e..98826efe22a0 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -270,12 +270,10 @@ static void __d_free_external(struct rcu_head *head)
 {
        struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
        struct external_name *name = external_name(dentry);
-       unsigned long bytes;
 
-       bytes = dentry->d_name.len + offsetof(struct external_name, name[1]);
        mod_node_page_state(page_pgdat(virt_to_page(name)),
                            NR_INDIRECTLY_RECLAIMABLE_BYTES,
-                           -kmalloc_size(kmalloc_index(bytes)));
+                           -ksize(name));
 
        kfree(name);
        kmem_cache_free(dentry_cache, dentry);
@@ -1607,10 +1605,10 @@ 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;
-       size_t reclaimable = 0;
 
        dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
        if (!dentry)
@@ -1627,17 +1625,15 @@ struct dentry *__d_alloc(struct super_block *sb, const 
struct qstr *name)
                name = &slash_name;
                dname = dentry->d_iname;
        } else if (name->len > DNAME_INLINE_LEN-1) {
-               struct external_name *p;
+               size_t size = offsetof(struct external_name, name[1]);
 
-               reclaimable = offsetof(struct external_name, name[1]) +
-                       name->len;
-               p = kmalloc(reclaimable, 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;
        }       
@@ -1676,12 +1672,10 @@ struct dentry *__d_alloc(struct super_block *sb, const 
struct qstr *name)
                }
        }
 
-       if (unlikely(reclaimable)) {
-               pg_data_t *pgdat;
-
-               pgdat = page_pgdat(virt_to_page(external_name(dentry)));
+       if (unlikely(ext)) {
+               pg_data_t *pgdat = page_pgdat(virt_to_page(ext));
                mod_node_page_state(pgdat, NR_INDIRECTLY_RECLAIMABLE_BYTES,
-                                   kmalloc_size(kmalloc_index(reclaimable)));
+                                   ksize(ext));
        }
 
        this_cpu_inc(nr_dentry);
-- 
2.14.3