zdata.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) 2018 HUAWEI, Inc.
   4 *             https://www.huawei.com/
   5 * Copyright (C) 2022 Alibaba Cloud
   6 */
   7#include "compress.h"
   8#include <linux/psi.h>
   9#include <linux/cpuhotplug.h>
  10#include <trace/events/erofs.h>
  11
  12#define Z_EROFS_PCLUSTER_MAX_PAGES	(Z_EROFS_PCLUSTER_MAX_SIZE / PAGE_SIZE)
  13#define Z_EROFS_INLINE_BVECS		2
  14
  15struct z_erofs_bvec {
  16	struct page *page;
  17	int offset;
  18	unsigned int end;
  19};
  20
  21#define __Z_EROFS_BVSET(name, total) \
  22struct name { \
  23	/* point to the next page which contains the following bvecs */ \
  24	struct page *nextpage; \
  25	struct z_erofs_bvec bvec[total]; \
  26}
  27__Z_EROFS_BVSET(z_erofs_bvset,);
  28__Z_EROFS_BVSET(z_erofs_bvset_inline, Z_EROFS_INLINE_BVECS);
  29
  30/*
  31 * Structure fields follow one of the following exclusion rules.
  32 *
  33 * I: Modifiable by initialization/destruction paths and read-only
  34 *    for everyone else;
  35 *
  36 * L: Field should be protected by the pcluster lock;
  37 *
  38 * A: Field should be accessed / updated in atomic for parallelized code.
  39 */
  40struct z_erofs_pcluster {
  41	struct mutex lock;
  42	struct lockref lockref;
  43
  44	/* A: point to next chained pcluster or TAILs */
  45	struct z_erofs_pcluster *next;
  46
  47	/* I: start physical position of this pcluster */
  48	erofs_off_t pos;
  49
  50	/* L: the maximum decompression size of this round */
  51	unsigned int length;
  52
  53	/* L: total number of bvecs */
  54	unsigned int vcnt;
  55
  56	/* I: pcluster size (compressed size) in bytes */
  57	unsigned int pclustersize;
  58
  59	/* I: page offset of start position of decompression */
  60	unsigned short pageofs_out;
  61
  62	/* I: page offset of inline compressed data */
  63	unsigned short pageofs_in;
  64
  65	union {
  66		/* L: inline a certain number of bvec for bootstrap */
  67		struct z_erofs_bvset_inline bvset;
  68
  69		/* I: can be used to free the pcluster by RCU. */
  70		struct rcu_head rcu;
  71	};
  72
  73	/* I: compression algorithm format */
  74	unsigned char algorithmformat;
  75
  76	/* I: whether compressed data is in-lined or not */
  77	bool from_meta;
  78
  79	/* L: whether partial decompression or not */
  80	bool partial;
  81
  82	/* L: whether extra buffer allocations are best-effort */
  83	bool besteffort;
  84
  85	/* A: compressed bvecs (can be cached or inplaced pages) */
  86	struct z_erofs_bvec compressed_bvecs[];
  87};
  88
  89/* the end of a chain of pclusters */
  90#define Z_EROFS_PCLUSTER_TAIL           ((void *) 0x700 + POISON_POINTER_DELTA)
  91
  92struct z_erofs_decompressqueue {
  93	struct super_block *sb;
  94	struct z_erofs_pcluster *head;
  95	atomic_t pending_bios;
  96
  97	union {
  98		struct completion done;
  99		struct work_struct work;
 100		struct kthread_work kthread_work;
 101	} u;
 102	bool eio, sync;
 103};
 104
 105static inline unsigned int z_erofs_pclusterpages(struct z_erofs_pcluster *pcl)
 106{
 107	return PAGE_ALIGN(pcl->pageofs_in + pcl->pclustersize) >> PAGE_SHIFT;
 108}
 109
 110static bool erofs_folio_is_managed(struct erofs_sb_info *sbi, struct folio *fo)
 111{
 112	return fo->mapping == MNGD_MAPPING(sbi);
 113}
 114
 115#define Z_EROFS_ONSTACK_PAGES		32
 116
 117/*
 118 * since pclustersize is variable for big pcluster feature, introduce slab
 119 * pools implementation for different pcluster sizes.
 120 */
 121struct z_erofs_pcluster_slab {
 122	struct kmem_cache *slab;
 123	unsigned int maxpages;
 124	char name[48];
 125};
 126
 127#define _PCLP(n) { .maxpages = n }
 128
 129static struct z_erofs_pcluster_slab pcluster_pool[] __read_mostly = {
 130	_PCLP(1), _PCLP(4), _PCLP(16), _PCLP(64), _PCLP(128),
 131	_PCLP(Z_EROFS_PCLUSTER_MAX_PAGES + 1)
 132};
 133
 134struct z_erofs_bvec_iter {
 135	struct page *bvpage;
 136	struct z_erofs_bvset *bvset;
 137	unsigned int nr, cur;
 138};
 139
 140static struct page *z_erofs_bvec_iter_end(struct z_erofs_bvec_iter *iter)
 141{
 142	if (iter->bvpage)
 143		kunmap_local(iter->bvset);
 144	return iter->bvpage;
 145}
 146
 147static struct page *z_erofs_bvset_flip(struct z_erofs_bvec_iter *iter)
 148{
 149	unsigned long base = (unsigned long)((struct z_erofs_bvset *)0)->bvec;
 150	/* have to access nextpage in advance, otherwise it will be unmapped */
 151	struct page *nextpage = iter->bvset->nextpage;
 152	struct page *oldpage;
 153
 154	DBG_BUGON(!nextpage);
 155	oldpage = z_erofs_bvec_iter_end(iter);
 156	iter->bvpage = nextpage;
 157	iter->bvset = kmap_local_page(nextpage);
 158	iter->nr = (PAGE_SIZE - base) / sizeof(struct z_erofs_bvec);
 159	iter->cur = 0;
 160	return oldpage;
 161}
 162
 163static void z_erofs_bvec_iter_begin(struct z_erofs_bvec_iter *iter,
 164				    struct z_erofs_bvset_inline *bvset,
 165				    unsigned int bootstrap_nr,
 166				    unsigned int cur)
 167{
 168	*iter = (struct z_erofs_bvec_iter) {
 169		.nr = bootstrap_nr,
 170		.bvset = (struct z_erofs_bvset *)bvset,
 171	};
 172
 173	while (cur > iter->nr) {
 174		cur -= iter->nr;
 175		z_erofs_bvset_flip(iter);
 176	}
 177	iter->cur = cur;
 178}
 179
 180static int z_erofs_bvec_enqueue(struct z_erofs_bvec_iter *iter,
 181				struct z_erofs_bvec *bvec,
 182				struct page **candidate_bvpage,
 183				struct page **pagepool)
 184{
 185	if (iter->cur >= iter->nr) {
 186		struct page *nextpage = *candidate_bvpage;
 187
 188		if (!nextpage) {
 189			nextpage = __erofs_allocpage(pagepool, GFP_KERNEL,
 190					true);
 191			if (!nextpage)
 192				return -ENOMEM;
 193			set_page_private(nextpage, Z_EROFS_SHORTLIVED_PAGE);
 194		}
 195		DBG_BUGON(iter->bvset->nextpage);
 196		iter->bvset->nextpage = nextpage;
 197		z_erofs_bvset_flip(iter);
 198
 199		iter->bvset->nextpage = NULL;
 200		*candidate_bvpage = NULL;
 201	}
 202	iter->bvset->bvec[iter->cur++] = *bvec;
 203	return 0;
 204}
 205
 206static void z_erofs_bvec_dequeue(struct z_erofs_bvec_iter *iter,
 207				 struct z_erofs_bvec *bvec,
 208				 struct page **old_bvpage)
 209{
 210	if (iter->cur == iter->nr)
 211		*old_bvpage = z_erofs_bvset_flip(iter);
 212	else
 213		*old_bvpage = NULL;
 214	*bvec = iter->bvset->bvec[iter->cur++];
 215}
 216
 217static void z_erofs_destroy_pcluster_pool(void)
 218{
 219	int i;
 220
 221	for (i = 0; i < ARRAY_SIZE(pcluster_pool); ++i) {
 222		if (!pcluster_pool[i].slab)
 223			continue;
 224		kmem_cache_destroy(pcluster_pool[i].slab);
 225		pcluster_pool[i].slab = NULL;
 226	}
 227}
 228
 229static int z_erofs_create_pcluster_pool(void)
 230{
 231	struct z_erofs_pcluster_slab *pcs;
 232	struct z_erofs_pcluster *a;
 233	unsigned int size;
 234
 235	for (pcs = pcluster_pool;
 236	     pcs < pcluster_pool + ARRAY_SIZE(pcluster_pool); ++pcs) {
 237		size = struct_size(a, compressed_bvecs, pcs->maxpages);
 238
 239		sprintf(pcs->name, "erofs_pcluster-%u", pcs->maxpages);
 240		pcs->slab = kmem_cache_create(pcs->name, size, 0,
 241					      SLAB_RECLAIM_ACCOUNT, NULL);
 242		if (pcs->slab)
 243			continue;
 244
 245		z_erofs_destroy_pcluster_pool();
 246		return -ENOMEM;
 247	}
 248	return 0;
 249}
 250
 251static struct z_erofs_pcluster *z_erofs_alloc_pcluster(unsigned int size)
 252{
 253	unsigned int nrpages = PAGE_ALIGN(size) >> PAGE_SHIFT;
 254	struct z_erofs_pcluster_slab *pcs = pcluster_pool;
 255
 256	for (; pcs < pcluster_pool + ARRAY_SIZE(pcluster_pool); ++pcs) {
 257		struct z_erofs_pcluster *pcl;
 258
 259		if (nrpages > pcs->maxpages)
 260			continue;
 261
 262		pcl = kmem_cache_zalloc(pcs->slab, GFP_KERNEL);
 263		if (!pcl)
 264			return ERR_PTR(-ENOMEM);
 265		return pcl;
 266	}
 267	return ERR_PTR(-EINVAL);
 268}
 269
 270static void z_erofs_free_pcluster(struct z_erofs_pcluster *pcl)
 271{
 272	unsigned int pclusterpages = z_erofs_pclusterpages(pcl);
 273	int i;
 274
 275	for (i = 0; i < ARRAY_SIZE(pcluster_pool); ++i) {
 276		struct z_erofs_pcluster_slab *pcs = pcluster_pool + i;
 277
 278		if (pclusterpages > pcs->maxpages)
 279			continue;
 280
 281		kmem_cache_free(pcs->slab, pcl);
 282		return;
 283	}
 284	DBG_BUGON(1);
 285}
 286
 287static struct workqueue_struct *z_erofs_workqueue __read_mostly;
 288
 289#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD
 290static struct kthread_worker __rcu **z_erofs_pcpu_workers;
 291static atomic_t erofs_percpu_workers_initialized = ATOMIC_INIT(0);
 292
 293static void erofs_destroy_percpu_workers(void)
 294{
 295	struct kthread_worker *worker;
 296	unsigned int cpu;
 297
 298	for_each_possible_cpu(cpu) {
 299		worker = rcu_dereference_protected(
 300					z_erofs_pcpu_workers[cpu], 1);
 301		rcu_assign_pointer(z_erofs_pcpu_workers[cpu], NULL);
 302		if (worker)
 303			kthread_destroy_worker(worker);
 304	}
 305	kfree(z_erofs_pcpu_workers);
 306}
 307
 308static struct kthread_worker *erofs_init_percpu_worker(int cpu)
 309{
 310	struct kthread_worker *worker =
 311		kthread_run_worker_on_cpu(cpu, 0, "erofs_worker/%u");
 312
 313	if (IS_ERR(worker))
 314		return worker;
 315	if (IS_ENABLED(CONFIG_EROFS_FS_PCPU_KTHREAD_HIPRI))
 316		sched_set_fifo_low(worker->task);
 317	return worker;
 318}
 319
 320static int erofs_init_percpu_workers(void)
 321{
 322	struct kthread_worker *worker;
 323	unsigned int cpu;
 324
 325	z_erofs_pcpu_workers = kcalloc(num_possible_cpus(),
 326			sizeof(struct kthread_worker *), GFP_ATOMIC);
 327	if (!z_erofs_pcpu_workers)
 328		return -ENOMEM;
 329
 330	for_each_online_cpu(cpu) {	/* could miss cpu{off,on}line? */
 331		worker = erofs_init_percpu_worker(cpu);
 332		if (!IS_ERR(worker))
 333			rcu_assign_pointer(z_erofs_pcpu_workers[cpu], worker);
 334	}
 335	return 0;
 336}
 337
 338#ifdef CONFIG_HOTPLUG_CPU
 339static DEFINE_SPINLOCK(z_erofs_pcpu_worker_lock);
 340static enum cpuhp_state erofs_cpuhp_state;
 341
 342static int erofs_cpu_online(unsigned int cpu)
 343{
 344	struct kthread_worker *worker, *old;
 345
 346	worker = erofs_init_percpu_worker(cpu);
 347	if (IS_ERR(worker))
 348		return PTR_ERR(worker);
 349
 350	spin_lock(&z_erofs_pcpu_worker_lock);
 351	old = rcu_dereference_protected(z_erofs_pcpu_workers[cpu],
 352			lockdep_is_held(&z_erofs_pcpu_worker_lock));
 353	if (!old)
 354		rcu_assign_pointer(z_erofs_pcpu_workers[cpu], worker);
 355	spin_unlock(&z_erofs_pcpu_worker_lock);
 356	if (old)
 357		kthread_destroy_worker(worker);
 358	return 0;
 359}
 360
 361static int erofs_cpu_offline(unsigned int cpu)
 362{
 363	struct kthread_worker *worker;
 364
 365	spin_lock(&z_erofs_pcpu_worker_lock);
 366	worker = rcu_dereference_protected(z_erofs_pcpu_workers[cpu],
 367			lockdep_is_held(&z_erofs_pcpu_worker_lock));
 368	rcu_assign_pointer(z_erofs_pcpu_workers[cpu], NULL);
 369	spin_unlock(&z_erofs_pcpu_worker_lock);
 370
 371	synchronize_rcu();
 372	if (worker)
 373		kthread_destroy_worker(worker);
 374	return 0;
 375}
 376
 377static int erofs_cpu_hotplug_init(void)
 378{
 379	int state;
 380
 381	state = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
 382			"fs/erofs:online", erofs_cpu_online, erofs_cpu_offline);
 383	if (state < 0)
 384		return state;
 385
 386	erofs_cpuhp_state = state;
 387	return 0;
 388}
 389
 390static void erofs_cpu_hotplug_destroy(void)
 391{
 392	if (erofs_cpuhp_state)
 393		cpuhp_remove_state_nocalls(erofs_cpuhp_state);
 394}
 395#else /* !CONFIG_HOTPLUG_CPU  */
 396static inline int erofs_cpu_hotplug_init(void) { return 0; }
 397static inline void erofs_cpu_hotplug_destroy(void) {}
 398#endif/* CONFIG_HOTPLUG_CPU */
 399static int z_erofs_init_pcpu_workers(struct super_block *sb)
 400{
 401	int err;
 402
 403	if (atomic_xchg(&erofs_percpu_workers_initialized, 1))
 404		return 0;
 405
 406	err = erofs_init_percpu_workers();
 407	if (err) {
 408		erofs_err(sb, "per-cpu workers: failed to allocate.");
 409		goto err_init_percpu_workers;
 410	}
 411
 412	err = erofs_cpu_hotplug_init();
 413	if (err < 0) {
 414		erofs_err(sb, "per-cpu workers: failed CPU hotplug init.");
 415		goto err_cpuhp_init;
 416	}
 417	erofs_info(sb, "initialized per-cpu workers successfully.");
 418	return err;
 419
 420err_cpuhp_init:
 421	erofs_destroy_percpu_workers();
 422err_init_percpu_workers:
 423	atomic_set(&erofs_percpu_workers_initialized, 0);
 424	return err;
 425}
 426
 427static void z_erofs_destroy_pcpu_workers(void)
 428{
 429	if (!atomic_xchg(&erofs_percpu_workers_initialized, 0))
 430		return;
 431	erofs_cpu_hotplug_destroy();
 432	erofs_destroy_percpu_workers();
 433}
 434#else /* !CONFIG_EROFS_FS_PCPU_KTHREAD */
 435static inline int z_erofs_init_pcpu_workers(struct super_block *sb) { return 0; }
 436static inline void z_erofs_destroy_pcpu_workers(void) {}
 437#endif/* CONFIG_EROFS_FS_PCPU_KTHREAD */
 438
 439void z_erofs_exit_subsystem(void)
 440{
 441	z_erofs_destroy_pcpu_workers();
 442	destroy_workqueue(z_erofs_workqueue);
 443	z_erofs_destroy_pcluster_pool();
 444	z_erofs_crypto_disable_all_engines();
 445	z_erofs_exit_decompressor();
 446}
 447
 448int __init z_erofs_init_subsystem(void)
 449{
 450	int err = z_erofs_init_decompressor();
 451
 452	if (err)
 453		goto err_decompressor;
 454
 455	err = z_erofs_create_pcluster_pool();
 456	if (err)
 457		goto err_pcluster_pool;
 458
 459	z_erofs_workqueue = alloc_workqueue("erofs_worker",
 460			WQ_UNBOUND | WQ_HIGHPRI, num_possible_cpus());
 461	if (!z_erofs_workqueue) {
 462		err = -ENOMEM;
 463		goto err_workqueue_init;
 464	}
 465
 466	return err;
 467
 468err_workqueue_init:
 469	z_erofs_destroy_pcluster_pool();
 470err_pcluster_pool:
 471	z_erofs_exit_decompressor();
 472err_decompressor:
 473	return err;
 474}
 475
 476enum z_erofs_pclustermode {
 477	/* It has previously been linked into another processing chain */
 478	Z_EROFS_PCLUSTER_INFLIGHT,
 479	/*
 480	 * A weaker form of Z_EROFS_PCLUSTER_FOLLOWED; the difference is that it
 481	 * may be dispatched to the bypass queue later due to uptodated managed
 482	 * folios.  All file-backed folios related to this pcluster cannot be
 483	 * reused for in-place I/O (or bvpage) since the pcluster may be decoded
 484	 * in a separate queue (and thus out of order).
 485	 */
 486	Z_EROFS_PCLUSTER_FOLLOWED_NOINPLACE,
 487	/*
 488	 * The pcluster has just been linked to our processing chain.
 489	 * File-backed folios (except for the head page) related to it can be
 490	 * used for in-place I/O (or bvpage).
 491	 */
 492	Z_EROFS_PCLUSTER_FOLLOWED,
 493};
 494
 495struct z_erofs_frontend {
 496	struct inode *const inode;
 497	struct erofs_map_blocks map;
 498	struct z_erofs_bvec_iter biter;
 499
 500	struct page *pagepool;
 501	struct page *candidate_bvpage;
 502	struct z_erofs_pcluster *pcl, *head;
 503	enum z_erofs_pclustermode mode;
 504
 505	erofs_off_t headoffset;
 506
 507	/* a pointer used to pick up inplace I/O pages */
 508	unsigned int icur;
 509};
 510
 511#define Z_EROFS_DEFINE_FRONTEND(fe, i, ho) struct z_erofs_frontend fe = { \
 512	.inode = i, .head = Z_EROFS_PCLUSTER_TAIL, \
 513	.mode = Z_EROFS_PCLUSTER_FOLLOWED, .headoffset = ho }
 514
 515static bool z_erofs_should_alloc_cache(struct z_erofs_frontend *fe)
 516{
 517	unsigned int cachestrategy = EROFS_I_SB(fe->inode)->opt.cache_strategy;
 518
 519	if (cachestrategy <= EROFS_ZIP_CACHE_DISABLED)
 520		return false;
 521
 522	if (!(fe->map.m_flags & EROFS_MAP_FULL_MAPPED))
 523		return true;
 524
 525	if (cachestrategy >= EROFS_ZIP_CACHE_READAROUND &&
 526	    fe->map.m_la < fe->headoffset)
 527		return true;
 528
 529	return false;
 530}
 531
 532static void z_erofs_bind_cache(struct z_erofs_frontend *fe)
 533{
 534	struct address_space *mc = MNGD_MAPPING(EROFS_I_SB(fe->inode));
 535	struct z_erofs_pcluster *pcl = fe->pcl;
 536	unsigned int pclusterpages = z_erofs_pclusterpages(pcl);
 537	bool shouldalloc = z_erofs_should_alloc_cache(fe);
 538	pgoff_t poff = pcl->pos >> PAGE_SHIFT;
 539	bool may_bypass = true;
 540	/* Optimistic allocation, as in-place I/O can be used as a fallback */
 541	gfp_t gfp = (mapping_gfp_mask(mc) & ~__GFP_DIRECT_RECLAIM) |
 542			__GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
 543	struct folio *folio, *newfolio;
 544	unsigned int i;
 545
 546	if (i_blocksize(fe->inode) != PAGE_SIZE ||
 547	    fe->mode < Z_EROFS_PCLUSTER_FOLLOWED)
 548		return;
 549
 550	for (i = 0; i < pclusterpages; ++i) {
 551		/* Inaccurate check w/o locking to avoid unneeded lookups */
 552		if (READ_ONCE(pcl->compressed_bvecs[i].page))
 553			continue;
 554
 555		folio = filemap_get_folio(mc, poff + i);
 556		if (IS_ERR(folio)) {
 557			may_bypass = false;
 558			if (!shouldalloc)
 559				continue;
 560
 561			/*
 562			 * Allocate a managed folio for cached I/O, or it may be
 563			 * then filled with a file-backed folio for in-place I/O
 564			 */
 565			newfolio = filemap_alloc_folio(gfp, 0, NULL);
 566			if (!newfolio)
 567				continue;
 568			newfolio->private = Z_EROFS_PREALLOCATED_FOLIO;
 569			folio = NULL;
 570		}
 571		spin_lock(&pcl->lockref.lock);
 572		if (!pcl->compressed_bvecs[i].page) {
 573			pcl->compressed_bvecs[i].page =
 574				folio_page(folio ?: newfolio, 0);
 575			spin_unlock(&pcl->lockref.lock);
 576			continue;
 577		}
 578		spin_unlock(&pcl->lockref.lock);
 579		folio_put(folio ?: newfolio);
 580	}
 581
 582	/*
 583	 * Don't perform in-place I/O if all compressed pages are available in
 584	 * the managed cache, as the pcluster can be moved to the bypass queue.
 585	 */
 586	if (may_bypass)
 587		fe->mode = Z_EROFS_PCLUSTER_FOLLOWED_NOINPLACE;
 588}
 589
 590/* (erofs_shrinker) disconnect cached encoded data with pclusters */
 591static int erofs_try_to_free_all_cached_folios(struct erofs_sb_info *sbi,
 592					       struct z_erofs_pcluster *pcl)
 593{
 594	unsigned int pclusterpages = z_erofs_pclusterpages(pcl);
 595	struct folio *folio;
 596	int i;
 597
 598	DBG_BUGON(pcl->from_meta);
 599	/* Each cached folio contains one page unless bs > ps is supported */
 600	for (i = 0; i < pclusterpages; ++i) {
 601		if (pcl->compressed_bvecs[i].page) {
 602			folio = page_folio(pcl->compressed_bvecs[i].page);
 603			/* Avoid reclaiming or migrating this folio */
 604			if (!folio_trylock(folio))
 605				return -EBUSY;
 606
 607			if (!erofs_folio_is_managed(sbi, folio))
 608				continue;
 609			pcl->compressed_bvecs[i].page = NULL;
 610			folio_detach_private(folio);
 611			folio_unlock(folio);
 612		}
 613	}
 614	return 0;
 615}
 616
 617static bool z_erofs_cache_release_folio(struct folio *folio, gfp_t gfp)
 618{
 619	struct z_erofs_pcluster *pcl = folio_get_private(folio);
 620	struct z_erofs_bvec *bvec = pcl->compressed_bvecs;
 621	struct z_erofs_bvec *end = bvec + z_erofs_pclusterpages(pcl);
 622	bool ret;
 623
 624	if (!folio_test_private(folio))
 625		return true;
 626
 627	ret = false;
 628	spin_lock(&pcl->lockref.lock);
 629	if (pcl->lockref.count <= 0) {
 630		DBG_BUGON(pcl->from_meta);
 631		for (; bvec < end; ++bvec) {
 632			if (bvec->page && page_folio(bvec->page) == folio) {
 633				bvec->page = NULL;
 634				folio_detach_private(folio);
 635				ret = true;
 636				break;
 637			}
 638		}
 639	}
 640	spin_unlock(&pcl->lockref.lock);
 641	return ret;
 642}
 643
 644/*
 645 * It will be called only on inode eviction. In case that there are still some
 646 * decompression requests in progress, wait with rescheduling for a bit here.
 647 * An extra lock could be introduced instead but it seems unnecessary.
 648 */
 649static void z_erofs_cache_invalidate_folio(struct folio *folio,
 650					   size_t offset, size_t length)
 651{
 652	const size_t stop = length + offset;
 653
 654	/* Check for potential overflow in debug mode */
 655	DBG_BUGON(stop > folio_size(folio) || stop < length);
 656
 657	if (offset == 0 && stop == folio_size(folio))
 658		while (!z_erofs_cache_release_folio(folio, 0))
 659			cond_resched();
 660}
 661
 662static const struct address_space_operations z_erofs_cache_aops = {
 663	.release_folio = z_erofs_cache_release_folio,
 664	.invalidate_folio = z_erofs_cache_invalidate_folio,
 665};
 666
 667int z_erofs_init_super(struct super_block *sb)
 668{
 669	struct inode *inode;
 670	int err;
 671
 672	err = z_erofs_init_pcpu_workers(sb);
 673	if (err)
 674		return err;
 675
 676	inode = new_inode(sb);
 677	if (!inode)
 678		return -ENOMEM;
 679	set_nlink(inode, 1);
 680	inode->i_size = OFFSET_MAX;
 681	inode->i_mapping->a_ops = &z_erofs_cache_aops;
 682	mapping_set_gfp_mask(inode->i_mapping, GFP_KERNEL);
 683	EROFS_SB(sb)->managed_cache = inode;
 684	xa_init(&EROFS_SB(sb)->managed_pslots);
 685	return 0;
 686}
 687
 688/* callers must be with pcluster lock held */
 689static int z_erofs_attach_page(struct z_erofs_frontend *fe,
 690			       struct z_erofs_bvec *bvec, bool exclusive)
 691{
 692	struct z_erofs_pcluster *pcl = fe->pcl;
 693	int ret;
 694
 695	if (exclusive) {
 696		/* Inplace I/O is limited to one page for uncompressed data */
 697		if (pcl->algorithmformat < Z_EROFS_COMPRESSION_MAX ||
 698		    fe->icur <= 1) {
 699			/* Try to prioritize inplace I/O here */
 700			spin_lock(&pcl->lockref.lock);
 701			while (fe->icur > 0) {
 702				if (pcl->compressed_bvecs[--fe->icur].page)
 703					continue;
 704				pcl->compressed_bvecs[fe->icur] = *bvec;
 705				spin_unlock(&pcl->lockref.lock);
 706				return 0;
 707			}
 708			spin_unlock(&pcl->lockref.lock);
 709		}
 710
 711		/* otherwise, check if it can be used as a bvpage */
 712		if (fe->mode >= Z_EROFS_PCLUSTER_FOLLOWED &&
 713		    !fe->candidate_bvpage)
 714			fe->candidate_bvpage = bvec->page;
 715	}
 716	ret = z_erofs_bvec_enqueue(&fe->biter, bvec, &fe->candidate_bvpage,
 717				   &fe->pagepool);
 718	fe->pcl->vcnt += (ret >= 0);
 719	return ret;
 720}
 721
 722static bool z_erofs_get_pcluster(struct z_erofs_pcluster *pcl)
 723{
 724	if (lockref_get_not_zero(&pcl->lockref))
 725		return true;
 726
 727	spin_lock(&pcl->lockref.lock);
 728	if (__lockref_is_dead(&pcl->lockref)) {
 729		spin_unlock(&pcl->lockref.lock);
 730		return false;
 731	}
 732
 733	if (!pcl->lockref.count++)
 734		atomic_long_dec(&erofs_global_shrink_cnt);
 735	spin_unlock(&pcl->lockref.lock);
 736	return true;
 737}
 738
 739static int z_erofs_register_pcluster(struct z_erofs_frontend *fe)
 740{
 741	struct erofs_map_blocks *map = &fe->map;
 742	struct super_block *sb = fe->inode->i_sb;
 743	struct erofs_sb_info *sbi = EROFS_SB(sb);
 744	struct z_erofs_pcluster *pcl, *pre;
 745	unsigned int pageofs_in;
 746	int err;
 747
 748	pageofs_in = erofs_blkoff(sb, map->m_pa);
 749	pcl = z_erofs_alloc_pcluster(pageofs_in + map->m_plen);
 750	if (IS_ERR(pcl))
 751		return PTR_ERR(pcl);
 752
 753	lockref_init(&pcl->lockref); /* one ref for this request */
 754	pcl->algorithmformat = map->m_algorithmformat;
 755	pcl->pclustersize = map->m_plen;
 756	pcl->length = 0;
 757	pcl->partial = true;
 758	pcl->next = fe->head;
 759	pcl->pos = map->m_pa;
 760	pcl->pageofs_in = pageofs_in;
 761	pcl->pageofs_out = map->m_la & ~PAGE_MASK;
 762	pcl->from_meta = map->m_flags & EROFS_MAP_META;
 763	fe->mode = Z_EROFS_PCLUSTER_FOLLOWED;
 764
 765	/*
 766	 * lock all primary followed works before visible to others
 767	 * and mutex_trylock *never* fails for a new pcluster.
 768	 */
 769	mutex_init(&pcl->lock);
 770	DBG_BUGON(!mutex_trylock(&pcl->lock));
 771
 772	if (!pcl->from_meta) {
 773		while (1) {
 774			xa_lock(&sbi->managed_pslots);
 775			pre = __xa_cmpxchg(&sbi->managed_pslots, pcl->pos,
 776					   NULL, pcl, GFP_KERNEL);
 777			if (!pre || xa_is_err(pre) || z_erofs_get_pcluster(pre)) {
 778				xa_unlock(&sbi->managed_pslots);
 779				break;
 780			}
 781			/* try to legitimize the current in-tree one */
 782			xa_unlock(&sbi->managed_pslots);
 783			cond_resched();
 784		}
 785		if (xa_is_err(pre)) {
 786			err = xa_err(pre);
 787			goto err_out;
 788		} else if (pre) {
 789			fe->pcl = pre;
 790			err = -EEXIST;
 791			goto err_out;
 792		}
 793	}
 794	fe->head = fe->pcl = pcl;
 795	return 0;
 796
 797err_out:
 798	mutex_unlock(&pcl->lock);
 799	z_erofs_free_pcluster(pcl);
 800	return err;
 801}
 802
 803static int z_erofs_pcluster_begin(struct z_erofs_frontend *fe)
 804{
 805	struct erofs_map_blocks *map = &fe->map;
 806	struct super_block *sb = fe->inode->i_sb;
 807	struct z_erofs_pcluster *pcl = NULL;
 808	void *ptr = NULL;
 809	int ret;
 810
 811	DBG_BUGON(fe->pcl);
 812	/* must be Z_EROFS_PCLUSTER_TAIL or pointed to previous pcluster */
 813	DBG_BUGON(!fe->head);
 814
 815	if (map->m_flags & EROFS_MAP_META) {
 816		ret = erofs_init_metabuf(&map->buf, sb,
 817					 erofs_inode_in_metabox(fe->inode));
 818		if (ret)
 819			return ret;
 820		ptr = erofs_bread(&map->buf, map->m_pa, false);
 821		if (IS_ERR(ptr)) {
 822			erofs_err(sb, "failed to read inline data %pe @ pa %llu of nid %llu",
 823				  ptr, map->m_pa, EROFS_I(fe->inode)->nid);
 824			return PTR_ERR(ptr);
 825		}
 826		ptr = map->buf.page;
 827	} else {
 828		while (1) {
 829			rcu_read_lock();
 830			pcl = xa_load(&EROFS_SB(sb)->managed_pslots, map->m_pa);
 831			if (!pcl || z_erofs_get_pcluster(pcl)) {
 832				DBG_BUGON(pcl && map->m_pa != pcl->pos);
 833				rcu_read_unlock();
 834				break;
 835			}
 836			rcu_read_unlock();
 837		}
 838	}
 839
 840	if (pcl) {
 841		fe->pcl = pcl;
 842		ret = -EEXIST;
 843	} else {
 844		ret = z_erofs_register_pcluster(fe);
 845	}
 846
 847	if (ret == -EEXIST) {
 848		mutex_lock(&fe->pcl->lock);
 849		/* check if this pcluster hasn't been linked into any chain. */
 850		if (!cmpxchg(&fe->pcl->next, NULL, fe->head)) {
 851			/* .. so it can be attached to our submission chain */
 852			fe->head = fe->pcl;
 853			fe->mode = Z_EROFS_PCLUSTER_FOLLOWED;
 854		} else {	/* otherwise, it belongs to an inflight chain */
 855			fe->mode = Z_EROFS_PCLUSTER_INFLIGHT;
 856		}
 857	} else if (ret) {
 858		return ret;
 859	}
 860
 861	z_erofs_bvec_iter_begin(&fe->biter, &fe->pcl->bvset,
 862				Z_EROFS_INLINE_BVECS, fe->pcl->vcnt);
 863	if (!fe->pcl->from_meta) {
 864		/* bind cache first when cached decompression is preferred */
 865		z_erofs_bind_cache(fe);
 866	} else {
 867		folio_get(page_folio((struct page *)ptr));
 868		WRITE_ONCE(fe->pcl->compressed_bvecs[0].page, ptr);
 869		fe->pcl->pageofs_in = map->m_pa & ~PAGE_MASK;
 870		fe->mode = Z_EROFS_PCLUSTER_FOLLOWED_NOINPLACE;
 871	}
 872	/* file-backed inplace I/O pages are traversed in reverse order */
 873	fe->icur = z_erofs_pclusterpages(fe->pcl);
 874	return 0;
 875}
 876
 877static void z_erofs_rcu_callback(struct rcu_head *head)
 878{
 879	z_erofs_free_pcluster(container_of(head, struct z_erofs_pcluster, rcu));
 880}
 881
 882static bool __erofs_try_to_release_pcluster(struct erofs_sb_info *sbi,
 883					  struct z_erofs_pcluster *pcl)
 884{
 885	if (pcl->lockref.count)
 886		return false;
 887
 888	/*
 889	 * Note that all cached folios should be detached before deleted from
 890	 * the XArray.  Otherwise some folios could be still attached to the
 891	 * orphan old pcluster when the new one is available in the tree.
 892	 */
 893	if (erofs_try_to_free_all_cached_folios(sbi, pcl))
 894		return false;
 895
 896	/*
 897	 * It's impossible to fail after the pcluster is freezed, but in order
 898	 * to avoid some race conditions, add a DBG_BUGON to observe this.
 899	 */
 900	DBG_BUGON(__xa_erase(&sbi->managed_pslots, pcl->pos) != pcl);
 901
 902	lockref_mark_dead(&pcl->lockref);
 903	return true;
 904}
 905
 906static bool erofs_try_to_release_pcluster(struct erofs_sb_info *sbi,
 907					  struct z_erofs_pcluster *pcl)
 908{
 909	bool free;
 910
 911	spin_lock(&pcl->lockref.lock);
 912	free = __erofs_try_to_release_pcluster(sbi, pcl);
 913	spin_unlock(&pcl->lockref.lock);
 914	if (free) {
 915		atomic_long_dec(&erofs_global_shrink_cnt);
 916		call_rcu(&pcl->rcu, z_erofs_rcu_callback);
 917	}
 918	return free;
 919}
 920
 921unsigned long z_erofs_shrink_scan(struct erofs_sb_info *sbi, unsigned long nr)
 922{
 923	struct z_erofs_pcluster *pcl;
 924	unsigned long index, freed = 0;
 925
 926	xa_lock(&sbi->managed_pslots);
 927	xa_for_each(&sbi->managed_pslots, index, pcl) {
 928		/* try to shrink each valid pcluster */
 929		if (!erofs_try_to_release_pcluster(sbi, pcl))
 930			continue;
 931		xa_unlock(&sbi->managed_pslots);
 932
 933		++freed;
 934		if (!--nr)
 935			return freed;
 936		xa_lock(&sbi->managed_pslots);
 937	}
 938	xa_unlock(&sbi->managed_pslots);
 939	return freed;
 940}
 941
 942static void z_erofs_put_pcluster(struct erofs_sb_info *sbi,
 943		struct z_erofs_pcluster *pcl, bool try_free)
 944{
 945	bool free = false;
 946
 947	if (lockref_put_or_lock(&pcl->lockref))
 948		return;
 949
 950	DBG_BUGON(__lockref_is_dead(&pcl->lockref));
 951	if (!--pcl->lockref.count) {
 952		if (try_free && xa_trylock(&sbi->managed_pslots)) {
 953			free = __erofs_try_to_release_pcluster(sbi, pcl);
 954			xa_unlock(&sbi->managed_pslots);
 955		}
 956		atomic_long_add(!free, &erofs_global_shrink_cnt);
 957	}
 958	spin_unlock(&pcl->lockref.lock);
 959	if (free)
 960		call_rcu(&pcl->rcu, z_erofs_rcu_callback);
 961}
 962
 963static void z_erofs_pcluster_end(struct z_erofs_frontend *fe)
 964{
 965	struct z_erofs_pcluster *pcl = fe->pcl;
 966
 967	if (!pcl)
 968		return;
 969
 970	z_erofs_bvec_iter_end(&fe->biter);
 971	mutex_unlock(&pcl->lock);
 972
 973	if (fe->candidate_bvpage)
 974		fe->candidate_bvpage = NULL;
 975
 976	/* Drop refcount if it doesn't belong to our processing chain */
 977	if (fe->mode < Z_EROFS_PCLUSTER_FOLLOWED_NOINPLACE)
 978		z_erofs_put_pcluster(EROFS_I_SB(fe->inode), pcl, false);
 979	fe->pcl = NULL;
 980}
 981
 982static int z_erofs_read_fragment(struct super_block *sb, struct folio *folio,
 983			unsigned int cur, unsigned int end, erofs_off_t pos)
 984{
 985	struct inode *packed_inode = EROFS_SB(sb)->packed_inode;
 986	struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
 987	unsigned int cnt;
 988	u8 *src;
 989
 990	if (!packed_inode)
 991		return -EFSCORRUPTED;
 992
 993	buf.mapping = packed_inode->i_mapping;
 994	for (; cur < end; cur += cnt, pos += cnt) {
 995		cnt = min(end - cur, sb->s_blocksize - erofs_blkoff(sb, pos));
 996		src = erofs_bread(&buf, pos, true);
 997		if (IS_ERR(src)) {
 998			erofs_put_metabuf(&buf);
 999			return PTR_ERR(src);
1000		}
1001		memcpy_to_folio(folio, cur, src, cnt);
1002	}
1003	erofs_put_metabuf(&buf);
1004	return 0;
1005}
1006
1007static int z_erofs_scan_folio(struct z_erofs_frontend *f,
1008			      struct folio *folio, bool ra)
1009{
1010	struct inode *const inode = f->inode;
1011	struct erofs_map_blocks *const map = &f->map;
1012	const loff_t offset = folio_pos(folio);
1013	const unsigned int bs = i_blocksize(inode);
1014	unsigned int end = folio_size(folio), split = 0, cur, pgs;
1015	bool tight, excl;
1016	int err = 0;
1017
1018	tight = (bs == PAGE_SIZE);
1019	erofs_onlinefolio_init(folio);
1020	do {
1021		if (offset + end - 1 < map->m_la ||
1022		    offset + end - 1 >= map->m_la + map->m_llen) {
1023			z_erofs_pcluster_end(f);
1024			map->m_la = offset + end - 1;
1025			map->m_llen = 0;
1026			err = z_erofs_map_blocks_iter(inode, map, 0);
1027			if (err)
1028				break;
1029		}
1030
1031		cur = offset > map->m_la ? 0 : map->m_la - offset;
1032		pgs = round_down(cur, PAGE_SIZE);
1033		/* bump split parts first to avoid several separate cases */
1034		++split;
1035
1036		if (!(map->m_flags & EROFS_MAP_MAPPED)) {
1037			folio_zero_segment(folio, cur, end);
1038			tight = false;
1039		} else if (map->m_flags & __EROFS_MAP_FRAGMENT) {
1040			erofs_off_t fpos = offset + cur - map->m_la;
1041
1042			err = z_erofs_read_fragment(inode->i_sb, folio, cur,
1043					cur + min(map->m_llen - fpos, end - cur),
1044					EROFS_I(inode)->z_fragmentoff + fpos);
1045			if (err)
1046				break;
1047			tight = false;
1048		} else {
1049			if (!f->pcl) {
1050				err = z_erofs_pcluster_begin(f);
1051				if (err)
1052					break;
1053				f->pcl->besteffort |= !ra;
1054			}
1055
1056			pgs = round_down(end - 1, PAGE_SIZE);
1057			/*
1058			 * Ensure this partial page belongs to this submit chain
1059			 * rather than other concurrent submit chains or
1060			 * noio(bypass) chains since those chains are handled
1061			 * asynchronously thus it cannot be used for inplace I/O
1062			 * or bvpage (should be processed in the strict order.)
1063			 */
1064			tight &= (f->mode >= Z_EROFS_PCLUSTER_FOLLOWED);
1065			excl = false;
1066			if (cur <= pgs) {
1067				excl = (split <= 1) || tight;
1068				cur = pgs;
1069			}
1070
1071			err = z_erofs_attach_page(f, &((struct z_erofs_bvec) {
1072				.page = folio_page(folio, pgs >> PAGE_SHIFT),
1073				.offset = offset + pgs - map->m_la,
1074				.end = end - pgs, }), excl);
1075			if (err)
1076				break;
1077
1078			erofs_onlinefolio_split(folio);
1079			if (f->pcl->length < offset + end - map->m_la) {
1080				f->pcl->length = offset + end - map->m_la;
1081				f->pcl->pageofs_out = map->m_la & ~PAGE_MASK;
1082			}
1083			if ((map->m_flags & EROFS_MAP_FULL_MAPPED) &&
1084			    !(map->m_flags & EROFS_MAP_PARTIAL_REF) &&
1085			    f->pcl->length == map->m_llen)
1086				f->pcl->partial = false;
1087		}
1088		/* shorten the remaining extent to update progress */
1089		map->m_llen = offset + cur - map->m_la;
1090		map->m_flags &= ~EROFS_MAP_FULL_MAPPED;
1091		if (cur <= pgs) {
1092			split = cur < pgs;
1093			tight = (bs == PAGE_SIZE);
1094		}
1095	} while ((end = cur) > 0);
1096	erofs_onlinefolio_end(folio, err, false);
1097	return err;
1098}
1099
1100static bool z_erofs_is_sync_decompress(struct erofs_sb_info *sbi,
1101				       unsigned int readahead_pages)
1102{
1103	/* auto: enable for read_folio, disable for readahead */
1104	if ((sbi->opt.sync_decompress == EROFS_SYNC_DECOMPRESS_AUTO) &&
1105	    !readahead_pages)
1106		return true;
1107
1108	if ((sbi->opt.sync_decompress == EROFS_SYNC_DECOMPRESS_FORCE_ON) &&
1109	    (readahead_pages <= sbi->opt.max_sync_decompress_pages))
1110		return true;
1111
1112	return false;
1113}
1114
1115static bool z_erofs_page_is_invalidated(struct page *page)
1116{
1117	return !page_folio(page)->mapping && !z_erofs_is_shortlived_page(page);
1118}
1119
1120struct z_erofs_backend {
1121	struct page *onstack_pages[Z_EROFS_ONSTACK_PAGES];
1122	struct super_block *sb;
1123	struct z_erofs_pcluster *pcl;
1124	/* pages with the longest decompressed length for deduplication */
1125	struct page **decompressed_pages;
1126	/* pages to keep the compressed data */
1127	struct page **compressed_pages;
1128
1129	struct list_head decompressed_secondary_bvecs;
1130	struct page **pagepool;
1131	unsigned int onstack_used, nr_pages;
1132	/* indicate if temporary copies should be preserved for later use */
1133	bool keepxcpy;
1134};
1135
1136struct z_erofs_bvec_item {
1137	struct z_erofs_bvec bvec;
1138	struct list_head list;
1139};
1140
1141static void z_erofs_do_decompressed_bvec(struct z_erofs_backend *be,
1142					 struct z_erofs_bvec *bvec)
1143{
1144	int poff = bvec->offset + be->pcl->pageofs_out;
1145	struct z_erofs_bvec_item *item;
1146	struct page **page;
1147
1148	if (!(poff & ~PAGE_MASK) && (bvec->end == PAGE_SIZE ||
1149			bvec->offset + bvec->end == be->pcl->length)) {
1150		DBG_BUGON((poff >> PAGE_SHIFT) >= be->nr_pages);
1151		page = be->decompressed_pages + (poff >> PAGE_SHIFT);
1152		if (!*page) {
1153			*page = bvec->page;
1154			return;
1155		}
1156	} else {
1157		be->keepxcpy = true;
1158	}
1159
1160	/* (cold path) one pcluster is requested multiple times */
1161	item = kmalloc(sizeof(*item), GFP_KERNEL | __GFP_NOFAIL);
1162	item->bvec = *bvec;
1163	list_add(&item->list, &be->decompressed_secondary_bvecs);
1164}
1165
1166static void z_erofs_fill_other_copies(struct z_erofs_backend *be, int err)
1167{
1168	unsigned int off0 = be->pcl->pageofs_out;
1169	struct list_head *p, *n;
1170
1171	list_for_each_safe(p, n, &be->decompressed_secondary_bvecs) {
1172		struct z_erofs_bvec_item *bvi;
1173		unsigned int end, cur;
1174		void *dst, *src;
1175
1176		bvi = container_of(p, struct z_erofs_bvec_item, list);
1177		cur = bvi->bvec.offset < 0 ? -bvi->bvec.offset : 0;
1178		end = min_t(unsigned int, be->pcl->length - bvi->bvec.offset,
1179			    bvi->bvec.end);
1180		dst = kmap_local_page(bvi->bvec.page);
1181		while (cur < end) {
1182			unsigned int pgnr, scur, len;
1183
1184			pgnr = (bvi->bvec.offset + cur + off0) >> PAGE_SHIFT;
1185			DBG_BUGON(pgnr >= be->nr_pages);
1186
1187			scur = bvi->bvec.offset + cur -
1188					((pgnr << PAGE_SHIFT) - off0);
1189			len = min_t(unsigned int, end - cur, PAGE_SIZE - scur);
1190			if (!be->decompressed_pages[pgnr]) {
1191				err = -EFSCORRUPTED;
1192				cur += len;
1193				continue;
1194			}
1195			src = kmap_local_page(be->decompressed_pages[pgnr]);
1196			memcpy(dst + cur, src + scur, len);
1197			kunmap_local(src);
1198			cur += len;
1199		}
1200		kunmap_local(dst);
1201		erofs_onlinefolio_end(page_folio(bvi->bvec.page), err, true);
1202		list_del(p);
1203		kfree(bvi);
1204	}
1205}
1206
1207static void z_erofs_parse_out_bvecs(struct z_erofs_backend *be)
1208{
1209	struct z_erofs_pcluster *pcl = be->pcl;
1210	struct z_erofs_bvec_iter biter;
1211	struct page *old_bvpage;
1212	int i;
1213
1214	z_erofs_bvec_iter_begin(&biter, &pcl->bvset, Z_EROFS_INLINE_BVECS, 0);
1215	for (i = 0; i < pcl->vcnt; ++i) {
1216		struct z_erofs_bvec bvec;
1217
1218		z_erofs_bvec_dequeue(&biter, &bvec, &old_bvpage);
1219
1220		if (old_bvpage)
1221			z_erofs_put_shortlivedpage(be->pagepool, old_bvpage);
1222
1223		DBG_BUGON(z_erofs_page_is_invalidated(bvec.page));
1224		z_erofs_do_decompressed_bvec(be, &bvec);
1225	}
1226
1227	old_bvpage = z_erofs_bvec_iter_end(&biter);
1228	if (old_bvpage)
1229		z_erofs_put_shortlivedpage(be->pagepool, old_bvpage);
1230}
1231
1232static int z_erofs_parse_in_bvecs(struct z_erofs_backend *be, bool *overlapped)
1233{
1234	struct z_erofs_pcluster *pcl = be->pcl;
1235	unsigned int pclusterpages = z_erofs_pclusterpages(pcl);
1236	int i, err = 0;
1237
1238	*overlapped = false;
1239	for (i = 0; i < pclusterpages; ++i) {
1240		struct z_erofs_bvec *bvec = &pcl->compressed_bvecs[i];
1241		struct page *page = bvec->page;
1242
1243		/* compressed data ought to be valid when decompressing */
1244		if (IS_ERR(page) || !page) {
1245			bvec->page = NULL;	/* clear the failure reason */
1246			err = page ? PTR_ERR(page) : -EIO;
1247			continue;
1248		}
1249		be->compressed_pages[i] = page;
1250
1251		if (pcl->from_meta ||
1252		    erofs_folio_is_managed(EROFS_SB(be->sb), page_folio(page))) {
1253			if (!PageUptodate(page))
1254				err = -EIO;
1255			continue;
1256		}
1257
1258		DBG_BUGON(z_erofs_page_is_invalidated(page));
1259		if (z_erofs_is_shortlived_page(page))
1260			continue;
1261		z_erofs_do_decompressed_bvec(be, bvec);
1262		*overlapped = true;
1263	}
1264	return err;
1265}
1266
1267static int z_erofs_decompress_pcluster(struct z_erofs_backend *be, bool eio)
1268{
1269	struct erofs_sb_info *const sbi = EROFS_SB(be->sb);
1270	struct z_erofs_pcluster *pcl = be->pcl;
1271	unsigned int pclusterpages = z_erofs_pclusterpages(pcl);
1272	const struct z_erofs_decompressor *alg =
1273				z_erofs_decomp[pcl->algorithmformat];
1274	bool try_free = true;
1275	int i, j, jtop, err2, err = eio ? -EIO : 0;
1276	struct page *page;
1277	bool overlapped;
1278	const char *reason;
1279
1280	mutex_lock(&pcl->lock);
1281	be->nr_pages = PAGE_ALIGN(pcl->length + pcl->pageofs_out) >> PAGE_SHIFT;
1282
1283	/* allocate (de)compressed page arrays if cannot be kept on stack */
1284	be->decompressed_pages = NULL;
1285	be->compressed_pages = NULL;
1286	be->onstack_used = 0;
1287	if (be->nr_pages <= Z_EROFS_ONSTACK_PAGES) {
1288		be->decompressed_pages = be->onstack_pages;
1289		be->onstack_used = be->nr_pages;
1290		memset(be->decompressed_pages, 0,
1291		       sizeof(struct page *) * be->nr_pages);
1292	}
1293
1294	if (pclusterpages + be->onstack_used <= Z_EROFS_ONSTACK_PAGES)
1295		be->compressed_pages = be->onstack_pages + be->onstack_used;
1296
1297	if (!be->decompressed_pages)
1298		be->decompressed_pages =
1299			kvcalloc(be->nr_pages, sizeof(struct page *),
1300				 GFP_KERNEL | __GFP_NOFAIL);
1301	if (!be->compressed_pages)
1302		be->compressed_pages =
1303			kvcalloc(pclusterpages, sizeof(struct page *),
1304				 GFP_KERNEL | __GFP_NOFAIL);
1305
1306	z_erofs_parse_out_bvecs(be);
1307	err2 = z_erofs_parse_in_bvecs(be, &overlapped);
1308	if (err2)
1309		err = err2;
1310	if (!err) {
1311		reason = alg->decompress(&(struct z_erofs_decompress_req) {
1312					.sb = be->sb,
1313					.in = be->compressed_pages,
1314					.out = be->decompressed_pages,
1315					.inpages = pclusterpages,
1316					.outpages = be->nr_pages,
1317					.pageofs_in = pcl->pageofs_in,
1318					.pageofs_out = pcl->pageofs_out,
1319					.inputsize = pcl->pclustersize,
1320					.outputsize = pcl->length,
1321					.alg = pcl->algorithmformat,
1322					.inplace_io = overlapped,
1323					.partial_decoding = pcl->partial,
1324					.fillgaps = be->keepxcpy,
1325					.gfp = pcl->besteffort ? GFP_KERNEL :
1326						GFP_NOWAIT | __GFP_NORETRY
1327				 }, be->pagepool);
1328		if (IS_ERR(reason)) {
1329			if (pcl->besteffort || reason != ERR_PTR(-ENOMEM))
1330				erofs_err(be->sb, "failed to decompress (%s) %pe @ pa %llu size %u => %u",
1331					  alg->name, reason, pcl->pos,
1332					  pcl->pclustersize, pcl->length);
1333			err = PTR_ERR(reason);
1334		} else if (unlikely(reason)) {
1335			erofs_err(be->sb, "failed to decompress (%s) %s @ pa %llu size %u => %u",
1336				  alg->name, reason, pcl->pos,
1337				  pcl->pclustersize, pcl->length);
1338			err = -EFSCORRUPTED;
1339		}
1340	}
1341
1342	/* must handle all compressed pages before actual file pages */
1343	if (pcl->from_meta) {
1344		folio_put(page_folio(pcl->compressed_bvecs[0].page));
1345		WRITE_ONCE(pcl->compressed_bvecs[0].page, NULL);
1346	} else {
1347		/* managed folios are still left in compressed_bvecs[] */
1348		for (i = 0; i < pclusterpages; ++i) {
1349			page = be->compressed_pages[i];
1350			if (!page)
1351				continue;
1352			if (erofs_folio_is_managed(sbi, page_folio(page))) {
1353				try_free = false;
1354				continue;
1355			}
1356			(void)z_erofs_put_shortlivedpage(be->pagepool, page);
1357			WRITE_ONCE(pcl->compressed_bvecs[i].page, NULL);
1358		}
1359	}
1360	if (be->compressed_pages < be->onstack_pages ||
1361	    be->compressed_pages >= be->onstack_pages + Z_EROFS_ONSTACK_PAGES)
1362		kvfree(be->compressed_pages);
1363
1364	jtop = 0;
1365	z_erofs_fill_other_copies(be, err);
1366	for (i = 0; i < be->nr_pages; ++i) {
1367		page = be->decompressed_pages[i];
1368		if (!page)
1369			continue;
1370
1371		DBG_BUGON(z_erofs_page_is_invalidated(page));
1372		if (!z_erofs_is_shortlived_page(page)) {
1373			erofs_onlinefolio_end(page_folio(page), err, true);
1374			continue;
1375		}
1376		if (pcl->algorithmformat != Z_EROFS_COMPRESSION_LZ4) {
1377			erofs_pagepool_add(be->pagepool, page);
1378			continue;
1379		}
1380		for (j = 0; j < jtop && be->decompressed_pages[j] != page; ++j)
1381			;
1382		if (j >= jtop)	/* this bounce page is newly detected */
1383			be->decompressed_pages[jtop++] = page;
1384	}
1385	while (jtop)
1386		erofs_pagepool_add(be->pagepool,
1387				   be->decompressed_pages[--jtop]);
1388	if (be->decompressed_pages != be->onstack_pages)
1389		kvfree(be->decompressed_pages);
1390
1391	pcl->length = 0;
1392	pcl->partial = true;
1393	pcl->besteffort = false;
1394	pcl->bvset.nextpage = NULL;
1395	pcl->vcnt = 0;
1396
1397	/* pcluster lock MUST be taken before the following line */
1398	WRITE_ONCE(pcl->next, NULL);
1399	mutex_unlock(&pcl->lock);
1400
1401	if (pcl->from_meta)
1402		z_erofs_free_pcluster(pcl);
1403	else
1404		z_erofs_put_pcluster(sbi, pcl, try_free);
1405	return err;
1406}
1407
1408static int z_erofs_decompress_queue(const struct z_erofs_decompressqueue *io,
1409				    struct page **pagepool)
1410{
1411	struct z_erofs_backend be = {
1412		.sb = io->sb,
1413		.pagepool = pagepool,
1414		.decompressed_secondary_bvecs =
1415			LIST_HEAD_INIT(be.decompressed_secondary_bvecs),
1416		.pcl = io->head,
1417	};
1418	struct z_erofs_pcluster *next;
1419	int err = 0;
1420
1421	for (; be.pcl != Z_EROFS_PCLUSTER_TAIL; be.pcl = next) {
1422		DBG_BUGON(!be.pcl);
1423		next = READ_ONCE(be.pcl->next);
1424		err = z_erofs_decompress_pcluster(&be, io->eio) ?: err;
1425	}
1426	return err;
1427}
1428
1429static void z_erofs_decompressqueue_work(struct work_struct *work)
1430{
1431	struct z_erofs_decompressqueue *bgq =
1432		container_of(work, struct z_erofs_decompressqueue, u.work);
1433	struct page *pagepool = NULL;
1434
1435	DBG_BUGON(bgq->head == Z_EROFS_PCLUSTER_TAIL);
1436	z_erofs_decompress_queue(bgq, &pagepool);
1437	erofs_release_pages(&pagepool);
1438	kvfree(bgq);
1439}
1440
1441#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD
1442static void z_erofs_decompressqueue_kthread_work(struct kthread_work *work)
1443{
1444	z_erofs_decompressqueue_work((struct work_struct *)work);
1445}
1446#endif
1447
1448/* Use (kthread_)work in atomic contexts to minimize scheduling overhead */
1449static inline bool z_erofs_in_atomic(void)
1450{
1451	if (IS_ENABLED(CONFIG_PREEMPTION) && rcu_preempt_depth())
1452		return true;
1453	if (!IS_ENABLED(CONFIG_PREEMPT_COUNT))
1454		return true;
1455	return !preemptible();
1456}
1457
1458static void z_erofs_decompress_kickoff(struct z_erofs_decompressqueue *io,
1459				       int bios)
1460{
1461	struct erofs_sb_info *const sbi = EROFS_SB(io->sb);
1462	int gfp_flag;
1463
1464	/* wake up the caller thread for sync decompression */
1465	if (io->sync) {
1466		if (!atomic_add_return(bios, &io->pending_bios))
1467			complete(&io->u.done);
1468		return;
1469	}
1470
1471	if (atomic_add_return(bios, &io->pending_bios))
1472		return;
1473	if (z_erofs_in_atomic()) {
1474#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD
1475		struct kthread_worker *worker;
1476
1477		rcu_read_lock();
1478		worker = rcu_dereference(
1479				z_erofs_pcpu_workers[raw_smp_processor_id()]);
1480		if (!worker) {
1481			INIT_WORK(&io->u.work, z_erofs_decompressqueue_work);
1482			queue_work(z_erofs_workqueue, &io->u.work);
1483		} else {
1484			kthread_queue_work(worker, &io->u.kthread_work);
1485		}
1486		rcu_read_unlock();
1487#else
1488		queue_work(z_erofs_workqueue, &io->u.work);
1489#endif
1490		/* enable sync decompression for readahead */
1491		if (sbi->opt.sync_decompress == EROFS_SYNC_DECOMPRESS_AUTO)
1492			sbi->opt.sync_decompress = EROFS_SYNC_DECOMPRESS_FORCE_ON;
1493		return;
1494	}
1495	gfp_flag = memalloc_noio_save();
1496	z_erofs_decompressqueue_work(&io->u.work);
1497	memalloc_noio_restore(gfp_flag);
1498}
1499
1500static void z_erofs_fill_bio_vec(struct bio_vec *bvec,
1501				 struct z_erofs_frontend *f,
1502				 struct z_erofs_pcluster *pcl,
1503				 unsigned int nr,
1504				 struct address_space *mc)
1505{
1506	gfp_t gfp = mapping_gfp_mask(mc);
1507	bool tocache = false;
1508	struct z_erofs_bvec zbv;
1509	struct address_space *mapping;
1510	struct folio *folio;
1511	struct page *page;
1512	int bs = i_blocksize(f->inode);
1513
1514	/* Except for inplace folios, the entire folio can be used for I/Os */
1515	bvec->bv_offset = 0;
1516	bvec->bv_len = PAGE_SIZE;
1517repeat:
1518	spin_lock(&pcl->lockref.lock);
1519	zbv = pcl->compressed_bvecs[nr];
1520	spin_unlock(&pcl->lockref.lock);
1521	if (!zbv.page)
1522		goto out_allocfolio;
1523
1524	bvec->bv_page = zbv.page;
1525	DBG_BUGON(z_erofs_is_shortlived_page(bvec->bv_page));
1526
1527	folio = page_folio(zbv.page);
1528	/* For preallocated managed folios, add them to page cache here */
1529	if (folio->private == Z_EROFS_PREALLOCATED_FOLIO) {
1530		tocache = true;
1531		goto out_tocache;
1532	}
1533
1534	mapping = READ_ONCE(folio->mapping);
1535	/*
1536	 * File-backed folios for inplace I/Os are all locked steady,
1537	 * therefore it is impossible for `mapping` to be NULL.
1538	 */
1539	if (mapping && mapping != mc) {
1540		if (zbv.offset < 0)
1541			bvec->bv_offset = round_up(-zbv.offset, bs);
1542		bvec->bv_len = round_up(zbv.end, bs) - bvec->bv_offset;
1543		return;
1544	}
1545
1546	folio_lock(folio);
1547	if (likely(folio->mapping == mc)) {
1548		/*
1549		 * The cached folio is still in managed cache but without
1550		 * a valid `->private` pcluster hint.  Let's reconnect them.
1551		 */
1552		if (!folio_test_private(folio)) {
1553			folio_attach_private(folio, pcl);
1554			/* compressed_bvecs[] already takes a ref before */
1555			folio_put(folio);
1556		}
1557		if (likely(folio->private == pcl))  {
1558			/* don't submit cache I/Os again if already uptodate */
1559			if (folio_test_uptodate(folio)) {
1560				folio_unlock(folio);
1561				bvec->bv_page = NULL;
1562			}
1563			return;
1564		}
1565		/*
1566		 * Already linked with another pcluster, which only appears in
1567		 * crafted images by fuzzers for now.  But handle this anyway.
1568		 */
1569		tocache = false;	/* use temporary short-lived pages */
1570	} else {
1571		DBG_BUGON(1); /* referenced managed folios can't be truncated */
1572		tocache = true;
1573	}
1574	folio_unlock(folio);
1575	folio_put(folio);
1576out_allocfolio:
1577	page = __erofs_allocpage(&f->pagepool, gfp, true);
1578	spin_lock(&pcl->lockref.lock);
1579	if (unlikely(pcl->compressed_bvecs[nr].page != zbv.page)) {
1580		if (page)
1581			erofs_pagepool_add(&f->pagepool, page);
1582		spin_unlock(&pcl->lockref.lock);
1583		cond_resched();
1584		goto repeat;
1585	}
1586	pcl->compressed_bvecs[nr].page = page ? page : ERR_PTR(-ENOMEM);
1587	spin_unlock(&pcl->lockref.lock);
1588	bvec->bv_page = page;
1589	if (!page)
1590		return;
1591	folio = page_folio(page);
1592out_tocache:
1593	if (!tocache || bs != PAGE_SIZE ||
1594	    filemap_add_folio(mc, folio, (pcl->pos >> PAGE_SHIFT) + nr, gfp)) {
1595		/* turn into a temporary shortlived folio (1 ref) */
1596		folio->private = (void *)Z_EROFS_SHORTLIVED_PAGE;
1597		return;
1598	}
1599	folio_attach_private(folio, pcl);
1600	/* drop a refcount added by allocpage (then 2 refs in total here) */
1601	folio_put(folio);
1602}
1603
1604static struct z_erofs_decompressqueue *jobqueue_init(struct super_block *sb,
1605			      struct z_erofs_decompressqueue *fgq, bool *fg)
1606{
1607	struct z_erofs_decompressqueue *q;
1608
1609	if (fg && !*fg) {
1610		q = kvzalloc(sizeof(*q), GFP_KERNEL | __GFP_NOWARN);
1611		if (!q) {
1612			*fg = true;
1613			goto fg_out;
1614		}
1615#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD
1616		kthread_init_work(&q->u.kthread_work,
1617				  z_erofs_decompressqueue_kthread_work);
1618#else
1619		INIT_WORK(&q->u.work, z_erofs_decompressqueue_work);
1620#endif
1621	} else {
1622fg_out:
1623		q = fgq;
1624		init_completion(&fgq->u.done);
1625		atomic_set(&fgq->pending_bios, 0);
1626		q->eio = false;
1627		q->sync = true;
1628	}
1629	q->sb = sb;
1630	q->head = Z_EROFS_PCLUSTER_TAIL;
1631	return q;
1632}
1633
1634/* define decompression jobqueue types */
1635enum {
1636	JQ_BYPASS,
1637	JQ_SUBMIT,
1638	NR_JOBQUEUES,
1639};
1640
1641static void z_erofs_move_to_bypass_queue(struct z_erofs_pcluster *pcl,
1642					 struct z_erofs_pcluster *next,
1643					 struct z_erofs_pcluster **qtail[])
1644{
1645	WRITE_ONCE(pcl->next, Z_EROFS_PCLUSTER_TAIL);
1646	WRITE_ONCE(*qtail[JQ_SUBMIT], next);
1647	WRITE_ONCE(*qtail[JQ_BYPASS], pcl);
1648	qtail[JQ_BYPASS] = &pcl->next;
1649}
1650
1651static void z_erofs_endio(struct bio *bio)
1652{
1653	struct z_erofs_decompressqueue *q = bio->bi_private;
1654	blk_status_t err = bio->bi_status;
1655	struct folio_iter fi;
1656
1657	bio_for_each_folio_all(fi, bio) {
1658		struct folio *folio = fi.folio;
1659
1660		DBG_BUGON(folio_test_uptodate(folio));
1661		DBG_BUGON(z_erofs_page_is_invalidated(&folio->page));
1662		if (!erofs_folio_is_managed(EROFS_SB(q->sb), folio))
1663			continue;
1664
1665		if (!err)
1666			folio_mark_uptodate(folio);
1667		folio_unlock(folio);
1668	}
1669	if (err)
1670		q->eio = true;
1671	z_erofs_decompress_kickoff(q, -1);
1672	if (bio->bi_bdev)
1673		bio_put(bio);
1674}
1675
1676static void z_erofs_submit_queue(struct z_erofs_frontend *f,
1677				 struct z_erofs_decompressqueue *fgq,
1678				 bool *force_fg, bool readahead)
1679{
1680	struct super_block *sb = f->inode->i_sb;
1681	struct address_space *mc = MNGD_MAPPING(EROFS_SB(sb));
1682	struct z_erofs_pcluster **qtail[NR_JOBQUEUES];
1683	struct z_erofs_decompressqueue *q[NR_JOBQUEUES];
1684	struct z_erofs_pcluster *pcl, *next;
1685	/* bio is NULL initially, so no need to initialize last_{index,bdev} */
1686	erofs_off_t last_pa;
1687	unsigned int nr_bios = 0;
1688	struct bio *bio = NULL;
1689	unsigned long pflags;
1690	int memstall = 0;
1691
1692	/* No need to read from device for pclusters in the bypass queue. */
1693	q[JQ_BYPASS] = jobqueue_init(sb, fgq + JQ_BYPASS, NULL);
1694	q[JQ_SUBMIT] = jobqueue_init(sb, fgq + JQ_SUBMIT, force_fg);
1695
1696	qtail[JQ_BYPASS] = &q[JQ_BYPASS]->head;
1697	qtail[JQ_SUBMIT] = &q[JQ_SUBMIT]->head;
1698
1699	/* by default, all need io submission */
1700	q[JQ_SUBMIT]->head = next = f->head;
1701
1702	do {
1703		struct erofs_map_dev mdev;
1704		erofs_off_t cur, end;
1705		struct bio_vec bvec;
1706		unsigned int i = 0;
1707		bool bypass = true;
1708
1709		pcl = next;
1710		next = READ_ONCE(pcl->next);
1711		if (pcl->from_meta) {
1712			z_erofs_move_to_bypass_queue(pcl, next, qtail);
1713			continue;
1714		}
1715
1716		/* no device id here, thus it will always succeed */
1717		mdev = (struct erofs_map_dev) {
1718			.m_pa = round_down(pcl->pos, sb->s_blocksize),
1719		};
1720		(void)erofs_map_dev(sb, &mdev);
1721
1722		cur = mdev.m_pa;
1723		end = round_up(cur + pcl->pageofs_in + pcl->pclustersize,
1724			       sb->s_blocksize);
1725		do {
1726			bvec.bv_page = NULL;
1727			if (bio && (cur != last_pa ||
1728				    bio->bi_bdev != mdev.m_bdev)) {
1729drain_io:
1730				if (erofs_is_fileio_mode(EROFS_SB(sb)))
1731					erofs_fileio_submit_bio(bio);
1732				else if (erofs_is_fscache_mode(sb))
1733					erofs_fscache_submit_bio(bio);
1734				else
1735					submit_bio(bio);
1736
1737				if (memstall) {
1738					psi_memstall_leave(&pflags);
1739					memstall = 0;
1740				}
1741				bio = NULL;
1742			}
1743
1744			if (!bvec.bv_page) {
1745				z_erofs_fill_bio_vec(&bvec, f, pcl, i++, mc);
1746				if (!bvec.bv_page)
1747					continue;
1748				if (cur + bvec.bv_len > end)
1749					bvec.bv_len = end - cur;
1750				DBG_BUGON(bvec.bv_len < sb->s_blocksize);
1751			}
1752
1753			if (unlikely(PageWorkingset(bvec.bv_page)) &&
1754			    !memstall) {
1755				psi_memstall_enter(&pflags);
1756				memstall = 1;
1757			}
1758
1759			if (!bio) {
1760				if (erofs_is_fileio_mode(EROFS_SB(sb)))
1761					bio = erofs_fileio_bio_alloc(&mdev);
1762				else if (erofs_is_fscache_mode(sb))
1763					bio = erofs_fscache_bio_alloc(&mdev);
1764				else
1765					bio = bio_alloc(mdev.m_bdev, BIO_MAX_VECS,
1766							REQ_OP_READ, GFP_NOIO);
1767				bio->bi_end_io = z_erofs_endio;
1768				bio->bi_iter.bi_sector =
1769						(mdev.m_dif->fsoff + cur) >> 9;
1770				bio->bi_private = q[JQ_SUBMIT];
1771				if (readahead)
1772					bio->bi_opf |= REQ_RAHEAD;
1773				++nr_bios;
1774			}
1775
1776			if (!bio_add_page(bio, bvec.bv_page, bvec.bv_len,
1777					  bvec.bv_offset))
1778				goto drain_io;
1779			last_pa = cur + bvec.bv_len;
1780			bypass = false;
1781		} while ((cur += bvec.bv_len) < end);
1782
1783		if (!bypass)
1784			qtail[JQ_SUBMIT] = &pcl->next;
1785		else
1786			z_erofs_move_to_bypass_queue(pcl, next, qtail);
1787	} while (next != Z_EROFS_PCLUSTER_TAIL);
1788
1789	if (bio) {
1790		if (erofs_is_fileio_mode(EROFS_SB(sb)))
1791			erofs_fileio_submit_bio(bio);
1792		else if (erofs_is_fscache_mode(sb))
1793			erofs_fscache_submit_bio(bio);
1794		else
1795			submit_bio(bio);
1796	}
1797	if (memstall)
1798		psi_memstall_leave(&pflags);
1799
1800	/*
1801	 * although background is preferred, no one is pending for submission.
1802	 * don't issue decompression but drop it directly instead.
1803	 */
1804	if (!*force_fg && !nr_bios) {
1805		kvfree(q[JQ_SUBMIT]);
1806		return;
1807	}
1808	z_erofs_decompress_kickoff(q[JQ_SUBMIT], nr_bios);
1809}
1810
1811static int z_erofs_runqueue(struct z_erofs_frontend *f, unsigned int rapages)
1812{
1813	struct z_erofs_decompressqueue io[NR_JOBQUEUES];
1814	struct erofs_sb_info *sbi = EROFS_I_SB(f->inode);
1815	bool force_fg = z_erofs_is_sync_decompress(sbi, rapages);
1816	int err;
1817
1818	if (f->head == Z_EROFS_PCLUSTER_TAIL)
1819		return 0;
1820	z_erofs_submit_queue(f, io, &force_fg, !!rapages);
1821
1822	/* handle bypass queue (no i/o pclusters) immediately */
1823	err = z_erofs_decompress_queue(&io[JQ_BYPASS], &f->pagepool);
1824	if (!force_fg)
1825		return err;
1826
1827	/* wait until all bios are completed */
1828	wait_for_completion_io(&io[JQ_SUBMIT].u.done);
1829
1830	/* handle synchronous decompress queue in the caller context */
1831	return z_erofs_decompress_queue(&io[JQ_SUBMIT], &f->pagepool) ?: err;
1832}
1833
1834/*
1835 * Since partial uptodate is still unimplemented for now, we have to use
1836 * approximate readmore strategies as a start.
1837 */
1838static void z_erofs_pcluster_readmore(struct z_erofs_frontend *f,
1839		struct readahead_control *rac, bool backmost)
1840{
1841	struct inode *inode = f->inode;
1842	struct erofs_map_blocks *map = &f->map;
1843	erofs_off_t cur, end, headoffset = f->headoffset;
1844	int err;
1845
1846	if (backmost) {
1847		if (rac)
1848			end = headoffset + readahead_length(rac) - 1;
1849		else
1850			end = headoffset + PAGE_SIZE - 1;
1851		map->m_la = end;
1852		err = z_erofs_map_blocks_iter(inode, map,
1853					      EROFS_GET_BLOCKS_READMORE);
1854		if (err || !(map->m_flags & EROFS_MAP_ENCODED))
1855			return;
1856
1857		/* expand ra for the trailing edge if readahead */
1858		if (rac) {
1859			cur = round_up(map->m_la + map->m_llen, PAGE_SIZE);
1860			readahead_expand(rac, headoffset, cur - headoffset);
1861			return;
1862		}
1863		end = round_up(end, PAGE_SIZE);
1864	} else {
1865		end = round_up(map->m_la, PAGE_SIZE);
1866		if (!(map->m_flags & EROFS_MAP_ENCODED) || !map->m_llen)
1867			return;
1868	}
1869
1870	cur = map->m_la + map->m_llen - 1;
1871	while ((cur >= end) && (cur < i_size_read(inode))) {
1872		pgoff_t index = cur >> PAGE_SHIFT;
1873		struct folio *folio;
1874
1875		folio = erofs_grab_folio_nowait(inode->i_mapping, index);
1876		if (!IS_ERR_OR_NULL(folio)) {
1877			if (folio_test_uptodate(folio))
1878				folio_unlock(folio);
1879			else
1880				z_erofs_scan_folio(f, folio, !!rac);
1881			folio_put(folio);
1882		}
1883
1884		if (cur < PAGE_SIZE)
1885			break;
1886		cur = (index << PAGE_SHIFT) - 1;
1887	}
1888}
1889
1890static int z_erofs_read_folio(struct file *file, struct folio *folio)
1891{
1892	struct inode *const inode = folio->mapping->host;
1893	Z_EROFS_DEFINE_FRONTEND(f, inode, folio_pos(folio));
1894	int err;
1895
1896	trace_erofs_read_folio(folio, false);
1897	z_erofs_pcluster_readmore(&f, NULL, true);
1898	err = z_erofs_scan_folio(&f, folio, false);
1899	z_erofs_pcluster_readmore(&f, NULL, false);
1900	z_erofs_pcluster_end(&f);
1901
1902	/* if some pclusters are ready, need submit them anyway */
1903	err = z_erofs_runqueue(&f, 0) ?: err;
1904	if (err && err != -EINTR)
1905		erofs_err(inode->i_sb, "read error %d @ %lu of nid %llu",
1906			  err, folio->index, EROFS_I(inode)->nid);
1907
1908	erofs_put_metabuf(&f.map.buf);
1909	erofs_release_pages(&f.pagepool);
1910	return err;
1911}
1912
1913static void z_erofs_readahead(struct readahead_control *rac)
1914{
1915	struct inode *const inode = rac->mapping->host;
1916	Z_EROFS_DEFINE_FRONTEND(f, inode, readahead_pos(rac));
1917	unsigned int nrpages = readahead_count(rac);
1918	struct folio *head = NULL, *folio;
1919	int err;
1920
1921	trace_erofs_readahead(inode, readahead_index(rac), nrpages, false);
1922	z_erofs_pcluster_readmore(&f, rac, true);
1923	while ((folio = readahead_folio(rac))) {
1924		folio->private = head;
1925		head = folio;
1926	}
1927
1928	/* traverse in reverse order for best metadata I/O performance */
1929	while (head) {
1930		folio = head;
1931		head = folio_get_private(folio);
1932
1933		err = z_erofs_scan_folio(&f, folio, true);
1934		if (err && err != -EINTR)
1935			erofs_err(inode->i_sb, "readahead error at folio %lu @ nid %llu",
1936				  folio->index, EROFS_I(inode)->nid);
1937	}
1938	z_erofs_pcluster_readmore(&f, rac, false);
1939	z_erofs_pcluster_end(&f);
1940
1941	(void)z_erofs_runqueue(&f, nrpages);
1942	erofs_put_metabuf(&f.map.buf);
1943	erofs_release_pages(&f.pagepool);
1944}
1945
1946const struct address_space_operations z_erofs_aops = {
1947	.read_folio = z_erofs_read_folio,
1948	.readahead = z_erofs_readahead,
1949};