Commit 89a80762 authored Jan 22, 2024 by Nikhil V Committed by Rafael J. Wysocki Feb 05, 2024

PM: hibernate: Rename lzo* to make it generic



Renaming lzo* to generic names, except for lzo_xxx() APIs. This is
used in the next patch where we move to crypto based APIs for
compression. There are no functional changes introduced by this
approach.

Signed-off-by: Nikhil V <quic_nprakash@quicinc.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

parent 86205785

kernel/power/swap.c

+60 −60

Original line number	Diff line number	Diff line
		@@ -515,23 +515,23 @@ static int swap_writer_finish(struct swap_map_handle *handle,
		}

		/* We need to remember how much compressed data we need to read. */
		#define LZO_HEADER sizeof(size_t)
		#define CMP_HEADER sizeof(size_t)

		/* Number of pages/bytes we'll compress at one time. */
		#define LZO_UNC_PAGES 32
		#define LZO_UNC_SIZE (LZO_UNC_PAGES * PAGE_SIZE)
		#define UNC_PAGES 32
		#define UNC_SIZE (UNC_PAGES * PAGE_SIZE)

		/* Number of pages/bytes we need for compressed data (worst case). */
		#define LZO_CMP_PAGES DIV_ROUND_UP(lzo1x_worst_compress(LZO_UNC_SIZE) + \
		LZO_HEADER, PAGE_SIZE)
		#define LZO_CMP_SIZE (LZO_CMP_PAGES * PAGE_SIZE)
		/* Number of pages we need for compressed data (worst case). */
		#define CMP_PAGES DIV_ROUND_UP(lzo1x_worst_compress(UNC_SIZE) + \
		CMP_HEADER, PAGE_SIZE)
		#define CMP_SIZE (CMP_PAGES * PAGE_SIZE)

		/* Maximum number of threads for compression/decompression. */
		#define LZO_THREADS 3
		#define CMP_THREADS 3

		/* Minimum/maximum number of pages for read buffering. */
		#define LZO_MIN_RD_PAGES 1024
		#define LZO_MAX_RD_PAGES 8192
		#define CMP_MIN_RD_PAGES 1024
		#define CMP_MAX_RD_PAGES 8192


		/**
		@@ -593,8 +593,8 @@ struct crc_data {
		wait_queue_head_t go; /* start crc update */
		wait_queue_head_t done; /* crc update done */
		u32 crc32; / points to handle's crc32 */
		size_t unc_len[LZO_THREADS]; / uncompressed lengths */
		unsigned char unc[LZO_THREADS]; / uncompressed data */
		size_t unc_len[CMP_THREADS]; / uncompressed lengths */
		unsigned char unc[CMP_THREADS]; / uncompressed data */
		};

		/*
		@@ -625,7 +625,7 @@ static int crc32_threadfn(void *data)
		return 0;
		}
		/*
		* Structure used for LZO data compression.
		* Structure used for data compression.
		*/
		struct cmp_data {
		struct task_struct thr; / thread */
		@@ -636,15 +636,15 @@ struct cmp_data {
		wait_queue_head_t done; /* compression done */
		size_t unc_len; /* uncompressed length */
		size_t cmp_len; /* compressed length */
		unsigned char unc[LZO_UNC_SIZE]; /* uncompressed buffer */
		unsigned char cmp[LZO_CMP_SIZE]; /* compressed buffer */
		unsigned char unc[UNC_SIZE]; /* uncompressed buffer */
		unsigned char cmp[CMP_SIZE]; /* compressed buffer */
		unsigned char wrk[LZO1X_1_MEM_COMPRESS]; /* compression workspace */
		};

		/*
		* Compression function that runs in its own thread.
		*/
		static int lzo_compress_threadfn(void *data)
		static int compress_threadfn(void *data)
		{
		struct cmp_data *d = data;

		@@ -661,7 +661,7 @@ static int lzo_compress_threadfn(void *data)
		atomic_set(&d->ready, 0);

		d->ret = lzo1x_1_compress(d->unc, d->unc_len,
		d->cmp + LZO_HEADER, &d->cmp_len,
		d->cmp + CMP_HEADER, &d->cmp_len,
		d->wrk);
		atomic_set_release(&d->stop, 1);
		wake_up(&d->done);
		@@ -670,12 +670,12 @@ static int lzo_compress_threadfn(void *data)
		}

		/**
		* save_image_lzo - Save the suspend image data compressed with LZO.
		* save_compressed_image - Save the suspend image data after compression.
		* @handle: Swap map handle to use for saving the image.
		* @snapshot: Image to read data from.
		* @nr_to_write: Number of pages to save.
		*/
		static int save_image_lzo(struct swap_map_handle *handle,
		static int save_compressed_image(struct swap_map_handle *handle,
		struct snapshot_handle *snapshot,
		unsigned int nr_to_write)
		{
		@@ -699,18 +699,18 @@ static int save_image_lzo(struct swap_map_handle *handle,
		* footprint.
		*/
		nr_threads = num_online_cpus() - 1;
		nr_threads = clamp_val(nr_threads, 1, LZO_THREADS);
		nr_threads = clamp_val(nr_threads, 1, CMP_THREADS);

		page = (void *)__get_free_page(GFP_NOIO \| __GFP_HIGH);
		if (!page) {
		pr_err("Failed to allocate LZO page\n");
		pr_err("Failed to allocate compression page\n");
		ret = -ENOMEM;
		goto out_clean;
		}

		data = vzalloc(array_size(nr_threads, sizeof(*data)));
		if (!data) {
		pr_err("Failed to allocate LZO data\n");
		pr_err("Failed to allocate compression data\n");
		ret = -ENOMEM;
		goto out_clean;
		}
		@@ -729,7 +729,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
		init_waitqueue_head(&data[thr].go);
		init_waitqueue_head(&data[thr].done);

		data[thr].thr = kthread_run(lzo_compress_threadfn,
		data[thr].thr = kthread_run(compress_threadfn,
		&data[thr],
		"image_compress/%u", thr);
		if (IS_ERR(data[thr].thr)) {
		@@ -777,7 +777,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
		start = ktime_get();
		for (;;) {
		for (thr = 0; thr < nr_threads; thr++) {
		for (off = 0; off < LZO_UNC_SIZE; off += PAGE_SIZE) {
		for (off = 0; off < UNC_SIZE; off += PAGE_SIZE) {
		ret = snapshot_read_next(snapshot);
		if (ret < 0)
		goto out_finish;
		@@ -817,14 +817,14 @@ static int save_image_lzo(struct swap_map_handle *handle,
		ret = data[thr].ret;

		if (ret < 0) {
		pr_err("LZO compression failed\n");
		pr_err("compression failed\n");
		goto out_finish;
		}

		if (unlikely(!data[thr].cmp_len \|\|
		data[thr].cmp_len >
		lzo1x_worst_compress(data[thr].unc_len))) {
		pr_err("Invalid LZO compressed length\n");
		pr_err("Invalid compressed length\n");
		ret = -1;
		goto out_finish;
		}
		@@ -840,7 +840,7 @@ static int save_image_lzo(struct swap_map_handle *handle,
		* read it.
		*/
		for (off = 0;
		off < LZO_HEADER + data[thr].cmp_len;
		off < CMP_HEADER + data[thr].cmp_len;
		off += PAGE_SIZE) {
		memcpy(page, data[thr].cmp + off, PAGE_SIZE);

		@@ -942,7 +942,7 @@ int swsusp_write(unsigned int flags)
		if (!error) {
		error = (flags & SF_NOCOMPRESS_MODE) ?
		save_image(&handle, &snapshot, pages - 1) :
		save_image_lzo(&handle, &snapshot, pages - 1);
		save_compressed_image(&handle, &snapshot, pages - 1);
		}
		out_finish:
		error = swap_writer_finish(&handle, flags, error);
		@@ -1109,7 +1109,7 @@ static int load_image(struct swap_map_handle *handle,
		}

		/*
		* Structure used for LZO data decompression.
		* Structure used for data decompression.
		*/
		struct dec_data {
		struct task_struct thr; / thread */
		@@ -1120,14 +1120,14 @@ struct dec_data {
		wait_queue_head_t done; /* decompression done */
		size_t unc_len; /* uncompressed length */
		size_t cmp_len; /* compressed length */
		unsigned char unc[LZO_UNC_SIZE]; /* uncompressed buffer */
		unsigned char cmp[LZO_CMP_SIZE]; /* compressed buffer */
		unsigned char unc[UNC_SIZE]; /* uncompressed buffer */
		unsigned char cmp[CMP_SIZE]; /* compressed buffer */
		};

		/*
		* Decompression function that runs in its own thread.
		*/
		static int lzo_decompress_threadfn(void *data)
		static int decompress_threadfn(void *data)
		{
		struct dec_data *d = data;

		@@ -1143,8 +1143,8 @@ static int lzo_decompress_threadfn(void *data)
		}
		atomic_set(&d->ready, 0);

		d->unc_len = LZO_UNC_SIZE;
		d->ret = lzo1x_decompress_safe(d->cmp + LZO_HEADER, d->cmp_len,
		d->unc_len = UNC_SIZE;
		d->ret = lzo1x_decompress_safe(d->cmp + CMP_HEADER, d->cmp_len,
		d->unc, &d->unc_len);
		if (clean_pages_on_decompress)
		flush_icache_range((unsigned long)d->unc,
		@@ -1157,12 +1157,12 @@ static int lzo_decompress_threadfn(void *data)
		}

		/**
		* load_image_lzo - Load compressed image data and decompress them with LZO.
		* load_compressed_image - Load compressed image data and decompress it.
		* @handle: Swap map handle to use for loading data.
		* @snapshot: Image to copy uncompressed data into.
		* @nr_to_read: Number of pages to load.
		*/
		static int load_image_lzo(struct swap_map_handle *handle,
		static int load_compressed_image(struct swap_map_handle *handle,
		struct snapshot_handle *snapshot,
		unsigned int nr_to_read)
		{
		@@ -1189,18 +1189,18 @@ static int load_image_lzo(struct swap_map_handle *handle,
		* footprint.
		*/
		nr_threads = num_online_cpus() - 1;
		nr_threads = clamp_val(nr_threads, 1, LZO_THREADS);
		nr_threads = clamp_val(nr_threads, 1, CMP_THREADS);

		page = vmalloc(array_size(LZO_MAX_RD_PAGES, sizeof(*page)));
		page = vmalloc(array_size(CMP_MAX_RD_PAGES, sizeof(*page)));
		if (!page) {
		pr_err("Failed to allocate LZO page\n");
		pr_err("Failed to allocate compression page\n");
		ret = -ENOMEM;
		goto out_clean;
		}

		data = vzalloc(array_size(nr_threads, sizeof(*data)));
		if (!data) {
		pr_err("Failed to allocate LZO data\n");
		pr_err("Failed to allocate compression data\n");
		ret = -ENOMEM;
		goto out_clean;
		}
		@@ -1221,7 +1221,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
		init_waitqueue_head(&data[thr].go);
		init_waitqueue_head(&data[thr].done);

		data[thr].thr = kthread_run(lzo_decompress_threadfn,
		data[thr].thr = kthread_run(decompress_threadfn,
		&data[thr],
		"image_decompress/%u", thr);
		if (IS_ERR(data[thr].thr)) {
		@@ -1262,18 +1262,18 @@ static int load_image_lzo(struct swap_map_handle *handle,
		*/
		if (low_free_pages() > snapshot_get_image_size())
		read_pages = (low_free_pages() - snapshot_get_image_size()) / 2;
		read_pages = clamp_val(read_pages, LZO_MIN_RD_PAGES, LZO_MAX_RD_PAGES);
		read_pages = clamp_val(read_pages, CMP_MIN_RD_PAGES, CMP_MAX_RD_PAGES);

		for (i = 0; i < read_pages; i++) {
		page[i] = (void *)__get_free_page(i < LZO_CMP_PAGES ?
		page[i] = (void *)__get_free_page(i < CMP_PAGES ?
		GFP_NOIO \| __GFP_HIGH :
		GFP_NOIO \| __GFP_NOWARN \|
		__GFP_NORETRY);

		if (!page[i]) {
		if (i < LZO_CMP_PAGES) {
		if (i < CMP_PAGES) {
		ring_size = i;
		pr_err("Failed to allocate LZO pages\n");
		pr_err("Failed to allocate compression pages\n");
		ret = -ENOMEM;
		goto out_clean;
		} else {
		@@ -1344,13 +1344,13 @@ static int load_image_lzo(struct swap_map_handle *handle,
		data[thr].cmp_len = (size_t )page[pg];
		if (unlikely(!data[thr].cmp_len \|\|
		data[thr].cmp_len >
		lzo1x_worst_compress(LZO_UNC_SIZE))) {
		pr_err("Invalid LZO compressed length\n");
		lzo1x_worst_compress(UNC_SIZE))) {
		pr_err("Invalid compressed length\n");
		ret = -1;
		goto out_finish;
		}

		need = DIV_ROUND_UP(data[thr].cmp_len + LZO_HEADER,
		need = DIV_ROUND_UP(data[thr].cmp_len + CMP_HEADER,
		PAGE_SIZE);
		if (need > have) {
		if (eof > 1) {
		@@ -1361,7 +1361,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
		}

		for (off = 0;
		off < LZO_HEADER + data[thr].cmp_len;
		off < CMP_HEADER + data[thr].cmp_len;
		off += PAGE_SIZE) {
		memcpy(data[thr].cmp + off,
		page[pg], PAGE_SIZE);
		@@ -1378,7 +1378,7 @@ static int load_image_lzo(struct swap_map_handle *handle,
		/*
		* Wait for more data while we are decompressing.
		*/
		if (have < LZO_CMP_PAGES && asked) {
		if (have < CMP_PAGES && asked) {
		ret = hib_wait_io(&hb);
		if (ret)
		goto out_finish;
		@@ -1396,14 +1396,14 @@ static int load_image_lzo(struct swap_map_handle *handle,
		ret = data[thr].ret;

		if (ret < 0) {
		pr_err("LZO decompression failed\n");
		pr_err("decompression failed\n");
		goto out_finish;
		}

		if (unlikely(!data[thr].unc_len \|\|
		data[thr].unc_len > LZO_UNC_SIZE \|\|
		data[thr].unc_len > UNC_SIZE \|\|
		data[thr].unc_len & (PAGE_SIZE - 1))) {
		pr_err("Invalid LZO uncompressed length\n");
		pr_err("Invalid uncompressed length\n");
		ret = -1;
		goto out_finish;
		}
		@@ -1500,7 +1500,7 @@ int swsusp_read(unsigned int *flags_p)
		if (!error) {
		error = (*flags_p & SF_NOCOMPRESS_MODE) ?
		load_image(&handle, &snapshot, header->pages - 1) :
		load_image_lzo(&handle, &snapshot, header->pages - 1);
		load_compressed_image(&handle, &snapshot, header->pages - 1);
		}
		swap_reader_finish(&handle);
		end: