PM: Use a more common logging style

Convert printks to pr_<level>.

Miscellanea:

o Use pr_fmt with "PM:" and remove "PM: " from format strings
o Coalesce format strings and realign format arguments
o Convert an embedded incorrect function name to "%s: ", __func__
o Convert a couple multi-line formats to multiple pr_<level> calls

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

diff --git a/kernel/power/qos.c b/kernel/power/qos.c
index 97b0df71303ef7bbecf28d1479c3e198885b6199..9d7503910ce220302c29a9ea4f3ba0e2fab8ef26 100644 (file)
--- a/kernel/power/qos.c
+++ b/kernel/power/qos.c
@@ -701,8 +701,8 @@ static int __init pm_qos_power_init(void)
        for (i = PM_QOS_CPU_DMA_LATENCY; i < PM_QOS_NUM_CLASSES; i++) {
                ret = register_pm_qos_misc(pm_qos_array[i], d);
                if (ret < 0) {
-                       printk(KERN_ERR "pm_qos_param: %s setup failed\n",
-                              pm_qos_array[i]->name);
+                       pr_err("%s: %s setup failed\n",
+                              __func__, pm_qos_array[i]->name);
                        return ret;
                }
        }

diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 0972a8e09d082d99c7f197cbe6bd4fdb6475ba33..a917a301e201a38148d6aef8970af088c082e718 100644 (file)
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -10,6 +10,8 @@
  *
  */
 
+#define pr_fmt(fmt) "PM: " fmt
+
 #include <linux/version.h>
 #include <linux/module.h>
 #include <linux/mm.h>
@@ -967,7 +969,7 @@ void __init __register_nosave_region(unsigned long start_pfn,
        region->end_pfn = end_pfn;
        list_add_tail(&region->list, &nosave_regions);
  Report:
-       printk(KERN_INFO "PM: Registered nosave memory: [mem %#010llx-%#010llx]\n",
+       pr_info("Registered nosave memory: [mem %#010llx-%#010llx]\n",
                (unsigned long long) start_pfn << PAGE_SHIFT,
                ((unsigned long long) end_pfn << PAGE_SHIFT) - 1);
 }
@@ -1039,7 +1041,7 @@ static void mark_nosave_pages(struct memory_bitmap *bm)
        list_for_each_entry(region, &nosave_regions, list) {
                unsigned long pfn;
 
-               pr_debug("PM: Marking nosave pages: [mem %#010llx-%#010llx]\n",
+               pr_debug("Marking nosave pages: [mem %#010llx-%#010llx]\n",
                         (unsigned long long) region->start_pfn << PAGE_SHIFT,
                         ((unsigned long long) region->end_pfn << PAGE_SHIFT)
                                - 1);
@@ -1095,7 +1097,7 @@ int create_basic_memory_bitmaps(void)
        free_pages_map = bm2;
        mark_nosave_pages(forbidden_pages_map);
 
-       pr_debug("PM: Basic memory bitmaps created\n");
+       pr_debug("Basic memory bitmaps created\n");
 
        return 0;
 
@@ -1131,7 +1133,7 @@ void free_basic_memory_bitmaps(void)
        memory_bm_free(bm2, PG_UNSAFE_CLEAR);
        kfree(bm2);
 
-       pr_debug("PM: Basic memory bitmaps freed\n");
+       pr_debug("Basic memory bitmaps freed\n");
 }
 
 void clear_free_pages(void)
@@ -1152,7 +1154,7 @@ void clear_free_pages(void)
                pfn = memory_bm_next_pfn(bm);
        }
        memory_bm_position_reset(bm);
-       pr_info("PM: free pages cleared after restore\n");
+       pr_info("free pages cleared after restore\n");
 #endif /* PAGE_POISONING_ZERO */
 }
 
@@ -1690,7 +1692,7 @@ int hibernate_preallocate_memory(void)
        ktime_t start, stop;
        int error;
 
-       printk(KERN_INFO "PM: Preallocating image memory... ");
+       pr_info("Preallocating image memory... ");
        start = ktime_get();
 
        error = memory_bm_create(&orig_bm, GFP_IMAGE, PG_ANY);
@@ -1821,13 +1823,13 @@ int hibernate_preallocate_memory(void)
 
  out:
        stop = ktime_get();
-       printk(KERN_CONT "done (allocated %lu pages)\n", pages);
+       pr_cont("done (allocated %lu pages)\n", pages);
        swsusp_show_speed(start, stop, pages, "Allocated");
 
        return 0;
 
  err_out:
-       printk(KERN_CONT "\n");
+       pr_cont("\n");
        swsusp_free();
        return -ENOMEM;
 }
@@ -1867,8 +1869,8 @@ static int enough_free_mem(unsigned int nr_pages, unsigned int nr_highmem)
                        free += zone_page_state(zone, NR_FREE_PAGES);
 
        nr_pages += count_pages_for_highmem(nr_highmem);
-       pr_debug("PM: Normal pages needed: %u + %u, available pages: %u\n",
-               nr_pages, PAGES_FOR_IO, free);
+       pr_debug("Normal pages needed: %u + %u, available pages: %u\n",
+                nr_pages, PAGES_FOR_IO, free);
 
        return free > nr_pages + PAGES_FOR_IO;
 }
@@ -1961,20 +1963,20 @@ asmlinkage __visible int swsusp_save(void)
 {
        unsigned int nr_pages, nr_highmem;
 
-       printk(KERN_INFO "PM: Creating hibernation image:\n");
+       pr_info("Creating hibernation image:\n");
 
        drain_local_pages(NULL);
        nr_pages = count_data_pages();
        nr_highmem = count_highmem_pages();
-       printk(KERN_INFO "PM: Need to copy %u pages\n", nr_pages + nr_highmem);
+       pr_info("Need to copy %u pages\n", nr_pages + nr_highmem);
 
        if (!enough_free_mem(nr_pages, nr_highmem)) {
-               printk(KERN_ERR "PM: Not enough free memory\n");
+               pr_err("Not enough free memory\n");
                return -ENOMEM;
        }
 
        if (swsusp_alloc(&copy_bm, nr_pages, nr_highmem)) {
-               printk(KERN_ERR "PM: Memory allocation failed\n");
+               pr_err("Memory allocation failed\n");
                return -ENOMEM;
        }
 
@@ -1995,8 +1997,7 @@ asmlinkage __visible int swsusp_save(void)
        nr_copy_pages = nr_pages;
        nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
 
-       printk(KERN_INFO "PM: Hibernation image created (%d pages copied)\n",
-               nr_pages);
+       pr_info("Hibernation image created (%d pages copied)\n", nr_pages);
 
        return 0;
 }
@@ -2170,7 +2171,7 @@ static int check_header(struct swsusp_info *info)
        if (!reason && info->num_physpages != get_num_physpages())
                reason = "memory size";
        if (reason) {
-               printk(KERN_ERR "PM: Image mismatch: %s\n", reason);
+               pr_err("Image mismatch: %s\n", reason);
                return -EPERM;
        }
        return 0;

diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index d7cdc426ee3809bbaafdfd9d5698f83db654e23a..293ead59ecccbab5c3013be15d5f4cbfbef2315f 100644 (file)
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -12,6 +12,8 @@
  *
  */
 
+#define pr_fmt(fmt) "PM: " fmt
+
 #include <linux/module.h>
 #include <linux/file.h>
 #include <linux/delay.h>
@@ -241,9 +243,9 @@ static void hib_end_io(struct bio *bio)
        struct page *page = bio->bi_io_vec[0].bv_page;
 
        if (bio->bi_status) {
-               printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
-                               MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)),
-                               (unsigned long long)bio->bi_iter.bi_sector);
+               pr_alert("Read-error on swap-device (%u:%u:%Lu)\n",
+                        MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)),
+                        (unsigned long long)bio->bi_iter.bi_sector);
        }
 
        if (bio_data_dir(bio) == WRITE)
