Commit dd2c0198 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'erofs-for-6.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs 

Pull erofs updates from Gao Xiang:
 "In this cycle, a xattr bloom filter feature is introduced to speed up
  negative xattr lookups, which was originally suggested by Alexander
  for Composefs use cases.

  Additionally, the DEFLATE algorithm is now supported, which can be
  used together with hardware accelerators for our cloud workloads. Each
  supported compression algorithm can be selected on a per-file basis
  for specific access patterns too.

  There are also some random fixes and cleanups as usual:

   - Support xattr bloom filter to optimize negative xattr lookups

   - Support DEFLATE compression algorithm as an alternative

   - Fix a regression that ztailpacking pclusters don't release properly

   - Avoid warning dedupe and fragments features anymore

   - Some folio conversions and cleanups"

* tag 'erofs-for-6.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs:
  erofs: release ztailpacking pclusters properly
  erofs: don't warn dedupe and fragments features anymore
  erofs: adapt folios for z_erofs_read_folio()
  erofs: adapt folios for z_erofs_readahead()
  erofs: get rid of fe->backmost for cache decompression
  erofs: drop z_erofs_page_mark_eio()
  erofs: tidy up z_erofs_do_read_page()
  erofs: move preparation logic into z_erofs_pcluster_begin()
  erofs: avoid obsolete {collector,collection} terms
  erofs: simplify z_erofs_read_fragment()
  erofs: remove redundant erofs_fs_type declaration in super.c
  erofs: add necessary kmem_cache_create flags for erofs inode cache
  erofs: clean up redundant comment and adjust code alignment
  erofs: refine warning messages for zdata I/Os
  erofs: boost negative xattr lookup with bloom filter
  erofs: update on-disk format for xattr name filter
  erofs: DEFLATE compression support
parents f20ae9cf 91b1ad08

fs/erofs/Kconfig

+16 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ config EROFS_FS_DEBUG 
config EROFS_FS_XATTR

	bool "EROFS extended attributes"

	depends on EROFS_FS

	select XXHASH

	default y

	help

	  Extended attributes are name:value pairs associated with inodes by
@@ -99,6 +100,21 @@ config EROFS_FS_ZIP_LZMA 


	  If unsure, say N.



config EROFS_FS_ZIP_DEFLATE

	bool "EROFS DEFLATE compressed data support"

	depends on EROFS_FS_ZIP

	select ZLIB_INFLATE

	help

	  Saying Y here includes support for reading EROFS file systems

	  containing DEFLATE compressed data.  It gives better compression

	  ratios than the default LZ4 format, while it costs more CPU

	  overhead.



	  DEFLATE support is an experimental feature for now and so most

	  file systems will be readable without selecting this option.



	  If unsure, say N.



config EROFS_FS_ONDEMAND

	bool "EROFS fscache-based on-demand read support"

	depends on CACHEFILES_ONDEMAND && (EROFS_FS=m && FSCACHE || EROFS_FS=y && FSCACHE=y)

fs/erofs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -5,4 +5,5 @@ erofs-objs := super.o inode.o data.o namei.o dir.o utils.o sysfs.o 
erofs-$(CONFIG_EROFS_FS_XATTR) += xattr.o

erofs-$(CONFIG_EROFS_FS_ZIP) += decompressor.o zmap.o zdata.o pcpubuf.o

erofs-$(CONFIG_EROFS_FS_ZIP_LZMA) += decompressor_lzma.o

erofs-$(CONFIG_EROFS_FS_ZIP_DEFLATE) += decompressor_deflate.o

erofs-$(CONFIG_EROFS_FS_ONDEMAND) += fscache.o

fs/erofs/compress.h

+2 −0
Original line number Diff line number Diff line
@@ -94,4 +94,6 @@ extern const struct z_erofs_decompressor erofs_decompressors[]; 
/* prototypes for specific algorithms */

int z_erofs_lzma_decompress(struct z_erofs_decompress_req *rq,

			    struct page **pagepool);

int z_erofs_deflate_decompress(struct z_erofs_decompress_req *rq,

			       struct page **pagepool);

#endif

fs/erofs/decompressor.c

+6 −0
Original line number Diff line number Diff line
@@ -379,4 +379,10 @@ const struct z_erofs_decompressor erofs_decompressors[] = { 
		.name = "lzma"

	},

#endif

#ifdef CONFIG_EROFS_FS_ZIP_DEFLATE

	[Z_EROFS_COMPRESSION_DEFLATE] = {

		.decompress = z_erofs_deflate_decompress,

		.name = "deflate"

	},

