pstore/ram_core: Remove now unused code

[firefly-linux-kernel-4.4.55.git] / fs / pstore / ram_core.c

diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c
index 31f8d184f3a0a659cd53a5002c2c013bb13e76a0..0fd81611525ca4de442515dd5202b0372af65947 100644 (file)
--- a/fs/pstore/ram_core.c
+++ b/fs/pstore/ram_core.c
@@ -35,8 +35,6 @@ struct persistent_ram_buffer {
 
 #define PERSISTENT_RAM_SIG (0x43474244) /* DBGC */
 
-static __initdata LIST_HEAD(persistent_ram_list);
-
 static inline size_t buffer_size(struct persistent_ram_zone *prz)
 {
        return atomic_read(&prz->buffer->size);
@@ -250,23 +248,24 @@ static void notrace persistent_ram_update(struct persistent_ram_zone *prz,
        persistent_ram_update_ecc(prz, start, count);
 }
 
-static void __init
-persistent_ram_save_old(struct persistent_ram_zone *prz)
+void persistent_ram_save_old(struct persistent_ram_zone *prz)
 {
        struct persistent_ram_buffer *buffer = prz->buffer;
        size_t size = buffer_size(prz);
        size_t start = buffer_start(prz);
-       char *dest;
 
-       persistent_ram_ecc_old(prz);
+       if (!size)
+               return;
 
-       dest = kmalloc(size, GFP_KERNEL);
-       if (dest == NULL) {
+       if (!prz->old_log) {
+               persistent_ram_ecc_old(prz);
+               prz->old_log = kmalloc(size, GFP_KERNEL);
+       }
+       if (!prz->old_log) {
                pr_err("persistent_ram: failed to allocate buffer\n");
                return;
        }
 
-       prz->old_log = dest;
        prz->old_log_size = size;
        memcpy(prz->old_log, &buffer->data[start], size - start);
        memcpy(prz->old_log + size - start, &buffer->data[0], start);
@@ -319,6 +318,13 @@ void persistent_ram_free_old(struct persistent_ram_zone *prz)
        prz->old_log_size = 0;
 }
 
+void persistent_ram_zap(struct persistent_ram_zone *prz)
+{
+       atomic_set(&prz->buffer->start, 0);
+       atomic_set(&prz->buffer->size, 0);
+       persistent_ram_update_header_ecc(prz);
+}
+
 static void *persistent_ram_vmap(phys_addr_t start, size_t size)
 {
        struct page **pages;
@@ -401,19 +407,19 @@ static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool
                                " size %zu, start %zu\n",
                               buffer_size(prz), buffer_start(prz));
                else {
-                       pr_info("persistent_ram: found existing buffer,"
+                       pr_debug("persistent_ram: found existing buffer,"
                                " size %zu, start %zu\n",
                               buffer_size(prz), buffer_start(prz));
                        persistent_ram_save_old(prz);
+                       return 0;
                }
        } else {
-               pr_info("persistent_ram: no valid data in buffer"
+               pr_debug("persistent_ram: no valid data in buffer"
                        " (sig = 0x%08x)\n", prz->buffer->sig);
        }
 
        prz->buffer->sig = PERSISTENT_RAM_SIG;
-       atomic_set(&prz->buffer->start, 0);
-       atomic_set(&prz->buffer->size, 0);
+       persistent_ram_zap(prz);
 
        return 0;
 }
@@ -448,85 +454,9 @@ struct persistent_ram_zone * __init persistent_ram_new(phys_addr_t start,
                goto err;
 
        persistent_ram_post_init(prz, ecc);
-       persistent_ram_update_header_ecc(prz);
 
        return prz;
 err:
        kfree(prz);
        return ERR_PTR(ret);
 }
-
-#ifndef MODULE
-static int __init persistent_ram_buffer_init(const char *name,
-               struct persistent_ram_zone *prz)
-{
-       int i;
-       struct persistent_ram *ram;
-       struct persistent_ram_descriptor *desc;
-       phys_addr_t start;
-
-       list_for_each_entry(ram, &persistent_ram_list, node) {
-               start = ram->start;
-               for (i = 0; i < ram->num_descs; i++) {
-                       desc = &ram->descs[i];
-                       if (!strcmp(desc->name, name))
-                               return persistent_ram_buffer_map(start,
-                                               desc->size, prz);
-                       start += desc->size;
-               }
-       }
-
-       return -EINVAL;
-}
-
-static  __init
-struct persistent_ram_zone *__persistent_ram_init(struct device *dev, bool ecc)
-{
-       struct persistent_ram_zone *prz;
-       int ret = -ENOMEM;
-
-       prz = kzalloc(sizeof(struct persistent_ram_zone), GFP_KERNEL);
-       if (!prz) {
-               pr_err("persistent_ram: failed to allocate persistent ram zone\n");
-               goto err;
-       }
-
-       ret = persistent_ram_buffer_init(dev_name(dev), prz);
-       if (ret) {
-               pr_err("persistent_ram: failed to initialize buffer\n");
-               goto err;
-       }
-
-       persistent_ram_post_init(prz, ecc);
-
-       return prz;
-err:
-       kfree(prz);
-       return ERR_PTR(ret);
-}
-
-struct persistent_ram_zone * __init
-persistent_ram_init_ringbuffer(struct device *dev, bool ecc)
-{
-       return __persistent_ram_init(dev, ecc);
-}
-
-int __init persistent_ram_early_init(struct persistent_ram *ram)
-{
-       int ret;
-
-       ret = memblock_reserve(ram->start, ram->size);
-       if (ret) {
-               pr_err("Failed to reserve persistent memory from %08lx-%08lx\n",
-                       (long)ram->start, (long)(ram->start + ram->size - 1));
-               return ret;
-       }
-
-       list_add_tail(&ram->node, &persistent_ram_list);
-
-       pr_info("Initialized persistent memory from %08lx-%08lx\n",
-               (long)ram->start, (long)(ram->start + ram->size - 1));
-
-       return 0;
-}
-#endif