@@ -273,8 +275,8 @@ static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr,
        bio_set_op_attrs(bio, op, op_flags);
 
        if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
-               printk(KERN_ERR "PM: Adding page to bio failed at %llu\n",
-                       (unsigned long long)bio->bi_iter.bi_sector);
+               pr_err("Adding page to bio failed at %llu\n",
+                      (unsigned long long)bio->bi_iter.bi_sector);
                bio_put(bio);
                return -EFAULT;
        }
@@ -319,7 +321,7 @@ static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
                error = hib_submit_io(REQ_OP_WRITE, REQ_SYNC,
                                      swsusp_resume_block, swsusp_header, NULL);
        } else {
-               printk(KERN_ERR "PM: Swap header not found!\n");
+               pr_err("Swap header not found!\n");
                error = -ENODEV;
        }
        return error;
@@ -413,8 +415,7 @@ static int get_swap_writer(struct swap_map_handle *handle)
        ret = swsusp_swap_check();
        if (ret) {
                if (ret != -ENOSPC)
-                       printk(KERN_ERR "PM: Cannot find swap device, try "
-                                       "swapon -a.\n");
+                       pr_err("Cannot find swap device, try swapon -a\n");
                return ret;
        }
        handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
@@ -491,9 +492,9 @@ static int swap_writer_finish(struct swap_map_handle *handle,
 {
        if (!error) {
                flush_swap_writer(handle);
-               printk(KERN_INFO "PM: S");
+               pr_info("S");
                error = mark_swapfiles(handle, flags);
-               printk("|\n");
+               pr_cont("|\n");
        }
 
        if (error)
@@ -542,7 +543,7 @@ static int save_image(struct swap_map_handle *handle,
 
        hib_init_batch(&hb);
 
-       printk(KERN_INFO "PM: Saving image data pages (%u pages)...\n",
+       pr_info("Saving image data pages (%u pages)...\n",
                nr_to_write);
        m = nr_to_write / 10;
        if (!m)
@@ -557,8 +558,8 @@ static int save_image(struct swap_map_handle *handle,
                if (ret)
                        break;
                if (!(nr_pages % m))
-                       printk(KERN_INFO "PM: Image saving progress: %3d%%\n",
-                              nr_pages / m * 10);
+                       pr_info("Image saving progress: %3d%%\n",
+                               nr_pages / m * 10);
                nr_pages++;
        }
        err2 = hib_wait_io(&hb);
@@ -566,7 +567,7 @@ static int save_image(struct swap_map_handle *handle,
        if (!ret)
                ret = err2;
        if (!ret)
-               printk(KERN_INFO "PM: Image saving done.\n");
+               pr_info("Image saving done\n");
        swsusp_show_speed(start, stop, nr_to_write, "Wrote");
        return ret;
 }
@@ -692,14 +693,14 @@ static int save_image_lzo(struct swap_map_handle *handle,
 
        page = (void *)__get_free_page(__GFP_RECLAIM | __GFP_HIGH);
        if (!page) {
-               printk(KERN_ERR "PM: Failed to allocate LZO page\n");
+               pr_err("Failed to allocate LZO page\n");
                ret = -ENOMEM;
                goto out_clean;
        }
 
        data = vmalloc(sizeof(*data) * nr_threads);
        if (!data) {
-               printk(KERN_ERR "PM: Failed to allocate LZO data\n");
+               pr_err("Failed to allocate LZO data\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -708,7 +709,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
 
        crc = kmalloc(sizeof(*crc), GFP_KERNEL);
        if (!crc) {
-               printk(KERN_ERR "PM: Failed to allocate crc\n");
+               pr_err("Failed to allocate crc\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -726,8 +727,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
                                            "image_compress/%u", thr);
                if (IS_ERR(data[thr].thr)) {
                        data[thr].thr = NULL;
-                       printk(KERN_ERR
-                              "PM: Cannot start compression threads\n");
+                       pr_err("Cannot start compression threads\n");
                        ret = -ENOMEM;
                        goto out_clean;
                }
@@ -749,7 +749,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
        crc->thr = kthread_run(crc32_threadfn, crc, "image_crc32");
        if (IS_ERR(crc->thr)) {
                crc->thr = NULL;
-               printk(KERN_ERR "PM: Cannot start CRC32 thread\n");
+               pr_err("Cannot start CRC32 thread\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -760,10 +760,9 @@ static int save_image_lzo(struct swap_map_handle *handle,
         */
        handle->reqd_free_pages = reqd_free_pages();
 
-       printk(KERN_INFO
-               "PM: Using %u thread(s) for compression.\n"
-               "PM: Compressing and saving image data (%u pages)...\n",
-               nr_threads, nr_to_write);
+       pr_info("Using %u thread(s) for compression\n", nr_threads);
+       pr_info("Compressing and saving image data (%u pages)...\n",
+               nr_to_write);
        m = nr_to_write / 10;
        if (!m)
                m = 1;
@@ -783,10 +782,8 @@ static int save_image_lzo(struct swap_map_handle *handle,
                                       data_of(*snapshot), PAGE_SIZE);
 
                                if (!(nr_pages % m))
-                                       printk(KERN_INFO
-                                              "PM: Image saving progress: "
-                                              "%3d%%\n",
-                                              nr_pages / m * 10);
+                                       pr_info("Image saving progress: %3d%%\n",
+                                               nr_pages / m * 10);
                                nr_pages++;
                        }
                        if (!off)
@@ -813,15 +810,14 @@ static int save_image_lzo(struct swap_map_handle *handle,
                        ret = data[thr].ret;
 
                        if (ret < 0) {
-                               printk(KERN_ERR "PM: LZO compression failed\n");
+                               pr_err("LZO compression failed\n");
                                goto out_finish;
                        }
 
                        if (unlikely(!data[thr].cmp_len ||
                                     data[thr].cmp_len >
                                     lzo1x_worst_compress(data[thr].unc_len))) {
-                               printk(KERN_ERR
-                                      "PM: Invalid LZO compressed length\n");
+                               pr_err("Invalid LZO compressed length\n");
                                ret = -1;
                                goto out_finish;
                        }
@@ -857,7 +853,7 @@ out_finish:
        if (!ret)
                ret = err2;
        if (!ret)
-               printk(KERN_INFO "PM: Image saving done.\n");
+               pr_info("Image saving done\n");
        swsusp_show_speed(start, stop, nr_to_write, "Wrote");
 out_clean:
        if (crc) {
@@ -888,7 +884,7 @@ static int enough_swap(unsigned int nr_pages, unsigned int flags)
        unsigned int free_swap = count_swap_pages(root_swap, 1);
        unsigned int required;
 
-       pr_debug("PM: Free swap pages: %u\n", free_swap);
+       pr_debug("Free swap pages: %u\n", free_swap);
 
        required = PAGES_FOR_IO + nr_pages;
        return free_swap > required;
@@ -915,12 +911,12 @@ int swsusp_write(unsigned int flags)
        pages = snapshot_get_image_size();
        error = get_swap_writer(&handle);
        if (error) {
-               printk(KERN_ERR "PM: Cannot get swap writer\n");
+               pr_err("Cannot get swap writer\n");
                return error;
        }
        if (flags & SF_NOCOMPRESS_MODE) {
                if (!enough_swap(pages, flags)) {
-                       printk(KERN_ERR "PM: Not enough free swap\n");
+                       pr_err("Not enough free swap\n");
                        error = -ENOSPC;
                        goto out_finish;
                }
@@ -1068,8 +1064,7 @@ static int load_image(struct swap_map_handle *handle,
        hib_init_batch(&hb);
 
        clean_pages_on_read = true;
-       printk(KERN_INFO "PM: Loading image data pages (%u pages)...\n",
-               nr_to_read);
+       pr_info("Loading image data pages (%u pages)...\n", nr_to_read);
        m = nr_to_read / 10;
        if (!m)
                m = 1;
@@ -1087,8 +1082,8 @@ static int load_image(struct swap_map_handle *handle,
                if (ret)
                        break;
                if (!(nr_pages % m))
-                       printk(KERN_INFO "PM: Image loading progress: %3d%%\n",
-                              nr_pages / m * 10);
+                       pr_info("Image loading progress: %3d%%\n",
+                               nr_pages / m * 10);
                nr_pages++;
        }
        err2 = hib_wait_io(&hb);
@@ -1096,7 +1091,7 @@ static int load_image(struct swap_map_handle *handle,
        if (!ret)
                ret = err2;
        if (!ret) {
-               printk(KERN_INFO "PM: Image loading done.\n");
+               pr_info("Image loading done\n");
                snapshot_write_finalize(snapshot);
                if (!snapshot_image_loaded(snapshot))
                        ret = -ENODATA;
@@ -1190,14 +1185,14 @@ static int load_image_lzo(struct swap_map_handle *handle,
 
        page = vmalloc(sizeof(*page) * LZO_MAX_RD_PAGES);
        if (!page) {
-               printk(KERN_ERR "PM: Failed to allocate LZO page\n");
+               pr_err("Failed to allocate LZO page\n");
                ret = -ENOMEM;
                goto out_clean;
        }
 
        data = vmalloc(sizeof(*data) * nr_threads);
        if (!data) {
-               printk(KERN_ERR "PM: Failed to allocate LZO data\n");
+               pr_err("Failed to allocate LZO data\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -1206,7 +1201,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
 
        crc = kmalloc(sizeof(*crc), GFP_KERNEL);
        if (!crc) {
-               printk(KERN_ERR "PM: Failed to allocate crc\n");
+               pr_err("Failed to allocate crc\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -1226,8 +1221,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
                                            "image_decompress/%u", thr);
                if (IS_ERR(data[thr].thr)) {
                        data[thr].thr = NULL;
-                       printk(KERN_ERR
-                              "PM: Cannot start decompression threads\n");
+                       pr_err("Cannot start decompression threads\n");
                        ret = -ENOMEM;
                        goto out_clean;
                }
@@ -1249,7 +1243,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
        crc->thr = kthread_run(crc32_threadfn, crc, "image_crc32");
        if (IS_ERR(crc->thr)) {
                crc->thr = NULL;
-               printk(KERN_ERR "PM: Cannot start CRC32 thread\n");
+               pr_err("Cannot start CRC32 thread\n");
                ret = -ENOMEM;
                goto out_clean;
        }
@@ -1274,8 +1268,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
                if (!page[i]) {
                        if (i < LZO_CMP_PAGES) {
                                ring_size = i;
-                               printk(KERN_ERR
-                                      "PM: Failed to allocate LZO pages\n");
+                               pr_err("Failed to allocate LZO pages\n");
                                ret = -ENOMEM;
                                goto out_clean;
                        } else {
@@ -1285,10 +1278,9 @@ static int load_image_lzo(struct swap_map_handle *handle,
        }
        want = ring_size = i;
 
-       printk(KERN_INFO
-               "PM: Using %u thread(s) for decompression.\n"
-               "PM: Loading and decompressing image data (%u pages)...\n",
-               nr_threads, nr_to_read);
+       pr_info("Using %u thread(s) for decompression\n", nr_threads);
+       pr_info("Loading and decompressing image data (%u pages)...\n",
+               nr_to_read);
        m = nr_to_read / 10;
        if (!m)
                m = 1;
@@ -1348,8 +1340,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
                        if (unlikely(!data[thr].cmp_len ||
                                     data[thr].cmp_len >
                                     lzo1x_worst_compress(LZO_UNC_SIZE))) {
-                               printk(KERN_ERR
-                                      "PM: Invalid LZO compressed length\n");
+                               pr_err("Invalid LZO compressed length\n");
                                ret = -1;
                                goto out_finish;
                        }
@@ -1400,16 +1391,14 @@ static int load_image_lzo(struct swap_map_handle *handle,
                        ret = data[thr].ret;
 
                        if (ret < 0) {
-                               printk(KERN_ERR
-                                      "PM: LZO decompression failed\n");
+                               pr_err("LZO decompression failed\n");
                                goto out_finish;
                        }
 
                        if (unlikely(!data[thr].unc_len ||
                                     data[thr].unc_len > LZO_UNC_SIZE ||
                                     data[thr].unc_len & (PAGE_SIZE - 1))) {
-                               printk(KERN_ERR
-                                      "PM: Invalid LZO uncompressed length\n");
+                               pr_err("Invalid LZO uncompressed length\n");
                                ret = -1;
                                goto out_finish;
                        }
@@ -1420,10 +1409,8 @@ static int load_image_lzo(struct swap_map_handle *handle,
                                       data[thr].unc + off, PAGE_SIZE);
 
                                if (!(nr_pages % m))
-                                       printk(KERN_INFO
-                                              "PM: Image loading progress: "
-                                              "%3d%%\n",
-                                              nr_pages / m * 10);
+                                       pr_info("Image loading progress: %3d%%\n",
+                                               nr_pages / m * 10);
                                nr_pages++;
 
                                ret = snapshot_write_next(snapshot);
@@ -1448,15 +1435,14 @@ out_finish:
        }
        stop = ktime_get();
        if (!ret) {
-               printk(KERN_INFO "PM: Image loading done.\n");
+               pr_info("Image loading done\n");
                snapshot_write_finalize(snapshot);
                if (!snapshot_image_loaded(snapshot))
                        ret = -ENODATA;
                if (!ret) {
                        if (swsusp_header->flags & SF_CRC32_MODE) {
                                if(handle->crc32 != swsusp_header->crc32) {
-                                       printk(KERN_ERR
-                                              "PM: Invalid image CRC32!\n");
+                                       pr_err("Invalid image CRC32!\n");
                                        ret = -ENODATA;
                                }
                        }
@@ -1513,9 +1499,9 @@ int swsusp_read(unsigned int *flags_p)
        swap_reader_finish(&handle);
 end:
        if (!error)
-               pr_debug("PM: Image successfully loaded\n");
+               pr_debug("Image successfully loaded\n");
        else
-               pr_debug("PM: Error %d resuming\n", error);
+               pr_debug("Error %d resuming\n", error);
        return error;
 }
 
@@ -1552,13 +1538,13 @@ put:
                if (error)
                        blkdev_put(hib_resume_bdev, FMODE_READ);
                else
-                       pr_debug("PM: Image signature found, resuming\n");
+                       pr_debug("Image signature found, resuming\n");
        } else {
                error = PTR_ERR(hib_resume_bdev);
        }
 
        if (error)
-               pr_debug("PM: Image not found (code %d)\n", error);
+               pr_debug("Image not found (code %d)\n", error);
 
        return error;
 }
@@ -1570,7 +1556,7 @@ put:
 void swsusp_close(fmode_t mode)
 {
        if (IS_ERR(hib_resume_bdev)) {
-               pr_debug("PM: Image device not initialised\n");
+               pr_debug("Image device not initialised\n");
                return;
        }
 
@@ -1594,7 +1580,7 @@ int swsusp_unmark(void)
                                        swsusp_resume_block,
                                        swsusp_header, NULL);
        } else {
-               printk(KERN_ERR "PM: Cannot find swsusp signature!\n");
+               pr_err("Cannot find swsusp signature!\n");
                error = -ENODEV;
        }