#endif

};

fs/erofs/decompressor_deflate.c

0 → 100644
+247 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

#include <linux/module.h>

#include <linux/zlib.h>

#include "compress.h"



struct z_erofs_deflate {

	struct z_erofs_deflate *next;

	struct z_stream_s z;

	u8 bounce[PAGE_SIZE];

};



static DEFINE_SPINLOCK(z_erofs_deflate_lock);

static unsigned int z_erofs_deflate_nstrms, z_erofs_deflate_avail_strms;

static struct z_erofs_deflate *z_erofs_deflate_head;

static DECLARE_WAIT_QUEUE_HEAD(z_erofs_deflate_wq);



module_param_named(deflate_streams, z_erofs_deflate_nstrms, uint, 0444);



void z_erofs_deflate_exit(void)

{

	/* there should be no running fs instance */

	while (z_erofs_deflate_avail_strms) {

		struct z_erofs_deflate *strm;



		spin_lock(&z_erofs_deflate_lock);

		strm = z_erofs_deflate_head;

		if (!strm) {

			spin_unlock(&z_erofs_deflate_lock);

			continue;

		}

		z_erofs_deflate_head = NULL;

		spin_unlock(&z_erofs_deflate_lock);



		while (strm) {

			struct z_erofs_deflate *n = strm->next;



			vfree(strm->z.workspace);

			kfree(strm);

			--z_erofs_deflate_avail_strms;

			strm = n;

		}

	}

}



int __init z_erofs_deflate_init(void)

{

	/* by default, use # of possible CPUs instead */

	if (!z_erofs_deflate_nstrms)

		z_erofs_deflate_nstrms = num_possible_cpus();



	for (; z_erofs_deflate_avail_strms < z_erofs_deflate_nstrms;

	     ++z_erofs_deflate_avail_strms) {

		struct z_erofs_deflate *strm;



		strm = kzalloc(sizeof(*strm), GFP_KERNEL);

		if (!strm)

			goto out_failed;



		/* XXX: in-kernel zlib cannot shrink windowbits currently */

		strm->z.workspace = vmalloc(zlib_inflate_workspacesize());

		if (!strm->z.workspace) {

			kfree(strm);

			goto out_failed;

		}



		spin_lock(&z_erofs_deflate_lock);

		strm->next = z_erofs_deflate_head;

		z_erofs_deflate_head = strm;

		spin_unlock(&z_erofs_deflate_lock);

	}

	return 0;



out_failed:

	pr_err("failed to allocate zlib workspace\n");

	z_erofs_deflate_exit();

	return -ENOMEM;

}



int z_erofs_load_deflate_config(struct super_block *sb,

				struct erofs_super_block *dsb,

				struct z_erofs_deflate_cfgs *dfl, int size)

{

	if (!dfl || size < sizeof(struct z_erofs_deflate_cfgs)) {

		erofs_err(sb, "invalid deflate cfgs, size=%u", size);

		return -EINVAL;

	}



	if (dfl->windowbits > MAX_WBITS) {

		erofs_err(sb, "unsupported windowbits %u", dfl->windowbits);

		return -EOPNOTSUPP;

	}



	erofs_info(sb, "EXPERIMENTAL DEFLATE feature in use. Use at your own risk!");

	return 0;

}



int z_erofs_deflate_decompress(struct z_erofs_decompress_req *rq,

			       struct page **pagepool)

{

	const unsigned int nrpages_out =

		PAGE_ALIGN(rq->pageofs_out + rq->outputsize) >> PAGE_SHIFT;

	const unsigned int nrpages_in =

		PAGE_ALIGN(rq->inputsize) >> PAGE_SHIFT;

	struct super_block *sb = rq->sb;

	unsigned int insz, outsz, pofs;

	struct z_erofs_deflate *strm;

	u8 *kin, *kout = NULL;

	bool bounced = false;

	int no = -1, ni = 0, j = 0, zerr, err;



	/* 1. get the exact DEFLATE compressed size */

	kin = kmap_local_page(*rq->in);

	err = z_erofs_fixup_insize(rq, kin + rq->pageofs_in,

			min_t(unsigned int, rq->inputsize,

			      sb->s_blocksize - rq->pageofs_in));

	if (err) {

		kunmap_local(kin);

		return err;

	}



	/* 2. get an available DEFLATE context */

again:

	spin_lock(&z_erofs_deflate_lock);

	strm = z_erofs_deflate_head;

	if (!strm) {

		spin_unlock(&z_erofs_deflate_lock);

		wait_event(z_erofs_deflate_wq, READ_ONCE(z_erofs_deflate_head));

		goto again;

	}

	z_erofs_deflate_head = strm->next;

	spin_unlock(&z_erofs_deflate_lock);



	/* 3. multi-call decompress */

	insz = rq->inputsize;

	outsz = rq->outputsize;

	zerr = zlib_inflateInit2(&strm->z, -MAX_WBITS);

	if (zerr != Z_OK) {

		err = -EIO;

		goto failed_zinit;

	}



	pofs = rq->pageofs_out;

	strm->z.avail_in = min_t(u32, insz, PAGE_SIZE - rq->pageofs_in);

	insz -= strm->z.avail_in;

	strm->z.next_in = kin + rq->pageofs_in;

	strm->z.avail_out = 0;



	while (1) {

		if (!strm->z.avail_out) {

			if (++no >= nrpages_out || !outsz) {

				erofs_err(sb, "insufficient space for decompressed data");

				err = -EFSCORRUPTED;

				break;

			}



			if (kout)

				kunmap_local(kout);

			strm->z.avail_out = min_t(u32, outsz, PAGE_SIZE - pofs);

			outsz -= strm->z.avail_out;

			if (!rq->out[no]) {

				rq->out[no] = erofs_allocpage(pagepool,

						GFP_KERNEL | __GFP_NOFAIL);

				set_page_private(rq->out[no],

						 Z_EROFS_SHORTLIVED_PAGE);

			}

			kout = kmap_local_page(rq->out[no]);

			strm->z.next_out = kout + pofs;

			pofs = 0;

		}



		if (!strm->z.avail_in && insz) {

			if (++ni >= nrpages_in) {

				erofs_err(sb, "invalid compressed data");

				err = -EFSCORRUPTED;

				break;

			}



			if (kout) { /* unlike kmap(), take care of the orders */

				j = strm->z.next_out - kout;

				kunmap_local(kout);

			}

			kunmap_local(kin);

			strm->z.avail_in = min_t(u32, insz, PAGE_SIZE);

			insz -= strm->z.avail_in;

			kin = kmap_local_page(rq->in[ni]);

			strm->z.next_in = kin;

			bounced = false;

			if (kout) {

				kout = kmap_local_page(rq->out[no]);

				strm->z.next_out = kout + j;

			}

		}



		/*

		 * Handle overlapping: Use bounced buffer if the compressed

		 * data is under processing; Or use short-lived pages from the

		 * on-stack pagepool where pages share among the same request

		 * and not _all_ inplace I/O pages are needed to be doubled.

		 */

		if (!bounced && rq->out[no] == rq->in[ni]) {

			memcpy(strm->bounce, strm->z.next_in, strm->z.avail_in);

			strm->z.next_in = strm->bounce;

			bounced = true;

		}



		for (j = ni + 1; j < nrpages_in; ++j) {

			struct page *tmppage;



			if (rq->out[no] != rq->in[j])

				continue;



			DBG_BUGON(erofs_page_is_managed(EROFS_SB(sb),

							rq->in[j]));

			tmppage = erofs_allocpage(pagepool,

						  GFP_KERNEL | __GFP_NOFAIL);

			set_page_private(tmppage, Z_EROFS_SHORTLIVED_PAGE);

			copy_highpage(tmppage, rq->in[j]);

			rq->in[j] = tmppage;

		}



		zerr = zlib_inflate(&strm->z, Z_SYNC_FLUSH);

		if (zerr != Z_OK || !(outsz + strm->z.avail_out)) {

			if (zerr == Z_OK && rq->partial_decoding)

				break;

			if (zerr == Z_STREAM_END && !outsz)

				break;

			erofs_err(sb, "failed to decompress %d in[%u] out[%u]",

				  zerr, rq->inputsize, rq->outputsize);

			err = -EFSCORRUPTED;

			break;

		}

	}



	if (zlib_inflateEnd(&strm->z) != Z_OK && !err)

		err = -EIO;

	if (kout)

		kunmap_local(kout);

failed_zinit:

	kunmap_local(kin);

	/* 4. push back DEFLATE stream context to the global list */

	spin_lock(&z_erofs_deflate_lock);

	strm->next = z_erofs_deflate_head;

	z_erofs_deflate_head = strm;

	spin_unlock(&z_erofs_deflate_lock);

	wake_up(&z_erofs_deflate_wq);

	return err;

}