arch/arc/include/asm/cacheflush.h

31

void flush_dcache_folio(struct folio *folio);

arch/arc/mm/cache.c

705

void flush_dcache_folio(struct folio *folio)

arch/arc/mm/cache.c

707

clear_bit(PG_dc_clean, &folio->flags.f);

arch/arc/mm/cache.c

885

struct folio *src = page_folio(from);

arch/arc/mm/cache.c

886

struct folio *dst = page_folio(to);

arch/arc/mm/cache.c

901

struct folio *folio = page_folio(page);

arch/arc/mm/cache.c

903

clear_bit(PG_dc_clean, &folio->flags.f);

arch/arc/mm/tlb.c

490

struct folio *folio = page_folio(page);

arch/arc/mm/tlb.c

491

int dirty = !test_and_set_bit(PG_dc_clean, &folio->flags.f);

arch/arc/mm/tlb.c

493

unsigned long offset = offset_in_folio(folio, paddr);

arch/arc/mm/tlb.c

494

nr = folio_nr_pages(folio);

arch/arm/include/asm/cacheflush.h

296

void flush_dcache_folio(struct folio *folio);

arch/arm/include/asm/hugetlb.h

18

static inline void arch_clear_hugetlb_flags(struct folio *folio)

arch/arm/include/asm/hugetlb.h

20

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/copypage-v4mc.c

67

struct folio *src = page_folio(from);

arch/arm/mm/copypage-v6.c

72

struct folio *src = page_folio(from);

arch/arm/mm/copypage-xscale.c

87

struct folio *src = page_folio(from);

arch/arm/mm/dma-mapping.c

707

struct folio *folio = pfn_folio(paddr / PAGE_SIZE);

arch/arm/mm/dma-mapping.c

708

size_t offset = offset_in_folio(folio, paddr);

arch/arm/mm/dma-mapping.c

711

size_t sz = folio_size(folio) - offset;

arch/arm/mm/dma-mapping.c

716

set_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/dma-mapping.c

721

folio = folio_next(folio);

arch/arm/mm/fault-armv.c

192

struct folio *folio;

arch/arm/mm/fault-armv.c

204

folio = page_folio(pfn_to_page(pfn));

arch/arm/mm/fault-armv.c

205

mapping = folio_flush_mapping(folio);

arch/arm/mm/fault-armv.c

206

if (!test_and_set_bit(PG_dcache_clean, &folio->flags.f))

arch/arm/mm/fault-armv.c

207

__flush_dcache_folio(mapping, folio);

arch/arm/mm/flush.c

199

void __flush_dcache_folio(struct address_space *mapping, struct folio *folio)

arch/arm/mm/flush.c

206

if (!folio_test_highmem(folio)) {

arch/arm/mm/flush.c

207

__cpuc_flush_dcache_area(folio_address(folio),

arch/arm/mm/flush.c

208

folio_size(folio));

arch/arm/mm/flush.c

212

for (i = 0; i < folio_nr_pages(folio); i++) {

arch/arm/mm/flush.c

213

void *addr = kmap_local_folio(folio,

arch/arm/mm/flush.c

219

for (i = 0; i < folio_nr_pages(folio); i++) {

arch/arm/mm/flush.c

220

void *addr = kmap_high_get(folio_page(folio, i));

arch/arm/mm/flush.c

223

kunmap_high(folio_page(folio, i));

arch/arm/mm/flush.c

235

flush_pfn_alias(folio_pfn(folio), folio_pos(folio));

arch/arm/mm/flush.c

238

static void __flush_dcache_aliases(struct address_space *mapping, struct folio *folio)

arch/arm/mm/flush.c

250

pgoff = folio->index;

arch/arm/mm/flush.c

251

pgoff_end = pgoff + folio_nr_pages(folio) - 1;

arch/arm/mm/flush.c

267

pfn = folio_pfn(folio);

arch/arm/mm/flush.c

268

nr = folio_nr_pages(folio);

arch/arm/mm/flush.c

288

struct folio *folio;

arch/arm/mm/flush.c

298

folio = page_folio(pfn_to_page(pfn));

arch/arm/mm/flush.c

299

if (folio_test_reserved(folio))

arch/arm/mm/flush.c

303

mapping = folio_flush_mapping(folio);

arch/arm/mm/flush.c

307

if (!test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/arm/mm/flush.c

308

__flush_dcache_folio(mapping, folio);

arch/arm/mm/flush.c

309

set_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/flush.c

336

void flush_dcache_folio(struct folio *folio)

arch/arm/mm/flush.c

344

if (is_zero_pfn(folio_pfn(folio)))

arch/arm/mm/flush.c

348

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/arm/mm/flush.c

349

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/flush.c

353

mapping = folio_flush_mapping(folio);

arch/arm/mm/flush.c

356

mapping && !folio_mapped(folio))

arch/arm/mm/flush.c

357

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/flush.c

359

__flush_dcache_folio(mapping, folio);

arch/arm/mm/flush.c

361

__flush_dcache_aliases(mapping, folio);

arch/arm/mm/flush.c

364

set_bit(PG_dcache_clean, &folio->flags.f);

arch/arm/mm/mm.h

48

void __flush_dcache_folio(struct address_space *mapping, struct folio *folio);

arch/arm/mm/nommu.c

165

void flush_dcache_folio(struct folio *folio)

arch/arm/mm/nommu.c

167

__cpuc_flush_dcache_area(folio_address(folio), folio_size(folio));

arch/arm64/include/asm/cacheflush.h

132

void flush_dcache_folio(struct folio *);

arch/arm64/include/asm/hugetlb.h

22

static inline void arch_clear_hugetlb_flags(struct folio *folio)

arch/arm64/include/asm/hugetlb.h

24

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/arm64/include/asm/hugetlb.h

28

clear_bit(PG_mte_tagged, &folio->flags.f);

arch/arm64/include/asm/hugetlb.h

29

clear_bit(PG_mte_lock, &folio->flags.f);

arch/arm64/include/asm/mte.h

167

static inline void folio_set_hugetlb_mte_tagged(struct folio *folio)

arch/arm64/include/asm/mte.h

169

VM_WARN_ON_ONCE(!folio_test_hugetlb(folio));

arch/arm64/include/asm/mte.h

176

set_bit(PG_mte_tagged, &folio->flags.f);

arch/arm64/include/asm/mte.h

180

static inline bool folio_test_hugetlb_mte_tagged(struct folio *folio)

arch/arm64/include/asm/mte.h

182

bool ret = test_bit(PG_mte_tagged, &folio->flags.f);

arch/arm64/include/asm/mte.h

184

VM_WARN_ON_ONCE(!folio_test_hugetlb(folio));

arch/arm64/include/asm/mte.h

195

static inline bool folio_try_hugetlb_mte_tagging(struct folio *folio)

arch/arm64/include/asm/mte.h

197

VM_WARN_ON_ONCE(!folio_test_hugetlb(folio));

arch/arm64/include/asm/mte.h

199

if (!test_and_set_bit(PG_mte_lock, &folio->flags.f))

arch/arm64/include/asm/mte.h

207

smp_cond_load_acquire(&folio->flags.f, VAL & (1UL << PG_mte_tagged));

arch/arm64/include/asm/mte.h

212

static inline void folio_set_hugetlb_mte_tagged(struct folio *folio)

arch/arm64/include/asm/mte.h

216

static inline bool folio_test_hugetlb_mte_tagged(struct folio *folio)

arch/arm64/include/asm/mte.h

221

static inline bool folio_try_hugetlb_mte_tagging(struct folio *folio)

arch/arm64/include/asm/page.h

32

struct folio *vma_alloc_zeroed_movable_folio(struct vm_area_struct *vma,

arch/arm64/include/asm/pgtable.h

1551

extern int arch_prepare_to_swap(struct folio *folio);

arch/arm64/include/asm/pgtable.h

1567

extern void arch_swap_restore(swp_entry_t entry, struct folio *folio);

arch/arm64/kernel/hibernate.c

269

struct folio *folio;

arch/arm64/kernel/hibernate.c

273

folio = page_folio(page);

arch/arm64/kernel/hibernate.c

275

if (folio_test_hugetlb(folio) &&

arch/arm64/kernel/hibernate.c

276

!folio_test_hugetlb_mte_tagged(folio))

arch/arm64/kernel/mte.c

42

struct folio *folio = page_folio(page);

arch/arm64/kernel/mte.c

45

if (folio_test_hugetlb(folio)) {

arch/arm64/kernel/mte.c

46

unsigned long nr = folio_nr_pages(folio);

arch/arm64/kernel/mte.c

464

struct folio *folio;

arch/arm64/kernel/mte.c

484

folio = page_folio(page);

arch/arm64/kernel/mte.c

485

if (folio_test_hugetlb(folio))

arch/arm64/kernel/mte.c

486

WARN_ON_ONCE(!folio_test_hugetlb_mte_tagged(folio) &&

arch/arm64/kernel/mte.c

487

!is_huge_zero_folio(folio));

arch/arm64/kernel/mte.c

49

if (folio_try_hugetlb_mte_tagging(folio)) {

arch/arm64/kernel/mte.c

52

folio_set_hugetlb_mte_tagged(folio);

arch/arm64/kvm/guest.c

1014

struct folio *folio;

arch/arm64/kvm/guest.c

1027

folio = page_folio(page);

arch/arm64/kvm/guest.c

1031

if ((folio_test_hugetlb(folio) &&

arch/arm64/kvm/guest.c

1032

folio_test_hugetlb_mte_tagged(folio)) ||

arch/arm64/kvm/guest.c

1047

if (folio_test_hugetlb(folio))

arch/arm64/kvm/guest.c

1048

folio_try_hugetlb_mte_tagging(folio);

arch/arm64/kvm/guest.c

1057

if (folio_test_hugetlb(folio))

arch/arm64/kvm/guest.c

1058

folio_set_hugetlb_mte_tagged(folio);

arch/arm64/kvm/mmu.c

1504

struct folio *folio = page_folio(page);

arch/arm64/kvm/mmu.c

1514

if (folio_test_hugetlb(folio)) {

arch/arm64/kvm/mmu.c

1516

if (folio_try_hugetlb_mte_tagging(folio)) {

arch/arm64/kvm/mmu.c

1519

folio_set_hugetlb_mte_tagged(folio);

arch/arm64/mm/contpte.c

258

struct folio *folio;

arch/arm64/mm/contpte.c

270

folio = page_folio(page);

arch/arm64/mm/contpte.c

271

folio_start = addr - (page - &folio->page) * PAGE_SIZE;

arch/arm64/mm/contpte.c

272

folio_end = folio_start + folio_nr_pages(folio) * PAGE_SIZE;

arch/arm64/mm/copypage.c

21

struct folio *src = page_folio(from);

arch/arm64/mm/copypage.c

22

struct folio *dst = page_folio(to);

arch/arm64/mm/fault.c

1010

struct folio *vma_alloc_zeroed_movable_folio(struct vm_area_struct *vma,

arch/arm64/mm/flush.c

54

struct folio *folio = page_folio(pte_page(pte));

arch/arm64/mm/flush.c

56

if (!test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/arm64/mm/flush.c

57

sync_icache_aliases((unsigned long)folio_address(folio),

arch/arm64/mm/flush.c

58

(unsigned long)folio_address(folio) +

arch/arm64/mm/flush.c

59

folio_size(folio));

arch/arm64/mm/flush.c

60

set_bit(PG_dcache_clean, &folio->flags.f);

arch/arm64/mm/flush.c

70

void flush_dcache_folio(struct folio *folio)

arch/arm64/mm/flush.c

72

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/arm64/mm/flush.c

73

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/arm64/mm/mteswap.c

102

nr = folio_nr_pages(folio);

arch/arm64/mm/mteswap.c

105

err = mte_save_tags(folio_page(folio, i));

arch/arm64/mm/mteswap.c

113

__mte_invalidate_tags(folio_page(folio, i));

arch/arm64/mm/mteswap.c

117

void arch_swap_restore(swp_entry_t entry, struct folio *folio)

arch/arm64/mm/mteswap.c

124

nr = folio_nr_pages(folio);

arch/arm64/mm/mteswap.c

127

mte_restore_tags(entry, folio_page(folio, i));

arch/arm64/mm/mteswap.c

94

int arch_prepare_to_swap(struct folio *folio)

arch/csky/abiv1/cacheflush.c

18

void flush_dcache_folio(struct folio *folio)

arch/csky/abiv1/cacheflush.c

22

if (is_zero_pfn(folio_pfn(folio)))

arch/csky/abiv1/cacheflush.c

25

mapping = folio_flush_mapping(folio);

arch/csky/abiv1/cacheflush.c

27

if (mapping && !folio_mapped(folio))

arch/csky/abiv1/cacheflush.c

28

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/csky/abiv1/cacheflush.c

33

set_bit(PG_dcache_clean, &folio->flags.f);

arch/csky/abiv1/cacheflush.c

48

struct folio *folio;

arch/csky/abiv1/cacheflush.c

58

folio = page_folio(pfn_to_page(pfn));

arch/csky/abiv1/cacheflush.c

59

if (!test_and_set_bit(PG_dcache_clean, &folio->flags.f))

arch/csky/abiv1/cacheflush.c

62

if (folio_flush_mapping(folio)) {

arch/csky/abiv1/inc/abi/cacheflush.h

12

void flush_dcache_folio(struct folio *);

arch/csky/abiv2/cacheflush.c

14

struct folio *folio;

arch/csky/abiv2/cacheflush.c

22

folio = page_folio(pfn_to_page(pfn));

arch/csky/abiv2/cacheflush.c

24

if (test_and_set_bit(PG_dcache_clean, &folio->flags.f))

arch/csky/abiv2/cacheflush.c

28

for (i = 0; i < folio_nr_pages(folio); i++) {

arch/csky/abiv2/cacheflush.c

29

unsigned long addr = (unsigned long) kmap_local_folio(folio,

arch/csky/abiv2/inc/abi/cacheflush.h

21

static inline void flush_dcache_folio(struct folio *folio)

arch/csky/abiv2/inc/abi/cacheflush.h

23

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/csky/abiv2/inc/abi/cacheflush.h

24

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/m68k/include/asm/cacheflush_mm.h

259

#define flush_dcache_folio(folio) \

arch/m68k/include/asm/cacheflush_mm.h

260

__flush_pages_to_ram(folio_address(folio), folio_nr_pages(folio))

arch/microblaze/include/asm/cacheflush.h

77

static inline void flush_dcache_folio(struct folio *folio)

arch/microblaze/include/asm/cacheflush.h

79

unsigned long addr = folio_pfn(folio) << PAGE_SHIFT;

arch/microblaze/include/asm/cacheflush.h

81

flush_dcache_range(addr, addr + folio_size(folio));

arch/mips/include/asm/cacheflush.h

39

#define folio_test_dcache_dirty(folio) \

arch/mips/include/asm/cacheflush.h

40

test_bit(PG_dcache_dirty, &(folio)->flags.f)

arch/mips/include/asm/cacheflush.h

41

#define folio_set_dcache_dirty(folio) \

arch/mips/include/asm/cacheflush.h

42

set_bit(PG_dcache_dirty, &(folio)->flags.f)

arch/mips/include/asm/cacheflush.h

43

#define folio_clear_dcache_dirty(folio) \

arch/mips/include/asm/cacheflush.h

44

clear_bit(PG_dcache_dirty, &(folio)->flags.f)

arch/mips/include/asm/cacheflush.h

53

void __flush_dcache_folio_pages(struct folio *folio, struct page *page, unsigned int nr);

arch/mips/include/asm/cacheflush.h

56

static inline void flush_dcache_folio(struct folio *folio)

arch/mips/include/asm/cacheflush.h

59

__flush_dcache_folio_pages(folio, folio_page(folio, 0),

arch/mips/include/asm/cacheflush.h

60

folio_nr_pages(folio));

arch/mips/include/asm/cacheflush.h

62

folio_set_dcache_dirty(folio);

arch/mips/include/asm/cacheflush.h

68

struct folio *folio = page_folio(page);

arch/mips/include/asm/cacheflush.h

71

__flush_dcache_folio_pages(folio, page, 1);

arch/mips/include/asm/cacheflush.h

73

folio_set_dcache_dirty(folio);

arch/mips/mm/c-r4k.c

571

struct folio *folio = page_folio(page);

arch/mips/mm/c-r4k.c

577

folio_mapped(folio) &&

arch/mips/mm/c-r4k.c

578

!folio_test_dcache_dirty(folio));

arch/mips/mm/cache.c

102

void __flush_dcache_folio_pages(struct folio *folio, struct page *page,

arch/mips/mm/cache.c

105

struct address_space *mapping = folio_flush_mapping(folio);

arch/mips/mm/cache.c

110

folio_set_dcache_dirty(folio);

arch/mips/mm/cache.c

130

struct folio *folio = page_folio(page);

arch/mips/mm/cache.c

133

if (folio_mapped(folio) && !folio_test_dcache_dirty(folio)) {

arch/mips/mm/cache.c

148

struct folio *folio;

arch/mips/mm/cache.c

157

folio = page_folio(pfn_to_page(pfn));

arch/mips/mm/cache.c

159

address -= offset_in_folio(folio, pfn << PAGE_SHIFT);

arch/mips/mm/cache.c

161

if (folio_test_dcache_dirty(folio)) {

arch/mips/mm/cache.c

162

for (i = 0; i < folio_nr_pages(folio); i++) {

arch/mips/mm/cache.c

163

addr = (unsigned long)kmap_local_folio(folio, i);

arch/mips/mm/cache.c

170

folio_clear_dcache_dirty(folio);

arch/mips/mm/init.c

163

struct folio *src = page_folio(from);

arch/mips/mm/init.c

189

struct folio *folio = page_folio(page);

arch/mips/mm/init.c

192

folio_mapped(folio) && !folio_test_dcache_dirty(folio)) {

arch/mips/mm/init.c

199

folio_set_dcache_dirty(folio);

arch/mips/mm/init.c

209

struct folio *folio = page_folio(page);

arch/mips/mm/init.c

212

folio_mapped(folio) && !folio_test_dcache_dirty(folio)) {

arch/mips/mm/init.c

219

folio_set_dcache_dirty(folio);

arch/nios2/include/asm/cacheflush.h

32

void flush_dcache_folio(struct folio *folio);

arch/nios2/mm/cacheflush.c

163

static void __flush_dcache_folio(struct folio *folio)

arch/nios2/mm/cacheflush.c

170

unsigned long start = (unsigned long)folio_address(folio);

arch/nios2/mm/cacheflush.c

172

__flush_dcache(start, start + folio_size(folio));

arch/nios2/mm/cacheflush.c

175

void flush_dcache_folio(struct folio *folio)

arch/nios2/mm/cacheflush.c

183

if (is_zero_pfn(folio_pfn(folio)))

arch/nios2/mm/cacheflush.c

186

mapping = folio_flush_mapping(folio);

arch/nios2/mm/cacheflush.c

190

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/nios2/mm/cacheflush.c

192

__flush_dcache_folio(folio);

arch/nios2/mm/cacheflush.c

194

unsigned long start = (unsigned long)folio_address(folio);

arch/nios2/mm/cacheflush.c

195

flush_aliases(mapping, folio);

arch/nios2/mm/cacheflush.c

196

flush_icache_range(start, start + folio_size(folio));

arch/nios2/mm/cacheflush.c

198

set_bit(PG_dcache_clean, &folio->flags.f);

arch/nios2/mm/cacheflush.c

214

struct folio *folio;

arch/nios2/mm/cacheflush.c

229

folio = page_folio(pfn_to_page(pfn));

arch/nios2/mm/cacheflush.c

230

if (!test_and_set_bit(PG_dcache_clean, &folio->flags.f))

arch/nios2/mm/cacheflush.c

231

__flush_dcache_folio(folio);

arch/nios2/mm/cacheflush.c

233

mapping = folio_flush_mapping(folio);

arch/nios2/mm/cacheflush.c

235

flush_aliases(mapping, folio);

arch/nios2/mm/cacheflush.c

237

flush_icache_pages(vma, &folio->page,

arch/nios2/mm/cacheflush.c

238

folio_nr_pages(folio));

arch/nios2/mm/cacheflush.c

74

static void flush_aliases(struct address_space *mapping, struct folio *folio)

arch/nios2/mm/cacheflush.c

80

unsigned long nr = folio_nr_pages(folio);

arch/nios2/mm/cacheflush.c

82

pgoff = folio->index;

arch/openrisc/include/asm/cacheflush.h

80

static inline void flush_dcache_folio(struct folio *folio)

arch/openrisc/include/asm/cacheflush.h

82

clear_bit(PG_dc_clean, &folio->flags.f);

arch/openrisc/mm/cache.c

101

struct folio *folio = page_folio(pfn_to_page(pfn));

arch/openrisc/mm/cache.c

102

int dirty = !test_and_set_bit(PG_dc_clean, &folio->flags.f);

arch/openrisc/mm/cache.c

110

unsigned int nr = folio_nr_pages(folio);

arch/openrisc/mm/cache.c

113

sync_icache_dcache(folio_page(folio, nr));

arch/parisc/include/asm/cacheflush.h

46

void flush_dcache_folio(struct folio *folio);

arch/parisc/kernel/cache.c

112

struct folio *folio;

arch/parisc/kernel/cache.c

121

folio = page_folio(pfn_to_page(pfn));

arch/parisc/kernel/cache.c

122

pfn = folio_pfn(folio);

arch/parisc/kernel/cache.c

123

nr = folio_nr_pages(folio);

arch/parisc/kernel/cache.c

124

if (folio_flush_mapping(folio) &&

arch/parisc/kernel/cache.c

125

test_bit(PG_dcache_dirty, &folio->flags.f)) {

arch/parisc/kernel/cache.c

128

clear_bit(PG_dcache_dirty, &folio->flags.f);

arch/parisc/kernel/cache.c

473

void flush_dcache_folio(struct folio *folio)

arch/parisc/kernel/cache.c

475

struct address_space *mapping = folio_flush_mapping(folio);

arch/parisc/kernel/cache.c

484

set_bit(PG_dcache_dirty, &folio->flags.f);

arch/parisc/kernel/cache.c

488

nr = folio_nr_pages(folio);

arch/parisc/kernel/cache.c

489

kaddr = folio_address(folio);

arch/parisc/kernel/cache.c

496

pgoff = folio->index;

arch/parisc/kernel/cache.c

508

unsigned long pfn = folio_pfn(folio);

arch/parisc/kernel/cache.c

511

nr = folio_nr_pages(folio);

arch/parisc/kernel/cache.c

536

if (nr == folio_nr_pages(folio))

arch/powerpc/include/asm/cacheflush.h

38

static inline void flush_dcache_folio(struct folio *folio)

arch/powerpc/include/asm/cacheflush.h

43

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/powerpc/include/asm/cacheflush.h

44

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/powerpc/include/asm/cacheflush.h

60

void flush_dcache_icache_folio(struct folio *folio);

arch/powerpc/include/asm/kvm_ppc.h

932

struct folio *folio;

arch/powerpc/include/asm/kvm_ppc.h

941

folio = page_folio(pfn_to_page(pfn));

arch/powerpc/include/asm/kvm_ppc.h

942

if (!test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/powerpc/include/asm/kvm_ppc.h

943

flush_dcache_icache_folio(folio);

arch/powerpc/include/asm/kvm_ppc.h

944

set_bit(PG_dcache_clean, &folio->flags.f);

arch/powerpc/kvm/book3s_hv_uvmem.c

1017

static void kvmppc_uvmem_folio_free(struct folio *folio)

arch/powerpc/kvm/book3s_hv_uvmem.c

1019

struct page *page = &folio->page;

arch/powerpc/mm/book3s64/hash_utils.c

1574

struct folio *folio;

arch/powerpc/mm/book3s64/hash_utils.c

1579

folio = page_folio(pte_page(pte));

arch/powerpc/mm/book3s64/hash_utils.c

1582

if (!test_bit(PG_dcache_clean, &folio->flags.f) &&

arch/powerpc/mm/book3s64/hash_utils.c

1583

!folio_test_reserved(folio)) {

arch/powerpc/mm/book3s64/hash_utils.c

1585

flush_dcache_icache_folio(folio);

arch/powerpc/mm/book3s64/hash_utils.c

1586

set_bit(PG_dcache_clean, &folio->flags.f);

arch/powerpc/mm/cacheflush.c

151

void flush_dcache_icache_folio(struct folio *folio)

arch/powerpc/mm/cacheflush.c

153

unsigned int i, nr = folio_nr_pages(folio);

arch/powerpc/mm/cacheflush.c

158

if (!folio_test_highmem(folio)) {

arch/powerpc/mm/cacheflush.c

159

void *addr = folio_address(folio);

arch/powerpc/mm/cacheflush.c

164

void *start = kmap_local_folio(folio, i * PAGE_SIZE);

arch/powerpc/mm/cacheflush.c

170

unsigned long pfn = folio_pfn(folio);

arch/powerpc/mm/pgtable-frag.c

136

struct folio *folio;

arch/powerpc/mm/pgtable-frag.c

138

folio = virt_to_folio(pgtable);

arch/powerpc/mm/pgtable-frag.c

139

folio_set_active(folio);

arch/powerpc/mm/pgtable.c

113

struct folio *folio;

arch/powerpc/mm/pgtable.c

126

folio = maybe_pte_to_folio(pte);

arch/powerpc/mm/pgtable.c

127

if (unlikely(!folio))

arch/powerpc/mm/pgtable.c

131

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/powerpc/mm/pgtable.c

136

flush_dcache_icache_folio(folio);

arch/powerpc/mm/pgtable.c

137

set_bit(PG_dcache_clean, &folio->flags.f);

arch/powerpc/mm/pgtable.c

148

struct folio *folio;

arch/powerpc/mm/pgtable.c

174

folio = maybe_pte_to_folio(pte);

arch/powerpc/mm/pgtable.c

175

if (unlikely(!folio))

arch/powerpc/mm/pgtable.c

179

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/powerpc/mm/pgtable.c

183

flush_dcache_icache_folio(folio);

arch/powerpc/mm/pgtable.c

184

set_bit(PG_dcache_clean, &folio->flags.f);

arch/powerpc/mm/pgtable.c

62

static struct folio *maybe_pte_to_folio(pte_t pte)

arch/powerpc/mm/pgtable.c

88

struct folio *folio = maybe_pte_to_folio(pte);

arch/powerpc/mm/pgtable.c

89

if (!folio)

arch/powerpc/mm/pgtable.c

91

if (!test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/powerpc/mm/pgtable.c

92

flush_dcache_icache_folio(folio);

arch/powerpc/mm/pgtable.c

93

set_bit(PG_dcache_clean, &folio->flags.f);

arch/riscv/include/asm/cacheflush.h

24

static inline void flush_dcache_folio(struct folio *folio)

arch/riscv/include/asm/cacheflush.h

26

if (test_bit(PG_dcache_clean, &folio->flags.f))

arch/riscv/include/asm/cacheflush.h

27

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/riscv/include/asm/hugetlb.h

10

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/riscv/include/asm/hugetlb.h

8

static inline void arch_clear_hugetlb_flags(struct folio *folio)

arch/riscv/mm/cacheflush.c

102

struct folio *folio = page_folio(pte_page(pte));

arch/riscv/mm/cacheflush.c

104

if (!test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/riscv/mm/cacheflush.c

106

set_bit(PG_dcache_clean, &folio->flags.f);

arch/s390/include/asm/page.h

173

struct folio;

arch/s390/include/asm/page.h

185

int arch_make_folio_accessible(struct folio *folio);

arch/s390/include/asm/page.h

261

#define folio_to_phys(page) pfn_to_phys(folio_pfn(folio))

arch/s390/include/asm/uv.h

631

int uv_destroy_folio(struct folio *folio);

arch/s390/include/asm/uv.h

634

int s390_wiggle_split_folio(struct mm_struct *mm, struct folio *folio);

arch/s390/include/asm/uv.h

635

int __make_folio_secure(struct folio *folio, struct uv_cb_header *uvcb);

arch/s390/include/asm/uv.h

637

int uv_convert_from_secure_folio(struct folio *folio);

arch/s390/kernel/uv.c

135

int uv_destroy_folio(struct folio *folio)

arch/s390/kernel/uv.c

140

folio_get(folio);

arch/s390/kernel/uv.c

141

for (i = 0; i < (1 << folio_order(folio)); i++) {

arch/s390/kernel/uv.c

142

rc = uv_destroy(folio_to_phys(folio) + i * PAGE_SIZE);

arch/s390/kernel/uv.c

147

clear_bit(PG_arch_1, &folio->flags.f);

arch/s390/kernel/uv.c

148

folio_put(folio);

arch/s390/kernel/uv.c

185

int uv_convert_from_secure_folio(struct folio *folio)

arch/s390/kernel/uv.c

190

folio_get(folio);

arch/s390/kernel/uv.c

191

for (i = 0; i < (1 << folio_order(folio)); i++) {

arch/s390/kernel/uv.c

192

rc = uv_convert_from_secure(folio_to_phys(folio) + i * PAGE_SIZE);

arch/s390/kernel/uv.c

197

clear_bit(PG_arch_1, &folio->flags.f);

arch/s390/kernel/uv.c

198

folio_put(folio);

arch/s390/kernel/uv.c

218

static int expected_folio_refs(struct folio *folio)

arch/s390/kernel/uv.c

222

res = folio_mapcount(folio);

arch/s390/kernel/uv.c

223

if (folio_test_swapcache(folio)) {

arch/s390/kernel/uv.c

225

} else if (folio_mapping(folio)) {

arch/s390/kernel/uv.c

227

if (folio->private)

arch/s390/kernel/uv.c

251

int __make_folio_secure(struct folio *folio, struct uv_cb_header *uvcb)

arch/s390/kernel/uv.c

255

if (folio_test_writeback(folio))

arch/s390/kernel/uv.c

257

expected = expected_folio_refs(folio) + 1;

arch/s390/kernel/uv.c

258

if (!folio_ref_freeze(folio, expected))

arch/s390/kernel/uv.c

260

set_bit(PG_arch_1, &folio->flags.f);

arch/s390/kernel/uv.c

270

folio_ref_unfreeze(folio, expected);

arch/s390/kernel/uv.c

296

int s390_wiggle_split_folio(struct mm_struct *mm, struct folio *folio)

arch/s390/kernel/uv.c

301

folio_wait_writeback(folio);

arch/s390/kernel/uv.c

304

if (!folio_test_large(folio))

arch/s390/kernel/uv.c

312

folio_lock(folio);

arch/s390/kernel/uv.c

313

rc = split_folio(folio);

arch/s390/kernel/uv.c

315

folio_unlock(folio);

arch/s390/kernel/uv.c

341

if (!folio_test_dirty(folio) || folio_test_anon(folio) ||

arch/s390/kernel/uv.c

342

!folio->mapping || !mapping_can_writeback(folio->mapping)) {

arch/s390/kernel/uv.c

343

folio_unlock(folio);

arch/s390/kernel/uv.c

354

mapping = folio->mapping;

arch/s390/kernel/uv.c

355

lstart = folio_pos(folio);

arch/s390/kernel/uv.c

356

lend = lstart + folio_size(folio) - 1;

arch/s390/kernel/uv.c

358

folio_unlock(folio);

arch/s390/kernel/uv.c

376

int arch_make_folio_accessible(struct folio *folio)

arch/s390/kernel/uv.c

385

if (!test_bit(PG_arch_1, &folio->flags.f))

arch/s390/kernel/uv.c

389

if (WARN_ON_ONCE(folio_test_large(folio)))

arch/s390/kernel/uv.c

392

rc = uv_pin_shared(folio_to_phys(folio));

arch/s390/kernel/uv.c

394

clear_bit(PG_arch_1, &folio->flags.f);

arch/s390/kernel/uv.c

398

rc = uv_convert_from_secure(folio_to_phys(folio));

arch/s390/kernel/uv.c

400

clear_bit(PG_arch_1, &folio->flags.f);

arch/s390/kvm/gmap.c

379

struct folio *folio = NULL;

arch/s390/kvm/gmap.c

389

folio = pfn_folio(ptep->h.pfra);

arch/s390/kvm/gmap.c

392

if (folio)

arch/s390/kvm/gmap.c

393

uv_convert_from_secure_folio(folio);

arch/s390/kvm/gmap.c

401

struct folio *folio = NULL;

arch/s390/kvm/gmap.c

409

folio = phys_to_folio(crste_origin_large(old));

arch/s390/kvm/gmap.c

425

if (folio)

arch/s390/kvm/gmap.c

426

uv_convert_from_secure_folio(folio);

arch/s390/kvm/kvm-s390.h

348

struct folio *folio = page_folio(page);

arch/s390/kvm/kvm-s390.h

352

if (folio_test_large(folio))

arch/s390/kvm/kvm-s390.h

355

rc = uv_destroy_folio(folio);

arch/s390/kvm/kvm-s390.h

366

rc = uv_convert_from_secure_folio(folio);

arch/s390/kvm/pv.c

107

struct folio *folio;

arch/s390/kvm/pv.c

111

folio = pfn_folio(f->pfn);

arch/s390/kvm/pv.c

123

if (folio_trylock(folio)) {

arch/s390/kvm/pv.c

124

priv->rc = __kvm_s390_pv_make_secure(f, folio);

arch/s390/kvm/pv.c

126

priv->folio = folio;

arch/s390/kvm/pv.c

127

folio_get(folio);

arch/s390/kvm/pv.c

129

folio_unlock(folio);

arch/s390/kvm/pv.c

167

if (priv.folio) {

arch/s390/kvm/pv.c

168

rc = s390_wiggle_split_folio(kvm->mm, priv.folio);

arch/s390/kvm/pv.c

174

if (priv.folio)

arch/s390/kvm/pv.c

175

folio_put(priv.folio);

arch/s390/kvm/pv.c

76

struct folio *folio;

arch/s390/kvm/pv.c

82

static int __kvm_s390_pv_make_secure(struct guest_fault *f, struct folio *folio)

arch/s390/kvm/pv.c

88

uv_convert_from_secure(folio_to_phys(folio));

arch/s390/kvm/pv.c

90

if (folio_test_hugetlb(folio))

arch/s390/kvm/pv.c

92

if (folio_test_large(folio))

arch/s390/kvm/pv.c

96

folio_get(folio);

arch/s390/kvm/pv.c

97

rc = __make_folio_secure(folio, priv->uvcb);

arch/s390/kvm/pv.c

99

folio_put(folio);

arch/s390/mm/fault.c

415

struct folio *folio;

arch/s390/mm/fault.c

441

folio = virt_to_folio((void *)addr);

arch/s390/mm/fault.c

442

if (unlikely(!folio_try_get(folio)))

arch/s390/mm/fault.c

444

rc = uv_convert_from_secure(folio_to_phys(folio));

arch/s390/mm/fault.c

446

clear_bit(PG_arch_1, &folio->flags.f);

arch/s390/mm/fault.c

447

folio_put(folio);

arch/s390/mm/fault.c

463

folio = folio_walk_start(&fw, vma, addr, 0);

arch/s390/mm/fault.c

464

if (!folio) {

arch/s390/mm/fault.c

469

folio_get(folio);

arch/s390/mm/fault.c

470

rc = arch_make_folio_accessible(folio);

arch/s390/mm/fault.c

471

folio_put(folio);

arch/sh/include/asm/cacheflush.h

45

void flush_dcache_folio(struct folio *folio);

arch/sh/include/asm/hugetlb.h

15

static inline void arch_clear_hugetlb_flags(struct folio *folio)

arch/sh/include/asm/hugetlb.h

17

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/cache-sh4.c

112

struct folio *folio = arg;

arch/sh/mm/cache-sh4.c

114

struct address_space *mapping = folio_flush_mapping(folio);

arch/sh/mm/cache-sh4.c

117

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/cache-sh4.c

121

unsigned long pfn = folio_pfn(folio);

arch/sh/mm/cache-sh4.c

122

unsigned long addr = (unsigned long)folio_address(folio);

arch/sh/mm/cache-sh4.c

123

unsigned int i, nr = folio_nr_pages(folio);

arch/sh/mm/cache-sh4.c

244

struct folio *folio = page_folio(page);

arch/sh/mm/cache-sh4.c

250

test_bit(PG_dcache_clean, folio_flags(folio, 0)) &&

arch/sh/mm/cache-sh4.c

251

folio_mapped(folio));

arch/sh/mm/cache-sh7705.c

137

struct folio *folio = arg;

arch/sh/mm/cache-sh7705.c

138

struct address_space *mapping = folio_flush_mapping(folio);

arch/sh/mm/cache-sh7705.c

141

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/cache-sh7705.c

143

unsigned long pfn = folio_pfn(folio);

arch/sh/mm/cache-sh7705.c

144

unsigned int i, nr = folio_nr_pages(folio);

arch/sh/mm/cache-sh7705.c

186

struct folio *folio = arg;

arch/sh/mm/cache-sh7705.c

187

__flush_purge_region(folio_address(folio), folio_size(folio));

arch/sh/mm/cache.c

102

struct folio *src = page_folio(from);

arch/sh/mm/cache.c

150

struct folio *folio = page_folio(pfn_to_page(pfn));

arch/sh/mm/cache.c

151

int dirty = !test_and_set_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/cache.c

153

__flush_purge_region(folio_address(folio),

arch/sh/mm/cache.c

154

folio_size(folio));

arch/sh/mm/cache.c

160

struct folio *folio = page_folio(page);

arch/sh/mm/cache.c

164

if (boot_cpu_data.dcache.n_aliases && folio_mapped(folio) &&

arch/sh/mm/cache.c

165

test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/sh/mm/cache.c

173

__flush_purge_region(folio_address(folio),

arch/sh/mm/cache.c

174

folio_size(folio));

arch/sh/mm/cache.c

225

void flush_dcache_folio(struct folio *folio)

arch/sh/mm/cache.c

227

cacheop_on_each_cpu(local_flush_dcache_folio, folio, 1);

arch/sh/mm/cache.c

64

struct folio *folio = page_folio(page);

arch/sh/mm/cache.c

66

if (boot_cpu_data.dcache.n_aliases && folio_mapped(folio) &&

arch/sh/mm/cache.c

67

test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/sh/mm/cache.c

74

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/cache.c

85

struct folio *folio = page_folio(page);

arch/sh/mm/cache.c

87

if (boot_cpu_data.dcache.n_aliases && folio_mapped(folio) &&

arch/sh/mm/cache.c

88

test_bit(PG_dcache_clean, &folio->flags.f)) {

arch/sh/mm/cache.c

95

clear_bit(PG_dcache_clean, &folio->flags.f);

arch/sh/mm/kmap.c

30

struct folio *folio = page_folio(page);

arch/sh/mm/kmap.c

34

BUG_ON(!test_bit(PG_dcache_clean, &folio->flags.f));

arch/sparc/include/asm/cacheflush_32.h

39

void sparc_flush_folio_to_ram(struct folio *folio);

arch/sparc/include/asm/cacheflush_32.h

42

#define flush_dcache_folio(folio) sparc_flush_folio_to_ram(folio)

arch/sparc/include/asm/cacheflush_64.h

38

void flush_dcache_folio_impl(struct folio *folio);

arch/sparc/include/asm/cacheflush_64.h

40

void smp_flush_dcache_folio_impl(struct folio *folio, int cpu);

arch/sparc/include/asm/cacheflush_64.h

41

void flush_dcache_folio_all(struct mm_struct *mm, struct folio *folio);

arch/sparc/include/asm/cacheflush_64.h

43

#define smp_flush_dcache_folio_impl(folio, cpu) flush_dcache_folio_impl(folio)

arch/sparc/include/asm/cacheflush_64.h

44

#define flush_dcache_folio_all(mm, folio) flush_dcache_folio_impl(folio)

arch/sparc/include/asm/cacheflush_64.h

49

void flush_dcache_folio(struct folio *folio);

arch/sparc/kernel/smp_64.c

1002

if (folio_flush_mapping(folio) != NULL)

arch/sparc/kernel/smp_64.c

1010

unsigned int i, nr = folio_nr_pages(folio);

arch/sparc/kernel/smp_64.c

1021

__local_flush_dcache_folio(folio);

arch/sparc/kernel/smp_64.c

921

static inline void __local_flush_dcache_folio(struct folio *folio)

arch/sparc/kernel/smp_64.c

923

unsigned int i, nr = folio_nr_pages(folio);

arch/sparc/kernel/smp_64.c

927

__flush_dcache_page(folio_address(folio) + i * PAGE_SIZE,

arch/sparc/kernel/smp_64.c

929

folio_flush_mapping(folio) != NULL));

arch/sparc/kernel/smp_64.c

931

if (folio_flush_mapping(folio) != NULL &&

arch/sparc/kernel/smp_64.c

933

unsigned long pfn = folio_pfn(folio)

arch/sparc/kernel/smp_64.c

940

void smp_flush_dcache_folio_impl(struct folio *folio, int cpu)

arch/sparc/kernel/smp_64.c

954

__local_flush_dcache_folio(folio);

arch/sparc/kernel/smp_64.c

956

void *pg_addr = folio_address(folio);

arch/sparc/kernel/smp_64.c

961

if (folio_flush_mapping(folio) != NULL)

arch/sparc/kernel/smp_64.c

969

unsigned int i, nr = folio_nr_pages(folio);

arch/sparc/kernel/smp_64.c

985

void flush_dcache_folio_all(struct mm_struct *mm, struct folio *folio)

arch/sparc/kernel/smp_64.c

999

pg_addr = folio_address(folio);

arch/sparc/mm/init_32.c

271

void sparc_flush_folio_to_ram(struct folio *folio)

arch/sparc/mm/init_32.c

273

unsigned long vaddr = (unsigned long)folio_address(folio);

arch/sparc/mm/init_32.c

274

unsigned int i, nr = folio_nr_pages(folio);

arch/sparc/mm/init_64.c

194

inline void flush_dcache_folio_impl(struct folio *folio)

arch/sparc/mm/init_64.c

196

unsigned int i, nr = folio_nr_pages(folio);

arch/sparc/mm/init_64.c

205

__flush_dcache_page(folio_address(folio) + i * PAGE_SIZE,

arch/sparc/mm/init_64.c

207

folio_flush_mapping(folio) != NULL));

arch/sparc/mm/init_64.c

209

if (folio_flush_mapping(folio) != NULL &&

arch/sparc/mm/init_64.c

222

#define dcache_dirty_cpu(folio) \

arch/sparc/mm/init_64.c

223

(((folio)->flags.f >> PG_dcache_cpu_shift) & PG_dcache_cpu_mask)

arch/sparc/mm/init_64.c

225

static inline void set_dcache_dirty(struct folio *folio, int this_cpu)

arch/sparc/mm/init_64.c

242

: "r" (mask), "r" (non_cpu_bits), "r" (&folio->flags.f)

arch/sparc/mm/init_64.c

246

static inline void clear_dcache_dirty_cpu(struct folio *folio, unsigned long cpu)

arch/sparc/mm/init_64.c

264

: "r" (cpu), "r" (mask), "r" (&folio->flags.f),

arch/sparc/mm/init_64.c

288

struct folio *folio = page_folio(page);

arch/sparc/mm/init_64.c

291

pg_flags = folio->flags.f;

arch/sparc/mm/init_64.c

301

flush_dcache_folio_impl(folio);

arch/sparc/mm/init_64.c

303

smp_flush_dcache_folio_impl(folio, cpu);

arch/sparc/mm/init_64.c

305

clear_dcache_dirty_cpu(folio, cpu);

arch/sparc/mm/init_64.c

453

void flush_dcache_folio(struct folio *folio)

arch/sparc/mm/init_64.c

455

unsigned long pfn = folio_pfn(folio);

arch/sparc/mm/init_64.c

471

mapping = folio_flush_mapping(folio);

arch/sparc/mm/init_64.c

473

bool dirty = test_bit(PG_dcache_dirty, &folio->flags.f);

arch/sparc/mm/init_64.c

475

int dirty_cpu = dcache_dirty_cpu(folio);

arch/sparc/mm/init_64.c

479

smp_flush_dcache_folio_impl(folio, dirty_cpu);

arch/sparc/mm/init_64.c

481

set_dcache_dirty(folio, this_cpu);

arch/sparc/mm/init_64.c

488

flush_dcache_folio_impl(folio);

arch/sparc/mm/tlb.c

130

struct folio *folio;

arch/sparc/mm/tlb.c

140

folio = page_folio(page);

arch/sparc/mm/tlb.c

141

mapping = folio_flush_mapping(folio);

arch/sparc/mm/tlb.c

147

flush_dcache_folio_all(mm, folio);

arch/xtensa/include/asm/cacheflush.h

127

void flush_dcache_folio(struct folio *folio);

arch/xtensa/mm/cache.c

105

struct folio *folio = page_folio(dst);

arch/xtensa/mm/cache.c

114

set_bit(PG_arch_1, folio_flags(folio, 0));

arch/xtensa/mm/cache.c

126

void flush_dcache_folio(struct folio *folio)

arch/xtensa/mm/cache.c

128

struct address_space *mapping = folio_flush_mapping(folio);

arch/xtensa/mm/cache.c

137

if (!test_bit(PG_arch_1, &folio->flags.f))

arch/xtensa/mm/cache.c

138

set_bit(PG_arch_1, &folio->flags.f);

arch/xtensa/mm/cache.c

142

unsigned long phys = folio_pfn(folio) * PAGE_SIZE;

arch/xtensa/mm/cache.c

143

unsigned long temp = folio_pos(folio);

arch/xtensa/mm/cache.c

144

unsigned int i, nr = folio_nr_pages(folio);

arch/xtensa/mm/cache.c

220

struct folio *folio;

arch/xtensa/mm/cache.c

226

folio = page_folio(pfn_to_page(pfn));

arch/xtensa/mm/cache.c

231

nr = folio_nr_pages(folio);

arch/xtensa/mm/cache.c

235

if (!folio_test_reserved(folio) && test_bit(PG_arch_1, &folio->flags.f)) {

arch/xtensa/mm/cache.c

236

unsigned long phys = folio_pfn(folio) * PAGE_SIZE;

arch/xtensa/mm/cache.c

250

clear_bit(PG_arch_1, &folio->flags.f);

arch/xtensa/mm/cache.c

253

if (!folio_test_reserved(folio) && !test_bit(PG_arch_1, &folio->flags.f)

arch/xtensa/mm/cache.c

256

void *paddr = kmap_local_folio(folio, i * PAGE_SIZE);

arch/xtensa/mm/cache.c

261

set_bit(PG_arch_1, &folio->flags.f);

arch/xtensa/mm/cache.c

90

struct folio *folio = page_folio(page);

arch/xtensa/mm/cache.c

96

set_bit(PG_arch_1, folio_flags(folio, 0));

arch/xtensa/mm/tlb.c

259

struct folio *f = page_folio(p);

block/bio-integrity.c

342

struct folio *folio = page_folio(pages[i]);

block/bio-integrity.c

348

if (page_folio(pages[j]) != folio ||

block/bio.c

1076

void bio_add_folio_nofail(struct bio *bio, struct folio *folio, size_t len,

block/bio.c

1082

__bio_add_page(bio, folio_page(folio, nr), len, off % PAGE_SIZE);

block/bio.c

1100

bool bio_add_folio(struct bio *bio, struct folio *folio, size_t len,

block/bio.c

1107

return bio_add_page(bio, folio_page(folio, nr), len, off % PAGE_SIZE) > 0;

block/bio.c

1174

folio_lock(fi.folio);

block/bio.c

1175

folio_mark_dirty(fi.folio);

block/bio.c

1176

folio_unlock(fi.folio);

block/bio.c

1180

unpin_user_folio(fi.folio, nr_pages);

block/bio.c

1284

static struct folio *folio_alloc_greedy(gfp_t gfp, size_t *size,

block/bio.c

1287

struct folio *folio;

block/bio.c

1290

folio = folio_alloc(gfp | __GFP_NORETRY | __GFP_NOWARN,

block/bio.c

1292

if (folio)

block/bio.c

1293

return folio;

block/bio.c

1306

struct folio *folio = bvec_folio(bv);

block/bio.c

1308

if (!is_zero_folio(folio) && !is_huge_zero_folio(folio))

block/bio.c

1309

folio_put(folio);

block/bio.c

1328

struct folio *folio;

block/bio.c

1336

folio = folio_alloc_greedy(GFP_KERNEL, &this_len, minsize);

block/bio.c

1337

if (!folio)

block/bio.c

1339

bio_add_folio_nofail(bio, folio, this_len, 0);

block/bio.c

1342

copied = copy_folio_from_iter_atomic(folio, 0, this_len,

block/bio.c

1345

copied = copy_folio_from_iter(folio, 0, this_len, iter);

block/bio.c

1374

struct folio *folio;

block/bio.c

1377

folio = folio_alloc_greedy(GFP_KERNEL, &len, minsize);

block/bio.c

1378

if (!folio)

block/bio.c

1399

bvec_set_folio(&bio->bi_io_vec[0], folio, bio->bi_iter.bi_size, 0);

block/bio.c

1414

folio_put(folio);

block/bio.c

1441

struct folio *folio = bvec_folio(bv);

block/bio.c

1446

folio_mark_dirty_lock(folio);

block/bio.c

1447

unpin_user_folio(folio, nr_pages);

block/bio.c

1680

folio_lock(fi.folio);

block/bio.c

1681

folio_mark_dirty(fi.folio);

block/bio.c

1682

folio_unlock(fi.folio);

block/bio.c

1729

if (!folio_test_dirty(fi.folio))

block/blk-lib.c

191

struct folio *zero_folio = largest_zero_folio();

block/fops.c

479

struct folio *folio = NULL;

block/fops.c

484

while ((folio = writeback_iter(mapping, wbc, folio, &err)))

block/fops.c

485

err = block_write_full_folio(folio, wbc, blkdev_get_block);

block/fops.c

491

static int blkdev_read_folio(struct file *file, struct folio *folio)

block/fops.c

493

return block_read_full_folio(folio, blkdev_get_block);

block/fops.c

511

static int blkdev_read_folio(struct file *file, struct folio *folio)

block/fops.c

513

iomap_bio_read_folio(folio, &blkdev_iomap_ops);

block/fops.c

523

struct folio *folio, u64 offset, unsigned int len, u64 end_pos)

block/fops.c

540

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

block/partitions/check.h

28

struct folio *v;

block/partitions/core.c

717

struct folio *folio;

block/partitions/core.c

724

folio = read_mapping_folio(mapping, n >> PAGE_SECTORS_SHIFT, NULL);

block/partitions/core.c

725

if (IS_ERR(folio))

block/partitions/core.c

728

p->v = folio;

block/partitions/core.c

729

return folio_address(folio) + offset_in_folio(folio, n * SECTOR_SIZE);

drivers/dax/device.c

76

struct folio *folio = pfn_folio(pfn + i);

drivers/dax/device.c

78

if (folio->mapping)

drivers/dax/device.c

81

folio->mapping = filp->f_mapping;

drivers/dax/device.c

82

folio->index = pgoff + i;

drivers/dax/fsdev.c

172

struct folio *folio = pfn_folio(pfn);

drivers/dax/fsdev.c

173

int order = dax_folio_reset_order(folio);

drivers/dibs/dibs_loopback.c

53

struct folio *folio;

drivers/dibs/dibs_loopback.c

77

folio = folio_alloc(GFP_KERNEL | __GFP_NOWARN | __GFP_NOMEMALLOC |

drivers/dibs/dibs_loopback.c

80

if (!folio) {

drivers/dibs/dibs_loopback.c

84

dmb_node->cpu_addr = folio_address(folio);

drivers/dma-buf/udmabuf.c

305

loff_t start, loff_t size, struct folio **folios)

drivers/dma-buf/udmabuf.c

355

struct folio **folios = NULL;

drivers/dma-buf/udmabuf.c

40

struct folio **pinned_folios;

drivers/gpu/drm/amd/amdkfd/kfd_migrate.c

577

static void svm_migrate_folio_free(struct folio *folio)

drivers/gpu/drm/amd/amdkfd/kfd_migrate.c

579

struct page *page = &folio->page;

drivers/gpu/drm/drm_gem.c

669

struct folio *folio;

drivers/gpu/drm/drm_gem.c

696

folio = shmem_read_folio_gfp(mapping, i,

drivers/gpu/drm/drm_gem.c

698

if (IS_ERR(folio))

drivers/gpu/drm/drm_gem.c

700

nr = min(npages - i, folio_nr_pages(folio));

drivers/gpu/drm/drm_gem.c

702

pages[i] = folio_file_page(folio, i);

drivers/gpu/drm/drm_gem.c

710

(folio_pfn(folio) >= 0x00100000UL));

drivers/gpu/drm/drm_gem.c

720

struct folio *f = page_folio(pages[j]);

drivers/gpu/drm/drm_gem.c

729

return ERR_CAST(folio);

drivers/gpu/drm/drm_gem.c

760

struct folio *folio;

drivers/gpu/drm/drm_gem.c

764

folio = page_folio(pages[i]);

drivers/gpu/drm/drm_gem.c

767

folio_mark_dirty(folio);

drivers/gpu/drm/drm_gem.c

770

folio_mark_accessed(folio);

drivers/gpu/drm/drm_gem.c

773

if (!folio_batch_add(&fbatch, folio))

drivers/gpu/drm/drm_gem.c

775

i += folio_nr_pages(folio) - 1;

drivers/gpu/drm/drm_gem_shmem_helper.c

638

struct folio *folio;

drivers/gpu/drm/drm_gem_shmem_helper.c

653

folio = page_folio(page);

drivers/gpu/drm/drm_gem_shmem_helper.c

659

folio_mark_accessed(folio);

drivers/gpu/drm/drm_pagemap.c

1330

static void drm_pagemap_folio_free(struct folio *folio)

drivers/gpu/drm/drm_pagemap.c

1332

struct page *page = folio_page(folio, 0);

drivers/gpu/drm/drm_pagemap.c

1360

static void drm_pagemap_folio_split(struct folio *orig_folio, struct folio *new_folio)

drivers/gpu/drm/drm_pagemap.c

162

static void drm_pagemap_migration_unlock_put_folio(struct folio *folio)

drivers/gpu/drm/drm_pagemap.c

164

folio_unlock(folio);

drivers/gpu/drm/drm_pagemap.c

165

folio_put(folio);

drivers/gpu/drm/drm_pagemap.c

182

struct folio *folio;

drivers/gpu/drm/drm_pagemap.c

189

folio = page_folio(page);

drivers/gpu/drm/drm_pagemap.c

190

order = folio_order(folio);

drivers/gpu/drm/drm_pagemap.c

192

drm_pagemap_migration_unlock_put_folio(folio);

drivers/gpu/drm/drm_pagemap.c

213

zone_device_folio_init((struct folio *)page, zdd->dpagemap->pagemap,

drivers/gpu/drm/drm_pagemap.c

252

struct folio *folio;

drivers/gpu/drm/drm_pagemap.c

259

folio = page_folio(page);

drivers/gpu/drm/drm_pagemap.c

260

order = folio_order(folio);

drivers/gpu/drm/drm_pagemap.c

338

struct folio *folio;

drivers/gpu/drm/drm_pagemap.c

345

folio = page_folio(page);

drivers/gpu/drm/drm_pagemap.c

346

order = folio_order(folio);

drivers/gpu/drm/drm_pagemap.c

574

struct folio *folio;

drivers/gpu/drm/drm_pagemap.c

578

folio = page_folio(page);

drivers/gpu/drm/drm_pagemap.c

579

order = folio_order(folio);

drivers/gpu/drm/drm_pagemap.c

876

struct folio *folio;

drivers/gpu/drm/drm_pagemap.c

896

folio = vma_alloc_folio(GFP_HIGHUSER, order, vas, addr);

drivers/gpu/drm/drm_pagemap.c

898

folio = folio_alloc(GFP_HIGHUSER, order);

drivers/gpu/drm/drm_pagemap.c

900

if (!folio)

drivers/gpu/drm/drm_pagemap.c

903

page = folio_page(folio, 0);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

104

struct folio *folio;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

114

folio = shmem_read_folio_gfp(mapping, i, gfp);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

115

if (!IS_ERR(folio))

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

119

ret = PTR_ERR(folio);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

157

folio_nr_pages(folio),

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

164

folio_pfn(folio) != next_pfn) {

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

169

sg_set_folio(sg, folio, nr_pages * PAGE_SIZE, 0);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

176

next_pfn = folio_pfn(folio) + nr_pages;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

315

struct folio *folio = NULL;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

324

while ((folio = writeback_iter(mapping, &wbc, folio, &error))) {

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

325

if (folio_mapped(folio))

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

326

folio_redirty_for_writepage(&wbc, folio);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

328

error = shmem_writeout(folio, NULL, NULL);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

39

struct folio *last = NULL;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

46

struct folio *folio = page_folio(page);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

48

if (folio == last)

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

50

last = folio;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

52

folio_mark_dirty(folio);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

54

folio_mark_accessed(folio);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

56

if (!folio_batch_add(&fbatch, folio))

drivers/gpu/drm/i915/i915_gpu_error.c

199

struct folio *folio;

drivers/gpu/drm/i915/i915_gpu_error.c

201

folio = folio_alloc(gfp, 0);

drivers/gpu/drm/i915/i915_gpu_error.c

202

if (!folio)

drivers/gpu/drm/i915/i915_gpu_error.c

205

folio_batch_add(fbatch, folio);

drivers/gpu/drm/i915/i915_gpu_error.c

226

struct folio *folio;

drivers/gpu/drm/i915/i915_gpu_error.c

228

folio = folio_alloc(gfp, 0);

drivers/gpu/drm/i915/i915_gpu_error.c

229

if (!folio && folio_batch_count(fbatch))

drivers/gpu/drm/i915/i915_gpu_error.c

230

folio = fbatch->folios[--fbatch->nr];

drivers/gpu/drm/i915/i915_gpu_error.c

232

return folio ? folio_address(folio) : NULL;

drivers/gpu/drm/i915/i915_gpu_error.c

237

struct folio *folio = virt_to_folio(addr);

drivers/gpu/drm/i915/i915_gpu_error.c

240

folio_batch_add(fbatch, folio);

drivers/gpu/drm/i915/i915_gpu_error.c

242

folio_put(folio);

drivers/gpu/drm/nouveau/nouveau_dmem.c

118

static void nouveau_dmem_folio_free(struct folio *folio)

drivers/gpu/drm/nouveau/nouveau_dmem.c

120

struct page *page = &folio->page;

drivers/gpu/drm/nouveau/nouveau_dmem.c

125

if (folio_order(folio)) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

127

dmem->free_folios = folio;

drivers/gpu/drm/nouveau/nouveau_dmem.c

156

struct folio *sfolio, struct folio *dfolio,

drivers/gpu/drm/nouveau/nouveau_dmem.c

202

struct folio *sfolio, *dfolio;

drivers/gpu/drm/nouveau/nouveau_dmem.c

280

static void nouveau_dmem_folio_split(struct folio *head, struct folio *tail)

drivers/gpu/drm/nouveau/nouveau_dmem.c

398

struct folio *folio = NULL;

drivers/gpu/drm/nouveau/nouveau_dmem.c

404

folio = drm->dmem->free_folios;

drivers/gpu/drm/nouveau/nouveau_dmem.c

405

page = &folio->page;

drivers/gpu/drm/nouveau/nouveau_dmem.c

407

chunk = nouveau_page_to_chunk(&folio->page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

417

folio = page_folio(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

423

folio = page_folio(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

428

zone_device_folio_init(folio, page_pgmap(folio_page(folio, 0)), order);

drivers/gpu/drm/nouveau/nouveau_dmem.c

492

struct folio *folio = page_folio(

drivers/gpu/drm/nouveau/nouveau_dmem.c

494

unsigned int order = folio_order(folio);

drivers/gpu/drm/nouveau/nouveau_dmem.c

792

struct folio *folio;

drivers/gpu/drm/nouveau/nouveau_dmem.c

803

folio = page_folio(migrate_pfn_to_page(args->dst[i]));

drivers/gpu/drm/nouveau/nouveau_dmem.c

804

order = folio_order(folio);

drivers/gpu/drm/nouveau/nouveau_dmem.c

87

struct folio *free_folios;

drivers/gpu/drm/nouveau/nouveau_svm.c

593

struct folio *folio;

drivers/gpu/drm/nouveau/nouveau_svm.c

613

page = make_device_exclusive(mm, start, drm->dev, &folio);

drivers/gpu/drm/nouveau/nouveau_svm.c

619

folio = page_folio(page);

drivers/gpu/drm/nouveau/nouveau_svm.c

627

folio_unlock(folio);

drivers/gpu/drm/nouveau/nouveau_svm.c

628

folio_put(folio);

drivers/gpu/drm/nouveau/nouveau_svm.c

644

folio_unlock(folio);

drivers/gpu/drm/nouveau/nouveau_svm.c

645

folio_put(folio);

drivers/gpu/drm/panfrost/panfrost_mmu.c

656

struct folio *folio;

drivers/gpu/drm/panfrost/panfrost_mmu.c

658

folio = shmem_read_folio(mapping, pg);

drivers/gpu/drm/panfrost/panfrost_mmu.c

659

if (IS_ERR(folio)) {

drivers/gpu/drm/panfrost/panfrost_mmu.c

660

ret = PTR_ERR(folio);

drivers/gpu/drm/panfrost/panfrost_mmu.c

664

pg &= ~(folio_nr_pages(folio) - 1);

drivers/gpu/drm/panfrost/panfrost_mmu.c

665

for (u32 i = 0; i < folio_nr_pages(folio) && pg < nr_pages; i++) {

drivers/gpu/drm/panfrost/panfrost_mmu.c

669

pages[pg++] = folio_page(folio, i);

drivers/gpu/drm/panfrost/panfrost_mmu.c

677

folio_put(folio);

drivers/gpu/drm/ttm/ttm_backup.c

103

ttm_backup_backup_folio(struct file *backup, struct folio *folio,

drivers/gpu/drm/ttm/ttm_backup.c

110

struct folio *to_folio;

drivers/gpu/drm/ttm/ttm_backup.c

158

folio_page(folio, i + j));

drivers/gpu/drm/ttm/ttm_backup.c

57

struct folio *from_folio;

drivers/iommu/iommu-pages.c

100

folio_put(folio);

drivers/iommu/iommu-pages.c

223

struct folio *folio = ioptdesc_folio(cur);

drivers/iommu/iommu-pages.c

227

dma_unmap_single(dma_dev, virt_to_phys(folio_address(folio)),

drivers/iommu/iommu-pages.c

47

struct folio *folio;

drivers/iommu/iommu-pages.c

66

folio = __folio_alloc_node(gfp | __GFP_ZERO, order, nid);

drivers/iommu/iommu-pages.c

67

if (unlikely(!folio))

drivers/iommu/iommu-pages.c

70

iopt = folio_ioptdesc(folio);

drivers/iommu/iommu-pages.c

83

mod_node_page_state(folio_pgdat(folio), NR_IOMMU_PAGES, pgcnt);

drivers/iommu/iommu-pages.c

84

lruvec_stat_mod_folio(folio, NR_SECONDARY_PAGETABLE, pgcnt);

drivers/iommu/iommu-pages.c

86

return folio_address(folio);

drivers/iommu/iommu-pages.c

92

struct folio *folio = ioptdesc_folio(iopt);

drivers/iommu/iommu-pages.c

93

const unsigned long pgcnt = folio_nr_pages(folio);

drivers/iommu/iommu-pages.c

98

mod_node_page_state(folio_pgdat(folio), NR_IOMMU_PAGES, -pgcnt);

drivers/iommu/iommu-pages.c

99

lruvec_stat_mod_folio(folio, NR_SECONDARY_PAGETABLE, -pgcnt);

drivers/iommu/iommu-pages.h

37

static inline struct ioptdesc *folio_ioptdesc(struct folio *folio)

drivers/iommu/iommu-pages.h

39

return (struct ioptdesc *)folio;

drivers/iommu/iommu-pages.h

42

static inline struct folio *ioptdesc_folio(struct ioptdesc *iopt)

drivers/iommu/iommu-pages.h

44

return (struct folio *)iopt;

drivers/iommu/iommufd/pages.c

663

static int batch_from_folios(struct pfn_batch *batch, struct folio ***folios_p,

drivers/iommu/iommufd/pages.c

667

struct folio **folios = *folios_p;

drivers/iommu/iommufd/pages.c

671

struct folio *folio = *folios;

drivers/iommu/iommufd/pages.c

672

unsigned long nr = folio_nr_pages(folio) - offset;

drivers/iommu/iommufd/pages.c

673

unsigned long pfn = page_to_pfn(folio_page(folio, offset));

drivers/iommu/iommufd/pages.c

681

rc = folio_add_pins(folio, nr - 1);

drivers/iommu/iommufd/pages.c

782

struct folio **ufolios;

drivers/iommu/iommufd/pages.c

785

struct folio **ufolios_next;

drivers/iommu/iommufd/pages.c

849

struct folio *folio = user->ufolios[i];

drivers/iommu/iommufd/pages.c

850

unsigned long nr = folio_nr_pages(folio);

drivers/iommu/iommufd/pages.c

858

*upages++ = folio_page(folio, offset);

drivers/iommu/iommufd/pages.c

860

int rc = folio_add_pins(folio, npin - 1);

drivers/iommu/iommufd/pages.c

866

*upages++ = folio_page(folio, offset++);

drivers/irqchip/irq-loongarch-ir.c

385

struct folio *folio;

drivers/irqchip/irq-loongarch-ir.c

387

folio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, IRD_TABLE_PAGE_ORDER, irde->node);

drivers/irqchip/irq-loongarch-ir.c

388

if (!folio) {

drivers/irqchip/irq-loongarch-ir.c

392

ird_table->table = folio_address(folio);

drivers/irqchip/irq-loongarch-ir.c

397

folio_put(folio);

drivers/irqchip/irq-loongarch-ir.c

411

struct folio *folio;

drivers/irqchip/irq-loongarch-ir.c

413

folio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, INV_QUEUE_PAGE_ORDER, irde->node);

drivers/irqchip/irq-loongarch-ir.c

414

if (!folio) {

drivers/irqchip/irq-loongarch-ir.c

419

inv_queue->cmd_base = folio_address(folio);

drivers/md/bcache/super.c

171

struct folio *folio;

drivers/md/bcache/super.c

174

folio = mapping_read_folio_gfp(bdev->bd_mapping,

drivers/md/bcache/super.c

176

if (IS_ERR(folio))

drivers/md/bcache/super.c

178

s = folio_address(folio) + offset_in_folio(folio, SB_OFFSET);

drivers/md/bcache/super.c

275

folio_put(folio);

drivers/md/dm-crypt.c

1707

if (folio_test_large(fi.folio)) {

drivers/md/dm-crypt.c

1709

folio_nr_pages(fi.folio));

drivers/md/dm-crypt.c

1710

folio_put(fi.folio);

drivers/md/dm-crypt.c

1712

mempool_free(&fi.folio->page, &cc->page_pool);

drivers/md/dm-flakey.c

413

folio_put(fi.folio);

drivers/misc/lkdtm/usercopy.c

405

struct folio *folio;

drivers/misc/lkdtm/usercopy.c

412

folio = folio_alloc(GFP_KERNEL | __GFP_ZERO, 1);

drivers/misc/lkdtm/usercopy.c

413

if (!folio) {

drivers/misc/lkdtm/usercopy.c

417

addr = folio_address(folio);

drivers/misc/lkdtm/usercopy.c

422

folio_put(folio);

drivers/pci/p2pdma.c

211

static void p2pdma_folio_free(struct folio *folio)

drivers/pci/p2pdma.c

213

struct page *page = &folio->page;

drivers/s390/net/ism_drv.c

232

struct folio *folio;

drivers/s390/net/ism_drv.c

251

folio = folio_alloc(GFP_KERNEL | __GFP_NOWARN | __GFP_NOMEMALLOC |

drivers/s390/net/ism_drv.c

254

if (!folio) {

drivers/s390/net/ism_drv.c

259

dmb->cpu_addr = folio_address(folio);

drivers/scsi/scsicam.c

37

struct folio *folio;

drivers/scsi/scsicam.c

39

folio = read_mapping_folio(mapping, 0, NULL);

drivers/scsi/scsicam.c

40

if (IS_ERR(folio))

drivers/scsi/scsicam.c

43

res = kmemdup(folio_address(folio) + 0x1be, 66, GFP_KERNEL);

drivers/scsi/scsicam.c

44

folio_put(folio);

fs/adfs/inode.c

43

static int adfs_read_folio(struct file *file, struct folio *folio)

fs/adfs/inode.c

45

return block_read_full_folio(folio, adfs_get_block);

fs/adfs/inode.c

59

struct folio **foliop, void **fsdata)

fs/affs/file.c

381

static int affs_read_folio(struct file *file, struct folio *folio)

fs/affs/file.c

383

return block_read_full_folio(folio, affs_get_block);

fs/affs/file.c

422

struct folio **foliop, void **fsdata)

fs/affs/file.c

438

struct folio *folio, void *fsdata)

fs/affs/file.c

443

ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/affs/file.c

528

static int affs_do_read_folio_ofs(struct folio *folio, size_t to, int create)

fs/affs/file.c

530

struct inode *inode = folio->mapping->host;

fs/affs/file.c

538

folio->index, to);

fs/affs/file.c

539

BUG_ON(to > folio_size(folio));

fs/affs/file.c

541

tmp = folio_pos(folio);

fs/affs/file.c

551

memcpy_to_folio(folio, pos, AFFS_DATA(bh) + boff, tmp);

fs/affs/file.c

632

static int affs_read_folio_ofs(struct file *file, struct folio *folio)

fs/affs/file.c

634

struct inode *inode = folio->mapping->host;

fs/affs/file.c

638

pr_debug("%s(%llu, %ld)\n", __func__, inode->i_ino, folio->index);

fs/affs/file.c

639

to = folio_size(folio);

fs/affs/file.c

640

if (folio_pos(folio) + to > inode->i_size) {

fs/affs/file.c

641

to = inode->i_size - folio_pos(folio);

fs/affs/file.c

642

folio_zero_segment(folio, to, folio_size(folio));

fs/affs/file.c

645

err = affs_do_read_folio_ofs(folio, to, 0);

fs/affs/file.c

647

folio_mark_uptodate(folio);

fs/affs/file.c

648

folio_unlock(folio);

fs/affs/file.c

655

struct folio **foliop, void **fsdata)

fs/affs/file.c

658

struct folio *folio;

fs/affs/file.c

674

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/affs/file.c

676

if (IS_ERR(folio))

fs/affs/file.c

677

return PTR_ERR(folio);

fs/affs/file.c

678

*foliop = folio;

fs/affs/file.c

680

if (folio_test_uptodate(folio))

fs/affs/file.c

684

err = affs_do_read_folio_ofs(folio, folio_size(folio), 1);

fs/affs/file.c

686

folio_unlock(folio);

fs/affs/file.c

687

folio_put(folio);

fs/affs/file.c

695

struct folio *folio, void *fsdata)

fs/affs/file.c

717

data = folio_address(folio);

fs/affs/file.c

721

tmp = (folio->index << PAGE_SHIFT) + from;

fs/affs/file.c

816

folio_mark_uptodate(folio);

fs/affs/file.c

820

tmp = (folio->index << PAGE_SHIFT) + from;

fs/affs/file.c

831

folio_unlock(folio);

fs/affs/file.c

832

folio_put(folio);

fs/affs/file.c

892

struct folio *folio;

fs/affs/file.c

897

res = mapping->a_ops->write_begin(NULL, mapping, isize, 0, &folio, &fsdata);

fs/affs/file.c

899

res = mapping->a_ops->write_end(NULL, mapping, isize, 0, 0, folio, fsdata);

fs/affs/symlink.c

14

static int affs_symlink_read_folio(struct file *file, struct folio *folio)

fs/affs/symlink.c

17

struct inode *inode = folio->mapping->host;

fs/affs/symlink.c

18

char *link = folio_address(folio);

fs/affs/symlink.c

60

folio_mark_uptodate(folio);

fs/affs/symlink.c

61

folio_unlock(folio);

fs/affs/symlink.c

64

folio_unlock(folio);

fs/afs/dir_edit.c

115

struct folio *folio;

fs/afs/dir_edit.c

142

folio = folioq_folio(fq, s);

fs/afs/dir_edit.c

143

if (WARN_ON_ONCE(folio_pos(folio) != fpos))

fs/afs/dir_edit.c

148

return kmap_local_folio(folio, blpos - fpos);

fs/afs/dir_search.c

100

if (WARN_ON_ONCE(folio_pos(folio) != fpos))

fs/afs/dir_search.c

105

iter->block = kmap_local_folio(folio, blpos - fpos);

fs/afs/dir_search.c

71

struct folio *folio;

fs/afs/dir_search.c

99

folio = folioq_folio(fq, slot);

fs/afs/file.c

417

struct folio **foliop, void **_fsdata)

fs/aio.c

125

struct folio **ring_folios;

fs/aio.c

1310

struct folio *folio;

fs/aio.c

1317

folio = ctx->ring_folios[pos / AIO_EVENTS_PER_PAGE];

fs/aio.c

1323

ev = folio_address(folio);

fs/aio.c

163

struct folio *internal_folios[AIO_RING_PAGES];

fs/aio.c

389

struct folio *folio = ctx->ring_folios[i];

fs/aio.c

391

if (!folio)

fs/aio.c

395

folio_ref_count(folio));

fs/aio.c

397

folio_put(folio);

fs/aio.c

460

static int aio_migrate_folio(struct address_space *mapping, struct folio *dst,

fs/aio.c

461

struct folio *src, enum migrate_mode mode)

fs/aio.c

567

ctx->ring_folios = kzalloc_objs(struct folio *, nr_pages);

fs/aio.c

575

struct folio *folio;

fs/aio.c

577

folio = __filemap_get_folio(file->f_mapping, i,

fs/aio.c

580

if (IS_ERR(folio))

fs/aio.c

584

folio_ref_count(folio));

fs/aio.c

585

folio_end_read(folio, true);

fs/aio.c

587

ctx->ring_folios[i] = folio;

fs/befs/linuxvfs.c

113

static int befs_read_folio(struct file *file, struct folio *folio)

fs/befs/linuxvfs.c

115

return block_read_full_folio(folio, befs_get_block);

fs/befs/linuxvfs.c

45

static int befs_read_folio(struct file *file, struct folio *folio);

fs/befs/linuxvfs.c

471

static int befs_symlink_read_folio(struct file *unused, struct folio *folio)

fs/befs/linuxvfs.c

473

struct inode *inode = folio->mapping->host;

fs/befs/linuxvfs.c

478

char *link = folio_address(folio);

fs/befs/linuxvfs.c

494

folio_end_read(folio, err == 0);

fs/befs/linuxvfs.c

53

static int befs_symlink_read_folio(struct file *, struct folio *);

fs/bfs/file.c

160

static int bfs_read_folio(struct file *file, struct folio *folio)

fs/bfs/file.c

162

return block_read_full_folio(folio, bfs_get_block);

fs/bfs/file.c

176

struct folio **foliop, void **fsdata)

fs/btrfs/btrfs_inode.h

583

struct folio *folio, u64 start, u64 len);

fs/btrfs/btrfs_inode.h

601

int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct folio *locked_folio,

fs/btrfs/compression.c

107

const u8 *data_in, struct folio *dest_folio,

fs/btrfs/compression.c

1086

int btrfs_decompress(int type, const u8 *data_in, struct folio *dest_folio,

fs/btrfs/compression.c

183

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info, gfp_t gfp)

fs/btrfs/compression.c

185

struct folio *folio = NULL;

fs/btrfs/compression.c

193

folio = list_first_entry(&compr_pool.list, struct folio, lru);

fs/btrfs/compression.c

194

list_del_init(&folio->lru);

fs/btrfs/compression.c

199

if (folio)

fs/btrfs/compression.c

200

return folio;

fs/btrfs/compression.c

206

void btrfs_free_compr_folio(struct folio *folio)

fs/btrfs/compression.c

211

if (folio_order(folio))

fs/btrfs/compression.c

218

list_add(&folio->lru, &compr_pool.list);

fs/btrfs/compression.c

227

ASSERT(folio_ref_count(folio) == 1);

fs/btrfs/compression.c

228

folio_put(folio);

fs/btrfs/compression.c

242

btrfs_free_compr_folio(fi.folio);

fs/btrfs/compression.c

273

struct folio *folio = fbatch.folios[i];

fs/btrfs/compression.c

275

btrfs_folio_clamp_clear_writeback(fs_info, folio,

fs/btrfs/compression.c

302

btrfs_free_compr_folio(fi.folio);

fs/btrfs/compression.c

376

struct folio *folio;

fs/btrfs/compression.c

412

folio = filemap_get_folio(mapping, pg_index);

fs/btrfs/compression.c

413

if (!IS_ERR(folio)) {

fs/btrfs/compression.c

414

u64 folio_sz = folio_size(folio);

fs/btrfs/compression.c

415

u64 offset = offset_in_folio(folio, cur);

fs/btrfs/compression.c

417

folio_put(folio);

fs/btrfs/compression.c

440

folio = filemap_alloc_folio(masked_constraint_gfp, 0, NULL);

fs/btrfs/compression.c

441

if (!folio)

fs/btrfs/compression.c

444

if (filemap_add_folio(mapping, folio, pg_index, cache_gfp)) {

fs/btrfs/compression.c

446

cur += folio_size(folio) - offset_in_folio(folio, cur);

fs/btrfs/compression.c

447

folio_put(folio);

fs/btrfs/compression.c

451

if (!*memstall && folio_test_workingset(folio)) {

fs/btrfs/compression.c

456

ret = set_folio_extent_mapped(folio);

fs/btrfs/compression.c

458

folio_unlock(folio);

fs/btrfs/compression.c

459

folio_put(folio);

fs/btrfs/compression.c

463

folio_end = folio_next_pos(folio) - 1;

fs/btrfs/compression.c

480

folio_unlock(folio);

fs/btrfs/compression.c

481

folio_put(folio);

fs/btrfs/compression.c

488

if (folio_contains(folio, end_index)) {

fs/btrfs/compression.c

489

size_t zero_offset = offset_in_folio(folio, isize);

fs/btrfs/compression.c

493

zeros = folio_size(folio) - zero_offset;

fs/btrfs/compression.c

494

folio_zero_range(folio, zero_offset, zeros);

fs/btrfs/compression.c

498

if (!bio_add_folio(orig_bio, folio, add_size,

fs/btrfs/compression.c

499

offset_in_folio(folio, cur))) {

fs/btrfs/compression.c

500

folio_unlock(folio);

fs/btrfs/compression.c

501

folio_put(folio);

fs/btrfs/compression.c

504

btrfs_folio_set_lock(fs_info, folio, cur, add_size);

fs/btrfs/compression.c

505

folio_put(folio);

fs/btrfs/compression.c

577

struct folio *folio;

fs/btrfs/compression.c

580

folio = btrfs_alloc_compr_folio(fs_info, gfp);

fs/btrfs/compression.c

581

if (!folio) {

fs/btrfs/compression.c

586

ret = bio_add_folio(&cb->bbio.bio, folio, cur_len, 0);

fs/btrfs/compression.c

588

folio_put(folio);

fs/btrfs/compression.c

975

struct folio **in_folio_ret)

fs/btrfs/compression.c

977

struct folio *in_folio;

fs/btrfs/compression.h

101

struct folio *btrfs_alloc_compr_folio(struct btrfs_fs_info *fs_info, gfp_t gfp);

fs/btrfs/compression.h

102

void btrfs_free_compr_folio(struct folio *folio);

fs/btrfs/compression.h

139

struct folio **in_folio_ret);

fs/btrfs/compression.h

150

btrfs_free_compr_folio(fi.folio);

fs/btrfs/compression.h

157

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/btrfs/compression.h

166

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/btrfs/compression.h

174

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/btrfs/compression.h

73

static inline u32 btrfs_calc_input_length(struct folio *folio, u64 range_end, u64 cur)

fs/btrfs/compression.h

76

ASSERT(folio_pos(folio) <= cur);

fs/btrfs/compression.h

77

ASSERT(cur < folio_next_pos(folio));

fs/btrfs/compression.h

78

return umin(range_end, folio_next_pos(folio)) - cur;

fs/btrfs/compression.h

88

int btrfs_decompress(int type, const u8 *data_in, struct folio *dest_folio,

fs/btrfs/defrag.c

1135

struct folio **folios, int nr_pages,

fs/btrfs/defrag.c

1158

struct folio *folio = folios[i];

fs/btrfs/defrag.c

1160

if (!folio)

fs/btrfs/defrag.c

1162

if (start >= folio_next_pos(folio) ||

fs/btrfs/defrag.c

1163

start + len <= folio_pos(folio))

fs/btrfs/defrag.c

1165

btrfs_folio_clamp_set_dirty(fs_info, folio, start, len);

fs/btrfs/defrag.c

1181

struct folio **folios;

fs/btrfs/defrag.c

1191

folios = kzalloc_objs(struct folio *, nr_pages, GFP_NOFS);

fs/btrfs/defrag.c

845

static struct folio *defrag_prepare_one_folio(struct btrfs_inode *inode, pgoff_t index)

fs/btrfs/defrag.c

852

struct folio *folio;

fs/btrfs/defrag.c

857

folio = __filemap_get_folio(mapping, index,

fs/btrfs/defrag.c

859

if (IS_ERR(folio))

fs/btrfs/defrag.c

860

return folio;

fs/btrfs/defrag.c

862

ret = set_folio_extent_mapped(folio);

fs/btrfs/defrag.c

864

folio_unlock(folio);

fs/btrfs/defrag.c

865

folio_put(folio);

fs/btrfs/defrag.c

869

lock_start = folio_pos(folio);

fs/btrfs/defrag.c

870

lock_end = folio_next_pos(folio) - 1;

fs/btrfs/defrag.c

876

ordered = btrfs_lookup_ordered_range(inode, lock_start, folio_size(folio));

fs/btrfs/defrag.c

881

folio_unlock(folio);

fs/btrfs/defrag.c

884

folio_lock(folio);

fs/btrfs/defrag.c

889

if (folio->mapping != mapping || !folio->private) {

fs/btrfs/defrag.c

890

folio_unlock(folio);

fs/btrfs/defrag.c

891

folio_put(folio);

fs/btrfs/defrag.c

900

if (!folio_test_uptodate(folio)) {

fs/btrfs/defrag.c

901

btrfs_read_folio(NULL, folio);

fs/btrfs/defrag.c

902

folio_lock(folio);

fs/btrfs/defrag.c

903

if (folio->mapping != mapping || !folio->private) {

fs/btrfs/defrag.c

904

folio_unlock(folio);

fs/btrfs/defrag.c

905

folio_put(folio);

fs/btrfs/defrag.c

908

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/defrag.c

909

folio_unlock(folio);

fs/btrfs/defrag.c

910

folio_put(folio);

fs/btrfs/defrag.c

914

return folio;

fs/btrfs/disk-io.c

187

struct folio *folio = eb->folios[i];

fs/btrfs/disk-io.c

190

ASSERT(folio_order(folio) == 0);

fs/btrfs/disk-io.c

200

paddrs[i] = page_to_phys(&folio->page) + offset_in_page(eb->start);

fs/btrfs/disk-io.c

3830

folio_unlock(fi.folio);

fs/btrfs/disk-io.c

3831

folio_put(fi.folio);

fs/btrfs/disk-io.c

3858

struct folio *folio;

fs/btrfs/disk-io.c

3883

folio = __filemap_get_folio(mapping, bytenr >> PAGE_SHIFT,

fs/btrfs/disk-io.c

3886

if (IS_ERR(folio)) {

fs/btrfs/disk-io.c

3889

bytenr, PTR_ERR(folio));

fs/btrfs/disk-io.c

3894

offset = offset_in_folio(folio, bytenr);

fs/btrfs/disk-io.c

3895

disk_super = folio_address(folio) + offset;

fs/btrfs/disk-io.c

3909

bio_add_folio_nofail(bio, folio, BTRFS_SUPER_INFO_SIZE, offset);

fs/btrfs/disk-io.c

3942

struct folio *folio;

fs/btrfs/disk-io.c

3957

folio = filemap_get_folio(device->bdev->bd_mapping,

fs/btrfs/disk-io.c

3960

if (IS_ERR(folio))

fs/btrfs/disk-io.c

3964

folio_wait_locked(folio);

fs/btrfs/disk-io.c

3965

folio_put(folio);

fs/btrfs/disk-io.c

462

struct folio *dst, struct folio *src, enum migrate_mode mode)

fs/btrfs/disk-io.c

483

static bool btree_release_folio(struct folio *folio, gfp_t gfp_flags)

fs/btrfs/disk-io.c

485

if (folio_test_writeback(folio) || folio_test_dirty(folio))

fs/btrfs/disk-io.c

488

return try_release_extent_buffer(folio);

fs/btrfs/disk-io.c

491

static void btree_invalidate_folio(struct folio *folio, size_t offset,

fs/btrfs/disk-io.c

494

struct extent_io_tree *tree = &folio_to_inode(folio)->io_tree;

fs/btrfs/disk-io.c

496

const u64 start = folio_pos(folio);

fs/btrfs/disk-io.c

497

const u64 end = folio_next_pos(folio) - 1;

fs/btrfs/disk-io.c

505

ASSERT(offset == 0, "folio=%llu offset=%zu", folio_pos(folio), offset);

fs/btrfs/disk-io.c

506

ASSERT(length == folio_size(folio), "folio=%llu folio_size=%zu length=%zu",

fs/btrfs/disk-io.c

507

folio_pos(folio), folio_size(folio), length);

fs/btrfs/disk-io.c

513

folio_wait_writeback(folio);

fs/btrfs/disk-io.c

522

btree_release_folio(folio, GFP_NOFS);

fs/btrfs/disk-io.c

523

if (folio_get_private(folio)) {

fs/btrfs/disk-io.c

524

btrfs_warn(folio_to_fs_info(folio),

fs/btrfs/disk-io.c

526

(unsigned long long)folio_pos(folio));

fs/btrfs/disk-io.c

527

folio_detach_private(folio);

fs/btrfs/disk-io.c

533

struct folio *folio)

fs/btrfs/disk-io.c

540

u64 page_start = folio_pos(folio);

fs/btrfs/disk-io.c

543

eb = folio_get_private(folio);

fs/btrfs/disk-io.c

548

return filemap_dirty_folio(mapping, folio);

fs/btrfs/disk-io.c

552

subpage = folio_get_private(folio);

fs/btrfs/disk-io.c

577

return filemap_dirty_folio(mapping, folio);

fs/btrfs/extent_io.c

1031

static int btrfs_do_readpage(struct folio *folio, struct extent_map **em_cached,

fs/btrfs/extent_io.c

1035

struct inode *inode = folio->mapping->host;

fs/btrfs/extent_io.c

1037

u64 start = folio_pos(folio);

fs/btrfs/extent_io.c

1038

const u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1051

ret = set_folio_extent_mapped(folio);

fs/btrfs/extent_io.c

1053

folio_unlock(folio);

fs/btrfs/extent_io.c

1057

if (folio_contains(folio, last_byte >> PAGE_SHIFT)) {

fs/btrfs/extent_io.c

1058

size_t zero_offset = offset_in_folio(folio, last_byte);

fs/btrfs/extent_io.c

1061

folio_zero_range(folio, zero_offset,

fs/btrfs/extent_io.c

1062

folio_size(folio) - zero_offset);

fs/btrfs/extent_io.c

1065

begin_folio_read(fs_info, folio);

fs/btrfs/extent_io.c

1068

unsigned long pg_offset = offset_in_folio(folio, cur);

fs/btrfs/extent_io.c

1077

folio_zero_range(folio, pg_offset, end - cur + 1);

fs/btrfs/extent_io.c

1078

end_folio_read(vi, folio, true, cur, end - cur + 1);

fs/btrfs/extent_io.c

1081

if (btrfs_folio_test_uptodate(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1082

end_folio_read(vi, folio, true, cur, blocksize);

fs/btrfs/extent_io.c

1092

em = get_extent_map(BTRFS_I(inode), folio, cur, locked_end - cur + 1, em_cached);

fs/btrfs/extent_io.c

1094

end_folio_read(vi, folio, false, cur, end + 1 - cur);

fs/btrfs/extent_io.c

1109

!btrfs_is_subpage(fs_info, folio) &&

fs/btrfs/extent_io.c

1170

folio_zero_range(folio, pg_offset, blocksize);

fs/btrfs/extent_io.c

1171

end_folio_read(vi, folio, true, cur, blocksize);

fs/btrfs/extent_io.c

1176

end_folio_read(vi, folio, true, cur, blocksize);

fs/btrfs/extent_io.c

1187

queued = submit_extent_folio(bio_ctrl, disk_bytenr, folio, blocksize,

fs/btrfs/extent_io.c

1214

struct folio *folio;

fs/btrfs/extent_io.c

1219

folio = filemap_get_folio(inode->vfs_inode.i_mapping, cur >> PAGE_SHIFT);

fs/btrfs/extent_io.c

1225

ASSERT(!IS_ERR(folio));

fs/btrfs/extent_io.c

1226

ASSERT(folio_test_locked(folio));

fs/btrfs/extent_io.c

1240

if (!folio_test_private(folio)) {

fs/btrfs/extent_io.c

1255

if (btrfs_folio_test_dirty(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1256

u64 range_len = umin(folio_next_pos(folio),

fs/btrfs/extent_io.c

1264

ASSERT(btrfs_folio_test_dirty(fs_info, folio, cur, range_len));

fs/btrfs/extent_io.c

1277

if (btrfs_folio_test_uptodate(fs_info, folio, cur, blocksize)) {

fs/btrfs/extent_io.c

1278

u64 range_len = umin(folio_next_pos(folio),

fs/btrfs/extent_io.c

1285

ASSERT(btrfs_folio_test_uptodate(fs_info, folio, cur, range_len));

fs/btrfs/extent_io.c

1301

folio_put(folio);

fs/btrfs/extent_io.c

1373

int btrfs_read_folio(struct file *file, struct folio *folio)

fs/btrfs/extent_io.c

1375

struct inode *vfs_inode = folio->mapping->host;

fs/btrfs/extent_io.c

1377

const u64 start = folio_pos(folio);

fs/btrfs/extent_io.c

1378

const u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1389

if (folio_pos(folio) < i_size_read(vfs_inode))

fs/btrfs/extent_io.c

1391

ret = btrfs_do_readpage(folio, &em_cached, &bio_ctrl, vi);

fs/btrfs/extent_io.c

1404

static void set_delalloc_bitmap(struct folio *folio, unsigned long *delalloc_bitmap,

fs/btrfs/extent_io.c

1407

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1408

const u64 folio_start = folio_pos(folio);

fs/btrfs/extent_io.c

1412

ASSERT(start >= folio_start && start + len <= folio_start + folio_size(folio));

fs/btrfs/extent_io.c

1419

static bool find_next_delalloc_bitmap(struct folio *folio,

fs/btrfs/extent_io.c

1423

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

1424

const u64 folio_start = folio_pos(folio);

fs/btrfs/extent_io.c

1425

const unsigned int bitmap_size = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1430

ASSERT(start >= folio_start && start < folio_start + folio_size(folio));

fs/btrfs/extent_io.c

1459

struct folio *folio,

fs/btrfs/extent_io.c

1464

const bool is_subpage = btrfs_is_subpage(fs_info, folio);

fs/btrfs/extent_io.c

1465

const u64 page_start = folio_pos(folio);

fs/btrfs/extent_io.c

1466

const u64 page_end = page_start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

1467

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1493

btrfs_copy_subpage_dirty_bitmap(fs_info, folio, bio_ctrl->submit_bitmap);

fs/btrfs/extent_io.c

1500

btrfs_folio_set_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1506

if (!find_lock_delalloc_range(&inode->vfs_inode, folio,

fs/btrfs/extent_io.c

1511

set_delalloc_bitmap(folio, delalloc_bitmap, delalloc_start,

fs/btrfs/extent_io.c

1537

found = find_next_delalloc_bitmap(folio, delalloc_bitmap,

fs/btrfs/extent_io.c

1558

ret = btrfs_run_delalloc_range(inode, folio,

fs/btrfs/extent_io.c

1569

folio_pos(folio),

fs/btrfs/extent_io.c

1580

unlock_delalloc_folio(&inode->vfs_inode, folio,

fs/btrfs/extent_io.c

1666

struct folio *folio,

fs/btrfs/extent_io.c

1698

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1699

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1700

btrfs_folio_clear_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1733

btrfs_folio_clear_dirty(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1734

btrfs_folio_set_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1741

ASSERT(folio_test_writeback(folio));

fs/btrfs/extent_io.c

1743

queued = submit_extent_folio(bio_ctrl, disk_bytenr, folio,

fs/btrfs/extent_io.c

1744

sectorsize, filepos - folio_pos(folio), 0);

fs/btrfs/extent_io.c

1746

btrfs_folio_clear_writeback(fs_info, folio, filepos, sectorsize);

fs/btrfs/extent_io.c

1763

struct folio *folio,

fs/btrfs/extent_io.c

1772

const u64 folio_start = folio_pos(folio);

fs/btrfs/extent_io.c

1773

const u64 folio_end = folio_start + folio_size(folio);

fs/btrfs/extent_io.c

1774

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1781

start, len, folio_start, folio_size(folio));

fs/btrfs/extent_io.c

1795

cur = folio_pos(folio) + (bit << fs_info->sectorsize_bits);

fs/btrfs/extent_io.c

1823

btrfs_folio_clear_dirty(fs_info, folio, cur, fs_info->sectorsize);

fs/btrfs/extent_io.c

1826

ret = submit_one_sector(inode, folio, cur, bio_ctrl, i_size);

fs/btrfs/extent_io.c

1847

btrfs_folio_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1848

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

1854

struct folio *folio,

fs/btrfs/extent_io.c

1857

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1881

static int extent_writepage(struct folio *folio, struct btrfs_bio_ctrl *bio_ctrl)

fs/btrfs/extent_io.c

1883

struct btrfs_inode *inode = BTRFS_I(folio->mapping->host);

fs/btrfs/extent_io.c

1889

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/extent_io.c

1891

trace_extent_writepage(folio, &inode->vfs_inode, bio_ctrl->wbc);

fs/btrfs/extent_io.c

1893

WARN_ON(!folio_test_locked(folio));

fs/btrfs/extent_io.c

1895

pg_offset = offset_in_folio(folio, i_size);

fs/btrfs/extent_io.c

1896

if (folio->index > end_index ||

fs/btrfs/extent_io.c

1897

(folio->index == end_index && !pg_offset)) {

fs/btrfs/extent_io.c

1898

folio_invalidate(folio, 0, folio_size(folio));

fs/btrfs/extent_io.c

1899

folio_unlock(folio);

fs/btrfs/extent_io.c

1903

if (folio_contains(folio, end_index))

fs/btrfs/extent_io.c

1904

folio_zero_range(folio, pg_offset, folio_size(folio) - pg_offset);

fs/btrfs/extent_io.c

1906

bio_ctrl_init_submit_bitmap(fs_info, folio, bio_ctrl);

fs/btrfs/extent_io.c

1916

if (unlikely(!folio_test_private(folio))) {

fs/btrfs/extent_io.c

1921

btrfs_ino(inode), folio_pos(folio));

fs/btrfs/extent_io.c

1926

ret = set_folio_extent_mapped(folio);

fs/btrfs/extent_io.c

1930

ret = writepage_delalloc(inode, folio, bio_ctrl);

fs/btrfs/extent_io.c

1936

ret = extent_writepage_io(inode, folio, folio_pos(folio),

fs/btrfs/extent_io.c

1937

folio_size(folio), bio_ctrl, i_size);

fs/btrfs/extent_io.c

1944

folio_pos(folio), blocks_per_folio,

fs/btrfs/extent_io.c

1951

mapping_set_error(folio->mapping, ret);

fs/btrfs/extent_io.c

1956

btrfs_folio_end_lock_bitmap(fs_info, folio, bio_ctrl->submit_bitmap);

fs/btrfs/extent_io.c

2246

btrfs_meta_folio_clear_writeback(fi.folio, eb);

fs/btrfs/extent_io.c

2298

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

2299

u64 range_start = max_t(u64, eb->start, folio_pos(folio));

fs/btrfs/extent_io.c

2300

u32 range_len = min_t(u64, folio_next_pos(folio),

fs/btrfs/extent_io.c

2303

folio_lock(folio);

fs/btrfs/extent_io.c

2304

btrfs_meta_folio_clear_dirty(folio, eb);

fs/btrfs/extent_io.c

2305

btrfs_meta_folio_set_writeback(folio, eb);

fs/btrfs/extent_io.c

2306

if (!folio_test_dirty(folio))

fs/btrfs/extent_io.c

2307

wbc->nr_to_write -= folio_nr_pages(folio);

fs/btrfs/extent_io.c

2308

bio_add_folio_nofail(&bbio->bio, folio, range_len,

fs/btrfs/extent_io.c

2309

offset_in_folio(folio, range_start));

fs/btrfs/extent_io.c

2310

wbc_account_cgroup_owner(wbc, folio, range_len);

fs/btrfs/extent_io.c

2311

folio_unlock(folio);

fs/btrfs/extent_io.c

246

struct folio *folio, const struct folio *locked_folio,

fs/btrfs/extent_io.c

2537

struct folio *folio = fbatch.folios[i];

fs/btrfs/extent_io.c

2539

done_index = folio_next_index(folio);

fs/btrfs/extent_io.c

2545

if (!folio_trylock(folio)) {

fs/btrfs/extent_io.c

2547

folio_lock(folio);

fs/btrfs/extent_io.c

255

btrfs_folio_clamp_clear_dirty(fs_info, folio, start, len);

fs/btrfs/extent_io.c

2550

if (unlikely(folio->mapping != mapping)) {

fs/btrfs/extent_io.c

2551

folio_unlock(folio);

fs/btrfs/extent_io.c

2555

if (!folio_test_dirty(folio)) {

fs/btrfs/extent_io.c

2557

folio_unlock(folio);

fs/btrfs/extent_io.c

256

btrfs_folio_clamp_set_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

2581

btrfs_is_subpage(inode_to_fs_info(inode), folio)) {

fs/btrfs/extent_io.c

2582

if (folio_test_writeback(folio))

fs/btrfs/extent_io.c

2584

folio_wait_writeback(folio);

fs/btrfs/extent_io.c

2587

if (folio_test_writeback(folio) ||

fs/btrfs/extent_io.c

2588

!folio_test_dirty(folio)) {

fs/btrfs/extent_io.c

2589

folio_unlock(folio);

fs/btrfs/extent_io.c

259

btrfs_folio_clamp_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

2593

ret = extent_writepage(folio, bio_ctrl);

fs/btrfs/extent_io.c

261

if (folio != locked_folio && (page_ops & PAGE_UNLOCK))

fs/btrfs/extent_io.c

262

btrfs_folio_end_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

2640

void extent_write_locked_range(struct inode *inode, const struct folio *locked_folio,

fs/btrfs/extent_io.c

266

const struct folio *locked_folio, u64 start,

fs/btrfs/extent_io.c

2664

struct folio *folio;

fs/btrfs/extent_io.c

2666

folio = filemap_get_folio(mapping, cur >> PAGE_SHIFT);

fs/btrfs/extent_io.c

2672

if (IS_ERR(folio)) {

fs/btrfs/extent_io.c

2676

mapping_set_error(mapping, PTR_ERR(folio));

fs/btrfs/extent_io.c

2681

cur_end = min_t(u64, folio_next_pos(folio) - 1, end);

fs/btrfs/extent_io.c

2684

ASSERT(folio_test_locked(folio));

fs/btrfs/extent_io.c

2685

if (pages_dirty && folio != locked_folio)

fs/btrfs/extent_io.c

2686

ASSERT(folio_test_dirty(folio));

fs/btrfs/extent_io.c

2692

bio_ctrl_init_submit_bitmap(fs_info, folio, &bio_ctrl);

fs/btrfs/extent_io.c

2693

ret = extent_writepage_io(BTRFS_I(inode), folio, cur, cur_len,

fs/btrfs/extent_io.c

2700

btrfs_folio_end_lock(fs_info, folio, cur, cur_len);

fs/btrfs/extent_io.c

2704

folio_put(folio);

fs/btrfs/extent_io.c

2738

struct folio *folio;

fs/btrfs/extent_io.c

2750

while ((folio = readahead_folio(rac)) != NULL)

fs/btrfs/extent_io.c

2751

btrfs_do_readpage(folio, &em_cached, &bio_ctrl, vi);

fs/btrfs/extent_io.c

2766

struct folio *folio)

fs/btrfs/extent_io.c

2769

u64 start = folio_pos(folio);

fs/btrfs/extent_io.c

2770

u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

2812

bool try_release_extent_mapping(struct folio *folio, gfp_t mask)

fs/btrfs/extent_io.c

2814

u64 start = folio_pos(folio);

fs/btrfs/extent_io.c

2815

u64 end = start + folio_size(folio) - 1;

fs/btrfs/extent_io.c

2816

struct btrfs_inode *inode = folio_to_inode(folio);

fs/btrfs/extent_io.c

282

struct folio *folio = fbatch.folios[i];

fs/btrfs/extent_io.c

284

process_one_folio(fs_info, folio, locked_folio,

fs/btrfs/extent_io.c

2886

return try_release_extent_state(io_tree, folio);

fs/btrfs/extent_io.c

2889

static bool folio_range_has_eb(struct folio *folio)

fs/btrfs/extent_io.c

2893

lockdep_assert_held(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

2895

if (folio_test_private(folio)) {

fs/btrfs/extent_io.c

2896

bfs = folio_get_private(folio);

fs/btrfs/extent_io.c

2903

static void detach_extent_buffer_folio(const struct extent_buffer *eb, struct folio *folio)

fs/btrfs/extent_io.c

2906

struct address_space *mapping = folio->mapping;

fs/btrfs/extent_io.c

2916

if (!folio_test_private(folio)) {

fs/btrfs/extent_io.c

2929

if (folio_test_private(folio) && folio_get_private(folio) == eb) {

fs/btrfs/extent_io.c

293

struct folio *locked_folio,

fs/btrfs/extent_io.c

2931

BUG_ON(folio_test_dirty(folio));

fs/btrfs/extent_io.c

2932

BUG_ON(folio_test_writeback(folio));

fs/btrfs/extent_io.c

2934

folio_detach_private(folio);

fs/btrfs/extent_io.c

2947

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

2951

btrfs_folio_dec_eb_refs(fs_info, folio);

fs/btrfs/extent_io.c

2957

if (!folio_range_has_eb(folio))

fs/btrfs/extent_io.c

2958

btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

2969

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

2971

if (!folio)

fs/btrfs/extent_io.c

2974

detach_extent_buffer_folio(eb, folio);

fs/btrfs/extent_io.c

303

struct folio *locked_folio,

fs/btrfs/extent_io.c

3112

struct folio *folio = new->folios[i];

fs/btrfs/extent_io.c

3114

ret = attach_extent_buffer_folio(new, folio, NULL);

fs/btrfs/extent_io.c

3117

WARN_ON(folio_test_dirty(folio));

fs/btrfs/extent_io.c

323

struct folio *folio = fbatch.folios[i];

fs/btrfs/extent_io.c

327

if (folio == locked_folio)

fs/btrfs/extent_io.c

3286

struct folio *folio)

fs/btrfs/extent_io.c

3290

lockdep_assert_held(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

330

folio_lock(folio);

fs/btrfs/extent_io.c

3301

if (!folio_test_private(folio))

fs/btrfs/extent_io.c

331

if (!folio_test_dirty(folio) || folio->mapping != mapping) {

fs/btrfs/extent_io.c

3310

exists = folio_get_private(folio);

fs/btrfs/extent_io.c

3314

WARN_ON(folio_test_dirty(folio));

fs/btrfs/extent_io.c

3315

folio_detach_private(folio);

fs/btrfs/extent_io.c

332

folio_unlock(folio);

fs/btrfs/extent_io.c

335

range_start = max_t(u64, folio_pos(folio), start);

fs/btrfs/extent_io.c

336

range_len = min_t(u64, folio_next_pos(folio), end + 1) - range_start;

fs/btrfs/extent_io.c

3368

struct folio *existing_folio;

fs/btrfs/extent_io.c

337

btrfs_folio_set_lock(fs_info, folio, range_start, range_len);

fs/btrfs/extent_io.c

3510

struct folio *folio;

fs/btrfs/extent_io.c

3548

folio = eb->folios[i];

fs/btrfs/extent_io.c

3549

WARN_ON(btrfs_meta_folio_test_dirty(folio, eb));

fs/btrfs/extent_io.c

3557

if (i && folio_page(eb->folios[i - 1], 0) + 1 != folio_page(folio, 0))

fs/btrfs/extent_io.c

3560

if (!btrfs_meta_folio_test_uptodate(folio, eb))

fs/btrfs/extent_io.c

3628

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

3631

ASSERT(folio);

fs/btrfs/extent_io.c

3632

detach_extent_buffer_folio(eb, folio);

fs/btrfs/extent_io.c

3633

folio_unlock(folio);

fs/btrfs/extent_io.c

3634

} else if (!folio) {

fs/btrfs/extent_io.c

3638

folio_put(folio);

fs/btrfs/extent_io.c

370

struct folio *locked_folio,

fs/btrfs/extent_io.c

3781

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

3784

if (!folio_test_dirty(folio))

fs/btrfs/extent_io.c

3786

folio_lock(folio);

fs/btrfs/extent_io.c

3787

last = btrfs_meta_folio_clear_and_test_dirty(folio, eb);

fs/btrfs/extent_io.c

3789

btrfs_clear_folio_dirty_tag(folio);

fs/btrfs/extent_io.c

3790

folio_unlock(folio);

fs/btrfs/extent_io.c

3843

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

3845

if (!folio)

fs/btrfs/extent_io.c

3848

btrfs_meta_folio_clear_uptodate(folio, eb);

fs/btrfs/extent_io.c

3953

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

3954

u64 range_start = max_t(u64, eb->start, folio_pos(folio));

fs/btrfs/extent_io.c

3955

u32 range_len = min_t(u64, folio_next_pos(folio),

fs/btrfs/extent_io.c

3958

bio_add_folio_nofail(&bbio->bio, folio, range_len,

fs/btrfs/extent_io.c

3959

offset_in_folio(folio, range_start));

fs/btrfs/extent_io.c

4134

struct folio *folio = eb->folios[i];

fs/btrfs/extent_io.c

4136

ASSERT(folio);

fs/btrfs/extent_io.c

4150

folio = eb->folios[0];

fs/btrfs/extent_io.c

4152

if (WARN_ON(!btrfs_subpage_test_uptodate(fs_info, folio,

fs/btrfs/extent_io.c

4154

btrfs_subpage_dump_bitmap(fs_info, folio, eb->start, eb->len);

fs/btrfs/extent_io.c

4156

WARN_ON(!folio_test_uptodate(folio));

fs/btrfs/extent_io.c

4524

static int try_release_subpage_extent_buffer(struct folio *folio)

fs/btrfs/extent_io.c

4526

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

4528

unsigned long start = (folio_pos(folio) >> fs_info->nodesize_bits);

fs/btrfs/extent_io.c

4573

spin_lock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

4574

if (!folio_test_private(folio))

fs/btrfs/extent_io.c

4578

spin_unlock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

4582

int try_release_extent_buffer(struct folio *folio)

fs/btrfs/extent_io.c

4586

if (btrfs_meta_is_subpage(folio_to_fs_info(folio)))

fs/btrfs/extent_io.c

4587

return try_release_subpage_extent_buffer(folio);

fs/btrfs/extent_io.c

4593

spin_lock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

4594

if (!folio_test_private(folio)) {

fs/btrfs/extent_io.c

4595

spin_unlock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

4599

eb = folio_get_private(folio);

fs/btrfs/extent_io.c

4610

spin_unlock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

4613

spin_unlock(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

468

const struct folio *locked_folio,

fs/btrfs/extent_io.c

478

static bool btrfs_verify_folio(struct fsverity_info *vi, struct folio *folio,

fs/btrfs/extent_io.c

481

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

483

if (!vi || btrfs_folio_test_uptodate(fs_info, folio, start, len))

fs/btrfs/extent_io.c

485

return fsverity_verify_folio(vi, folio);

fs/btrfs/extent_io.c

488

static void end_folio_read(struct fsverity_info *vi, struct folio *folio,

fs/btrfs/extent_io.c

491

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

493

ASSERT(folio_pos(folio) <= start &&

fs/btrfs/extent_io.c

494

start + len <= folio_next_pos(folio));

fs/btrfs/extent_io.c

496

if (uptodate && btrfs_verify_folio(vi, folio, start, len))

fs/btrfs/extent_io.c

497

btrfs_folio_set_uptodate(fs_info, folio, start, len);

fs/btrfs/extent_io.c

499

btrfs_folio_clear_uptodate(fs_info, folio, start, len);

fs/btrfs/extent_io.c

501

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

502

folio_unlock(folio);

fs/btrfs/extent_io.c

504

btrfs_folio_end_lock(fs_info, folio, start, len);

fs/btrfs/extent_io.c

527

struct folio *folio = fi.folio;

fs/btrfs/extent_io.c

528

u64 start = folio_pos(folio) + fi.offset;

fs/btrfs/extent_io.c

532

btrfs_folio_clear_writeback(fs_info, folio, start, len);

fs/btrfs/extent_io.c

542

static void begin_folio_read(struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/extent_io.c

544

ASSERT(folio_test_locked(folio));

fs/btrfs/extent_io.c

545

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

548

ASSERT(folio_test_private(folio));

fs/btrfs/extent_io.c

549

btrfs_folio_set_lock(fs_info, folio, folio_pos(folio), folio_size(folio));

fs/btrfs/extent_io.c

579

struct folio *folio = fi.folio;

fs/btrfs/extent_io.c

580

u64 start = folio_pos(folio) + fi.offset;

fs/btrfs/extent_io.c

602

if (folio_contains(folio, i_size >> PAGE_SHIFT) &&

fs/btrfs/extent_io.c

604

u32 zero_start = max(offset_in_folio(folio, i_size),

fs/btrfs/extent_io.c

605

offset_in_folio(folio, start));

fs/btrfs/extent_io.c

606

u32 zero_len = offset_in_folio(folio, end) + 1 -

fs/btrfs/extent_io.c

609

folio_zero_range(folio, zero_start, zero_len);

fs/btrfs/extent_io.c

614

end_folio_read(vi, folio, uptodate, start, fi.length);

fs/btrfs/extent_io.c

632

struct folio **folio_array, gfp_t gfp)

fs/btrfs/extent_io.c

796

u64 disk_bytenr, struct folio *folio,

fs/btrfs/extent_io.c

800

struct btrfs_inode *inode = folio_to_inode(folio);

fs/btrfs/extent_io.c

801

loff_t file_offset = folio_pos(folio) + pg_offset;

fs/btrfs/extent_io.c

804

ASSERT(pg_offset + size <= folio_size(folio));

fs/btrfs/extent_io.c

830

if (!bio_add_folio(&bio_ctrl->bbio->bio, folio, len, pg_offset)) {

fs/btrfs/extent_io.c

843

wbc_account_cgroup_owner(bio_ctrl->wbc, folio, len);

fs/btrfs/extent_io.c

893

struct folio *folio,

fs/btrfs/extent_io.c

905

if (folio->mapping)

fs/btrfs/extent_io.c

906

lockdep_assert_held(&folio->mapping->i_private_lock);

fs/btrfs/extent_io.c

909

if (!folio_test_private(folio))

fs/btrfs/extent_io.c

910

folio_attach_private(folio, eb);

fs/btrfs/extent_io.c

912

WARN_ON(folio_get_private(folio) != eb);

fs/btrfs/extent_io.c

917

if (folio_test_private(folio)) {

fs/btrfs/extent_io.c

924

folio_attach_private(folio, prealloc);

fs/btrfs/extent_io.c

927

ret = btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_METADATA);

fs/btrfs/extent_io.c

931

int set_folio_extent_mapped(struct folio *folio)

fs/btrfs/extent_io.c

935

ASSERT(folio->mapping);

fs/btrfs/extent_io.c

937

if (folio_test_private(folio))

fs/btrfs/extent_io.c

940

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

942

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

943

return btrfs_attach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.c

945

folio_attach_private(folio, (void *)EXTENT_FOLIO_PRIVATE);

fs/btrfs/extent_io.c

949

void clear_folio_extent_mapped(struct folio *folio)

fs/btrfs/extent_io.c

953

ASSERT(folio->mapping);

fs/btrfs/extent_io.c

963

ASSERT(!folio_test_dirty(folio));

fs/btrfs/extent_io.c

964

ASSERT(!folio_test_writeback(folio));

fs/btrfs/extent_io.c

966

if (!folio_test_private(folio))

fs/btrfs/extent_io.c

969

fs_info = folio_to_fs_info(folio);

fs/btrfs/extent_io.c

970

if (btrfs_is_subpage(fs_info, folio))

fs/btrfs/extent_io.c

971

return btrfs_detach_folio_state(fs_info, folio, BTRFS_SUBPAGE_DATA);

fs/btrfs/extent_io.c

973

folio_detach_private(folio);

fs/btrfs/extent_io.c

977

struct folio *folio, u64 start,

fs/btrfs/extent_io.c

996

em = btrfs_get_extent(inode, folio, start, len);

fs/btrfs/extent_io.h

115

struct folio *folios[INLINE_EXTENT_BUFFER_PAGES];

fs/btrfs/extent_io.h

21

struct folio;

fs/btrfs/extent_io.h

254

bool try_release_extent_mapping(struct folio *folio, gfp_t mask);

fs/btrfs/extent_io.h

255

int try_release_extent_buffer(struct folio *folio);

fs/btrfs/extent_io.h

257

int btrfs_read_folio(struct file *file, struct folio *folio);

fs/btrfs/extent_io.h

258

void extent_write_locked_range(struct inode *inode, const struct folio *locked_folio,

fs/btrfs/extent_io.h

265

int set_folio_extent_mapped(struct folio *folio);

fs/btrfs/extent_io.h

266

void clear_folio_extent_mapped(struct folio *folio);

fs/btrfs/extent_io.h

386

const struct folio *locked_folio,

fs/btrfs/extent_io.h

392

static inline void btrfs_clear_folio_dirty_tag(struct folio *folio)

fs/btrfs/extent_io.h

394

ASSERT(!folio_test_dirty(folio));

fs/btrfs/extent_io.h

395

ASSERT(folio_test_locked(folio));

fs/btrfs/extent_io.h

396

ASSERT(folio->mapping);

fs/btrfs/extent_io.h

397

xa_lock_irq(&folio->mapping->i_pages);

fs/btrfs/extent_io.h

398

__xa_clear_mark(&folio->mapping->i_pages, folio->index,

fs/btrfs/extent_io.h

400

xa_unlock_irq(&folio->mapping->i_pages);

fs/btrfs/extent_io.h

405

struct folio **folio_array, gfp_t gfp);

fs/btrfs/extent_io.h

409

struct folio *locked_folio, u64 *start,

fs/btrfs/file.c

1197

struct folio *folio = NULL;

fs/btrfs/file.c

1234

ret = prepare_one_folio(&inode->vfs_inode, &folio, start, write_bytes, false);

fs/btrfs/file.c

1246

if (reserved_start + reserved_len > folio_next_pos(folio)) {

fs/btrfs/file.c

1247

const u64 last_block = folio_next_pos(folio);

fs/btrfs/file.c

1256

extents_locked = lock_and_cleanup_extent_if_need(inode, folio, start,

fs/btrfs/file.c

1270

copied = copy_folio_from_iter_atomic(folio, offset_in_folio(folio, start),

fs/btrfs/file.c

1272

flush_dcache_folio(folio);

fs/btrfs/file.c

1284

if (!folio_test_uptodate(folio)) {

fs/btrfs/file.c

1299

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1312

ret = btrfs_dirty_folio(inode, folio, start, copied, &cached_state,

fs/btrfs/file.c

1328

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1336

btrfs_drop_folio(fs_info, folio, start, copied);

fs/btrfs/file.c

1844

struct folio *folio = page_folio(page);

fs/btrfs/file.c

1853

size_t fsize = folio_size(folio);

fs/btrfs/file.c

1864

page_start = folio_pos(folio);

fs/btrfs/file.c

1865

page_end = page_start + folio_size(folio) - 1;

fs/btrfs/file.c

1909

folio_lock(folio);

fs/btrfs/file.c

1912

if ((folio->mapping != inode->vfs_inode.i_mapping) ||

fs/btrfs/file.c

1917

folio_wait_writeback(folio);

fs/btrfs/file.c

1920

ret = set_folio_extent_mapped(folio);

fs/btrfs/file.c

1933

folio_unlock(folio);

fs/btrfs/file.c

1940

if (folio_contains(folio, (size - 1) >> PAGE_SHIFT)) {

fs/btrfs/file.c

1961

if (page_start + folio_size(folio) > size)

fs/btrfs/file.c

1962

zero_start = offset_in_folio(folio, size);

fs/btrfs/file.c

1967

folio_zero_range(folio, zero_start, folio_size(folio) - zero_start);

fs/btrfs/file.c

1969

btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

1970

btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start);

fs/btrfs/file.c

1989

folio_unlock(folio);

fs/btrfs/file.c

2249

struct folio *folio = fbatch.folios[i];

fs/btrfs/file.c

2252

if (folio->index < start_index)

fs/btrfs/file.c

2255

if (folio_next_index(folio) > end_index)

fs/btrfs/file.c

45

static void btrfs_drop_folio(struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/file.c

52

folio_unlock(folio);

fs/btrfs/file.c

53

folio_put(folio);

fs/btrfs/file.c

63

int btrfs_dirty_folio(struct btrfs_inode *inode, struct folio *folio, loff_t pos,

fs/btrfs/file.c

786

static int prepare_uptodate_folio(struct inode *inode, struct folio *folio, u64 pos,

fs/btrfs/file.c

789

u64 clamp_start = max_t(u64, pos, folio_pos(folio));

fs/btrfs/file.c

790

u64 clamp_end = min_t(u64, pos + len, folio_next_pos(folio));

fs/btrfs/file.c

794

if (folio_test_uptodate(folio))

fs/btrfs/file.c

801

ret = btrfs_read_folio(NULL, folio);

fs/btrfs/file.c

804

folio_lock(folio);

fs/btrfs/file.c

805

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/file.c

806

folio_unlock(folio);

fs/btrfs/file.c

819

if (folio->mapping != inode->i_mapping || !folio_test_private(folio)) {

fs/btrfs/file.c

820

folio_unlock(folio);

fs/btrfs/file.c

84

ASSERT(folio_pos(folio) <= pos && folio_next_pos(folio) >= end_pos);

fs/btrfs/file.c

842

static noinline int prepare_one_folio(struct inode *inode, struct folio **folio_ret,

fs/btrfs/file.c

850

struct folio *folio;

fs/btrfs/file.c

854

folio = __filemap_get_folio(inode->i_mapping, index, fgp_flags, mask);

fs/btrfs/file.c

855

if (IS_ERR(folio))

fs/btrfs/file.c

856

return PTR_ERR(folio);

fs/btrfs/file.c

858

ret = set_folio_extent_mapped(folio);

fs/btrfs/file.c

860

folio_unlock(folio);

fs/btrfs/file.c

861

folio_put(folio);

fs/btrfs/file.c

864

ret = prepare_uptodate_folio(inode, folio, pos, write_bytes);

fs/btrfs/file.c

867

folio_put(folio);

fs/btrfs/file.c

872

*folio_ret = folio;

fs/btrfs/file.c

886

lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct folio *folio,

fs/btrfs/file.c

905

folio_unlock(folio);

fs/btrfs/file.c

906

folio_put(folio);

fs/btrfs/file.c

921

folio_unlock(folio);

fs/btrfs/file.c

922

folio_put(folio);

fs/btrfs/file.c

93

btrfs_folio_clamp_set_uptodate(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.c

939

WARN_ON(!folio_test_locked(folio));

fs/btrfs/file.c

94

btrfs_folio_clamp_set_dirty(fs_info, folio, start_pos, num_bytes);

fs/btrfs/file.h

13

struct folio;

fs/btrfs/file.h

39

int btrfs_dirty_folio(struct btrfs_inode *inode, struct folio *folio, loff_t pos,

fs/btrfs/free-space-cache.c

444

struct folio *folio;

fs/btrfs/free-space-cache.c

452

folio = __filemap_get_folio(inode->i_mapping, i,

fs/btrfs/free-space-cache.c

455

if (IS_ERR(folio)) {

fs/btrfs/free-space-cache.c

457

return PTR_ERR(folio);

fs/btrfs/free-space-cache.c

460

ret = set_folio_extent_mapped(folio);

fs/btrfs/free-space-cache.c

462

folio_unlock(folio);

fs/btrfs/free-space-cache.c

463

folio_put(folio);

fs/btrfs/free-space-cache.c

468

io_ctl->pages[i] = &folio->page;

fs/btrfs/free-space-cache.c

469

if (uptodate && !folio_test_uptodate(folio)) {

fs/btrfs/free-space-cache.c

470

btrfs_read_folio(NULL, folio);

fs/btrfs/free-space-cache.c

471

folio_lock(folio);

fs/btrfs/free-space-cache.c

472

if (folio->mapping != inode->i_mapping) {

fs/btrfs/free-space-cache.c

478

if (!folio_test_uptodate(folio)) {

fs/btrfs/fs.h

1082

const struct folio *folio)

fs/btrfs/fs.h

1084

return folio_size(folio) >> fs_info->sectorsize_bits;

fs/btrfs/fs.h

977

struct folio *: (_folio))->mapping->host))

fs/btrfs/inode.c

1035

struct folio *locked_folio = NULL;

fs/btrfs/inode.c

1197

static int cow_one_range(struct btrfs_inode *inode, struct folio *locked_folio,

fs/btrfs/inode.c

122

struct folio *locked_folio, u64 start,

fs/btrfs/inode.c

1341

struct folio *locked_folio, u64 start,

fs/btrfs/inode.c

1561

struct folio *locked_folio, u64 start,

fs/btrfs/inode.c

1654

struct folio *locked_folio, u64 start,

fs/btrfs/inode.c

1675

struct folio *locked_folio, const u64 start,

fs/btrfs/inode.c

1902

static int nocow_one_range(struct btrfs_inode *inode, struct folio *locked_folio,

fs/btrfs/inode.c

1975

struct folio *locked_folio,

fs/btrfs/inode.c

2307

static int run_delalloc_inline(struct btrfs_inode *inode, struct folio *locked_folio)

fs/btrfs/inode.c

2391

int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct folio *locked_folio,

fs/btrfs/inode.c

3279

struct folio *folio = page_folio(phys_to_page(paddr));

fs/btrfs/inode.c

3286

ASSERT(offset_in_folio(folio, paddr) + blocksize <= folio_size(folio));

fs/btrfs/inode.c

3289

u32 pindex = offset_in_folio(folio, paddr + i * step) >> PAGE_SHIFT;

fs/btrfs/inode.c

3298

paddrs[i] = page_to_phys(folio_page(folio, pindex)) + offset_in_page(paddr);

fs/btrfs/inode.c

439

struct folio *compressed_folio,

fs/btrfs/inode.c

4814

struct folio *folio;

fs/btrfs/inode.c

4820

folio = filemap_lock_folio(mapping, index);

fs/btrfs/inode.c

4822

if (IS_ERR(folio))

fs/btrfs/inode.c

4825

if (!folio_test_uptodate(folio)) {

fs/btrfs/inode.c

4826

ret = btrfs_read_folio(NULL, folio);

fs/btrfs/inode.c

4827

folio_lock(folio);

fs/btrfs/inode.c

4828

if (folio->mapping != mapping) {

fs/btrfs/inode.c

4829

folio_unlock(folio);

fs/btrfs/inode.c

4830

folio_put(folio);

fs/btrfs/inode.c

4833

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/inode.c

4838

folio_wait_writeback(folio);

fs/btrfs/inode.c

4845

zero_start = max_t(u64, folio_pos(folio), start);

fs/btrfs/inode.c

4846

zero_end = folio_next_pos(folio);

fs/btrfs/inode.c

4847

folio_zero_range(folio, zero_start - folio_pos(folio),

fs/btrfs/inode.c

4851

folio_unlock(folio);

fs/btrfs/inode.c

4852

folio_put(folio);

fs/btrfs/inode.c

4884

struct folio *folio;

fs/btrfs/inode.c

4956

folio = __filemap_get_folio(mapping, index,

fs/btrfs/inode.c

4958

if (IS_ERR(folio)) {

fs/btrfs/inode.c

4965

ret = PTR_ERR(folio);

fs/btrfs/inode.c

4969

if (!folio_test_uptodate(folio)) {

fs/btrfs/inode.c

4970

ret = btrfs_read_folio(NULL, folio);

fs/btrfs/inode.c

4971

folio_lock(folio);

fs/btrfs/inode.c

4972

if (folio->mapping != mapping) {

fs/btrfs/inode.c

4973

folio_unlock(folio);

fs/btrfs/inode.c

4974

folio_put(folio);

fs/btrfs/inode.c

4977

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/inode.c

4989

ret = set_folio_extent_mapped(folio);

fs/btrfs/inode.c

4993

folio_wait_writeback(folio);

fs/btrfs/inode.c

5000

folio_unlock(folio);

fs/btrfs/inode.c

5001

folio_put(folio);

fs/btrfs/inode.c

5023

zero_start = max_t(u64, folio_pos(folio), start);

fs/btrfs/inode.c

5024

zero_end = min_t(u64, folio_next_pos(folio) - 1, end);

fs/btrfs/inode.c

5029

folio_zero_range(folio, zero_start - folio_pos(folio),

fs/btrfs/inode.c

5032

btrfs_folio_set_dirty(fs_info, folio, block_start,

fs/btrfs/inode.c

505

struct folio *folio;

fs/btrfs/inode.c

5050

folio_unlock(folio);

fs/btrfs/inode.c

5051

folio_put(folio);

fs/btrfs/inode.c

507

folio = filemap_get_folio(inode->vfs_inode.i_mapping, 0);

fs/btrfs/inode.c

508

ASSERT(!IS_ERR(folio));

fs/btrfs/inode.c

510

kaddr = kmap_local_folio(folio, 0);

fs/btrfs/inode.c

513

folio_put(folio);

fs/btrfs/inode.c

608

struct folio *compressed_folio,

fs/btrfs/inode.c

694

struct folio *locked_folio;

fs/btrfs/inode.c

6946

struct folio *folio,

fs/btrfs/inode.c

6969

ret = btrfs_decompress(compress_type, tmp, folio, 0, inline_size,

fs/btrfs/inode.c

6981

folio_zero_range(folio, max_size, blocksize - max_size);

fs/btrfs/inode.c

6986

static int read_inline_extent(struct btrfs_path *path, struct folio *folio)

fs/btrfs/inode.c

6993

if (!folio || folio_test_uptodate(folio))

fs/btrfs/inode.c

6996

ASSERT(folio_pos(folio) == 0);

fs/btrfs/inode.c

7001

return uncompress_inline(path, folio, fi);

fs/btrfs/inode.c

7005

kaddr = kmap_local_folio(folio, 0);

fs/btrfs/inode.c

7010

folio_zero_range(folio, copy_size, blocksize - copy_size);

fs/btrfs/inode.c

7032

struct folio *folio, u64 start, u64 len)

fs/btrfs/inode.c

7055

else if (em->disk_bytenr == EXTENT_MAP_INLINE && folio)

fs/btrfs/inode.c

7185

ret = read_inline_extent(path, folio);

fs/btrfs/inode.c

7418

static void wait_subpage_spinlock(struct folio *folio)

fs/btrfs/inode.c

7420

struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);

fs/btrfs/inode.c

7423

if (!btrfs_is_subpage(fs_info, folio))

fs/btrfs/inode.c

7426

ASSERT(folio_test_private(folio) && folio_get_private(folio));

fs/btrfs/inode.c

7427

bfs = folio_get_private(folio);

fs/btrfs/inode.c

7444

static int btrfs_launder_folio(struct folio *folio)

fs/btrfs/inode.c

7446

return btrfs_qgroup_free_data(folio_to_inode(folio), NULL, folio_pos(folio),

fs/btrfs/inode.c

7447

folio_size(folio), NULL);

fs/btrfs/inode.c

7450

static bool __btrfs_release_folio(struct folio *folio, gfp_t gfp_flags)

fs/btrfs/inode.c

7452

if (try_release_extent_mapping(folio, gfp_flags)) {

fs/btrfs/inode.c

7453

wait_subpage_spinlock(folio);

fs/btrfs/inode.c

7454

clear_folio_extent_mapped(folio);

fs/btrfs/inode.c

7460

static bool btrfs_release_folio(struct folio *folio, gfp_t gfp_flags)

fs/btrfs/inode.c

7462

if (folio_test_writeback(folio) || folio_test_dirty(folio))

fs/btrfs/inode.c

7464

return __btrfs_release_folio(folio, gfp_flags);

fs/btrfs/inode.c

7469

struct folio *dst, struct folio *src,

fs/btrfs/inode.c

7482

static void btrfs_invalidate_folio(struct folio *folio, size_t offset,

fs/btrfs/inode.c

7485

struct btrfs_inode *inode = folio_to_inode(folio);

fs/btrfs/inode.c

7489

u64 page_start = folio_pos(folio);

fs/btrfs/inode.c

7490

u64 page_end = page_start + folio_size(folio) - 1;

fs/btrfs/inode.c

7507

folio_wait_writeback(folio);

fs/btrfs/inode.c

7508

wait_subpage_spinlock(folio);

fs/btrfs/inode.c

7522

if (!(offset == 0 && length == folio_size(folio))) {

fs/btrfs/inode.c

7523

btrfs_release_folio(folio, GFP_NOFS);

fs/btrfs/inode.c

7570

if (!btrfs_folio_test_dirty(fs_info, folio, cur, range_len))

fs/btrfs/inode.c

7634

btrfs_folio_clear_dirty(fs_info, folio, page_start, folio_size(folio));

fs/btrfs/inode.c

7635

btrfs_clear_folio_dirty_tag(folio);

fs/btrfs/inode.c

7637

__btrfs_release_folio(folio, GFP_NOFS);

fs/btrfs/inode.c

7638

clear_folio_extent_mapped(folio);

fs/btrfs/inode.c

779

struct folio *folio;

fs/btrfs/inode.c

783

folio = filemap_get_folio(inode->vfs_inode.i_mapping, index);

fs/btrfs/inode.c

784

if (IS_ERR(folio)) {

fs/btrfs/inode.c

786

ret = PTR_ERR(folio);

fs/btrfs/inode.c

789

btrfs_folio_clamp_clear_dirty(inode->root->fs_info, folio, start,

fs/btrfs/inode.c

791

folio_put(folio);

fs/btrfs/inode.c

796

static struct folio *compressed_bio_last_folio(struct compressed_bio *cb)

fs/btrfs/inode.c

814

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/inode.c

828

struct folio *last_folio = compressed_bio_last_folio(cb);

fs/btrfs/inode.c

9817

struct folio *folio;

fs/btrfs/inode.c

9821

folio = btrfs_alloc_compr_folio(fs_info, GFP_NOFS);

fs/btrfs/inode.c

9822

if (!folio) {

fs/btrfs/inode.c

9826

kaddr = kmap_local_folio(folio, 0);

fs/btrfs/inode.c

9830

folio_put(folio);

fs/btrfs/inode.c

9835

folio_zero_range(folio, bytes, round_up(bytes, blocksize) - bytes);

fs/btrfs/inode.c

9836

ret = bio_add_folio(&cb->bbio.bio, folio, round_up(bytes, blocksize), 0);

fs/btrfs/inode.c

9838

folio_put(folio);

fs/btrfs/inode.c

997

struct folio *locked_folio)

fs/btrfs/lzo.c

118

static int write_and_queue_folio(struct bio *out_bio, struct folio **out_folio,

fs/btrfs/lzo.c

180

struct folio **out_folio,

fs/btrfs/lzo.c

271

struct folio *folio_in = NULL;

fs/btrfs/lzo.c

272

struct folio *folio_out = NULL;

fs/btrfs/lzo.c

367

static struct folio *get_current_folio(struct compressed_bio *cb, struct folio_iter *fi,

fs/btrfs/lzo.c

383

return fi->folio;

fs/btrfs/lzo.c

398

struct folio *cur_folio = get_current_folio(cb, fi, cur_folio_index, *cur_in);

fs/btrfs/lzo.c

433

if (unlikely(!fi.folio))

fs/btrfs/lzo.c

435

ASSERT(folio_size(fi.folio) == btrfs_min_folio_size(fs_info));

fs/btrfs/lzo.c

436

kaddr = kmap_local_folio(fi.folio, 0);

fs/btrfs/lzo.c

461

struct folio *cur_folio;

fs/btrfs/lzo.c

544

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/btrfs/raid56.c

3000

struct folio **data_folios, u64 data_logical)

fs/btrfs/raid56.h

286

struct folio **data_folios, u64 data_logical);

fs/btrfs/reflink.c

116

memcpy_to_folio(folio, offset_in_folio(folio, file_offset), data_start,

fs/btrfs/reflink.c

119

ret = btrfs_decompress(comp_type, data_start, folio,

fs/btrfs/reflink.c

120

offset_in_folio(folio, file_offset),

fs/btrfs/reflink.c

124

flush_dcache_folio(folio);

fs/btrfs/reflink.c

140

folio_zero_range(folio, datal, block_size - datal);

fs/btrfs/reflink.c

142

btrfs_folio_set_uptodate(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

143

btrfs_folio_set_dirty(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

145

if (!IS_ERR(folio)) {

fs/btrfs/reflink.c

146

folio_unlock(folio);

fs/btrfs/reflink.c

147

folio_put(folio);

fs/btrfs/reflink.c

68

struct folio *folio = NULL;

fs/btrfs/reflink.c

86

folio = __filemap_get_folio(mapping, file_offset >> PAGE_SHIFT,

fs/btrfs/reflink.c

89

if (IS_ERR(folio)) {

fs/btrfs/reflink.c

90

ret = PTR_ERR(folio);

fs/btrfs/reflink.c

94

ret = set_folio_extent_mapped(folio);

fs/btrfs/relocation.c

2879

struct folio *folio;

fs/btrfs/relocation.c

2888

folio = filemap_lock_folio(inode->i_mapping, index);

fs/btrfs/relocation.c

2889

if (IS_ERR(folio)) {

fs/btrfs/relocation.c

2903

folio = __filemap_get_folio(inode->i_mapping, index,

fs/btrfs/relocation.c

2906

if (IS_ERR(folio))

fs/btrfs/relocation.c

2907

return PTR_ERR(folio);

fs/btrfs/relocation.c

2910

if (folio_test_readahead(folio) && !use_rst)

fs/btrfs/relocation.c

2912

folio, last_index + 1 - index);

fs/btrfs/relocation.c

2914

if (!folio_test_uptodate(folio)) {

fs/btrfs/relocation.c

2915

btrfs_read_folio(NULL, folio);

fs/btrfs/relocation.c

2916

folio_lock(folio);

fs/btrfs/relocation.c

2917

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/relocation.c

2921

if (folio->mapping != inode->i_mapping) {

fs/btrfs/relocation.c

2922

folio_unlock(folio);

fs/btrfs/relocation.c

2923

folio_put(folio);

fs/btrfs/relocation.c

2933

ret = set_folio_extent_mapped(folio);

fs/btrfs/relocation.c

2937

folio_start = folio_pos(folio);

fs/btrfs/relocation.c

2938

folio_end = folio_start + folio_size(folio) - 1;

fs/btrfs/relocation.c

2977

btrfs_folio_set_dirty(fs_info, folio, clamped_start, clamped_len);

fs/btrfs/relocation.c

2987

folio_start, folio_size(folio))) {

fs/btrfs/relocation.c

3010

folio_unlock(folio);

fs/btrfs/relocation.c

3011

folio_put(folio);

fs/btrfs/relocation.c

3021

folio_unlock(folio);

fs/btrfs/relocation.c

3022

folio_put(folio);

fs/btrfs/scrub.c

141

struct folio *folios[SCRUB_STRIPE_MAX_FOLIOS];

fs/btrfs/scrub.c

690

const struct folio *folio = stripe->folios[offset >> min_folio_shift];

fs/btrfs/scrub.c

693

ASSERT(folio);

fs/btrfs/scrub.c

694

ASSERT(!folio_test_highmem(folio));

fs/btrfs/scrub.c

695

return folio_address(folio) + offset_in_folio(folio, offset);

fs/btrfs/scrub.c

703

const struct folio *folio = stripe->folios[offset >> min_folio_shift];

fs/btrfs/scrub.c

706

ASSERT(folio);

fs/btrfs/scrub.c

707

ASSERT(!folio_test_highmem(folio));

fs/btrfs/scrub.c

709

ASSERT(offset_in_folio(folio, offset) + fs_info->sectorsize <= folio_size(folio));

fs/btrfs/scrub.c

710

return page_to_phys(folio_page(folio, 0)) + offset_in_folio(folio, offset);

fs/btrfs/send.c

5189

struct folio *folio;

fs/btrfs/send.c

5191

folio = filemap_lock_folio(mapping, index);

fs/btrfs/send.c

5192

if (IS_ERR(folio)) {

fs/btrfs/send.c

5197

folio = filemap_grab_folio(mapping, index);

fs/btrfs/send.c

5198

if (IS_ERR(folio)) {

fs/btrfs/send.c

5199

ret = PTR_ERR(folio);

fs/btrfs/send.c

5203

pg_offset = offset_in_folio(folio, cur);

fs/btrfs/send.c

5204

cur_len = min_t(unsigned int, end - cur, folio_size(folio) - pg_offset);

fs/btrfs/send.c

5206

if (folio_test_readahead(folio))

fs/btrfs/send.c

5207

page_cache_async_readahead(mapping, &sctx->ra, NULL, folio,

fs/btrfs/send.c

5210

if (!folio_test_uptodate(folio)) {

fs/btrfs/send.c

5211

btrfs_read_folio(NULL, folio);

fs/btrfs/send.c

5212

folio_lock(folio);

fs/btrfs/send.c

5213

if (unlikely(!folio_test_uptodate(folio))) {

fs/btrfs/send.c

5214

folio_unlock(folio);

fs/btrfs/send.c

5217

folio_pos(folio), sctx->cur_ino,

fs/btrfs/send.c

5219

folio_put(folio);

fs/btrfs/send.c

5223

if (folio->mapping != mapping) {

fs/btrfs/send.c

5224

folio_unlock(folio);

fs/btrfs/send.c

5225

folio_put(folio);

fs/btrfs/send.c

5230

memcpy_from_folio(sctx->send_buf + sctx->send_size, folio,

fs/btrfs/send.c

5232

folio_unlock(folio);

fs/btrfs/send.c

5233

folio_put(folio);

fs/btrfs/subpage.c

120

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

127

ASSERT(folio_test_private(folio) && folio->mapping);

fs/btrfs/subpage.c

128

lockdep_assert_held(&folio->mapping->i_private_lock);

fs/btrfs/subpage.c

130

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

134

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio)

fs/btrfs/subpage.c

141

ASSERT(folio_test_private(folio) && folio->mapping);

fs/btrfs/subpage.c

142

lockdep_assert_held(&folio->mapping->i_private_lock);

fs/btrfs/subpage.c

144

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

150

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

153

ASSERT(folio_test_private(folio) && folio_get_private(folio));

fs/btrfs/subpage.c

160

if (folio->mapping)

fs/btrfs/subpage.c

161

ASSERT(folio_pos(folio) <= start &&

fs/btrfs/subpage.c

162

start + len <= folio_next_pos(folio),

fs/btrfs/subpage.c

164

start, len, folio_pos(folio), folio_size(folio));

fs/btrfs/subpage.c

167

#define subpage_calc_start_bit(fs_info, folio, name, start, len) \

fs/btrfs/subpage.c

170

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

172

btrfs_subpage_assert(fs_info, folio, start, len); \

fs/btrfs/subpage.c

173

__start_bit = offset_in_folio(folio, start) >> fs_info->sectorsize_bits; \

fs/btrfs/subpage.c

178

static void btrfs_subpage_clamp_range(struct folio *folio, u64 *start, u32 *len)

fs/btrfs/subpage.c

183

*start = max_t(u64, folio_pos(folio), orig_start);

fs/btrfs/subpage.c

189

if (folio_pos(folio) >= orig_start + orig_len)

fs/btrfs/subpage.c

192

*len = min_t(u64, folio_next_pos(folio), orig_start + orig_len) - *start;

fs/btrfs/subpage.c

196

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

198

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

203

btrfs_subpage_assert(fs_info, folio, start, len);

fs/btrfs/subpage.c

242

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

244

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

246

ASSERT(folio_test_locked(folio));

fs/btrfs/subpage.c

248

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

249

folio_unlock(folio);

fs/btrfs/subpage.c

262

folio_unlock(folio);

fs/btrfs/subpage.c

266

btrfs_subpage_clamp_range(folio, &start, &len);

fs/btrfs/subpage.c

267

if (btrfs_subpage_end_and_test_lock(fs_info, folio, start, len))

fs/btrfs/subpage.c

268

folio_unlock(folio);

fs/btrfs/subpage.c

272

struct folio *folio, unsigned long *bitmap)

fs/btrfs/subpage.c

274

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

275

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

280

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

281

folio_unlock(folio);

fs/btrfs/subpage.c

287

folio_unlock(folio);

fs/btrfs/subpage.c

298

folio_unlock(folio);

fs/btrfs/subpage.c

301

#define subpage_test_bitmap_all_set(fs_info, folio, name) \

fs/btrfs/subpage.c

303

struct btrfs_folio_state *__bfs = folio_get_private(folio); \

fs/btrfs/subpage.c

304

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

310

#define subpage_test_bitmap_all_zero(fs_info, folio, name) \

fs/btrfs/subpage.c

312

struct btrfs_folio_state *__bfs = folio_get_private(folio); \

fs/btrfs/subpage.c

313

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

320

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

322

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

323

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

329

if (subpage_test_bitmap_all_set(fs_info, folio, uptodate))

fs/btrfs/subpage.c

330

folio_mark_uptodate(folio);

fs/btrfs/subpage.c

335

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

337

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

338

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

344

folio_clear_uptodate(folio);

fs/btrfs/subpage.c

349

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

351

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

352

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

359

folio_mark_dirty(folio);

fs/btrfs/subpage.c

362

static void folio_clear_tags(struct folio *folio)

fs/btrfs/subpage.c

364

struct address_space *mapping = folio_mapping(folio);

fs/btrfs/subpage.c

365

XA_STATE(xas, &mapping->i_pages, folio->index);

fs/btrfs/subpage.c

368

ASSERT(folio_test_locked(folio));

fs/btrfs/subpage.c

39

struct folio *folio, enum btrfs_folio_type type)

fs/btrfs/subpage.c

390

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

392

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

393

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

400

if (subpage_test_bitmap_all_zero(fs_info, folio, dirty))

fs/btrfs/subpage.c

407

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

411

last = btrfs_subpage_clear_and_test_dirty(fs_info, folio, start, len);

fs/btrfs/subpage.c

413

folio_clear_dirty_for_io(folio);

fs/btrfs/subpage.c

417

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

419

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

420

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

436

if (!folio_test_writeback(folio))

fs/btrfs/subpage.c

437

__folio_start_writeback(folio, true);

fs/btrfs/subpage.c

438

if (!folio_test_dirty(folio))

fs/btrfs/subpage.c

439

folio_clear_tags(folio);

fs/btrfs/subpage.c

444

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

446

struct btrfs_folio_state *bfs = folio_get_private(folio);

fs/btrfs/subpage.c

447

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio,

fs/btrfs/subpage.c

45

ASSERT(!folio_test_large(folio));

fs/btrfs/subpage.c

453

if (subpage_test_bitmap_all_zero(fs_info, folio, writeback)) {

fs/btrfs/subpage.c

454

ASSERT(folio_test_writeback(folio));

fs/btrfs/subpage.c

455

folio_end_writeback(folio);

fs/btrfs/subpage.c

466

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

468

struct btrfs_folio_state *bfs = folio_get_private(folio); \

fs/btrfs/subpage.c

469

unsigned int start_bit = subpage_calc_start_bit(fs_info, folio, \

fs/btrfs/subpage.c

492

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

495

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

496

folio_set_func(folio); \

fs/btrfs/subpage.c

499

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

502

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

505

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

506

folio_clear_func(folio); \

fs/btrfs/subpage.c

509

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

51

if (folio->mapping)

fs/btrfs/subpage.c

512

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

515

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

516

return folio_test_func(folio); \

fs/btrfs/subpage.c

517

return btrfs_subpage_test_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

52

ASSERT(folio_test_locked(folio));

fs/btrfs/subpage.c

520

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

523

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

524

folio_set_func(folio); \

fs/btrfs/subpage.c

527

btrfs_subpage_clamp_range(folio, &start, &len); \

fs/btrfs/subpage.c

528

btrfs_subpage_set_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

531

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

534

!btrfs_is_subpage(fs_info, folio)) { \

fs/btrfs/subpage.c

535

folio_clear_func(folio); \

fs/btrfs/subpage.c

538

btrfs_subpage_clamp_range(folio, &start, &len); \

fs/btrfs/subpage.c

539

btrfs_subpage_clear_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

542

struct folio *folio, u64 start, u32 len) \

fs/btrfs/subpage.c

545

!btrfs_is_subpage(fs_info, folio)) \

fs/btrfs/subpage.c

546

return folio_test_func(folio); \

fs/btrfs/subpage.c

547

btrfs_subpage_clamp_range(folio, &start, &len); \

fs/btrfs/subpage.c

548

return btrfs_subpage_test_##name(fs_info, folio, start, len); \

fs/btrfs/subpage.c

55

if (folio_test_private(folio))

fs/btrfs/subpage.c

550

void btrfs_meta_folio_set_##name(struct folio *folio, const struct extent_buffer *eb) \

fs/btrfs/subpage.c

553

folio_set_func(folio); \

fs/btrfs/subpage.c

556

btrfs_subpage_set_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

558

void btrfs_meta_folio_clear_##name(struct folio *folio, const struct extent_buffer *eb) \

fs/btrfs/subpage.c

561

folio_clear_func(folio); \

fs/btrfs/subpage.c

564

btrfs_subpage_clear_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

566

bool btrfs_meta_folio_test_##name(struct folio *folio, const struct extent_buffer *eb) \

fs/btrfs/subpage.c

569

return folio_test_func(folio); \

fs/btrfs/subpage.c

570

return btrfs_subpage_test_##name(eb->fs_info, folio, eb->start, eb->len); \

fs/btrfs/subpage.c

582

struct folio *folio) \

fs/btrfs/subpage.c

584

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

585

const struct btrfs_folio_state *__bfs = folio_get_private(folio); \

fs/btrfs/subpage.c

59

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

595

struct folio *folio) \

fs/btrfs/subpage.c

597

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

598

struct btrfs_folio_state *__bfs = folio_get_private(folio); \

fs/btrfs/subpage.c

611

#define SUBPAGE_DUMP_BITMAP(fs_info, folio, name, start, len) \

fs/btrfs/subpage.c

613

const unsigned int __bpf = btrfs_blocks_per_folio(fs_info, folio); \

fs/btrfs/subpage.c

616

unsigned long bitmap = get_bitmap_value_##name(fs_info, folio); \

fs/btrfs/subpage.c

62

bfs = btrfs_alloc_folio_state(fs_info, folio_size(folio), type);

fs/btrfs/subpage.c

620

start, len, folio_pos(folio), __bpf, &bitmap); \

fs/btrfs/subpage.c

624

start, len, folio_pos(folio), __bpf, \

fs/btrfs/subpage.c

625

get_bitmap_pointer_##name(fs_info, folio)); \

fs/btrfs/subpage.c

634

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

644

if (!btrfs_is_subpage(fs_info, folio)) {

fs/btrfs/subpage.c

645

ASSERT(!folio_test_dirty(folio));

fs/btrfs/subpage.c

649

start_bit = subpage_calc_start_bit(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

651

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

655

SUBPAGE_DUMP_BITMAP(fs_info, folio, dirty, start, len);

fs/btrfs/subpage.c

66

folio_attach_private(folio, bfs);

fs/btrfs/subpage.c

670

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

677

ASSERT(folio_test_locked(folio));

fs/btrfs/subpage.c

678

if (unlikely(!fs_info) || !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

681

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

685

ASSERT(ret <= btrfs_blocks_per_folio(fs_info, folio));

fs/btrfs/subpage.c

694

bool btrfs_meta_folio_clear_and_test_dirty(struct folio *folio, const struct extent_buffer *eb)

fs/btrfs/subpage.c

699

folio_clear_dirty_for_io(folio);

fs/btrfs/subpage.c

70

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.c

703

last = btrfs_subpage_clear_and_test_dirty(eb->fs_info, folio, eb->start, eb->len);

fs/btrfs/subpage.c

705

folio_clear_dirty_for_io(folio);

fs/btrfs/subpage.c

712

struct folio *folio, u64 start, u32 len)

fs/btrfs/subpage.c

715

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

718

ASSERT(folio_test_private(folio) && folio_get_private(folio));

fs/btrfs/subpage.c

720

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

722

dump_page(folio_page(folio, 0), "btrfs folio state dump");

fs/btrfs/subpage.c

730

uptodate = get_bitmap_value_uptodate(fs_info, folio);

fs/btrfs/subpage.c

731

dirty = get_bitmap_value_dirty(fs_info, folio);

fs/btrfs/subpage.c

732

writeback = get_bitmap_value_writeback(fs_info, folio);

fs/btrfs/subpage.c

738

start, len, folio_pos(folio),

fs/btrfs/subpage.c

748

start, len, folio_pos(folio),

fs/btrfs/subpage.c

749

blocks_per_folio, get_bitmap_pointer_uptodate(fs_info, folio),

fs/btrfs/subpage.c

750

blocks_per_folio, get_bitmap_pointer_dirty(fs_info, folio),

fs/btrfs/subpage.c

751

blocks_per_folio, get_bitmap_pointer_writeback(fs_info, folio));

fs/btrfs/subpage.c

756

struct folio *folio,

fs/btrfs/subpage.c

76

if (!folio_test_private(folio))

fs/btrfs/subpage.c

760

const unsigned int blocks_per_folio = btrfs_blocks_per_folio(fs_info, folio);

fs/btrfs/subpage.c

770

ASSERT(folio_test_private(folio) && folio_get_private(folio));

fs/btrfs/subpage.c

772

bfs = folio_get_private(folio);

fs/btrfs/subpage.c

783

bitmap_copy(dst, get_bitmap_pointer_dirty(fs_info, folio),

fs/btrfs/subpage.c

80

if (type == BTRFS_SUBPAGE_DATA && !btrfs_is_subpage(fs_info, folio))

fs/btrfs/subpage.c

83

bfs = folio_detach_private(folio);

fs/btrfs/subpage.h

100

void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,

fs/btrfs/subpage.h

111

void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

112

void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);

fs/btrfs/subpage.h

115

struct folio *folio, u64 start, u32 len);

fs/btrfs/subpage.h

117

struct folio *folio, u64 start, u32 len);

fs/btrfs/subpage.h

119

struct folio *folio, unsigned long *bitmap);

fs/btrfs/subpage.h

12

struct folio;

fs/btrfs/subpage.h

143

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

145

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

147

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

149

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

151

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

153

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

155

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

157

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

159

struct folio *folio, u64 start, u32 len); \

fs/btrfs/subpage.h

160

void btrfs_meta_folio_set_##name(struct folio *folio, const struct extent_buffer *eb); \

fs/btrfs/subpage.h

161

void btrfs_meta_folio_clear_##name(struct folio *folio, const struct extent_buffer *eb); \

fs/btrfs/subpage.h

162

bool btrfs_meta_folio_test_##name(struct folio *folio, const struct extent_buffer *eb);

fs/btrfs/subpage.h

173

struct folio *locked_folio,

fs/btrfs/subpage.h

182

struct folio *folio, u64 start, u32 len);

fs/btrfs/subpage.h

185

struct folio *folio, u64 start, u32 len);

fs/btrfs/subpage.h

186

bool btrfs_meta_folio_clear_and_test_dirty(struct folio *folio, const struct extent_buffer *eb);

fs/btrfs/subpage.h

188

struct folio *folio,

fs/btrfs/subpage.h

191

struct folio *folio, u64 start, u32 len);

fs/btrfs/subpage.h

91

struct folio *folio)

fs/btrfs/subpage.h

93

if (folio->mapping && folio->mapping->host)

fs/btrfs/subpage.h

94

ASSERT(is_data_inode(BTRFS_I(folio->mapping->host)));

fs/btrfs/subpage.h

95

return fs_info->sectorsize < folio_size(folio);

fs/btrfs/subpage.h

99

struct folio *folio, enum btrfs_folio_type type);

fs/btrfs/tests/extent-io-tests.c

38

struct folio *folio = fbatch.folios[i];

fs/btrfs/tests/extent-io-tests.c

41

!folio_test_locked(folio))

fs/btrfs/tests/extent-io-tests.c

43

if (flags & PROCESS_UNLOCK && folio_test_locked(folio))

fs/btrfs/tests/extent-io-tests.c

44

folio_unlock(folio);

fs/btrfs/tests/extent-io-tests.c

46

folio_put(folio);

fs/btrfs/verity.c

289

char *dest, u64 len, struct folio *dest_folio)

fs/btrfs/verity.c

706

struct folio *folio;

fs/btrfs/verity.c

717

folio = __filemap_get_folio(inode->i_mapping, index, FGP_ACCESSED, 0);

fs/btrfs/verity.c

718

if (!IS_ERR(folio)) {

fs/btrfs/verity.c

719

if (folio_test_uptodate(folio))

fs/btrfs/verity.c

722

folio_lock(folio);

fs/btrfs/verity.c

724

if (!folio_test_uptodate(folio)) {

fs/btrfs/verity.c

725

folio_unlock(folio);

fs/btrfs/verity.c

726

folio_put(folio);

fs/btrfs/verity.c

729

folio_unlock(folio);

fs/btrfs/verity.c

733

folio = filemap_alloc_folio(mapping_gfp_constraint(inode->i_mapping, ~__GFP_FS),

fs/btrfs/verity.c

735

if (!folio)

fs/btrfs/verity.c

738

ret = filemap_add_folio(inode->i_mapping, folio, index, GFP_NOFS);

fs/btrfs/verity.c

740

folio_put(folio);

fs/btrfs/verity.c

754

folio_address(folio), PAGE_SIZE, folio);

fs/btrfs/verity.c

756

folio_put(folio);

fs/btrfs/verity.c

760

folio_zero_segment(folio, ret, PAGE_SIZE);

fs/btrfs/verity.c

762

folio_mark_uptodate(folio);

fs/btrfs/verity.c

763

folio_unlock(folio);

fs/btrfs/verity.c

766

return folio_file_page(folio, index);

fs/btrfs/zlib.c

124

struct folio *folio;

fs/btrfs/zlib.c

130

ret = btrfs_compress_filemap_get_folio(mapping, cur, &folio);

fs/btrfs/zlib.c

134

offset = offset_in_folio(folio, cur);

fs/btrfs/zlib.c

135

copy_length = min(folio_size(folio) - offset,

fs/btrfs/zlib.c

138

data_in = kmap_local_folio(folio, offset);

fs/btrfs/zlib.c

141

folio_put(folio);

fs/btrfs/zlib.c

159

struct folio *in_folio = NULL;

fs/btrfs/zlib.c

160

struct folio *out_folio = NULL;

fs/btrfs/zlib.c

354

if (unlikely(!fi.folio))

fs/btrfs/zlib.c

356

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/zlib.c

358

data_in = kmap_local_folio(fi.folio, 0);

fs/btrfs/zlib.c

414

if (!fi.folio) {

fs/btrfs/zlib.c

418

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/zlib.c

419

data_in = kmap_local_folio(fi.folio, 0);

fs/btrfs/zlib.c

442

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/btrfs/zstd.c

408

struct folio *in_folio = NULL;

fs/btrfs/zstd.c

410

struct folio *out_folio = NULL;

fs/btrfs/zstd.c

598

if (unlikely(!fi.folio))

fs/btrfs/zstd.c

600

ASSERT(folio_size(fi.folio) == min_folio_size);

fs/btrfs/zstd.c

614

workspace->in_buf.src = kmap_local_folio(fi.folio, 0);

fs/btrfs/zstd.c

663

ASSERT(fi.folio);

fs/btrfs/zstd.c

664

workspace->in_buf.src = kmap_local_folio(fi.folio, 0);

fs/btrfs/zstd.c

677

struct folio *dest_folio, unsigned long dest_pgoff, size_t srclen,

fs/buffer.c

1000

folio_put(folio);

fs/buffer.c

1110

struct folio *folio = bh->b_folio;

fs/buffer.c

1113

if (!folio_test_set_dirty(folio)) {

fs/buffer.c

1114

mapping = folio->mapping;

fs/buffer.c

1116

__folio_mark_dirty(folio, mapping, 0);

fs/buffer.c

1556

void folio_set_bh(struct buffer_head *bh, struct folio *folio,

fs/buffer.c

1559

bh->b_folio = folio;

fs/buffer.c

1560

BUG_ON(offset >= folio_size(folio));

fs/buffer.c

1561

if (folio_test_highmem(folio))

fs/buffer.c

1567

bh->b_data = folio_address(folio) + offset;

fs/buffer.c

1609

void block_invalidate_folio(struct folio *folio, size_t offset, size_t length)

fs/buffer.c

1615

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

1620

BUG_ON(stop > folio_size(folio) || stop < length);

fs/buffer.c

1622

head = folio_buffers(folio);

fs/buffer.c

1651

if (length == folio_size(folio))

fs/buffer.c

1652

filemap_release_folio(folio, 0);

fs/buffer.c

1654

folio_clear_mappedtodisk(folio);

fs/buffer.c

1663

struct buffer_head *create_empty_buffers(struct folio *folio,

fs/buffer.c

1669

head = folio_alloc_buffers(folio, blocksize, gfp);

fs/buffer.c

1678

spin_lock(&folio->mapping->i_private_lock);

fs/buffer.c

1679

if (folio_test_uptodate(folio) || folio_test_dirty(folio)) {

fs/buffer.c

1682

if (folio_test_dirty(folio))

fs/buffer.c

1684

if (folio_test_uptodate(folio))

fs/buffer.c

1689

folio_attach_private(folio, head);

fs/buffer.c

1690

spin_unlock(&folio->mapping->i_private_lock);

fs/buffer.c

1732

struct folio *folio = fbatch.folios[i];

fs/buffer.c

1734

if (!folio_buffers(folio))

fs/buffer.c

1741

folio_lock(folio);

fs/buffer.c

1743

head = folio_buffers(folio);

fs/buffer.c

1759

folio_unlock(folio);

fs/buffer.c

1770

static struct buffer_head *folio_create_buffers(struct folio *folio,

fs/buffer.c

1776

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

1778

bh = folio_buffers(folio);

fs/buffer.c

1780

bh = create_empty_buffers(folio,

fs/buffer.c

1814

int __block_write_full_folio(struct inode *inode, struct folio *folio,

fs/buffer.c

1825

head = folio_create_buffers(folio, inode,

fs/buffer.c

1841

block = div_u64(folio_pos(folio), blocksize);

fs/buffer.c

1890

folio_redirty_for_writepage(wbc, folio);

fs/buffer.c

1904

BUG_ON(folio_test_writeback(folio));

fs/buffer.c

1905

folio_start_writeback(folio);

fs/buffer.c

1917

folio_unlock(folio);

fs/buffer.c

1927

folio_end_writeback(folio);

fs/buffer.c

1958

BUG_ON(folio_test_writeback(folio));

fs/buffer.c

1959

mapping_set_error(folio->mapping, err);

fs/buffer.c

1960

folio_start_writeback(folio);

fs/buffer.c

1972

folio_unlock(folio);

fs/buffer.c

1982

void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to)

fs/buffer.c

1987

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

1988

head = folio_buffers(folio);

fs/buffer.c

1999

if (!folio_test_uptodate(folio)) {

fs/buffer.c

2005

folio_zero_segment(folio, start, xend);

fs/buffer.c

2088

int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,

fs/buffer.c

2091

size_t from = offset_in_folio(folio, pos);

fs/buffer.c

2093

struct inode *inode = folio->mapping->host;

fs/buffer.c

2100

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

2101

BUG_ON(to > folio_size(folio));

fs/buffer.c

2104

head = folio_create_buffers(folio, inode, 0);

fs/buffer.c

2106

block = div_u64(folio_pos(folio), blocksize);

fs/buffer.c

2112

if (folio_test_uptodate(folio)) {

fs/buffer.c

2131

if (folio_test_uptodate(folio)) {

fs/buffer.c

2138

folio_zero_segments(folio,

fs/buffer.c

2144

if (folio_test_uptodate(folio)) {

fs/buffer.c

2165

folio_zero_new_buffers(folio, from, to);

fs/buffer.c

2169

int __block_write_begin(struct folio *folio, loff_t pos, unsigned len,

fs/buffer.c

2172

return __block_write_begin_int(folio, pos, len, get_block, NULL);

fs/buffer.c

2176

void block_commit_write(struct folio *folio, size_t from, size_t to)

fs/buffer.c

2183

bh = head = folio_buffers(folio);

fs/buffer.c

2212

folio_mark_uptodate(folio);

fs/buffer.c

2223

struct folio **foliop, get_block_t *get_block)

fs/buffer.c

2226

struct folio *folio;

fs/buffer.c

2229

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/buffer.c

2231

if (IS_ERR(folio))

fs/buffer.c

2232

return PTR_ERR(folio);

fs/buffer.c

2234

status = __block_write_begin_int(folio, pos, len, get_block, NULL);

fs/buffer.c

2236

folio_unlock(folio);

fs/buffer.c

2237

folio_put(folio);

fs/buffer.c

2238

folio = NULL;

fs/buffer.c

2241

*foliop = folio;

fs/buffer.c

2247

struct folio *folio)

fs/buffer.c

2249

size_t start = pos - folio_pos(folio);

fs/buffer.c

225

struct folio *folio;

fs/buffer.c

2264

if (!folio_test_uptodate(folio))

fs/buffer.c

2267

folio_zero_new_buffers(folio, start+copied, start+len);

fs/buffer.c

2269

flush_dcache_folio(folio);

fs/buffer.c

2272

block_commit_write(folio, start, start + copied);

fs/buffer.c

2280

struct folio *folio, void *fsdata)

fs/buffer.c

2286

copied = block_write_end(pos, len, copied, folio);

fs/buffer.c

230

folio = __filemap_get_folio(bd_mapping, index, FGP_ACCESSED, 0);

fs/buffer.c

2300

folio_unlock(folio);

fs/buffer.c

2301

folio_put(folio);

fs/buffer.c

231

if (IS_ERR(folio))

fs/buffer.c

2324

bool block_is_partially_uptodate(struct folio *folio, size_t from, size_t count)

fs/buffer.c

2331

head = folio_buffers(folio);

fs/buffer.c

2335

to = min(folio_size(folio) - from, count);

fs/buffer.c

2337

if (from < blocksize && to > folio_size(folio) - blocksize)

fs/buffer.c

2367

int block_read_full_folio(struct folio *folio, get_block_t *get_block)

fs/buffer.c

2369

struct inode *inode = folio->mapping->host;

fs/buffer.c

2381

head = folio_create_buffers(folio, inode, 0);

fs/buffer.c

2384

iblock = div_u64(folio_pos(folio), blocksize);

fs/buffer.c

2403

folio_zero_range(folio, bh_offset(bh),

fs/buffer.c

242

folio_lock(folio);

fs/buffer.c

244

head = folio_buffers(folio);

fs/buffer.c

2454

folio_set_mappedtodisk(folio);

fs/buffer.c

2465

folio_end_read(folio, !page_error);

fs/buffer.c

2479

struct folio *folio;

fs/buffer.c

2487

err = aops->write_begin(NULL, mapping, size, 0, &folio, &fsdata);

fs/buffer.c

2491

err = aops->write_end(NULL, mapping, size, 0, 0, folio, fsdata);

fs/buffer.c

2506

struct folio *folio;

fs/buffer.c

2525

&folio, &fsdata);

fs/buffer.c

2528

folio_zero_range(folio, offset_in_folio(folio, curpos), len);

fs/buffer.c

2530

folio, fsdata);

fs/buffer.c

2558

&folio, &fsdata);

fs/buffer.c

2561

folio_zero_range(folio, offset_in_folio(folio, curpos), len);

fs/buffer.c

2563

folio, fsdata);

fs/buffer.c

2578

loff_t pos, unsigned len, struct folio **foliop,

fs/buffer.c

2621

struct folio *folio = page_folio(vmf->page);

fs/buffer.c

2627

folio_lock(folio);

fs/buffer.c

2629

if ((folio->mapping != inode->i_mapping) ||

fs/buffer.c

2630

(folio_pos(folio) >= size)) {

fs/buffer.c

2636

end = folio_size(folio);

fs/buffer.c

2638

if (folio_pos(folio) + end > size)

fs/buffer.c

2639

end = size - folio_pos(folio);

fs/buffer.c

2641

ret = __block_write_begin_int(folio, 0, end, get_block, NULL);

fs/buffer.c

2645

block_commit_write(folio, 0, end);

fs/buffer.c

2647

folio_mark_dirty(folio);

fs/buffer.c

2648

folio_wait_stable(folio);

fs/buffer.c

2651

folio_unlock(folio);

fs/buffer.c

2664

struct folio *folio;

fs/buffer.c

2678

folio = filemap_grab_folio(mapping, index);

fs/buffer.c

2679

if (IS_ERR(folio))

fs/buffer.c

2680

return PTR_ERR(folio);

fs/buffer.c

2682

bh = folio_buffers(folio);

fs/buffer.c

2684

bh = create_empty_buffers(folio, blocksize, 0);

fs/buffer.c

2687

offset = offset_in_folio(folio, from);

fs/buffer.c

2706

if (folio_test_uptodate(folio))

fs/buffer.c

2716

folio_zero_range(folio, offset, length);

fs/buffer.c

2720

folio_unlock(folio);

fs/buffer.c

2721

folio_put(folio);

fs/buffer.c

2730

int block_write_full_folio(struct folio *folio, struct writeback_control *wbc,

fs/buffer.c

2733

struct inode * const inode = folio->mapping->host;

fs/buffer.c

2737

if (folio_next_pos(folio) <= i_size)

fs/buffer.c

2738

return __block_write_full_folio(inode, folio, get_block, wbc);

fs/buffer.c

2741

if (folio_pos(folio) >= i_size) {

fs/buffer.c

2742

folio_unlock(folio);

fs/buffer.c

2753

folio_zero_segment(folio, offset_in_folio(folio, i_size),

fs/buffer.c

2754

folio_size(folio));

fs/buffer.c

2755

return __block_write_full_folio(inode, folio, get_block, wbc);

fs/buffer.c

2825

drop_buffers(struct folio *folio, struct buffer_head **buffers_to_free)

fs/buffer.c

2827

struct buffer_head *head = folio_buffers(folio);

fs/buffer.c

2844

folio_detach_private(folio);

fs/buffer.c

287

folio_unlock(folio);

fs/buffer.c

2874

bool try_to_free_buffers(struct folio *folio)

fs/buffer.c

2876

struct address_space * const mapping = folio->mapping;

fs/buffer.c

288

folio_put(folio);

fs/buffer.c

2880

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

2881

if (folio_test_writeback(folio))

fs/buffer.c

2885

if (WARN_ON_ONCE(!folio_buffers(folio)))

fs/buffer.c

2889

ret = drop_buffers(folio, &buffers_to_free);

fs/buffer.c

2894

ret = drop_buffers(folio, &buffers_to_free);

fs/buffer.c

2911

folio_cancel_dirty(folio);

fs/buffer.c

298

struct folio *folio;

fs/buffer.c

303

folio = bh->b_folio;

fs/buffer.c

316

first = folio_buffers(folio);

fs/buffer.c

332

folio_end_read(folio, folio_uptodate);

fs/buffer.c

434

struct folio *folio;

fs/buffer.c

438

folio = bh->b_folio;

fs/buffer.c

447

first = folio_buffers(folio);

fs/buffer.c

461

folio_end_writeback(folio);

fs/buffer.c

775

bool block_dirty_folio(struct address_space *mapping, struct folio *folio)

fs/buffer.c

781

head = folio_buffers(folio);

fs/buffer.c

794

newly_dirty = !folio_test_set_dirty(folio);

fs/buffer.c

798

__folio_mark_dirty(folio, mapping, 1);

fs/buffer.c

83

void buffer_check_dirty_writeback(struct folio *folio,

fs/buffer.c

832

struct buffer_head *folio_alloc_buffers(struct folio *folio, unsigned long size,

fs/buffer.c

839

memcg = get_mem_cgroup_from_folio(folio);

fs/buffer.c

843

offset = folio_size(folio);

fs/buffer.c

856

folio_set_bh(bh, folio, offset);

fs/buffer.c

886

static inline void link_dev_buffers(struct folio *folio,

fs/buffer.c

897

folio_attach_private(folio, head);

fs/buffer.c

90

BUG_ON(!folio_test_locked(folio));

fs/buffer.c

915

static sector_t folio_init_buffers(struct folio *folio,

fs/buffer.c

918

struct buffer_head *head = folio_buffers(folio);

fs/buffer.c

92

head = folio_buffers(folio);

fs/buffer.c

920

bool uptodate = folio_test_uptodate(folio);

fs/buffer.c

921

sector_t block = div_u64(folio_pos(folio), size);

fs/buffer.c

956

struct folio *folio;

fs/buffer.c

96

if (folio_test_writeback(folio))

fs/buffer.c

960

folio = __filemap_get_folio(mapping, index,

fs/buffer.c

962

if (IS_ERR(folio))

fs/buffer.c

965

bh = folio_buffers(folio);

fs/buffer.c

968

end_block = folio_init_buffers(folio, bdev, size);

fs/buffer.c

979

if (!try_to_free_buffers(folio)) {

fs/buffer.c

985

bh = folio_alloc_buffers(folio, size, gfp | __GFP_ACCOUNT);

fs/buffer.c

995

link_dev_buffers(folio, bh);

fs/buffer.c

996

end_block = folio_init_buffers(folio, bdev, size);

fs/buffer.c

999

folio_unlock(folio);

fs/ceph/addr.c

1160

struct folio *folio)

fs/ceph/addr.c

1168

if (unlikely(!folio_test_dirty(folio) || folio->mapping != mapping)) {

fs/ceph/addr.c

1169

doutc(cl, "!dirty or !mapping %p\n", folio);

fs/ceph/addr.c

1174

pgsnapc = page_snap_context(&folio->page);

fs/ceph/addr.c

1187

if (folio_pos(folio) >= ceph_wbc->i_size) {

fs/ceph/addr.c

1189

folio->index, ceph_wbc->i_size);

fs/ceph/addr.c

1192

folio_pos(folio) >= i_size_read(inode)) &&

fs/ceph/addr.c

1193

folio_clear_dirty_for_io(folio))

fs/ceph/addr.c

1194

folio_invalidate(folio, 0, folio_size(folio));

fs/ceph/addr.c

120

ceph_vinop(inode), folio, folio->index,

fs/ceph/addr.c

1200

(folio->index > ceph_wbc->strip_unit_end)) {

fs/ceph/addr.c

1201

doutc(cl, "end of strip unit %p\n", folio);

fs/ceph/addr.c

1223

struct folio *folio)

fs/ceph/addr.c

1232

ceph_wbc->offset = (u64)folio_pos(folio);

fs/ceph/addr.c

1238

ceph_wbc->strip_unit_end = folio->index + ((xlen - 1) >> PAGE_SHIFT);

fs/ceph/addr.c

1249

const struct folio *folio)

fs/ceph/addr.c

1251

return folio->index == (ceph_wbc->offset + ceph_wbc->len) >> PAGE_SHIFT;

fs/ceph/addr.c

1270

struct ceph_writeback_ctl *ceph_wbc, struct folio *folio)

fs/ceph/addr.c

1280

pages[index] = fscrypt_encrypt_pagecache_blocks(folio,

fs/ceph/addr.c

1299

pages[index] = &folio->page;

fs/ceph/addr.c

130

VM_WARN_ON_FOLIO(folio->private, folio);

fs/ceph/addr.c

131

folio_attach_private(folio, snapc);

fs/ceph/addr.c

1315

struct folio *folio = NULL;

fs/ceph/addr.c

1320

folio = ceph_wbc->fbatch.folios[i];

fs/ceph/addr.c

1322

if (!folio)

fs/ceph/addr.c

1327

folio, folio->index, folio_test_writeback(folio),

fs/ceph/addr.c

1328

folio_test_dirty(folio),

fs/ceph/addr.c

1329

folio_test_locked(folio));

fs/ceph/addr.c

133

return ceph_fscache_dirty_folio(mapping, folio);

fs/ceph/addr.c

1331

if (folio_test_writeback(folio) ||

fs/ceph/addr.c

1332

folio_test_private_2(folio) /* [DEPRECATED] */) {

fs/ceph/addr.c

1333

doutc(cl, "waiting on writeback %p\n", folio);

fs/ceph/addr.c

1334

folio_wait_writeback(folio);

fs/ceph/addr.c

1335

folio_wait_private_2(folio); /* [DEPRECATED] */

fs/ceph/addr.c

1340

folio_lock(folio);

fs/ceph/addr.c

1341

else if (!folio_trylock(folio))

fs/ceph/addr.c

1345

ceph_wbc, folio);

fs/ceph/addr.c

1347

folio_unlock(folio);

fs/ceph/addr.c

1348

folio_put(folio);

fs/ceph/addr.c

1352

folio_unlock(folio);

fs/ceph/addr.c

1356

if (!folio_clear_dirty_for_io(folio)) {

fs/ceph/addr.c

1357

doutc(cl, "%p !folio_clear_dirty_for_io\n", folio);

fs/ceph/addr.c

1358

folio_unlock(folio);

fs/ceph/addr.c

1359

folio_put(folio);

fs/ceph/addr.c

1371

ceph_allocate_page_array(mapping, ceph_wbc, folio);

fs/ceph/addr.c

1372

} else if (!is_folio_index_contiguous(ceph_wbc, folio)) {

fs/ceph/addr.c

1374

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

1375

folio_unlock(folio);

fs/ceph/addr.c

1380

ceph_wbc->offset = (u64)folio_pos(folio);

fs/ceph/addr.c

1386

ceph_vinop(inode), folio, folio->index);

fs/ceph/addr.c

1391

folio);

fs/ceph/addr.c

1397

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

1398

folio_unlock(folio);

fs/ceph/addr.c

1403

ceph_wbc->len += folio_size(folio);

fs/ceph/addr.c

141

static void ceph_invalidate_folio(struct folio *folio, size_t offset,

fs/ceph/addr.c

144

struct inode *inode = folio->mapping->host;

fs/ceph/addr.c

1476

struct folio *folio = ceph_wbc->fbatch.folios[i];

fs/ceph/addr.c

1478

if (!folio)

fs/ceph/addr.c

1481

page = &folio->page;

fs/ceph/addr.c

150

if (offset != 0 || length != folio_size(folio)) {

fs/ceph/addr.c

152

ceph_vinop(inode), folio->index, offset, length);

fs/ceph/addr.c

156

WARN_ON(!folio_test_locked(folio));

fs/ceph/addr.c

157

if (folio_test_private(folio)) {

fs/ceph/addr.c

159

ceph_vinop(inode), folio->index);

fs/ceph/addr.c

161

snapc = folio_detach_private(folio);

fs/ceph/addr.c

166

netfs_invalidate_folio(folio, offset, length);

fs/ceph/addr.c

1810

ceph_find_incompatible(struct folio *folio)

fs/ceph/addr.c

1812

struct inode *inode = folio->mapping->host;

fs/ceph/addr.c

1818

ceph_vinop(inode), folio);

fs/ceph/addr.c

1825

folio_wait_writeback(folio);

fs/ceph/addr.c

1827

snapc = page_snap_context(&folio->page);

fs/ceph/addr.c

1840

ceph_vinop(inode), folio, snapc);

fs/ceph/addr.c

1847

ceph_vinop(inode), folio, snapc);

fs/ceph/addr.c

1848

if (folio_clear_dirty_for_io(folio)) {

fs/ceph/addr.c

1849

int r = write_folio_nounlock(folio, NULL);

fs/ceph/addr.c

1858

struct folio **foliop, void **_fsdata)

fs/ceph/addr.c

1890

struct folio **foliop, void **fsdata)

fs/ceph/addr.c

1913

struct folio *folio, void *fsdata)

fs/ceph/addr.c

1921

file, folio, (int)pos, (int)copied, (int)len);

fs/ceph/addr.c

1923

if (!folio_test_uptodate(folio)) {

fs/ceph/addr.c

1929

folio_mark_uptodate(folio);

fs/ceph/addr.c

1936

folio_mark_dirty(folio);

fs/ceph/addr.c

1939

folio_unlock(folio);

fs/ceph/addr.c

1940

folio_put(folio);

fs/ceph/addr.c

2075

struct folio *folio = page_folio(vmf->page);

fs/ceph/addr.c

2076

loff_t off = folio_pos(folio);

fs/ceph/addr.c

2093

if (off + folio_size(folio) <= size)

fs/ceph/addr.c

2094

len = folio_size(folio);

fs/ceph/addr.c

2096

len = offset_in_folio(folio, size);

fs/ceph/addr.c

2120

folio_lock(folio);

fs/ceph/addr.c

2122

if (folio_mkwrite_check_truncate(folio, inode) < 0) {

fs/ceph/addr.c

2123

folio_unlock(folio);

fs/ceph/addr.c

2128

snapc = ceph_find_incompatible(folio);

fs/ceph/addr.c

2131

folio_mark_dirty(folio);

fs/ceph/addr.c

2136

folio_unlock(folio);

fs/ceph/addr.c

2224

struct folio *folio = NULL;

fs/ceph/addr.c

2271

folio = read_mapping_folio(inode->i_mapping, 0, file);

fs/ceph/addr.c

2272

if (IS_ERR(folio)) {

fs/ceph/addr.c

2273

err = PTR_ERR(folio);

fs/ceph/addr.c

2277

folio_lock(folio);

fs/ceph/addr.c

2280

if (len > folio_size(folio))

fs/ceph/addr.c

2281

len = folio_size(folio);

fs/ceph/addr.c

2309

pages[0] = folio_page(folio, 0);

fs/ceph/addr.c

2360

if (folio) {

fs/ceph/addr.c

2361

folio_unlock(folio);

fs/ceph/addr.c

2362

folio_put(folio);

fs/ceph/addr.c

69

struct folio **foliop, void **_fsdata);

fs/ceph/addr.c

722

static int write_folio_nounlock(struct folio *folio,

fs/ceph/addr.c

725

struct page *page = &folio->page;

fs/ceph/addr.c

726

struct inode *inode = folio->mapping->host;

fs/ceph/addr.c

731

loff_t page_off = folio_pos(folio);

fs/ceph/addr.c

733

loff_t len = folio_size(folio);

fs/ceph/addr.c

741

doutc(cl, "%llx.%llx folio %p idx %lu\n", ceph_vinop(inode), folio,

fs/ceph/addr.c

742

folio->index);

fs/ceph/addr.c

748

snapc = page_snap_context(&folio->page);

fs/ceph/addr.c

751

folio);

fs/ceph/addr.c

757

ceph_vinop(inode), folio, snapc);

fs/ceph/addr.c

761

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

769

ceph_vinop(inode), folio->index, ceph_wbc.i_size);

fs/ceph/addr.c

770

folio_invalidate(folio, 0, folio_size(folio));

fs/ceph/addr.c

779

ceph_vinop(inode), folio, folio->index, page_off, wlen, snapc,

fs/ceph/addr.c

792

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

802

folio_start_writeback(folio);

fs/ceph/addr.c

804

ceph_set_page_fscache(&folio->page);

fs/ceph/addr.c

808

bounce_page = fscrypt_encrypt_pagecache_blocks(folio,

fs/ceph/addr.c

812

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

813

folio_end_writeback(folio);

fs/ceph/addr.c

82

static bool ceph_dirty_folio(struct address_space *mapping, struct folio *folio)

fs/ceph/addr.c

823

WARN_ON_ONCE(len > folio_size(folio));

fs/ceph/addr.c

853

ceph_vinop(inode), folio);

fs/ceph/addr.c

854

folio_redirty_for_writepage(wbc, folio);

fs/ceph/addr.c

855

folio_end_writeback(folio);

fs/ceph/addr.c

864

ceph_vinop(inode), err, folio);

fs/ceph/addr.c

869

ceph_vinop(inode), folio);

fs/ceph/addr.c

872

oldest = folio_detach_private(folio);

fs/ceph/addr.c

874

folio_end_writeback(folio);

fs/ceph/addr.c

90

if (folio_test_dirty(folio)) {

fs/ceph/addr.c

92

ceph_vinop(inode), folio, folio->index);

fs/ceph/addr.c

93

VM_BUG_ON_FOLIO(!folio_test_private(folio), folio);

fs/ceph/dir.c

144

if (!cache_ctl->folio || ptr_pgoff != cache_ctl->folio->index) {

fs/ceph/dir.c

146

cache_ctl->folio = filemap_lock_folio(&dir->i_data, ptr_pgoff);

fs/ceph/dir.c

147

if (IS_ERR(cache_ctl->folio)) {

fs/ceph/dir.c

148

cache_ctl->folio = NULL;

fs/ceph/dir.c

154

folio_unlock(cache_ctl->folio);

fs/ceph/dir.c

155

cache_ctl->dentries = kmap_local_folio(cache_ctl->folio, 0);

fs/ceph/file.c

2597

struct folio *folio;

fs/ceph/file.c

2599

folio = filemap_lock_folio(inode->i_mapping, offset >> PAGE_SHIFT);

fs/ceph/file.c

2600

if (IS_ERR(folio))

fs/ceph/file.c

2603

folio_wait_writeback(folio);

fs/ceph/file.c

2604

folio_zero_range(folio, offset_in_folio(folio, offset), size);

fs/ceph/file.c

2605

folio_unlock(folio);

fs/ceph/file.c

2606

folio_put(folio);

fs/ceph/inode.c

1948

if (ctl->folio) {

fs/ceph/inode.c

1949

folio_release_kmap(ctl->folio, ctl->dentries);

fs/ceph/inode.c

1950

ctl->folio = NULL;

fs/ceph/inode.c

1964

if (!ctl->folio || pgoff != ctl->folio->index) {

fs/ceph/inode.c

1971

ctl->folio = __filemap_get_folio(&dir->i_data, pgoff,

fs/ceph/inode.c

1973

if (IS_ERR(ctl->folio)) {

fs/ceph/inode.c

1974

int err = PTR_ERR(ctl->folio);

fs/ceph/inode.c

1976

ctl->folio = NULL;

fs/ceph/inode.c

1982

folio_unlock(ctl->folio);

fs/ceph/inode.c

1983

ctl->dentries = kmap_local_folio(ctl->folio, 0);

fs/ceph/super.h

952

struct folio *folio;

fs/coda/symlink.c

23

static int coda_symlink_filler(struct file *file, struct folio *folio)

fs/coda/symlink.c

25

struct inode *inode = folio->mapping->host;

fs/coda/symlink.c

29

char *p = folio_address(folio);

fs/coda/symlink.c

34

folio_end_read(folio, error == 0);

fs/cramfs/inode.c

821

static int cramfs_read_folio(struct file *file, struct folio *folio)

fs/cramfs/inode.c

823

struct inode *inode = folio->mapping->host;

fs/cramfs/inode.c

831

pgdata = kmap_local_folio(folio, 0);

fs/cramfs/inode.c

833

if (folio->index < maxblock) {

fs/cramfs/inode.c

835

u32 blkptr_offset = OFFSET(inode) + folio->index * 4;

fs/cramfs/inode.c

856

if (folio->index == maxblock - 1)

fs/cramfs/inode.c

873

if (folio->index)

fs/cramfs/inode.c

918

flush_dcache_folio(folio);

fs/cramfs/inode.c

923

folio_end_read(folio, success);

fs/crypto/bio.c

38

int err = fscrypt_decrypt_pagecache_blocks(fi.folio, fi.length,

fs/crypto/crypto.c

172

struct page *fscrypt_encrypt_pagecache_blocks(struct folio *folio,

fs/crypto/crypto.c

175

const struct inode *inode = folio->mapping->host;

fs/crypto/crypto.c

180

u64 index = ((u64)folio->index << (PAGE_SHIFT - du_bits)) +

fs/crypto/crypto.c

185

VM_BUG_ON_FOLIO(folio_test_large(folio), folio);

fs/crypto/crypto.c

186

if (WARN_ON_ONCE(!folio_test_locked(folio)))

fs/crypto/crypto.c

198

&folio->page, ciphertext_page,

fs/crypto/crypto.c

206

set_page_private(ciphertext_page, (unsigned long)folio);

fs/crypto/crypto.c

255

int fscrypt_decrypt_pagecache_blocks(struct folio *folio, size_t len,

fs/crypto/crypto.c

258

const struct inode *inode = folio->mapping->host;

fs/crypto/crypto.c

262

u64 index = ((u64)folio->index << (PAGE_SHIFT - du_bits)) +

fs/crypto/crypto.c

267

if (WARN_ON_ONCE(!folio_test_locked(folio)))

fs/crypto/crypto.c

274

struct page *page = folio_page(folio, i >> PAGE_SHIFT);

fs/dax.c

1416

struct folio *zero_folio;

fs/dax.c

1852

struct folio *folio;

fs/dax.c

1885

folio = dax_to_folio(*entry);

fs/dax.c

1889

folio_ref_inc(folio);

fs/dax.c

1894

folio_put(folio);

fs/dax.c

2135

struct folio *folio;

fs/dax.c

2153

folio = pfn_folio(pfn);

fs/dax.c

2154

folio_ref_inc(folio);

fs/dax.c

2156

ret = vmf_insert_page_mkwrite(vmf, &folio->page, true);

fs/dax.c

2159

ret = vmf_insert_folio_pmd(vmf, folio, FAULT_FLAG_WRITE);

fs/dax.c

2163

folio_put(folio);

fs/dax.c

350

static inline bool dax_folio_is_shared(struct folio *folio)

fs/dax.c

352

return !folio->mapping && folio->share;

fs/dax.c

365

static void dax_folio_make_shared(struct folio *folio)

fs/dax.c

371

folio->mapping = NULL;

fs/dax.c

377

folio->share = 1;

fs/dax.c

389

int dax_folio_reset_order(struct folio *folio)

fs/dax.c

391

struct dev_pagemap *pgmap = page_pgmap(&folio->page);

fs/dax.c

392

int order = folio_order(folio);

fs/dax.c

402

folio->mapping = NULL;

fs/dax.c

403

folio->share = 0;

fs/dax.c

412

folio->pgmap = pgmap;

fs/dax.c

416

folio_reset_order(folio);

fs/dax.c

419

struct page *page = folio_page(folio, i);

fs/dax.c

420

struct folio *f = (struct folio *)page;

fs/dax.c

433

static inline unsigned long dax_folio_put(struct folio *folio)

fs/dax.c

438

if (!dax_folio_is_shared(folio))

fs/dax.c

441

ref = --folio->share;

fs/dax.c

446

order = dax_folio_reset_order(folio);

fs/dax.c

450

struct page *page = folio_page(folio, i);

fs/dax.c

452

WARN_ON_ONCE(folio_ref_count((struct folio *)page));

fs/dax.c

460

struct folio *folio = dax_to_folio(entry);

fs/dax.c

468

WARN_ON_ONCE(folio_order(folio));

fs/dax.c

471

prep_compound_page(&folio->page, order);

fs/dax.c

473

INIT_LIST_HEAD(&folio->_deferred_list);

fs/dax.c

474

WARN_ON_ONCE(folio_ref_count(folio));

fs/dax.c

483

struct folio *folio = dax_to_folio(entry);

fs/dax.c

489

if (shared && (folio->mapping || dax_folio_is_shared(folio))) {

fs/dax.c

490

if (folio->mapping)

fs/dax.c

491

dax_folio_make_shared(folio);

fs/dax.c

493

WARN_ON_ONCE(!folio->share);

fs/dax.c

494

WARN_ON_ONCE(dax_entry_order(entry) != folio_order(folio));

fs/dax.c

495

folio->share++;

fs/dax.c

497

WARN_ON_ONCE(folio->mapping);

fs/dax.c

499

folio = dax_to_folio(entry);

fs/dax.c

500

folio->mapping = mapping;

fs/dax.c

501

folio->index = index;

fs/dax.c

508

struct folio *folio = dax_to_folio(entry);

fs/dax.c

513

dax_folio_put(folio);

fs/dax.c

518

struct folio *folio = dax_to_folio(entry);

fs/dax.c

523

if (folio_ref_count(folio) - folio_mapcount(folio))

fs/dax.c

524

return &folio->page;

fs/dax.c

537

dax_entry_t dax_lock_folio(struct folio *folio)

fs/dax.c

545

struct address_space *mapping = READ_ONCE(folio->mapping);

fs/dax.c

564

if (mapping != folio->mapping) {

fs/dax.c

568

xas_set(&xas, folio->index);

fs/dax.c

584

void dax_unlock_folio(struct folio *folio, dax_entry_t cookie)

fs/dax.c

586

struct address_space *mapping = folio->mapping;

fs/dax.c

587

XA_STATE(xas, &mapping->i_pages, folio->index);

fs/dax.c

72

static struct folio *dax_to_folio(void *entry)

fs/ecryptfs/crypto.c

264

struct folio *folio)

fs/ecryptfs/crypto.c

267

(loff_t)folio->index * PAGE_SIZE;

fs/ecryptfs/crypto.c

336

int ecryptfs_encrypt_page(struct folio *folio)

fs/ecryptfs/crypto.c

346

ecryptfs_inode = folio->mapping->host;

fs/ecryptfs/crypto.c

362

folio_page(folio, 0), folio->index,

fs/ecryptfs/crypto.c

371

lower_offset = lower_offset_for_page(crypt_stat, folio);

fs/ecryptfs/crypto.c

406

int ecryptfs_decrypt_page(struct folio *folio)

fs/ecryptfs/crypto.c

415

ecryptfs_inode = folio->mapping->host;

fs/ecryptfs/crypto.c

420

lower_offset = lower_offset_for_page(crypt_stat, folio);

fs/ecryptfs/crypto.c

421

page_virt = kmap_local_folio(folio, 0);

fs/ecryptfs/crypto.c

435

struct page *page = folio_page(folio, 0);

fs/ecryptfs/crypto.c

436

rc = crypt_extent(crypt_stat, page, page, folio->index,

fs/ecryptfs/ecryptfs_kernel.h

562

int ecryptfs_encrypt_page(struct folio *folio);

fs/ecryptfs/ecryptfs_kernel.h

563

int ecryptfs_decrypt_page(struct folio *folio);

fs/ecryptfs/ecryptfs_kernel.h

646

struct folio *folio_for_lower,

fs/ecryptfs/ecryptfs_kernel.h

651

int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,

fs/ecryptfs/mmap.c

100

loff_t view_extent_num = ((loff_t)folio->index

fs/ecryptfs/mmap.c

110

page_virt = kmap_local_folio(folio, 0);

fs/ecryptfs/mmap.c

117

page_virt, folio->mapping->host);

fs/ecryptfs/mmap.c

124

flush_dcache_folio(folio);

fs/ecryptfs/mmap.c

137

folio, (lower_offset >> PAGE_SHIFT),

fs/ecryptfs/mmap.c

139

crypt_stat->extent_size, folio->mapping->host);

fs/ecryptfs/mmap.c

163

static int ecryptfs_read_folio(struct file *file, struct folio *folio)

fs/ecryptfs/mmap.c

165

struct inode *inode = folio->mapping->host;

fs/ecryptfs/mmap.c

171

err = ecryptfs_read_lower_page_segment(folio, folio->index, 0,

fs/ecryptfs/mmap.c

172

folio_size(folio), inode);

fs/ecryptfs/mmap.c

175

err = ecryptfs_copy_up_encrypted_with_header(folio,

fs/ecryptfs/mmap.c

187

err = ecryptfs_read_lower_page_segment(folio,

fs/ecryptfs/mmap.c

188

folio->index, 0, folio_size(folio),

fs/ecryptfs/mmap.c

197

err = ecryptfs_decrypt_page(folio);

fs/ecryptfs/mmap.c

206

folio->index);

fs/ecryptfs/mmap.c

207

folio_end_read(folio, err == 0);

fs/ecryptfs/mmap.c

214

static int fill_zeros_to_end_of_page(struct folio *folio, unsigned int to)

fs/ecryptfs/mmap.c

216

struct inode *inode = folio->mapping->host;

fs/ecryptfs/mmap.c

219

if ((i_size_read(inode) / PAGE_SIZE) != folio->index)

fs/ecryptfs/mmap.c

224

folio_zero_segment(folio, end_byte_in_page, PAGE_SIZE);

fs/ecryptfs/mmap.c

245

struct folio **foliop, void **fsdata)

fs/ecryptfs/mmap.c

248

struct folio *folio;

fs/ecryptfs/mmap.c

252

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/ecryptfs/mmap.c

254

if (IS_ERR(folio))

fs/ecryptfs/mmap.c

255

return PTR_ERR(folio);

fs/ecryptfs/mmap.c

256

*foliop = folio;

fs/ecryptfs/mmap.c

259

if (!folio_test_uptodate(folio)) {

fs/ecryptfs/mmap.c

265

folio, index, 0, PAGE_SIZE, mapping->host);

fs/ecryptfs/mmap.c

270

folio_clear_uptodate(folio);

fs/ecryptfs/mmap.c

273

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

277

folio, crypt_stat);

fs/ecryptfs/mmap.c

285

folio_clear_uptodate(folio);

fs/ecryptfs/mmap.c

288

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

291

folio, index, 0, PAGE_SIZE,

fs/ecryptfs/mmap.c

297

folio_clear_uptodate(folio);

fs/ecryptfs/mmap.c

300

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

305

folio_zero_range(folio, 0, PAGE_SIZE);

fs/ecryptfs/mmap.c

306

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

308

rc = ecryptfs_decrypt_page(folio);

fs/ecryptfs/mmap.c

313

__func__, folio->index, rc);

fs/ecryptfs/mmap.c

314

folio_clear_uptodate(folio);

fs/ecryptfs/mmap.c

317

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

33

struct folio *folio = NULL;

fs/ecryptfs/mmap.c

340

folio_zero_range(folio, 0, PAGE_SIZE);

fs/ecryptfs/mmap.c

343

folio_unlock(folio);

fs/ecryptfs/mmap.c

344

folio_put(folio);

fs/ecryptfs/mmap.c

36

while ((folio = writeback_iter(mapping, wbc, folio, &error))) {

fs/ecryptfs/mmap.c

37

error = ecryptfs_encrypt_page(folio);

fs/ecryptfs/mmap.c

41

folio->index);

fs/ecryptfs/mmap.c

42

folio_clear_uptodate(folio);

fs/ecryptfs/mmap.c

443

struct folio *folio, void *fsdata)

fs/ecryptfs/mmap.c

45

folio_unlock(folio);

fs/ecryptfs/mmap.c

457

folio, 0, to);

fs/ecryptfs/mmap.c

465

if (!folio_test_uptodate(folio)) {

fs/ecryptfs/mmap.c

470

folio_mark_uptodate(folio);

fs/ecryptfs/mmap.c

473

rc = fill_zeros_to_end_of_page(folio, to);

fs/ecryptfs/mmap.c

479

rc = ecryptfs_encrypt_page(folio);

fs/ecryptfs/mmap.c

498

folio_unlock(folio);

fs/ecryptfs/mmap.c

499

folio_put(folio);

fs/ecryptfs/mmap.c

91

ecryptfs_copy_up_encrypted_with_header(struct folio *folio,

fs/ecryptfs/read_write.c

112

struct folio *ecryptfs_folio;

fs/ecryptfs/read_write.c

246

int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,

fs/ecryptfs/read_write.c

58

struct folio *folio_for_lower,

fs/efs/inode.c

17

static int efs_read_folio(struct file *file, struct folio *folio)

fs/efs/inode.c

19

return block_read_full_folio(folio, efs_get_block);

fs/efs/symlink.c

15

static int efs_symlink_read_folio(struct file *file, struct folio *folio)

fs/efs/symlink.c

17

char *link = folio_address(folio);

fs/efs/symlink.c

19

struct inode *inode = folio->mapping->host;

fs/efs/symlink.c

44

folio_end_read(folio, err == 0);

fs/erofs/data.c

259

void erofs_onlinefolio_init(struct folio *folio)

fs/erofs/data.c

266

folio->private = u.v; /* valid only if file-backed folio is locked */

fs/erofs/data.c

269

void erofs_onlinefolio_split(struct folio *folio)

fs/erofs/data.c

271

atomic_inc((atomic_t *)&folio->private);

fs/erofs/data.c

274

void erofs_onlinefolio_end(struct folio *folio, int err, bool dirty)

fs/erofs/data.c

279

orig = atomic_read((atomic_t *)&folio->private);

fs/erofs/data.c

283

} while (atomic_cmpxchg((atomic_t *)&folio->private, orig, v) != orig);

fs/erofs/data.c

287

folio->private = 0;

fs/erofs/data.c

289

flush_dcache_folio(folio);

fs/erofs/data.c

290

folio_end_read(folio, !(v & BIT(EROFS_ONLINEFOLIO_EIO)));

fs/erofs/data.c

32

struct folio *folio = NULL;

fs/erofs/data.c

404

static int erofs_read_folio(struct file *file, struct folio *folio)

fs/erofs/data.c

408

.cur_folio = folio,

fs/erofs/data.c

412

.realinode = erofs_real_inode(folio_inode(folio), &need_iput),

fs/erofs/data.c

415

trace_erofs_read_folio(iter_ctx.realinode, folio, true);

fs/erofs/data.c

49

folio = page_folio(buf->page);

fs/erofs/data.c

50

if (folio_file_page(folio, index) != buf->page)

fs/erofs/data.c

53

if (!folio || !folio_contains(folio, index)) {

fs/erofs/data.c

55

folio = read_mapping_folio(buf->mapping, index, buf->file);

fs/erofs/data.c

56

if (IS_ERR(folio))

fs/erofs/data.c

57

return folio;

fs/erofs/data.c

59

buf->page = folio_file_page(folio, index);

fs/erofs/fileio.c

107

ofs = folio_pos(folio) + cur - map->m_la;

fs/erofs/fileio.c

119

memcpy_to_folio(folio, cur, src, len);

fs/erofs/fileio.c

122

folio_zero_segment(folio, cur, cur + len);

fs/erofs/fileio.c

145

if (!bio_add_folio(&io->rq->bio, folio, len, cur))

fs/erofs/fileio.c

148

erofs_onlinefolio_split(folio);

fs/erofs/fileio.c

153

erofs_onlinefolio_end(folio, err, false);

fs/erofs/fileio.c

157

static int erofs_fileio_read_folio(struct file *file, struct folio *folio)

fs/erofs/fileio.c

160

struct inode *realinode = erofs_real_inode(folio_inode(folio), &need_iput);

fs/erofs/fileio.c

164

trace_erofs_read_folio(realinode, folio, true);

fs/erofs/fileio.c

165

err = erofs_fileio_scan_folio(&io, realinode, folio);

fs/erofs/fileio.c

177

struct folio *folio;

fs/erofs/fileio.c

182

while ((folio = readahead_folio(rac))) {

fs/erofs/fileio.c

183

err = erofs_fileio_scan_folio(&io, realinode, folio);

fs/erofs/fileio.c

186

folio->index, EROFS_I(realinode)->nid);

fs/erofs/fileio.c

32

DBG_BUGON(folio_test_uptodate(fi.folio));

fs/erofs/fileio.c

33

erofs_onlinefolio_end(fi.folio, ret < 0, false);

fs/erofs/fileio.c

90

struct inode *inode, struct folio *folio)

fs/erofs/fileio.c

93

unsigned int cur = 0, end = folio_size(folio), len, attached = 0;

fs/erofs/fileio.c

94

loff_t pos = folio_pos(folio), ofs;

fs/erofs/fileio.c

97

erofs_onlinefolio_init(folio);

fs/erofs/internal.h

328

static inline struct folio *erofs_grab_folio_nowait(struct address_space *as,

fs/erofs/internal.h

415

void erofs_onlinefolio_init(struct folio *folio);

fs/erofs/internal.h

416

void erofs_onlinefolio_split(struct folio *folio);

fs/erofs/internal.h

417

void erofs_onlinefolio_end(struct folio *folio, int err, bool dirty);

fs/erofs/zdata.c

1006

struct folio *folio, bool ra)

fs/erofs/zdata.c

1010

const loff_t offset = folio_pos(folio);

fs/erofs/zdata.c

1012

unsigned int end = folio_size(folio), split = 0, cur, pgs;

fs/erofs/zdata.c

1017

erofs_onlinefolio_init(folio);

fs/erofs/zdata.c

1037

err = z_erofs_read_fragment(inode->i_sb, folio, cur,

fs/erofs/zdata.c

1044

folio_zero_segment(folio, cur, end);

fs/erofs/zdata.c

1070

.page = folio_page(folio, pgs >> PAGE_SHIFT),

fs/erofs/zdata.c

1076

erofs_onlinefolio_split(folio);

fs/erofs/zdata.c

1093

erofs_onlinefolio_end(folio, err, false);

fs/erofs/zdata.c

111

static bool erofs_folio_is_managed(struct erofs_sb_info *sbi, struct folio *fo)

fs/erofs/zdata.c

1490

struct folio *folio;

fs/erofs/zdata.c

1507

folio = page_folio(zbv.page);

fs/erofs/zdata.c

1515

if (folio->private == Z_EROFS_PREALLOCATED_FOLIO) {

fs/erofs/zdata.c

1516

folio->private = NULL;

fs/erofs/zdata.c

1521

mapping = READ_ONCE(folio->mapping);

fs/erofs/zdata.c

1533

folio_lock(folio);

fs/erofs/zdata.c

1534

if (likely(folio->mapping == mc)) {

fs/erofs/zdata.c

1539

if (!folio_test_private(folio)) {

fs/erofs/zdata.c

1540

folio_attach_private(folio, pcl);

fs/erofs/zdata.c

1542

folio_put(folio);

fs/erofs/zdata.c

1544

if (likely(folio->private == pcl)) {

fs/erofs/zdata.c

1546

if (folio_test_uptodate(folio)) {

fs/erofs/zdata.c

1547

folio_unlock(folio);

fs/erofs/zdata.c

1555

folio_unlock(folio);

fs/erofs/zdata.c

1556

folio_put(folio);

fs/erofs/zdata.c

1572

folio = page_folio(page);

fs/erofs/zdata.c

1575

filemap_add_folio(mc, folio, (pcl->pos >> PAGE_SHIFT) + nr, gfp)) {

fs/erofs/zdata.c

1577

folio->private = (void *)Z_EROFS_SHORTLIVED_PAGE;

fs/erofs/zdata.c

1580

folio_attach_private(folio, pcl);

fs/erofs/zdata.c

1582

folio_put(folio);

fs/erofs/zdata.c

1639

struct folio *folio = fi.folio;

fs/erofs/zdata.c

1641

DBG_BUGON(folio_test_uptodate(folio));

fs/erofs/zdata.c

1642

DBG_BUGON(z_erofs_page_is_invalidated(&folio->page));

fs/erofs/zdata.c

1643

if (!erofs_folio_is_managed(EROFS_SB(q->sb), folio))

fs/erofs/zdata.c

1647

folio_mark_uptodate(folio);

fs/erofs/zdata.c

1648

folio_unlock(folio);

fs/erofs/zdata.c

1853

struct folio *folio;

fs/erofs/zdata.c

1855

folio = erofs_grab_folio_nowait(f->sharedinode->i_mapping, index);

fs/erofs/zdata.c

1856

if (!IS_ERR_OR_NULL(folio)) {

fs/erofs/zdata.c

1857

if (folio_test_uptodate(folio))

fs/erofs/zdata.c

1858

folio_unlock(folio);

fs/erofs/zdata.c

1860

z_erofs_scan_folio(f, folio, !!rac);

fs/erofs/zdata.c

1861

folio_put(folio);

fs/erofs/zdata.c

1870

static int z_erofs_read_folio(struct file *file, struct folio *folio)

fs/erofs/zdata.c

1872

struct inode *sharedinode = folio->mapping->host;

fs/erofs/zdata.c

1875

Z_EROFS_DEFINE_FRONTEND(f, realinode, sharedinode, folio_pos(folio));

fs/erofs/zdata.c

1878

trace_erofs_read_folio(realinode, folio, false);

fs/erofs/zdata.c

1880

err = z_erofs_scan_folio(&f, folio, false);

fs/erofs/zdata.c

1888

err, folio->index, EROFS_I(realinode)->nid);

fs/erofs/zdata.c

1905

struct folio *head = NULL, *folio;

fs/erofs/zdata.c

1910

while ((folio = readahead_folio(rac))) {

fs/erofs/zdata.c

1911

folio->private = head;

fs/erofs/zdata.c

1912

head = folio;

fs/erofs/zdata.c

1917

folio = head;

fs/erofs/zdata.c

1918

head = folio_get_private(folio);

fs/erofs/zdata.c

1920

err = z_erofs_scan_folio(&f, folio, true);

fs/erofs/zdata.c

1923

folio->index, EROFS_I(realinode)->nid);

fs/erofs/zdata.c

544

struct folio *folio, *newfolio;

fs/erofs/zdata.c

556

folio = filemap_get_folio(mc, poff + i);

fs/erofs/zdata.c

557

if (IS_ERR(folio)) {

fs/erofs/zdata.c

570

folio = NULL;

fs/erofs/zdata.c

575

folio_page(folio ?: newfolio, 0);

fs/erofs/zdata.c

580

folio_put(folio ?: newfolio);

fs/erofs/zdata.c

596

struct folio *folio;

fs/erofs/zdata.c

603

folio = page_folio(pcl->compressed_bvecs[i].page);

fs/erofs/zdata.c

605

if (!folio_trylock(folio))

fs/erofs/zdata.c

608

DBG_BUGON(!erofs_folio_is_managed(sbi, folio));

fs/erofs/zdata.c

610

folio_detach_private(folio);

fs/erofs/zdata.c

611

folio_unlock(folio);

fs/erofs/zdata.c

617

static bool z_erofs_cache_release_folio(struct folio *folio, gfp_t gfp)

fs/erofs/zdata.c

619

struct z_erofs_pcluster *pcl = folio_get_private(folio);

fs/erofs/zdata.c

624

if (!folio_test_private(folio))

fs/erofs/zdata.c

632

if (bvec->page && page_folio(bvec->page) == folio) {

fs/erofs/zdata.c

634

folio_detach_private(folio);

fs/erofs/zdata.c

649

static void z_erofs_cache_invalidate_folio(struct folio *folio,

fs/erofs/zdata.c

655

DBG_BUGON(stop > folio_size(folio) || stop < length);

fs/erofs/zdata.c

657

if (offset == 0 && stop == folio_size(folio))

fs/erofs/zdata.c

658

while (!z_erofs_cache_release_folio(folio, 0))

fs/erofs/zdata.c

980

static int z_erofs_read_fragment(struct super_block *sb, struct folio *folio,

fs/erofs/zdata.c

999

memcpy_to_folio(folio, cur, src, cnt);

fs/exfat/inode.c

244

static int exfat_read_folio(struct file *file, struct folio *folio)

fs/exfat/inode.c

247

.cur_folio = folio,

fs/exfat/iomap.c

201

struct folio *folio, u64 offset, unsigned int len, u64 end_pos)

fs/exfat/iomap.c

213

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/exfat/iomap.c

237

struct folio *folio = iter.folio;

fs/exfat/iomap.c

238

struct exfat_inode_info *ei = EXFAT_I(folio->mapping->host);

fs/exfat/iomap.c

240

loff_t pos = folio_pos(folio);

fs/exfat/iomap.c

245

folio_zero_segment(folio, offset_in_folio(folio, valid_size),

fs/exfat/iomap.c

248

iomap_finish_folio_read(folio, iter.offset, iter.length, error);

fs/ext2/dir.c

100

static bool ext2_check_folio(struct folio *folio, int quiet, char *kaddr)

fs/ext2/dir.c

102

struct inode *dir = folio->mapping->host;

fs/ext2/dir.c

107

unsigned limit = folio_size(folio);

fs/ext2/dir.c

111

if (dir->i_size < folio_pos(folio) + limit) {

fs/ext2/dir.c

112

limit = offset_in_folio(folio, dir->i_size);

fs/ext2/dir.c

136

folio_set_checked(folio);

fs/ext2/dir.c

165

dir->i_ino, error, folio_pos(folio) + offs,

fs/ext2/dir.c

175

dir->i_ino, folio_pos(folio) + offs,

fs/ext2/dir.c

191

int quiet, struct folio **foliop)

fs/ext2/dir.c

194

struct folio *folio = read_mapping_folio(mapping, n, NULL);

fs/ext2/dir.c

197

if (IS_ERR(folio))

fs/ext2/dir.c

198

return ERR_CAST(folio);

fs/ext2/dir.c

199

kaddr = kmap_local_folio(folio, 0);

fs/ext2/dir.c

200

if (unlikely(!folio_test_checked(folio))) {

fs/ext2/dir.c

201

if (!ext2_check_folio(folio, quiet, kaddr))

fs/ext2/dir.c

204

*foliop = folio;

fs/ext2/dir.c

208

folio_release_kmap(folio, kaddr);

fs/ext2/dir.c

278

struct folio *folio;

fs/ext2/dir.c

279

char *kaddr = ext2_get_folio(inode, n, 0, &folio);

fs/ext2/dir.c

303

folio_release_kmap(folio, de);

fs/ext2/dir.c

315

folio_release_kmap(folio, de);

fs/ext2/dir.c

321

folio_release_kmap(folio, kaddr);

fs/ext2/dir.c

344

const struct qstr *child, struct folio **foliop)

fs/ext2/dir.c

413

struct ext2_dir_entry_2 *ext2_dotdot(struct inode *dir, struct folio **foliop)

fs/ext2/dir.c

425

struct folio *folio;

fs/ext2/dir.c

427

de = ext2_find_entry(dir, child, &folio);

fs/ext2/dir.c

432

folio_release_kmap(folio, de);

fs/ext2/dir.c

436

static int ext2_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/ext2/dir.c

438

return __block_write_begin(folio, pos, len, ext2_get_block);

fs/ext2/dir.c

452

struct folio *folio, struct inode *inode, bool update_times)

fs/ext2/dir.c

454

loff_t pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/ext2/dir.c

458

folio_lock(folio);

fs/ext2/dir.c

459

err = ext2_prepare_chunk(folio, pos, len);

fs/ext2/dir.c

461

folio_unlock(folio);

fs/ext2/dir.c

466

ext2_commit_chunk(folio, pos, len);

fs/ext2/dir.c

485

struct folio *folio = NULL;

fs/ext2/dir.c

498

char *kaddr = ext2_get_folio(dir, n, 0, &folio);

fs/ext2/dir.c

503

folio_lock(folio);

fs/ext2/dir.c

506

kaddr += folio_size(folio) - reclen;

fs/ext2/dir.c

533

folio_unlock(folio);

fs/ext2/dir.c

534

folio_release_kmap(folio, kaddr);

fs/ext2/dir.c

540

pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/ext2/dir.c

541

err = ext2_prepare_chunk(folio, pos, rec_len);

fs/ext2/dir.c

554

ext2_commit_chunk(folio, pos, rec_len);

fs/ext2/dir.c

561

folio_release_kmap(folio, de);

fs/ext2/dir.c

564

folio_unlock(folio);

fs/ext2/dir.c

572

int ext2_delete_entry(struct ext2_dir_entry_2 *dir, struct folio *folio)

fs/ext2/dir.c

574

struct inode *inode = folio->mapping->host;

fs/ext2/dir.c

581

from = offset_in_folio(folio, dir);

fs/ext2/dir.c

597

from = offset_in_folio(folio, pde);

fs/ext2/dir.c

598

pos = folio_pos(folio) + from;

fs/ext2/dir.c

599

folio_lock(folio);

fs/ext2/dir.c

600

err = ext2_prepare_chunk(folio, pos, to - from);

fs/ext2/dir.c

602

folio_unlock(folio);

fs/ext2/dir.c

608

ext2_commit_chunk(folio, pos, to - from);

fs/ext2/dir.c

620

struct folio *folio = filemap_grab_folio(inode->i_mapping, 0);

fs/ext2/dir.c

626

if (IS_ERR(folio))

fs/ext2/dir.c

627

return PTR_ERR(folio);

fs/ext2/dir.c

629

err = ext2_prepare_chunk(folio, 0, chunk_size);

fs/ext2/dir.c

631

folio_unlock(folio);

fs/ext2/dir.c

634

kaddr = kmap_local_folio(folio, 0);

fs/ext2/dir.c

650

ext2_commit_chunk(folio, 0, chunk_size);

fs/ext2/dir.c

653

folio_put(folio);

fs/ext2/dir.c

662

struct folio *folio;

fs/ext2/dir.c

669

kaddr = ext2_get_folio(inode, i, 0, &folio);

fs/ext2/dir.c

698

folio_release_kmap(folio, kaddr);

fs/ext2/dir.c

703

folio_release_kmap(folio, kaddr);

fs/ext2/dir.c

85

static void ext2_commit_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/ext2/dir.c

87

struct address_space *mapping = folio->mapping;

fs/ext2/dir.c

91

block_write_end(pos, len, len, folio);

fs/ext2/dir.c

97

folio_unlock(folio);

fs/ext2/ext2.h

722

struct folio **foliop);

fs/ext2/ext2.h

723

int ext2_delete_entry(struct ext2_dir_entry_2 *dir, struct folio *folio);

fs/ext2/ext2.h

725

struct ext2_dir_entry_2 *ext2_dotdot(struct inode *dir, struct folio **foliop);

fs/ext2/ext2.h

727

struct folio *folio, struct inode *inode, bool update_times);

fs/ext2/inode.c

891

static int ext2_read_folio(struct file *file, struct folio *folio)

fs/ext2/inode.c

893

return mpage_read_folio(folio, ext2_get_block);

fs/ext2/inode.c

903

loff_t pos, unsigned len, struct folio **foliop, void **fsdata)

fs/ext2/inode.c

916

struct folio *folio, void *fsdata)

fs/ext2/inode.c

920

ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/ext2/namei.c

275

struct folio *folio;

fs/ext2/namei.c

282

de = ext2_find_entry(dir, &dentry->d_name, &folio);

fs/ext2/namei.c

288

err = ext2_delete_entry(de, folio);

fs/ext2/namei.c

289

folio_release_kmap(folio, de);

fs/ext2/namei.c

326

struct folio *dir_folio = NULL;

fs/ext2/namei.c

328

struct folio * old_folio;

fs/ext2/namei.c

356

struct folio *new_folio;

fs/ext4/ext4.h

3740

int ext4_readpage_inline(struct inode *inode, struct folio *folio);

fs/ext4/ext4.h

3744

struct folio **foliop);

fs/ext4/ext4.h

3746

unsigned copied, struct folio *folio);

fs/ext4/ext4.h

3750

struct folio **foliop,

fs/ext4/ext4.h

3830

int ext4_read_folio(struct file *file, struct folio *folio);

fs/ext4/ext4.h

3948

int ext4_bio_write_folio(struct ext4_io_submit *io, struct folio *page,

fs/ext4/ext4.h

4031

extern int ext4_block_write_begin(handle_t *handle, struct folio *folio,

fs/ext4/inline.c

503

static int ext4_read_inline_folio(struct inode *inode, struct folio *folio)

fs/ext4/inline.c

510

BUG_ON(!folio_test_locked(folio));

fs/ext4/inline.c

512

BUG_ON(folio->index);

fs/ext4/inline.c

534

kaddr = kmap_local_folio(folio, 0);

fs/ext4/inline.c

536

kaddr = folio_zero_tail(folio, len, kaddr + len);

fs/ext4/inline.c

538

folio_mark_uptodate(folio);

fs/ext4/inline.c

545

int ext4_readpage_inline(struct inode *inode, struct folio *folio)

fs/ext4/inline.c

559

if (!folio->index)

fs/ext4/inline.c

560

ret = ext4_read_inline_folio(inode, folio);

fs/ext4/inline.c

561

else if (!folio_test_uptodate(folio)) {

fs/ext4/inline.c

562

folio_zero_segment(folio, 0, folio_size(folio));

fs/ext4/inline.c

563

folio_mark_uptodate(folio);

fs/ext4/inline.c

568

folio_unlock(folio);

fs/ext4/inline.c

578

struct folio *folio = NULL;

fs/ext4/inline.c

607

folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS,

fs/ext4/inline.c

609

if (IS_ERR(folio)) {

fs/ext4/inline.c

610

ret = PTR_ERR(folio);

fs/ext4/inline.c

624

if (!folio_test_uptodate(folio)) {

fs/ext4/inline.c

625

ret = ext4_read_inline_folio(inode, folio);

fs/ext4/inline.c

636

ret = ext4_block_write_begin(handle, folio, from, to,

fs/ext4/inline.c

639

ret = ext4_block_write_begin(handle, folio, from, to,

fs/ext4/inline.c

641

clear_buffer_new(folio_buffers(folio));

fs/ext4/inline.c

645

folio_buffers(folio), from, to,

fs/ext4/inline.c

650

folio_unlock(folio);

fs/ext4/inline.c

651

folio_put(folio);

fs/ext4/inline.c

652

folio = NULL;

fs/ext4/inline.c

672

if (folio)

fs/ext4/inline.c

673

block_commit_write(folio, from, to);

fs/ext4/inline.c

675

if (folio) {

fs/ext4/inline.c

676

folio_unlock(folio);

fs/ext4/inline.c

677

folio_put(folio);

fs/ext4/inline.c

699

struct folio **foliop,

fs/ext4/inline.c

704

struct folio *folio;

fs/ext4/inline.c

738

folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS,

fs/ext4/inline.c

740

if (IS_ERR(folio)) {

fs/ext4/inline.c

741

ret = PTR_ERR(folio);

fs/ext4/inline.c

752

if (!folio_test_uptodate(folio)) {

fs/ext4/inline.c

753

ret = ext4_read_inline_folio(inode, folio);

fs/ext4/inline.c

761

*foliop = folio;

fs/ext4/inline.c

768

folio_unlock(folio);

fs/ext4/inline.c

769

folio_put(folio);

fs/ext4/inline.c

786

struct folio **foliop)

fs/ext4/inline.c

795

unsigned copied, struct folio *folio)

fs/ext4/inline.c

803

if (unlikely(copied < len) && !folio_test_uptodate(folio))

fs/ext4/inline.c

809

folio_unlock(folio);

fs/ext4/inline.c

810

folio_put(folio);

fs/ext4/inline.c

824

kaddr = kmap_local_folio(folio, 0);

fs/ext4/inline.c

827

folio_mark_uptodate(folio);

fs/ext4/inline.c

829

folio_clear_dirty(folio);

fs/ext4/inline.c

841

folio_unlock(folio);

fs/ext4/inline.c

842

folio_put(folio);

fs/ext4/inline.c

890

struct folio *folio;

fs/ext4/inline.c

892

folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN,

fs/ext4/inline.c

894

if (IS_ERR(folio))

fs/ext4/inline.c

895

return PTR_ERR(folio);

fs/ext4/inline.c

905

if (!folio_test_uptodate(folio)) {

fs/ext4/inline.c

906

ret = ext4_read_inline_folio(inode, folio);

fs/ext4/inline.c

911

ret = ext4_block_write_begin(NULL, folio, 0, inline_size,

fs/ext4/inline.c

915

folio_unlock(folio);

fs/ext4/inline.c

916

folio_put(folio);

fs/ext4/inline.c

921

clear_buffer_new(folio_buffers(folio));

fs/ext4/inline.c

922

folio_mark_dirty(folio);

fs/ext4/inline.c

923

folio_mark_uptodate(folio);

fs/ext4/inline.c

929

if (folio) {

fs/ext4/inline.c

930

folio_unlock(folio);

fs/ext4/inline.c

931

folio_put(folio);

fs/ext4/inode.c

1151

struct folio *folio = bh->b_folio;

fs/ext4/inode.c

1152

struct inode *inode = folio->mapping->host;

fs/ext4/inode.c

1156

folio_mark_dirty(folio);

fs/ext4/inode.c

1170

int ext4_block_write_begin(handle_t *handle, struct folio *folio,

fs/ext4/inode.c

1174

unsigned int from = offset_in_folio(folio, pos);

fs/ext4/inode.c

1176

struct inode *inode = folio->mapping->host;

fs/ext4/inode.c

1186

BUG_ON(!folio_test_locked(folio));

fs/ext4/inode.c

1187

BUG_ON(to > folio_size(folio));

fs/ext4/inode.c

1189

WARN_ON_ONCE(blocksize > folio_size(folio));

fs/ext4/inode.c

1191

head = folio_buffers(folio);

fs/ext4/inode.c

1193

head = create_empty_buffers(folio, blocksize, 0);

fs/ext4/inode.c

1194

block = EXT4_PG_TO_LBLK(inode, folio->index);

fs/ext4/inode.c

1200

if (folio_test_uptodate(folio)) {

fs/ext4/inode.c

1223

if (folio_test_uptodate(folio)) {

fs/ext4/inode.c

1234

folio_zero_segments(folio, to,

fs/ext4/inode.c

1240

if (folio_test_uptodate(folio)) {

fs/ext4/inode.c

1261

ext4_journalled_zero_new_buffers(handle, inode, folio,

fs/ext4/inode.c

1264

folio_zero_new_buffers(folio, from, to);

fs/ext4/inode.c

1269

err2 = fscrypt_decrypt_pagecache_blocks(folio,

fs/ext4/inode.c

1291

struct folio **foliop, void **fsdata)

fs/ext4/inode.c

1297

struct folio *folio;

fs/ext4/inode.c

1331

folio = write_begin_get_folio(iocb, mapping, index, len);

fs/ext4/inode.c

1332

if (IS_ERR(folio))

fs/ext4/inode.c

1333

return PTR_ERR(folio);

fs/ext4/inode.c

1335

if (len > folio_next_pos(folio) - pos)

fs/ext4/inode.c

1336

len = folio_next_pos(folio) - pos;

fs/ext4/inode.c

1338

from = offset_in_folio(folio, pos);

fs/ext4/inode.c

1345

if (!folio_buffers(folio))

fs/ext4/inode.c

1346

create_empty_buffers(folio, inode->i_sb->s_blocksize, 0);

fs/ext4/inode.c

1348

folio_unlock(folio);

fs/ext4/inode.c

1353

folio_put(folio);

fs/ext4/inode.c

1357

folio_lock(folio);

fs/ext4/inode.c

1358

if (folio->mapping != mapping) {

fs/ext4/inode.c

1360

folio_unlock(folio);

fs/ext4/inode.c

1361

folio_put(folio);

fs/ext4/inode.c

1366

folio_wait_stable(folio);

fs/ext4/inode.c

1369

ret = ext4_block_write_begin(handle, folio, pos, len,

fs/ext4/inode.c

1372

ret = ext4_block_write_begin(handle, folio, pos, len,

fs/ext4/inode.c

1376

folio_buffers(folio), from, to,

fs/ext4/inode.c

1384

folio_unlock(folio);

fs/ext4/inode.c

1413

folio_put(folio);

fs/ext4/inode.c

1416

*foliop = folio;

fs/ext4/inode.c

1442

struct folio *folio, void *fsdata)

fs/ext4/inode.c

1456

folio);

fs/ext4/inode.c

1458

copied = block_write_end(pos, len, copied, folio);

fs/ext4/inode.c

1468

folio_unlock(folio);

fs/ext4/inode.c

1469

folio_put(folio);

fs/ext4/inode.c

1515

struct folio *folio,

fs/ext4/inode.c

1521

bh = head = folio_buffers(folio);

fs/ext4/inode.c

1526

if (!folio_test_uptodate(folio)) {

fs/ext4/inode.c

1532

folio_zero_range(folio, start, size);

fs/ext4/inode.c

1546

struct folio *folio, void *fsdata)

fs/ext4/inode.c

1566

folio);

fs/ext4/inode.c

1568

if (unlikely(copied < len) && !folio_test_uptodate(folio)) {

fs/ext4/inode.c

1570

ext4_journalled_zero_new_buffers(handle, inode, folio,

fs/ext4/inode.c

1574

ext4_journalled_zero_new_buffers(handle, inode, folio,

fs/ext4/inode.c

1577

folio_buffers(folio),

fs/ext4/inode.c

1581

folio_mark_uptodate(folio);

fs/ext4/inode.c

1586

folio_unlock(folio);

fs/ext4/inode.c

1587

folio_put(folio);

fs/ext4/inode.c

1751

struct folio *folio = fbatch.folios[i];

fs/ext4/inode.c

1753

if (folio_pos(folio) < mpd->start_pos)

fs/ext4/inode.c

1755

if (folio_next_index(folio) > end)

fs/ext4/inode.c

1757

BUG_ON(!folio_test_locked(folio));

fs/ext4/inode.c

1758

BUG_ON(folio_test_writeback(folio));

fs/ext4/inode.c

1760

if (folio_mapped(folio)) {

fs/ext4/inode.c

1761

folio_clear_dirty_for_io(folio);

fs/ext4/inode.c

1772

unmap_mapping_pages(folio->mapping,

fs/ext4/inode.c

1773

folio->index,

fs/ext4/inode.c

1774

folio_nr_pages(folio), false);

fs/ext4/inode.c

1776

block_invalidate_folio(folio, 0,

fs/ext4/inode.c

1777

folio_size(folio));

fs/ext4/inode.c

1778

folio_clear_uptodate(folio);

fs/ext4/inode.c

1780

folio_unlock(folio);

fs/ext4/inode.c

2071

static void mpage_folio_done(struct mpage_da_data *mpd, struct folio *folio)

fs/ext4/inode.c

2073

mpd->start_pos += folio_size(folio);

fs/ext4/inode.c

2074

mpd->wbc->nr_to_write -= folio_nr_pages(folio);

fs/ext4/inode.c

2075

folio_unlock(folio);

fs/ext4/inode.c

2078

static int mpage_submit_folio(struct mpage_da_data *mpd, struct folio *folio)

fs/ext4/inode.c

2084

WARN_ON_ONCE(folio_pos(folio) != mpd->start_pos);

fs/ext4/inode.c

2085

folio_clear_dirty_for_io(folio);

fs/ext4/inode.c

2100

len = folio_size(folio);

fs/ext4/inode.c

2101

if (folio_pos(folio) + len > size &&

fs/ext4/inode.c

2104

err = ext4_bio_write_folio(&mpd->io_submit, folio, len);

fs/ext4/inode.c

2243

static int mpage_process_folio(struct mpage_da_data *mpd, struct folio *folio,

fs/ext4/inode.c

2255

bh = head = folio_buffers(folio);

fs/ext4/inode.c

2334

struct folio *folio = fbatch.folios[i];

fs/ext4/inode.c

2336

lblk = EXT4_PG_TO_LBLK(inode, folio->index);

fs/ext4/inode.c

2337

err = mpage_process_folio(mpd, folio, &lblk, &pblock,

fs/ext4/inode.c

2347

err = mpage_submit_folio(mpd, folio);

fs/ext4/inode.c

2350

mpage_folio_done(mpd, folio);

fs/ext4/inode.c

2420

struct folio *folio;

fs/ext4/inode.c

2424

folio = filemap_get_folio(inode->i_mapping,

fs/ext4/inode.c

2426

if (IS_ERR(folio))

fs/ext4/inode.c

2427

return PTR_ERR(folio);

fs/ext4/inode.c

2433

if (WARN_ON_ONCE((folio_pos(folio) == pos) ||

fs/ext4/inode.c

2434

!folio_contains(folio, pos >> PAGE_SHIFT)))

fs/ext4/inode.c

2437

ret = mpage_submit_folio(mpd, folio);

fs/ext4/inode.c

2449

folio_unlock(folio);

fs/ext4/inode.c

2450

folio_put(folio);

fs/ext4/inode.c

2571

static int ext4_journal_folio_buffers(handle_t *handle, struct folio *folio,

fs/ext4/inode.c

2574

struct buffer_head *page_bufs = folio_buffers(folio);

fs/ext4/inode.c

2575

struct inode *inode = folio->mapping->host;

fs/ext4/inode.c

2584

err = ext4_jbd2_inode_add_write(handle, inode, folio_pos(folio), len);

fs/ext4/inode.c

2594

struct folio *folio)

fs/ext4/inode.c

2598

size_t len = folio_size(folio);

fs/ext4/inode.c

2600

folio_clear_checked(folio);

fs/ext4/inode.c

2601

mpd->wbc->nr_to_write -= folio_nr_pages(folio);

fs/ext4/inode.c

2603

if (folio_pos(folio) + len > size &&

fs/ext4/inode.c

2607

return ext4_journal_folio_buffers(handle, folio, len);

fs/ext4/inode.c

2662

struct folio *folio = fbatch.folios[i];

fs/ext4/inode.c

2679

mpd->next_pos != folio_pos(folio))

fs/ext4/inode.c

2689

folio_lock(folio);

fs/ext4/inode.c

2697

if (!folio_test_dirty(folio) ||

fs/ext4/inode.c

2698

(folio_test_writeback(folio) &&

fs/ext4/inode.c

2700

unlikely(folio->mapping != mapping)) {

fs/ext4/inode.c

2701

folio_unlock(folio);

fs/ext4/inode.c

2705

folio_wait_writeback(folio);

fs/ext4/inode.c

2706

BUG_ON(folio_test_writeback(folio));

fs/ext4/inode.c

2717

if (!folio_buffers(folio)) {

fs/ext4/inode.c

2718

ext4_warning_inode(mpd->inode, "page %lu does not have buffers attached", folio->index);

fs/ext4/inode.c

2719

folio_clear_dirty(folio);

fs/ext4/inode.c

2720

folio_unlock(folio);

fs/ext4/inode.c

2725

mpd->start_pos = folio_pos(folio);

fs/ext4/inode.c

2726

mpd->next_pos = folio_next_pos(folio);

fs/ext4/inode.c

2738

err = mpage_submit_folio(mpd, folio);

fs/ext4/inode.c

2742

if (folio_test_checked(folio)) {

fs/ext4/inode.c

2744

mpd, folio);

fs/ext4/inode.c

2749

mpage_folio_done(mpd, folio);

fs/ext4/inode.c

2752

lblk = EXT4_PG_TO_LBLK(mpd->inode, folio->index);

fs/ext4/inode.c

2753

head = folio_buffers(folio);

fs/ext4/inode.c

3138

struct folio **foliop, void **fsdata)

fs/ext4/inode.c

3141

struct folio *folio;

fs/ext4/inode.c

3169

folio = write_begin_get_folio(iocb, mapping, index, len);

fs/ext4/inode.c

3170

if (IS_ERR(folio))

fs/ext4/inode.c

3171

return PTR_ERR(folio);

fs/ext4/inode.c

3173

if (len > folio_next_pos(folio) - pos)

fs/ext4/inode.c

3174

len = folio_next_pos(folio) - pos;

fs/ext4/inode.c

3176

ret = ext4_block_write_begin(NULL, folio, pos, len,

fs/ext4/inode.c

3179

folio_unlock(folio);

fs/ext4/inode.c

3180

folio_put(folio);

fs/ext4/inode.c

3195

*foliop = folio;

fs/ext4/inode.c

3203

static int ext4_da_should_update_i_disksize(struct folio *folio,

fs/ext4/inode.c

3207

struct inode *inode = folio->mapping->host;

fs/ext4/inode.c

3211

bh = folio_buffers(folio);

fs/ext4/inode.c

3224

struct folio *folio)

fs/ext4/inode.c

3232

if (unlikely(!folio_buffers(folio))) {

fs/ext4/inode.c

3233

folio_unlock(folio);

fs/ext4/inode.c

3234

folio_put(folio);

fs/ext4/inode.c

3241

copied = block_write_end(pos, len, copied, folio);

fs/ext4/inode.c

3263

end = offset_in_folio(folio, new_i_size - 1);

fs/ext4/inode.c

3264

if (copied && ext4_da_should_update_i_disksize(folio, end)) {

fs/ext4/inode.c

3270

folio_unlock(folio);

fs/ext4/inode.c

3271

folio_put(folio);

fs/ext4/inode.c

3291

struct folio *folio, void *fsdata)

fs/ext4/inode.c

3298

len, copied, folio, fsdata);

fs/ext4/inode.c

3306

folio);

fs/ext4/inode.c

3308

if (unlikely(copied < len) && !folio_test_uptodate(folio))

fs/ext4/inode.c

3311

return ext4_da_do_write_end(mapping, pos, len, copied, folio);

fs/ext4/inode.c

3401

static void ext4_invalidate_folio(struct folio *folio, size_t offset,

fs/ext4/inode.c

3404

trace_ext4_invalidate_folio(folio, offset, length);

fs/ext4/inode.c

3407

WARN_ON(folio_buffers(folio) && buffer_jbd(folio_buffers(folio)));

fs/ext4/inode.c

3409

block_invalidate_folio(folio, offset, length);

fs/ext4/inode.c

3412

static int __ext4_journalled_invalidate_folio(struct folio *folio,

fs/ext4/inode.c

3415

journal_t *journal = EXT4_JOURNAL(folio->mapping->host);

fs/ext4/inode.c

3417

trace_ext4_journalled_invalidate_folio(folio, offset, length);

fs/ext4/inode.c

3422

if (offset == 0 && length == folio_size(folio))

fs/ext4/inode.c

3423

folio_clear_checked(folio);

fs/ext4/inode.c

3425

return jbd2_journal_invalidate_folio(journal, folio, offset, length);

fs/ext4/inode.c

3429

static void ext4_journalled_invalidate_folio(struct folio *folio,

fs/ext4/inode.c

3433

WARN_ON(__ext4_journalled_invalidate_folio(folio, offset, length) < 0);

fs/ext4/inode.c

3436

static bool ext4_release_folio(struct folio *folio, gfp_t wait)

fs/ext4/inode.c

3438

struct inode *inode = folio->mapping->host;

fs/ext4/inode.c

3441

trace_ext4_release_folio(inode, folio);

fs/ext4/inode.c

3444

if (folio_test_checked(folio))

fs/ext4/inode.c

3447

return jbd2_journal_try_to_free_buffers(journal, folio);

fs/ext4/inode.c

3449

return try_to_free_buffers(folio);

fs/ext4/inode.c

3928

struct folio *folio)

fs/ext4/inode.c

3930

WARN_ON_ONCE(!folio_buffers(folio));

fs/ext4/inode.c

3931

if (folio_maybe_dma_pinned(folio))

fs/ext4/inode.c

3932

folio_set_checked(folio);

fs/ext4/inode.c

3933

return filemap_dirty_folio(mapping, folio);

fs/ext4/inode.c

3936

static bool ext4_dirty_folio(struct address_space *mapping, struct folio *folio)

fs/ext4/inode.c

3938

WARN_ON_ONCE(!folio_test_locked(folio) && !folio_test_dirty(folio));

fs/ext4/inode.c

3939

WARN_ON_ONCE(!folio_buffers(folio));

fs/ext4/inode.c

3940

return block_dirty_folio(mapping, folio);

fs/ext4/inode.c

4037

struct folio *folio;

fs/ext4/inode.c

4040

folio = __filemap_get_folio(mapping, from >> PAGE_SHIFT,

fs/ext4/inode.c

4043

if (IS_ERR(folio))

fs/ext4/inode.c

4044

return ERR_CAST(folio);

fs/ext4/inode.c

4048

iblock = EXT4_PG_TO_LBLK(inode, folio->index);

fs/ext4/inode.c

4050

bh = folio_buffers(folio);

fs/ext4/inode.c

4052

bh = create_empty_buffers(folio, blocksize, 0);

fs/ext4/inode.c

4055

offset = offset_in_folio(folio, from);

fs/ext4/inode.c

4077

if (folio_test_uptodate(folio))

fs/ext4/inode.c

4087

err = fscrypt_decrypt_pagecache_blocks(folio,

fs/ext4/inode.c

4099

folio_unlock(folio);

fs/ext4/inode.c

4100

folio_put(folio);

fs/ext4/inode.c

4109

struct folio *folio;

fs/ext4/inode.c

4115

folio = bh->b_folio;

fs/ext4/inode.c

4116

folio_zero_range(folio, offset_in_folio(folio, from), length);

fs/ext4/inode.c

4125

folio_unlock(folio);

fs/ext4/inode.c

4126

folio_put(folio);

fs/ext4/inode.c

4134

struct folio *folio;

fs/ext4/inode.c

4147

folio = bh->b_folio;

fs/ext4/inode.c

4155

folio_zero_range(folio, offset_in_folio(folio, from), length);

fs/ext4/inode.c

4165

folio_unlock(folio);

fs/ext4/inode.c

4166

folio_put(folio);

fs/ext4/inode.c

4344

struct folio *folio;

fs/ext4/inode.c

4350

folio = filemap_lock_folio(inode->i_mapping, start >> PAGE_SHIFT);

fs/ext4/inode.c

4351

if (IS_ERR(folio))

fs/ext4/inode.c

4354

if (folio_mkclean(folio))

fs/ext4/inode.c

4355

folio_mark_dirty(folio);

fs/ext4/inode.c

4356

folio_unlock(folio);

fs/ext4/inode.c

4357

folio_put(folio);

fs/ext4/inode.c

57

struct folio *folio,

fs/ext4/inode.c

5888

struct folio *folio = filemap_lock_folio(inode->i_mapping,

fs/ext4/inode.c

5890

if (IS_ERR(folio))

fs/ext4/inode.c

5892

ret = __ext4_journalled_invalidate_folio(folio, offset,

fs/ext4/inode.c

5893

folio_size(folio) - offset);

fs/ext4/inode.c

5894

folio_unlock(folio);

fs/ext4/inode.c

5895

folio_put(folio);

fs/ext4/inode.c

6738

static int ext4_block_page_mkwrite(struct inode *inode, struct folio *folio,

fs/ext4/inode.c

6753

folio_lock(folio);

fs/ext4/inode.c

6756

if (folio->mapping != inode->i_mapping || folio_pos(folio) > size) {

fs/ext4/inode.c

6761

len = folio_size(folio);

fs/ext4/inode.c

6762

if (folio_pos(folio) + len > size)

fs/ext4/inode.c

6763

len = size - folio_pos(folio);

fs/ext4/inode.c

6765

ret = ext4_block_write_begin(handle, folio, 0, len, get_block);

fs/ext4/inode.c

6770

block_commit_write(folio, 0, len);

fs/ext4/inode.c

6771

folio_mark_dirty(folio);

fs/ext4/inode.c

6773

ret = ext4_journal_folio_buffers(handle, folio, len);

fs/ext4/inode.c

6778

folio_wait_stable(folio);

fs/ext4/inode.c

6782

folio_unlock(folio);

fs/ext4/inode.c

6790

struct folio *folio = page_folio(vmf->page);

fs/ext4/inode.c

6833

folio_lock(folio);

fs/ext4/inode.c

6836

if (folio->mapping != mapping || folio_pos(folio) > size) {

fs/ext4/inode.c

6837

folio_unlock(folio);

fs/ext4/inode.c

6842

len = folio_size(folio);

fs/ext4/inode.c

6843

if (folio_pos(folio) + len > size)

fs/ext4/inode.c

6844

len = size - folio_pos(folio);

fs/ext4/inode.c

6852

if (folio_buffers(folio)) {

fs/ext4/inode.c

6853

if (!ext4_walk_page_buffers(NULL, inode, folio_buffers(folio),

fs/ext4/inode.c

6857

folio_wait_stable(folio);

fs/ext4/inode.c

6862

folio_unlock(folio);

fs/ext4/inode.c

6868

err = ext4_block_page_mkwrite(inode, folio, get_block);

fs/ext4/mballoc.c

1373

static int ext4_mb_init_cache(struct folio *folio, char *incore, gfp_t gfp)

fs/ext4/mballoc.c

1391

inode = folio->mapping->host;

fs/ext4/mballoc.c

1395

blocks_per_folio = folio_size(folio) / blocksize;

fs/ext4/mballoc.c

1399

mb_debug(sb, "init folio %lu\n", folio->index);

fs/ext4/mballoc.c

1411

first_group = EXT4_PG_TO_LBLK(inode, folio->index) / 2;

fs/ext4/mballoc.c

1425

if (folio_test_uptodate(folio) &&

fs/ext4/mballoc.c

1450

first_block = EXT4_PG_TO_LBLK(inode, folio->index);

fs/ext4/mballoc.c

1471

data = folio_address(folio) + (i * blocksize);

fs/ext4/mballoc.c

1487

group, folio->index, i * blocksize);

fs/ext4/mballoc.c

1506

group, folio->index, i * blocksize);

fs/ext4/mballoc.c

1524

folio_mark_uptodate(folio);

fs/ext4/mballoc.c

1547

struct folio *folio;

fs/ext4/mballoc.c

1559

folio = __filemap_get_folio(inode->i_mapping, pnum,

fs/ext4/mballoc.c

1561

if (IS_ERR(folio))

fs/ext4/mballoc.c

1562

return PTR_ERR(folio);

fs/ext4/mballoc.c

1563

BUG_ON(folio->mapping != inode->i_mapping);

fs/ext4/mballoc.c

1564

WARN_ON_ONCE(folio_size(folio) < sb->s_blocksize);

fs/ext4/mballoc.c

1565

e4b->bd_bitmap_folio = folio;

fs/ext4/mballoc.c

1566

e4b->bd_bitmap = folio_address(folio) +

fs/ext4/mballoc.c

1567

offset_in_folio(folio, EXT4_LBLK_TO_B(inode, block));

fs/ext4/mballoc.c

1571

if (folio_contains(folio, pnum)) {

fs/ext4/mballoc.c

1577

folio = __filemap_get_folio(inode->i_mapping, pnum,

fs/ext4/mballoc.c

1579

if (IS_ERR(folio))

fs/ext4/mballoc.c

1580

return PTR_ERR(folio);

fs/ext4/mballoc.c

1581

BUG_ON(folio->mapping != inode->i_mapping);

fs/ext4/mballoc.c

1582

WARN_ON_ONCE(folio_size(folio) < sb->s_blocksize);

fs/ext4/mballoc.c

1583

e4b->bd_buddy_folio = folio;

fs/ext4/mballoc.c

1610

struct folio *folio;

fs/ext4/mballoc.c

1637

folio = e4b.bd_bitmap_folio;

fs/ext4/mballoc.c

1638

ret = ext4_mb_init_cache(folio, NULL, gfp);

fs/ext4/mballoc.c

1641

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1656

folio = e4b.bd_buddy_folio;

fs/ext4/mballoc.c

1657

ret = ext4_mb_init_cache(folio, e4b.bd_bitmap, gfp);

fs/ext4/mballoc.c

1660

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1680

struct folio *folio;

fs/ext4/mballoc.c

1719

folio = __filemap_get_folio(inode->i_mapping, pnum, FGP_ACCESSED, 0);

fs/ext4/mballoc.c

1720

if (IS_ERR(folio) || !folio_test_uptodate(folio) || folio_test_locked(folio)) {

fs/ext4/mballoc.c

1730

if (!IS_ERR(folio))

fs/ext4/mballoc.c

1731

folio_put(folio);

fs/ext4/mballoc.c

1732

folio = __filemap_get_folio(inode->i_mapping, pnum,

fs/ext4/mballoc.c

1734

if (!IS_ERR(folio)) {

fs/ext4/mballoc.c

1735

if (WARN_RATELIMIT(folio->mapping != inode->i_mapping,

fs/ext4/mballoc.c

1738

folio_unlock(folio);

fs/ext4/mballoc.c

1742

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1743

ret = ext4_mb_init_cache(folio, NULL, gfp);

fs/ext4/mballoc.c

1745

folio_unlock(folio);

fs/ext4/mballoc.c

1748

mb_cmp_bitmaps(e4b, folio_address(folio) +

fs/ext4/mballoc.c

1749

offset_in_folio(folio,

fs/ext4/mballoc.c

1752

folio_unlock(folio);

fs/ext4/mballoc.c

1755

if (IS_ERR(folio)) {

fs/ext4/mballoc.c

1756

ret = PTR_ERR(folio);

fs/ext4/mballoc.c

1759

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1765

e4b->bd_bitmap_folio = folio;

fs/ext4/mballoc.c

1766

e4b->bd_bitmap = folio_address(folio) +

fs/ext4/mballoc.c

1767

offset_in_folio(folio, EXT4_LBLK_TO_B(inode, block));

fs/ext4/mballoc.c

1772

if (folio_contains(folio, pnum)) {

fs/ext4/mballoc.c

1773

folio_get(folio);

fs/ext4/mballoc.c

1778

folio = __filemap_get_folio(inode->i_mapping, pnum, FGP_ACCESSED, 0);

fs/ext4/mballoc.c

1779

if (IS_ERR(folio) || !folio_test_uptodate(folio) || folio_test_locked(folio)) {

fs/ext4/mballoc.c

1780

if (!IS_ERR(folio))

fs/ext4/mballoc.c

1781

folio_put(folio);

fs/ext4/mballoc.c

1782

folio = __filemap_get_folio(inode->i_mapping, pnum,

fs/ext4/mballoc.c

1784

if (!IS_ERR(folio)) {

fs/ext4/mballoc.c

1785

if (WARN_RATELIMIT(folio->mapping != inode->i_mapping,

fs/ext4/mballoc.c

1788

folio_unlock(folio);

fs/ext4/mballoc.c

1792

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1793

ret = ext4_mb_init_cache(folio, e4b->bd_bitmap,

fs/ext4/mballoc.c

1796

folio_unlock(folio);

fs/ext4/mballoc.c

1800

folio_unlock(folio);

fs/ext4/mballoc.c

1803

if (IS_ERR(folio)) {

fs/ext4/mballoc.c

1804

ret = PTR_ERR(folio);

fs/ext4/mballoc.c

1807

if (!folio_test_uptodate(folio)) {

fs/ext4/mballoc.c

1814

e4b->bd_buddy_folio = folio;

fs/ext4/mballoc.c

1815

e4b->bd_buddy = folio_address(folio) +

fs/ext4/mballoc.c

1816

offset_in_folio(folio, EXT4_LBLK_TO_B(inode, block));

fs/ext4/mballoc.c

1821

if (!IS_ERR_OR_NULL(folio))

fs/ext4/mballoc.c

1822

folio_put(folio);

fs/ext4/mballoc.h

214

struct folio *ac_bitmap_folio;

fs/ext4/mballoc.h

215

struct folio *ac_buddy_folio;

fs/ext4/mballoc.h

225

struct folio *bd_buddy_folio;

fs/ext4/mballoc.h

227

struct folio *bd_bitmap_folio;

fs/ext4/move_extent.c

100

folio_wait_writeback(folio[0]);

fs/ext4/move_extent.c

101

folio_wait_writeback(folio[1]);

fs/ext4/move_extent.c

103

swap(folio[0], folio[1]);

fs/ext4/move_extent.c

108

static void mext_folio_double_unlock(struct folio *folio[2])

fs/ext4/move_extent.c

110

folio_unlock(folio[0]);

fs/ext4/move_extent.c

111

folio_put(folio[0]);

fs/ext4/move_extent.c

112

folio_unlock(folio[1]);

fs/ext4/move_extent.c

113

folio_put(folio[1]);

fs/ext4/move_extent.c

117

static int mext_folio_mkuptodate(struct folio *folio, size_t from, size_t to)

fs/ext4/move_extent.c

119

struct inode *inode = folio->mapping->host;

fs/ext4/move_extent.c

126

BUG_ON(!folio_test_locked(folio));

fs/ext4/move_extent.c

127

BUG_ON(folio_test_writeback(folio));

fs/ext4/move_extent.c

129

if (folio_test_uptodate(folio))

fs/ext4/move_extent.c

133

head = folio_buffers(folio);

fs/ext4/move_extent.c

135

head = create_empty_buffers(folio, blocksize, 0);

fs/ext4/move_extent.c

137

block = folio_pos(folio) >> inode->i_blkbits;

fs/ext4/move_extent.c

155

folio_zero_range(folio, block_start, blocksize);

fs/ext4/move_extent.c

186

folio_mark_uptodate(folio);

fs/ext4/move_extent.c

197

static int mext_move_begin(struct mext_data *mext, struct folio *folio[2],

fs/ext4/move_extent.c

212

((size_t)mext->orig_map.m_len) << blkbits, folio);

fs/ext4/move_extent.c

227

move_len = umin(folio_next_pos(folio[0]) - orig_pos,

fs/ext4/move_extent.c

228

folio_next_pos(folio[1]) - donor_pos);

fs/ext4/move_extent.c

255

mext_folio_double_unlock(folio);

fs/ext4/move_extent.c

263

static int mext_folio_mkwrite(struct inode *inode, struct folio *folio,

fs/ext4/move_extent.c

272

head = folio_buffers(folio);

fs/ext4/move_extent.c

274

head = create_empty_buffers(folio, blocksize, 0);

fs/ext4/move_extent.c

276

block = folio_pos(folio) >> inode->i_blkbits;

fs/ext4/move_extent.c

290

block_commit_write(folio, from, to);

fs/ext4/move_extent.c

307

struct folio *folio[2] = {NULL, NULL};

fs/ext4/move_extent.c

327

ret = mext_move_begin(mext, folio, &move_type);

fs/ext4/move_extent.c

341

from = offset_in_folio(folio[0],

fs/ext4/move_extent.c

345

ret = mext_folio_mkuptodate(folio[0], from, from + length);

fs/ext4/move_extent.c

350

if (!filemap_release_folio(folio[0], 0) ||

fs/ext4/move_extent.c

351

!filemap_release_folio(folio[1], 0)) {

fs/ext4/move_extent.c

372

ret2 = mext_folio_mkwrite(orig_inode, folio[0], from, from + length);

fs/ext4/move_extent.c

387

mext_folio_double_unlock(folio);

fs/ext4/move_extent.c

62

struct folio *folio[2])

fs/ext4/move_extent.c

80

folio[0] = __filemap_get_folio(mapping[0], index1, fgp_flags,

fs/ext4/move_extent.c

82

if (IS_ERR(folio[0])) {

fs/ext4/move_extent.c

84

return PTR_ERR(folio[0]);

fs/ext4/move_extent.c

87

folio[1] = __filemap_get_folio(mapping[1], index2, fgp_flags,

fs/ext4/move_extent.c

90

if (IS_ERR(folio[1])) {

fs/ext4/move_extent.c

91

folio_unlock(folio[0]);

fs/ext4/move_extent.c

92

folio_put(folio[0]);

fs/ext4/move_extent.c

93

return PTR_ERR(folio[1]);

fs/ext4/page-io.c

105

struct folio *folio = fi.folio;

fs/ext4/page-io.c

106

struct folio *io_folio = NULL;

fs/ext4/page-io.c

113

if (fscrypt_is_bounce_folio(folio)) {

fs/ext4/page-io.c

114

io_folio = folio;

fs/ext4/page-io.c

115

folio = fscrypt_pagecache_folio(folio);

fs/ext4/page-io.c

120

mapping_set_error(folio->mapping, err);

fs/ext4/page-io.c

122

bh = head = folio_buffers(folio);

fs/ext4/page-io.c

144

folio_end_writeback(folio);

fs/ext4/page-io.c

419

struct folio *folio,

fs/ext4/page-io.c

429

fscrypt_set_bio_crypt_ctx(bio, inode, folio_pos(folio) + bh_offset(bh),

fs/ext4/page-io.c

442

struct folio *folio,

fs/ext4/page-io.c

448

folio_pos(folio) + bh_offset(bh)))

fs/ext4/page-io.c

455

struct folio *folio,

fs/ext4/page-io.c

456

struct folio *io_folio,

fs/ext4/page-io.c

459

if (io->io_bio && io_submit_need_new_bio(io, inode, folio, bh)) {

fs/ext4/page-io.c

464

io_submit_init_bio(io, inode, folio, bh);

fs/ext4/page-io.c

467

wbc_account_cgroup_owner(io->io_wbc, folio, bh->b_size);

fs/ext4/page-io.c

471

int ext4_bio_write_folio(struct ext4_io_submit *io, struct folio *folio,

fs/ext4/page-io.c

474

struct folio *io_folio = folio;

fs/ext4/page-io.c

475

struct inode *inode = folio->mapping->host;

fs/ext4/page-io.c

483

BUG_ON(!folio_test_locked(folio));

fs/ext4/page-io.c

484

BUG_ON(folio_test_writeback(folio));

fs/ext4/page-io.c

495

if (len < folio_size(folio))

fs/ext4/page-io.c

496

folio_zero_segment(folio, len, folio_size(folio));

fs/ext4/page-io.c

504

bh = head = folio_buffers(folio);

fs/ext4/page-io.c

527

if (!folio_test_dirty(folio))

fs/ext4/page-io.c

528

folio_redirty_for_writepage(wbc, folio);

fs/ext4/page-io.c

545

__folio_start_writeback(folio, keep_towrite);

fs/ext4/page-io.c

546

folio_end_writeback(folio);

fs/ext4/page-io.c

550

bh = head = folio_buffers(folio);

fs/ext4/page-io.c

572

bounce_page = fscrypt_encrypt_pagecache_blocks(folio,

fs/ext4/page-io.c

589

folio_redirty_for_writepage(wbc, folio);

fs/ext4/page-io.c

603

__folio_start_writeback(folio, keep_towrite);

fs/ext4/page-io.c

609

io_submit_add_bh(io, inode, folio, io_folio, bh);

fs/ext4/readpage.c

211

struct readahead_control *rac, struct folio *folio)

fs/ext4/readpage.c

234

nr_pages = rac ? readahead_count(rac) : folio_nr_pages(folio);

fs/ext4/readpage.c

241

folio = readahead_folio(rac);

fs/ext4/readpage.c

243

folio_pages = folio_nr_pages(folio);

fs/ext4/readpage.c

244

prefetchw(&folio->flags);

fs/ext4/readpage.c

246

if (folio_buffers(folio))

fs/ext4/readpage.c

249

blocks_per_folio = folio_size(folio) >> blkbits;

fs/ext4/readpage.c

251

pos = folio_pos(folio);

fs/ext4/readpage.c

253

last_block = EXT4_PG_TO_LBLK(inode, folio->index + nr_pages);

fs/ext4/readpage.c

294

folio_zero_segment(folio, 0,

fs/ext4/readpage.c

295

folio_size(folio));

fs/ext4/readpage.c

296

folio_unlock(folio);

fs/ext4/readpage.c

328

folio_zero_segment(folio, first_hole << blkbits,

fs/ext4/readpage.c

329

folio_size(folio));

fs/ext4/readpage.c

331

if (vi && !fsverity_verify_folio(vi, folio))

fs/ext4/readpage.c

333

folio_end_read(folio, true);

fs/ext4/readpage.c

337

folio_set_mappedtodisk(folio);

fs/ext4/readpage.c

366

if (!bio_add_folio(bio, folio, length, 0))

fs/ext4/readpage.c

382

if (!folio_test_uptodate(folio))

fs/ext4/readpage.c

383

block_read_full_folio(folio, ext4_get_block);

fs/ext4/readpage.c

385

folio_unlock(folio);

fs/ext4/readpage.c

394

int ext4_read_folio(struct file *file, struct folio *folio)

fs/ext4/readpage.c

396

struct inode *inode = folio->mapping->host;

fs/ext4/readpage.c

400

trace_ext4_read_folio(inode, folio);

fs/ext4/readpage.c

403

ret = ext4_readpage_inline(inode, folio);

fs/ext4/readpage.c

408

if (folio->index < DIV_ROUND_UP(inode->i_size, PAGE_SIZE))

fs/ext4/readpage.c

411

fsverity_readahead(vi, folio->index, folio_nr_pages(folio));

fs/ext4/readpage.c

412

return ext4_mpage_readpages(inode, vi, NULL, folio);

fs/ext4/readpage.c

76

folio_end_read(fi.folio, bio->bi_status == 0);

fs/ext4/super.c

520

struct folio *folio)

fs/ext4/super.c

526

bh = head = folio_buffers(folio);

fs/ext4/super.c

559

struct folio *folio = NULL;

fs/ext4/super.c

575

while ((folio = writeback_iter(mapping, &wbc, folio, &error))) {

fs/ext4/super.c

576

if (ext4_journalled_writepage_needs_redirty(jinode, folio))

fs/ext4/super.c

577

folio_redirty_for_writepage(&wbc, folio);

fs/ext4/super.c

578

folio_unlock(folio);

fs/ext4/verity.c

45

struct folio *folio;

fs/ext4/verity.c

48

folio = read_mapping_folio(inode->i_mapping, pos >> PAGE_SHIFT,

fs/ext4/verity.c

50

if (IS_ERR(folio))

fs/ext4/verity.c

51

return PTR_ERR(folio);

fs/ext4/verity.c

53

n = memcpy_from_file_folio(buf, folio, pos, count);

fs/ext4/verity.c

54

folio_put(folio);

fs/ext4/verity.c

79

struct folio *folio;

fs/ext4/verity.c

83

res = aops->write_begin(NULL, mapping, pos, n, &folio, &fsdata);

fs/ext4/verity.c

87

memcpy_to_folio(folio, offset_in_folio(folio, pos), buf, n);

fs/ext4/verity.c

89

res = aops->write_end(NULL, mapping, pos, n, n, folio, fsdata);

fs/f2fs/acl.c

184

struct folio *dfolio)

fs/f2fs/acl.c

245

struct posix_acl *acl, struct folio *ifolio)

fs/f2fs/acl.c

377

struct folio *dfolio)

fs/f2fs/acl.c

426

int f2fs_init_acl(struct inode *inode, struct inode *dir, struct folio *ifolio,

fs/f2fs/acl.c

427

struct folio *dfolio)

fs/f2fs/acl.h

39

int f2fs_init_acl(struct inode *, struct inode *, struct folio *ifolio,

fs/f2fs/acl.h

40

struct folio *dfolio);

fs/f2fs/acl.h

46

struct folio *ifolio, struct folio *dfolio)

fs/f2fs/checkpoint.c

1007

if (!folio) {

fs/f2fs/checkpoint.c

1008

folio = f2fs_grab_meta_folio(sbi, start_blk++);

fs/f2fs/checkpoint.c

1009

orphan_blk = folio_address(folio);

fs/f2fs/checkpoint.c

1024

folio_mark_dirty(folio);

fs/f2fs/checkpoint.c

1025

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

1028

folio = NULL;

fs/f2fs/checkpoint.c

1032

if (folio) {

fs/f2fs/checkpoint.c

1036

folio_mark_dirty(folio);

fs/f2fs/checkpoint.c

1037

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

1056

struct f2fs_checkpoint **cp_block, struct folio **cp_folio,

fs/f2fs/checkpoint.c

1087

static struct folio *validate_checkpoint(struct f2fs_sb_info *sbi,

fs/f2fs/checkpoint.c

1090

struct folio *cp_folio_1 = NULL, *cp_folio_2 = NULL;

fs/f2fs/checkpoint.c

1132

struct folio *cp1, *cp2, *cur_folio;

fs/f2fs/checkpoint.c

1243

void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio)

fs/f2fs/checkpoint.c

1258

folio_set_f2fs_reference(folio);

fs/f2fs/checkpoint.c

1611

struct folio *folio = f2fs_grab_meta_folio(sbi, blk_addr);

fs/f2fs/checkpoint.c

1613

memcpy(folio_address(folio), src, PAGE_SIZE);

fs/f2fs/checkpoint.c

1615

folio_mark_dirty(folio);

fs/f2fs/checkpoint.c

1616

if (unlikely(!folio_clear_dirty_for_io(folio)))

fs/f2fs/checkpoint.c

1620

if (unlikely(!__f2fs_write_meta_folio(folio, &wbc, FS_CP_META_IO))) {

fs/f2fs/checkpoint.c

1622

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

1628

f2fs_folio_put(folio, false);

fs/f2fs/checkpoint.c

238

struct folio *f2fs_grab_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index)

fs/f2fs/checkpoint.c

241

struct folio *folio;

fs/f2fs/checkpoint.c

243

folio = f2fs_grab_cache_folio(mapping, index, false);

fs/f2fs/checkpoint.c

244

if (IS_ERR(folio)) {

fs/f2fs/checkpoint.c

248

f2fs_folio_wait_writeback(folio, META, true, true);

fs/f2fs/checkpoint.c

249

if (!folio_test_uptodate(folio))

fs/f2fs/checkpoint.c

250

folio_mark_uptodate(folio);

fs/f2fs/checkpoint.c

251

return folio;

fs/f2fs/checkpoint.c

254

static struct folio *__get_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index,

fs/f2fs/checkpoint.c

258

struct folio *folio;

fs/f2fs/checkpoint.c

274

folio = f2fs_grab_cache_folio(mapping, index, false);

fs/f2fs/checkpoint.c

275

if (IS_ERR(folio)) {

fs/f2fs/checkpoint.c

279

if (folio_test_uptodate(folio))

fs/f2fs/checkpoint.c

282

fio.folio = folio;

fs/f2fs/checkpoint.c

286

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

292

folio_lock(folio);

fs/f2fs/checkpoint.c

293

if (unlikely(!is_meta_folio(folio))) {

fs/f2fs/checkpoint.c

294

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

298

if (unlikely(!folio_test_uptodate(folio))) {

fs/f2fs/checkpoint.c

299

f2fs_handle_page_eio(sbi, folio, META);

fs/f2fs/checkpoint.c

300

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

304

return folio;

fs/f2fs/checkpoint.c

307

struct folio *f2fs_get_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index)

fs/f2fs/checkpoint.c

312

struct folio *f2fs_get_meta_folio_retry(struct f2fs_sb_info *sbi, pgoff_t index)

fs/f2fs/checkpoint.c

314

struct folio *folio;

fs/f2fs/checkpoint.c

318

folio = __get_meta_folio(sbi, index, true);

fs/f2fs/checkpoint.c

319

if (IS_ERR(folio)) {

fs/f2fs/checkpoint.c

320

if (PTR_ERR(folio) == -EIO &&

fs/f2fs/checkpoint.c

325

return folio;

fs/f2fs/checkpoint.c

329

struct folio *f2fs_get_tmp_folio(struct f2fs_sb_info *sbi, pgoff_t index)

fs/f2fs/checkpoint.c

470

struct folio *folio;

fs/f2fs/checkpoint.c

500

folio = f2fs_grab_cache_folio(META_MAPPING(sbi),

fs/f2fs/checkpoint.c

502

if (IS_ERR(folio))

fs/f2fs/checkpoint.c

504

if (folio_test_uptodate(folio)) {

fs/f2fs/checkpoint.c

505

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

509

fio.folio = folio;

fs/f2fs/checkpoint.c

511

f2fs_folio_put(folio, err ? true : false);

fs/f2fs/checkpoint.c

525

struct folio *folio;

fs/f2fs/checkpoint.c

531

folio = filemap_get_folio(META_MAPPING(sbi), index);

fs/f2fs/checkpoint.c

532

if (IS_ERR(folio) || !folio_test_uptodate(folio))

fs/f2fs/checkpoint.c

534

f2fs_folio_put(folio, false);

fs/f2fs/checkpoint.c

540

static bool __f2fs_write_meta_folio(struct folio *folio,

fs/f2fs/checkpoint.c

544

struct f2fs_sb_info *sbi = F2FS_F_SB(folio);

fs/f2fs/checkpoint.c

546

trace_f2fs_writepage(folio, META);

fs/f2fs/checkpoint.c

550

folio_clear_uptodate(folio);

fs/f2fs/checkpoint.c

552

folio_unlock(folio);

fs/f2fs/checkpoint.c

560

f2fs_do_write_meta_page(sbi, folio, io_type);

fs/f2fs/checkpoint.c

563

folio_unlock(folio);

fs/f2fs/checkpoint.c

571

folio_redirty_for_writepage(wbc, folio);

fs/f2fs/checkpoint.c

629

struct folio *folio = fbatch.folios[i];

fs/f2fs/checkpoint.c

632

folio->index != prev +

fs/f2fs/checkpoint.c

638

folio_lock(folio);

fs/f2fs/checkpoint.c

640

if (unlikely(!is_meta_folio(folio))) {

fs/f2fs/checkpoint.c

642

folio_unlock(folio);

fs/f2fs/checkpoint.c

645

if (!folio_test_dirty(folio)) {

fs/f2fs/checkpoint.c

650

f2fs_folio_wait_writeback(folio, META, true, true);

fs/f2fs/checkpoint.c

652

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/checkpoint.c

655

if (!__f2fs_write_meta_folio(folio, &wbc,

fs/f2fs/checkpoint.c

657

folio_unlock(folio);

fs/f2fs/checkpoint.c

660

nwritten += folio_nr_pages(folio);

fs/f2fs/checkpoint.c

661

prev = folio->index;

fs/f2fs/checkpoint.c

678

struct folio *folio)

fs/f2fs/checkpoint.c

680

trace_f2fs_set_page_dirty(folio, META);

fs/f2fs/checkpoint.c

682

if (!folio_test_uptodate(folio))

fs/f2fs/checkpoint.c

683

folio_mark_uptodate(folio);

fs/f2fs/checkpoint.c

684

if (filemap_dirty_folio(mapping, folio)) {

fs/f2fs/checkpoint.c

686

folio_set_f2fs_reference(folio);

fs/f2fs/checkpoint.c

944

struct folio *folio;

fs/f2fs/checkpoint.c

948

folio = f2fs_get_meta_folio(sbi, start_blk + i);

fs/f2fs/checkpoint.c

949

if (IS_ERR(folio)) {

fs/f2fs/checkpoint.c

950

err = PTR_ERR(folio);

fs/f2fs/checkpoint.c

954

orphan_blk = folio_address(folio);

fs/f2fs/checkpoint.c

962

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

971

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

975

f2fs_folio_put(folio, true);

fs/f2fs/checkpoint.c

992

struct folio *folio = NULL;

fs/f2fs/compress.c

1093

struct folio *folio;

fs/f2fs/compress.c

1110

folio = f2fs_filemap_get_folio(mapping, start_idx + i,

fs/f2fs/compress.c

1112

if (IS_ERR(folio)) {

fs/f2fs/compress.c

1113

ret = PTR_ERR(folio);

fs/f2fs/compress.c

1117

if (folio_test_uptodate(folio))

fs/f2fs/compress.c

1118

f2fs_folio_put(folio, true);

fs/f2fs/compress.c

1120

f2fs_compress_ctx_add_page(cc, folio);

fs/f2fs/compress.c

1143

folio = filemap_lock_folio(mapping, start_idx + i);

fs/f2fs/compress.c

1144

if (IS_ERR(folio)) {

fs/f2fs/compress.c

1149

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/compress.c

1150

f2fs_compress_ctx_add_page(cc, folio);

fs/f2fs/compress.c

1152

if (!folio_test_uptodate(folio)) {

fs/f2fs/compress.c

1153

f2fs_handle_page_eio(sbi, folio, DATA);

fs/f2fs/compress.c

1202

struct folio *folio = page_folio(cc.rpages[0]);

fs/f2fs/compress.c

1203

bool first_index = (index == folio->index);

fs/f2fs/compress.c

1246

struct folio *folio = page_folio(rpages[i]);

fs/f2fs/compress.c

1247

loff_t start = (loff_t)folio->index << PAGE_SHIFT;

fs/f2fs/compress.c

1250

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/compress.c

1292

struct folio *folio;

fs/f2fs/compress.c

1332

folio = page_folio(cc->rpages[last_index]);

fs/f2fs/compress.c

1333

psize = folio_next_pos(folio);

fs/f2fs/compress.c

137

struct folio *f2fs_compress_control_folio(struct folio *folio)

fs/f2fs/compress.c

139

struct compress_io_ctx *ctx = folio->private;

fs/f2fs/compress.c

1428

folio_unlock(fio.folio);

fs/f2fs/compress.c

1485

void f2fs_compress_write_end_io(struct bio *bio, struct folio *folio)

fs/f2fs/compress.c

1487

struct page *page = &folio->page;

fs/f2fs/compress.c

1489

struct compress_io_ctx *cic = folio->private;

fs/f2fs/compress.c

1490

enum count_type type = WB_DATA_TYPE(folio, true);

fs/f2fs/compress.c

1550

struct folio *folio;

fs/f2fs/compress.c

1554

folio = page_folio(cc->rpages[i]);

fs/f2fs/compress.c

1556

folio_lock(folio);

fs/f2fs/compress.c

1558

if (folio->mapping != mapping) {

fs/f2fs/compress.c

1560

folio_unlock(folio);

fs/f2fs/compress.c

1564

if (!folio_test_dirty(folio))

fs/f2fs/compress.c

1567

if (folio_test_writeback(folio)) {

fs/f2fs/compress.c

1570

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/compress.c

1573

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/compress.c

1577

ret = f2fs_write_single_data_page(folio, &submitted,

fs/f2fs/compress.c

164

void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct folio *folio)

fs/f2fs/compress.c

168

if (!f2fs_cluster_can_merge_page(cc, folio->index))

fs/f2fs/compress.c

171

cluster_ofs = offset_in_cluster(cc, folio->index);

fs/f2fs/compress.c

172

cc->rpages[cluster_ofs] = folio_page(folio, 0);

fs/f2fs/compress.c

174

cc->cluster_idx = cluster_idx(cc, folio->index);

fs/f2fs/compress.c

1828

struct folio *rfolio;

fs/f2fs/compress.c

1888

void f2fs_put_folio_dic(struct folio *folio, bool in_task)

fs/f2fs/compress.c

1890

struct decompress_io_ctx *dic = folio->private;

fs/f2fs/compress.c

1941

struct folio *folio, nid_t ino, block_t blkaddr)

fs/f2fs/compress.c

1943

struct folio *cfolio;

fs/f2fs/compress.c

1974

memcpy(folio_address(cfolio), folio_address(folio), PAGE_SIZE);

fs/f2fs/compress.c

1979

bool f2fs_load_compressed_folio(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/compress.c

1982

struct folio *cfolio;

fs/f2fs/compress.c

1993

memcpy(folio_address(folio),

fs/f2fs/compress.c

1994

folio_address(cfolio), folio_size(folio));

fs/f2fs/compress.c

2023

struct folio *folio = fbatch.folios[i];

fs/f2fs/compress.c

2025

folio_lock(folio);

fs/f2fs/compress.c

2026

if (folio->mapping != mapping) {

fs/f2fs/compress.c

2027

folio_unlock(folio);

fs/f2fs/compress.c

2031

if (ino != folio_get_f2fs_data(folio)) {

fs/f2fs/compress.c

2032

folio_unlock(folio);

fs/f2fs/compress.c

2036

generic_error_remove_folio(mapping, folio);

fs/f2fs/compress.c

2037

folio_unlock(folio);

fs/f2fs/compress.c

593

struct folio *folio;

fs/f2fs/compress.c

597

folio = page_folio(page);

fs/f2fs/compress.c

598

folio_detach_private(folio);

fs/f2fs/compress.c

599

folio->mapping = NULL;

fs/f2fs/compress.c

600

folio_unlock(folio);

fs/f2fs/compress.c

75

bool f2fs_is_compressed_page(struct folio *folio)

fs/f2fs/compress.c

77

if (!folio->private)

fs/f2fs/compress.c

79

if (folio_test_f2fs_nonpointer(folio))

fs/f2fs/compress.c

796

struct folio *folio, nid_t ino, block_t blkaddr);

fs/f2fs/compress.c

804

void f2fs_end_read_compressed_page(struct folio *folio, bool failed,

fs/f2fs/compress.c

807

struct decompress_io_ctx *dic = folio->private;

fs/f2fs/compress.c

815

f2fs_cache_compressed_page(sbi, folio,

fs/f2fs/compress.c

82

f2fs_bug_on(F2FS_F_SB(folio),

fs/f2fs/compress.c

83

*((u32 *)folio->private) != F2FS_COMPRESSED_PAGE_MAGIC);

fs/f2fs/compress.c

863

struct folio *folio = page_folio(pages[index + i]);

fs/f2fs/compress.c

865

if (folio->index != pgidx + i)

fs/f2fs/compress.c

867

if (uptodate && !folio_test_uptodate(folio))

fs/f2fs/compress.c

90

struct folio *folio = page_folio(page);

fs/f2fs/compress.c

92

folio_attach_private(folio, (void *)data);

fs/f2fs/compress.c

95

folio->index = index;

fs/f2fs/compress.c

96

folio->mapping = inode->i_mapping;

fs/f2fs/data.c

1007

f2fs_set_bio_crypt_ctx(bio, folio->mapping->host,

fs/f2fs/data.c

1008

folio->index, fio, GFP_NOIO);

fs/f2fs/data.c

1017

wbc_account_cgroup_owner(fio->io_wbc, folio, folio_size(folio));

fs/f2fs/data.c

1019

inc_page_count(fio->sbi, WB_DATA_TYPE(folio, false));

fs/f2fs/data.c

1054

struct folio *bio_folio;

fs/f2fs/data.c

1090

bio_folio = fio->folio;

fs/f2fs/data.c

1118

wbc_account_cgroup_owner(fio->io_wbc, fio->folio,

fs/f2fs/data.c

1119

folio_size(fio->folio));

fs/f2fs/data.c

1123

trace_f2fs_submit_folio_write(fio->folio, fio);

fs/f2fs/data.c

1195

struct folio *folio, block_t blkaddr,

fs/f2fs/data.c

1201

bio = f2fs_grab_read_bio(inode, vi, blkaddr, 1, op_flags, folio->index,

fs/f2fs/data.c

1207

if (!bio_add_folio(bio, folio, PAGE_SIZE, 0))

fs/f2fs/data.c

1312

struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/data.c

1317

struct folio *folio;

fs/f2fs/data.c

1320

folio = f2fs_grab_cache_folio(mapping, index, for_write);

fs/f2fs/data.c

1321

if (IS_ERR(folio))

fs/f2fs/data.c

1322

return folio;

fs/f2fs/data.c

1324

if (folio_test_large(folio)) {

fs/f2fs/data.c

1327

f2fs_folio_put(folio, true);

fs/f2fs/data.c

1329

folio_index + folio_nr_pages(folio) - 1);

fs/f2fs/data.c

1367

if (folio_test_uptodate(folio)) {

fs/f2fs/data.c

1368

folio_unlock(folio);

fs/f2fs/data.c

1369

return folio;

fs/f2fs/data.c

1380

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

1381

if (!folio_test_uptodate(folio))

fs/f2fs/data.c

1382

folio_mark_uptodate(folio);

fs/f2fs/data.c

1383

folio_unlock(folio);

fs/f2fs/data.c

1384

return folio;

fs/f2fs/data.c

1387

f2fs_submit_page_read(inode, f2fs_need_verity(inode, folio->index),

fs/f2fs/data.c

1388

folio, dn.data_blkaddr, op_flags, for_write);

fs/f2fs/data.c

1389

return folio;

fs/f2fs/data.c

1392

f2fs_folio_put(folio, true);

fs/f2fs/data.c

1396

struct folio *f2fs_find_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/data.c

1400

struct folio *folio;

fs/f2fs/data.c

1402

folio = f2fs_filemap_get_folio(mapping, index, FGP_ACCESSED, 0);

fs/f2fs/data.c

1403

if (IS_ERR(folio))

fs/f2fs/data.c

1405

if (folio_test_uptodate(folio))

fs/f2fs/data.c

1406

return folio;

fs/f2fs/data.c

1407

f2fs_folio_put(folio, false);

fs/f2fs/data.c

1410

folio = f2fs_get_read_data_folio(inode, index, 0, false, next_pgofs);

fs/f2fs/data.c

1411

if (IS_ERR(folio))

fs/f2fs/data.c

1412

return folio;

fs/f2fs/data.c

1414

if (folio_test_uptodate(folio))

fs/f2fs/data.c

1415

return folio;

fs/f2fs/data.c

1417

folio_wait_locked(folio);

fs/f2fs/data.c

1418

if (unlikely(!folio_test_uptodate(folio))) {

fs/f2fs/data.c

1419

f2fs_folio_put(folio, false);

fs/f2fs/data.c

1422

return folio;

fs/f2fs/data.c

1430

struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/data.c

1434

struct folio *folio;

fs/f2fs/data.c

1436

folio = f2fs_get_read_data_folio(inode, index, 0, for_write, NULL);

fs/f2fs/data.c

1437

if (IS_ERR(folio))

fs/f2fs/data.c

1438

return folio;

fs/f2fs/data.c

1441

folio_lock(folio);

fs/f2fs/data.c

1442

if (unlikely(folio->mapping != mapping || !folio_test_uptodate(folio))) {

fs/f2fs/data.c

1443

f2fs_folio_put(folio, true);

fs/f2fs/data.c

1446

return folio;

fs/f2fs/data.c

1458

struct folio *f2fs_get_new_data_folio(struct inode *inode,

fs/f2fs/data.c

1459

struct folio *ifolio, pgoff_t index, bool new_i_size)

fs/f2fs/data.c

1462

struct folio *folio;

fs/f2fs/data.c

1466

folio = f2fs_grab_cache_folio(mapping, index, true);

fs/f2fs/data.c

1467

if (IS_ERR(folio)) {

fs/f2fs/data.c

1479

f2fs_folio_put(folio, true);

fs/f2fs/data.c

1485

if (folio_test_uptodate(folio))

fs/f2fs/data.c

1489

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

1490

if (!folio_test_uptodate(folio))

fs/f2fs/data.c

1491

folio_mark_uptodate(folio);

fs/f2fs/data.c

1493

f2fs_folio_put(folio, true);

fs/f2fs/data.c

1497

folio = f2fs_get_lock_data_folio(inode, index, true);

fs/f2fs/data.c

1498

if (IS_ERR(folio))

fs/f2fs/data.c

1499

return folio;

fs/f2fs/data.c

1505

return folio;

fs/f2fs/data.c

157

struct folio *folio = fi.folio;

fs/f2fs/data.c

161

if (!folio_test_large(folio) &&

fs/f2fs/data.c

162

f2fs_is_compressed_page(folio)) {

fs/f2fs/data.c

164

f2fs_end_read_compressed_page(folio, true, 0,

fs/f2fs/data.c

166

f2fs_put_folio_dic(folio, in_task);

fs/f2fs/data.c

170

if (folio_test_large(folio)) {

fs/f2fs/data.c

171

struct f2fs_folio_state *ffs = folio->private;

fs/f2fs/data.c

180

dec_page_count(F2FS_F_SB(folio), __read_io_type(folio));

fs/f2fs/data.c

183

F2FS_F_SB(folio)->node_inode && is_node_folio(folio) &&

fs/f2fs/data.c

184

f2fs_sanity_check_node_footer(F2FS_F_SB(folio),

fs/f2fs/data.c

185

folio, folio->index, NODE_TYPE_REGULAR, true))

fs/f2fs/data.c

189

folio_end_read(folio, bio->bi_status == BLK_STS_OK);

fs/f2fs/data.c

1993

struct folio *folio = f2fs_grab_cache_folio(NODE_MAPPING(sbi),

fs/f2fs/data.c

1996

if (IS_ERR(folio))

fs/f2fs/data.c

1997

return PTR_ERR(folio);

fs/f2fs/data.c

2001

f2fs_folio_put(folio, true);

fs/f2fs/data.c

2013

f2fs_folio_put(folio, true);

fs/f2fs/data.c

2027

struct folio *folio = f2fs_grab_cache_folio(NODE_MAPPING(sbi),

fs/f2fs/data.c

2030

if (IS_ERR(folio))

fs/f2fs/data.c

2031

return PTR_ERR(folio);

fs/f2fs/data.c

2035

f2fs_folio_put(folio, true);

fs/f2fs/data.c

2042

f2fs_folio_put(folio, true);

fs/f2fs/data.c

2226

struct folio *folio, unsigned int nr_pages,

fs/f2fs/data.c

223

struct folio *folio = fi.folio;

fs/f2fs/data.c

2238

pgoff_t index = folio->index;

fs/f2fs/data.c

225

if (!f2fs_is_compressed_page(folio) &&

fs/f2fs/data.c

226

!fsverity_verify_folio(vi, folio)) {

fs/f2fs/data.c

2275

folio_set_mappedtodisk(folio);

fs/f2fs/data.c

2284

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2285

if (vi && !fsverity_verify_folio(vi, folio)) {

fs/f2fs/data.c

2289

if (!folio_test_uptodate(folio))

fs/f2fs/data.c

2290

folio_mark_uptodate(folio);

fs/f2fs/data.c

2291

folio_unlock(folio);

fs/f2fs/data.c

2316

if (!bio_add_folio(bio, folio, blocksize, 0))

fs/f2fs/data.c

2360

struct folio *folio;

fs/f2fs/data.c

2365

folio = page_folio(page);

fs/f2fs/data.c

2366

if ((sector_t)folio->index >= last_block_in_file) {

fs/f2fs/data.c

2367

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2368

if (!folio_test_uptodate(folio))

fs/f2fs/data.c

2369

folio_mark_uptodate(folio);

fs/f2fs/data.c

2370

} else if (!folio_test_uptodate(folio)) {

fs/f2fs/data.c

2373

folio_unlock(folio);

fs/f2fs/data.c

2375

folio_put(folio);

fs/f2fs/data.c

2431

struct folio *folio = page_folio(dic->cpages[i]);

fs/f2fs/data.c

2441

if (f2fs_load_compressed_folio(sbi, folio, blkaddr)) {

fs/f2fs/data.c

2451

!f2fs_crypt_mergeable_bio(bio, inode, folio->index, NULL))) {

fs/f2fs/data.c

2461

folio->index, for_write);

fs/f2fs/data.c

2463

if (!bio_add_folio(bio, folio, blocksize, 0))

fs/f2fs/data.c

2496

static struct f2fs_folio_state *ffs_find_or_alloc(struct folio *folio)

fs/f2fs/data.c

2498

struct f2fs_folio_state *ffs = folio->private;

fs/f2fs/data.c

2507

folio_attach_private(folio, ffs);

fs/f2fs/data.c

2511

static void ffs_detach_free(struct folio *folio)

fs/f2fs/data.c

2515

if (!folio_test_large(folio)) {

fs/f2fs/data.c

2516

folio_detach_private(folio);

fs/f2fs/data.c

2520

ffs = folio_detach_private(folio);

fs/f2fs/data.c

2530

struct readahead_control *rac, struct folio *folio)

fs/f2fs/data.c

2537

folio_nr_pages(folio);

fs/f2fs/data.c

2544

if (folio)

fs/f2fs/data.c

2545

folio_unlock(folio);

fs/f2fs/data.c

2552

folio = readahead_folio(rac);

fs/f2fs/data.c

2554

if (!folio)

fs/f2fs/data.c

2557

f2fs_update_read_folio_count(F2FS_I_SB(inode), folio);

fs/f2fs/data.c

2560

index = folio->index;

fs/f2fs/data.c

2563

nrpages = folio_nr_pages(folio);

fs/f2fs/data.c

2602

folio_zero_range(folio, page_offset, PAGE_SIZE);

fs/f2fs/data.c

2603

if (vi && !fsverity_verify_blocks(vi, folio, PAGE_SIZE, page_offset)) {

fs/f2fs/data.c

2613

if (folio_test_large(folio)) {

fs/f2fs/data.c

2614

ffs = ffs_find_or_alloc(folio);

fs/f2fs/data.c

2645

if (!bio_add_folio(bio, folio, F2FS_BLKSIZE,

fs/f2fs/data.c

2655

trace_f2fs_read_folio(folio, DATA);

fs/f2fs/data.c

2658

folio_end_read(folio, !ret);

fs/f2fs/data.c

2662

folio = readahead_folio(rac);

fs/f2fs/data.c

2669

folio_lock(folio);

fs/f2fs/data.c

2670

folio_clear_uptodate(folio);

fs/f2fs/data.c

2671

folio_unlock(folio);

fs/f2fs/data.c

2681

struct readahead_control *rac, struct folio *folio)

fs/f2fs/data.c

2702

struct address_space *mapping = rac ? rac->mapping : folio->mapping;

fs/f2fs/data.c

2707

return f2fs_read_data_large_folio(inode, vi, rac, folio);

fs/f2fs/data.c

2711

index = rac ? readahead_index(rac) : folio->index;

fs/f2fs/data.c

2728

folio = readahead_folio(rac);

fs/f2fs/data.c

2729

prefetchw(&folio->flags);

fs/f2fs/data.c

2732

f2fs_update_read_folio_count(F2FS_I_SB(inode), folio);

fs/f2fs/data.c

2735

index = folio->index;

fs/f2fs/data.c

276

struct folio *folio = fi.folio;

fs/f2fs/data.c

2770

f2fs_compress_ctx_add_page(&cc, folio);

fs/f2fs/data.c

2776

ret = f2fs_read_single_page(inode, vi, folio, max_nr_pages,

fs/f2fs/data.c

278

if (f2fs_is_compressed_page(folio))

fs/f2fs/data.c

2783

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

2784

folio_unlock(folio);

fs/f2fs/data.c

279

f2fs_end_read_compressed_page(folio, false, blkaddr,

fs/f2fs/data.c

2808

static int f2fs_read_data_folio(struct file *file, struct folio *folio)

fs/f2fs/data.c

2810

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

2814

trace_f2fs_readpage(folio, DATA);

fs/f2fs/data.c

2817

folio_unlock(folio);

fs/f2fs/data.c

2823

ret = f2fs_read_inline_data(inode, folio);

fs/f2fs/data.c

2828

vi = f2fs_need_verity(inode, folio->index);

fs/f2fs/data.c

2830

fsverity_readahead(vi, folio->index, folio_nr_pages(folio));

fs/f2fs/data.c

2831

return f2fs_mpage_readpages(inode, vi, NULL, folio);

fs/f2fs/data.c

2858

struct folio *mfolio;

fs/f2fs/data.c

2988

struct folio *folio = fio->folio;

fs/f2fs/data.c

2989

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

2999

folio_test_f2fs_atomic(folio);

fs/f2fs/data.c

3006

f2fs_lookup_read_extent_cache_block(inode, folio->index,

fs/f2fs/data.c

3025

err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);

fs/f2fs/data.c

3033

folio_clear_uptodate(folio);

fs/f2fs/data.c

3034

folio_clear_f2fs_gcing(folio);

fs/f2fs/data.c

3060

folio_start_writeback(folio);

fs/f2fs/data.c

3068

folio_end_writeback(folio);

fs/f2fs/data.c

3072

trace_f2fs_do_write_data_page(folio, IPU);

fs/f2fs/data.c

3094

folio_start_writeback(folio);

fs/f2fs/data.c

3101

trace_f2fs_do_write_data_page(folio, OPU);

fs/f2fs/data.c

3104

folio_clear_f2fs_atomic(folio);

fs/f2fs/data.c

3113

int f2fs_write_single_data_page(struct folio *folio, int *submitted,

fs/f2fs/data.c

3121

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

3126

loff_t psize = (loff_t)(folio->index + 1) << PAGE_SHIFT;

fs/f2fs/data.c

3138

.folio = folio,

fs/f2fs/data.c

3150

trace_f2fs_writepage(folio, DATA);

fs/f2fs/data.c

3154

mapping_set_error(folio->mapping, -EIO);

fs/f2fs/data.c

3172

if (folio->index < end_index ||

fs/f2fs/data.c

3182

if ((folio->index >= end_index + 1) || !offset)

fs/f2fs/data.c

3185

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/data.c

3211

err = f2fs_write_inline_data(inode, folio);

fs/f2fs/data.c

3241

folio_clear_uptodate(folio);

fs/f2fs/data.c

3242

folio_clear_f2fs_gcing(folio);

fs/f2fs/data.c

3244

folio_unlock(folio);

fs/f2fs/data.c

3262

folio_redirty_for_writepage(wbc, folio);

fs/f2fs/data.c

3269

folio_unlock(folio);

fs/f2fs/data.c

3365

struct folio *folio = fbatch.folios[i];

fs/f2fs/data.c

3368

p = folio_nr_pages(folio);

fs/f2fs/data.c

3370

pages[nr_pages] = folio_page(folio, idx);

fs/f2fs/data.c

3371

folio_get(folio);

fs/f2fs/data.c

3373

index = folio->index + idx + 1;

fs/f2fs/data.c

3385

struct folio *folio = page_folio(page);

fs/f2fs/data.c

3402

folio->index)) {

fs/f2fs/data.c

3422

folio->index, &fsdata);

fs/f2fs/data.c

3429

fsdata, folio->index, 1) ||

fs/f2fs/data.c

3447

done_index = folio->index;

fs/f2fs/data.c

3449

folio_lock(folio);

fs/f2fs/data.c

3451

if (unlikely(folio->mapping != mapping)) {

fs/f2fs/data.c

3453

folio_unlock(folio);

fs/f2fs/data.c

3457

if (!folio_test_dirty(folio)) {

fs/f2fs/data.c

3462

if (folio_test_writeback(folio)) {

fs/f2fs/data.c

3465

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/data.c

3468

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/data.c

3473

folio_get(folio);

fs/f2fs/data.c

3474

f2fs_compress_ctx_add_page(&cc, folio);

fs/f2fs/data.c

3479

ret = f2fs_write_single_data_page(folio,

fs/f2fs/data.c

3505

done_index = folio_next_index(folio);

fs/f2fs/data.c

362

struct folio *folio = fi.folio;

fs/f2fs/data.c

365

if (fscrypt_is_bounce_folio(folio)) {

fs/f2fs/data.c

366

struct folio *io_folio = folio;

fs/f2fs/data.c

368

folio = fscrypt_pagecache_folio(io_folio);

fs/f2fs/data.c

3719

struct folio *folio, loff_t pos, unsigned int len,

fs/f2fs/data.c

3722

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

3723

pgoff_t index = folio->index;

fs/f2fs/data.c

3726

struct folio *ifolio;

fs/f2fs/data.c

373

if (f2fs_is_compressed_page(folio)) {

fs/f2fs/data.c

374

f2fs_compress_write_end_io(bio, folio);

fs/f2fs/data.c

3766

f2fs_do_read_inline_data(folio, ifolio);

fs/f2fs/data.c

3772

err = f2fs_convert_inline_folio(&dn, folio);

fs/f2fs/data.c

379

type = WB_DATA_TYPE(folio, false);

fs/f2fs/data.c

3816

struct folio *ifolio;

fs/f2fs/data.c

382

mapping_set_error(folio->mapping, -EIO);

fs/f2fs/data.c

3845

struct folio *ifolio;

fs/f2fs/data.c

3871

struct folio *folio, loff_t pos, unsigned int len,

fs/f2fs/data.c

3874

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

3876

pgoff_t index = folio->index;

fs/f2fs/data.c

389

if (is_node_folio(folio)) {

fs/f2fs/data.c

390

f2fs_sanity_check_node_footer(sbi, folio,

fs/f2fs/data.c

391

folio->index, NODE_TYPE_REGULAR, true);

fs/f2fs/data.c

392

f2fs_bug_on(sbi, folio->index != nid_of_node(folio));

fs/f2fs/data.c

3921

loff_t pos, unsigned len, struct folio **foliop,

fs/f2fs/data.c

3926

struct folio *folio;

fs/f2fs/data.c

394

if (f2fs_in_warm_node_list(folio))

fs/f2fs/data.c

395

f2fs_del_fsync_node_entry(sbi, folio);

fs/f2fs/data.c

3977

folio = f2fs_filemap_get_folio(mapping, index,

fs/f2fs/data.c

3980

if (IS_ERR(folio)) {

fs/f2fs/data.c

3981

err = PTR_ERR(folio);

fs/f2fs/data.c

3987

*foliop = folio;

fs/f2fs/data.c

3990

err = prepare_atomic_write_begin(sbi, folio, pos, len,

fs/f2fs/data.c

3993

err = prepare_write_begin(sbi, folio, pos, len,

fs/f2fs/data.c

4000

folio_unlock(folio);

fs/f2fs/data.c

4002

folio_lock(folio);

fs/f2fs/data.c

4003

if (folio->mapping != mapping) {

fs/f2fs/data.c

4005

folio_unlock(folio);

fs/f2fs/data.c

4006

folio_put(folio);

fs/f2fs/data.c

4011

f2fs_folio_wait_writeback(folio, DATA, false, true);

fs/f2fs/data.c

4013

if (len == folio_size(folio) || folio_test_uptodate(folio))

fs/f2fs/data.c

4018

folio_zero_segment(folio, len, folio_size(folio));

fs/f2fs/data.c

4023

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/data.c

4024

folio_mark_uptodate(folio);

fs/f2fs/data.c

4041

folio, blkaddr, 0, true);

fs/f2fs/data.c

4043

folio_lock(folio);

fs/f2fs/data.c

4044

if (unlikely(folio->mapping != mapping)) {

fs/f2fs/data.c

4045

folio_unlock(folio);

fs/f2fs/data.c

4046

folio_put(folio);

fs/f2fs/data.c

4049

if (unlikely(!folio_test_uptodate(folio))) {

fs/f2fs/data.c

4057

f2fs_folio_put(folio, true);

fs/f2fs/data.c

4066

struct folio *folio, void *fsdata)

fs/f2fs/data.c

4068

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

407

folio_clear_f2fs_gcing(folio);

fs/f2fs/data.c

4077

if (!folio_test_uptodate(folio)) {

fs/f2fs/data.c

408

folio_end_writeback(folio);

fs/f2fs/data.c

4081

folio_mark_uptodate(folio);

fs/f2fs/data.c

4087

f2fs_compress_write_end(inode, fsdata, folio->index, copied);

fs/f2fs/data.c

4100

folio_mark_dirty(folio);

fs/f2fs/data.c

4103

folio_set_f2fs_atomic(folio);

fs/f2fs/data.c

4113

f2fs_folio_put(folio, true);

fs/f2fs/data.c

4118

void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)

fs/f2fs/data.c

4120

struct inode *inode = folio->mapping->host;

fs/f2fs/data.c

4124

(offset || length != folio_size(folio)))

fs/f2fs/data.c

4127

if (folio_test_dirty(folio)) {

fs/f2fs/data.c

4138

if (offset || length != folio_size(folio))

fs/f2fs/data.c

4141

folio_cancel_dirty(folio);

fs/f2fs/data.c

4142

ffs_detach_free(folio);

fs/f2fs/data.c

4145

bool f2fs_release_folio(struct folio *folio, gfp_t wait)

fs/f2fs/data.c

4148

if (folio_test_dirty(folio))

fs/f2fs/data.c

4151

ffs_detach_free(folio);

fs/f2fs/data.c

4156

struct folio *folio)

fs/f2fs/data.c

4160

trace_f2fs_set_page_dirty(folio, DATA);

fs/f2fs/data.c

4162

if (!folio_test_uptodate(folio))

fs/f2fs/data.c

4163

folio_mark_uptodate(folio);

fs/f2fs/data.c

4164

BUG_ON(folio_test_swapcache(folio));

fs/f2fs/data.c

4166

if (filemap_dirty_folio(mapping, folio)) {

fs/f2fs/data.c

4167

f2fs_update_dirty_folio(inode, folio);

fs/f2fs/data.c

4275

struct folio *folio;

fs/f2fs/data.c

4278

folio = f2fs_get_lock_data_folio(inode, blkidx, true);

fs/f2fs/data.c

4279

if (IS_ERR(folio)) {

fs/f2fs/data.c

4281

ret = PTR_ERR(folio);

fs/f2fs/data.c

4285

folio_mark_dirty(folio);

fs/f2fs/data.c

4286

f2fs_folio_put(folio, true);

fs/f2fs/data.c

4497

void f2fs_clear_page_cache_dirty_tag(struct folio *folio)

fs/f2fs/data.c

4499

struct address_space *mapping = folio->mapping;

fs/f2fs/data.c

4503

__xa_clear_mark(&mapping->i_pages, folio->index,

fs/f2fs/data.c

497

F2FS_I(fio->folio->mapping->host)->ioprio_hint == F2FS_IOPRIO_WRITE)

fs/f2fs/data.c

604

struct folio *folio, nid_t ino)

fs/f2fs/data.c

611

if (!inode && !folio && !ino)

fs/f2fs/data.c

615

struct folio *target = fi.folio;

fs/f2fs/data.c

62

bool f2fs_is_cp_guaranteed(const struct folio *folio)

fs/f2fs/data.c

630

if (folio && folio == target)

fs/f2fs/data.c

64

struct address_space *mapping = folio->mapping;

fs/f2fs/data.c

68

if (fscrypt_is_bounce_folio(folio))

fs/f2fs/data.c

69

return folio_test_f2fs_gcing(fscrypt_pagecache_folio(folio));

fs/f2fs/data.c

701

struct inode *inode, struct folio *folio,

fs/f2fs/data.c

706

bool force = !inode && !folio && !ino;

fs/f2fs/data.c

715

ret = __has_merged_page(io->bio, inode, folio, ino);

fs/f2fs/data.c

741

struct inode *inode, struct folio *folio,

fs/f2fs/data.c

744

__submit_merged_write_cond(sbi, inode, folio, ino, type, false);

fs/f2fs/data.c

748

struct folio *folio, enum page_type type)

fs/f2fs/data.c

750

__submit_merged_write_cond(sbi, NULL, folio, 0, type, true);

fs/f2fs/data.c

767

struct folio *fio_folio = fio->folio;

fs/f2fs/data.c

768

struct folio *data_folio = fio->encrypted_page ?

fs/f2fs/data.c

789

__read_io_type(data_folio) : WB_DATA_TYPE(fio->folio, false));

fs/f2fs/data.c

80

folio_test_f2fs_gcing(folio))

fs/f2fs/data.c

831

struct folio *folio, enum temp_type temp)

fs/f2fs/data.c

840

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

fs/f2fs/data.c

85

static enum count_type __read_io_type(struct folio *folio)

fs/f2fs/data.c

854

struct folio *folio)

fs/f2fs/data.c

856

struct folio *fio_folio = fio->folio;

fs/f2fs/data.c

87

struct address_space *mapping = folio->mapping;

fs/f2fs/data.c

880

bio_add_folio(*bio, folio, folio_size(folio), 0)) {

fs/f2fs/data.c

902

struct bio **bio, struct folio *folio)

fs/f2fs/data.c

908

f2fs_bug_on(sbi, !target && !folio);

fs/f2fs/data.c

924

folio, 0);

fs/f2fs/data.c

941

folio, 0);

fs/f2fs/data.c

991

struct folio *data_folio = fio->encrypted_page ?

fs/f2fs/data.c

992

page_folio(fio->encrypted_page) : fio->folio;

fs/f2fs/data.c

993

struct folio *folio = fio->folio;

fs/f2fs/dir.c

1092

struct folio *dentry_folio;

fs/f2fs/dir.c

193

struct folio *dentry_folio,

fs/f2fs/dir.c

285

struct folio **res_folio,

fs/f2fs/dir.c

308

struct folio *dentry_folio;

fs/f2fs/dir.c

354

struct folio **res_folio)

fs/f2fs/dir.c

410

const struct qstr *child, struct folio **res_folio)

fs/f2fs/dir.c

431

struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct folio **f)

fs/f2fs/dir.c

437

struct folio **folio)

fs/f2fs/dir.c

442

de = f2fs_find_entry(dir, qstr, folio);

fs/f2fs/dir.c

445

f2fs_folio_put(*folio, false);

fs/f2fs/dir.c

452

struct folio *folio, struct inode *inode)

fs/f2fs/dir.c

456

folio_lock(folio);

fs/f2fs/dir.c

457

f2fs_folio_wait_writeback(folio, type, true, true);

fs/f2fs/dir.c

460

folio_mark_dirty(folio);

fs/f2fs/dir.c

464

f2fs_folio_put(folio, true);

fs/f2fs/dir.c

469

struct folio *ifolio)

fs/f2fs/dir.c

517

struct inode *parent, struct folio *folio)

fs/f2fs/dir.c

519

struct folio *dentry_folio;

fs/f2fs/dir.c

524

return f2fs_make_empty_inline_dir(inode, parent, folio);

fs/f2fs/dir.c

526

dentry_folio = f2fs_get_new_data_folio(inode, folio, 0, true);

fs/f2fs/dir.c

540

struct folio *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,

fs/f2fs/dir.c

541

const struct f2fs_filename *fname, struct folio *dfolio)

fs/f2fs/dir.c

543

struct folio *folio;

fs/f2fs/dir.c

547

folio = f2fs_new_inode_folio(inode);

fs/f2fs/dir.c

548

if (IS_ERR(folio))

fs/f2fs/dir.c

549

return folio;

fs/f2fs/dir.c

553

folio_get(folio);

fs/f2fs/dir.c

554

err = make_empty_dir(inode, dir, folio);

fs/f2fs/dir.c

556

folio_lock(folio);

fs/f2fs/dir.c

559

folio_put(folio);

fs/f2fs/dir.c

562

err = f2fs_init_acl(inode, dir, folio, dfolio);

fs/f2fs/dir.c

568

folio);

fs/f2fs/dir.c

573

err = fscrypt_set_context(inode, folio);

fs/f2fs/dir.c

578

folio = f2fs_get_inode_folio(F2FS_I_SB(dir), inode->i_ino);

fs/f2fs/dir.c

579

if (IS_ERR(folio))

fs/f2fs/dir.c

580

return folio;

fs/f2fs/dir.c

583

init_dent_inode(dir, inode, fname, folio);

fs/f2fs/dir.c

600

return folio;

fs/f2fs/dir.c

604

f2fs_update_inode(inode, folio);

fs/f2fs/dir.c

605

f2fs_folio_put(folio, true);

fs/f2fs/dir.c

647

bool f2fs_has_enough_room(struct inode *dir, struct folio *ifolio,

fs/f2fs/dir.c

691

struct folio *dentry_folio = NULL;

fs/f2fs/dir.c

694

struct folio *folio = NULL;

fs/f2fs/dir.c

745

folio = f2fs_init_inode_metadata(inode, dir, fname, NULL);

fs/f2fs/dir.c

746

if (IS_ERR(folio)) {

fs/f2fs/dir.c

747

err = PTR_ERR(folio);

fs/f2fs/dir.c

763

f2fs_update_inode(inode, folio);

fs/f2fs/dir.c

765

f2fs_folio_put(folio, true);

fs/f2fs/dir.c

807

struct folio *folio = NULL;

fs/f2fs/dir.c

823

de = __f2fs_find_entry(dir, &fname, &folio);

fs/f2fs/dir.c

827

f2fs_folio_put(folio, false);

fs/f2fs/dir.c

829

} else if (IS_ERR(folio)) {

fs/f2fs/dir.c

830

err = PTR_ERR(folio);

fs/f2fs/dir.c

841

struct folio *folio;

fs/f2fs/dir.c

845

folio = f2fs_init_inode_metadata(inode, dir, fname, NULL);

fs/f2fs/dir.c

846

if (IS_ERR(folio)) {

fs/f2fs/dir.c

847

err = PTR_ERR(folio);

fs/f2fs/dir.c

850

f2fs_folio_put(folio, true);

fs/f2fs/dir.c

886

void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct folio *folio,

fs/f2fs/dir.c

892

pgoff_t index = folio->index;

fs/f2fs/dir.c

901

return f2fs_delete_inline_entry(dentry, folio, dir, inode);

fs/f2fs/dir.c

903

folio_lock(folio);

fs/f2fs/dir.c

904

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/dir.c

906

dentry_blk = folio_address(folio);

fs/f2fs/dir.c

915

folio_mark_dirty(folio);

fs/f2fs/dir.c

919

f2fs_clear_page_cache_dirty_tag(folio);

fs/f2fs/dir.c

920

folio_clear_dirty_for_io(folio);

fs/f2fs/dir.c

921

folio_clear_uptodate(folio);

fs/f2fs/dir.c

922

folio_detach_private(folio);

fs/f2fs/dir.c

927

f2fs_folio_put(folio, true);

fs/f2fs/dir.c

948

struct folio *dentry_folio;

fs/f2fs/extent_cache.c

22

bool sanity_check_extent_cache(struct inode *inode, struct folio *ifolio)

fs/f2fs/extent_cache.c

410

void f2fs_init_read_extent_tree(struct inode *inode, struct folio *ifolio)

fs/f2fs/f2fs.h

1120

struct folio *inode_folio; /* its inode folio, NULL is possible */

fs/f2fs/f2fs.h

1121

struct folio *node_folio; /* cached direct node folio */

fs/f2fs/f2fs.h

1132

struct folio *ifolio, struct folio *nfolio, nid_t nid)

fs/f2fs/f2fs.h

1236

#define WB_DATA_TYPE(folio, f) \

fs/f2fs/f2fs.h

1237

(f || f2fs_is_cp_guaranteed(folio) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)

fs/f2fs/f2fs.h

1356

struct folio *folio;

fs/f2fs/f2fs.h

2208

static inline struct f2fs_sb_info *F2FS_F_SB(const struct folio *folio)

fs/f2fs/f2fs.h

2210

return F2FS_M_SB(folio->mapping);

fs/f2fs/f2fs.h

2218

static inline struct f2fs_super_block *F2FS_SUPER_BLOCK(struct folio *folio,

fs/f2fs/f2fs.h

2221

pgoff_t idx_in_folio = index % folio_nr_pages(folio);

fs/f2fs/f2fs.h

2224

(page_address(folio_page(folio, idx_in_folio)) +

fs/f2fs/f2fs.h

2233

static inline struct f2fs_node *F2FS_NODE(const struct folio *folio)

fs/f2fs/f2fs.h

2235

return (struct f2fs_node *)folio_address(folio);

fs/f2fs/f2fs.h

2238

static inline struct f2fs_inode *F2FS_INODE(const struct folio *folio)

fs/f2fs/f2fs.h

2240

return &((struct f2fs_node *)folio_address(folio))->i;

fs/f2fs/f2fs.h

2278

static inline bool is_meta_folio(struct folio *folio)

fs/f2fs/f2fs.h

2280

return folio->mapping == META_MAPPING(F2FS_F_SB(folio));

fs/f2fs/f2fs.h

2283

static inline bool is_node_folio(struct folio *folio)

fs/f2fs/f2fs.h

2285

return folio->mapping == NODE_MAPPING(F2FS_F_SB(folio));

fs/f2fs/f2fs.h

2637

static inline bool folio_test_f2fs_##name(const struct folio *folio) \

fs/f2fs/f2fs.h

2639

unsigned long priv = (unsigned long)folio->private; \

fs/f2fs/f2fs.h

2652

static inline void folio_set_f2fs_##name(struct folio *folio) \

fs/f2fs/f2fs.h

2656

if (!folio->private) \

fs/f2fs/f2fs.h

2657

folio_attach_private(folio, (void *)v); \

fs/f2fs/f2fs.h

2659

v |= (unsigned long)folio->private; \

fs/f2fs/f2fs.h

2660

folio->private = (void *)v; \

fs/f2fs/f2fs.h

2672

static inline void folio_clear_f2fs_##name(struct folio *folio) \

fs/f2fs/f2fs.h

2674

unsigned long v = (unsigned long)folio->private; \

fs/f2fs/f2fs.h

2678

folio_detach_private(folio); \

fs/f2fs/f2fs.h

2680

folio->private = (void *)v; \

fs/f2fs/f2fs.h

2704

static inline unsigned long folio_get_f2fs_data(struct folio *folio)

fs/f2fs/f2fs.h

2706

unsigned long data = (unsigned long)folio->private;

fs/f2fs/f2fs.h

2713

static inline void folio_set_f2fs_data(struct folio *folio, unsigned long data)

fs/f2fs/f2fs.h

2717

if (!folio_test_private(folio))

fs/f2fs/f2fs.h

2718

folio_attach_private(folio, (void *)data);

fs/f2fs/f2fs.h

2720

folio->private = (void *)((unsigned long)folio->private | data);

fs/f2fs/f2fs.h

3048

static inline struct folio *f2fs_grab_cache_folio(struct address_space *mapping,

fs/f2fs/f2fs.h

3051

struct folio *folio;

fs/f2fs/f2fs.h

3061

folio = __filemap_get_folio(mapping, index, fgf_flags, 0);

fs/f2fs/f2fs.h

3062

if (!IS_ERR(folio))

fs/f2fs/f2fs.h

3063

return folio;

fs/f2fs/f2fs.h

3073

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/f2fs/f2fs.h

3077

return folio;

fs/f2fs/f2fs.h

3080

static inline struct folio *f2fs_filemap_get_folio(

fs/f2fs/f2fs.h

3090

static inline void f2fs_folio_put(struct folio *folio, bool unlock)

fs/f2fs/f2fs.h

3092

if (IS_ERR_OR_NULL(folio))

fs/f2fs/f2fs.h

3096

f2fs_bug_on(F2FS_F_SB(folio), !folio_test_locked(folio));

fs/f2fs/f2fs.h

3097

folio_unlock(folio);

fs/f2fs/f2fs.h

3099

folio_put(folio);

fs/f2fs/f2fs.h

3207

static inline bool IS_INODE(const struct folio *folio)

fs/f2fs/f2fs.h

3209

struct f2fs_node *p = F2FS_NODE(folio);

fs/f2fs/f2fs.h

3227

struct folio *node_folio)

fs/f2fs/f2fs.h

3237

struct folio *node_folio)

fs/f2fs/f2fs.h

3244

struct folio *node_folio, unsigned int offset)

fs/f2fs/f2fs.h

3563

void *inline_xattr_addr(struct inode *inode, const struct folio *folio)

fs/f2fs/f2fs.h

3565

struct f2fs_inode *ri = F2FS_INODE(folio);

fs/f2fs/f2fs.h

3612

static inline void *inline_data_addr(struct inode *inode, struct folio *folio)

fs/f2fs/f2fs.h

3614

__le32 *addr = get_dnode_addr(inode, folio);

fs/f2fs/f2fs.h

3824

bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct folio *folio);

fs/f2fs/f2fs.h

3825

void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct folio *folio);

fs/f2fs/f2fs.h

3829

void f2fs_update_inode(struct inode *inode, struct folio *node_folio);

fs/f2fs/f2fs.h

3876

struct folio *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,

fs/f2fs/f2fs.h

3877

const struct f2fs_filename *fname, struct folio *dfolio);

fs/f2fs/f2fs.h

3883

const struct f2fs_filename *fname, struct folio **res_folio);

fs/f2fs/f2fs.h

3885

const struct qstr *child, struct folio **res_folio);

fs/f2fs/f2fs.h

3886

struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct folio **f);

fs/f2fs/f2fs.h

3888

struct folio **folio);

fs/f2fs/f2fs.h

3890

struct folio *folio, struct inode *inode);

fs/f2fs/f2fs.h

3891

bool f2fs_has_enough_room(struct inode *dir, struct folio *ifolio,

fs/f2fs/f2fs.h

3902

void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct folio *folio,

fs/f2fs/f2fs.h

3945

bool f2fs_in_warm_node_list(struct folio *folio);

fs/f2fs/f2fs.h

3947

void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct folio *folio);

fs/f2fs/f2fs.h

3961

struct folio *f2fs_new_inode_folio(struct inode *inode);

fs/f2fs/f2fs.h

3962

struct folio *f2fs_new_node_folio(struct dnode_of_data *dn, unsigned int ofs);

fs/f2fs/f2fs.h

3964

struct folio *f2fs_get_node_folio(struct f2fs_sb_info *sbi, pgoff_t nid,

fs/f2fs/f2fs.h

3967

struct folio *folio, pgoff_t nid,

fs/f2fs/f2fs.h

3969

struct folio *f2fs_get_inode_folio(struct f2fs_sb_info *sbi, pgoff_t ino);

fs/f2fs/f2fs.h

3970

struct folio *f2fs_get_xnode_folio(struct f2fs_sb_info *sbi, pgoff_t xnid);

fs/f2fs/f2fs.h

3971

int f2fs_write_single_node_folio(struct folio *node_folio, int sync_mode,

fs/f2fs/f2fs.h

3973

int f2fs_move_node_folio(struct folio *node_folio, int gc_type);

fs/f2fs/f2fs.h

3986

int f2fs_recover_inline_xattr(struct inode *inode, struct folio *folio);

fs/f2fs/f2fs.h

3987

int f2fs_recover_xattr_data(struct inode *inode, struct folio *folio);

fs/f2fs/f2fs.h

3988

int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct folio *folio);

fs/f2fs/f2fs.h

4036

struct folio *f2fs_get_sum_folio(struct f2fs_sb_info *sbi, unsigned int segno);

fs/f2fs/f2fs.h

4039

void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/f2fs.h

4055

int f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/f2fs.h

4061

void f2fs_folio_wait_writeback(struct folio *folio, enum page_type type,

fs/f2fs/f2fs.h

4092

return fio->folio->mapping->host;

fs/f2fs/f2fs.h

4114

struct folio *f2fs_grab_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index);

fs/f2fs/f2fs.h

4115

struct folio *f2fs_get_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index);

fs/f2fs/f2fs.h

4116

struct folio *f2fs_get_meta_folio_retry(struct f2fs_sb_info *sbi, pgoff_t index);

fs/f2fs/f2fs.h

4117

struct folio *f2fs_get_tmp_folio(struct f2fs_sb_info *sbi, pgoff_t index);

fs/f2fs/f2fs.h

413

struct folio *folio; /* warm node folio pointer */

fs/f2fs/f2fs.h

4142

void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio);

fs/f2fs/f2fs.h

4162

bool f2fs_is_cp_guaranteed(const struct folio *folio);

fs/f2fs/f2fs.h

4170

struct inode *inode, struct folio *folio,

fs/f2fs/f2fs.h

4173

struct folio *folio, enum page_type type);

fs/f2fs/f2fs.h

4175

struct bio **bio, struct folio *folio);

fs/f2fs/f2fs.h

4190

struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/f2fs.h

4192

struct folio *f2fs_find_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/f2fs.h

4194

struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,

fs/f2fs/f2fs.h

4196

struct folio *f2fs_get_new_data_folio(struct inode *inode,

fs/f2fs/f2fs.h

4197

struct folio *ifolio, pgoff_t index, bool new_i_size);

fs/f2fs/f2fs.h

4205

int f2fs_write_single_data_page(struct folio *folio, int *submitted,

fs/f2fs/f2fs.h

4211

void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length);

fs/f2fs/f2fs.h

4212

bool f2fs_release_folio(struct folio *folio, gfp_t wait);

fs/f2fs/f2fs.h

4214

void f2fs_clear_page_cache_dirty_tag(struct folio *folio);

fs/f2fs/f2fs.h

4521

bool f2fs_sanity_check_inline_data(struct inode *inode, struct folio *ifolio);

fs/f2fs/f2fs.h

4523

void f2fs_do_read_inline_data(struct folio *folio, struct folio *ifolio);

fs/f2fs/f2fs.h

4524

void f2fs_truncate_inline_inode(struct inode *inode, struct folio *ifolio,

fs/f2fs/f2fs.h

4526

int f2fs_read_inline_data(struct inode *inode, struct folio *folio);

fs/f2fs/f2fs.h

4527

int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio);

fs/f2fs/f2fs.h

4530

int f2fs_write_inline_data(struct inode *inode, struct folio *folio);

fs/f2fs/f2fs.h

4531

int f2fs_recover_inline_data(struct inode *inode, struct folio *nfolio);

fs/f2fs/f2fs.h

4533

const struct f2fs_filename *fname, struct folio **res_folio,

fs/f2fs/f2fs.h

4536

struct folio *ifolio);

fs/f2fs/f2fs.h

4540

struct folio *folio, struct inode *dir, struct inode *inode);

fs/f2fs/f2fs.h

4563

bool sanity_check_extent_cache(struct inode *inode, struct folio *ifolio);

fs/f2fs/f2fs.h

4573

void f2fs_init_read_extent_tree(struct inode *inode, struct folio *ifolio);

fs/f2fs/f2fs.h

4653

bool f2fs_is_compressed_page(struct folio *folio);

fs/f2fs/f2fs.h

4654

struct folio *f2fs_compress_control_folio(struct folio *folio);

fs/f2fs/f2fs.h

4660

void f2fs_compress_write_end_io(struct bio *bio, struct folio *folio);

fs/f2fs/f2fs.h

4666

void f2fs_end_read_compressed_page(struct folio *folio, bool failed,

fs/f2fs/f2fs.h

4673

void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct folio *folio);

fs/f2fs/f2fs.h

4689

void f2fs_put_folio_dic(struct folio *folio, bool in_task);

fs/f2fs/f2fs.h

4704

bool f2fs_load_compressed_folio(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/f2fs.h

4720

static inline bool f2fs_is_compressed_page(struct folio *folio) { return false; }

fs/f2fs/f2fs.h

4729

static inline struct folio *f2fs_compress_control_folio(struct folio *folio)

fs/f2fs/f2fs.h

4738

static inline void f2fs_end_read_compressed_page(struct folio *folio,

fs/f2fs/f2fs.h

4743

static inline void f2fs_put_folio_dic(struct folio *folio, bool in_task)

fs/f2fs/f2fs.h

4759

struct folio *folio, block_t blkaddr) { return false; }

fs/f2fs/f2fs.h

5091

struct folio *folio, enum page_type type)

fs/f2fs/f2fs.h

5093

pgoff_t ofs = folio->index;

fs/f2fs/f2fs.h

5136

struct folio *folio;

fs/f2fs/f2fs.h

5138

folio = filemap_get_folio(META_MAPPING(sbi), blkaddr + i);

fs/f2fs/f2fs.h

5139

if (!IS_ERR(folio)) {

fs/f2fs/f2fs.h

5140

if (folio_test_writeback(folio))

fs/f2fs/f2fs.h

5142

f2fs_folio_put(folio, false);

fs/f2fs/file.c

117

int ret = f2fs_is_compressed_cluster(inode, folio->index);

fs/f2fs/file.c

1229

struct folio *folio;

fs/f2fs/file.c

1238

folio = f2fs_get_new_data_folio(inode, NULL, index, false);

fs/f2fs/file.c

1241

if (IS_ERR(folio))

fs/f2fs/file.c

1242

return PTR_ERR(folio);

fs/f2fs/file.c

1244

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/file.c

1245

folio_zero_range(folio, start, len);

fs/f2fs/file.c

1246

folio_mark_dirty(folio);

fs/f2fs/file.c

1247

f2fs_folio_put(folio, true);

fs/f2fs/file.c

135

f2fs_zero_post_eof_page(inode, (folio->index + 1) << PAGE_SHIFT, true);

fs/f2fs/file.c

140

folio_lock(folio);

fs/f2fs/file.c

141

if (unlikely(folio->mapping != inode->i_mapping ||

fs/f2fs/file.c

142

folio_pos(folio) > i_size_read(inode) ||

fs/f2fs/file.c

143

!folio_test_uptodate(folio))) {

fs/f2fs/file.c

144

folio_unlock(folio);

fs/f2fs/file.c

1482

struct folio *fsrc, *fdst;

fs/f2fs/file.c

152

err = f2fs_get_block_locked(&dn, folio->index);

fs/f2fs/file.c

154

err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);

fs/f2fs/file.c

162

folio_unlock(folio);

fs/f2fs/file.c

166

f2fs_folio_wait_writeback(folio, DATA, false, true);

fs/f2fs/file.c

174

if (folio_test_mappedtodisk(folio))

fs/f2fs/file.c

178

if (((loff_t)(folio->index + 1) << PAGE_SHIFT) >

fs/f2fs/file.c

183

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/file.c

185

folio_mark_dirty(folio);

fs/f2fs/file.c

197

trace_f2fs_vm_page_mkwrite(inode, folio->index, vmf->vma->vm_flags, ret);

fs/f2fs/file.c

261

struct folio *i = filemap_get_folio(NODE_MAPPING(sbi), ino);

fs/f2fs/file.c

3027

struct folio *folio;

fs/f2fs/file.c

3029

folio = f2fs_get_lock_data_folio(inode, idx, true);

fs/f2fs/file.c

3030

if (IS_ERR(folio)) {

fs/f2fs/file.c

3031

err = PTR_ERR(folio);

fs/f2fs/file.c

3035

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/file.c

3037

folio_mark_dirty(folio);

fs/f2fs/file.c

3038

folio_set_f2fs_gcing(folio);

fs/f2fs/file.c

3039

f2fs_folio_put(folio, true);

fs/f2fs/file.c

4458

struct folio *folio;

fs/f2fs/file.c

4467

folio = read_cache_folio(mapping, page_idx, NULL, NULL);

fs/f2fs/file.c

4468

if (IS_ERR(folio)) {

fs/f2fs/file.c

4469

ret = PTR_ERR(folio);

fs/f2fs/file.c

4472

page_len += folio_nr_pages(folio) - (page_idx - folio->index);

fs/f2fs/file.c

4473

page_idx = folio_next_index(folio);

fs/f2fs/file.c

4477

folio = filemap_lock_folio(mapping, redirty_idx);

fs/f2fs/file.c

4480

f2fs_bug_on(F2FS_I_SB(inode), IS_ERR(folio));

fs/f2fs/file.c

4482

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/file.c

4484

folio_mark_dirty(folio);

fs/f2fs/file.c

4485

folio_set_f2fs_gcing(folio);

fs/f2fs/file.c

4486

redirty_idx = folio_next_index(folio);

fs/f2fs/file.c

4487

folio_unlock(folio);

fs/f2fs/file.c

4488

folio_put_refs(folio, 2);

fs/f2fs/file.c

753

struct folio *folio;

fs/f2fs/file.c

759

folio = filemap_lock_folio(mapping, index);

fs/f2fs/file.c

76

struct folio *folio = page_folio(vmf->page);

fs/f2fs/file.c

760

if (IS_ERR(folio))

fs/f2fs/file.c

762

if (folio_test_uptodate(folio))

fs/f2fs/file.c

764

f2fs_folio_put(folio, true);

fs/f2fs/file.c

768

folio = f2fs_get_lock_data_folio(inode, index, true);

fs/f2fs/file.c

769

if (IS_ERR(folio))

fs/f2fs/file.c

770

return PTR_ERR(folio) == -ENOENT ? 0 : PTR_ERR(folio);

fs/f2fs/file.c

772

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/file.c

773

folio_zero_segment(folio, offset, folio_size(folio));

fs/f2fs/file.c

778

folio_mark_dirty(folio);

fs/f2fs/file.c

779

f2fs_folio_put(folio, true);

fs/f2fs/file.c

790

struct folio *ifolio;

fs/f2fs/gc.c

1063

struct folio *node_folio;

fs/f2fs/gc.c

1155

struct folio *node_folio;

fs/f2fs/gc.c

1226

struct folio *folio, *efolio;

fs/f2fs/gc.c

1250

folio = f2fs_grab_cache_folio(mapping, index, true);

fs/f2fs/gc.c

1251

if (IS_ERR(folio)) {

fs/f2fs/gc.c

1252

err = PTR_ERR(folio);

fs/f2fs/gc.c

1283

fio.folio = folio;

fs/f2fs/gc.c

1290

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/gc.c

1310

f2fs_folio_put(folio, true);

fs/f2fs/gc.c

1321

f2fs_folio_put(folio, true);

fs/f2fs/gc.c

1350

struct folio *folio, *mfolio, *efolio;

fs/f2fs/gc.c

1370

folio = f2fs_grab_cache_folio(mapping, bidx, false);

fs/f2fs/gc.c

1371

if (IS_ERR(folio)) {

fs/f2fs/gc.c

1372

err = PTR_ERR(folio);

fs/f2fs/gc.c

1391

folio_clear_uptodate(folio);

fs/f2fs/gc.c

1400

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/gc.c

1409

fio.folio = folio;

fs/f2fs/gc.c

1502

f2fs_folio_put(folio, true);

fs/f2fs/gc.c

1512

struct folio *folio;

fs/f2fs/gc.c

1515

folio = f2fs_get_lock_data_folio(inode, bidx, true);

fs/f2fs/gc.c

1516

if (IS_ERR(folio))

fs/f2fs/gc.c

1517

return PTR_ERR(folio);

fs/f2fs/gc.c

1529

if (folio_test_writeback(folio)) {

fs/f2fs/gc.c

1533

folio_mark_dirty(folio);

fs/f2fs/gc.c

1534

folio_set_f2fs_gcing(folio);

fs/f2fs/gc.c

1544

.folio = folio,

fs/f2fs/gc.c

1549

bool is_dirty = folio_test_dirty(folio);

fs/f2fs/gc.c

1552

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/gc.c

1554

folio_mark_dirty(folio);

fs/f2fs/gc.c

1555

if (folio_clear_dirty_for_io(folio)) {

fs/f2fs/gc.c

1560

folio_set_f2fs_gcing(folio);

fs/f2fs/gc.c

1564

folio_clear_f2fs_gcing(folio);

fs/f2fs/gc.c

1570

folio_mark_dirty(folio);

fs/f2fs/gc.c

1574

f2fs_folio_put(folio, true);

fs/f2fs/gc.c

1645

struct folio *data_folio;

fs/f2fs/gc.c

1832

struct folio *sum_folio = f2fs_get_sum_folio(sbi, segno);

fs/f2fs/gc.c

1858

struct folio *sum_folio = filemap_get_folio(META_MAPPING(sbi),

fs/f2fs/inline.c

101

void f2fs_truncate_inline_inode(struct inode *inode, struct folio *ifolio,

fs/f2fs/inline.c

119

int f2fs_read_inline_data(struct inode *inode, struct folio *folio)

fs/f2fs/inline.c

121

struct folio *ifolio;

fs/f2fs/inline.c

125

folio_unlock(folio);

fs/f2fs/inline.c

134

if (folio->index)

fs/f2fs/inline.c

135

folio_zero_segment(folio, 0, folio_size(folio));

fs/f2fs/inline.c

137

f2fs_do_read_inline_data(folio, ifolio);

fs/f2fs/inline.c

139

if (!folio_test_uptodate(folio))

fs/f2fs/inline.c

140

folio_mark_uptodate(folio);

fs/f2fs/inline.c

142

folio_unlock(folio);

fs/f2fs/inline.c

146

int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio)

fs/f2fs/inline.c

154

.folio = folio,

fs/f2fs/inline.c

187

f2fs_bug_on(F2FS_F_SB(folio), folio_test_writeback(folio));

fs/f2fs/inline.c

189

f2fs_do_read_inline_data(folio, dn->inode_folio);

fs/f2fs/inline.c

190

folio_mark_dirty(folio);

fs/f2fs/inline.c

193

dirty = folio_clear_dirty_for_io(folio);

fs/f2fs/inline.c

196

folio_start_writeback(folio);

fs/f2fs/inline.c

200

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/inline.c

224

struct folio *ifolio, *folio;

fs/f2fs/inline.c

237

folio = f2fs_grab_cache_folio(inode->i_mapping, 0, false);

fs/f2fs/inline.c

238

if (IS_ERR(folio))

fs/f2fs/inline.c

239

return PTR_ERR(folio);

fs/f2fs/inline.c

252

err = f2fs_convert_inline_folio(&dn, folio);

fs/f2fs/inline.c

258

f2fs_folio_put(folio, true);

fs/f2fs/inline.c

266

int f2fs_write_inline_data(struct inode *inode, struct folio *folio)

fs/f2fs/inline.c

269

struct folio *ifolio;

fs/f2fs/inline.c

280

f2fs_bug_on(F2FS_I_SB(inode), folio->index);

fs/f2fs/inline.c

284

folio, 0, MAX_INLINE_DATA(inode));

fs/f2fs/inline.c

287

f2fs_clear_page_cache_dirty_tag(folio);

fs/f2fs/inline.c

297

int f2fs_recover_inline_data(struct inode *inode, struct folio *nfolio)

fs/f2fs/inline.c

316

struct folio *ifolio;

fs/f2fs/inline.c

337

struct folio *ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);

fs/f2fs/inline.c

358

struct folio **res_folio,

fs/f2fs/inline.c

364

struct folio *ifolio;

fs/f2fs/inline.c

37

static bool inode_has_blocks(struct inode *inode, struct folio *ifolio)

fs/f2fs/inline.c

391

struct folio *ifolio)

fs/f2fs/inline.c

413

static int f2fs_move_inline_dirents(struct inode *dir, struct folio *ifolio,

fs/f2fs/inline.c

416

struct folio *folio;

fs/f2fs/inline.c

422

folio = f2fs_grab_cache_folio(dir->i_mapping, 0, true);

fs/f2fs/inline.c

423

if (IS_ERR(folio)) {

fs/f2fs/inline.c

425

return PTR_ERR(folio);

fs/f2fs/inline.c

435

set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);

fs/f2fs/inline.c

436

f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.",

fs/f2fs/inline.c

438

f2fs_handle_error(F2FS_F_SB(folio), ERROR_INVALID_BLKADDR);

fs/f2fs/inline.c

444

f2fs_folio_wait_writeback(folio, DATA, true, true);

fs/f2fs/inline.c

446

dentry_blk = folio_address(folio);

fs/f2fs/inline.c

462

if (!folio_test_uptodate(folio))

fs/f2fs/inline.c

463

folio_mark_uptodate(folio);

fs/f2fs/inline.c

464

folio_mark_dirty(folio);

fs/f2fs/inline.c

484

f2fs_folio_put(folio, true);

fs/f2fs/inline.c

52

bool f2fs_sanity_check_inline_data(struct inode *inode, struct folio *ifolio)

fs/f2fs/inline.c

547

static int f2fs_move_rehashed_dirents(struct inode *dir, struct folio *ifolio,

fs/f2fs/inline.c

597

static int do_convert_inline_dir(struct inode *dir, struct folio *ifolio,

fs/f2fs/inline.c

609

struct folio *ifolio;

fs/f2fs/inline.c

651

struct folio *ifolio;

fs/f2fs/inline.c

656

struct folio *folio = NULL;

fs/f2fs/inline.c

678

folio = f2fs_init_inode_metadata(inode, dir, fname, ifolio);

fs/f2fs/inline.c

679

if (IS_ERR(folio)) {

fs/f2fs/inline.c

680

err = PTR_ERR(folio);

fs/f2fs/inline.c

698

f2fs_update_inode(inode, folio);

fs/f2fs/inline.c

700

f2fs_folio_put(folio, true);

fs/f2fs/inline.c

713

struct folio *folio, struct inode *dir, struct inode *inode)

fs/f2fs/inline.c

721

folio_lock(folio);

fs/f2fs/inline.c

722

f2fs_folio_wait_writeback(folio, NODE, true, true);

fs/f2fs/inline.c

724

inline_dentry = inline_data_addr(dir, folio);

fs/f2fs/inline.c

731

folio_mark_dirty(folio);

fs/f2fs/inline.c

732

f2fs_folio_put(folio, true);

fs/f2fs/inline.c

744

struct folio *ifolio;

fs/f2fs/inline.c

770

struct folio *ifolio = NULL;

fs/f2fs/inline.c

809

struct folio *ifolio;

fs/f2fs/inline.c

83

void f2fs_do_read_inline_data(struct folio *folio, struct folio *ifolio)

fs/f2fs/inline.c

85

struct inode *inode = folio->mapping->host;

fs/f2fs/inline.c

87

if (folio_test_uptodate(folio))

fs/f2fs/inline.c

90

f2fs_bug_on(F2FS_I_SB(inode), folio->index);

fs/f2fs/inline.c

92

folio_zero_segment(folio, MAX_INLINE_DATA(inode), folio_size(folio));

fs/f2fs/inline.c

95

memcpy_to_folio(folio, 0, inline_data_addr(inode, ifolio),

fs/f2fs/inline.c

97

if (!folio_test_uptodate(folio))

fs/f2fs/inline.c

98

folio_mark_uptodate(folio);

fs/f2fs/inode.c

101

static void __recover_inline_status(struct inode *inode, struct folio *ifolio)

fs/f2fs/inode.c

121

bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/inode.c

123

struct f2fs_inode *ri = &F2FS_NODE(folio)->i;

fs/f2fs/inode.c

128

if (!IS_INODE(folio) || !(ri->i_inline & F2FS_EXTRA_ATTR))

fs/f2fs/inode.c

138

static __u32 f2fs_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/inode.c

140

struct f2fs_node *node = F2FS_NODE(folio);

fs/f2fs/inode.c

160

bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/inode.c

169

if (!f2fs_enable_inode_chksum(sbi, folio))

fs/f2fs/inode.c

171

if (!f2fs_enable_inode_chksum(sbi, folio) ||

fs/f2fs/inode.c

172

folio_test_dirty(folio) ||

fs/f2fs/inode.c

173

folio_test_writeback(folio))

fs/f2fs/inode.c

177

ri = &F2FS_NODE(folio)->i;

fs/f2fs/inode.c

179

calculated = f2fs_inode_chksum(sbi, folio);

fs/f2fs/inode.c

183

folio->index, ino_of_node(folio),

fs/f2fs/inode.c

189

void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/inode.c

191

struct f2fs_inode *ri = &F2FS_NODE(folio)->i;

fs/f2fs/inode.c

193

if (!f2fs_enable_inode_chksum(sbi, folio))

fs/f2fs/inode.c

196

ri->i_inode_checksum = cpu_to_le32(f2fs_inode_chksum(sbi, folio));

fs/f2fs/inode.c

271

static bool sanity_check_inode(struct inode *inode, struct folio *node_folio)

fs/f2fs/inode.c

418

struct folio *node_folio;

fs/f2fs/inode.c

681

void f2fs_update_inode(struct inode *inode, struct folio *node_folio)

fs/f2fs/inode.c

72

static void __get_inode_rdev(struct inode *inode, struct folio *node_folio)

fs/f2fs/inode.c

782

struct folio *node_folio;

fs/f2fs/inode.c

85

static void __set_inode_rdev(struct inode *inode, struct folio *node_folio)

fs/f2fs/iostat.c

186

void f2fs_update_read_folio_count(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/iostat.c

188

unsigned int order = folio_order(folio);

fs/f2fs/iostat.h

38

struct folio *folio);

fs/f2fs/iostat.h

74

struct folio *folio) {}

fs/f2fs/namei.c

1138

struct folio *old_dir_folio, *new_dir_folio;

fs/f2fs/namei.c

1139

struct folio *old_folio, *new_folio;

fs/f2fs/namei.c

1335

struct folio *folio;

fs/f2fs/namei.c

1341

folio = read_mapping_folio(inode->i_mapping, 0, NULL);

fs/f2fs/namei.c

1342

if (IS_ERR(folio))

fs/f2fs/namei.c

1343

return ERR_CAST(folio);

fs/f2fs/namei.c

1345

target = fscrypt_get_symlink(inode, folio_address(folio),

fs/f2fs/namei.c

1347

folio_put(folio);

fs/f2fs/namei.c

467

struct folio *folio;

fs/f2fs/namei.c

468

unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot_name, &folio);

fs/f2fs/namei.c

471

if (IS_ERR(folio))

fs/f2fs/namei.c

472

return ERR_CAST(folio);

fs/f2fs/namei.c

483

struct folio *folio;

fs/f2fs/namei.c

501

de = __f2fs_find_entry(dir, &fname, &folio);

fs/f2fs/namei.c

505

if (IS_ERR(folio)) {

fs/f2fs/namei.c

506

err = PTR_ERR(folio);

fs/f2fs/namei.c

514

f2fs_folio_put(folio, false);

fs/f2fs/namei.c

566

struct folio *folio;

fs/f2fs/namei.c

583

de = f2fs_find_entry(dir, &dentry->d_name, &folio);

fs/f2fs/namei.c

585

if (IS_ERR(folio))

fs/f2fs/namei.c

586

err = PTR_ERR(folio);

fs/f2fs/namei.c

606

f2fs_folio_put(folio, false);

fs/f2fs/namei.c

609

f2fs_delete_entry(de, folio, dir, inode);

fs/f2fs/namei.c

628

f2fs_folio_put(folio, false);

fs/f2fs/namei.c

940

struct folio *old_dir_folio = NULL;

fs/f2fs/namei.c

941

struct folio *old_folio, *new_folio = NULL;

fs/f2fs/node.c

1010

struct folio *folio;

fs/f2fs/node.c

1017

folio = f2fs_get_node_folio(sbi, dn->nid, NODE_TYPE_NON_INODE);

fs/f2fs/node.c

1018

if (PTR_ERR(folio) == -ENOENT)

fs/f2fs/node.c

1020

else if (IS_ERR(folio))

fs/f2fs/node.c

1021

return PTR_ERR(folio);

fs/f2fs/node.c

1023

if (IS_INODE(folio) || ino_of_node(folio) != dn->inode->i_ino) {

fs/f2fs/node.c

1025

dn->inode->i_ino, dn->nid, ino_of_node(folio));

fs/f2fs/node.c

1028

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1033

dn->node_folio = folio;

fs/f2fs/node.c

1038

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1049

struct folio *folio;

fs/f2fs/node.c

1061

folio = f2fs_get_node_folio(F2FS_I_SB(dn->inode), dn->nid,

fs/f2fs/node.c

1063

if (IS_ERR(folio)) {

fs/f2fs/node.c

1064

trace_f2fs_truncate_nodes_exit(dn->inode, PTR_ERR(folio));

fs/f2fs/node.c

1065

return PTR_ERR(folio);

fs/f2fs/node.c

1068

f2fs_ra_node_pages(folio, ofs, NIDS_PER_BLOCK);

fs/f2fs/node.c

1070

rn = F2FS_NODE(folio);

fs/f2fs/node.c

1080

if (set_nid(folio, i, 0, false))

fs/f2fs/node.c

1094

if (set_nid(folio, i, 0, false))

fs/f2fs/node.c

1106

dn->node_folio = folio;

fs/f2fs/node.c

1112

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1118

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1126

struct folio *folios[2];

fs/f2fs/node.c

1196

struct folio *folio;

fs/f2fs/node.c

1213

folio = f2fs_get_inode_folio(sbi, inode->i_ino);

fs/f2fs/node.c

1214

if (IS_ERR(folio)) {

fs/f2fs/node.c

1215

trace_f2fs_truncate_inode_blocks_exit(inode, PTR_ERR(folio));

fs/f2fs/node.c

1216

return PTR_ERR(folio);

fs/f2fs/node.c

1219

set_new_dnode(&dn, inode, folio, NULL, 0);

fs/f2fs/node.c

1220

folio_unlock(folio);

fs/f2fs/node.c

1250

dn.nid = get_nid(folio, offset[0], true);

fs/f2fs/node.c

1271

set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);

fs/f2fs/node.c

1284

if (offset[1] == 0 && get_nid(folio, offset[0], true)) {

fs/f2fs/node.c

1285

folio_lock(folio);

fs/f2fs/node.c

1286

BUG_ON(!is_node_folio(folio));

fs/f2fs/node.c

1287

set_nid(folio, offset[0], 0, true);

fs/f2fs/node.c

1288

folio_unlock(folio);

fs/f2fs/node.c

1295

f2fs_folio_put(folio, false);

fs/f2fs/node.c

1306

struct folio *nfolio;

fs/f2fs/node.c

133

static void clear_node_folio_dirty(struct folio *folio)

fs/f2fs/node.c

135

if (folio_test_dirty(folio)) {

fs/f2fs/node.c

136

f2fs_clear_page_cache_dirty_tag(folio);

fs/f2fs/node.c

137

folio_clear_dirty_for_io(folio);

fs/f2fs/node.c

1376

struct folio *f2fs_new_inode_folio(struct inode *inode)

fs/f2fs/node.c

138

dec_page_count(F2FS_F_SB(folio), F2FS_DIRTY_NODES);

fs/f2fs/node.c

1387

struct folio *f2fs_new_node_folio(struct dnode_of_data *dn, unsigned int ofs)

fs/f2fs/node.c

1391

struct folio *folio;

fs/f2fs/node.c

1397

folio = f2fs_grab_cache_folio(NODE_MAPPING(sbi), dn->nid, false);

fs/f2fs/node.c

1398

if (IS_ERR(folio))

fs/f2fs/node.c

1399

return folio;

fs/f2fs/node.c

140

folio_clear_uptodate(folio);

fs/f2fs/node.c

143

static struct folio *get_current_nat_folio(struct f2fs_sb_info *sbi, nid_t nid)

fs/f2fs/node.c

1430

f2fs_folio_wait_writeback(folio, NODE, true, true);

fs/f2fs/node.c

1431

fill_node_footer(folio, dn->nid, dn->inode->i_ino, ofs, true);

fs/f2fs/node.c

1432

set_cold_node(folio, S_ISDIR(dn->inode->i_mode));

fs/f2fs/node.c

1433

if (!folio_test_uptodate(folio))

fs/f2fs/node.c

1434

folio_mark_uptodate(folio);

fs/f2fs/node.c

1435

if (folio_mark_dirty(folio))

fs/f2fs/node.c

1443

return folio;

fs/f2fs/node.c

1445

clear_node_folio_dirty(folio);

fs/f2fs/node.c

1446

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1455

static int read_node_folio(struct folio *folio, blk_opf_t op_flags)

fs/f2fs/node.c

1457

struct f2fs_sb_info *sbi = F2FS_F_SB(folio);

fs/f2fs/node.c

1464

.folio = folio,

fs/f2fs/node.c

1469

if (folio_test_uptodate(folio)) {

fs/f2fs/node.c

1470

if (!f2fs_inode_chksum_verify(sbi, folio)) {

fs/f2fs/node.c

1471

folio_clear_uptodate(folio);

fs/f2fs/node.c

1477

err = f2fs_get_node_info(sbi, folio->index, &ni, false);

fs/f2fs/node.c

148

static struct folio *get_next_nat_folio(struct f2fs_sb_info *sbi, nid_t nid)

fs/f2fs/node.c

1483

folio_clear_uptodate(folio);

fs/f2fs/node.c

150

struct folio *src_folio;

fs/f2fs/node.c

1502

struct folio *afolio;

fs/f2fs/node.c

151

struct folio *dst_folio;

fs/f2fs/node.c

1523

struct folio *folio, pgoff_t nid,

fs/f2fs/node.c

1528

if (unlikely(nid != nid_of_node(folio)))

fs/f2fs/node.c

1531

is_inode = IS_INODE(folio);

fs/f2fs/node.c

1532

is_xnode = f2fs_has_xattr_block(ofs_of_node(folio));

fs/f2fs/node.c

1565

ntype, nid, nid_of_node(folio), ino_of_node(folio),

fs/f2fs/node.c

1566

ofs_of_node(folio), cpver_of_node(folio),

fs/f2fs/node.c

1567

next_blkaddr_of_node(folio));

fs/f2fs/node.c

1570

fserror_report_file_metadata(folio->mapping->host,

fs/f2fs/node.c

1575

static struct folio *__get_node_folio(struct f2fs_sb_info *sbi, pgoff_t nid,

fs/f2fs/node.c

1576

struct folio *parent, int start, enum node_type ntype)

fs/f2fs/node.c

1578

struct folio *folio;

fs/f2fs/node.c

1586

folio = f2fs_grab_cache_folio(NODE_MAPPING(sbi), nid, false);

fs/f2fs/node.c

1587

if (IS_ERR(folio))

fs/f2fs/node.c

1588

return folio;

fs/f2fs/node.c

1590

err = read_node_folio(folio, 0);

fs/f2fs/node.c

1599

folio_lock(folio);

fs/f2fs/node.c

1601

if (unlikely(!is_node_folio(folio))) {

fs/f2fs/node.c

1602

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1606

if (unlikely(!folio_test_uptodate(folio))) {

fs/f2fs/node.c

1611

if (!f2fs_inode_chksum_verify(sbi, folio)) {

fs/f2fs/node.c

1616

err = f2fs_sanity_check_node_footer(sbi, folio, nid, ntype, false);

fs/f2fs/node.c

1618

return folio;

fs/f2fs/node.c

1620

folio_clear_uptodate(folio);

fs/f2fs/node.c

1624

f2fs_handle_page_eio(sbi, folio, NODE);

fs/f2fs/node.c

1625

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1629

struct folio *f2fs_get_node_folio(struct f2fs_sb_info *sbi, pgoff_t nid,

fs/f2fs/node.c

1635

struct folio *f2fs_get_inode_folio(struct f2fs_sb_info *sbi, pgoff_t ino)

fs/f2fs/node.c

1640

struct folio *f2fs_get_xnode_folio(struct f2fs_sb_info *sbi, pgoff_t xnid)

fs/f2fs/node.c

1645

static struct folio *f2fs_get_node_folio_ra(struct folio *parent, int start)

fs/f2fs/node.c

1656

struct folio *folio;

fs/f2fs/node.c

1664

folio = f2fs_filemap_get_folio(inode->i_mapping, 0,

fs/f2fs/node.c

1666

if (IS_ERR(folio))

fs/f2fs/node.c

1669

if (!folio_test_uptodate(folio))

fs/f2fs/node.c

1672

if (!folio_test_dirty(folio))

fs/f2fs/node.c

1675

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/node.c

1678

ret = f2fs_write_inline_data(inode, folio);

fs/f2fs/node.c

1682

folio_mark_dirty(folio);

fs/f2fs/node.c

1684

f2fs_folio_put(folio, true);

fs/f2fs/node.c

1689

static struct folio *last_fsync_dnode(struct f2fs_sb_info *sbi, nid_t ino)

fs/f2fs/node.c

1693

struct folio *last_folio = NULL;

fs/f2fs/node.c

1705

struct folio *folio = fbatch.folios[i];

fs/f2fs/node.c

1713

if (!IS_DNODE(folio) || !is_cold_node(folio))

fs/f2fs/node.c

1715

if (ino_of_node(folio) != ino)

fs/f2fs/node.c

1718

folio_lock(folio);

fs/f2fs/node.c

1720

if (unlikely(!is_node_folio(folio))) {

fs/f2fs/node.c

1722

folio_unlock(folio);

fs/f2fs/node.c

1725

if (ino_of_node(folio) != ino)

fs/f2fs/node.c

1728

if (!folio_test_dirty(folio)) {

fs/f2fs/node.c

1736

folio_get(folio);

fs/f2fs/node.c

1737

last_folio = folio;

fs/f2fs/node.c

1738

folio_unlock(folio);

fs/f2fs/node.c

1746

static bool __write_node_folio(struct folio *folio, bool atomic, bool do_fsync,

fs/f2fs/node.c

1751

struct f2fs_sb_info *sbi = F2FS_F_SB(folio);

fs/f2fs/node.c

1756

.ino = ino_of_node(folio),

fs/f2fs/node.c

1760

.folio = folio,

fs/f2fs/node.c

1769

trace_f2fs_writepage(folio, NODE);

fs/f2fs/node.c

1775

folio_clear_uptodate(folio);

fs/f2fs/node.c

1777

folio_unlock(folio);

fs/f2fs/node.c

1786

IS_DNODE(folio) && is_cold_node(folio))

fs/f2fs/node.c

1790

nid = nid_of_node(folio);

fs/f2fs/node.c

1792

if (f2fs_sanity_check_node_footer(sbi, folio, nid,

fs/f2fs/node.c

1806

folio_clear_uptodate(folio);

fs/f2fs/node.c

1809

folio_unlock(folio);

fs/f2fs/node.c

1823

set_dentry_mark(folio, false);

fs/f2fs/node.c

1824

set_fsync_mark(folio, do_fsync);

fs/f2fs/node.c

1825

if (IS_INODE(folio) && (atomic || is_fsync_dnode(folio)))

fs/f2fs/node.c

1826

set_dentry_mark(folio,

fs/f2fs/node.c

1827

f2fs_need_dentry_mark(sbi, ino_of_node(folio)));

fs/f2fs/node.c

1830

if (f2fs_in_warm_node_list(folio)) {

fs/f2fs/node.c

1831

seq = f2fs_add_fsync_node_entry(sbi, folio);

fs/f2fs/node.c

1836

folio_start_writeback(folio);

fs/f2fs/node.c

1840

set_node_addr(sbi, &ni, fio.new_blkaddr, is_fsync_dnode(folio));

fs/f2fs/node.c

1844

folio_unlock(folio);

fs/f2fs/node.c

1858

folio_redirty_for_writepage(wbc, folio);

fs/f2fs/node.c

1859

folio_unlock(folio);

fs/f2fs/node.c

1863

int f2fs_write_single_node_folio(struct folio *node_folio, int sync_mode,

fs/f2fs/node.c

1902

int f2fs_move_node_folio(struct folio *node_folio, int gc_type)

fs/f2fs/node.c

1915

struct folio *last_folio = NULL;

fs/f2fs/node.c

1936

struct folio *folio = fbatch.folios[i];

fs/f2fs/node.c

1947

if (!IS_DNODE(folio) || !is_cold_node(folio))

fs/f2fs/node.c

1949

if (ino_of_node(folio) != ino)

fs/f2fs/node.c

1952

folio_lock(folio);

fs/f2fs/node.c

1954

if (unlikely(!is_node_folio(folio))) {

fs/f2fs/node.c

1956

folio_unlock(folio);

fs/f2fs/node.c

1959

if (ino_of_node(folio) != ino)

fs/f2fs/node.c

1962

if (!folio_test_dirty(folio) && folio != last_folio) {

fs/f2fs/node.c

1967

f2fs_folio_wait_writeback(folio, NODE, true, true);

fs/f2fs/node.c

1969

if (!atomic || folio == last_folio) {

fs/f2fs/node.c

1972

if (IS_INODE(folio)) {

fs/f2fs/node.c

1975

f2fs_update_inode(inode, folio);

fs/f2fs/node.c

1978

if (!folio_test_dirty(folio))

fs/f2fs/node.c

1979

folio_mark_dirty(folio);

fs/f2fs/node.c

1982

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/node.c

1985

if (!__write_node_folio(folio, atomic &&

fs/f2fs/node.c

1986

folio == last_folio,

fs/f2fs/node.c

1998

if (folio == last_folio) {

fs/f2fs/node.c

1999

f2fs_folio_put(folio, false);

fs/f2fs/node.c

2047

static bool flush_dirty_inode(struct folio *folio)

fs/f2fs/node.c

2049

struct f2fs_sb_info *sbi = F2FS_F_SB(folio);

fs/f2fs/node.c

2051

nid_t ino = ino_of_node(folio);

fs/f2fs/node.c

2057

f2fs_update_inode(inode, folio);

fs/f2fs/node.c

2058

folio_unlock(folio);

fs/f2fs/node.c

2078

struct folio *folio = fbatch.folios[i];

fs/f2fs/node.c

2080

if (!IS_INODE(folio))

fs/f2fs/node.c

2083

folio_lock(folio);

fs/f2fs/node.c

2085

if (unlikely(!is_node_folio(folio)))

fs/f2fs/node.c

2087

if (!folio_test_dirty(folio))

fs/f2fs/node.c

2091

if (folio_test_f2fs_inline(folio)) {

fs/f2fs/node.c

2092

folio_clear_f2fs_inline(folio);

fs/f2fs/node.c

2093

folio_unlock(folio);

fs/f2fs/node.c

2094

flush_inline_data(sbi, ino_of_node(folio));

fs/f2fs/node.c

2098

folio_unlock(folio);

fs/f2fs/node.c

2127

struct folio *folio = fbatch.folios[i];

fs/f2fs/node.c

2143

if (step == 0 && IS_DNODE(folio))

fs/f2fs/node.c

2145

if (step == 1 && (!IS_DNODE(folio) ||

fs/f2fs/node.c

2146

is_cold_node(folio)))

fs/f2fs/node.c

2148

if (step == 2 && (!IS_DNODE(folio) ||

fs/f2fs/node.c

2149

!is_cold_node(folio)))

fs/f2fs/node.c

2153

folio_lock(folio);

fs/f2fs/node.c

2154

else if (!folio_trylock(folio))

fs/f2fs/node.c

2157

if (unlikely(!is_node_folio(folio))) {

fs/f2fs/node.c

2159

folio_unlock(folio);

fs/f2fs/node.c

2163

if (!folio_test_dirty(folio)) {

fs/f2fs/node.c

2173

if (folio_test_f2fs_inline(folio)) {

fs/f2fs/node.c

2174

folio_clear_f2fs_inline(folio);

fs/f2fs/node.c

2175

folio_unlock(folio);

fs/f2fs/node.c

2176

flush_inline_data(sbi, ino_of_node(folio));

fs/f2fs/node.c

2181

if (IS_INODE(folio) && flush_dirty_inode(folio))

fs/f2fs/node.c

2184

f2fs_folio_wait_writeback(folio, NODE, true, true);

fs/f2fs/node.c

2186

if (!folio_clear_dirty_for_io(folio))

fs/f2fs/node.c

2189

if (!__write_node_folio(folio, false, false, &submitted,

fs/f2fs/node.c

2235

struct folio *folio;

fs/f2fs/node.c

2248

folio = fn->folio;

fs/f2fs/node.c

2249

folio_get(folio);

fs/f2fs/node.c

2252

f2fs_folio_wait_writeback(folio, NODE, true, false);

fs/f2fs/node.c

2254

folio_put(folio);

fs/f2fs/node.c

2307

struct folio *folio)

fs/f2fs/node.c

2309

trace_f2fs_set_page_dirty(folio, NODE);

fs/f2fs/node.c

2311

if (!folio_test_uptodate(folio))

fs/f2fs/node.c

2312

folio_mark_uptodate(folio);

fs/f2fs/node.c

2314

if (IS_INODE(folio))

fs/f2fs/node.c

2315

f2fs_inode_chksum_set(F2FS_M_SB(mapping), folio);

fs/f2fs/node.c

2317

if (filemap_dirty_folio(mapping, folio)) {

fs/f2fs/node.c

2319

folio_set_f2fs_reference(folio);

fs/f2fs/node.c

2633

struct folio *folio = get_current_nat_folio(sbi, nid);

fs/f2fs/node.c

2635

if (IS_ERR(folio)) {

fs/f2fs/node.c

2636

ret = PTR_ERR(folio);

fs/f2fs/node.c

2638

ret = scan_nat_page(sbi, folio_address(folio),

fs/f2fs/node.c

2640

f2fs_folio_put(folio, true);

fs/f2fs/node.c

2828

int f2fs_recover_inline_xattr(struct inode *inode, struct folio *folio)

fs/f2fs/node.c

2832

struct folio *ifolio;

fs/f2fs/node.c

2839

ri = F2FS_INODE(folio);

fs/f2fs/node.c

2854

src_addr = inline_xattr_addr(inode, folio);

fs/f2fs/node.c

2865

int f2fs_recover_xattr_data(struct inode *inode, struct folio *folio)

fs/f2fs/node.c

2872

struct folio *xfolio;

fs/f2fs/node.c

2903

if (folio) {

fs/f2fs/node.c

2904

memcpy(F2FS_NODE(xfolio), F2FS_NODE(folio),

fs/f2fs/node.c

2913

int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/node.c

2916

nid_t ino = ino_of_node(folio);

fs/f2fs/node.c

2918

struct folio *ifolio;

fs/f2fs/node.c

2942

src = F2FS_INODE(folio);

fs/f2fs/node.c

3004

struct folio *folio = f2fs_get_tmp_folio(sbi, idx);

fs/f2fs/node.c

3006

if (IS_ERR(folio))

fs/f2fs/node.c

3007

return PTR_ERR(folio);

fs/f2fs/node.c

3009

rn = F2FS_NODE(folio);

fs/f2fs/node.c

3014

f2fs_folio_put(folio, true);

fs/f2fs/node.c

3128

struct folio *folio = NULL;

fs/f2fs/node.c

3142

folio = get_next_nat_folio(sbi, start_nid);

fs/f2fs/node.c

3143

if (IS_ERR(folio))

fs/f2fs/node.c

3144

return PTR_ERR(folio);

fs/f2fs/node.c

3146

nat_blk = folio_address(folio);

fs/f2fs/node.c

3183

f2fs_folio_put(folio, true);

fs/f2fs/node.c

3290

struct folio *folio;

fs/f2fs/node.c

3292

folio = f2fs_get_meta_folio(sbi, nat_bits_addr++);

fs/f2fs/node.c

3293

if (IS_ERR(folio))

fs/f2fs/node.c

3294

return PTR_ERR(folio);

fs/f2fs/node.c

3297

folio_address(folio), F2FS_BLKSIZE);

fs/f2fs/node.c

3298

f2fs_folio_put(folio, true);

fs/f2fs/node.c

333

bool f2fs_in_warm_node_list(struct folio *folio)

fs/f2fs/node.c

335

return is_node_folio(folio) && IS_DNODE(folio) && is_cold_node(folio);

fs/f2fs/node.c

347

struct folio *folio)

fs/f2fs/node.c

356

folio_get(folio);

fs/f2fs/node.c

357

fn->folio = folio;

fs/f2fs/node.c

370

void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct folio *folio)

fs/f2fs/node.c

377

if (fn->folio == folio) {

fs/f2fs/node.c

382

folio_put(folio);

fs/f2fs/node.c

578

struct folio *folio = NULL;

fs/f2fs/node.c

632

folio = f2fs_get_meta_folio(sbi, index);

fs/f2fs/node.c

633

if (IS_ERR(folio))

fs/f2fs/node.c

634

return PTR_ERR(folio);

fs/f2fs/node.c

636

nat_blk = folio_address(folio);

fs/f2fs/node.c

639

f2fs_folio_put(folio, true);

fs/f2fs/node.c

674

static void f2fs_ra_node_pages(struct folio *parent, int start, int n)

fs/f2fs/node.c

805

static struct folio *f2fs_get_node_folio_ra(struct folio *parent, int start);

fs/f2fs/node.c

815

struct folio *nfolio[4];

fs/f2fs/node.c

816

struct folio *parent = NULL;

fs/f2fs/node.h

243

static inline nid_t ino_of_node(const struct folio *node_folio)

fs/f2fs/node.h

249

static inline nid_t nid_of_node(const struct folio *node_folio)

fs/f2fs/node.h

255

static inline unsigned int ofs_of_node(const struct folio *node_folio)

fs/f2fs/node.h

262

static inline __u64 cpver_of_node(const struct folio *node_folio)

fs/f2fs/node.h

268

static inline block_t next_blkaddr_of_node(const struct folio *node_folio)

fs/f2fs/node.h

274

static inline void fill_node_footer(const struct folio *folio, nid_t nid,

fs/f2fs/node.h

277

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

293

static inline void copy_node_footer(const struct folio *dst,

fs/f2fs/node.h

294

const struct folio *src)

fs/f2fs/node.h

301

static inline void fill_node_footer_blkaddr(struct folio *folio, block_t blkaddr)

fs/f2fs/node.h

303

struct f2fs_checkpoint *ckpt = F2FS_CKPT(F2FS_F_SB(folio));

fs/f2fs/node.h

304

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

314

static inline bool is_recoverable_dnode(const struct folio *folio)

fs/f2fs/node.h

316

struct f2fs_checkpoint *ckpt = F2FS_CKPT(F2FS_F_SB(folio));

fs/f2fs/node.h

321

return (cp_ver << 32) == (cpver_of_node(folio) << 32);

fs/f2fs/node.h

326

return cp_ver == cpver_of_node(folio);

fs/f2fs/node.h

350

static inline bool IS_DNODE(const struct folio *node_folio)

fs/f2fs/node.h

368

static inline int set_nid(struct folio *folio, int off, nid_t nid, bool i)

fs/f2fs/node.h

370

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

372

f2fs_folio_wait_writeback(folio, NODE, true, true);

fs/f2fs/node.h

378

return folio_mark_dirty(folio);

fs/f2fs/node.h

381

static inline nid_t get_nid(const struct folio *folio, int off, bool i)

fs/f2fs/node.h

383

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

397

static inline int is_node(const struct folio *folio, int type)

fs/f2fs/node.h

399

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

403

#define is_cold_node(folio) is_node(folio, COLD_BIT_SHIFT)

fs/f2fs/node.h

404

#define is_fsync_dnode(folio) is_node(folio, FSYNC_BIT_SHIFT)

fs/f2fs/node.h

405

#define is_dent_dnode(folio) is_node(folio, DENT_BIT_SHIFT)

fs/f2fs/node.h

407

static inline void __set_mark(const struct folio *folio, bool mark, int type)

fs/f2fs/node.h

409

struct f2fs_node *rn = F2FS_NODE(folio);

fs/f2fs/node.h

419

static inline void set_cold_node(const struct folio *folio, bool is_dir)

fs/f2fs/node.h

421

__set_mark(folio, !is_dir, COLD_BIT_SHIFT);

fs/f2fs/node.h

424

static inline void set_mark(struct folio *folio, bool mark, int type)

fs/f2fs/node.h

426

__set_mark(folio, mark, type);

fs/f2fs/node.h

429

f2fs_inode_chksum_set(F2FS_F_SB(folio), folio);

fs/f2fs/node.h

432

#define set_dentry_mark(folio, mark) set_mark(folio, mark, DENT_BIT_SHIFT)

fs/f2fs/node.h

433

#define set_fsync_mark(folio, mark) set_mark(folio, mark, FSYNC_BIT_SHIFT)

fs/f2fs/recovery.c

161

static int recover_dentry(struct inode *inode, struct folio *ifolio,

fs/f2fs/recovery.c

169

struct folio *folio;

fs/f2fs/recovery.c

191

de = __f2fs_find_entry(dir, &fname, &folio);

fs/f2fs/recovery.c

216

f2fs_delete_entry(de, folio, dir, einode);

fs/f2fs/recovery.c

219

} else if (IS_ERR(folio)) {

fs/f2fs/recovery.c

220

err = PTR_ERR(folio);

fs/f2fs/recovery.c

230

f2fs_folio_put(folio, false);

fs/f2fs/recovery.c

242

static int recover_quota_data(struct inode *inode, struct folio *folio)

fs/f2fs/recovery.c

244

struct f2fs_inode *raw = F2FS_INODE(folio);

fs/f2fs/recovery.c

281

static int recover_inode(struct inode *inode, struct folio *folio)

fs/f2fs/recovery.c

283

struct f2fs_inode *raw = F2FS_INODE(folio);

fs/f2fs/recovery.c

290

err = recover_quota_data(inode, folio);

fs/f2fs/recovery.c

337

name = F2FS_INODE(folio)->i_name;

fs/f2fs/recovery.c

340

ino_of_node(folio), name, raw->i_inline);

fs/f2fs/recovery.c

368

struct folio *folio;

fs/f2fs/recovery.c

375

folio = f2fs_get_tmp_folio(sbi, *blkaddr_fast);

fs/f2fs/recovery.c

376

if (IS_ERR(folio))

fs/f2fs/recovery.c

377

return PTR_ERR(folio);

fs/f2fs/recovery.c

379

if (!is_recoverable_dnode(folio)) {

fs/f2fs/recovery.c

380

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

386

next_blkaddr_of_node(folio));

fs/f2fs/recovery.c

388

*blkaddr_fast = next_blkaddr_of_node(folio);

fs/f2fs/recovery.c

389

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

417

struct folio *folio;

fs/f2fs/recovery.c

422

folio = f2fs_get_tmp_folio(sbi, blkaddr);

fs/f2fs/recovery.c

423

if (IS_ERR(folio)) {

fs/f2fs/recovery.c

424

err = PTR_ERR(folio);

fs/f2fs/recovery.c

428

if (!is_recoverable_dnode(folio)) {

fs/f2fs/recovery.c

429

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

433

if (!is_fsync_dnode(folio))

fs/f2fs/recovery.c

436

entry = get_fsync_inode(head, ino_of_node(folio));

fs/f2fs/recovery.c

441

IS_INODE(folio) &&

fs/f2fs/recovery.c

442

is_dent_dnode(folio)) {

fs/f2fs/recovery.c

443

err = f2fs_recover_inode_page(sbi, folio);

fs/f2fs/recovery.c

445

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

451

entry = add_fsync_inode(sbi, head, ino_of_node(folio),

fs/f2fs/recovery.c

464

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

470

if (IS_INODE(folio) && is_dent_dnode(folio))

fs/f2fs/recovery.c

474

blkaddr = next_blkaddr_of_node(folio);

fs/f2fs/recovery.c

475

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

501

struct folio *sum_folio, *node_folio;

fs/f2fs/recovery.c

627

struct folio *folio)

fs/f2fs/recovery.c

635

if (IS_INODE(folio)) {

fs/f2fs/recovery.c

636

err = f2fs_recover_inline_xattr(inode, folio);

fs/f2fs/recovery.c

639

} else if (f2fs_has_xattr_block(ofs_of_node(folio))) {

fs/f2fs/recovery.c

640

err = f2fs_recover_xattr_data(inode, folio);

fs/f2fs/recovery.c

647

err = f2fs_recover_inline_data(inode, folio);

fs/f2fs/recovery.c

655

start = f2fs_start_bidx_of_node(ofs_of_node(folio), inode);

fs/f2fs/recovery.c

656

end = start + ADDRS_PER_PAGE(folio, inode);

fs/f2fs/recovery.c

675

f2fs_bug_on(sbi, ni.ino != ino_of_node(folio));

fs/f2fs/recovery.c

677

if (ofs_of_node(dn.node_folio) != ofs_of_node(folio)) {

fs/f2fs/recovery.c

680

ofs_of_node(folio));

fs/f2fs/recovery.c

691

dest = data_blkaddr(dn.inode, folio, dn.ofs_in_node);

fs/f2fs/recovery.c

766

copy_node_footer(dn.node_folio, folio);

fs/f2fs/recovery.c

768

ofs_of_node(folio), false);

fs/f2fs/recovery.c

775

inode->i_ino, nid_of_node(folio),

fs/f2fs/recovery.c

803

struct folio *folio;

fs/f2fs/recovery.c

808

folio = f2fs_get_tmp_folio(sbi, blkaddr);

fs/f2fs/recovery.c

809

if (IS_ERR(folio)) {

fs/f2fs/recovery.c

810

err = PTR_ERR(folio);

fs/f2fs/recovery.c

814

if (!is_recoverable_dnode(folio)) {

fs/f2fs/recovery.c

815

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

820

entry = get_fsync_inode(inode_list, ino_of_node(folio));

fs/f2fs/recovery.c

829

if (IS_INODE(folio)) {

fs/f2fs/recovery.c

830

err = recover_inode(entry->inode, folio);

fs/f2fs/recovery.c

832

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

838

err = recover_dentry(entry->inode, folio, dir_list);

fs/f2fs/recovery.c

840

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

845

err = do_recover_data(sbi, entry->inode, folio);

fs/f2fs/recovery.c

847

f2fs_folio_put(folio, true);

fs/f2fs/recovery.c

856

next_blkaddr_of_node(folio));

fs/f2fs/recovery.c

859

blkaddr = next_blkaddr_of_node(folio);

fs/f2fs/recovery.c

860

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

2685

struct folio *f2fs_get_sum_folio(struct f2fs_sb_info *sbi, unsigned int segno)

fs/f2fs/segment.c

2695

struct folio *folio;

fs/f2fs/segment.c

2698

folio = f2fs_grab_meta_folio(sbi, blk_addr);

fs/f2fs/segment.c

2700

folio = f2fs_get_meta_folio_retry(sbi, blk_addr);

fs/f2fs/segment.c

2702

if (IS_ERR(folio))

fs/f2fs/segment.c

2705

memcpy(folio_address(folio), src, PAGE_SIZE);

fs/f2fs/segment.c

2706

folio_mark_dirty(folio);

fs/f2fs/segment.c

2707

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

2713

struct folio *folio;

fs/f2fs/segment.c

2719

folio = f2fs_get_sum_folio(sbi, segno);

fs/f2fs/segment.c

2720

if (IS_ERR(folio))

fs/f2fs/segment.c

2723

memcpy(SUM_BLK_PAGE_ADDR(sbi, folio, segno), sum_blk,

fs/f2fs/segment.c

2725

folio_mark_dirty(folio);

fs/f2fs/segment.c

2726

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

2733

struct folio *folio = f2fs_grab_meta_folio(sbi, blk_addr);

fs/f2fs/segment.c

2737

dst = folio_address(folio);

fs/f2fs/segment.c

2751

folio_mark_dirty(folio);

fs/f2fs/segment.c

2752

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

3048

struct folio *sum_folio;

fs/f2fs/segment.c

3656

if (IS_DNODE(fio->folio) && is_cold_node(fio->folio))

fs/f2fs/segment.c

3702

type = __get_age_segment_type(inode, fio->folio->index);

fs/f2fs/segment.c

3714

if (IS_DNODE(fio->folio))

fs/f2fs/segment.c

3715

return is_cold_node(fio->folio) ? CURSEG_WARM_NODE :

fs/f2fs/segment.c

3783

int f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/segment.c

3891

if (folio && IS_NODESEG(curseg->seg_type)) {

fs/f2fs/segment.c

3892

fill_node_footer_blkaddr(folio, NEXT_FREE_BLKADDR(sbi, curseg));

fs/f2fs/segment.c

3894

f2fs_inode_chksum_set(sbi, folio);

fs/f2fs/segment.c

3972

struct folio *folio = fio->folio;

fs/f2fs/segment.c

3982

err = f2fs_allocate_data_block(fio->sbi, folio, fio->old_blkaddr,

fs/f2fs/segment.c

3987

__func__, fio->ino, folio->index, type,

fs/f2fs/segment.c

3989

if (fscrypt_inode_uses_fs_layer_crypto(folio->mapping->host))

fs/f2fs/segment.c

3991

folio_end_writeback(folio);

fs/f2fs/segment.c

3992

if (f2fs_in_warm_node_list(folio))

fs/f2fs/segment.c

3993

f2fs_del_fsync_node_entry(fio->sbi, folio);

fs/f2fs/segment.c

4014

void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/segment.c

4023

.old_blkaddr = folio->index,

fs/f2fs/segment.c

4024

.new_blkaddr = folio->index,

fs/f2fs/segment.c

4025

.folio = folio,

fs/f2fs/segment.c

4030

if (unlikely(folio->index >= MAIN_BLKADDR(sbi)))

fs/f2fs/segment.c

4033

folio_start_writeback(folio);

fs/f2fs/segment.c

4036

stat_inc_meta_count(sbi, folio->index);

fs/f2fs/segment.c

4237

void f2fs_folio_wait_writeback(struct folio *folio, enum page_type type,

fs/f2fs/segment.c

4240

if (folio_test_writeback(folio)) {

fs/f2fs/segment.c

4241

struct f2fs_sb_info *sbi = F2FS_F_SB(folio);

fs/f2fs/segment.c

4244

f2fs_submit_merged_write_folio(sbi, folio, type);

fs/f2fs/segment.c

4246

f2fs_submit_merged_ipu_write(sbi, NULL, folio);

fs/f2fs/segment.c

4248

folio_wait_writeback(folio);

fs/f2fs/segment.c

4249

f2fs_bug_on(sbi, locked && folio_test_writeback(folio));

fs/f2fs/segment.c

4251

folio_wait_stable(folio);

fs/f2fs/segment.c

4259

struct folio *cfolio;

fs/f2fs/segment.c

4294

struct folio *folio;

fs/f2fs/segment.c

4300

folio = f2fs_get_meta_folio(sbi, start++);

fs/f2fs/segment.c

4301

if (IS_ERR(folio))

fs/f2fs/segment.c

4302

return PTR_ERR(folio);

fs/f2fs/segment.c

4303

kaddr = folio_address(folio);

fs/f2fs/segment.c

4340

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

4342

folio = f2fs_get_meta_folio(sbi, start++);

fs/f2fs/segment.c

4343

if (IS_ERR(folio))

fs/f2fs/segment.c

4344

return PTR_ERR(folio);

fs/f2fs/segment.c

4345

kaddr = folio_address(folio);

fs/f2fs/segment.c

4349

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

4358

struct folio *new;

fs/f2fs/segment.c

4474

struct folio *folio;

fs/f2fs/segment.c

4481

folio = f2fs_grab_meta_folio(sbi, blkaddr++);

fs/f2fs/segment.c

4482

kaddr = folio_address(folio);

fs/f2fs/segment.c

4499

if (!folio) {

fs/f2fs/segment.c

4500

folio = f2fs_grab_meta_folio(sbi, blkaddr++);

fs/f2fs/segment.c

4501

kaddr = folio_address(folio);

fs/f2fs/segment.c

4513

folio_mark_dirty(folio);

fs/f2fs/segment.c

4514

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

4515

folio = NULL;

fs/f2fs/segment.c

4518

if (folio) {

fs/f2fs/segment.c

4519

folio_mark_dirty(folio);

fs/f2fs/segment.c

4520

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

4574

static struct folio *get_current_sit_folio(struct f2fs_sb_info *sbi,

fs/f2fs/segment.c

4580

static struct folio *get_next_sit_folio(struct f2fs_sb_info *sbi,

fs/f2fs/segment.c

4584

struct folio *folio;

fs/f2fs/segment.c

4590

folio = f2fs_grab_meta_folio(sbi, dst_off);

fs/f2fs/segment.c

4591

seg_info_to_sit_folio(sbi, folio, start);

fs/f2fs/segment.c

4593

folio_mark_dirty(folio);

fs/f2fs/segment.c

4596

return folio;

fs/f2fs/segment.c

4726

struct folio *folio = NULL;

fs/f2fs/segment.c

4741

folio = get_next_sit_folio(sbi, start_segno);

fs/f2fs/segment.c

4742

raw_sit = folio_address(folio);

fs/f2fs/segment.c

4787

f2fs_folio_put(folio, true);

fs/f2fs/segment.c

4986

struct folio *folio;

fs/f2fs/segment.c

4989

folio = get_current_sit_folio(sbi, start);

fs/f2fs/segment.c

4990

if (IS_ERR(folio))

fs/f2fs/segment.c

4991

return PTR_ERR(folio);

fs/f2fs/segment.c

4992

sit_blk = folio_address(folio);

fs/f2fs/segment.c

4994

f2fs_folio_put(folio, true);

fs/f2fs/segment.h

421

struct folio *folio, unsigned int start)

fs/f2fs/segment.h

430

raw_sit = folio_address(folio);

fs/f2fs/segment.h

96

#define SUM_BLK_PAGE_ADDR(sbi, folio, segno) \

fs/f2fs/segment.h

97

(folio_address(folio) + GET_SUM_BLKOFF(sbi, segno) * (sbi)->sum_blocksize)

fs/f2fs/super.c

3166

struct folio *folio;

fs/f2fs/super.c

3170

folio = mapping_read_folio_gfp(mapping, off >> PAGE_SHIFT,

fs/f2fs/super.c

3172

if (IS_ERR(folio)) {

fs/f2fs/super.c

3173

if (PTR_ERR(folio) == -ENOMEM) {

fs/f2fs/super.c

3178

return PTR_ERR(folio);

fs/f2fs/super.c

3180

offset = offset_in_folio(folio, off);

fs/f2fs/super.c

3181

tocopy = min(folio_size(folio) - offset, toread);

fs/f2fs/super.c

3183

folio_lock(folio);

fs/f2fs/super.c

3185

if (unlikely(folio->mapping != mapping)) {

fs/f2fs/super.c

3186

f2fs_folio_put(folio, true);

fs/f2fs/super.c

3194

f2fs_bug_on(F2FS_SB(sb), !folio_test_uptodate(folio));

fs/f2fs/super.c

3196

memcpy_from_folio(data, folio, offset, tocopy);

fs/f2fs/super.c

3197

f2fs_folio_put(folio, true);

fs/f2fs/super.c

3215

struct folio *folio;

fs/f2fs/super.c

3225

&folio, &fsdata);

fs/f2fs/super.c

3235

memcpy_to_folio(folio, offset_in_folio(folio, off), data, tocopy);

fs/f2fs/super.c

3238

folio, fsdata);

fs/f2fs/super.c

3876

static int __f2fs_commit_super(struct f2fs_sb_info *sbi, struct folio *folio,

fs/f2fs/super.c

3884

folio_lock(folio);

fs/f2fs/super.c

3885

folio_wait_writeback(folio);

fs/f2fs/super.c

3887

memcpy(F2FS_SUPER_BLOCK(folio, index), F2FS_RAW_SUPER(sbi),

fs/f2fs/super.c

3889

folio_mark_dirty(folio);

fs/f2fs/super.c

3890

folio_clear_dirty_for_io(folio);

fs/f2fs/super.c

3891

folio_start_writeback(folio);

fs/f2fs/super.c

3892

folio_unlock(folio);

fs/f2fs/super.c

3897

bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(folio->index);

fs/f2fs/super.c

3899

if (!bio_add_folio(bio, folio, folio_size(folio), 0))

fs/f2fs/super.c

3904

folio_end_writeback(folio);

fs/f2fs/super.c

3910

struct folio *folio, pgoff_t index)

fs/f2fs/super.c

3912

struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);

fs/f2fs/super.c

3987

err = __f2fs_commit_super(sbi, folio, index, false);

fs/f2fs/super.c

4000

struct folio *folio, pgoff_t index)

fs/f2fs/super.c

4004

struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);

fs/f2fs/super.c

4162

if (sanity_check_area_boundary(sbi, folio, index))

fs/f2fs/super.c

4537

struct folio *folio;

fs/f2fs/super.c

4546

folio = read_mapping_folio(sb->s_bdev->bd_mapping, block, NULL);

fs/f2fs/super.c

4547

if (IS_ERR(folio)) {

fs/f2fs/super.c

4550

err = PTR_ERR(folio);

fs/f2fs/super.c

4556

err = sanity_check_raw_super(sbi, folio, block);

fs/f2fs/super.c

4560

folio_put(folio);

fs/f2fs/super.c

4566

memcpy(super, F2FS_SUPER_BLOCK(folio, block),

fs/f2fs/super.c

4571

folio_put(folio);

fs/f2fs/super.c

4585

struct folio *folio;

fs/f2fs/super.c

4605

folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);

fs/f2fs/super.c

4606

if (IS_ERR(folio))

fs/f2fs/super.c

4607

return PTR_ERR(folio);

fs/f2fs/super.c

4608

err = __f2fs_commit_super(sbi, folio, index, true);

fs/f2fs/super.c

4609

folio_put(folio);

fs/f2fs/super.c

4617

folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);

fs/f2fs/super.c

4618

if (IS_ERR(folio))

fs/f2fs/super.c

4619

return PTR_ERR(folio);

fs/f2fs/super.c

4620

err = __f2fs_commit_super(sbi, folio, index, true);

fs/f2fs/super.c

4621

folio_put(folio);

fs/f2fs/verity.c

84

struct folio *folio;

fs/f2fs/verity.c

88

res = aops->write_begin(NULL, mapping, pos, n, &folio, &fsdata);

fs/f2fs/verity.c

92

memcpy_to_folio(folio, offset_in_folio(folio, pos), buf, n);

fs/f2fs/verity.c

94

res = aops->write_end(NULL, mapping, pos, n, n, folio, fsdata);

fs/f2fs/xattr.c

141

void *folio)

fs/f2fs/xattr.c

149

xattr->value_len, folio, 0);

fs/f2fs/xattr.c

157

const struct qstr *qstr, struct folio *ifolio)

fs/f2fs/xattr.c

276

static int read_inline_xattr(struct inode *inode, struct folio *ifolio,

fs/f2fs/xattr.c

281

struct folio *folio = NULL;

fs/f2fs/xattr.c

287

folio = f2fs_get_inode_folio(sbi, inode->i_ino);

fs/f2fs/xattr.c

288

if (IS_ERR(folio))

fs/f2fs/xattr.c

289

return PTR_ERR(folio);

fs/f2fs/xattr.c

291

inline_addr = inline_xattr_addr(inode, folio);

fs/f2fs/xattr.c

294

f2fs_folio_put(folio, true);

fs/f2fs/xattr.c

304

struct folio *xfolio;

fs/f2fs/xattr.c

319

static int lookup_all_xattrs(struct inode *inode, struct folio *ifolio,

fs/f2fs/xattr.c

391

static int read_all_xattrs(struct inode *inode, struct folio *ifolio,

fs/f2fs/xattr.c

435

void *txattr_addr, struct folio *ifolio)

fs/f2fs/xattr.c

439

struct folio *in_folio = NULL;

fs/f2fs/xattr.c

442

struct folio *xfolio;

fs/f2fs/xattr.c

518

void *buffer, size_t buffer_size, struct folio *ifolio)

fs/f2fs/xattr.c

635

struct folio *ifolio, int flags)

fs/f2fs/xattr.c

810

struct folio *ifolio, int flags)

fs/f2fs/xattr.h

133

size_t, struct folio *, int);

fs/f2fs/xattr.h

135

size_t, struct folio *);

fs/f2fs/xattr.h

145

struct folio *folio, int flags)

fs/f2fs/xattr.h

151

size_t buffer_size, struct folio *dfolio)

fs/f2fs/xattr.h

161

const struct qstr *, struct folio *);

fs/f2fs/xattr.h

164

const struct qstr *qstr, struct folio *ifolio)

fs/fat/inode.c

203

static int fat_read_folio(struct file *file, struct folio *folio)

fs/fat/inode.c

205

return mpage_read_folio(folio, fat_get_block);

fs/fat/inode.c

226

struct folio **foliop, void **fsdata)

fs/fat/inode.c

241

struct folio *folio, void *fsdata)

fs/fat/inode.c

245

err = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/freevxfs/vxfs_immed.c

31

static int vxfs_immed_read_folio(struct file *fp, struct folio *folio)

fs/freevxfs/vxfs_immed.c

33

struct vxfs_inode_info *vip = VXFS_INO(folio->mapping->host);

fs/freevxfs/vxfs_immed.c

34

void *src = vip->vii_immed.vi_immed + folio_pos(folio);

fs/freevxfs/vxfs_immed.c

37

for (i = 0; i < folio_nr_pages(folio); i++) {

fs/freevxfs/vxfs_immed.c

38

memcpy_to_page(folio_page(folio, i), 0, src, PAGE_SIZE);

fs/freevxfs/vxfs_immed.c

42

folio_mark_uptodate(folio);

fs/freevxfs/vxfs_immed.c

43

folio_unlock(folio);

fs/freevxfs/vxfs_subr.c

128

static int vxfs_read_folio(struct file *file, struct folio *folio)

fs/freevxfs/vxfs_subr.c

130

return block_read_full_folio(folio, vxfs_getblk);

fs/freevxfs/vxfs_subr.c

17

static int vxfs_read_folio(struct file *, struct folio *);

fs/fs-writeback.c

1014

css = get_mem_cgroup_css_from_folio(folio);

fs/fs-writeback.c

275

void __inode_attach_wb(struct inode *inode, struct folio *folio)

fs/fs-writeback.c

284

if (folio)

fs/fs-writeback.c

285

memcg_css = get_mem_cgroup_css_from_folio(folio);

fs/fs-writeback.c

410

struct folio *folio;

fs/fs-writeback.c

430

xas_for_each_marked(&xas, folio, ULONG_MAX, PAGECACHE_TAG_DIRTY) {

fs/fs-writeback.c

431

if (folio_test_dirty(folio)) {

fs/fs-writeback.c

432

long nr = folio_nr_pages(folio);

fs/fs-writeback.c

435

if (folio_test_dropbehind(folio)) {

fs/fs-writeback.c

443

xas_for_each_marked(&xas, folio, ULONG_MAX, PAGECACHE_TAG_WRITEBACK) {

fs/fs-writeback.c

444

long nr = folio_nr_pages(folio);

fs/fs-writeback.c

445

WARN_ON_ONCE(!folio_test_writeback(folio));

fs/fs-writeback.c

999

void wbc_account_cgroup_owner(struct writeback_control *wbc, struct folio *folio,

fs/fuse/args.h

60

struct folio **folios;

fs/fuse/cuse.c

308

struct folio *folio;

fs/fuse/cuse.c

331

struct folio *folio = ap->folios[0];

fs/fuse/cuse.c

348

rc = cuse_parse_devinfo(folio_address(folio), ap->args.out_args[1].size,

fs/fuse/cuse.c

416

folio_put(folio);

fs/fuse/cuse.c

436

struct folio *folio;

fs/fuse/cuse.c

445

folio = folio_alloc(GFP_KERNEL | __GFP_ZERO, 0);

fs/fuse/cuse.c

446

if (!folio)

fs/fuse/cuse.c

468

ap->folios = &ia->folio;

fs/fuse/cuse.c

470

ia->folio = folio;

fs/fuse/cuse.c

479

folio_put(folio);

fs/fuse/dev.c

1087

static int fuse_check_folio(struct folio *folio)

fs/fuse/dev.c

1089

if (folio_mapped(folio) ||

fs/fuse/dev.c

1090

folio->mapping != NULL ||

fs/fuse/dev.c

1091

(folio->flags.f & PAGE_FLAGS_CHECK_AT_PREP &

fs/fuse/dev.c

1100

dump_page(&folio->page, "fuse: trying to steal weird page");

fs/fuse/dev.c

1112

static int fuse_try_move_folio(struct fuse_copy_state *cs, struct folio **foliop)

fs/fuse/dev.c

1115

struct folio *oldfolio = *foliop;

fs/fuse/dev.c

1116

struct folio *newfolio;

fs/fuse/dev.c

1209

static int fuse_ref_folio(struct fuse_copy_state *cs, struct folio *folio,

fs/fuse/dev.c

1218

folio_get(folio);

fs/fuse/dev.c

1221

folio_put(folio);

fs/fuse/dev.c

1228

buf->page = &folio->page;

fs/fuse/dev.c

1243

int fuse_copy_folio(struct fuse_copy_state *cs, struct folio **foliop,

fs/fuse/dev.c

1247

struct folio *folio = *foliop;

fs/fuse/dev.c

1250

if (folio) {

fs/fuse/dev.c

1251

size = folio_size(folio);

fs/fuse/dev.c

1253

folio_zero_range(folio, 0, size);

fs/fuse/dev.c

1257

if (cs->write && cs->pipebufs && folio) {

fs/fuse/dev.c

1267

return fuse_ref_folio(cs, folio, offset, count);

fs/fuse/dev.c

1270

if (cs->move_folios && folio &&

fs/fuse/dev.c

1281

if (folio) {

fs/fuse/dev.c

1282

void *mapaddr = kmap_local_folio(folio, offset);

fs/fuse/dev.c

1287

if (folio_test_highmem(folio) && count > PAGE_SIZE - offset_in_page(offset))

fs/fuse/dev.c

1297

if (folio && !cs->write)

fs/fuse/dev.c

1298

flush_dcache_folio(folio);

fs/fuse/dev.h

18

struct folio;

fs/fuse/dev.h

92

int fuse_copy_folio(struct fuse_copy_state *cs, struct folio **foliop,

fs/fuse/dir.c

1811

static int fuse_readlink_folio(struct inode *inode, struct folio *folio)

fs/fuse/dir.c

1814

struct fuse_folio_desc desc = { .length = folio_size(folio) - 1 };

fs/fuse/dir.c

1817

.folios = &folio,

fs/fuse/dir.c

1840

link = folio_address(folio);

fs/fuse/dir.c

1850

struct folio *folio;

fs/fuse/dir.c

1864

folio = folio_alloc(GFP_KERNEL, 0);

fs/fuse/dir.c

1866

if (!folio)

fs/fuse/dir.c

1869

err = fuse_readlink_folio(inode, folio);

fs/fuse/dir.c

1871

folio_put(folio);

fs/fuse/dir.c

1875

set_delayed_call(callback, page_put_link, folio);

fs/fuse/dir.c

1877

return folio_address(folio);

fs/fuse/dir.c

2468

static int fuse_symlink_read_folio(struct file *null, struct folio *folio)

fs/fuse/dir.c

2470

int err = fuse_readlink_folio(folio->mapping->host, folio);

fs/fuse/dir.c

2473

folio_mark_uptodate(folio);

fs/fuse/dir.c

2475

folio_unlock(folio);

fs/fuse/file.c

1002

folio_unlock(folio);

fs/fuse/file.c

1012

struct folio *folio, loff_t pos,

fs/fuse/file.c

1016

size_t off = offset_in_folio(folio, pos);

fs/fuse/file.c

1018

return fuse_do_readfolio(file, folio, off, len);

fs/fuse/file.c

1242

struct folio *folio = ap->folios[i];

fs/fuse/file.c

1245

folio_clear_uptodate(folio);

fs/fuse/file.c

1247

if (count >= folio_size(folio) - offset)

fs/fuse/file.c

1248

count -= folio_size(folio) - offset;

fs/fuse/file.c

1251

folio_clear_uptodate(folio);

fs/fuse/file.c

1257

folio_unlock(folio);

fs/fuse/file.c

1258

folio_put(folio);

fs/fuse/file.c

1281

struct folio *folio;

fs/fuse/file.c

1287

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/fuse/file.c

1289

if (IS_ERR(folio)) {

fs/fuse/file.c

1290

err = PTR_ERR(folio);

fs/fuse/file.c

1295

flush_dcache_folio(folio);

fs/fuse/file.c

1297

folio_offset = offset_in_folio(folio, pos);

fs/fuse/file.c

1298

bytes = min(folio_size(folio) - folio_offset, num);

fs/fuse/file.c

1300

tmp = copy_folio_from_iter_atomic(folio, folio_offset, bytes, ii);

fs/fuse/file.c

1301

flush_dcache_folio(folio);

fs/fuse/file.c

1304

folio_unlock(folio);

fs/fuse/file.c

1305

folio_put(folio);

fs/fuse/file.c

1319

ap->folios[ap->num_folios] = folio;

fs/fuse/file.c

1329

if (tmp == folio_size(folio))

fs/fuse/file.c

1330

folio_mark_uptodate(folio);

fs/fuse/file.c

1332

if (folio_test_uptodate(folio)) {

fs/fuse/file.c

1333

folio_unlock(folio);

fs/fuse/file.c

1340

if (folio_offset + tmp != folio_size(folio))

fs/fuse/file.c

1631

struct folio *folio = page_folio(pages[i]);

fs/fuse/file.c

1633

(folio_page_idx(folio, pages[i]) << PAGE_SHIFT);

fs/fuse/file.c

1638

ap->folios[ap->num_folios] = folio;

fs/fuse/file.c

2102

static void fuse_writepage_args_page_fill(struct fuse_writepage_args *wpa, struct folio *folio,

fs/fuse/file.c

2107

ap->folios[folio_index] = folio;

fs/fuse/file.c

2112

static struct fuse_writepage_args *fuse_writepage_args_setup(struct folio *folio,

fs/fuse/file.c

2116

struct inode *inode = folio->mapping->host;

fs/fuse/file.c

2126

fuse_write_args_fill(&wpa->ia, ff, folio_pos(folio) + offset, 0);

fs/fuse/file.c

2154

struct folio **folios;

fs/fuse/file.c

2166

memcpy(folios, ap->folios, sizeof(struct folio *) * ap->num_folios);

fs/fuse/file.c

2192

struct folio *prev_folio;

fs/fuse/file.c

2221

struct folio *folio, u64 pos,

fs/fuse/file.c

2230

loff_t offset = offset_in_folio(folio, pos);

fs/fuse/file.c

2261

wpa = fuse_writepage_args_setup(folio, offset, data->ff);

fs/fuse/file.c

2269

fuse_writepage_args_page_fill(wpa, folio, ap->num_folios,

fs/fuse/file.c

2327

static int fuse_launder_folio(struct folio *folio)

fs/fuse/file.c

2332

.inode = folio->mapping->host,

fs/fuse/file.c

2338

if (folio_clear_dirty_for_io(folio)) {

fs/fuse/file.c

2339

err = iomap_writeback_folio(&wpc, folio);

fs/fuse/file.c

2342

folio_wait_writeback(folio);

fs/fuse/file.c

2376

struct folio *folio = page_folio(vmf->page);

fs/fuse/file.c

2380

folio_lock(folio);

fs/fuse/file.c

2381

if (folio->mapping != inode->i_mapping) {

fs/fuse/file.c

2382

folio_unlock(folio);

fs/fuse/file.c

2386

folio_wait_writeback(folio);

fs/fuse/file.c

844

static int fuse_do_readfolio(struct file *file, struct folio *folio,

fs/fuse/file.c

847

struct inode *inode = folio->mapping->host;

fs/fuse/file.c

849

loff_t pos = folio_pos(folio) + off;

fs/fuse/file.c

858

.ap.folios = &folio,

fs/fuse/file.c

913

static int fuse_handle_readahead(struct folio *folio,

fs/fuse/file.c

919

size_t off = offset_in_folio(folio, pos);

fs/fuse/file.c

947

folio_get(folio);

fs/fuse/file.c

949

ap->folios[ap->num_folios] = folio;

fs/fuse/file.c

963

struct folio *folio = ctx->cur_folio;

fs/fuse/file.c

965

size_t off = offset_in_folio(folio, pos);

fs/fuse/file.c

970

ret = fuse_handle_readahead(folio, ctx->rac, data, pos, len);

fs/fuse/file.c

977

ret = fuse_do_readfolio(file, folio, off, len);

fs/fuse/file.c

979

iomap_finish_folio_read(folio, off, len, ret);

fs/fuse/file.c

988

static int fuse_read_folio(struct file *file, struct folio *folio)

fs/fuse/file.c

990

struct inode *inode = folio->mapping->host;

fs/fuse/file.c

995

.cur_folio = folio,

fs/fuse/fuse_i.h

871

static inline struct folio **fuse_folios_alloc(unsigned int nfolios, gfp_t flags,

fs/fuse/fuse_i.h

874

struct folio **folios;

fs/fuse/fuse_i.h

876

folios = kzalloc(nfolios * (sizeof(struct folio *) +

fs/fuse/notify.c

178

struct folio *folio;

fs/fuse/notify.c

183

folio = filemap_grab_folio(mapping, index);

fs/fuse/notify.c

184

err = PTR_ERR(folio);

fs/fuse/notify.c

185

if (IS_ERR(folio))

fs/fuse/notify.c

188

folio_offset = offset_in_folio(folio, pos);

fs/fuse/notify.c

189

nr_bytes = min(num, folio_size(folio) - folio_offset);

fs/fuse/notify.c

191

err = fuse_copy_folio(cs, &folio, folio_offset, nr_bytes, 0);

fs/fuse/notify.c

192

if (!folio_test_uptodate(folio) && !err && folio_offset == 0 &&

fs/fuse/notify.c

193

(nr_bytes == folio_size(folio) || file_size == end)) {

fs/fuse/notify.c

194

folio_zero_segment(folio, nr_bytes, folio_size(folio));

fs/fuse/notify.c

195

folio_mark_uptodate(folio);

fs/fuse/notify.c

197

folio_unlock(folio);

fs/fuse/notify.c

198

folio_put(folio);

fs/fuse/notify.c

278

struct folio *folio;

fs/fuse/notify.c

283

folio = filemap_get_folio(mapping, index);

fs/fuse/notify.c

284

if (IS_ERR(folio))

fs/fuse/notify.c

286

if (!folio_test_uptodate(folio)) {

fs/fuse/notify.c

287

folio_put(folio);

fs/fuse/notify.c

291

folio_offset = offset_in_folio(folio, pos);

fs/fuse/notify.c

292

nr_bytes = min(folio_size(folio) - folio_offset, num);

fs/fuse/notify.c

294

ap->folios[ap->num_folios] = folio;

fs/fuse/virtio_fs.c

1346

struct folio **folios,

fs/fuse/virtio_fs.c

790

struct folio *folio;

fs/fuse/virtio_fs.c

802

folio = ap->folios[i];

fs/fuse/virtio_fs.c

803

folio_zero_segment(folio, len, thislen);

fs/gfs2/aops.c

101

static int __gfs2_jdata_write_folio(struct folio *folio,

fs/gfs2/aops.c

104

struct inode *inode = folio->mapping->host;

fs/gfs2/aops.c

107

if (folio_test_checked(folio)) {

fs/gfs2/aops.c

108

folio_clear_checked(folio);

fs/gfs2/aops.c

109

if (!folio_buffers(folio)) {

fs/gfs2/aops.c

110

create_empty_buffers(folio,

fs/gfs2/aops.c

114

gfs2_trans_add_databufs(ip->i_gl, folio, 0, folio_size(folio));

fs/gfs2/aops.c

116

return gfs2_write_jdata_folio(folio, wbc);

fs/gfs2/aops.c

131

struct folio *folio = NULL;

fs/gfs2/aops.c

138

while ((folio = writeback_iter(mapping, wbc, folio, &error))) {

fs/gfs2/aops.c

139

if (folio_test_checked(folio)) {

fs/gfs2/aops.c

140

folio_redirty_for_writepage(wbc, folio);

fs/gfs2/aops.c

141

folio_unlock(folio);

fs/gfs2/aops.c

144

error = __gfs2_jdata_write_folio(folio, wbc);

fs/gfs2/aops.c

213

struct folio *folio = fbatch->folios[i];

fs/gfs2/aops.c

215

*done_index = folio->index;

fs/gfs2/aops.c

217

folio_lock(folio);

fs/gfs2/aops.c

219

if (unlikely(folio->mapping != mapping)) {

fs/gfs2/aops.c

221

folio_unlock(folio);

fs/gfs2/aops.c

225

if (!folio_test_dirty(folio)) {

fs/gfs2/aops.c

230

if (folio_test_writeback(folio)) {

fs/gfs2/aops.c

232

folio_wait_writeback(folio);

fs/gfs2/aops.c

237

BUG_ON(folio_test_writeback(folio));

fs/gfs2/aops.c

238

if (!folio_clear_dirty_for_io(folio))

fs/gfs2/aops.c

243

ret = __gfs2_jdata_write_folio(folio, wbc);

fs/gfs2/aops.c

252

*done_index = folio_next_index(folio);

fs/gfs2/aops.c

385

static int stuffed_read_folio(struct gfs2_inode *ip, struct folio *folio)

fs/gfs2/aops.c

397

if (unlikely(folio->index)) {

fs/gfs2/aops.c

406

folio_fill_tail(folio, 0, from, dsize);

fs/gfs2/aops.c

409

folio_end_read(folio, error == 0);

fs/gfs2/aops.c

419

static int gfs2_read_folio(struct file *file, struct folio *folio)

fs/gfs2/aops.c

421

struct inode *inode = folio->mapping->host;

fs/gfs2/aops.c

427

(i_blocksize(inode) == PAGE_SIZE && !folio_buffers(folio))) {

fs/gfs2/aops.c

428

iomap_bio_read_folio(folio, &gfs2_iomap_ops);

fs/gfs2/aops.c

430

error = stuffed_read_folio(ip, folio);

fs/gfs2/aops.c

432

error = mpage_read_folio(folio, gfs2_block_map);

fs/gfs2/aops.c

459

struct folio *folio;

fs/gfs2/aops.c

461

folio = read_cache_folio(mapping, index, gfs2_read_folio, NULL);

fs/gfs2/aops.c

462

if (IS_ERR(folio)) {

fs/gfs2/aops.c

463

if (PTR_ERR(folio) == -EINTR)

fs/gfs2/aops.c

465

return PTR_ERR(folio);

fs/gfs2/aops.c

467

offset = *pos + copied - folio_pos(folio);

fs/gfs2/aops.c

468

chunk = min(size - copied, folio_size(folio) - offset);

fs/gfs2/aops.c

469

memcpy_from_folio(buf + copied, folio, offset, chunk);

fs/gfs2/aops.c

470

index = folio_next_index(folio);

fs/gfs2/aops.c

471

folio_put(folio);

fs/gfs2/aops.c

547

struct folio *folio)

fs/gfs2/aops.c

550

folio_set_checked(folio);

fs/gfs2/aops.c

551

return block_dirty_folio(mapping, folio);

fs/gfs2/aops.c

606

static void gfs2_invalidate_folio(struct folio *folio, size_t offset,

fs/gfs2/aops.c

609

struct gfs2_sbd *sdp = GFS2_SB(folio->mapping->host);

fs/gfs2/aops.c

611

int partial_page = (offset || length < folio_size(folio));

fs/gfs2/aops.c

615

BUG_ON(!folio_test_locked(folio));

fs/gfs2/aops.c

617

folio_clear_checked(folio);

fs/gfs2/aops.c

618

head = folio_buffers(folio);

fs/gfs2/aops.c

634

filemap_release_folio(folio, 0);

fs/gfs2/aops.c

648

bool gfs2_release_folio(struct folio *folio, gfp_t gfp_mask)

fs/gfs2/aops.c

650

struct address_space *mapping = folio->mapping;

fs/gfs2/aops.c

655

head = folio_buffers(folio);

fs/gfs2/aops.c

704

return try_to_free_buffers(folio);

fs/gfs2/aops.c

71

static int gfs2_write_jdata_folio(struct folio *folio,

fs/gfs2/aops.c

74

struct inode * const inode = folio->mapping->host;

fs/gfs2/aops.c

84

if (folio_pos(folio) < i_size && i_size < folio_next_pos(folio))

fs/gfs2/aops.c

85

folio_zero_segment(folio, offset_in_folio(folio, i_size),

fs/gfs2/aops.c

86

folio_size(folio));

fs/gfs2/aops.c

88

return __block_write_full_folio(inode, folio, gfs2_get_block_noalloc,

fs/gfs2/bmap.c

1000

folio_unlock(folio);

fs/gfs2/bmap.c

1001

folio_put(folio);

fs/gfs2/bmap.c

119

error = gfs2_unstuffer_folio(ip, dibh, block, folio);

fs/gfs2/bmap.c

158

struct folio *folio;

fs/gfs2/bmap.c

162

folio = filemap_grab_folio(inode->i_mapping, 0);

fs/gfs2/bmap.c

163

error = PTR_ERR(folio);

fs/gfs2/bmap.c

164

if (IS_ERR(folio))

fs/gfs2/bmap.c

166

error = __gfs2_unstuff_inode(ip, folio);

fs/gfs2/bmap.c

167

folio_unlock(folio);

fs/gfs2/bmap.c

168

folio_put(folio);

fs/gfs2/bmap.c

2507

struct folio *folio, u64 offset, unsigned int len, u64 end_pos)

fs/gfs2/bmap.c

2522

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/gfs2/bmap.c

55

u64 block, struct folio *folio)

fs/gfs2/bmap.c

59

if (!folio_test_uptodate(folio)) {

fs/gfs2/bmap.c

60

void *kaddr = kmap_local_folio(folio, 0);

fs/gfs2/bmap.c

64

memset(kaddr + dsize, 0, folio_size(folio) - dsize);

fs/gfs2/bmap.c

67

folio_mark_uptodate(folio);

fs/gfs2/bmap.c

71

struct buffer_head *bh = folio_buffers(folio);

fs/gfs2/bmap.c

74

bh = create_empty_buffers(folio,

fs/gfs2/bmap.c

83

folio_mark_dirty(folio);

fs/gfs2/bmap.c

90

static int __gfs2_unstuff_inode(struct gfs2_inode *ip, struct folio *folio)

fs/gfs2/bmap.c

963

static struct folio *

fs/gfs2/bmap.c

971

struct folio *folio;

fs/gfs2/bmap.c

982

folio = iomap_get_folio(iter, pos, len);

fs/gfs2/bmap.c

983

if (IS_ERR(folio))

fs/gfs2/bmap.c

985

return folio;

fs/gfs2/bmap.c

989

unsigned copied, struct folio *folio)

fs/gfs2/bmap.c

996

gfs2_trans_add_databufs(ip->i_gl, folio,

fs/gfs2/bmap.c

997

offset_in_folio(folio, pos),

fs/gfs2/file.c

389

static int gfs2_allocate_folio_backing(struct folio *folio, size_t length)

fs/gfs2/file.c

391

u64 pos = folio_pos(folio);

fs/gfs2/file.c

396

if (gfs2_iomap_alloc(folio->mapping->host, pos, length, &iomap))

fs/gfs2/file.c

418

struct folio *folio = page_folio(vmf->page);

fs/gfs2/file.c

423

u64 pos = folio_pos(folio);

fs/gfs2/file.c

451

if (size - pos < folio_size(folio))

fs/gfs2/file.c

454

length = folio_size(folio);

fs/gfs2/file.c

468

folio_lock(folio);

fs/gfs2/file.c

469

if (!folio_test_uptodate(folio) ||

fs/gfs2/file.c

470

folio->mapping != inode->i_mapping) {

fs/gfs2/file.c

472

folio_unlock(folio);

fs/gfs2/file.c

518

folio_lock(folio);

fs/gfs2/file.c

522

if (!folio_test_uptodate(folio) || folio->mapping != inode->i_mapping) {

fs/gfs2/file.c

527

err = gfs2_allocate_folio_backing(folio, length);

fs/gfs2/file.c

533

folio_unlock(folio);

fs/gfs2/file.c

545

folio_mark_dirty(folio);

fs/gfs2/file.c

546

folio_wait_stable(folio);

fs/gfs2/inode.h

15

bool gfs2_release_folio(struct folio *folio, gfp_t gfp_mask);

fs/gfs2/lops.c

171

static void gfs2_end_log_write_bh(struct gfs2_sbd *sdp, struct folio *folio,

fs/gfs2/lops.c

176

bh = folio_buffers(folio);

fs/gfs2/lops.c

217

struct folio *folio = page_folio(page);

fs/gfs2/lops.c

219

if (folio && folio_buffers(folio))

fs/gfs2/lops.c

220

gfs2_end_log_write_bh(sdp, folio, bvec->bv_offset,

fs/gfs2/lops.c

401

filemap_set_wb_err(fi.folio->mapping, error);

fs/gfs2/lops.c

402

folio_end_read(fi.folio, !error);

fs/gfs2/lops.c

418

struct folio *folio)

fs/gfs2/lops.c

426

VM_BUG_ON_FOLIO(folio_test_large(folio), folio);

fs/gfs2/lops.c

427

kaddr = kmap_local_folio(folio, 0);

fs/gfs2/lops.c

466

struct folio *folio;

fs/gfs2/lops.c

468

folio = filemap_get_folio(jd->jd_inode->i_mapping, index);

fs/gfs2/lops.c

470

folio_wait_locked(folio);

fs/gfs2/lops.c

471

if (!folio_test_uptodate(folio))

fs/gfs2/lops.c

475

*done = gfs2_jhead_folio_search(jd, head, folio);

fs/gfs2/lops.c

478

folio_put_refs(folio, 2);

fs/gfs2/lops.c

516

struct folio *folio = NULL;

fs/gfs2/lops.c

529

if (!folio) {

fs/gfs2/lops.c

530

folio = filemap_grab_folio(mapping,

fs/gfs2/lops.c

532

if (IS_ERR(folio)) {

fs/gfs2/lops.c

533

ret = PTR_ERR(folio);

fs/gfs2/lops.c

544

if (bio_add_folio(bio, folio, bsize, off))

fs/gfs2/lops.c

565

bio_add_folio_nofail(bio, folio, bsize, off);

fs/gfs2/lops.c

568

if (off == folio_size(folio))

fs/gfs2/lops.c

569

folio = NULL;

fs/gfs2/meta_io.c

131

struct folio *folio;

fs/gfs2/meta_io.c

145

folio = __filemap_get_folio(mapping, index,

fs/gfs2/meta_io.c

148

bh = folio_buffers(folio);

fs/gfs2/meta_io.c

150

bh = create_empty_buffers(folio,

fs/gfs2/meta_io.c

153

folio = __filemap_get_folio(mapping, index,

fs/gfs2/meta_io.c

155

if (IS_ERR(folio))

fs/gfs2/meta_io.c

157

bh = folio_buffers(folio);

fs/gfs2/meta_io.c

168

folio_unlock(folio);

fs/gfs2/meta_io.c

169

folio_put(folio);

fs/gfs2/meta_io.c

207

struct folio *folio = fi.folio;

fs/gfs2/meta_io.c

208

struct buffer_head *bh = folio_buffers(folio);

fs/gfs2/meta_io.c

33

static void gfs2_aspace_write_folio(struct folio *folio,

fs/gfs2/meta_io.c

378

struct folio *folio;

fs/gfs2/meta_io.c

384

folio = __filemap_get_folio(mapping, index, FGP_LOCK | FGP_ACCESSED, 0);

fs/gfs2/meta_io.c

385

if (IS_ERR(folio))

fs/gfs2/meta_io.c

387

bh = folio_buffers(folio);

fs/gfs2/meta_io.c

390

folio_unlock(folio);

fs/gfs2/meta_io.c

391

folio_put(folio);

fs/gfs2/meta_io.c

40

BUG_ON(!folio_test_locked(folio));

fs/gfs2/meta_io.c

42

head = folio_buffers(folio);

fs/gfs2/meta_io.c

58

folio_redirty_for_writepage(wbc, folio);

fs/gfs2/meta_io.c

72

BUG_ON(folio_test_writeback(folio));

fs/gfs2/meta_io.c

73

folio_start_writeback(folio);

fs/gfs2/meta_io.c

84

folio_unlock(folio);

fs/gfs2/meta_io.c

87

folio_end_writeback(folio);

fs/gfs2/meta_io.c

93

struct folio *folio = NULL;

fs/gfs2/meta_io.c

96

while ((folio = writeback_iter(mapping, wbc, folio, &error)))

fs/gfs2/meta_io.c

97

gfs2_aspace_write_folio(folio, wbc);

fs/gfs2/quota.c

746

struct folio *folio;

fs/gfs2/quota.c

755

folio = filemap_grab_folio(mapping, index);

fs/gfs2/quota.c

756

if (IS_ERR(folio))

fs/gfs2/quota.c

757

return PTR_ERR(folio);

fs/gfs2/quota.c

758

bh = folio_buffers(folio);

fs/gfs2/quota.c

760

bh = create_empty_buffers(folio, bsize, 0);

fs/gfs2/quota.c

776

folio_zero_range(folio, bnum * bsize,

fs/gfs2/quota.c

779

if (folio_test_uptodate(folio))

fs/gfs2/quota.c

796

memcpy_to_folio(folio, off, buf, bytes);

fs/gfs2/quota.c

797

flush_dcache_folio(folio);

fs/gfs2/quota.c

798

folio_unlock(folio);

fs/gfs2/quota.c

799

folio_put(folio);

fs/gfs2/quota.c

804

folio_unlock(folio);

fs/gfs2/quota.c

805

folio_put(folio);

fs/gfs2/trans.c

236

void gfs2_trans_add_databufs(struct gfs2_glock *gl, struct folio *folio,

fs/gfs2/trans.c

239

struct buffer_head *head = folio_buffers(folio);

fs/gfs2/trans.h

45

void gfs2_trans_add_databufs(struct gfs2_glock *gl, struct folio *folio,

fs/hfs/btree.c

102

len = min_t(size_t, folio_size(folio), sb->s_blocksize);

fs/hfs/btree.c

103

memcpy_to_folio(folio, offset, bh->b_data, sb->s_blocksize);

fs/hfs/btree.c

112

folio_mark_uptodate(folio);

fs/hfs/btree.c

115

head = (struct hfs_btree_header_rec *)(kmap_local_folio(folio, 0) +

fs/hfs/btree.c

156

folio_unlock(folio);

fs/hfs/btree.c

157

folio_put(folio);

fs/hfs/btree.c

163

folio_unlock(folio);

fs/hfs/btree.c

164

folio_put(folio);

fs/hfs/btree.c

24

struct folio *folio;

fs/hfs/btree.c

82

folio = filemap_grab_folio(mapping, 0);

fs/hfs/btree.c

83

if (IS_ERR(folio))

fs/hfs/btree.c

86

folio_zero_range(folio, 0, folio_size(folio));

fs/hfs/btree.c

91

size = folio_size(folio);

fs/hfs/extent.c

491

struct folio *folio;

fs/hfs/extent.c

495

res = hfs_write_begin(NULL, mapping, size + 1, 0, &folio,

fs/hfs/extent.c

499

folio, fsdata);

fs/hfs/hfs_fs.h

181

loff_t pos, unsigned int len, struct folio **foliop,

fs/hfs/inode.c

107

nidx = folio->index << (PAGE_SHIFT - tree->node_size_shift);

fs/hfs/inode.c

123

return res ? try_to_free_buffers(folio) : false;

fs/hfs/inode.c

33

static int hfs_read_folio(struct file *file, struct folio *folio)

fs/hfs/inode.c

35

return block_read_full_folio(folio, hfs_get_block);

fs/hfs/inode.c

49

loff_t pos, unsigned int len, struct folio **foliop,

fs/hfs/inode.c

68

static bool hfs_release_folio(struct folio *folio, gfp_t mask)

fs/hfs/inode.c

70

struct inode *inode = folio->mapping->host;

fs/hfs/inode.c

94

nidx = folio->index >> (tree->node_size_shift - PAGE_SHIFT);

fs/hfsplus/extents.c

557

struct folio *folio;

fs/hfsplus/extents.c

562

&folio, &fsdata);

fs/hfsplus/extents.c

566

folio, fsdata);

fs/hfsplus/hfsplus_fs.h

451

loff_t pos, unsigned len, struct folio **foliop,

fs/hfsplus/inode.c

103

nidx = folio->index <<

fs/hfsplus/inode.c

120

return res ? try_to_free_buffers(folio) : false;

fs/hfsplus/inode.c

26

static int hfsplus_read_folio(struct file *file, struct folio *folio)

fs/hfsplus/inode.c

28

return block_read_full_folio(folio, hfsplus_get_block);

fs/hfsplus/inode.c

43

unsigned len, struct folio **foliop,

fs/hfsplus/inode.c

62

static bool hfsplus_release_folio(struct folio *folio, gfp_t mask)

fs/hfsplus/inode.c

64

struct inode *inode = folio->mapping->host;

fs/hfsplus/inode.c

89

nidx = folio->index >>

fs/hostfs/hostfs_kern.c

403

struct folio *folio = NULL;

fs/hostfs/hostfs_kern.c

407

while ((folio = writeback_iter(mapping, wbc, folio, &err))) {

fs/hostfs/hostfs_kern.c

408

loff_t pos = folio_pos(folio);

fs/hostfs/hostfs_kern.c

409

size_t count = folio_size(folio);

fs/hostfs/hostfs_kern.c

416

buffer = kmap_local_folio(folio, 0);

fs/hostfs/hostfs_kern.c

419

folio_unlock(folio);

fs/hostfs/hostfs_kern.c

429

static int hostfs_read_folio(struct file *file, struct folio *folio)

fs/hostfs/hostfs_kern.c

432

loff_t start = folio_pos(folio);

fs/hostfs/hostfs_kern.c

435

buffer = kmap_local_folio(folio, 0);

fs/hostfs/hostfs_kern.c

441

buffer = folio_zero_tail(folio, bytes_read, buffer + bytes_read);

fs/hostfs/hostfs_kern.c

444

folio_end_read(folio, ret == 0);

fs/hostfs/hostfs_kern.c

451

struct folio **foliop, void **fsdata)

fs/hostfs/hostfs_kern.c

465

struct folio *folio, void *fsdata)

fs/hostfs/hostfs_kern.c

469

size_t from = offset_in_folio(folio, pos);

fs/hostfs/hostfs_kern.c

472

buffer = kmap_local_folio(folio, from);

fs/hostfs/hostfs_kern.c

476

if (!folio_test_uptodate(folio) && err == folio_size(folio))

fs/hostfs/hostfs_kern.c

477

folio_mark_uptodate(folio);

fs/hostfs/hostfs_kern.c

485

folio_unlock(folio);

fs/hostfs/hostfs_kern.c

486

folio_put(folio);

fs/hpfs/file.c

163

static int hpfs_read_folio(struct file *file, struct folio *folio)

fs/hpfs/file.c

165

return mpage_read_folio(folio, hpfs_get_block);

fs/hpfs/file.c

196

struct folio **foliop, void **fsdata)

fs/hpfs/file.c

212

struct folio *folio, void *fsdata)

fs/hpfs/file.c

216

err = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/hpfs/namei.c

479

static int hpfs_symlink_read_folio(struct file *file, struct folio *folio)

fs/hpfs/namei.c

481

char *link = folio_address(folio);

fs/hpfs/namei.c

482

struct inode *i = folio->mapping->host;

fs/hpfs/namei.c

495

folio_end_read(folio, err == 0);

fs/hugetlbfs/inode.c

1025

struct folio *dst, struct folio *src,

fs/hugetlbfs/inode.c

1049

struct folio *folio)

fs/hugetlbfs/inode.c

195

static size_t adjust_range_hwpoison(struct folio *folio, size_t offset,

fs/hugetlbfs/inode.c

198

struct page *page = folio_page(folio, offset / PAGE_SIZE);

fs/hugetlbfs/inode.c

232

struct folio *folio;

fs/hugetlbfs/inode.c

251

folio = filemap_lock_hugetlb_folio(h, mapping, index);

fs/hugetlbfs/inode.c

252

if (IS_ERR(folio)) {

fs/hugetlbfs/inode.c

259

folio_unlock(folio);

fs/hugetlbfs/inode.c

261

if (!folio_test_hwpoison(folio))

fs/hugetlbfs/inode.c

269

want = adjust_range_hwpoison(folio, offset, nr);

fs/hugetlbfs/inode.c

271

folio_put(folio);

fs/hugetlbfs/inode.c

280

copied = copy_folio_to_iter(folio, offset, want, to);

fs/hugetlbfs/inode.c

281

folio_put(folio);

fs/hugetlbfs/inode.c

300

struct folio **foliop, void **fsdata)

fs/hugetlbfs/inode.c

308

struct folio *folio, void *fsdata)

fs/hugetlbfs/inode.c

314

static void hugetlb_delete_from_page_cache(struct folio *folio)

fs/hugetlbfs/inode.c

316

folio_clear_dirty(folio);

fs/hugetlbfs/inode.c

317

folio_clear_uptodate(folio);

fs/hugetlbfs/inode.c

318

filemap_remove_folio(folio);

fs/hugetlbfs/inode.c

381

struct folio *folio, pgoff_t index)

fs/hugetlbfs/inode.c

385

unsigned long pfn = folio_pfn(folio);

fs/hugetlbfs/inode.c

498

struct address_space *mapping, struct folio *folio,

fs/hugetlbfs/inode.c

509

folio_lock(folio);

fs/hugetlbfs/inode.c

510

if (unlikely(folio_mapped(folio)))

fs/hugetlbfs/inode.c

511

hugetlb_unmap_file_folio(h, mapping, folio, index);

fs/hugetlbfs/inode.c

520

VM_BUG_ON_FOLIO(folio_test_hugetlb_restore_reserve(folio), folio);

fs/hugetlbfs/inode.c

521

hugetlb_delete_from_page_cache(folio);

fs/hugetlbfs/inode.c

528

folio_unlock(folio);

fs/hugetlbfs/inode.c

566

struct folio *folio = fbatch.folios[i];

fs/hugetlbfs/inode.c

569

index = folio->index >> huge_page_order(h);

fs/hugetlbfs/inode.c

576

remove_inode_single_folio(h, inode, mapping, folio,

fs/hugetlbfs/inode.c

630

struct folio *folio;

fs/hugetlbfs/inode.c

632

folio = filemap_lock_hugetlb_folio(h, mapping, idx);

fs/hugetlbfs/inode.c

633

if (IS_ERR(folio))

fs/hugetlbfs/inode.c

641

folio_zero_segment(folio, (size_t)start, (size_t)end);

fs/hugetlbfs/inode.c

643

folio_unlock(folio);

fs/hugetlbfs/inode.c

644

folio_put(folio);

fs/hugetlbfs/inode.c

756

struct folio *folio;

fs/hugetlbfs/inode.c

778

folio = filemap_get_folio(mapping, index << huge_page_order(h));

fs/hugetlbfs/inode.c

779

if (!IS_ERR(folio)) {

fs/hugetlbfs/inode.c

780

folio_put(folio);

fs/hugetlbfs/inode.c

793

folio = alloc_hugetlb_folio(&pseudo_vma, addr, false);

fs/hugetlbfs/inode.c

794

if (IS_ERR(folio)) {

fs/hugetlbfs/inode.c

796

error = PTR_ERR(folio);

fs/hugetlbfs/inode.c

799

folio_zero_user(folio, addr);

fs/hugetlbfs/inode.c

800

__folio_mark_uptodate(folio);

fs/hugetlbfs/inode.c

801

error = hugetlb_add_to_page_cache(folio, mapping, index);

fs/hugetlbfs/inode.c

803

restore_reserve_on_error(h, &pseudo_vma, addr, folio);

fs/hugetlbfs/inode.c

804

folio_put(folio);

fs/hugetlbfs/inode.c

811

folio_set_hugetlb_migratable(folio);

fs/hugetlbfs/inode.c

816

folio_unlock(folio);

fs/hugetlbfs/inode.c

817

folio_put(folio);

fs/internal.h

36

int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,

fs/iomap/bio.c

114

struct folio *folio = ctx->cur_folio;

fs/iomap/bio.c

115

gfp_t gfp = mapping_gfp_constraint(folio->mapping, GFP_KERNEL);

fs/iomap/bio.c

140

bio_add_folio_nofail(bio, folio, plen,

fs/iomap/bio.c

141

offset_in_folio(folio, iter->pos));

fs/iomap/bio.c

149

struct folio *folio = ctx->cur_folio;

fs/iomap/bio.c

155

!bio_add_folio(bio, folio, plen, offset_in_folio(folio, iter->pos)))

fs/iomap/bio.c

168

struct folio *folio, loff_t pos, size_t len)

fs/iomap/bio.c

178

bio_add_folio_nofail(&bio, folio, len, offset_in_folio(folio, pos));

fs/iomap/bio.c

21

iomap_finish_folio_read(fi.folio, fi.offset, fi.length, error);

fs/iomap/buffered-io.c

1002

size_t fsize = folio_size(folio);

fs/iomap/buffered-io.c

1004

WARN_ON_ONCE(pos < folio_pos(folio));

fs/iomap/buffered-io.c

1005

WARN_ON_ONCE(pos >= folio_pos(folio) + fsize);

fs/iomap/buffered-io.c

1007

*offset = offset_in_folio(folio, pos);

fs/iomap/buffered-io.c

101

mark_uptodate = ifs_set_range_uptodate(folio, ifs, off, len) &&

fs/iomap/buffered-io.c

1014

struct folio *folio)

fs/iomap/buffered-io.c

1019

return iomap_read_inline_data(iter, folio);

fs/iomap/buffered-io.c

1028

const struct iomap_write_ops *write_ops, struct folio **foliop,

fs/iomap/buffered-io.c

1034

struct folio *folio;

fs/iomap/buffered-io.c

1044

folio = __iomap_get_folio(iter, write_ops, len);

fs/iomap/buffered-io.c

1045

if (IS_ERR(folio))

fs/iomap/buffered-io.c

1046

return PTR_ERR(folio);

fs/iomap/buffered-io.c

1052

if (!folio) {

fs/iomap/buffered-io.c

107

folio_mark_uptodate(folio);

fs/iomap/buffered-io.c

1084

if (folio_pos(folio) > iter->pos) {

fs/iomap/buffered-io.c

1085

len = min_t(u64, folio_pos(folio) - iter->pos,

fs/iomap/buffered-io.c

1093

pos = iomap_trim_folio_range(iter, folio, poffset, &len);

fs/iomap/buffered-io.c

1096

status = iomap_write_begin_inline(iter, folio);

fs/iomap/buffered-io.c

1098

status = __block_write_begin_int(folio, pos, len, NULL, srcmap);

fs/iomap/buffered-io.c

1100

status = __iomap_write_begin(iter, write_ops, len, folio);

fs/iomap/buffered-io.c

1105

*foliop = folio;

fs/iomap/buffered-io.c

1110

__iomap_put_folio(iter, write_ops, 0, folio);

fs/iomap/buffered-io.c

1115

size_t copied, struct folio *folio)

fs/iomap/buffered-io.c

1117

flush_dcache_folio(folio);

fs/iomap/buffered-io.c

1130

if (unlikely(copied < len && !folio_test_uptodate(folio)))

fs/iomap/buffered-io.c

1132

iomap_set_range_uptodate(folio, offset_in_folio(folio, pos), len);

fs/iomap/buffered-io.c

1133

iomap_set_range_dirty(folio, offset_in_folio(folio, pos), copied);

fs/iomap/buffered-io.c

1134

filemap_dirty_folio(inode->i_mapping, folio);

fs/iomap/buffered-io.c

1139

struct folio *folio, loff_t pos, size_t copied)

fs/iomap/buffered-io.c

114

static unsigned ifs_next_dirty_block(struct folio *folio,

fs/iomap/buffered-io.c

1144

WARN_ON_ONCE(!folio_test_uptodate(folio));

fs/iomap/buffered-io.c

1149

flush_dcache_folio(folio);

fs/iomap/buffered-io.c

1150

addr = kmap_local_folio(folio, pos);

fs/iomap/buffered-io.c

1163

struct folio *folio)

fs/iomap/buffered-io.c

1169

return iomap_write_end_inline(iter, folio, pos, copied);

fs/iomap/buffered-io.c

117

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

1174

bh_written = block_write_end(pos, len, copied, folio);

fs/iomap/buffered-io.c

1179

return __iomap_write_end(iter->inode, pos, len, copied, folio);

fs/iomap/buffered-io.c

118

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

119

unsigned int blks = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

1192

struct folio *folio;

fs/iomap/buffered-io.c

1227

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1239

flush_dcache_folio(folio);

fs/iomap/buffered-io.c

1241

copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);

fs/iomap/buffered-io.c

1242

written = iomap_write_end(iter, bytes, copied, folio) ?

fs/iomap/buffered-io.c

1258

__iomap_put_folio(iter, write_ops, written, folio);

fs/iomap/buffered-io.c

129

static unsigned ifs_next_clean_block(struct folio *folio,

fs/iomap/buffered-io.c

132

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

133

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

134

unsigned int blks = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

1345

struct folio *folio, loff_t start_byte, loff_t end_byte,

fs/iomap/buffered-io.c

1359

ifs = folio->private;

fs/iomap/buffered-io.c

1363

last_byte = min_t(loff_t, end_byte - 1, folio_next_pos(folio) - 1);

fs/iomap/buffered-io.c

1364

first_blk = offset_in_folio(folio, start_byte) >> blkbits;

fs/iomap/buffered-io.c

1365

last_blk = offset_in_folio(folio, last_byte) >> blkbits;

fs/iomap/buffered-io.c

1366

while ((first_blk = ifs_next_clean_block(folio, first_blk, last_blk))

fs/iomap/buffered-io.c

1368

punch(inode, folio_pos(folio) + (first_blk << blkbits),

fs/iomap/buffered-io.c

1374

static void iomap_write_delalloc_punch(struct inode *inode, struct folio *folio,

fs/iomap/buffered-io.c

1378

if (!folio_test_dirty(folio))

fs/iomap/buffered-io.c

1388

iomap_write_delalloc_ifs_punch(inode, folio, start_byte, end_byte,

fs/iomap/buffered-io.c

1395

*punch_start_byte = min_t(loff_t, end_byte, folio_next_pos(folio));

fs/iomap/buffered-io.c

140

static unsigned ifs_find_dirty_range(struct folio *folio,

fs/iomap/buffered-io.c

1420

struct folio *folio;

fs/iomap/buffered-io.c

1423

folio = filemap_lock_folio(inode->i_mapping,

fs/iomap/buffered-io.c

1425

if (IS_ERR(folio)) {

fs/iomap/buffered-io.c

143

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

1431

iomap_write_delalloc_punch(inode, folio, punch_start_byte,

fs/iomap/buffered-io.c

1435

start_byte = folio_next_pos(folio);

fs/iomap/buffered-io.c

1436

folio_unlock(folio);

fs/iomap/buffered-io.c

1437

folio_put(folio);

fs/iomap/buffered-io.c

145

offset_in_folio(folio, *range_start) >> inode->i_blkbits;

fs/iomap/buffered-io.c

147

offset_in_folio(folio, range_end) >> inode->i_blkbits,

fs/iomap/buffered-io.c

148

i_blocks_per_folio(inode, folio)) - 1;

fs/iomap/buffered-io.c

151

start_blk = ifs_next_dirty_block(folio, start_blk, end_blk);

fs/iomap/buffered-io.c

157

nblks = ifs_next_clean_block(folio, start_blk + 1, end_blk) -

fs/iomap/buffered-io.c

1578

struct folio *folio;

fs/iomap/buffered-io.c

1583

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1590

ret = iomap_write_end(iter, bytes, bytes, folio);

fs/iomap/buffered-io.c

1591

__iomap_put_folio(iter, write_ops, bytes, folio);

fs/iomap/buffered-io.c

160

*range_start = folio_pos(folio) + (start_blk << inode->i_blkbits);

fs/iomap/buffered-io.c

164

static unsigned iomap_find_dirty_range(struct folio *folio, u64 *range_start,

fs/iomap/buffered-io.c

1652

struct folio *folio;

fs/iomap/buffered-io.c

1659

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1667

if (!folio) {

fs/iomap/buffered-io.c

167

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

1675

WARN_ON_ONCE(folio_pos(folio) > iter->inode->i_size);

fs/iomap/buffered-io.c

1677

trace_iomap_zero_iter(iter->inode, folio_pos(folio) + offset,

fs/iomap/buffered-io.c

1680

folio_zero_range(folio, offset, bytes);

fs/iomap/buffered-io.c

1682

folio_mark_accessed(folio);

fs/iomap/buffered-io.c

1684

ret = iomap_write_end(iter, bytes, bytes, folio);

fs/iomap/buffered-io.c

1685

__iomap_put_folio(iter, write_ops, bytes, folio);

fs/iomap/buffered-io.c

173

return ifs_find_dirty_range(folio, ifs, range_start, range_end);

fs/iomap/buffered-io.c

1803

struct folio *folio)

fs/iomap/buffered-io.c

1809

ret = __block_write_begin_int(folio, iter->pos, length, NULL,

fs/iomap/buffered-io.c

1813

block_commit_write(folio, 0, length);

fs/iomap/buffered-io.c

1815

WARN_ON_ONCE(!folio_test_uptodate(folio));

fs/iomap/buffered-io.c

1816

folio_mark_dirty(folio);

fs/iomap/buffered-io.c

1830

struct folio *folio = page_folio(vmf->page);

fs/iomap/buffered-io.c

1833

folio_lock(folio);

fs/iomap/buffered-io.c

1834

ret = folio_mkwrite_check_truncate(folio, iter.inode);

fs/iomap/buffered-io.c

1837

iter.pos = folio_pos(folio);

fs/iomap/buffered-io.c

184

static void ifs_clear_range_dirty(struct folio *folio,

fs/iomap/buffered-io.c

1840

iter.status = iomap_folio_mkwrite_iter(&iter, folio);

fs/iomap/buffered-io.c

1844

folio_wait_stable(folio);

fs/iomap/buffered-io.c

1847

folio_unlock(folio);

fs/iomap/buffered-io.c

1852

static void iomap_writeback_init(struct inode *inode, struct folio *folio)

fs/iomap/buffered-io.c

1854

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

1856

WARN_ON_ONCE(i_blocks_per_folio(inode, folio) > 1 && !ifs);

fs/iomap/buffered-io.c

1868

atomic_set(&ifs->write_bytes_pending, folio_size(folio));

fs/iomap/buffered-io.c

187

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

1872

void iomap_finish_folio_write(struct inode *inode, struct folio *folio,

fs/iomap/buffered-io.c

1875

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

1877

WARN_ON_ONCE(i_blocks_per_folio(inode, folio) > 1 && !ifs);

fs/iomap/buffered-io.c

188

unsigned int blks_per_folio = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

1881

folio_end_writeback(folio);

fs/iomap/buffered-io.c

1886

struct folio *folio, u64 pos, u32 rlen, u64 end_pos,

fs/iomap/buffered-io.c

1892

ret = wpc->ops->writeback_range(wpc, folio, pos, rlen, end_pos);

fs/iomap/buffered-io.c

1918

static bool iomap_writeback_handle_eof(struct folio *folio,

fs/iomap/buffered-io.c

1925

WARN_ON_ONCE(folio_pos(folio) < isize);

fs/iomap/buffered-io.c

1930

size_t poff = offset_in_folio(folio, isize);

fs/iomap/buffered-io.c

1951

if (folio->index > end_index ||

fs/iomap/buffered-io.c

1952

(folio->index == end_index && poff == 0))

fs/iomap/buffered-io.c

1969

folio_zero_segment(folio, poff, folio_size(folio));

fs/iomap/buffered-io.c

1976

int iomap_writeback_folio(struct iomap_writepage_ctx *wpc, struct folio *folio)

fs/iomap/buffered-io.c

1978

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

1980

u64 pos = folio_pos(folio);

fs/iomap/buffered-io.c

1981

u64 end_pos = pos + folio_size(folio);

fs/iomap/buffered-io.c

1988

WARN_ON_ONCE(!folio_test_locked(folio));

fs/iomap/buffered-io.c

1989

WARN_ON_ONCE(folio_test_dirty(folio));

fs/iomap/buffered-io.c

1990

WARN_ON_ONCE(folio_test_writeback(folio));

fs/iomap/buffered-io.c

1992

trace_iomap_writeback_folio(inode, pos, folio_size(folio));

fs/iomap/buffered-io.c

1994

if (!iomap_writeback_handle_eof(folio, wpc, &end_pos))

fs/iomap/buffered-io.c

1998

if (i_blocks_per_folio(inode, folio) > 1) {

fs/iomap/buffered-io.c

2000

ifs = ifs_alloc(inode, folio, 0);

fs/iomap/buffered-io.c

2001

iomap_set_range_dirty(folio, 0, end_pos - pos);

fs/iomap/buffered-io.c

2004

iomap_writeback_init(inode, folio);

fs/iomap/buffered-io.c

2011

folio_start_writeback(folio);

fs/iomap/buffered-io.c

2017

while ((rlen = iomap_find_dirty_range(folio, &pos, end_aligned))) {

fs/iomap/buffered-io.c

2018

error = iomap_writeback_range(wpc, folio, pos, rlen, end_pos,

fs/iomap/buffered-io.c

203

static void iomap_clear_range_dirty(struct folio *folio, size_t off, size_t len)

fs/iomap/buffered-io.c

2036

iomap_clear_range_dirty(folio, 0, folio_size(folio));

fs/iomap/buffered-io.c

205

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

2050

size_t bytes_not_submitted = folio_size(folio) -

fs/iomap/buffered-io.c

2054

iomap_finish_folio_write(inode, folio,

fs/iomap/buffered-io.c

2057

folio_end_writeback(folio);

fs/iomap/buffered-io.c

2069

struct folio *folio = NULL;

fs/iomap/buffered-io.c

208

ifs_clear_range_dirty(folio, ifs, off, len);

fs/iomap/buffered-io.c

2080

while ((folio = writeback_iter(mapping, wpc->wbc, folio, &error))) {

fs/iomap/buffered-io.c

2081

error = iomap_writeback_folio(wpc, folio);

fs/iomap/buffered-io.c

2082

folio_unlock(folio);

fs/iomap/buffered-io.c

218

static void ifs_set_range_dirty(struct folio *folio,

fs/iomap/buffered-io.c

221

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

222

unsigned int blks_per_folio = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

237

static void iomap_set_range_dirty(struct folio *folio, size_t off, size_t len)

fs/iomap/buffered-io.c

239

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

242

ifs_set_range_dirty(folio, ifs, off, len);

fs/iomap/buffered-io.c

246

struct folio *folio, unsigned int flags)

fs/iomap/buffered-io.c

248

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

249

unsigned int nr_blocks = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

271

if (folio_test_uptodate(folio))

fs/iomap/buffered-io.c

273

if (folio_test_dirty(folio))

fs/iomap/buffered-io.c

275

folio_attach_private(folio, ifs);

fs/iomap/buffered-io.c

280

static void ifs_free(struct folio *folio)

fs/iomap/buffered-io.c

282

struct iomap_folio_state *ifs = folio_detach_private(folio);

fs/iomap/buffered-io.c

288

WARN_ON_ONCE(ifs_is_fully_uptodate(folio, ifs) !=

fs/iomap/buffered-io.c

289

folio_test_uptodate(folio));

fs/iomap/buffered-io.c

312

static void iomap_adjust_read_range(struct inode *inode, struct folio *folio,

fs/iomap/buffered-io.c

315

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

320

size_t poff = offset_in_folio(folio, *pos);

fs/iomap/buffered-io.c

321

size_t plen = min_t(loff_t, folio_size(folio) - poff, length);

fs/iomap/buffered-io.c

334

next = ifs_next_nonuptodate_block(folio, first, last);

fs/iomap/buffered-io.c

35

static inline bool ifs_is_fully_uptodate(struct folio *folio,

fs/iomap/buffered-io.c

350

next = ifs_next_uptodate_block(folio, next, last);

fs/iomap/buffered-io.c

365

unsigned end = offset_in_folio(folio, isize - 1) >> block_bits;

fs/iomap/buffered-io.c

38

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

40

return bitmap_full(ifs->state, i_blocks_per_folio(inode, folio));

fs/iomap/buffered-io.c

413

struct folio *folio)

fs/iomap/buffered-io.c

417

size_t offset = offset_in_folio(folio, iomap->offset);

fs/iomap/buffered-io.c

422

if (folio_test_uptodate(folio))

fs/iomap/buffered-io.c

431

ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

433

folio_fill_tail(folio, offset, iomap->inline_data, size);

fs/iomap/buffered-io.c

434

iomap_set_range_uptodate(folio, offset, folio_size(folio) - offset);

fs/iomap/buffered-io.c

438

void iomap_finish_folio_read(struct folio *folio, size_t off, size_t len,

fs/iomap/buffered-io.c

441

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

446

fserror_report_io(folio->mapping->host, FSERR_BUFFERED_READ,

fs/iomap/buffered-io.c

447

folio_pos(folio) + off, len, error,

fs/iomap/buffered-io.c

455

uptodate = ifs_set_range_uptodate(folio, ifs, off, len);

fs/iomap/buffered-io.c

462

folio_end_read(folio, uptodate);

fs/iomap/buffered-io.c

466

static void iomap_read_init(struct folio *folio)

fs/iomap/buffered-io.c

468

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

47

static unsigned ifs_next_uptodate_block(struct folio *folio,

fs/iomap/buffered-io.c

490

ifs->read_bytes_pending = folio_size(folio);

fs/iomap/buffered-io.c

50

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

504

static void iomap_read_end(struct folio *folio, size_t bytes_submitted)

fs/iomap/buffered-io.c

506

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

515

folio_unlock(folio);

fs/iomap/buffered-io.c

523

ifs->read_bytes_pending -= folio_size(folio) - bytes_submitted;

fs/iomap/buffered-io.c

533

uptodate = ifs_is_fully_uptodate(folio, ifs);

fs/iomap/buffered-io.c

536

folio_end_read(folio, uptodate);

fs/iomap/buffered-io.c

547

folio_unlock(folio);

fs/iomap/buffered-io.c

557

struct folio *folio = ctx->cur_folio;

fs/iomap/buffered-io.c

558

size_t folio_len = folio_size(folio);

fs/iomap/buffered-io.c

565

ret = iomap_read_inline_data(iter, folio);

fs/iomap/buffered-io.c

571

ifs = ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

573

length = min_t(loff_t, length, folio_len - offset_in_folio(folio, pos));

fs/iomap/buffered-io.c

575

iomap_adjust_read_range(iter->inode, folio, &pos, length, &poff,

fs/iomap/buffered-io.c

59

static unsigned ifs_next_nonuptodate_block(struct folio *folio,

fs/iomap/buffered-io.c

601

fsverity_fill_zerohash(folio, poff, plen,

fs/iomap/buffered-io.c

603

iomap_set_range_uptodate(folio, poff, plen);

fs/iomap/buffered-io.c

606

folio_zero_range(folio, poff, plen);

fs/iomap/buffered-io.c

608

!fsverity_verify_blocks(ctx->vi, folio, plen, poff))

fs/iomap/buffered-io.c

610

iomap_set_range_uptodate(folio, poff, plen);

fs/iomap/buffered-io.c

613

iomap_read_init(folio);

fs/iomap/buffered-io.c

62

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

648

struct folio *folio = ctx->cur_folio;

fs/iomap/buffered-io.c

650

.inode = folio->mapping->host,

fs/iomap/buffered-io.c

651

.pos = folio_pos(folio),

fs/iomap/buffered-io.c

652

.len = folio_size(folio),

fs/iomap/buffered-io.c

666

fsverity_readahead(ctx->vi, folio->index,

fs/iomap/buffered-io.c

667

folio_nr_pages(folio));

fs/iomap/buffered-io.c

67

static bool ifs_set_range_uptodate(struct folio *folio,

fs/iomap/buffered-io.c

70

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

764

bool iomap_is_partially_uptodate(struct folio *folio, size_t from, size_t count)

fs/iomap/buffered-io.c

766

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

767

struct inode *inode = folio->mapping->host;

fs/iomap/buffered-io.c

774

count = min(folio_size(folio) - from, count);

fs/iomap/buffered-io.c

78

return ifs_is_fully_uptodate(folio, ifs);

fs/iomap/buffered-io.c

780

return ifs_next_nonuptodate_block(folio, first, last) > last;

fs/iomap/buffered-io.c

793

struct folio *iomap_get_folio(struct iomap_iter *iter, loff_t pos, size_t len)

fs/iomap/buffered-io.c

808

bool iomap_release_folio(struct folio *folio, gfp_t gfp_flags)

fs/iomap/buffered-io.c

81

static void iomap_set_range_uptodate(struct folio *folio, size_t off,

fs/iomap/buffered-io.c

810

trace_iomap_release_folio(folio->mapping->host, folio_pos(folio),

fs/iomap/buffered-io.c

811

folio_size(folio));

fs/iomap/buffered-io.c

818

if (folio_test_dirty(folio))

fs/iomap/buffered-io.c

820

ifs_free(folio);

fs/iomap/buffered-io.c

825

void iomap_invalidate_folio(struct folio *folio, size_t offset, size_t len)

fs/iomap/buffered-io.c

827

trace_iomap_invalidate_folio(folio->mapping->host,

fs/iomap/buffered-io.c

828

folio_pos(folio) + offset, len);

fs/iomap/buffered-io.c

834

if (offset == 0 && len == folio_size(folio)) {

fs/iomap/buffered-io.c

835

WARN_ON_ONCE(folio_test_writeback(folio));

fs/iomap/buffered-io.c

836

folio_cancel_dirty(folio);

fs/iomap/buffered-io.c

837

ifs_free(folio);

fs/iomap/buffered-io.c

839

iomap_clear_range_dirty(folio, offset, len);

fs/iomap/buffered-io.c

84

struct iomap_folio_state *ifs = folio->private;

fs/iomap/buffered-io.c

844

bool iomap_dirty_folio(struct address_space *mapping, struct folio *folio)

fs/iomap/buffered-io.c

847

size_t len = folio_size(folio);

fs/iomap/buffered-io.c

849

ifs_alloc(inode, folio, 0);

fs/iomap/buffered-io.c

850

iomap_set_range_dirty(folio, 0, len);

fs/iomap/buffered-io.c

851

return filemap_dirty_folio(mapping, folio);

fs/iomap/buffered-io.c

871

struct folio *folio)

fs/iomap/buffered-io.c

878

unsigned int nr_blocks = i_blocks_per_folio(iter->inode, folio);

fs/iomap/buffered-io.c

879

size_t from = offset_in_folio(folio, pos), to = from + len;

fs/iomap/buffered-io.c

88

if (folio_test_uptodate(folio))

fs/iomap/buffered-io.c

889

if (!(iter->flags & IOMAP_UNSHARE) && pos <= folio_pos(folio) &&

fs/iomap/buffered-io.c

890

pos + len >= folio_next_pos(folio))

fs/iomap/buffered-io.c

893

ifs = ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

897

if (folio_test_uptodate(folio))

fs/iomap/buffered-io.c

901

iomap_adjust_read_range(iter->inode, folio, &block_start,

fs/iomap/buffered-io.c

917

folio_zero_segments(folio, poff, from, to, poff + plen);

fs/iomap/buffered-io.c

927

folio, block_start, plen);

fs/iomap/buffered-io.c

930

folio, block_start, plen);

fs/iomap/buffered-io.c

939

folio_zero_segment(folio, to, poff + plen);

fs/iomap/buffered-io.c

941

iomap_set_range_uptodate(folio, poff, plen);

fs/iomap/buffered-io.c

947

static struct folio *__iomap_get_folio(struct iomap_iter *iter,

fs/iomap/buffered-io.c

956

struct folio *folio = folio_batch_next(iter->fbatch);

fs/iomap/buffered-io.c

958

if (!folio)

fs/iomap/buffered-io.c

966

folio_lock(folio);

fs/iomap/buffered-io.c

967

if (unlikely(folio->mapping != iter->inode->i_mapping)) {

fs/iomap/buffered-io.c

969

folio_unlock(folio);

fs/iomap/buffered-io.c

973

folio_get(folio);

fs/iomap/buffered-io.c

974

folio_wait_stable(folio);

fs/iomap/buffered-io.c

975

return folio;

fs/iomap/buffered-io.c

985

struct folio *folio)

fs/iomap/buffered-io.c

990

write_ops->put_folio(iter->inode, pos, ret, folio);

fs/iomap/buffered-io.c

992

folio_unlock(folio);

fs/iomap/buffered-io.c

993

folio_put(folio);

fs/iomap/buffered-io.c

999

struct folio *folio, size_t *offset, u64 *bytes)

fs/iomap/direct-io.c

303

struct folio *zero_folio = largest_zero_folio();

fs/iomap/internal.h

25

struct folio *folio, loff_t pos, size_t len);

fs/iomap/internal.h

28

struct folio *folio, loff_t pos, size_t len)

fs/iomap/ioend.c

213

ssize_t iomap_add_to_ioend(struct iomap_writepage_ctx *wpc, struct folio *folio,

fs/iomap/ioend.c

217

size_t poff = offset_in_folio(folio, pos);

fs/iomap/ioend.c

225

WARN_ON_ONCE(!folio->private && map_len < dirty_len);

fs/iomap/ioend.c

242

if (folio_test_dropbehind(folio))

fs/iomap/ioend.c

257

if (!bio_add_folio(&ioend->io_bio, folio, map_len, poff))

fs/iomap/ioend.c

309

wbc_account_cgroup_owner(wpc->wbc, folio, map_len);

fs/iomap/ioend.c

64

folio_pos(fi.folio) + fi.offset,

fs/iomap/ioend.c

67

iomap_finish_folio_write(inode, fi.folio, fi.length);

fs/isofs/compress.c

302

static int zisofs_read_folio(struct file *file, struct folio *folio)

fs/isofs/compress.c

313

pgoff_t index = folio->index, end_index;

fs/isofs/compress.c

321

folio_end_read(folio, true);

fs/isofs/compress.c

339

folio_unlock(folio);

fs/isofs/compress.c

342

pages[full_page] = &folio->page;

fs/isofs/inode.c

1148

static int isofs_read_folio(struct file *file, struct folio *folio)

fs/isofs/inode.c

1150

return mpage_read_folio(folio, isofs_get_block);

fs/isofs/rock.c

715

static int rock_ridge_symlink_read_folio(struct file *file, struct folio *folio)

fs/isofs/rock.c

717

struct inode *inode = folio->mapping->host;

fs/isofs/rock.c

720

char *link = folio_address(folio);

fs/isofs/rock.c

809

folio_end_read(folio, ret == 0);

fs/jbd2/commit.c

65

struct folio *folio;

fs/jbd2/commit.c

71

folio = bh->b_folio;

fs/jbd2/commit.c

72

if (folio->mapping)

fs/jbd2/commit.c

76

if (!folio_trylock(folio))

fs/jbd2/commit.c

79

folio_get(folio);

fs/jbd2/commit.c

81

try_to_free_buffers(folio);

fs/jbd2/commit.c

82

folio_unlock(folio);

fs/jbd2/commit.c

83

folio_put(folio);

fs/jbd2/journal.c

330

struct folio *new_folio;

fs/jbd2/transaction.c

2180

bool jbd2_journal_try_to_free_buffers(journal_t *journal, struct folio *folio)

fs/jbd2/transaction.c

2186

if (WARN_ON_ONCE(!folio_test_locked(folio)))

fs/jbd2/transaction.c

2189

head = folio_buffers(folio);

fs/jbd2/transaction.c

2217

ret = try_to_free_buffers(folio);

fs/jbd2/transaction.c

2482

int jbd2_journal_invalidate_folio(journal_t *journal, struct folio *folio,

fs/jbd2/transaction.c

2488

int partial_page = (offset || length < folio_size(folio));

fs/jbd2/transaction.c

2492

if (!folio_test_locked(folio))

fs/jbd2/transaction.c

2494

head = folio_buffers(folio);

fs/jbd2/transaction.c

2498

BUG_ON(stop > folio_size(folio) || stop < length);

fs/jbd2/transaction.c

2527

if (may_free && try_to_free_buffers(folio))

fs/jbd2/transaction.c

2528

J_ASSERT(!folio_buffers(folio));

fs/jffs2/file.c

102

folio_mark_uptodate(folio);

fs/jffs2/file.c

104

flush_dcache_folio(folio);

fs/jffs2/file.c

110

int __jffs2_read_folio(struct file *file, struct folio *folio)

fs/jffs2/file.c

112

int ret = jffs2_do_readpage_nolock(folio->mapping->host, folio);

fs/jffs2/file.c

113

folio_unlock(folio);

fs/jffs2/file.c

117

static int jffs2_read_folio(struct file *file, struct folio *folio)

fs/jffs2/file.c

119

struct jffs2_inode_info *f = JFFS2_INODE_INFO(folio->mapping->host);

fs/jffs2/file.c

123

ret = __jffs2_read_folio(file, folio);

fs/jffs2/file.c

131

struct folio **foliop, void **fsdata)

fs/jffs2/file.c

133

struct folio *folio;

fs/jffs2/file.c

212

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/jffs2/file.c

214

if (IS_ERR(folio)) {

fs/jffs2/file.c

215

ret = PTR_ERR(folio);

fs/jffs2/file.c

218

*foliop = folio;

fs/jffs2/file.c

225

if (!folio_test_uptodate(folio)) {

fs/jffs2/file.c

227

ret = jffs2_do_readpage_nolock(inode, folio);

fs/jffs2/file.c

230

folio_unlock(folio);

fs/jffs2/file.c

231

folio_put(folio);

fs/jffs2/file.c

235

jffs2_dbg(1, "end write_begin(). folio->flags %lx\n", folio->flags.f);

fs/jffs2/file.c

246

struct folio *folio, void *fsdata)

fs/jffs2/file.c

263

__func__, inode->i_ino, folio_pos(folio),

fs/jffs2/file.c

264

start, end, folio->flags.f);

fs/jffs2/file.c

270

BUG_ON(!folio_test_uptodate(folio));

fs/jffs2/file.c

28

struct folio *folio, void *fsdata);

fs/jffs2/file.c

285

folio_unlock(folio);

fs/jffs2/file.c

286

folio_put(folio);

fs/jffs2/file.c

298

buf = kmap_local_folio(folio, aligned_start);

fs/jffs2/file.c

300

folio_pos(folio) + aligned_start,

fs/jffs2/file.c

32

struct folio **foliop, void **fsdata);

fs/jffs2/file.c

328

folio_clear_uptodate(folio);

fs/jffs2/file.c

33

static int jffs2_read_folio(struct file *filp, struct folio *folio);

fs/jffs2/file.c

333

folio_unlock(folio);

fs/jffs2/file.c

334

folio_put(folio);

fs/jffs2/file.c

84

static int jffs2_do_readpage_nolock(struct inode *inode, struct folio *folio)

fs/jffs2/file.c

92

__func__, inode->i_ino, folio->index << PAGE_SHIFT);

fs/jffs2/file.c

94

BUG_ON(!folio_test_locked(folio));

fs/jffs2/file.c

96

kaddr = kmap_local_folio(folio, 0);

fs/jffs2/file.c

97

ret = jffs2_read_inode_range(c, f, kaddr, folio->index << PAGE_SHIFT,

fs/jffs2/gc.c

1174

struct folio *folio;

fs/jffs2/gc.c

1329

folio = read_cache_folio(inode->i_mapping, start >> PAGE_SHIFT,

fs/jffs2/gc.c

1331

if (IS_ERR(folio)) {

fs/jffs2/gc.c

1333

PTR_ERR(folio));

fs/jffs2/gc.c

1335

return PTR_ERR(folio);

fs/jffs2/gc.c

1338

pg_ptr = kmap_local_folio(folio, 0);

fs/jffs2/gc.c

1403

folio_release_kmap(folio, pg_ptr);

fs/jffs2/os-linux.h

158

int __jffs2_read_folio(struct file *file, struct folio *folio);

fs/jfs/inode.c

279

static int jfs_read_folio(struct file *file, struct folio *folio)

fs/jfs/inode.c

281

return mpage_read_folio(folio, jfs_get_block);

fs/jfs/inode.c

302

struct folio **foliop, void **fsdata)

fs/jfs/inode.c

316

struct folio *folio, void *fsdata)

fs/jfs/inode.c

320

ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/jfs/jfs_logmgr.c

1600

sizeof(long), mp->folio,

fs/jfs/jfs_metapage.c

104

folio_attach_private(folio, a);

fs/jfs/jfs_metapage.c

105

kmap(&folio->page);

fs/jfs/jfs_metapage.c

109

l2mp_blocks = L2PSIZE - folio->mapping->host->i_blkbits;

fs/jfs/jfs_metapage.c

118

static inline void remove_metapage(struct folio *folio, struct metapage *mp)

fs/jfs/jfs_metapage.c

120

struct meta_anchor *a = folio->private;

fs/jfs/jfs_metapage.c

121

int l2mp_blocks = L2PSIZE - folio->mapping->host->i_blkbits;

fs/jfs/jfs_metapage.c

131

folio_detach_private(folio);

fs/jfs/jfs_metapage.c

132

kunmap(&folio->page);

fs/jfs/jfs_metapage.c

136

static inline void inc_io(struct folio *folio)

fs/jfs/jfs_metapage.c

138

struct meta_anchor *anchor = folio->private;

fs/jfs/jfs_metapage.c

143

static inline void dec_io(struct folio *folio, blk_status_t status,

fs/jfs/jfs_metapage.c

144

void (*handler)(struct folio *, blk_status_t))

fs/jfs/jfs_metapage.c

146

struct meta_anchor *anchor = folio->private;

fs/jfs/jfs_metapage.c

152

handler(folio, anchor->status);

fs/jfs/jfs_metapage.c

157

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

197

mp->folio = dst;

fs/jfs/jfs_metapage.c

208

static inline struct metapage *folio_to_mp(struct folio *folio, int offset)

fs/jfs/jfs_metapage.c

210

return folio->private;

fs/jfs/jfs_metapage.c

213

static inline int insert_metapage(struct folio *folio, struct metapage *mp)

fs/jfs/jfs_metapage.c

216

folio_attach_private(folio, mp);

fs/jfs/jfs_metapage.c

217

kmap(&folio->page);

fs/jfs/jfs_metapage.c

222

static inline void remove_metapage(struct folio *folio, struct metapage *mp)

fs/jfs/jfs_metapage.c

224

folio_detach_private(folio);

fs/jfs/jfs_metapage.c

225

kunmap(&folio->page);

fs/jfs/jfs_metapage.c

228

#define inc_io(folio) do {} while(0)

fs/jfs/jfs_metapage.c

229

#define dec_io(folio, status, handler) handler(folio, status)

fs/jfs/jfs_metapage.c

233

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

253

mp->folio = dst;

fs/jfs/jfs_metapage.c

310

static inline void drop_metapage(struct folio *folio, struct metapage *mp)

fs/jfs/jfs_metapage.c

315

remove_metapage(folio, mp);

fs/jfs/jfs_metapage.c

349

static void last_read_complete(struct folio *folio, blk_status_t status)

fs/jfs/jfs_metapage.c

353

folio_pos(folio));

fs/jfs/jfs_metapage.c

355

folio_end_read(folio, status == 0);

fs/jfs/jfs_metapage.c

360

struct folio *folio = bio->bi_private;

fs/jfs/jfs_metapage.c

362

dec_io(folio, bio->bi_status, last_read_complete);

fs/jfs/jfs_metapage.c

388

static void last_write_complete(struct folio *folio, blk_status_t status)

fs/jfs/jfs_metapage.c

396

mapping_set_error(folio->mapping, err);

fs/jfs/jfs_metapage.c

400

mp = folio_to_mp(folio, offset);

fs/jfs/jfs_metapage.c

411

folio_end_writeback(folio);

fs/jfs/jfs_metapage.c

416

struct folio *folio = bio->bi_private;

fs/jfs/jfs_metapage.c

418

BUG_ON(!folio->private);

fs/jfs/jfs_metapage.c

420

dec_io(folio, bio->bi_status, last_write_complete);

fs/jfs/jfs_metapage.c

424

static int metapage_write_folio(struct folio *folio,

fs/jfs/jfs_metapage.c

429

struct inode *inode = folio->mapping->host;

fs/jfs/jfs_metapage.c

445

page_start = folio_pos(folio) >> inode->i_blkbits;

fs/jfs/jfs_metapage.c

446

BUG_ON(!folio_test_locked(folio));

fs/jfs/jfs_metapage.c

447

BUG_ON(folio_test_writeback(folio));

fs/jfs/jfs_metapage.c

448

folio_start_writeback(folio);

fs/jfs/jfs_metapage.c

451

mp = folio_to_mp(folio, offset);

fs/jfs/jfs_metapage.c

480

bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset);

fs/jfs/jfs_metapage.c

485

inc_io(folio);

fs/jfs/jfs_metapage.c

492

inc_io(folio);

fs/jfs/jfs_metapage.c

493

xlen = (folio_size(folio) - offset) >> inode->i_blkbits;

fs/jfs/jfs_metapage.c

509

bio->bi_private = folio;

fs/jfs/jfs_metapage.c

51

folio_unlock(mp->folio);

fs/jfs/jfs_metapage.c

519

bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset);

fs/jfs/jfs_metapage.c

527

folio_redirty_for_writepage(wbc, folio);

fs/jfs/jfs_metapage.c

529

folio_unlock(folio);

fs/jfs/jfs_metapage.c

53

folio_lock(mp->folio);

fs/jfs/jfs_metapage.c

535

folio_end_writeback(folio);

fs/jfs/jfs_metapage.c

542

folio_unlock(folio);

fs/jfs/jfs_metapage.c

543

dec_io(folio, BLK_STS_OK, last_write_complete);

fs/jfs/jfs_metapage.c

546

dec_io(folio, BLK_STS_OK, last_write_complete);

fs/jfs/jfs_metapage.c

554

struct folio *folio = NULL;

fs/jfs/jfs_metapage.c

558

while ((folio = writeback_iter(mapping, wbc, folio, &err)))

fs/jfs/jfs_metapage.c

559

err = metapage_write_folio(folio, wbc);

fs/jfs/jfs_metapage.c

565

static int metapage_read_folio(struct file *fp, struct folio *folio)

fs/jfs/jfs_metapage.c

567

struct inode *inode = folio->mapping->host;

fs/jfs/jfs_metapage.c

570

int blocks_per_page = i_blocks_per_folio(inode, folio);

fs/jfs/jfs_metapage.c

577

BUG_ON(!folio_test_locked(folio));

fs/jfs/jfs_metapage.c

578

page_start = folio_pos(folio) >> inode->i_blkbits;

fs/jfs/jfs_metapage.c

586

if (!folio->private)

fs/jfs/jfs_metapage.c

587

insert_metapage(folio, NULL);

fs/jfs/jfs_metapage.c

588

inc_io(folio);

fs/jfs/jfs_metapage.c

597

bio->bi_private = folio;

fs/jfs/jfs_metapage.c

600

bio_add_folio_nofail(bio, folio, len, offset);

fs/jfs/jfs_metapage.c

608

folio_unlock(folio);

fs/jfs/jfs_metapage.c

613

static bool metapage_release_folio(struct folio *folio, gfp_t gfp_mask)

fs/jfs/jfs_metapage.c

620

mp = folio_to_mp(folio, offset);

fs/jfs/jfs_metapage.c

635

remove_metapage(folio, mp);

fs/jfs/jfs_metapage.c

647

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

665

static void metapage_invalidate_folio(struct folio *folio, size_t offset,

fs/jfs/jfs_metapage.c

668

BUG_ON(offset || length < folio_size(folio));

fs/jfs/jfs_metapage.c

670

BUG_ON(folio_test_writeback(folio));

fs/jfs/jfs_metapage.c

672

metapage_release_folio(folio, 0);

fs/jfs/jfs_metapage.c

692

struct folio *folio;

fs/jfs/jfs_metapage.c

723

folio = filemap_grab_folio(mapping, page_index);

fs/jfs/jfs_metapage.c

724

if (IS_ERR(folio)) {

fs/jfs/jfs_metapage.c

728

folio_mark_uptodate(folio);

fs/jfs/jfs_metapage.c

730

folio = read_mapping_folio(mapping, page_index, NULL);

fs/jfs/jfs_metapage.c

731

if (IS_ERR(folio)) {

fs/jfs/jfs_metapage.c

735

folio_lock(folio);

fs/jfs/jfs_metapage.c

738

mp = folio_to_mp(folio, page_offset);

fs/jfs/jfs_metapage.c

764

mp->folio = folio;

fs/jfs/jfs_metapage.c

771

mp->data = folio_address(folio) + page_offset;

fs/jfs/jfs_metapage.c

773

if (unlikely(insert_metapage(folio, mp))) {

fs/jfs/jfs_metapage.c

785

folio_unlock(folio);

fs/jfs/jfs_metapage.c

790

folio_unlock(folio);

fs/jfs/jfs_metapage.c

797

folio_get(mp->folio);

fs/jfs/jfs_metapage.c

798

folio_lock(mp->folio);

fs/jfs/jfs_metapage.c

801

folio_unlock(mp->folio);

fs/jfs/jfs_metapage.c

804

static int metapage_write_one(struct folio *folio)

fs/jfs/jfs_metapage.c

806

struct address_space *mapping = folio->mapping;

fs/jfs/jfs_metapage.c

809

.nr_to_write = folio_nr_pages(folio),

fs/jfs/jfs_metapage.c

813

BUG_ON(!folio_test_locked(folio));

fs/jfs/jfs_metapage.c

815

folio_wait_writeback(folio);

fs/jfs/jfs_metapage.c

817

if (folio_clear_dirty_for_io(folio)) {

fs/jfs/jfs_metapage.c

818

folio_get(folio);

fs/jfs/jfs_metapage.c

819

ret = metapage_write_folio(folio, &wbc);

fs/jfs/jfs_metapage.c

821

folio_wait_writeback(folio);

fs/jfs/jfs_metapage.c

822

folio_put(folio);

fs/jfs/jfs_metapage.c

824

folio_unlock(folio);

fs/jfs/jfs_metapage.c

834

struct folio *folio = mp->folio;

fs/jfs/jfs_metapage.c

838

folio_get(folio);

fs/jfs/jfs_metapage.c

839

folio_lock(folio);

fs/jfs/jfs_metapage.c

84

static inline struct metapage *folio_to_mp(struct folio *folio, int offset)

fs/jfs/jfs_metapage.c

840

folio_mark_dirty(folio);

fs/jfs/jfs_metapage.c

841

if (metapage_write_one(folio))

fs/jfs/jfs_metapage.c

844

folio_put(folio);

fs/jfs/jfs_metapage.c

849

folio_lock(mp->folio);

fs/jfs/jfs_metapage.c

856

folio_unlock(mp->folio);

fs/jfs/jfs_metapage.c

859

folio_get(mp->folio);

fs/jfs/jfs_metapage.c

86

struct meta_anchor *anchor = folio->private;

fs/jfs/jfs_metapage.c

862

folio_unlock(mp->folio);

fs/jfs/jfs_metapage.c

868

struct folio *folio = mp->folio;

fs/jfs/jfs_metapage.c

871

folio_lock(folio);

fs/jfs/jfs_metapage.c

876

folio_unlock(folio);

fs/jfs/jfs_metapage.c

877

folio_put(folio);

fs/jfs/jfs_metapage.c

882

folio_mark_dirty(folio);

fs/jfs/jfs_metapage.c

885

if (metapage_write_one(folio))

fs/jfs/jfs_metapage.c

887

folio_lock(folio);

fs/jfs/jfs_metapage.c

893

drop_metapage(folio, mp);

fs/jfs/jfs_metapage.c

895

folio_unlock(folio);

fs/jfs/jfs_metapage.c

896

folio_put(folio);

fs/jfs/jfs_metapage.c

916

struct folio *folio = filemap_lock_folio(mapping,

fs/jfs/jfs_metapage.c

918

if (IS_ERR(folio))

fs/jfs/jfs_metapage.c

921

mp = folio_to_mp(folio, offset);

fs/jfs/jfs_metapage.c

93

static inline int insert_metapage(struct folio *folio, struct metapage *mp)

fs/jfs/jfs_metapage.c

934

folio_unlock(folio);

fs/jfs/jfs_metapage.c

935

folio_put(folio);

fs/jfs/jfs_metapage.c

99

a = folio->private;

fs/jfs/jfs_metapage.h

100

folio_unlock(folio);

fs/jfs/jfs_metapage.h

110

folio_wait_writeback(mp->folio);

fs/jfs/jfs_metapage.h

119

folio_put(mp->folio);

fs/jfs/jfs_metapage.h

27

struct folio *folio;

fs/jfs/jfs_metapage.h

93

struct folio *folio = mp->folio;

fs/jfs/jfs_metapage.h

94

folio_lock(folio);

fs/jfs/jfs_metapage.h

97

folio_get(folio);

fs/jfs/jfs_metapage.h

98

folio_wait_writeback(folio);

fs/libfs.c

1000

size_t from = offset_in_folio(folio, pos);

fs/libfs.c

1002

folio_zero_range(folio, from + copied, len - copied);

fs/libfs.c

1004

folio_mark_uptodate(folio);

fs/libfs.c

1013

folio_mark_dirty(folio);

fs/libfs.c

1014

folio_unlock(folio);

fs/libfs.c

1015

folio_put(folio);

fs/libfs.c

934

static int simple_read_folio(struct file *file, struct folio *folio)

fs/libfs.c

936

folio_zero_range(folio, 0, folio_size(folio));

fs/libfs.c

937

flush_dcache_folio(folio);

fs/libfs.c

938

folio_mark_uptodate(folio);

fs/libfs.c

939

folio_unlock(folio);

fs/libfs.c

945

struct folio **foliop, void **fsdata)

fs/libfs.c

947

struct folio *folio;

fs/libfs.c

949

folio = __filemap_get_folio(mapping, pos / PAGE_SIZE, FGP_WRITEBEGIN,

fs/libfs.c

951

if (IS_ERR(folio))

fs/libfs.c

952

return PTR_ERR(folio);

fs/libfs.c

954

*foliop = folio;

fs/libfs.c

956

if (!folio_test_uptodate(folio) && (len != folio_size(folio))) {

fs/libfs.c

957

size_t from = offset_in_folio(folio, pos);

fs/libfs.c

959

folio_zero_segments(folio, 0, from,

fs/libfs.c

960

from + len, folio_size(folio));

fs/libfs.c

992

struct folio *folio, void *fsdata)

fs/libfs.c

994

struct inode *inode = folio->mapping->host;

fs/libfs.c

998

if (!folio_test_uptodate(folio)) {

fs/minix/dir.c

103

struct folio *folio;

fs/minix/dir.c

105

kaddr = dir_get_folio(inode, n, &folio);

fs/minix/dir.c

126

folio_release_kmap(folio, p);

fs/minix/dir.c

132

folio_release_kmap(folio, kaddr);

fs/minix/dir.c

154

minix_dirent *minix_find_entry(struct dentry *dentry, struct folio **foliop)

fs/minix/dir.c

206

struct folio *folio = NULL;

fs/minix/dir.c

225

kaddr = dir_get_folio(dir, n, &folio);

fs/minix/dir.c

228

folio_lock(folio);

fs/minix/dir.c

255

folio_unlock(folio);

fs/minix/dir.c

256

folio_release_kmap(folio, kaddr);

fs/minix/dir.c

262

pos = folio_pos(folio) + offset_in_folio(folio, p);

fs/minix/dir.c

263

err = minix_prepare_chunk(folio, pos, sbi->s_dirsize);

fs/minix/dir.c

274

dir_commit_chunk(folio, pos, sbi->s_dirsize);

fs/minix/dir.c

279

folio_release_kmap(folio, kaddr);

fs/minix/dir.c

282

folio_unlock(folio);

fs/minix/dir.c

286

int minix_delete_entry(struct minix_dir_entry *de, struct folio *folio)

fs/minix/dir.c

288

struct inode *inode = folio->mapping->host;

fs/minix/dir.c

289

loff_t pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/minix/dir.c

294

folio_lock(folio);

fs/minix/dir.c

295

err = minix_prepare_chunk(folio, pos, len);

fs/minix/dir.c

297

folio_unlock(folio);

fs/minix/dir.c

304

dir_commit_chunk(folio, pos, len);

fs/minix/dir.c

312

struct folio *folio = filemap_grab_folio(inode->i_mapping, 0);

fs/minix/dir.c

317

if (IS_ERR(folio))

fs/minix/dir.c

318

return PTR_ERR(folio);

fs/minix/dir.c

319

err = minix_prepare_chunk(folio, 0, 2 * sbi->s_dirsize);

fs/minix/dir.c

321

folio_unlock(folio);

fs/minix/dir.c

325

kaddr = kmap_local_folio(folio, 0);

fs/minix/dir.c

326

memset(kaddr, 0, folio_size(folio));

fs/minix/dir.c

347

dir_commit_chunk(folio, 0, 2 * sbi->s_dirsize);

fs/minix/dir.c

350

folio_put(folio);

fs/minix/dir.c

359

struct folio *folio = NULL;

fs/minix/dir.c

368

kaddr = dir_get_folio(inode, i, &folio);

fs/minix/dir.c

397

folio_release_kmap(folio, kaddr);

fs/minix/dir.c

402

folio_release_kmap(folio, kaddr);

fs/minix/dir.c

407

int minix_set_link(struct minix_dir_entry *de, struct folio *folio,

fs/minix/dir.c

410

struct inode *dir = folio->mapping->host;

fs/minix/dir.c

412

loff_t pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/minix/dir.c

415

folio_lock(folio);

fs/minix/dir.c

416

err = minix_prepare_chunk(folio, pos, sbi->s_dirsize);

fs/minix/dir.c

418

folio_unlock(folio);

fs/minix/dir.c

425

dir_commit_chunk(folio, pos, sbi->s_dirsize);

fs/minix/dir.c

43

static void dir_commit_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/minix/dir.c

431

struct minix_dir_entry *minix_dotdot(struct inode *dir, struct folio **foliop)

fs/minix/dir.c

443

struct folio *folio;

fs/minix/dir.c

444

struct minix_dir_entry *de = minix_find_entry(dentry, &folio);

fs/minix/dir.c

448

struct inode *inode = folio->mapping->host;

fs/minix/dir.c

45

struct address_space *mapping = folio->mapping;

fs/minix/dir.c

455

folio_release_kmap(folio, de);

fs/minix/dir.c

48

block_write_end(pos, len, len, folio);

fs/minix/dir.c

54

folio_unlock(folio);

fs/minix/dir.c

68

struct folio **foliop)

fs/minix/dir.c

70

struct folio *folio = read_mapping_folio(dir->i_mapping, n, NULL);

fs/minix/dir.c

72

if (IS_ERR(folio))

fs/minix/dir.c

73

return ERR_CAST(folio);

fs/minix/dir.c

74

*foliop = folio;

fs/minix/dir.c

75

return kmap_local_folio(folio, 0);

fs/minix/inode.c

454

static int minix_read_folio(struct file *file, struct folio *folio)

fs/minix/inode.c

456

return block_read_full_folio(folio, minix_get_block);

fs/minix/inode.c

459

int minix_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/minix/inode.c

461

return __block_write_begin(folio, pos, len, minix_get_block);

fs/minix/inode.c

477

struct folio **foliop, void **fsdata)

fs/minix/minix.h

60

int minix_prepare_chunk(struct folio *folio, loff_t pos, unsigned len);

fs/minix/minix.h

73

struct minix_dir_entry *minix_find_entry(struct dentry *, struct folio **);

fs/minix/minix.h

75

int minix_delete_entry(struct minix_dir_entry *, struct folio *);

fs/minix/minix.h

78

int minix_set_link(struct minix_dir_entry *de, struct folio *folio,

fs/minix/minix.h

80

struct minix_dir_entry *minix_dotdot(struct inode*, struct folio **);

fs/minix/namei.c

144

struct folio *folio;

fs/minix/namei.c

153

de = minix_find_entry(dentry, &folio);

fs/minix/namei.c

156

err = minix_delete_entry(de, folio);

fs/minix/namei.c

157

folio_release_kmap(folio, de);

fs/minix/namei.c

197

struct folio * dir_folio = NULL;

fs/minix/namei.c

199

struct folio *old_folio;

fs/minix/namei.c

218

struct folio *new_folio;

fs/mpage.c

103

head = folio_buffers(folio);

fs/mpage.c

109

if (inode->i_blkbits == folio_shift(folio) &&

fs/mpage.c

111

folio_mark_uptodate(folio);

fs/mpage.c

114

head = create_empty_buffers(folio, i_blocksize(inode), 0);

fs/mpage.c

132

struct folio *folio;

fs/mpage.c

152

struct folio *folio = args->folio;

fs/mpage.c

153

struct inode *inode = folio->mapping->host;

fs/mpage.c

155

const unsigned blocks_per_folio = folio_size(folio) >> blkbits;

fs/mpage.c

170

gfp_t gfp = mapping_gfp_constraint(folio->mapping, GFP_KERNEL);

fs/mpage.c

177

if (folio_buffers(folio))

fs/mpage.c

180

block_in_file = folio_pos(folio) >> blkbits;

fs/mpage.c

214

map_bh->b_folio = folio;

fs/mpage.c

242

map_buffer_to_folio(folio, map_bh, page_block);

fs/mpage.c

268

folio_zero_segment(folio, first_hole << blkbits, folio_size(folio));

fs/mpage.c

270

folio_mark_uptodate(folio);

fs/mpage.c

271

folio_unlock(folio);

fs/mpage.c

275

folio_set_mappedtodisk(folio);

fs/mpage.c

294

if (!bio_add_folio(args->bio, folio, length, 0)) {

fs/mpage.c

312

if (!folio_test_uptodate(folio))

fs/mpage.c

313

block_read_full_folio(folio, args->get_block);

fs/mpage.c

315

folio_unlock(folio);

fs/mpage.c

360

struct folio *folio;

fs/mpage.c

366

while ((folio = readahead_folio(rac))) {

fs/mpage.c

367

prefetchw(&folio->flags);

fs/mpage.c

368

args.folio = folio;

fs/mpage.c

375

if (!folio_test_locked(folio) && !folio_test_uptodate(folio))

fs/mpage.c

386

int mpage_read_folio(struct folio *folio, get_block_t get_block)

fs/mpage.c

389

.folio = folio,

fs/mpage.c

390

.nr_pages = folio_nr_pages(folio),

fs/mpage.c

428

static void clean_buffers(struct folio *folio, unsigned first_unmapped)

fs/mpage.c

431

struct buffer_head *bh, *head = folio_buffers(folio);

fs/mpage.c

449

if (buffer_heads_over_limit && folio_test_uptodate(folio))

fs/mpage.c

450

try_to_free_buffers(folio);

fs/mpage.c

453

static int mpage_write_folio(struct writeback_control *wbc, struct folio *folio,

fs/mpage.c

457

struct address_space *mapping = folio->mapping;

fs/mpage.c

460

const unsigned blocks_per_folio = folio_size(folio) >> blkbits;

fs/mpage.c

474

struct buffer_head *head = folio_buffers(folio);

fs/mpage.c

51

folio_end_read(fi.folio, err == 0);

fs/mpage.c

530

BUG_ON(!folio_test_uptodate(folio));

fs/mpage.c

531

block_in_file = folio_pos(folio) >> blkbits;

fs/mpage.c

539

map_bh.b_folio = folio;

fs/mpage.c

573

if (folio_pos(folio) >= i_size)

fs/mpage.c

575

length = folio_size(folio);

fs/mpage.c

576

if (folio_pos(folio) + length > i_size) {

fs/mpage.c

585

length = i_size - folio_pos(folio);

fs/mpage.c

586

folio_zero_segment(folio, length, folio_size(folio));

fs/mpage.c

610

wbc_account_cgroup_owner(wbc, folio, folio_size(folio));

fs/mpage.c

612

if (!bio_add_folio(bio, folio, length, 0)) {

fs/mpage.c

617

clean_buffers(folio, first_unmapped);

fs/mpage.c

619

BUG_ON(folio_test_writeback(folio));

fs/mpage.c

620

folio_start_writeback(folio);

fs/mpage.c

621

folio_unlock(folio);

fs/mpage.c

63

mapping_set_error(fi.folio->mapping, err);

fs/mpage.c

64

folio_end_writeback(fi.folio);

fs/mpage.c

640

ret = block_write_full_folio(folio, wbc, mpd->get_block);

fs/mpage.c

664

int (*write_folio)(struct folio *folio,

fs/mpage.c

670

struct folio *folio = NULL;

fs/mpage.c

675

while ((folio = writeback_iter(mapping, wbc, folio, &error))) {

fs/mpage.c

677

error = write_folio(folio, wbc);

fs/mpage.c

686

error = mpage_write_folio(wbc, folio, &mpd);

fs/mpage.c

96

static void map_buffer_to_folio(struct folio *folio, struct buffer_head *bh,

fs/mpage.c

99

struct inode *inode = folio->mapping->host;

fs/namei.c

6324

struct folio *folio;

fs/namei.c

6328

folio = filemap_get_folio(mapping, 0);

fs/namei.c

6329

if (IS_ERR(folio))

fs/namei.c

6331

if (!folio_test_uptodate(folio)) {

fs/namei.c

6332

folio_put(folio);

fs/namei.c

6336

folio = read_mapping_folio(mapping, 0, NULL);

fs/namei.c

6337

if (IS_ERR(folio))

fs/namei.c

6338

return ERR_CAST(folio);

fs/namei.c

6340

set_delayed_call(callback, page_put_link, folio);

fs/namei.c

6342

return folio_address(folio);

fs/namei.c

6414

struct folio *folio;

fs/namei.c

6422

err = aops->write_begin(NULL, mapping, 0, len-1, &folio, &fsdata);

fs/namei.c

6428

memcpy(folio_address(folio), symname, len - 1);

fs/namei.c

6431

folio, fsdata);

fs/netfs/buffered_read.c

378

static int netfs_create_singular_buffer(struct netfs_io_request *rreq, struct folio *folio,

fs/netfs/buffered_read.c

386

added = rolling_buffer_append(&rreq->buffer, folio, rollbuf_flags, rreq->gfp);

fs/netfs/buffered_read.c

396

static int netfs_read_gaps(struct file *file, struct folio *folio)

fs/netfs/buffered_read.c

399

struct address_space *mapping = folio->mapping;

fs/netfs/buffered_read.c

400

struct netfs_group *group = netfs_folio_group(folio);

fs/netfs/buffered_read.c

401

struct netfs_folio *finfo = netfs_folio_info(folio);

fs/netfs/buffered_read.c

403

struct folio *sink = NULL;

fs/netfs/buffered_read.c

408

size_t flen = folio_size(folio);

fs/netfs/buffered_read.c

413

_enter("%lx", folio->index);

fs/netfs/buffered_read.c

415

rreq = netfs_alloc_request(mapping, file, folio_pos(folio), flen, NETFS_READ_GAPS);

fs/netfs/buffered_read.c

442

trace_netfs_folio(folio, netfs_folio_trace_read_gaps);

fs/netfs/buffered_read.c

447

bvec_set_folio(&bvec[i++], folio, from, 0);

fs/netfs/buffered_read.c

456

bvec_set_folio(&bvec[i++], folio, flen - to, to);

fs/netfs/buffered_read.c

465

folio_change_private(folio, group);

fs/netfs/buffered_read.c

467

folio_detach_private(folio);

fs/netfs/buffered_read.c

469

trace_netfs_folio(folio, netfs_folio_trace_filled_gaps);

fs/netfs/buffered_read.c

470

flush_dcache_folio(folio);

fs/netfs/buffered_read.c

471

folio_mark_uptodate(folio);

fs/netfs/buffered_read.c

476

folio_unlock(folio);

fs/netfs/buffered_read.c

483

folio_unlock(folio);

fs/netfs/buffered_read.c

501

int netfs_read_folio(struct file *file, struct folio *folio)

fs/netfs/buffered_read.c

503

struct address_space *mapping = folio->mapping;

fs/netfs/buffered_read.c

508

folio_wait_writeback(folio);

fs/netfs/buffered_read.c

510

if (folio_test_dirty(folio))

fs/netfs/buffered_read.c

511

return netfs_read_gaps(file, folio);

fs/netfs/buffered_read.c

513

_enter("%lx", folio->index);

fs/netfs/buffered_read.c

516

folio_pos(folio), folio_size(folio),

fs/netfs/buffered_read.c

531

ret = netfs_create_singular_buffer(rreq, folio, 0);

fs/netfs/buffered_read.c

543

folio_unlock(folio);

fs/netfs/buffered_read.c

563

static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len,

fs/netfs/buffered_read.c

566

struct inode *inode = folio_inode(folio);

fs/netfs/buffered_read.c

568

size_t offset = offset_in_folio(folio, pos);

fs/netfs/buffered_read.c

569

size_t plen = folio_size(folio);

fs/netfs/buffered_read.c

574

folio_zero_segment(folio, 0, plen);

fs/netfs/buffered_read.c

575

folio_mark_uptodate(folio);

fs/netfs/buffered_read.c

593

folio_zero_segments(folio, 0, offset, offset + len, plen);

fs/netfs/buffered_read.c

632

loff_t pos, unsigned int len, struct folio **_folio,

fs/netfs/buffered_read.c

636

struct folio *folio;

fs/netfs/buffered_read.c

641

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/netfs/buffered_read.c

643

if (IS_ERR(folio))

fs/netfs/buffered_read.c

644

return PTR_ERR(folio);

fs/netfs/buffered_read.c

648

ret = ctx->ops->check_write_begin(file, pos, len, &folio, _fsdata);

fs/netfs/buffered_read.c

653

if (!folio)

fs/netfs/buffered_read.c

657

if (folio_test_uptodate(folio))

fs/netfs/buffered_read.c

665

netfs_skip_folio_read(folio, pos, len, false)) {

fs/netfs/buffered_read.c

671

folio_pos(folio), folio_size(folio),

fs/netfs/buffered_read.c

677

rreq->no_unlock_folio = folio;

fs/netfs/buffered_read.c

688

ret = netfs_create_singular_buffer(rreq, folio, 0);

fs/netfs/buffered_read.c

699

ret = folio_wait_private_2_killable(folio);

fs/netfs/buffered_read.c

703

*_folio = folio;

fs/netfs/buffered_read.c

710

if (folio) {

fs/netfs/buffered_read.c

711

folio_unlock(folio);

fs/netfs/buffered_read.c

712

folio_put(folio);

fs/netfs/buffered_read.c

722

int netfs_prefetch_for_write(struct file *file, struct folio *folio,

fs/netfs/buffered_read.c

726

struct address_space *mapping = folio->mapping;

fs/netfs/buffered_read.c

728

unsigned long long start = folio_pos(folio);

fs/netfs/buffered_read.c

729

size_t flen = folio_size(folio);

fs/netfs/buffered_read.c

743

rreq->no_unlock_folio = folio;

fs/netfs/buffered_read.c

753

ret = netfs_create_singular_buffer(rreq, folio, NETFS_ROLLBUF_PAGECACHE_MARK);

fs/netfs/buffered_write.c

102

struct folio *folio = NULL, *writethrough = NULL;

fs/netfs/buffered_write.c

162

folio = netfs_grab_folio_for_write(mapping, pos, part);

fs/netfs/buffered_write.c

163

if (IS_ERR(folio)) {

fs/netfs/buffered_write.c

164

ret = PTR_ERR(folio);

fs/netfs/buffered_write.c

168

flen = folio_size(folio);

fs/netfs/buffered_write.c

169

fpos = folio_pos(folio);

fs/netfs/buffered_write.c

177

if (folio_get_private(folio) &&

fs/netfs/buffered_write.c

178

folio_wait_writeback_killable(folio)) {

fs/netfs/buffered_write.c

188

finfo = netfs_folio_info(folio);

fs/netfs/buffered_write.c

189

group = netfs_folio_group(folio);

fs/netfs/buffered_write.c

19

static struct folio *netfs_grab_folio_for_write(struct address_space *mapping,

fs/netfs/buffered_write.c

214

if (folio_test_uptodate(folio)) {

fs/netfs/buffered_write.c

216

flush_dcache_folio(folio);

fs/netfs/buffered_write.c

217

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

229

folio_zero_segment(folio, 0, offset);

fs/netfs/buffered_write.c

230

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

233

folio_zero_segment(folio, offset + copied, flen);

fs/netfs/buffered_write.c

243

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

257

folio_unlock(folio);

fs/netfs/buffered_write.c

285

ret = netfs_prefetch_for_write(file, folio, offset, part);

fs/netfs/buffered_write.c

292

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

302

if (WARN_ON(folio_get_private(folio)))

fs/netfs/buffered_write.c

304

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

321

folio_attach_private(folio, (void *)((unsigned long)finfo |

fs/netfs/buffered_write.c

332

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

346

trace_netfs_folio(folio, netfs_flush_content);

fs/netfs/buffered_write.c

347

folio_unlock(folio);

fs/netfs/buffered_write.c

348

folio_put(folio);

fs/netfs/buffered_write.c

361

folio_mark_uptodate(folio);

fs/netfs/buffered_write.c

364

priv = folio_get_private(folio);

fs/netfs/buffered_write.c

369

folio_detach_private(folio);

fs/netfs/buffered_write.c

371

folio_change_private(folio, netfs_get_group(netfs_group));

fs/netfs/buffered_write.c

373

folio_attach_private(folio, netfs_get_group(netfs_group));

fs/netfs/buffered_write.c

378

folio_change_private(folio, netfs_group);

fs/netfs/buffered_write.c

380

folio_detach_private(folio);

fs/netfs/buffered_write.c

385

trace_netfs_folio(folio, trace);

fs/netfs/buffered_write.c

386

flush_dcache_folio(folio);

fs/netfs/buffered_write.c

394

folio_mark_dirty(folio);

fs/netfs/buffered_write.c

395

folio_unlock(folio);

fs/netfs/buffered_write.c

397

netfs_advance_writethrough(wreq, &wbc, folio, copied,

fs/netfs/buffered_write.c

403

folio_put(folio);

fs/netfs/buffered_write.c

404

folio = NULL;

fs/netfs/buffered_write.c

439

folio_unlock(folio);

fs/netfs/buffered_write.c

440

folio_put(folio);

fs/netfs/buffered_write.c

540

struct folio *folio = page_folio(vmf->page);

fs/netfs/buffered_write.c

549

_enter("%lx", folio->index);

fs/netfs/buffered_write.c

553

if (folio_lock_killable(folio) < 0)

fs/netfs/buffered_write.c

555

if (folio->mapping != mapping)

fs/netfs/buffered_write.c

557

if (folio_wait_writeback_killable(folio) < 0)

fs/netfs/buffered_write.c

561

if (WARN_ON(!folio_test_uptodate(folio))) {

fs/netfs/buffered_write.c

566

group = netfs_folio_group(folio);

fs/netfs/buffered_write.c

570

folio_unlock(folio);

fs/netfs/buffered_write.c

572

folio_pos(folio),

fs/netfs/buffered_write.c

573

folio_next_pos(folio));

fs/netfs/buffered_write.c

587

if (folio_test_dirty(folio))

fs/netfs/buffered_write.c

588

trace_netfs_folio(folio, netfs_folio_trace_mkwrite_plus);

fs/netfs/buffered_write.c

590

trace_netfs_folio(folio, netfs_folio_trace_mkwrite);

fs/netfs/buffered_write.c

592

priv = folio_get_private(folio);

fs/netfs/buffered_write.c

595

folio_detach_private(folio);

fs/netfs/buffered_write.c

597

folio_change_private(folio, netfs_get_group(netfs_group));

fs/netfs/buffered_write.c

599

folio_attach_private(folio, netfs_get_group(netfs_group));

fs/netfs/buffered_write.c

613

folio_unlock(folio);

fs/netfs/internal.h

120

void netfs_pgpriv2_copy_to_cache(struct netfs_io_request *rreq, struct folio *folio);

fs/netfs/internal.h

194

int netfs_folio_written_back(struct folio *folio);

fs/netfs/internal.h

218

struct folio *folio, size_t copied, bool to_page_end,

fs/netfs/internal.h

219

struct folio **writethrough_cache);

fs/netfs/internal.h

221

struct folio *writethrough_cache);

fs/netfs/internal.h

29

int netfs_prefetch_for_write(struct file *file, struct folio *folio,

fs/netfs/iterator.c

210

struct folio *folio;

fs/netfs/iterator.c

225

xas_for_each(&xas, folio, ULONG_MAX) {

fs/netfs/iterator.c

227

if (xas_retry(&xas, folio))

fs/netfs/iterator.c

229

if (WARN_ON(xa_is_value(folio)))

fs/netfs/iterator.c

231

if (WARN_ON(folio_test_hugetlb(folio)))

fs/netfs/iterator.c

234

flen = folio_size(folio);

fs/netfs/iterator.c

235

offset = offset_in_folio(folio, pos);

fs/netfs/misc.c

136

bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio)

fs/netfs/misc.c

145

if (!filemap_dirty_folio(mapping, folio))

fs/netfs/misc.c

211

void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)

fs/netfs/misc.c

214

struct inode *inode = folio_inode(folio);

fs/netfs/misc.c

216

size_t flen = folio_size(folio);

fs/netfs/misc.c

218

_enter("{%lx},%zx,%zx", folio->index, offset, length);

fs/netfs/misc.c

222

unsigned long long fpos = folio_pos(folio), end;

fs/netfs/misc.c

235

folio_wait_private_2(folio); /* [DEPRECATED] */

fs/netfs/misc.c

237

if (!folio_test_private(folio))

fs/netfs/misc.c

240

finfo = netfs_folio_info(folio);

fs/netfs/misc.c

266

trace_netfs_folio(folio, netfs_folio_trace_invalidate_front);

fs/netfs/misc.c

275

trace_netfs_folio(folio, netfs_folio_trace_invalidate_tail);

fs/netfs/misc.c

282

trace_netfs_folio(folio, netfs_folio_trace_invalidate_middle);

fs/netfs/misc.c

287

netfs_put_group(netfs_folio_group(folio));

fs/netfs/misc.c

288

folio_detach_private(folio);

fs/netfs/misc.c

289

folio_clear_uptodate(folio);

fs/netfs/misc.c

290

folio_cancel_dirty(folio);

fs/netfs/misc.c

292

trace_netfs_folio(folio, netfs_folio_trace_invalidate_all);

fs/netfs/misc.c

304

bool netfs_release_folio(struct folio *folio, gfp_t gfp)

fs/netfs/misc.c

306

struct inode *inode = folio_inode(folio);

fs/netfs/misc.c

310

if (folio_test_dirty(folio))

fs/netfs/misc.c

314

end = folio_next_pos(folio);

fs/netfs/misc.c

323

if (folio_test_private(folio))

fs/netfs/misc.c

325

if (unlikely(folio_test_private_2(folio))) { /* [DEPRECATED] */

fs/netfs/misc.c

328

folio_wait_private_2(folio);

fs/netfs/misc.c

34

struct folio *folio;

fs/netfs/misc.c

54

folio = folio_alloc(gfp, order);

fs/netfs/misc.c

55

if (!folio && order > 0)

fs/netfs/misc.c

56

folio = folio_alloc(gfp, 0);

fs/netfs/misc.c

57

if (!folio)

fs/netfs/misc.c

60

folio->mapping = mapping;

fs/netfs/misc.c

61

folio->index = *_cur_size / PAGE_SIZE;

fs/netfs/misc.c

62

trace_netfs_folio(folio, netfs_folio_trace_alloc_buffer);

fs/netfs/misc.c

63

slot = folioq_append_mark(tail, folio);

fs/netfs/misc.c

87

struct folio *folio = folioq_folio(fq, slot);

fs/netfs/misc.c

89

if (!folio ||

fs/netfs/misc.c

93

trace_netfs_folio(folio, netfs_folio_trace_put);

fs/netfs/misc.c

94

if (folio_batch_add(&fbatch, folio))

fs/netfs/read_collect.c

122

struct folio *folio;

fs/netfs/read_collect.c

130

folio = folioq_folio(folioq, slot);

fs/netfs/read_collect.c

131

if (WARN_ONCE(!folio_test_locked(folio),

fs/netfs/read_collect.c

133

rreq->debug_id, folio->index))

fs/netfs/read_collect.c

134

trace_netfs_folio(folio, netfs_folio_trace_not_locked);

fs/netfs/read_collect.c

139

fpos = folio_pos(folio);

fs/netfs/read_collect.c

142

trace_netfs_collect_folio(rreq, folio, fend, collected_to);

fs/netfs/read_collect.c

47

struct folio *folio = folioq_folio(folioq, slot);

fs/netfs/read_collect.c

49

if (unlikely(folio_pos(folio) < rreq->abandon_to)) {

fs/netfs/read_collect.c

50

trace_netfs_folio(folio, netfs_folio_trace_abandon);

fs/netfs/read_collect.c

54

flush_dcache_folio(folio);

fs/netfs/read_collect.c

55

folio_mark_uptodate(folio);

fs/netfs/read_collect.c

58

finfo = netfs_folio_info(folio);

fs/netfs/read_collect.c

60

trace_netfs_folio(folio, netfs_folio_trace_filled_gaps);

fs/netfs/read_collect.c

62

folio_change_private(folio, finfo->netfs_group);

fs/netfs/read_collect.c

64

folio_detach_private(folio);

fs/netfs/read_collect.c

69

if (!WARN_ON_ONCE(folio_get_private(folio) != NULL)) {

fs/netfs/read_collect.c

70

trace_netfs_folio(folio, netfs_folio_trace_copy_to_cache);

fs/netfs/read_collect.c

71

folio_attach_private(folio, NETFS_FOLIO_COPY_TO_CACHE);

fs/netfs/read_collect.c

72

folio_mark_dirty(folio);

fs/netfs/read_collect.c

75

trace_netfs_folio(folio, netfs_folio_trace_read_done);

fs/netfs/read_collect.c

82

netfs_pgpriv2_copy_to_cache(rreq, folio);

fs/netfs/read_collect.c

86

if (folio == rreq->no_unlock_folio &&

fs/netfs/read_collect.c

90

trace_netfs_folio(folio, netfs_folio_trace_read_unlock);

fs/netfs/read_collect.c

91

folio_unlock(folio);

fs/netfs/read_pgpriv2.c

106

creq = netfs_create_write_req(rreq->mapping, NULL, folio_pos(folio),

fs/netfs/read_pgpriv2.c

133

void netfs_pgpriv2_copy_to_cache(struct netfs_io_request *rreq, struct folio *folio)

fs/netfs/read_pgpriv2.c

138

creq = netfs_pgpriv2_begin_copy_to_cache(rreq, folio);

fs/netfs/read_pgpriv2.c

142

trace_netfs_folio(folio, netfs_folio_trace_copy_to_cache);

fs/netfs/read_pgpriv2.c

143

folio_start_private_2(folio);

fs/netfs/read_pgpriv2.c

144

netfs_pgpriv2_copy_folio(creq, folio);

fs/netfs/read_pgpriv2.c

185

struct folio *folio;

fs/netfs/read_pgpriv2.c

189

folio = folioq_folio(folioq, slot);

fs/netfs/read_pgpriv2.c

19

static void netfs_pgpriv2_copy_folio(struct netfs_io_request *creq, struct folio *folio)

fs/netfs/read_pgpriv2.c

190

if (WARN_ONCE(!folio_test_private_2(folio),

fs/netfs/read_pgpriv2.c

192

creq->debug_id, folio->index))

fs/netfs/read_pgpriv2.c

193

trace_netfs_folio(folio, netfs_folio_trace_not_under_wback);

fs/netfs/read_pgpriv2.c

195

fpos = folio_pos(folio);

fs/netfs/read_pgpriv2.c

196

fsize = folio_size(folio);

fs/netfs/read_pgpriv2.c

201

trace_netfs_collect_folio(creq, folio, fend, collected_to);

fs/netfs/read_pgpriv2.c

207

trace_netfs_folio(folio, netfs_folio_trace_end_copy);

fs/netfs/read_pgpriv2.c

208

folio_end_private_2(folio);

fs/netfs/read_pgpriv2.c

22

size_t fsize = folio_size(folio), flen = fsize;

fs/netfs/read_pgpriv2.c

23

loff_t fpos = folio_pos(folio), i_size;

fs/netfs/read_pgpriv2.c

37

folio_end_private_2(folio);

fs/netfs/read_pgpriv2.c

53

trace_netfs_folio(folio, netfs_folio_trace_store_copy);

fs/netfs/read_pgpriv2.c

56

if (rolling_buffer_append(&creq->buffer, folio, 0, creq->gfp) < 0) {

fs/netfs/read_pgpriv2.c

57

folio_end_private_2(folio);

fs/netfs/read_pgpriv2.c

99

struct netfs_io_request *rreq, struct folio *folio)

fs/netfs/read_retry.c

297

struct folio *folio = folioq_folio(p, slot);

fs/netfs/read_retry.c

299

if (folio && !folioq_is_marked2(p, slot)) {

fs/netfs/read_retry.c

300

if (folio == rreq->no_unlock_folio &&

fs/netfs/read_retry.c

305

trace_netfs_folio(folio,

fs/netfs/read_retry.c

307

folio_unlock(folio);

fs/netfs/rolling_buffer.c

140

struct folio *folio = folioq_folio(fq, ix);

fs/netfs/rolling_buffer.c

141

unsigned int order = folio_order(folio);

fs/netfs/rolling_buffer.c

145

trace_netfs_folio(folio, netfs_folio_trace_read);

fs/netfs/rolling_buffer.c

146

if (!folio_batch_add(put_batch, folio))

fs/netfs/rolling_buffer.c

159

ssize_t rolling_buffer_append(struct rolling_buffer *roll, struct folio *folio,

fs/netfs/rolling_buffer.c

162

ssize_t size = folio_size(folio);

fs/netfs/rolling_buffer.c

168

slot = folioq_append(roll->head, folio);

fs/netfs/rolling_buffer.c

211

struct folio *folio = folioq_folio(p, slot);

fs/netfs/rolling_buffer.c

213

if (!folio)

fs/netfs/rolling_buffer.c

216

trace_netfs_folio(folio, netfs_folio_trace_put);

fs/netfs/rolling_buffer.c

217

if (!folio_batch_add(&fbatch, folio))

fs/netfs/write_collect.c

106

trace_netfs_folio(folio, why);

fs/netfs/write_collect.c

107

folio_end_writeback(folio);

fs/netfs/write_collect.c

141

struct folio *folio;

fs/netfs/write_collect.c

146

folio = folioq_folio(folioq, slot);

fs/netfs/write_collect.c

147

if (WARN_ONCE(!folio_test_writeback(folio),

fs/netfs/write_collect.c

149

wreq->debug_id, folio->index))

fs/netfs/write_collect.c

150

trace_netfs_folio(folio, netfs_folio_trace_not_under_wback);

fs/netfs/write_collect.c

152

fpos = folio_pos(folio);

fs/netfs/write_collect.c

153

fsize = folio_size(folio);

fs/netfs/write_collect.c

154

finfo = netfs_folio_info(folio);

fs/netfs/write_collect.c

159

trace_netfs_collect_folio(wreq, folio, fend, collected_to);

fs/netfs/write_collect.c

165

wreq->nr_group_rel += netfs_folio_written_back(folio);

fs/netfs/write_collect.c

57

int netfs_folio_written_back(struct folio *folio)

fs/netfs/write_collect.c

60

struct inode *inode = folio_inode(folio);

fs/netfs/write_collect.c

66

if ((finfo = netfs_folio_info(folio))) {

fs/netfs/write_collect.c

72

fend = folio_pos(folio) + finfo->dirty_offset + finfo->dirty_len;

fs/netfs/write_collect.c

78

folio_detach_private(folio);

fs/netfs/write_collect.c

86

if ((group = netfs_folio_group(folio))) {

fs/netfs/write_collect.c

89

folio_detach_private(folio);

fs/netfs/write_collect.c

98

if (!folio_test_dirty(folio)) {

fs/netfs/write_collect.c

99

folio_detach_private(folio);

fs/netfs/write_issue.c

322

struct folio *folio)

fs/netfs/write_issue.c

330

size_t fsize = folio_size(folio), flen = fsize, foff = 0;

fs/netfs/write_issue.c

331

loff_t fpos = folio_pos(folio), i_size;

fs/netfs/write_issue.c

349

folio_start_writeback(folio);

fs/netfs/write_issue.c

350

folio_unlock(folio);

fs/netfs/write_issue.c

351

wreq->nr_group_rel += netfs_folio_written_back(folio);

fs/netfs/write_issue.c

360

fgroup = netfs_folio_group(folio);

fs/netfs/write_issue.c

361

finfo = netfs_folio_info(folio);

fs/netfs/write_issue.c

375

folio_zero_segment(folio, flen, fsize);

fs/netfs/write_issue.c

405

folio_redirty_for_writepage(wbc, folio);

fs/netfs/write_issue.c

406

folio_unlock(folio);

fs/netfs/write_issue.c

417

folio_start_writeback(folio);

fs/netfs/write_issue.c

418

folio_unlock(folio);

fs/netfs/write_issue.c

422

trace_netfs_folio(folio, netfs_folio_trace_cancel_copy);

fs/netfs/write_issue.c

424

netfs_folio_written_back(folio);

fs/netfs/write_issue.c

427

trace_netfs_folio(folio, netfs_folio_trace_store_copy);

fs/netfs/write_issue.c

429

trace_netfs_folio(folio, netfs_folio_trace_cancel_store);

fs/netfs/write_issue.c

430

netfs_folio_written_back(folio);

fs/netfs/write_issue.c

433

trace_netfs_folio(folio, netfs_folio_trace_store);

fs/netfs/write_issue.c

435

trace_netfs_folio(folio, netfs_folio_trace_store_plus);

fs/netfs/write_issue.c

439

rolling_buffer_append(&wreq->buffer, folio, 0, wreq->gfp);

fs/netfs/write_issue.c

45

struct folio *folio)

fs/netfs/write_issue.c

55

priv = folio_detach_private(folio);

fs/netfs/write_issue.c

551

struct folio *folio;

fs/netfs/write_issue.c

558

folio = writeback_iter(mapping, wbc, NULL, &error);

fs/netfs/write_issue.c

559

if (!folio)

fs/netfs/write_issue.c

562

wreq = netfs_create_write_req(mapping, NULL, folio_pos(folio), NETFS_WRITEBACK);

fs/netfs/write_issue.c

573

_debug("wbiter %lx %llx", folio->index, atomic64_read(&wreq->issued_to));

fs/netfs/write_issue.c

576

WARN_ON_ONCE(wreq && folio_pos(folio) < atomic64_read(&wreq->issued_to));

fs/netfs/write_issue.c

578

if (netfs_folio_group(folio) != NETFS_FOLIO_COPY_TO_CACHE &&

fs/netfs/write_issue.c

584

error = netfs_write_folio(wreq, wbc, folio);

fs/netfs/write_issue.c

586

folio_redirty_for_writepage(wbc, folio);

fs/netfs/write_issue.c

587

folio_unlock(folio);

fs/netfs/write_issue.c

589

} while ((folio = writeback_iter(mapping, wbc, folio, &error)));

fs/netfs/write_issue.c

600

folio_redirty_for_writepage(wbc, folio);

fs/netfs/write_issue.c

601

folio_unlock(folio);

fs/netfs/write_issue.c

602

folio = writeback_iter(mapping, wbc, folio, &error);

fs/netfs/write_issue.c

603

WARN_ON_ONCE(folio != NULL);

fs/netfs/write_issue.c

605

netfs_kill_dirty_pages(mapping, wbc, folio);

fs/netfs/write_issue.c

644

struct folio *folio, size_t copied, bool to_page_end,

fs/netfs/write_issue.c

645

struct folio **writethrough_cache)

fs/netfs/write_issue.c

654

if (*writethrough_cache != folio) {

fs/netfs/write_issue.c

662

trace_netfs_folio(folio, netfs_folio_trace_wthru);

fs/netfs/write_issue.c

664

trace_netfs_folio(folio, netfs_folio_trace_wthru_plus);

fs/netfs/write_issue.c

665

*writethrough_cache = folio;

fs/netfs/write_issue.c

666

folio_get(folio);

fs/netfs/write_issue.c

672

folio_mark_dirty(folio);

fs/netfs/write_issue.c

673

folio_unlock(folio);

fs/netfs/write_issue.c

677

ret = netfs_write_folio(wreq, wbc, folio);

fs/netfs/write_issue.c

688

struct folio *writethrough_cache)

fs/netfs/write_issue.c

715

struct folio *folio)

fs/netfs/write_issue.c

721

size_t fsize = folio_size(folio), flen;

fs/netfs/write_issue.c

722

loff_t fpos = folio_pos(folio);

fs/netfs/write_issue.c

729

flen = folio_size(folio);

fs/netfs/write_issue.c

732

folio_zero_segment(folio, flen, fsize);

fs/netfs/write_issue.c

741

trace_netfs_folio(folio, netfs_folio_trace_cancel_store);

fs/netfs/write_issue.c

746

trace_netfs_folio(folio, netfs_folio_trace_store);

fs/netfs/write_issue.c

748

trace_netfs_folio(folio, netfs_folio_trace_store_plus);

fs/netfs/write_issue.c

75

trace_netfs_folio(folio, why);

fs/netfs/write_issue.c

751

folio_get(folio);

fs/netfs/write_issue.c

752

ret = rolling_buffer_append(&wreq->buffer, folio, NETFS_ROLLBUF_PUT_MARK, wreq->gfp);

fs/netfs/write_issue.c

754

folio_put(folio);

fs/netfs/write_issue.c

77

folio_start_writeback(folio);

fs/netfs/write_issue.c

78

folio_unlock(folio);

fs/netfs/write_issue.c

79

folio_end_writeback(folio);

fs/netfs/write_issue.c

84

} while ((folio = writeback_iter(mapping, wbc, folio, &error)));

fs/netfs/write_issue.c

875

struct folio *folio = folioq_folio(fq, slot);

fs/netfs/write_issue.c

878

_debug("wbiter %lx %llx", folio->index, atomic64_read(&wreq->issued_to));

fs/netfs/write_issue.c

880

ret = netfs_write_folio_single(wreq, folio);

fs/nfs/blocklayout/blocklayout.c

676

struct folio *scratch;

fs/nfs/blocklayout/dev.c

549

struct folio *scratch;

fs/nfs/dir.c

1000

struct folio *folio;

fs/nfs/dir.c

1002

folio = nfs_readdir_folio_get_locked(mapping, cookie, change_attr);

fs/nfs/dir.c

1003

if (!folio)

fs/nfs/dir.c

1005

if (desc->clear_cache && !nfs_readdir_folio_needs_filling(folio))

fs/nfs/dir.c

1006

nfs_readdir_folio_reinit_array(folio, cookie, change_attr);

fs/nfs/dir.c

1007

return folio;

fs/nfs/dir.c

1021

desc->folio = nfs_readdir_folio_get_cached(desc);

fs/nfs/dir.c

1022

if (!desc->folio)

fs/nfs/dir.c

1024

if (nfs_readdir_folio_needs_filling(desc->folio)) {

fs/nfs/dir.c

1031

desc->folio->index, desc->dtsize);

fs/nfs/dir.c

1033

&desc->folio, 1);

fs/nfs/dir.c

1091

array = kmap_local_folio(desc->folio, 0);

fs/nfs/dir.c

1147

struct folio **arrays;

fs/nfs/dir.c

1177

desc->folio = arrays[i];

fs/nfs/dir.c

1180

desc->folio = NULL;

fs/nfs/dir.c

158

struct folio *folio;

fs/nfs/dir.c

202

static void nfs_readdir_folio_init_array(struct folio *folio, u64 last_cookie,

fs/nfs/dir.c

207

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

220

static void nfs_readdir_clear_array(struct folio *folio)

fs/nfs/dir.c

225

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

232

static void nfs_readdir_folio_reinit_array(struct folio *folio, u64 last_cookie,

fs/nfs/dir.c

235

nfs_readdir_clear_array(folio);

fs/nfs/dir.c

236

nfs_readdir_folio_init_array(folio, last_cookie, change_attr);

fs/nfs/dir.c

239

static struct folio *

fs/nfs/dir.c

242

struct folio *folio = folio_alloc(gfp_flags, 0);

fs/nfs/dir.c

243

if (folio)

fs/nfs/dir.c

244

nfs_readdir_folio_init_array(folio, last_cookie, 0);

fs/nfs/dir.c

245

return folio;

fs/nfs/dir.c

248

static void nfs_readdir_folio_array_free(struct folio *folio)

fs/nfs/dir.c

250

if (folio) {

fs/nfs/dir.c

251

nfs_readdir_clear_array(folio);

fs/nfs/dir.c

252

folio_put(folio);

fs/nfs/dir.c

2636

struct folio *folio;

fs/nfs/dir.c

2651

folio = folio_alloc(GFP_USER, 0);

fs/nfs/dir.c

2652

if (!folio)

fs/nfs/dir.c

2655

kaddr = folio_address(folio);

fs/nfs/dir.c

2661

error = NFS_PROTO(dir)->symlink(dir, dentry, folio, pathlen, &attr);

fs/nfs/dir.c

2668

folio_put(folio);

fs/nfs/dir.c

2678

if (filemap_add_folio(d_inode(dentry)->i_mapping, folio, 0,

fs/nfs/dir.c

2680

folio_mark_uptodate(folio);

fs/nfs/dir.c

2681

folio_unlock(folio);

fs/nfs/dir.c

2684

folio_put(folio);

fs/nfs/dir.c

310

static int nfs_readdir_folio_array_append(struct folio *folio,

fs/nfs/dir.c

321

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

367

static bool nfs_readdir_folio_validate(struct folio *folio, u64 last_cookie,

fs/nfs/dir.c

370

struct nfs_cache_array *array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

381

static void nfs_readdir_folio_unlock_and_put(struct folio *folio)

fs/nfs/dir.c

383

folio_unlock(folio);

fs/nfs/dir.c

384

folio_put(folio);

fs/nfs/dir.c

387

static void nfs_readdir_folio_init_and_validate(struct folio *folio, u64 cookie,

fs/nfs/dir.c

390

if (folio_test_uptodate(folio)) {

fs/nfs/dir.c

391

if (nfs_readdir_folio_validate(folio, cookie, change_attr))

fs/nfs/dir.c

393

nfs_readdir_clear_array(folio);

fs/nfs/dir.c

395

nfs_readdir_folio_init_array(folio, cookie, change_attr);

fs/nfs/dir.c

396

folio_mark_uptodate(folio);

fs/nfs/dir.c

399

static struct folio *nfs_readdir_folio_get_locked(struct address_space *mapping,

fs/nfs/dir.c

403

struct folio *folio;

fs/nfs/dir.c

405

folio = filemap_grab_folio(mapping, index);

fs/nfs/dir.c

406

if (IS_ERR(folio))

fs/nfs/dir.c

408

nfs_readdir_folio_init_and_validate(folio, cookie, change_attr);

fs/nfs/dir.c

409

return folio;

fs/nfs/dir.c

412

static u64 nfs_readdir_folio_last_cookie(struct folio *folio)

fs/nfs/dir.c

417

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

423

static bool nfs_readdir_folio_needs_filling(struct folio *folio)

fs/nfs/dir.c

428

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

434

static void nfs_readdir_folio_set_eof(struct folio *folio)

fs/nfs/dir.c

438

array = kmap_local_folio(folio, 0);

fs/nfs/dir.c

443

static struct folio *nfs_readdir_folio_get_next(struct address_space *mapping,

fs/nfs/dir.c

447

struct folio *folio;

fs/nfs/dir.c

449

folio = __filemap_get_folio(mapping, index,

fs/nfs/dir.c

452

if (IS_ERR(folio))

fs/nfs/dir.c

454

nfs_readdir_folio_init_and_validate(folio, cookie, change_attr);

fs/nfs/dir.c

455

if (nfs_readdir_folio_last_cookie(folio) != cookie)

fs/nfs/dir.c

456

nfs_readdir_folio_reinit_array(folio, cookie, change_attr);

fs/nfs/dir.c

457

return folio;

fs/nfs/dir.c

569

array = kmap_local_folio(desc->folio, 0);

fs/nfs/dir.c

57

static void nfs_readdir_clear_array(struct folio *);

fs/nfs/dir.c

825

struct folio **arrays, size_t narrays,

fs/nfs/dir.c

829

struct folio *new, *folio = *arrays;

fs/nfs/dir.c

831

struct folio *scratch;

fs/nfs/dir.c

848

status = nfs_readdir_folio_array_append(folio, entry, &cookie);

fs/nfs/dir.c

852

if (folio->mapping != mapping) {

fs/nfs/dir.c

859

*arrays = folio = new;

fs/nfs/dir.c

865

if (folio != *arrays)

fs/nfs/dir.c

866

nfs_readdir_folio_unlock_and_put(folio);

fs/nfs/dir.c

867

folio = new;

fs/nfs/dir.c

870

status = nfs_readdir_folio_array_append(folio, entry, &cookie);

fs/nfs/dir.c

877

nfs_readdir_folio_set_eof(folio);

fs/nfs/dir.c

890

if (folio != *arrays)

fs/nfs/dir.c

891

nfs_readdir_folio_unlock_and_put(folio);

fs/nfs/dir.c

931

struct folio **arrays, size_t narrays)

fs/nfs/dir.c

935

struct folio *folio = *arrays;

fs/nfs/dir.c

946

entry->cookie = nfs_readdir_folio_last_cookie(folio);

fs/nfs/dir.c

969

nfs_readdir_folio_set_eof(folio);

fs/nfs/dir.c

983

folio_put(desc->folio);

fs/nfs/dir.c

984

desc->folio = NULL;

fs/nfs/dir.c

990

folio_unlock(desc->folio);

fs/nfs/dir.c

994

static struct folio *

fs/nfs/file.c

297

struct folio *folio;

fs/nfs/file.c

302

folio = filemap_lock_folio(mapping, from >> PAGE_SHIFT);

fs/nfs/file.c

303

if (IS_ERR(folio))

fs/nfs/file.c

306

if (folio_mkclean(folio))

fs/nfs/file.c

307

folio_mark_dirty(folio);

fs/nfs/file.c

309

if (folio_test_uptodate(folio)) {

fs/nfs/file.c

310

loff_t fpos = folio_pos(folio);

fs/nfs/file.c

312

size_t end = folio_size(folio);

fs/nfs/file.c

316

folio_zero_segment(folio, offset, end);

fs/nfs/file.c

320

folio_unlock(folio);

fs/nfs/file.c

321

folio_put(folio);

fs/nfs/file.c

351

static bool nfs_folio_is_full_write(struct folio *folio, loff_t pos,

fs/nfs/file.c

354

unsigned int pglen = nfs_folio_length(folio);

fs/nfs/file.c

355

unsigned int offset = offset_in_folio(folio, pos);

fs/nfs/file.c

361

static bool nfs_want_read_modify_write(struct file *file, struct folio *folio,

fs/nfs/file.c

368

if (folio_test_uptodate(folio) || folio_test_private(folio) ||

fs/nfs/file.c

369

nfs_folio_is_full_write(folio, pos, len))

fs/nfs/file.c

374

if (folio_test_dropbehind(folio))

fs/nfs/file.c

392

loff_t pos, unsigned len, struct folio **foliop,

fs/nfs/file.c

395

struct folio *folio;

fs/nfs/file.c

407

folio = write_begin_get_folio(iocb, mapping, pos >> PAGE_SHIFT, len);

fs/nfs/file.c

408

if (IS_ERR(folio)) {

fs/nfs/file.c

409

ret = PTR_ERR(folio);

fs/nfs/file.c

412

*foliop = folio;

fs/nfs/file.c

414

ret = nfs_flush_incompatible(file, folio);

fs/nfs/file.c

416

folio_unlock(folio);

fs/nfs/file.c

417

folio_put(folio);

fs/nfs/file.c

419

nfs_want_read_modify_write(file, folio, pos, len)) {

fs/nfs/file.c

421

folio_clear_dropbehind(folio);

fs/nfs/file.c

422

ret = nfs_read_folio(file, folio);

fs/nfs/file.c

423

folio_put(folio);

fs/nfs/file.c

435

struct folio *folio, void *fsdata)

fs/nfs/file.c

439

unsigned offset = offset_in_folio(folio, pos);

fs/nfs/file.c

450

if (!folio_test_uptodate(folio)) {

fs/nfs/file.c

451

size_t fsize = folio_size(folio);

fs/nfs/file.c

452

unsigned pglen = nfs_folio_length(folio);

fs/nfs/file.c

456

folio_zero_segments(folio, 0, offset, end, fsize);

fs/nfs/file.c

457

folio_mark_uptodate(folio);

fs/nfs/file.c

459

folio_zero_segment(folio, end, fsize);

fs/nfs/file.c

461

folio_mark_uptodate(folio);

fs/nfs/file.c

463

folio_zero_segment(folio, pglen, fsize);

fs/nfs/file.c

466

status = nfs_update_folio(file, folio, offset, copied);

fs/nfs/file.c

468

folio_unlock(folio);

fs/nfs/file.c

469

folio_put(folio);

fs/nfs/file.c

491

static void nfs_invalidate_folio(struct folio *folio, size_t offset,

fs/nfs/file.c

494

struct inode *inode = folio->mapping->host;

fs/nfs/file.c

496

folio->index, offset, length);

fs/nfs/file.c

499

if (offset != 0 || length < folio_size(folio))

fs/nfs/file.c

500

nfs_wb_folio(inode, folio);

fs/nfs/file.c

502

nfs_wb_folio_cancel(inode, folio);

fs/nfs/file.c

503

folio_wait_private_2(folio); /* [DEPRECATED] */

fs/nfs/file.c

504

trace_nfs_invalidate_folio(inode, folio_pos(folio) + offset, length);

fs/nfs/file.c

513

static bool nfs_release_folio(struct folio *folio, gfp_t gfp)

fs/nfs/file.c

515

dfprintk(PAGECACHE, "NFS: release_folio(%p)\n", folio);

fs/nfs/file.c

518

if (folio_test_private(folio)) {

fs/nfs/file.c

522

if (nfs_wb_folio_reclaim(folio->mapping->host, folio) < 0 ||

fs/nfs/file.c

523

folio_test_private(folio))

fs/nfs/file.c

526

return nfs_fscache_release_folio(folio, gfp);

fs/nfs/file.c

529

static void nfs_check_dirty_writeback(struct folio *folio,

fs/nfs/file.c

533

struct address_space *mapping = folio->mapping;

fs/nfs/file.c

551

if (folio_test_private(folio))

fs/nfs/file.c

563

static int nfs_launder_folio(struct folio *folio)

fs/nfs/file.c

565

struct inode *inode = folio->mapping->host;

fs/nfs/file.c

569

inode->i_ino, folio_pos(folio));

fs/nfs/file.c

571

folio_wait_private_2(folio); /* [DEPRECATED] */

fs/nfs/file.c

572

ret = nfs_wb_folio(inode, folio);

fs/nfs/file.c

573

trace_nfs_launder_folio_done(inode, folio_pos(folio),

fs/nfs/file.c

574

folio_size(folio), ret);

fs/nfs/file.c

656

struct folio *folio = page_folio(vmf->page);

fs/nfs/file.c

660

(long long)folio_pos(folio));

fs/nfs/file.c

665

if (folio_test_private_2(folio) && /* [DEPRECATED] */

fs/nfs/file.c

666

folio_wait_private_2_killable(folio) < 0) {

fs/nfs/file.c

675

folio_lock(folio);

fs/nfs/file.c

676

mapping = folio->mapping;

fs/nfs/file.c

680

folio_wait_writeback(folio);

fs/nfs/file.c

682

pagelen = nfs_folio_length(folio);

fs/nfs/file.c

687

if (nfs_flush_incompatible(filp, folio) == 0 &&

fs/nfs/file.c

688

nfs_update_folio(filp, folio, 0, pagelen) == 0)

fs/nfs/file.c

693

folio_unlock(folio);

fs/nfs/filelayout/filelayout.c

649

struct folio *scratch;

fs/nfs/filelayout/filelayoutdev.c

76

struct folio *scratch;

fs/nfs/flexfilelayout/flexfilelayout.c

454

struct folio *scratch;

fs/nfs/flexfilelayout/flexfilelayoutdev.c

47

struct folio *scratch;

fs/nfs/fscache.c

244

int nfs_netfs_read_folio(struct file *file, struct folio *folio)

fs/nfs/fscache.c

246

if (!netfs_inode(folio_inode(folio))->cache)

fs/nfs/fscache.c

249

return netfs_read_folio(file, folio);

fs/nfs/fscache.c

347

int nfs_netfs_folio_unlock(struct folio *folio)

fs/nfs/fscache.c

349

struct inode *inode = folio->mapping->host;

fs/nfs/fscache.h

100

extern int nfs_netfs_read_folio(struct file *file, struct folio *folio);

fs/nfs/fscache.h

102

static inline bool nfs_fscache_release_folio(struct folio *folio, gfp_t gfp)

fs/nfs/fscache.h

104

if (folio_test_private_2(folio)) { /* [DEPRECATED] */

fs/nfs/fscache.h

107

folio_wait_private_2(folio);

fs/nfs/fscache.h

109

fscache_note_page_release(netfs_i_cookie(netfs_inode(folio->mapping->host)));

fs/nfs/fscache.h

166

static inline int nfs_netfs_folio_unlock(struct folio *folio)

fs/nfs/fscache.h

181

static inline int nfs_netfs_read_folio(struct file *file, struct folio *folio)

fs/nfs/fscache.h

186

static inline bool nfs_fscache_release_folio(struct folio *folio, gfp_t gfp)

fs/nfs/fscache.h

87

extern int nfs_netfs_folio_unlock(struct folio *folio);

fs/nfs/internal.h

579

struct folio *folio);

fs/nfs/internal.h

673

int nfs_migrate_folio(struct address_space *, struct folio *dst,

fs/nfs/internal.h

674

struct folio *src, enum migrate_mode);

fs/nfs/internal.h

860

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/internal.h

862

if (folio && !cinfo->dreq) {

fs/nfs/internal.h

863

struct inode *inode = folio->mapping->host;

fs/nfs/internal.h

869

node_stat_mod_folio(folio, NR_WRITEBACK, nr);

fs/nfs/internal.h

878

static inline size_t nfs_folio_length(struct folio *folio)

fs/nfs/internal.h

880

loff_t i_size = i_size_read(folio->mapping->host);

fs/nfs/internal.h

883

pgoff_t index = folio->index >> folio_order(folio);

fs/nfs/internal.h

884

pgoff_t end_index = (i_size - 1) >> folio_shift(folio);

fs/nfs/internal.h

886

return folio_size(folio);

fs/nfs/internal.h

888

return offset_in_folio(folio, i_size - 1) + 1;

fs/nfs/nfs3proc.c

552

nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio,

fs/nfs/nfs3proc.c

555

struct page *page = &folio->page;

fs/nfs/nfs4proc.c

5220

struct folio *folio, unsigned int len, struct iattr *sattr,

fs/nfs/nfs4proc.c

5223

struct page *page = &folio->page;

fs/nfs/nfs4proc.c

5248

struct folio *folio, unsigned int len, struct iattr *sattr)

fs/nfs/nfs4proc.c

5259

err = _nfs4_proc_symlink(dir, dentry, folio, len, sattr, label);

fs/nfs/pagelist.c

1057

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/pagelist.c

1058

if (folio)

fs/nfs/pagelist.c

1059

return folio == nfs_page_to_folio(prev);

fs/nfs/pagelist.c

1438

struct folio *folio;

fs/nfs/pagelist.c

1445

folio = nfs_page_to_folio(prev);

fs/nfs/pagelist.c

1446

if (folio) {

fs/nfs/pagelist.c

1447

if (index == folio_next_index(folio))

fs/nfs/pagelist.c

407

static void nfs_page_assign_folio(struct nfs_page *req, struct folio *folio)

fs/nfs/pagelist.c

409

if (folio != NULL) {

fs/nfs/pagelist.c

410

req->wb_folio = folio;

fs/nfs/pagelist.c

411

folio_get(folio);

fs/nfs/pagelist.c

468

struct folio *folio,

fs/nfs/pagelist.c

477

ret = nfs_page_create(l_ctx, offset, folio->index, offset, count);

fs/nfs/pagelist.c

479

nfs_page_assign_folio(ret, folio);

fs/nfs/pagelist.c

494

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/pagelist.c

500

if (folio)

fs/nfs/pagelist.c

501

nfs_page_assign_folio(ret, folio);

fs/nfs/pagelist.c

549

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/pagelist.c

554

if (folio != NULL) {

fs/nfs/pagelist.c

555

folio_put(folio);

fs/nfs/proc.c

401

nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio,

fs/nfs/proc.c

404

struct page *page = &folio->page;

fs/nfs/read.c

124

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/read.c

127

if (nfs_netfs_folio_unlock(folio))

fs/nfs/read.c

128

folio_unlock(folio);

fs/nfs/read.c

170

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/read.c

181

folio_zero_segment(folio, start, end);

fs/nfs/read.c

188

folio_zero_segment(folio, start, end);

fs/nfs/read.c

311

struct folio *folio)

fs/nfs/read.c

313

struct inode *inode = folio->mapping->host;

fs/nfs/read.c

315

size_t fsize = folio_size(folio);

fs/nfs/read.c

321

len = nfs_folio_length(folio);

fs/nfs/read.c

323

return nfs_return_empty_folio(folio);

fs/nfs/read.c

327

new = nfs_page_create_from_folio(ctx, folio, 0, aligned_len);

fs/nfs/read.c

330

if (nfs_netfs_folio_unlock(folio))

fs/nfs/read.c

331

folio_unlock(folio);

fs/nfs/read.c

336

folio_zero_segment(folio, len, fsize);

fs/nfs/read.c

351

static int nfs_do_read_folio(struct file *file, struct folio *folio)

fs/nfs/read.c

364

ret = nfs_read_add_folio(&pgio, ctx, folio);

fs/nfs/read.c

375

ret = folio_wait_locked_killable(folio);

fs/nfs/read.c

376

if (!folio_test_uptodate(folio) && !ret)

fs/nfs/read.c

390

int nfs_read_folio(struct file *file, struct folio *folio)

fs/nfs/read.c

393

loff_t pos = folio_pos(folio);

fs/nfs/read.c

394

size_t len = folio_size(folio);

fs/nfs/read.c

408

ret = nfs_wb_folio(inode, folio);

fs/nfs/read.c

411

if (folio_test_uptodate(folio))

fs/nfs/read.c

418

ret = nfs_netfs_read_folio(file, folio);

fs/nfs/read.c

420

ret = nfs_do_read_folio(file, folio);

fs/nfs/read.c

425

folio_unlock(folio);

fs/nfs/read.c

436

struct folio *folio;

fs/nfs/read.c

462

while ((folio = readahead_folio(ractl)) != NULL) {

fs/nfs/read.c

463

ret = nfs_read_add_folio(&pgio, ctx, folio);

fs/nfs/read.c

55

static int nfs_return_empty_folio(struct folio *folio)

fs/nfs/read.c

57

folio_zero_segment(folio, 0, folio_size(folio));

fs/nfs/read.c

58

folio_mark_uptodate(folio);

fs/nfs/read.c

59

if (nfs_netfs_folio_unlock(folio))

fs/nfs/read.c

60

folio_unlock(folio);

fs/nfs/symlink.c

31

static int nfs_symlink_filler(struct file *file, struct folio *folio)

fs/nfs/symlink.c

33

struct inode *inode = folio->mapping->host;

fs/nfs/symlink.c

36

error = NFS_PROTO(inode)->readlink(inode, &folio->page, 0, PAGE_SIZE);

fs/nfs/symlink.c

37

folio_end_read(folio, error == 0);

fs/nfs/symlink.c

45

struct folio *folio;

fs/nfs/symlink.c

52

folio = filemap_get_folio(inode->i_mapping, 0);

fs/nfs/symlink.c

53

if (IS_ERR(folio))

fs/nfs/symlink.c

55

if (!folio_test_uptodate(folio)) {

fs/nfs/symlink.c

56

folio_put(folio);

fs/nfs/symlink.c

63

folio = read_cache_folio(&inode->i_data, 0, nfs_symlink_filler,

fs/nfs/symlink.c

65

if (IS_ERR(folio))

fs/nfs/symlink.c

66

return ERR_CAST(folio);

fs/nfs/symlink.c

68

set_delayed_call(done, page_put_link, folio);

fs/nfs/symlink.c

69

return folio_address(folio);

fs/nfs/write.c

1021

static struct nfs_page *nfs_try_to_update_request(struct folio *folio,

fs/nfs/write.c

1030

trace_nfs_try_to_update_request(folio_inode(folio), offset, bytes);

fs/nfs/write.c

1033

req = nfs_lock_and_join_requests(folio);

fs/nfs/write.c

1058

trace_nfs_try_to_update_request_done(folio_inode(folio), offset, bytes,

fs/nfs/write.c

1069

error = nfs_wb_folio(folio->mapping->host, folio);

fs/nfs/write.c

1070

trace_nfs_try_to_update_request_done(folio_inode(folio), offset, bytes, error);

fs/nfs/write.c

1082

struct folio *folio,

fs/nfs/write.c

1088

req = nfs_try_to_update_request(folio, offset, bytes);

fs/nfs/write.c

1091

req = nfs_page_create_from_folio(ctx, folio, offset, bytes);

fs/nfs/write.c

1100

struct folio *folio, unsigned int offset,

fs/nfs/write.c

1105

req = nfs_setup_write_request(ctx, folio, offset, count);

fs/nfs/write.c

1110

nfs_grow_file(folio, offset, count);

fs/nfs/write.c

1117

int nfs_flush_incompatible(struct file *file, struct folio *folio)

fs/nfs/write.c

1133

req = nfs_folio_find_head_request(folio);

fs/nfs/write.c

1137

do_flush = nfs_page_to_folio(req) != folio ||

fs/nfs/write.c

1147

status = nfs_wb_folio(folio->mapping->host, folio);

fs/nfs/write.c

1219

static bool nfs_folio_write_uptodate(struct folio *folio, unsigned int pagelen)

fs/nfs/write.c

1221

struct inode *inode = folio->mapping->host;

fs/nfs/write.c

1235

return folio_test_uptodate(folio) != 0;

fs/nfs/write.c

1253

static int nfs_can_extend_write(struct file *file, struct folio *folio,

fs/nfs/write.c

1266

if (!nfs_folio_write_uptodate(folio, pagelen))

fs/nfs/write.c

1298

int nfs_update_folio(struct file *file, struct folio *folio,

fs/nfs/write.c

1302

struct address_space *mapping = folio->mapping;

fs/nfs/write.c

1304

unsigned int pagelen = nfs_folio_length(folio);

fs/nfs/write.c

1312

(long long)(folio_pos(folio) + offset));

fs/nfs/write.c

1317

if (nfs_can_extend_write(file, folio, pagelen)) {

fs/nfs/write.c

1326

status = nfs_writepage_setup(ctx, folio, offset, count);

fs/nfs/write.c

170

static struct nfs_page *nfs_folio_find_head_request(struct folio *folio)

fs/nfs/write.c

172

struct address_space *mapping = folio->mapping;

fs/nfs/write.c

175

if (!folio_test_private(folio))

fs/nfs/write.c

1755

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/write.c

1757

filemap_dirty_folio(folio_mapping(folio), folio);

fs/nfs/write.c

178

req = folio->private;

fs/nfs/write.c

1812

struct folio *folio;

fs/nfs/write.c

1817

folio = nfs_page_to_folio(req);

fs/nfs/write.c

1826

if (folio) {

fs/nfs/write.c

1829

nfs_mapping_set_error(folio, status);

fs/nfs/write.c

1840

if (folio)

fs/nfs/write.c

188

static void nfs_grow_file(struct folio *folio, unsigned int offset,

fs/nfs/write.c

191

struct inode *inode = folio->mapping->host;

fs/nfs/write.c

197

end_index = ((i_size - 1) >> folio_shift(folio)) << folio_order(folio);

fs/nfs/write.c

198

if (i_size > 0 && folio->index < end_index)

fs/nfs/write.c

200

end = folio_pos(folio) + (loff_t)offset + (loff_t)count;

fs/nfs/write.c

2011

int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio)

fs/nfs/write.c

2016

folio_wait_writeback(folio);

fs/nfs/write.c

2020

req = nfs_lock_and_join_requests(folio);

fs/nfs/write.c

2031

folio_cancel_dirty(folio);

fs/nfs/write.c

2044

int nfs_wb_folio_reclaim(struct inode *inode, struct folio *folio)

fs/nfs/write.c

2046

loff_t range_start = folio_pos(folio);

fs/nfs/write.c

2047

size_t len = folio_size(folio);

fs/nfs/write.c

2057

if (folio_test_writeback(folio))

fs/nfs/write.c

2059

if (folio_clear_dirty_for_io(folio)) {

fs/nfs/write.c

2061

ret = nfs_writepage_locked(folio, &wbc);

fs/nfs/write.c

2078

int nfs_wb_folio(struct inode *inode, struct folio *folio)

fs/nfs/write.c

2080

loff_t range_start = folio_pos(folio);

fs/nfs/write.c

2081

size_t len = folio_size(folio);

fs/nfs/write.c

2093

folio_wait_writeback(folio);

fs/nfs/write.c

2094

if (folio_clear_dirty_for_io(folio)) {

fs/nfs/write.c

2095

ret = nfs_writepage_locked(folio, &wbc);

fs/nfs/write.c

2101

if (!folio_test_private(folio))

fs/nfs/write.c

2113

int nfs_migrate_folio(struct address_space *mapping, struct folio *dst,

fs/nfs/write.c

2114

struct folio *src, enum migrate_mode mode)

fs/nfs/write.c

228

static void nfs_mapping_set_error(struct folio *folio, int error)

fs/nfs/write.c

230

struct address_space *mapping = folio->mapping;

fs/nfs/write.c

258

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/write.c

260

if (folio_test_uptodate(folio))

fs/nfs/write.c

264

folio_mark_uptodate(folio);

fs/nfs/write.c

286

static void nfs_folio_set_writeback(struct folio *folio)

fs/nfs/write.c

288

struct nfs_server *nfss = NFS_SERVER(folio->mapping->host);

fs/nfs/write.c

290

folio_start_writeback(folio);

fs/nfs/write.c

295

static void nfs_folio_end_writeback(struct folio *folio)

fs/nfs/write.c

297

struct nfs_server *nfss = NFS_SERVER(folio->mapping->host);

fs/nfs/write.c

299

folio_end_writeback_no_dropbehind(folio);

fs/nfs/write.c

511

static struct nfs_page *nfs_lock_and_join_requests(struct folio *folio)

fs/nfs/write.c

513

struct inode *inode = folio->mapping->host;

fs/nfs/write.c

524

head = nfs_folio_find_head_request(folio);

fs/nfs/write.c

541

if (head != folio->private) {

fs/nfs/write.c

582

static int nfs_do_writepage(struct folio *folio, struct writeback_control *wbc,

fs/nfs/write.c

588

nfs_pageio_cond_complete(pgio, folio->index);

fs/nfs/write.c

590

req = nfs_lock_and_join_requests(folio);

fs/nfs/write.c

597

nfs_folio_set_writeback(folio);

fs/nfs/write.c

612

folio_redirty_for_writepage(wbc, folio);

fs/nfs/write.c

618

nfs_add_stats(folio->mapping->host, NFSIOS_WRITEPAGES, 1);

fs/nfs/write.c

629

static int nfs_writepage_locked(struct folio *folio,

fs/nfs/write.c

633

struct inode *inode = folio->mapping->host;

fs/nfs/write.c

639

err = nfs_do_writepage(folio, wbc, &pgio);

fs/nfs/write.c

682

struct folio *folio = NULL;

fs/nfs/write.c

687

while ((folio = writeback_iter(mapping, wbc, folio, &err))) {

fs/nfs/write.c

688

err = nfs_do_writepage(folio, wbc, &pgio);

fs/nfs/write.c

689

folio_unlock(folio);

fs/nfs/write.c

710

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/write.c

711

struct address_space *mapping = folio->mapping;

fs/nfs/write.c

720

folio_set_private(folio);

fs/nfs/write.c

721

folio->private = req;

fs/nfs/write.c

741

struct folio *folio = nfs_page_to_folio(req->wb_head);

fs/nfs/write.c

742

struct address_space *mapping = folio->mapping;

fs/nfs/write.c

745

if (likely(folio)) {

fs/nfs/write.c

746

folio->private = NULL;

fs/nfs/write.c

747

folio_clear_private(folio);

fs/nfs/write.c

752

folio_end_dropbehind(folio);

fs/nfs/write.c

764

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/write.c

765

if (folio)

fs/nfs/write.c

766

filemap_dirty_folio(folio_mapping(folio), folio);

fs/nfs/write.c

871

struct folio *folio = nfs_page_to_folio(req);

fs/nfs/write.c

873

if (folio) {

fs/nfs/write.c

876

node_stat_mod_folio(folio, NR_WRITEBACK, -nr);

fs/nfs/write.c

877

bdi_wb_stat_mod(folio->mapping->host, WB_WRITEBACK, -nr);

fs/nilfs2/btnode.c

101

folio = bh->b_folio;

fs/nilfs2/btnode.c

145

folio_unlock(folio);

fs/nilfs2/btnode.c

146

folio_put(folio);

fs/nilfs2/btnode.c

160

struct folio *folio = bh->b_folio;

fs/nilfs2/btnode.c

161

pgoff_t index = folio->index;

fs/nilfs2/btnode.c

164

folio_get(folio);

fs/nilfs2/btnode.c

165

folio_lock(folio);

fs/nilfs2/btnode.c

166

folio_wait_writeback(folio);

fs/nilfs2/btnode.c

169

still_dirty = folio_test_dirty(folio);

fs/nilfs2/btnode.c

170

mapping = folio->mapping;

fs/nilfs2/btnode.c

171

folio_unlock(folio);

fs/nilfs2/btnode.c

172

folio_put(folio);

fs/nilfs2/btnode.c

222

struct folio *ofolio = obh->b_folio;

fs/nilfs2/btnode.c

288

struct folio *ofolio;

fs/nilfs2/btnode.c

93

struct folio *folio;

fs/nilfs2/dir.c

100

copied = block_write_end(pos, len, len, folio);

fs/nilfs2/dir.c

107

folio_unlock(folio);

fs/nilfs2/dir.c

110

static bool nilfs_check_folio(struct folio *folio, char *kaddr)

fs/nilfs2/dir.c

112

struct inode *dir = folio->mapping->host;

fs/nilfs2/dir.c

116

size_t limit = folio_size(folio);

fs/nilfs2/dir.c

120

if (dir->i_size < folio_pos(folio) + limit) {

fs/nilfs2/dir.c

121

limit = dir->i_size - folio_pos(folio);

fs/nilfs2/dir.c

146

folio_set_checked(folio);

fs/nilfs2/dir.c

173

dir->i_ino, error, (folio->index << PAGE_SHIFT) + offs,

fs/nilfs2/dir.c

181

dir->i_ino, (folio->index << PAGE_SHIFT) + offs,

fs/nilfs2/dir.c

188

struct folio **foliop)

fs/nilfs2/dir.c

191

struct folio *folio = read_mapping_folio(mapping, n, NULL);

fs/nilfs2/dir.c

194

if (IS_ERR(folio))

fs/nilfs2/dir.c

195

return folio;

fs/nilfs2/dir.c

197

kaddr = kmap_local_folio(folio, 0);

fs/nilfs2/dir.c

198

if (unlikely(!folio_test_checked(folio))) {

fs/nilfs2/dir.c

199

if (!nilfs_check_folio(folio, kaddr))

fs/nilfs2/dir.c

203

*foliop = folio;

fs/nilfs2/dir.c

207

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

250

struct folio *folio;

fs/nilfs2/dir.c

252

kaddr = nilfs_get_folio(inode, n, &folio);

fs/nilfs2/dir.c

264

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

274

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

280

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

296

const struct qstr *qstr, struct folio **foliop)

fs/nilfs2/dir.c

353

struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct folio **foliop)

fs/nilfs2/dir.c

355

struct folio *folio;

fs/nilfs2/dir.c

360

de = nilfs_get_folio(dir, 0, &folio);

fs/nilfs2/dir.c

381

*foliop = folio;

fs/nilfs2/dir.c

386

folio_release_kmap(folio, de);

fs/nilfs2/dir.c

393

struct folio *folio;

fs/nilfs2/dir.c

395

de = nilfs_find_entry(dir, qstr, &folio);

fs/nilfs2/dir.c

400

folio_release_kmap(folio, de);

fs/nilfs2/dir.c

405

struct folio *folio, struct inode *inode)

fs/nilfs2/dir.c

407

size_t from = offset_in_folio(folio, de);

fs/nilfs2/dir.c

409

struct address_space *mapping = folio->mapping;

fs/nilfs2/dir.c

412

folio_lock(folio);

fs/nilfs2/dir.c

413

err = nilfs_prepare_chunk(folio, from, to);

fs/nilfs2/dir.c

415

folio_unlock(folio);

fs/nilfs2/dir.c

420

nilfs_commit_chunk(folio, mapping, from, to);

fs/nilfs2/dir.c

436

struct folio *folio = NULL;

fs/nilfs2/dir.c

449

char *kaddr = nilfs_get_folio(dir, n, &folio);

fs/nilfs2/dir.c

454

folio_lock(folio);

fs/nilfs2/dir.c

457

kaddr += folio_size(folio) - reclen;

fs/nilfs2/dir.c

484

folio_unlock(folio);

fs/nilfs2/dir.c

485

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

491

from = offset_in_folio(folio, de);

fs/nilfs2/dir.c

493

err = nilfs_prepare_chunk(folio, from, to);

fs/nilfs2/dir.c

508

nilfs_commit_chunk(folio, folio->mapping, from, to);

fs/nilfs2/dir.c

513

folio_release_kmap(folio, de);

fs/nilfs2/dir.c

516

folio_unlock(folio);

fs/nilfs2/dir.c

524

int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct folio *folio)

fs/nilfs2/dir.c

526

struct address_space *mapping = folio->mapping;

fs/nilfs2/dir.c

528

char *kaddr = (char *)((unsigned long)dir & ~(folio_size(folio) - 1));

fs/nilfs2/dir.c

549

folio_lock(folio);

fs/nilfs2/dir.c

550

err = nilfs_prepare_chunk(folio, from, to);

fs/nilfs2/dir.c

552

folio_unlock(folio);

fs/nilfs2/dir.c

558

nilfs_commit_chunk(folio, mapping, from, to);

fs/nilfs2/dir.c

570

struct folio *folio = filemap_grab_folio(mapping, 0);

fs/nilfs2/dir.c

576

if (IS_ERR(folio))

fs/nilfs2/dir.c

577

return PTR_ERR(folio);

fs/nilfs2/dir.c

579

err = nilfs_prepare_chunk(folio, 0, chunk_size);

fs/nilfs2/dir.c

581

folio_unlock(folio);

fs/nilfs2/dir.c

584

kaddr = kmap_local_folio(folio, 0);

fs/nilfs2/dir.c

600

nilfs_commit_chunk(folio, mapping, 0, chunk_size);

fs/nilfs2/dir.c

602

folio_put(folio);

fs/nilfs2/dir.c

611

struct folio *folio = NULL;

fs/nilfs2/dir.c

618

kaddr = nilfs_get_folio(inode, i, &folio);

fs/nilfs2/dir.c

647

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

652

folio_release_kmap(folio, kaddr);

fs/nilfs2/dir.c

82

static int nilfs_prepare_chunk(struct folio *folio, unsigned int from,

fs/nilfs2/dir.c

85

loff_t pos = folio_pos(folio) + from;

fs/nilfs2/dir.c

87

return __block_write_begin(folio, pos, to - from, nilfs_get_block);

fs/nilfs2/dir.c

90

static void nilfs_commit_chunk(struct folio *folio,

fs/nilfs2/dir.c

94

loff_t pos = folio_pos(folio) + from;

fs/nilfs2/dir.c

99

nr_dirty = nilfs_page_count_clean_buffers(folio, from, to);

fs/nilfs2/file.c

117

folio_wait_writeback(folio);

fs/nilfs2/file.c

49

struct folio *folio = page_folio(vmf->page);

fs/nilfs2/file.c

59

folio_lock(folio);

fs/nilfs2/file.c

60

if (folio->mapping != inode->i_mapping ||

fs/nilfs2/file.c

61

folio_pos(folio) >= i_size_read(inode) ||

fs/nilfs2/file.c

62

!folio_test_uptodate(folio)) {

fs/nilfs2/file.c

63

folio_unlock(folio);

fs/nilfs2/file.c

71

if (folio_test_mappedtodisk(folio))

fs/nilfs2/file.c

74

head = folio_buffers(folio);

fs/nilfs2/file.c

87

folio_set_mappedtodisk(folio);

fs/nilfs2/file.c

91

folio_unlock(folio);

fs/nilfs2/inode.c

149

static int nilfs_read_folio(struct file *file, struct folio *folio)

fs/nilfs2/inode.c

151

return mpage_read_folio(folio, nilfs_get_block);

fs/nilfs2/inode.c

178

struct folio *folio)

fs/nilfs2/inode.c

183

bool ret = filemap_dirty_folio(mapping, folio);

fs/nilfs2/inode.c

189

head = folio_buffers(folio);

fs/nilfs2/inode.c

202

nr_dirty = 1 << (folio_shift(folio) - inode->i_blkbits);

fs/nilfs2/inode.c

224

struct folio **foliop, void **fsdata)

fs/nilfs2/inode.c

244

struct folio *folio, void *fsdata)

fs/nilfs2/inode.c

251

nr_dirty = nilfs_page_count_clean_buffers(folio, start,

fs/nilfs2/inode.c

253

copied = generic_write_end(iocb, mapping, pos, len, copied, folio,

fs/nilfs2/mdt.c

355

struct folio *folio;

fs/nilfs2/mdt.c

36

struct folio *folio = bh->b_folio;

fs/nilfs2/mdt.c

360

folio = filemap_lock_folio(inode->i_mapping, index);

fs/nilfs2/mdt.c

361

if (IS_ERR(folio))

fs/nilfs2/mdt.c

364

folio_wait_writeback(folio);

fs/nilfs2/mdt.c

366

bh = folio_buffers(folio);

fs/nilfs2/mdt.c

373

still_dirty = folio_test_dirty(folio);

fs/nilfs2/mdt.c

374

folio_unlock(folio);

fs/nilfs2/mdt.c

375

folio_put(folio);

fs/nilfs2/mdt.c

394

static int nilfs_mdt_write_folio(struct folio *folio,

fs/nilfs2/mdt.c

397

struct inode *inode = folio->mapping->host;

fs/nilfs2/mdt.c

408

nilfs_clear_folio_dirty(folio);

fs/nilfs2/mdt.c

409

folio_unlock(folio);

fs/nilfs2/mdt.c

413

folio_redirty_for_writepage(wbc, folio);

fs/nilfs2/mdt.c

414

folio_unlock(folio);

fs/nilfs2/mdt.c

430

struct folio *folio = NULL;

fs/nilfs2/mdt.c

433

while ((folio = writeback_iter(mapping, wbc, folio, &error)))

fs/nilfs2/mdt.c

434

error = nilfs_mdt_write_folio(folio, wbc);

fs/nilfs2/mdt.c

52

from = kmap_local_folio(folio, offset_in_folio(folio, bh->b_data));

fs/nilfs2/mdt.c

570

struct folio *folio;

fs/nilfs2/mdt.c

573

folio = filemap_grab_folio(shadow->inode->i_mapping,

fs/nilfs2/mdt.c

575

if (IS_ERR(folio))

fs/nilfs2/mdt.c

576

return PTR_ERR(folio);

fs/nilfs2/mdt.c

578

bh_frozen = folio_buffers(folio);

fs/nilfs2/mdt.c

58

flush_dcache_folio(folio);

fs/nilfs2/mdt.c

580

bh_frozen = create_empty_buffers(folio, 1 << blkbits, 0);

fs/nilfs2/mdt.c

583

offset_in_folio(folio, bh->b_data) >> blkbits);

fs/nilfs2/mdt.c

595

folio_unlock(folio);

fs/nilfs2/mdt.c

596

folio_put(folio);

fs/nilfs2/mdt.c

605

struct folio *folio;

fs/nilfs2/mdt.c

608

folio = filemap_lock_folio(shadow->inode->i_mapping,

fs/nilfs2/mdt.c

610

if (!IS_ERR(folio)) {

fs/nilfs2/mdt.c

611

bh_frozen = folio_buffers(folio);

fs/nilfs2/mdt.c

613

n = offset_in_folio(folio, bh->b_data) >>

fs/nilfs2/mdt.c

617

folio_unlock(folio);

fs/nilfs2/mdt.c

618

folio_put(folio);

fs/nilfs2/namei.c

279

struct folio *folio;

fs/nilfs2/namei.c

282

de = nilfs_find_entry(dir, &dentry->d_name, &folio);

fs/nilfs2/namei.c

299

err = nilfs_delete_entry(de, folio);

fs/nilfs2/namei.c

300

folio_release_kmap(folio, de);

fs/nilfs2/namei.c

368

struct folio *dir_folio = NULL;

fs/nilfs2/namei.c

370

struct folio *old_folio;

fs/nilfs2/namei.c

397

struct folio *new_folio;

fs/nilfs2/nilfs.h

261

struct folio **);

fs/nilfs2/nilfs.h

262

int nilfs_delete_entry(struct nilfs_dir_entry *, struct folio *);

fs/nilfs2/nilfs.h

264

struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct folio **);

fs/nilfs2/nilfs.h

266

struct folio *folio, struct inode *inode);

fs/nilfs2/page.c

104

struct folio *sfolio = sbh->b_folio, *dfolio = dbh->b_folio;

fs/nilfs2/page.c

140

bool nilfs_folio_buffers_clean(struct folio *folio)

fs/nilfs2/page.c

144

bh = head = folio_buffers(folio);

fs/nilfs2/page.c

153

void nilfs_folio_bug(struct folio *folio)

fs/nilfs2/page.c

159

if (unlikely(!folio)) {

fs/nilfs2/page.c

164

m = folio->mapping;

fs/nilfs2/page.c

169

folio, folio_ref_count(folio),

fs/nilfs2/page.c

170

(unsigned long long)folio->index, folio->flags.f, m, ino);

fs/nilfs2/page.c

172

head = folio_buffers(folio);

fs/nilfs2/page.c

197

static void nilfs_copy_folio(struct folio *dst, struct folio *src,

fs/nilfs2/page.c

258

struct folio *folio = fbatch.folios[i], *dfolio;

fs/nilfs2/page.c

260

folio_lock(folio);

fs/nilfs2/page.c

261

if (unlikely(!folio_test_dirty(folio)))

fs/nilfs2/page.c

262

NILFS_FOLIO_BUG(folio, "inconsistent dirty state");

fs/nilfs2/page.c

264

dfolio = filemap_grab_folio(dmap, folio->index);

fs/nilfs2/page.c

267

folio_unlock(folio);

fs/nilfs2/page.c

271

if (unlikely(!folio_buffers(folio)))

fs/nilfs2/page.c

272

NILFS_FOLIO_BUG(folio,

fs/nilfs2/page.c

275

nilfs_copy_folio(dfolio, folio, true);

fs/nilfs2/page.c

28

static struct buffer_head *__nilfs_get_folio_block(struct folio *folio,

fs/nilfs2/page.c

280

folio_unlock(folio);

fs/nilfs2/page.c

312

struct folio *folio = fbatch.folios[i], *dfolio;

fs/nilfs2/page.c

313

pgoff_t index = folio->index;

fs/nilfs2/page.c

315

folio_lock(folio);

fs/nilfs2/page.c

320

nilfs_copy_folio(dfolio, folio, false);

fs/nilfs2/page.c

325

struct folio *f;

fs/nilfs2/page.c

330

WARN_ON(folio != f);

fs/nilfs2/page.c

335

f = __xa_store(&dmap->i_pages, index, folio, GFP_NOFS);

fs/nilfs2/page.c

338

folio->mapping = NULL;

fs/nilfs2/page.c

339

folio_put(folio);

fs/nilfs2/page.c

34

struct buffer_head *bh = folio_buffers(folio);

fs/nilfs2/page.c

341

folio->mapping = dmap;

fs/nilfs2/page.c

343

if (folio_test_dirty(folio))

fs/nilfs2/page.c

349

folio_unlock(folio);

fs/nilfs2/page.c

37

bh = create_empty_buffers(folio, 1 << blkbits, b_state);

fs/nilfs2/page.c

372

struct folio *folio = fbatch.folios[i];

fs/nilfs2/page.c

374

folio_lock(folio);

fs/nilfs2/page.c

381

if (likely(folio->mapping == mapping))

fs/nilfs2/page.c

382

nilfs_clear_folio_dirty(folio);

fs/nilfs2/page.c

384

folio_unlock(folio);

fs/nilfs2/page.c

400

void nilfs_clear_folio_dirty(struct folio *folio)

fs/nilfs2/page.c

404

BUG_ON(!folio_test_locked(folio));

fs/nilfs2/page.c

406

head = folio_buffers(folio);

fs/nilfs2/page.c

441

folio_clear_uptodate(folio);

fs/nilfs2/page.c

442

folio_clear_mappedtodisk(folio);

fs/nilfs2/page.c

443

folio_clear_checked(folio);

fs/nilfs2/page.c

444

__nilfs_clear_folio_dirty(folio);

fs/nilfs2/page.c

447

unsigned int nilfs_page_count_clean_buffers(struct folio *folio,

fs/nilfs2/page.c

454

for (bh = head = folio_buffers(folio), block_start = 0;

fs/nilfs2/page.c

474

void __nilfs_clear_folio_dirty(struct folio *folio)

fs/nilfs2/page.c

476

struct address_space *mapping = folio->mapping;

fs/nilfs2/page.c

480

if (folio_test_dirty(folio)) {

fs/nilfs2/page.c

481

__xa_clear_mark(&mapping->i_pages, folio->index,

fs/nilfs2/page.c

484

folio_clear_dirty_for_io(folio);

fs/nilfs2/page.c

490

folio_clear_dirty(folio);

fs/nilfs2/page.c

514

struct folio *folio;

fs/nilfs2/page.c

53

struct folio *folio;

fs/nilfs2/page.c

531

folio = fbatch.folios[i];

fs/nilfs2/page.c

533

folio_lock(folio);

fs/nilfs2/page.c

534

if (folio_buffers(folio)) {

fs/nilfs2/page.c

538

b = folio->index << (PAGE_SHIFT - inode->i_blkbits);

fs/nilfs2/page.c

539

bh = head = folio_buffers(folio);

fs/nilfs2/page.c

555

folio_unlock(folio);

fs/nilfs2/page.c

56

folio = filemap_grab_folio(mapping, index);

fs/nilfs2/page.c

564

folio_unlock(folio);

fs/nilfs2/page.c

57

if (IS_ERR(folio))

fs/nilfs2/page.c

60

bh = __nilfs_get_folio_block(folio, blkoff, index, blkbits, b_state);

fs/nilfs2/page.c

62

folio_unlock(folio);

fs/nilfs2/page.c

63

folio_put(folio);

fs/nilfs2/page.c

76

struct folio *folio = bh->b_folio;

fs/nilfs2/page.c

85

if (nilfs_folio_buffers_clean(folio))

fs/nilfs2/page.c

86

__nilfs_clear_folio_dirty(folio);

fs/nilfs2/page.c

89

folio_clear_uptodate(folio);

fs/nilfs2/page.c

90

folio_clear_mappedtodisk(folio);

fs/nilfs2/page.h

33

void __nilfs_clear_folio_dirty(struct folio *);

fs/nilfs2/page.h

39

bool nilfs_folio_buffers_clean(struct folio *);

fs/nilfs2/page.h

40

void nilfs_folio_bug(struct folio *);

fs/nilfs2/page.h

44

void nilfs_clear_folio_dirty(struct folio *folio);

fs/nilfs2/page.h

46

unsigned int nilfs_page_count_clean_buffers(struct folio *folio,

fs/nilfs2/page.h

52

#define NILFS_FOLIO_BUG(folio, m, a...) \

fs/nilfs2/page.h

53

do { nilfs_folio_bug(folio); BUG(); } while (0)

fs/nilfs2/recovery.c

508

loff_t pos, struct folio *folio)

fs/nilfs2/recovery.c

511

size_t from = offset_in_folio(folio, pos);

fs/nilfs2/recovery.c

517

memcpy_to_folio(folio, from, bh_org->b_data, bh_org->b_size);

fs/nilfs2/recovery.c

531

struct folio *folio;

fs/nilfs2/recovery.c

545

&folio, nilfs_get_block);

fs/nilfs2/recovery.c

555

err = nilfs_recovery_copy_block(nilfs, rb, pos, folio);

fs/nilfs2/recovery.c

563

block_write_end(pos, blocksize, blocksize, folio);

fs/nilfs2/recovery.c

565

folio_unlock(folio);

fs/nilfs2/recovery.c

566

folio_put(folio);

fs/nilfs2/recovery.c

572

folio_unlock(folio);

fs/nilfs2/recovery.c

573

folio_put(folio);

fs/nilfs2/segment.c

1682

static void nilfs_begin_folio_io(struct folio *folio)

fs/nilfs2/segment.c

1684

if (!folio || folio_test_writeback(folio))

fs/nilfs2/segment.c

1691

folio_lock(folio);

fs/nilfs2/segment.c

1692

folio_clear_dirty_for_io(folio);

fs/nilfs2/segment.c

1693

folio_start_writeback(folio);

fs/nilfs2/segment.c

1694

folio_unlock(folio);

fs/nilfs2/segment.c

1712

struct folio *bd_folio = NULL, *fs_folio = NULL;

fs/nilfs2/segment.c

1783

static void nilfs_end_folio_io(struct folio *folio, int err)

fs/nilfs2/segment.c

1785

if (!folio)

fs/nilfs2/segment.c

1788

if (buffer_nilfs_node(folio_buffers(folio)) &&

fs/nilfs2/segment.c

1789

!folio_test_writeback(folio)) {

fs/nilfs2/segment.c

1794

if (folio_test_dirty(folio)) {

fs/nilfs2/segment.c

1802

folio_lock(folio);

fs/nilfs2/segment.c

1803

if (nilfs_folio_buffers_clean(folio))

fs/nilfs2/segment.c

1804

__nilfs_clear_folio_dirty(folio);

fs/nilfs2/segment.c

1805

folio_unlock(folio);

fs/nilfs2/segment.c

1810

if (err || !nilfs_folio_buffers_clean(folio))

fs/nilfs2/segment.c

1811

filemap_dirty_folio(folio->mapping, folio);

fs/nilfs2/segment.c

1813

folio_end_writeback(folio);

fs/nilfs2/segment.c

1819

struct folio *bd_folio = NULL, *fs_folio = NULL;

fs/nilfs2/segment.c

1901

struct folio *bd_folio = NULL, *fs_folio = NULL;

fs/nilfs2/segment.c

727

struct folio *folio = fbatch.folios[i];

fs/nilfs2/segment.c

729

folio_lock(folio);

fs/nilfs2/segment.c

730

if (unlikely(folio->mapping != mapping)) {

fs/nilfs2/segment.c

732

folio_unlock(folio);

fs/nilfs2/segment.c

735

head = folio_buffers(folio);

fs/nilfs2/segment.c

737

head = create_empty_buffers(folio,

fs/nilfs2/segment.c

748

folio_unlock(folio);

fs/nilfs2/segment.c

755

folio_unlock(folio);

fs/ntfs/aops.c

24

struct folio *folio = iter.folio;

fs/ntfs/aops.c

25

struct ntfs_inode *ni = NTFS_I(folio->mapping->host);

fs/ntfs/aops.c

27

loff_t pos = folio_pos(folio);

fs/ntfs/aops.c

32

folio_zero_segment(folio, offset_in_folio(folio, init_size),

fs/ntfs/aops.c

35

iomap_finish_folio_read(folio, iter.offset, iter.length, error);

fs/ntfs/aops.c

68

static int ntfs_read_folio(struct file *file, struct folio *folio)

fs/ntfs/aops.c

70

struct ntfs_inode *ni = NTFS_I(folio->mapping->host);

fs/ntfs/aops.c

72

.cur_folio = folio,

fs/ntfs/aops.c

90

folio_unlock(folio);

fs/ntfs/aops.c

95

return ntfs_read_compressed_block(folio);

fs/ntfs/attrib.c

159

put_this_folio = old_ctx.ntfs_ino->folio;

fs/ntfs/attrib.c

1920

struct folio *folio;

fs/ntfs/attrib.c

1991

folio = __filemap_get_folio(vi->i_mapping, 0,

fs/ntfs/attrib.c

1994

if (IS_ERR(folio)) {

fs/ntfs/attrib.c

2012

folio = NULL;

fs/ntfs/attrib.c

2052

if (folio && !folio_test_uptodate(folio)) {

fs/ntfs/attrib.c

2053

folio_fill_tail(folio, 0, (u8 *)a +

fs/ntfs/attrib.c

2056

folio_mark_uptodate(folio);

fs/ntfs/attrib.c

2146

if (folio) {

fs/ntfs/attrib.c

2147

iomap_dirty_folio(vi->i_mapping, folio);

fs/ntfs/attrib.c

2148

folio_unlock(folio);

fs/ntfs/attrib.c

2149

folio_put(folio);

fs/ntfs/attrib.c

2198

if (folio)

fs/ntfs/attrib.c

2199

memcpy_from_folio((u8 *)a + mp_ofs, folio, 0, attr_size);

fs/ntfs/attrib.c

2216

folio_unlock(folio);

fs/ntfs/attrib.c

2217

folio_put(folio);

fs/ntfs/attrib.c

2250

struct folio *folio;

fs/ntfs/attrib.c

2259

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/attrib.c

2260

if (IS_ERR(folio)) {

fs/ntfs/attrib.c

2261

ret = PTR_ERR(folio);

fs/ntfs/attrib.c

2263

index, ni->type, PTR_ERR(folio));

fs/ntfs/attrib.c

2267

offset = offset_in_folio(folio, ofs);

fs/ntfs/attrib.c

2268

attr_len = min_t(size_t, (size_t)cnt, folio_size(folio) - offset);

fs/ntfs/attrib.c

2270

folio_lock(folio);

fs/ntfs/attrib.c

2271

addr = kmap_local_folio(folio, offset);

fs/ntfs/attrib.c

2275

folio_mark_dirty(folio);

fs/ntfs/attrib.c

2276

folio_unlock(folio);

fs/ntfs/attrib.c

2277

folio_put(folio);

fs/ntfs/attrib.c

94

struct folio *put_this_folio = NULL;

fs/ntfs/bdev-io.c

102

folio = read_mapping_folio(sb->s_bdev->bd_mapping, idx, NULL);

fs/ntfs/bdev-io.c

103

if (IS_ERR(folio)) {

fs/ntfs/bdev-io.c

105

return PTR_ERR(folio);

fs/ntfs/bdev-io.c

112

memcpy_to_folio(folio, from, buf + buf_off, len);

fs/ntfs/bdev-io.c

114

folio_mark_uptodate(folio);

fs/ntfs/bdev-io.c

115

folio_mark_dirty(folio);

fs/ntfs/bdev-io.c

116

folio_put(folio);

fs/ntfs/bdev-io.c

90

struct folio *folio;

fs/ntfs/bitmap.c

126

struct folio *folio;

fs/ntfs/bitmap.c

150

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/bitmap.c

151

if (IS_ERR(folio)) {

fs/ntfs/bitmap.c

155

PTR_ERR(folio));

fs/ntfs/bitmap.c

156

return PTR_ERR(folio);

fs/ntfs/bitmap.c

159

folio_lock(folio);

fs/ntfs/bitmap.c

160

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/bitmap.c

20

struct folio *folio;

fs/ntfs/bitmap.c

210

folio_mark_dirty(folio);

fs/ntfs/bitmap.c

211

folio_unlock(folio);

fs/ntfs/bitmap.c

213

folio_put(folio);

fs/ntfs/bitmap.c

214

folio = read_mapping_folio(mapping, ++index, NULL);

fs/ntfs/bitmap.c

215

if (IS_ERR(folio)) {

fs/ntfs/bitmap.c

218

PTR_ERR(folio));

fs/ntfs/bitmap.c

219

err = PTR_ERR(folio);

fs/ntfs/bitmap.c

223

folio_lock(folio);

fs/ntfs/bitmap.c

224

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/bitmap.c

258

folio_mark_dirty(folio);

fs/ntfs/bitmap.c

259

folio_unlock(folio);

fs/ntfs/bitmap.c

261

folio_put(folio);

fs/ntfs/bitmap.c

52

folio = ntfs_get_locked_folio(vol->lcnbmp_ino->i_mapping,

fs/ntfs/bitmap.c

54

if (IS_ERR(folio)) {

fs/ntfs/bitmap.c

55

ret = PTR_ERR(folio);

fs/ntfs/bitmap.c

59

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/bitmap.c

90

folio_unlock(folio);

fs/ntfs/bitmap.c

91

folio_put(folio);

fs/ntfs/compress.c

1470

struct folio *folio;

fs/ntfs/compress.c

1511

folio = read_mapping_folio(mapping, index + i, NULL);

fs/ntfs/compress.c

1512

if (IS_ERR(folio)) {

fs/ntfs/compress.c

1517

err = PTR_ERR(folio);

fs/ntfs/compress.c

1521

folio_lock(folio);

fs/ntfs/compress.c

1522

pages[i] = folio_page(folio, 0);

fs/ntfs/compress.c

1554

folio = page_folio(pages[i]);

fs/ntfs/compress.c

1556

folio_clear_dirty(folio);

fs/ntfs/compress.c

1557

folio_mark_uptodate(folio);

fs/ntfs/compress.c

1559

folio_unlock(folio);

fs/ntfs/compress.c

1560

folio_put(folio);

fs/ntfs/compress.c

463

int ntfs_read_compressed_block(struct folio *folio)

fs/ntfs/compress.c

465

struct page *page = &folio->page;

fs/ntfs/dir.c

315

folio = read_mapping_folio(ia_mapping, vcn <<

fs/ntfs/dir.c

317

if (IS_ERR(folio)) {

fs/ntfs/dir.c

319

-PTR_ERR(folio));

fs/ntfs/dir.c

320

err = PTR_ERR(folio);

fs/ntfs/dir.c

324

folio_lock(folio);

fs/ntfs/dir.c

328

folio_unlock(folio);

fs/ntfs/dir.c

329

folio_put(folio);

fs/ntfs/dir.c

333

memcpy_from_folio(kaddr, folio, 0, PAGE_SIZE);

fs/ntfs/dir.c

335

folio_unlock(folio);

fs/ntfs/dir.c

336

folio_put(folio);

fs/ntfs/dir.c

90

struct folio *folio;

fs/ntfs/inode.c

101

ni->folio = NULL;

fs/ntfs/inode.c

2335

if (ni->folio)

fs/ntfs/inode.c

2336

folio_put(ni->folio);

fs/ntfs/inode.c

3469

struct folio *folio;

fs/ntfs/inode.c

3521

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/inode.c

3522

if (IS_ERR(folio))

fs/ntfs/inode.c

3525

offset = offset_in_folio(folio, pos);

fs/ntfs/inode.c

3526

attr_len = min_t(size_t, (size_t)count, folio_size(folio) - offset);

fs/ntfs/inode.c

3528

folio_lock(folio);

fs/ntfs/inode.c

3529

memcpy_from_folio(buf, folio, offset, attr_len);

fs/ntfs/inode.c

3530

folio_unlock(folio);

fs/ntfs/inode.c

3531

folio_put(folio);

fs/ntfs/inode.c

3596

struct folio *folio;

fs/ntfs/inode.c

3613

folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS,

fs/ntfs/inode.c

3615

if (IS_ERR(folio)) {

fs/ntfs/inode.c

3616

err = PTR_ERR(folio);

fs/ntfs/inode.c

3621

if (!folio_test_uptodate(folio))

fs/ntfs/inode.c

3622

folio_fill_tail(folio, 0, addr,

fs/ntfs/inode.c

3625

memcpy_to_folio(folio, offset_in_folio(folio, pos), buf, count);

fs/ntfs/inode.c

3626

folio_mark_uptodate(folio);

fs/ntfs/inode.c

3627

folio_unlock(folio);

fs/ntfs/inode.c

3628

folio_put(folio);

fs/ntfs/inode.c

3640

struct folio *folio;

fs/ntfs/inode.c

3651

folio = __filemap_get_folio(vi->i_mapping, index,

fs/ntfs/inode.c

3654

if (IS_ERR(folio)) {

fs/ntfs/inode.c

3659

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/inode.c

3660

if (IS_ERR(folio)) {

fs/ntfs/inode.c

3661

ret = PTR_ERR(folio);

fs/ntfs/inode.c

3663

index, ni->type, PTR_ERR(folio));

fs/ntfs/inode.c

3667

folio_lock(folio);

fs/ntfs/inode.c

3674

offset = offset_in_folio(folio, pos);

fs/ntfs/inode.c

3675

attr_len = min_t(size_t, (size_t)count, folio_size(folio) - offset);

fs/ntfs/inode.c

3677

memcpy_to_folio(folio, offset, buf, attr_len);

fs/ntfs/inode.c

3689

vcn = ntfs_pidx_to_cluster(vol, folio->index);

fs/ntfs/inode.c

3710

lcn_folio_off = folio->index << PAGE_SHIFT;

fs/ntfs/inode.c

3723

folio_size(folio));

fs/ntfs/inode.c

3724

if (!bio_add_folio(bio, folio, length, offset)) {

fs/ntfs/inode.c

3736

folio_mark_uptodate(folio);

fs/ntfs/inode.c

3738

folio_mark_uptodate(folio);

fs/ntfs/inode.c

3739

folio_mark_dirty(folio);

fs/ntfs/inode.c

3742

folio_unlock(folio);

fs/ntfs/inode.c

3743

folio_put(folio);

fs/ntfs/inode.c

3797

struct folio *ntfs_get_locked_folio(struct address_space *mapping,

fs/ntfs/inode.c

3800

struct folio *folio;

fs/ntfs/inode.c

3802

folio = filemap_lock_folio(mapping, index);

fs/ntfs/inode.c

3803

if (IS_ERR(folio)) {

fs/ntfs/inode.c

3804

if (PTR_ERR(folio) != -ENOENT)

fs/ntfs/inode.c

3805

return folio;

fs/ntfs/inode.c

3809

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/inode.c

3810

if (!IS_ERR(folio))

fs/ntfs/inode.c

3811

folio_lock(folio);

fs/ntfs/inode.c

3814

return folio;

fs/ntfs/inode.c

430

if (ni->folio)

fs/ntfs/inode.c

431

folio_put(ni->folio);

fs/ntfs/inode.c

475

ni->folio = NULL;

fs/ntfs/inode.h

117

struct folio *folio;

fs/ntfs/inode.h

357

struct folio *ntfs_get_locked_folio(struct address_space *mapping,

fs/ntfs/iomap.c

16

unsigned int len, struct folio *folio)

fs/ntfs/iomap.c

28

loff_t offset = offset_in_folio(folio, pos + len);

fs/ntfs/iomap.c

31

offset = folio_size(folio);

fs/ntfs/iomap.c

32

folio_zero_segments(folio,

fs/ntfs/iomap.c

33

offset_in_folio(folio, init),

fs/ntfs/iomap.c

34

offset_in_folio(folio, pos),

fs/ntfs/iomap.c

36

folio_size(folio));

fs/ntfs/iomap.c

41

offset = offset_in_folio(folio, offset);

fs/ntfs/iomap.c

43

offset = folio_size(folio);

fs/ntfs/iomap.c

44

folio_zero_segment(folio,

fs/ntfs/iomap.c

46

folio_size(folio));

fs/ntfs/iomap.c

49

loff_t offset = 0, offset2 = offset_in_folio(folio, pos + len);

fs/ntfs/iomap.c

51

if ((init >> folio_shift(folio)) == (pos >> folio_shift(folio)))

fs/ntfs/iomap.c

52

offset = offset_in_folio(folio, init);

fs/ntfs/iomap.c

54

offset2 = folio_size(folio);

fs/ntfs/iomap.c

55

folio_zero_segments(folio,

fs/ntfs/iomap.c

57

offset_in_folio(folio, pos),

fs/ntfs/iomap.c

59

folio_size(folio));

fs/ntfs/iomap.c

61

folio_unlock(folio);

fs/ntfs/iomap.c

62

folio_put(folio);

fs/ntfs/iomap.c

70

unsigned int len, struct folio *folio)

fs/ntfs/iomap.c

74

len, folio);

fs/ntfs/iomap.c

75

folio_unlock(folio);

fs/ntfs/iomap.c

76

folio_put(folio);

fs/ntfs/iomap.c

799

struct folio *folio, u64 offset, unsigned int len, u64 end_pos)

fs/ntfs/iomap.c

813

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/ntfs/lcnalloc.c

197

struct folio *folio = NULL;

fs/ntfs/lcnalloc.c

314

if (likely(folio)) {

fs/ntfs/lcnalloc.c

317

folio_mark_dirty(folio);

fs/ntfs/lcnalloc.c

320

folio_unlock(folio);

fs/ntfs/lcnalloc.c

322

folio_put(folio);

fs/ntfs/lcnalloc.c

323

folio = NULL;

fs/ntfs/lcnalloc.c

338

folio = read_mapping_folio(mapping, index, NULL);

fs/ntfs/lcnalloc.c

339

if (IS_ERR(folio)) {

fs/ntfs/lcnalloc.c

340

err = PTR_ERR(folio);

fs/ntfs/lcnalloc.c

345

folio_lock(folio);

fs/ntfs/lcnalloc.c

346

buf = kmap_local_folio(folio, 0) + pg_off;

fs/ntfs/lcnalloc.c

724

if (!IS_ERR_OR_NULL(folio)) {

fs/ntfs/lcnalloc.c

727

folio_mark_dirty(folio);

fs/ntfs/lcnalloc.c

730

folio_unlock(folio);

fs/ntfs/lcnalloc.c

732

folio_put(folio);

fs/ntfs/logfile.c

360

struct folio *folio;

fs/ntfs/logfile.c

370

folio = read_mapping_folio(vi->i_mapping, idx, NULL);

fs/ntfs/logfile.c

371

if (IS_ERR(folio)) {

fs/ntfs/logfile.c

374

err = PTR_ERR(folio);

fs/ntfs/logfile.c

380

memcpy((u8 *)trp + have_read, folio_address(folio), size);

fs/ntfs/logfile.c

381

folio_put(folio);

fs/ntfs/logfile.c

459

struct folio *folio = NULL;

fs/ntfs/logfile.c

512

if (!folio || folio->index != idx) {

fs/ntfs/logfile.c

513

if (folio) {

fs/ntfs/logfile.c

515

folio_put(folio);

fs/ntfs/logfile.c

517

folio = read_mapping_folio(mapping, idx, NULL);

fs/ntfs/logfile.c

518

if (IS_ERR(folio)) {

fs/ntfs/logfile.c

524

kaddr = (u8 *)kmap_local_folio(folio, 0) + (pos & ~PAGE_MASK);

fs/ntfs/logfile.c

578

folio_put(folio);

fs/ntfs/logfile.c

585

if (folio) {

fs/ntfs/logfile.c

587

folio_put(folio);

fs/ntfs/mft.c

1058

struct folio *folio;

fs/ntfs/mft.c

1107

folio = read_mapping_folio(vol->lcnbmp_ino->i_mapping,

fs/ntfs/mft.c

1109

if (IS_ERR(folio)) {

fs/ntfs/mft.c

1112

return PTR_ERR(folio);

fs/ntfs/mft.c

1116

folio_lock(folio);

fs/ntfs/mft.c

1117

b = (u8 *)kmap_local_folio(folio, 0) + (ll & ~PAGE_MASK);

fs/ntfs/mft.c

1122

folio_mark_dirty(folio);

fs/ntfs/mft.c

1123

folio_unlock(folio);

fs/ntfs/mft.c

1125

folio_put(folio);

fs/ntfs/mft.c

1133

folio_unlock(folio);

fs/ntfs/mft.c

1135

folio_put(folio);

fs/ntfs/mft.c

114

struct folio *folio;

fs/ntfs/mft.c

118

WARN_ON(ni->folio);

fs/ntfs/mft.c

134

folio = ERR_PTR(-ENOENT);

fs/ntfs/mft.c

143

folio = read_mapping_folio(mft_vi->i_mapping, index, NULL);

fs/ntfs/mft.c

144

if (!IS_ERR(folio)) {

fs/ntfs/mft.c

149

folio_put(folio);

fs/ntfs/mft.c

150

folio = ERR_PTR(-ENOMEM);

fs/ntfs/mft.c

154

addr = kmap_local_folio(folio, 0);

fs/ntfs/mft.c

161

ni->folio = folio;

fs/ntfs/mft.c

166

folio_put(folio);

fs/ntfs/mft.c

169

folio = ERR_PTR(-EIO);

fs/ntfs/mft.c

173

ni->folio = NULL;

fs/ntfs/mft.c

175

return (struct mft_record *)folio;

fs/ntfs/mft.c

1862

struct folio *folio;

fs/ntfs/mft.c

1888

folio = read_mapping_folio(mft_vi->i_mapping, index, NULL);

fs/ntfs/mft.c

1889

if (IS_ERR(folio)) {

fs/ntfs/mft.c

1892

return PTR_ERR(folio);

fs/ntfs/mft.c

1894

folio_lock(folio);

fs/ntfs/mft.c

1895

folio_clear_uptodate(folio);

fs/ntfs/mft.c

1896

m = (struct mft_record *)((u8 *)kmap_local_folio(folio, 0) + ofs);

fs/ntfs/mft.c

1901

folio_mark_uptodate(folio);

fs/ntfs/mft.c

1902

folio_unlock(folio);

fs/ntfs/mft.c

1904

folio_put(folio);

fs/ntfs/mft.c

1908

folio_mark_uptodate(folio);

fs/ntfs/mft.c

1914

ntfs_mft_mark_dirty(folio);

fs/ntfs/mft.c

1915

folio_unlock(folio);

fs/ntfs/mft.c

1917

folio_put(folio);

fs/ntfs/mft.c

2019

struct folio *folio;

fs/ntfs/mft.c

208

if (ni->folio)

fs/ntfs/mft.c

2303

folio = read_mapping_folio(vol->mft_ino->i_mapping, index, NULL);

fs/ntfs/mft.c

2304

if (IS_ERR(folio)) {

fs/ntfs/mft.c

2307

err = PTR_ERR(folio);

fs/ntfs/mft.c

2310

folio_lock(folio);

fs/ntfs/mft.c

2311

folio_clear_uptodate(folio);

fs/ntfs/mft.c

2312

m = (struct mft_record *)((u8 *)kmap_local_folio(folio, 0) + ofs);

fs/ntfs/mft.c

2321

folio_mark_uptodate(folio);

fs/ntfs/mft.c

2322

folio_unlock(folio);

fs/ntfs/mft.c

2324

folio_put(folio);

fs/ntfs/mft.c

2341

folio_mark_uptodate(folio);

fs/ntfs/mft.c

2342

folio_unlock(folio);

fs/ntfs/mft.c

2344

folio_put(folio);

fs/ntfs/mft.c

2357

folio_mark_uptodate(folio);

fs/ntfs/mft.c

236

struct folio *folio;

fs/ntfs/mft.c

2384

ntfs_mft_mark_dirty(folio);

fs/ntfs/mft.c

2385

folio_unlock(folio);

fs/ntfs/mft.c

2387

folio_put(folio);

fs/ntfs/mft.c

2398

ntfs_mft_mark_dirty(folio);

fs/ntfs/mft.c

2399

folio_unlock(folio);

fs/ntfs/mft.c

2405

folio_put(folio);

fs/ntfs/mft.c

2425

folio_unlock(folio);

fs/ntfs/mft.c

2427

folio_put(folio);

fs/ntfs/mft.c

243

folio = ni->folio;

fs/ntfs/mft.c

2434

ntfs_mft_mark_dirty(folio);

fs/ntfs/mft.c

2435

folio_unlock(folio);

fs/ntfs/mft.c

2436

(*ni)->folio = folio;

fs/ntfs/mft.c

246

WARN_ON(!folio);

fs/ntfs/mft.c

2620

static int ntfs_write_mft_block(struct folio *folio, struct writeback_control *wbc)

fs/ntfs/mft.c

2622

struct address_space *mapping = folio->mapping;

fs/ntfs/mft.c

2637

s64 vcn = ntfs_pidx_to_cluster(vol, folio->index);

fs/ntfs/mft.c

2643

ni->mft_no, ni->type, folio->index);

fs/ntfs/mft.c

2646

folio_redirty_for_writepage(wbc, folio);

fs/ntfs/mft.c

2647

folio_unlock(folio);

fs/ntfs/mft.c

2652

if (folio->index >= (i_size >> folio_shift(folio)))

fs/ntfs/mft.c

2654

folio_zero_segment(folio,

fs/ntfs/mft.c

2655

offset_in_folio(folio, i_size),

fs/ntfs/mft.c

2656

folio_size(folio));

fs/ntfs/mft.c

2658

lcn = lcn_from_index(vol, ni, folio->index);

fs/ntfs/mft.c

2660

folio_start_writeback(folio);

fs/ntfs/mft.c

2661

folio_unlock(folio);

fs/ntfs/mft.c

2662

folio_end_writeback(folio);

fs/ntfs/mft.c

2667

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/mft.c

2669

folio_clear_uptodate(folio);

fs/ntfs/mft.c

2674

mft_no = (((s64)folio->index << PAGE_SHIFT) + mft_ofs) >>

fs/ntfs/mft.c

2703

if (vol->cluster_size < folio_size(folio)) {

fs/ntfs/mft.c

2745

if (!bio_add_folio(bio, folio, folio_sz,

fs/ntfs/mft.c

2775

folio_mark_uptodate(folio);

fs/ntfs/mft.c

2778

folio_start_writeback(folio);

fs/ntfs/mft.c

2779

folio_unlock(folio);

fs/ntfs/mft.c

2780

folio_end_writeback(folio);

fs/ntfs/mft.c

2831

struct folio *folio = NULL;

fs/ntfs/mft.c

2837

while ((folio = writeback_iter(mapping, wbc, folio, &error)))

fs/ntfs/mft.c

2838

error = ntfs_write_mft_block(folio, wbc);

fs/ntfs/mft.c

2842

void ntfs_mft_mark_dirty(struct folio *folio)

fs/ntfs/mft.c

2844

iomap_dirty_folio(folio->mapping, folio);

fs/ntfs/mft.c

442

folio_put((struct folio *)bio->bi_private);

fs/ntfs/mft.c

464

struct folio *folio;

fs/ntfs/mft.c

477

folio = read_mapping_folio(vol->mftmirr_ino->i_mapping,

fs/ntfs/mft.c

479

if (IS_ERR(folio)) {

fs/ntfs/mft.c

481

err = PTR_ERR(folio);

fs/ntfs/mft.c

485

folio_lock(folio);

fs/ntfs/mft.c

486

folio_clear_uptodate(folio);

fs/ntfs/mft.c

490

kmirr = kmap_local_folio(folio, 0) + folio_ofs;

fs/ntfs/mft.c

496

lcn_folio_off = folio->index << PAGE_SHIFT;

fs/ntfs/mft.c

505

if (bio_add_folio(bio, folio, vol->mft_record_size, folio_ofs))

fs/ntfs/mft.c

518

folio_mark_uptodate(folio);

fs/ntfs/mft.c

520

folio_unlock(folio);

fs/ntfs/mft.c

521

folio_put(folio);

fs/ntfs/mft.c

554

struct folio *folio = ni->folio;

fs/ntfs/mft.c

564

WARN_ON(!folio_test_locked(folio));

fs/ntfs/mft.c

575

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/mft.c

598

if (!bio_add_folio(bio, folio, folio_size,

fs/ntfs/mft.c

619

folio_get(folio);

fs/ntfs/mft.c

620

bio->bi_private = folio;

fs/ntfs/mft.c

870

struct folio *folio;

fs/ntfs/mft.c

927

folio = read_mapping_folio(mftbmp_mapping,

fs/ntfs/mft.c

929

if (IS_ERR(folio)) {

fs/ntfs/mft.c

931

return PTR_ERR(folio);

fs/ntfs/mft.c

933

folio_lock(folio);

fs/ntfs/mft.c

934

buf = (u8 *)kmap_local_folio(folio, 0) + folio_ofs;

fs/ntfs/mft.c

947

folio_unlock(folio);

fs/ntfs/mft.c

949

folio_put(folio);

fs/ntfs/mft.c

960

folio_unlock(folio);

fs/ntfs/mft.c

962

folio_put(folio);

fs/ntfs/mft.c

966

folio_mark_dirty(folio);

fs/ntfs/mft.c

967

folio_unlock(folio);

fs/ntfs/mft.c

969

folio_put(folio);

fs/ntfs/mft.c

978

folio_unlock(folio);

fs/ntfs/mft.c

980

folio_put(folio);

fs/ntfs/mft.h

69

struct folio *folio = ni->folio;

fs/ntfs/mft.h

72

folio_lock(folio);

fs/ntfs/mft.h

74

folio_unlock(folio);

fs/ntfs/mft.h

89

void ntfs_mft_mark_dirty(struct folio *folio);

fs/ntfs/ntfs.h

204

int ntfs_read_compressed_block(struct folio *folio);

fs/ntfs/super.c

1149

struct folio *folio;

fs/ntfs/super.c

1189

folio = read_mapping_folio(vi->i_mapping, 0, NULL);

fs/ntfs/super.c

1190

if (IS_ERR(folio)) {

fs/ntfs/super.c

1192

ret = PTR_ERR(folio);

fs/ntfs/super.c

1195

start_addr = (u32 *)kmap_local_folio(folio, 0);

fs/ntfs/super.c

1213

folio_put(folio);

fs/ntfs/super.c

1230

struct folio *folio;

fs/ntfs/super.c

1257

folio = read_mapping_folio(ino->i_mapping, index, NULL);

fs/ntfs/super.c

1258

if (IS_ERR(folio))

fs/ntfs/super.c

1260

addr = kmap_local_folio(folio, 0);

fs/ntfs/super.c

1264

folio_put(folio);

fs/ntfs/super.c

1296

struct folio *folio;

fs/ntfs/super.c

1326

folio = read_mapping_folio(ino->i_mapping, index, NULL);

fs/ntfs/super.c

1327

if (IS_ERR(folio))

fs/ntfs/super.c

1329

addr = kmap_local_folio(folio, 0);

fs/ntfs/super.c

1333

folio_put(folio);

fs/ntfs/super.c

1899

struct folio *folio;

fs/ntfs/super.c

1928

folio = ntfs_get_locked_folio(mapping, index, max_index, &ra);

fs/ntfs/super.c

1931

if (IS_ERR(folio)) {

fs/ntfs/super.c

1938

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/super.c

1950

folio_unlock(folio);

fs/ntfs/super.c

1951

folio_put(folio);

fs/ntfs/super.c

2019

struct folio *folio;

fs/ntfs/super.c

2037

folio = ntfs_get_locked_folio(mapping, index, max_index, &ra);

fs/ntfs/super.c

2040

if (IS_ERR(folio)) {

fs/ntfs/super.c

2047

kaddr = kmap_local_folio(folio, 0);

fs/ntfs/super.c

2058

folio_unlock(folio);

fs/ntfs/super.c

2059

folio_put(folio);

fs/ntfs/super.c

961

struct folio *mft_folio = NULL, *mirr_folio = NULL;

fs/ntfs3/attrib.c

1394

int attr_data_write_resident(struct ntfs_inode *ni, struct folio *folio)

fs/ntfs3/attrib.c

1410

vbo = folio_pos(folio);

fs/ntfs3/attrib.c

1414

size_t len = min(data_size - vbo, folio_size(folio));

fs/ntfs3/attrib.c

1416

memcpy_from_folio(data + vbo, folio, 0, len);

fs/ntfs3/attrib.c

1517

struct folio *folio;

fs/ntfs3/attrib.c

1562

folio = ni->file.offs_folio;

fs/ntfs3/attrib.c

1563

if (!folio) {

fs/ntfs3/attrib.c

1564

folio = folio_alloc(GFP_KERNEL, 0);

fs/ntfs3/attrib.c

1565

if (!folio) {

fs/ntfs3/attrib.c

1569

folio->index = -1;

fs/ntfs3/attrib.c

1570

ni->file.offs_folio = folio;

fs/ntfs3/attrib.c

1572

folio_lock(folio);

fs/ntfs3/attrib.c

1573

addr = folio_address(folio);

fs/ntfs3/attrib.c

1589

if (index != folio->index) {

fs/ntfs3/attrib.c

1607

folio->index = -1;

fs/ntfs3/attrib.c

1610

folio->index = index;

fs/ntfs3/attrib.c

1648

folio_unlock(folio);

fs/ntfs3/attrib.c

320

struct folio *folio;

fs/ntfs3/attrib.c

322

folio = __filemap_get_folio(

fs/ntfs3/attrib.c

325

if (IS_ERR(folio)) {

fs/ntfs3/attrib.c

326

err = PTR_ERR(folio);

fs/ntfs3/attrib.c

329

folio_fill_tail(folio, 0, data, rsize);

fs/ntfs3/attrib.c

330

folio_mark_uptodate(folio);

fs/ntfs3/attrib.c

331

folio_mark_dirty(folio);

fs/ntfs3/attrib.c

332

folio_unlock(folio);

fs/ntfs3/attrib.c

333

folio_put(folio);

fs/ntfs3/file.c

1041

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1042

folio_unlock(folio);

fs/ntfs3/file.c

1043

folio_put(folio);

fs/ntfs3/file.c

1052

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1053

folio_zero_segment(folio, off, PAGE_SIZE);

fs/ntfs3/file.c

1054

flush_dcache_folio(folio);

fs/ntfs3/file.c

1055

folio_mark_uptodate(folio);

fs/ntfs3/file.c

1063

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1064

folio_mark_uptodate(folio);

fs/ntfs3/file.c

1065

folio_unlock(folio);

fs/ntfs3/file.c

1066

folio_put(folio);

fs/ntfs3/file.c

1107

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1108

folio_unlock(folio);

fs/ntfs3/file.c

1109

folio_put(folio);

fs/ntfs3/file.c

1125

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1127

folio, off, min(tail, bytes), from);

fs/ntfs3/file.c

1128

flush_dcache_folio(folio);

fs/ntfs3/file.c

1148

folio = page_folio(pages[ip]);

fs/ntfs3/file.c

1149

folio_clear_dirty(folio);

fs/ntfs3/file.c

1150

folio_mark_uptodate(folio);

fs/ntfs3/file.c

1151

folio_unlock(folio);

fs/ntfs3/file.c

1152

folio_put(folio);

fs/ntfs3/file.c

342

struct folio *folio = fbatch.folios[i];

fs/ntfs3/file.c

343

u32 st = folio_pos(folio) < from ?

fs/ntfs3/file.c

344

offset_in_folio(folio, from) :

fs/ntfs3/file.c

347

folio_lock(folio);

fs/ntfs3/file.c

348

folio_zero_segment(folio, st, folio_size(folio));

fs/ntfs3/file.c

350

folio_unlock(folio);

fs/ntfs3/file.c

938

struct folio *folio;

fs/ntfs3/file.c

940

folio = __filemap_get_folio(mapping, index,

fs/ntfs3/file.c

943

if (IS_ERR(folio)) {

fs/ntfs3/file.c

945

folio = page_folio(pages[npages]);

fs/ntfs3/file.c

946

folio_unlock(folio);

fs/ntfs3/file.c

947

folio_put(folio);

fs/ntfs3/file.c

953

if (!folio_test_uptodate(folio))

fs/ntfs3/file.c

956

pages[npages] = &folio->page;

fs/ntfs3/file.c

978

struct folio *folio;

fs/ntfs3/frecord.c

1855

static struct folio *ntfs_lock_new_page(struct address_space *mapping,

fs/ntfs3/frecord.c

1858

struct folio *folio = __filemap_get_folio(

fs/ntfs3/frecord.c

1861

if (IS_ERR(folio))

fs/ntfs3/frecord.c

1862

return folio;

fs/ntfs3/frecord.c

1864

if (!folio_test_uptodate(folio)) {

fs/ntfs3/frecord.c

1865

struct page *page = folio_file_page(folio, index);

fs/ntfs3/frecord.c

1873

folio_unlock(folio);

fs/ntfs3/frecord.c

1874

folio_put(folio);

fs/ntfs3/frecord.c

1875

folio = folio_alloc(gfp, 0);

fs/ntfs3/frecord.c

1876

if (!folio)

fs/ntfs3/frecord.c

1878

__folio_set_locked(folio);

fs/ntfs3/frecord.c

1879

return folio;

fs/ntfs3/frecord.c

1888

int ni_read_folio_cmpr(struct ntfs_inode *ni, struct folio *folio)

fs/ntfs3/frecord.c

1892

struct address_space *mapping = folio->mapping;

fs/ntfs3/frecord.c

1894

u64 frame_vbo, vbo = folio_pos(folio);

fs/ntfs3/frecord.c

1901

struct folio *f;

fs/ntfs3/frecord.c

1904

folio_zero_range(folio, 0, folio_size(folio));

fs/ntfs3/frecord.c

1905

folio_mark_uptodate(folio);

fs/ntfs3/frecord.c

1929

pages[idx] = &folio->page;

fs/ntfs3/frecord.c

1961

folio_unlock(folio);

fs/ntfs3/frecord.c

2031

struct folio *f;

fs/ntfs3/frecord.c

2488

struct folio *folio = page_folio(pages[0]);

fs/ntfs3/frecord.c

2491

u64 frame_vbo = folio_pos(folio);

fs/ntfs3/fsntfs.c

1523

struct folio *folio;

fs/ntfs3/fsntfs.c

1541

folio = read_mapping_folio(mapping, lbo >> PAGE_SHIFT, NULL);

fs/ntfs3/fsntfs.c

1543

if (IS_ERR(folio))

fs/ntfs3/fsntfs.c

1544

return PTR_ERR(folio);

fs/ntfs3/fsntfs.c

1554

kaddr = kmap_local_folio(folio, 0);

fs/ntfs3/fsntfs.c

1557

folio_mark_dirty(folio);

fs/ntfs3/fsntfs.c

1560

flush_dcache_folio(folio);

fs/ntfs3/fsntfs.c

1563

folio_put(folio);

fs/ntfs3/inode.c

1010

struct folio *folio = NULL;

fs/ntfs3/inode.c

1013

while ((folio = writeback_iter(mapping, wbc, folio, &err))) {

fs/ntfs3/inode.c

1017

err2 = attr_data_write_resident(ni, folio);

fs/ntfs3/inode.c

1020

folio_unlock(folio);

fs/ntfs3/inode.c

588

struct folio *folio = fi.folio;

fs/ntfs3/inode.c

589

struct inode *inode = folio->mapping->host;

fs/ntfs3/inode.c

592

u32 f_size = folio_size(folio);

fs/ntfs3/inode.c

593

loff_t f_pos = folio_pos(folio);

fs/ntfs3/inode.c

598

offset_in_folio(folio, valid);

fs/ntfs3/inode.c

600

folio_zero_segment(folio, z_from, f_size);

fs/ntfs3/inode.c

603

iomap_finish_folio_read(folio, fi.offset, fi.length, error);

fs/ntfs3/inode.c

619

static int ntfs_read_folio(struct file *file, struct folio *folio)

fs/ntfs3/inode.c

622

struct address_space *mapping = folio->mapping;

fs/ntfs3/inode.c

625

loff_t vbo = folio_pos(folio);

fs/ntfs3/inode.c

627

.cur_folio = folio,

fs/ntfs3/inode.c

632

folio_unlock(folio);

fs/ntfs3/inode.c

637

folio_zero_range(folio, 0, folio_size(folio));

fs/ntfs3/inode.c

638

folio_mark_uptodate(folio);

fs/ntfs3/inode.c

639

folio_unlock(folio);

fs/ntfs3/inode.c

645

err = ni_read_folio_cmpr(ni, folio);

fs/ntfs3/inode.c

934

unsigned int len, struct folio *folio)

fs/ntfs3/inode.c

938

u32 f_size = folio_size(folio);

fs/ntfs3/inode.c

939

loff_t f_pos = folio_pos(folio);

fs/ntfs3/inode.c

945

folio_zero_segment(folio, offset_in_folio(folio, end), f_size);

fs/ntfs3/inode.c

947

folio_unlock(folio);

fs/ntfs3/inode.c

948

folio_put(folio);

fs/ntfs3/inode.c

955

struct folio *folio, u64 offset,

fs/ntfs3/inode.c

982

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/ntfs3/ntfs_fs.h

411

struct folio *offs_folio;

fs/ntfs3/ntfs_fs.h

475

int attr_data_write_resident(struct ntfs_inode *ni, struct folio *folio);

fs/ntfs3/ntfs_fs.h

600

int ni_read_folio_cmpr(struct ntfs_inode *ni, struct folio *folio);

fs/ocfs2/alloc.c

6846

size_t from, size_t to, struct folio *folio, int zero,

fs/ocfs2/alloc.c

6850

loff_t start_byte = folio_pos(folio) + from;

fs/ocfs2/alloc.c

6853

ret = ocfs2_map_folio_blocks(folio, phys, inode, from, to, 0);

fs/ocfs2/alloc.c

6858

folio_zero_segment(folio, from, to);

fs/ocfs2/alloc.c

6865

ret = walk_page_buffers(handle, folio_buffers(folio),

fs/ocfs2/alloc.c

6878

folio_mark_uptodate(folio);

fs/ocfs2/alloc.c

6880

flush_dcache_folio(folio);

fs/ocfs2/alloc.c

6884

loff_t end, struct folio **folios, int numfolios,

fs/ocfs2/alloc.c

6896

struct folio *folio = folios[i];

fs/ocfs2/alloc.c

6897

size_t to = folio_size(folio);

fs/ocfs2/alloc.c

6898

size_t from = offset_in_folio(folio, start);

fs/ocfs2/alloc.c

6900

if (to > end - folio_pos(folio))

fs/ocfs2/alloc.c

6901

to = end - folio_pos(folio);

fs/ocfs2/alloc.c

6903

ocfs2_map_and_dirty_folio(inode, handle, from, to, folio, 1,

fs/ocfs2/alloc.c

6906

start = folio_next_pos(folio);

fs/ocfs2/alloc.c

6914

struct folio **folios, int *num)

fs/ocfs2/alloc.c

6952

struct folio **folios, int *num)

fs/ocfs2/alloc.c

6974

struct folio **folios = NULL;

fs/ocfs2/alloc.c

6995

folios = kzalloc_objs(struct folio *, ocfs2_pages_per_cluster(sb),

fs/ocfs2/alloc.c

7101

struct folio *folio = NULL;

fs/ocfs2/alloc.c

7156

ret = ocfs2_grab_eof_folios(inode, 0, page_end, &folio,

fs/ocfs2/alloc.c

7168

ret = ocfs2_read_inline_data(inode, folio, di_bh);

fs/ocfs2/alloc.c

7175

ocfs2_map_and_dirty_folio(inode, handle, 0, page_end, folio, 0,

fs/ocfs2/alloc.c

7207

if (folio)

fs/ocfs2/alloc.c

7208

ocfs2_unlock_and_free_folios(&folio, num_folios);

fs/ocfs2/alloc.h

258

size_t from, size_t to, struct folio *folio, int zero,

fs/ocfs2/aops.c

1006

unsigned user_len, int new, struct folio *mmap_folio)

fs/ocfs2/aops.c

1456

struct folio *folio;

fs/ocfs2/aops.c

1467

folio = __filemap_get_folio(mapping, 0,

fs/ocfs2/aops.c

1469

if (IS_ERR(folio)) {

fs/ocfs2/aops.c

1471

ret = PTR_ERR(folio);

fs/ocfs2/aops.c

1479

wc->w_target_folio = folio;

fs/ocfs2/aops.c

1480

wc->w_folios[0] = folio;

fs/ocfs2/aops.c

1495

if (!folio_test_uptodate(folio)) {

fs/ocfs2/aops.c

1496

ret = ocfs2_read_inline_data(inode, folio, wc->w_di_bh);

fs/ocfs2/aops.c

1520

struct folio *mmap_folio, struct ocfs2_write_ctxt *wc)

fs/ocfs2/aops.c

1627

struct folio **foliop, void **fsdata,

fs/ocfs2/aops.c

1628

struct buffer_head *di_bh, struct folio *mmap_folio)

fs/ocfs2/aops.c

1864

struct folio **foliop, void **fsdata)

fs/ocfs2/aops.c

1981

struct folio *folio = wc->w_folios[i];

fs/ocfs2/aops.c

1984

if (folio == NULL)

fs/ocfs2/aops.c

1987

if (folio == wc->w_target_folio) {

fs/ocfs2/aops.c

1991

BUG_ON(from > folio_size(folio) ||

fs/ocfs2/aops.c

1992

to > folio_size(folio) ||

fs/ocfs2/aops.c

2001

to = folio_size(folio);

fs/ocfs2/aops.c

2004

if (folio_buffers(folio)) {

fs/ocfs2/aops.c

2006

loff_t start_byte = folio_pos(folio) + from;

fs/ocfs2/aops.c

2011

block_commit_write(folio, from, to);

fs/ocfs2/aops.c

2056

struct folio *folio, void *fsdata)

fs/ocfs2/aops.c

213

int ocfs2_read_inline_data(struct inode *inode, struct folio *folio,

fs/ocfs2/aops.c

227

if (size > folio_size(folio) ||

fs/ocfs2/aops.c

236

folio_fill_tail(folio, 0, di->id2.i_data.id_data, size);

fs/ocfs2/aops.c

237

folio_mark_uptodate(folio);

fs/ocfs2/aops.c

242

static int ocfs2_readpage_inline(struct inode *inode, struct folio *folio)

fs/ocfs2/aops.c

247

BUG_ON(!folio_test_locked(folio));

fs/ocfs2/aops.c

256

ret = ocfs2_read_inline_data(inode, folio, di_bh);

fs/ocfs2/aops.c

258

folio_unlock(folio);

fs/ocfs2/aops.c

264

static int ocfs2_read_folio(struct file *file, struct folio *folio)

fs/ocfs2/aops.c

266

struct inode *inode = folio->mapping->host;

fs/ocfs2/aops.c

268

loff_t start = folio_pos(folio);

fs/ocfs2/aops.c

271

trace_ocfs2_readpage((unsigned long long)oi->ip_blkno, folio->index);

fs/ocfs2/aops.c

273

ret = ocfs2_inode_lock_with_folio(inode, NULL, 0, folio);

fs/ocfs2/aops.c

287

folio_unlock(folio);

fs/ocfs2/aops.c

305

folio_zero_segment(folio, 0, folio_size(folio));

fs/ocfs2/aops.c

306

folio_mark_uptodate(folio);

fs/ocfs2/aops.c

312

ret = ocfs2_readpage_inline(inode, folio);

fs/ocfs2/aops.c

314

ret = block_read_full_folio(folio, ocfs2_get_block);

fs/ocfs2/aops.c

323

folio_unlock(folio);

fs/ocfs2/aops.c

482

static bool ocfs2_release_folio(struct folio *folio, gfp_t wait)

fs/ocfs2/aops.c

484

if (!folio_buffers(folio))

fs/ocfs2/aops.c

486

return try_to_free_buffers(folio);

fs/ocfs2/aops.c

524

static void ocfs2_clear_folio_regions(struct folio *folio,

fs/ocfs2/aops.c

533

kaddr = kmap_local_folio(folio, 0);

fs/ocfs2/aops.c

554

static int ocfs2_should_read_blk(struct inode *inode, struct folio *folio,

fs/ocfs2/aops.c

557

u64 offset = folio_pos(folio) + block_start;

fs/ocfs2/aops.c

575

int ocfs2_map_folio_blocks(struct folio *folio, u64 *p_blkno,

fs/ocfs2/aops.c

584

head = folio_buffers(folio);

fs/ocfs2/aops.c

586

head = create_empty_buffers(folio, bsize, 0);

fs/ocfs2/aops.c

599

if (folio_test_uptodate(folio))

fs/ocfs2/aops.c

616

if (folio_test_uptodate(folio)) {

fs/ocfs2/aops.c

620

ocfs2_should_read_blk(inode, folio, block_start) &&

fs/ocfs2/aops.c

654

folio_zero_range(folio, block_start, bh->b_size);

fs/ocfs2/aops.c

730

struct folio *w_folios[OCFS2_MAX_CTXT_PAGES];

fs/ocfs2/aops.c

731

struct folio *w_target_folio;

fs/ocfs2/aops.c

760

void ocfs2_unlock_and_free_folios(struct folio **folios, int num_folios)

fs/ocfs2/aops.c

858

static void ocfs2_zero_new_buffers(struct folio *folio, size_t from, size_t to)

fs/ocfs2/aops.c

863

BUG_ON(!folio_test_locked(folio));

fs/ocfs2/aops.c

864

head = folio_buffers(folio);

fs/ocfs2/aops.c

875

if (!folio_test_uptodate(folio)) {

fs/ocfs2/aops.c

881

folio_zero_segment(folio, start, end);

fs/ocfs2/aops.c

911

struct folio *folio = wc->w_folios[i];

fs/ocfs2/aops.c

913

if (folio && folio_buffers(folio)) {

fs/ocfs2/aops.c

918

block_commit_write(folio, from, to);

fs/ocfs2/aops.c

924

struct ocfs2_write_ctxt *wc, struct folio *folio, u32 cpos,

fs/ocfs2/aops.c

938

new = new | ((i_size_read(inode) <= folio_pos(folio)) &&

fs/ocfs2/aops.c

939

(folio_pos(folio) <= user_pos));

fs/ocfs2/aops.c

941

if (folio == wc->w_target_folio) {

fs/ocfs2/aops.c

946

ret = ocfs2_map_folio_blocks(folio, p_blkno, inode,

fs/ocfs2/aops.c

949

ret = ocfs2_map_folio_blocks(folio, p_blkno, inode,

fs/ocfs2/aops.c

973

ret = ocfs2_map_folio_blocks(folio, p_blkno, inode,

fs/ocfs2/aops.c

991

if (new && !folio_test_uptodate(folio))

fs/ocfs2/aops.c

992

ocfs2_clear_folio_regions(folio, OCFS2_SB(inode->i_sb),

fs/ocfs2/aops.c

995

flush_dcache_folio(folio);

fs/ocfs2/aops.h

11

int ocfs2_map_folio_blocks(struct folio *folio, u64 *p_blkno,

fs/ocfs2/aops.h

15

void ocfs2_unlock_and_free_folios(struct folio **folios, int num_folios);

fs/ocfs2/aops.h

36

struct folio **foliop, void **fsdata,

fs/ocfs2/aops.h

37

struct buffer_head *di_bh, struct folio *mmap_folio);

fs/ocfs2/aops.h

39

int ocfs2_read_inline_data(struct inode *inode, struct folio *folio,

fs/ocfs2/cluster/tcp.c

2097

struct folio *folio;

fs/ocfs2/cluster/tcp.c

2104

folio = folio_alloc(GFP_KERNEL | __GFP_ZERO, 0);

fs/ocfs2/cluster/tcp.c

2105

if (!folio)

fs/ocfs2/cluster/tcp.c

2108

p = folio_address(folio);

fs/ocfs2/dlmglue.c

2548

struct buffer_head **ret_bh, int ex, struct folio *folio)

fs/ocfs2/dlmglue.c

2554

folio_unlock(folio);

fs/ocfs2/dlmglue.h

141

struct buffer_head **ret_bh, int ex, struct folio *folio);

fs/ocfs2/file.c

764

struct folio *folio;

fs/ocfs2/file.c

783

folio = __filemap_get_folio(mapping, index,

fs/ocfs2/file.c

785

if (IS_ERR(folio)) {

fs/ocfs2/file.c

786

ret = PTR_ERR(folio);

fs/ocfs2/file.c

792

zero_from = offset_in_folio(folio, abs_from);

fs/ocfs2/file.c

793

zero_to = offset_in_folio(folio, abs_to);

fs/ocfs2/file.c

795

zero_to = folio_size(folio);

fs/ocfs2/file.c

813

ret = __block_write_begin(folio, block_start + 1, 0,

fs/ocfs2/file.c

822

block_commit_write(folio, block_start + 1, block_start + 1);

fs/ocfs2/file.c

843

folio_unlock(folio);

fs/ocfs2/file.c

844

folio_put(folio);

fs/ocfs2/mmap.c

114

struct folio *folio = page_folio(vmf->page);

fs/ocfs2/mmap.c

143

ret = __ocfs2_page_mkwrite(vmf->vma->vm_file, di_bh, folio);

fs/ocfs2/mmap.c

46

struct buffer_head *di_bh, struct folio *folio)

fs/ocfs2/mmap.c

52

loff_t pos = folio_pos(folio);

fs/ocfs2/mmap.c

55

struct folio *locked_folio = NULL;

fs/ocfs2/mmap.c

74

if ((folio->mapping != inode->i_mapping) ||

fs/ocfs2/mmap.c

75

!folio_test_uptodate(folio) ||

fs/ocfs2/mmap.c

89

if (folio->index == last_index)

fs/ocfs2/mmap.c

93

&locked_folio, &fsdata, di_bh, folio);

fs/ocfs2/refcounttree.c

2928

struct folio *folio;

fs/ocfs2/refcounttree.c

2941

folio = __filemap_get_folio(mapping, page_index,

fs/ocfs2/refcounttree.c

2943

if (IS_ERR(folio)) {

fs/ocfs2/refcounttree.c

2944

ret = PTR_ERR(folio);

fs/ocfs2/refcounttree.c

2954

if (folio_test_dirty(folio)) {

fs/ocfs2/refcounttree.c

2955

folio_unlock(folio);

fs/ocfs2/refcounttree.c

2956

folio_put(folio);

fs/ocfs2/refcounttree.c

2964

if (!folio_test_uptodate(folio)) {

fs/ocfs2/refcounttree.c

2965

ret = block_read_full_folio(folio, ocfs2_get_block);

fs/ocfs2/refcounttree.c

2970

folio_lock(folio);

fs/ocfs2/refcounttree.c

2973

if (folio_buffers(folio)) {

fs/ocfs2/refcounttree.c

2974

ret = walk_page_buffers(handle, folio_buffers(folio),

fs/ocfs2/refcounttree.c

2984

folio, 0, &new_block);

fs/ocfs2/refcounttree.c

2985

folio_mark_accessed(folio);

fs/ocfs2/refcounttree.c

2987

folio_unlock(folio);

fs/ocfs2/refcounttree.c

2988

folio_put(folio);

fs/ocfs2/symlink.c

55

static int ocfs2_fast_symlink_read_folio(struct file *f, struct folio *folio)

fs/ocfs2/symlink.c

57

struct inode *inode = folio->mapping->host;

fs/ocfs2/symlink.c

73

memcpy_to_folio(folio, 0, link, len + 1);

fs/ocfs2/symlink.c

75

folio_end_read(folio, status == 0);

fs/omfs/file.c

287

static int omfs_read_folio(struct file *file, struct folio *folio)

fs/omfs/file.c

289

return block_read_full_folio(folio, omfs_get_block);

fs/omfs/file.c

316

struct folio **foliop, void **fsdata)

fs/orangefs/inode.c

124

static int orangefs_writepages_callback(struct folio *folio,

fs/orangefs/inode.c

127

struct orangefs_write_range *wr = folio->private;

fs/orangefs/inode.c

131

folio_unlock(folio);

fs/orangefs/inode.c

144

ow->folios[ow->nfolios++] = folio;

fs/orangefs/inode.c

156

ow->folios[ow->nfolios++] = folio;

fs/orangefs/inode.c

166

ret = orangefs_writepage_locked(folio, wbc);

fs/orangefs/inode.c

167

mapping_set_error(folio->mapping, ret);

fs/orangefs/inode.c

168

folio_unlock(folio);

fs/orangefs/inode.c

169

folio_end_writeback(folio);

fs/orangefs/inode.c

185

struct folio *folio = NULL;

fs/orangefs/inode.c

19

static int orangefs_writepage_locked(struct folio *folio,

fs/orangefs/inode.c

191

ow->folios = kzalloc_objs(struct folio *, ow->maxpages);

fs/orangefs/inode.c

204

while ((folio = writeback_iter(mapping, wbc, folio, &error)))

fs/orangefs/inode.c

205

error = orangefs_writepages_callback(folio, wbc, ow);

fs/orangefs/inode.c

215

static int orangefs_launder_folio(struct folio *);

fs/orangefs/inode.c

22

struct inode *inode = folio->mapping->host;

fs/orangefs/inode.c

223

struct folio *folio;

fs/orangefs/inode.c

272

while ((folio = readahead_folio(rac))) {

fs/orangefs/inode.c

274

folio_mark_uptodate(folio);

fs/orangefs/inode.c

275

folio_unlock(folio);

fs/orangefs/inode.c

279

static int orangefs_read_folio(struct file *file, struct folio *folio)

fs/orangefs/inode.c

281

struct inode *inode = folio->mapping->host;

fs/orangefs/inode.c

287

if (folio_test_dirty(folio))

fs/orangefs/inode.c

288

orangefs_launder_folio(folio);

fs/orangefs/inode.c

290

off = folio_pos(folio);

fs/orangefs/inode.c

291

bvec_set_folio(&bv, folio, folio_size(folio), 0);

fs/orangefs/inode.c

292

iov_iter_bvec(&iter, ITER_DEST, &bv, 1, folio_size(folio));

fs/orangefs/inode.c

295

folio_size(folio), inode->i_size, NULL, NULL, file);

fs/orangefs/inode.c

299

flush_dcache_folio(folio);

fs/orangefs/inode.c

30

folio_start_writeback(folio);

fs/orangefs/inode.c

302

folio_end_read(folio, ret == 0);

fs/orangefs/inode.c

308

unsigned len, struct folio **foliop,

fs/orangefs/inode.c

312

struct folio *folio;

fs/orangefs/inode.c

315

folio = __filemap_get_folio(mapping, pos / PAGE_SIZE, FGP_WRITEBEGIN,

fs/orangefs/inode.c

317

if (IS_ERR(folio))

fs/orangefs/inode.c

318

return PTR_ERR(folio);

fs/orangefs/inode.c

320

*foliop = folio;

fs/orangefs/inode.c

322

if (folio_test_dirty(folio) && !folio_test_private(folio)) {

fs/orangefs/inode.c

328

ret = orangefs_launder_folio(folio);

fs/orangefs/inode.c

33

if (folio->private) {

fs/orangefs/inode.c

332

if (folio_test_private(folio)) {

fs/orangefs/inode.c

334

wr = folio_get_private(folio);

fs/orangefs/inode.c

34

wr = folio->private;

fs/orangefs/inode.c

343

ret = orangefs_launder_folio(folio);

fs/orangefs/inode.c

357

folio_attach_private(folio, wr);

fs/orangefs/inode.c

365

struct folio *folio, void *fsdata)

fs/orangefs/inode.c

367

struct inode *inode = folio->mapping->host;

fs/orangefs/inode.c

378

if (!folio_test_uptodate(folio)) {

fs/orangefs/inode.c

381

folio_zero_range(folio, from + copied, len - copied);

fs/orangefs/inode.c

384

if (pos == folio_pos(folio) &&

fs/orangefs/inode.c

386

folio_zero_segment(folio, from + copied, PAGE_SIZE);

fs/orangefs/inode.c

387

folio_mark_uptodate(folio);

fs/orangefs/inode.c

391

folio_mark_dirty(folio);

fs/orangefs/inode.c

392

folio_unlock(folio);

fs/orangefs/inode.c

393

folio_put(folio);

fs/orangefs/inode.c

399

static void orangefs_invalidate_folio(struct folio *folio,

fs/orangefs/inode.c

402

struct orangefs_write_range *wr = folio_get_private(folio);

fs/orangefs/inode.c

405

kfree(folio_detach_private(folio));

fs/orangefs/inode.c

408

} else if (folio_pos(folio) + offset <= wr->pos &&

fs/orangefs/inode.c

409

wr->pos + wr->len <= folio_pos(folio) + offset + length) {

fs/orangefs/inode.c

410

kfree(folio_detach_private(folio));

fs/orangefs/inode.c

412

folio_cancel_dirty(folio);

fs/orangefs/inode.c

415

} else if (wr->pos < folio_pos(folio) + offset &&

fs/orangefs/inode.c

416

wr->pos + wr->len <= folio_pos(folio) + offset + length &&

fs/orangefs/inode.c

417

folio_pos(folio) + offset < wr->pos + wr->len) {

fs/orangefs/inode.c

419

x = wr->pos + wr->len - (folio_pos(folio) + offset);

fs/orangefs/inode.c

425

} else if (folio_pos(folio) + offset <= wr->pos &&

fs/orangefs/inode.c

426

folio_pos(folio) + offset + length < wr->pos + wr->len &&

fs/orangefs/inode.c

427

wr->pos < folio_pos(folio) + offset + length) {

fs/orangefs/inode.c

429

x = folio_pos(folio) + offset + length - wr->pos;

fs/orangefs/inode.c

436

} else if (wr->pos < folio_pos(folio) + offset &&

fs/orangefs/inode.c

437

folio_pos(folio) + offset + length < wr->pos + wr->len) {

fs/orangefs/inode.c

44

off = folio_pos(folio);

fs/orangefs/inode.c

449

if (!((folio_pos(folio) + offset + length <= wr->pos) ^

fs/orangefs/inode.c

45

wlen = folio_size(folio);

fs/orangefs/inode.c

450

(wr->pos + wr->len <= folio_pos(folio) + offset))) {

fs/orangefs/inode.c

453

folio_pos(folio) + offset, length);

fs/orangefs/inode.c

465

orangefs_launder_folio(folio);

fs/orangefs/inode.c

468

static bool orangefs_release_folio(struct folio *folio, gfp_t foo)

fs/orangefs/inode.c

470

return !folio_test_private(folio);

fs/orangefs/inode.c

473

static void orangefs_free_folio(struct folio *folio)

fs/orangefs/inode.c

475

kfree(folio_detach_private(folio));

fs/orangefs/inode.c

478

static int orangefs_launder_folio(struct folio *folio)

fs/orangefs/inode.c

485

folio_wait_writeback(folio);

fs/orangefs/inode.c

486

if (folio_clear_dirty_for_io(folio)) {

fs/orangefs/inode.c

487

r = orangefs_writepage_locked(folio, &wbc);

fs/orangefs/inode.c

488

folio_end_writeback(folio);

fs/orangefs/inode.c

52

bvec_set_folio(&bv, folio, wlen, offset_in_folio(folio, off));

fs/orangefs/inode.c

58

mapping_set_error(folio->mapping, ret);

fs/orangefs/inode.c

62

kfree(folio_detach_private(folio));

fs/orangefs/inode.c

625

struct folio *folio = page_folio(vmf->page);

fs/orangefs/inode.c

639

folio_lock(folio);

fs/orangefs/inode.c

640

if (folio_test_dirty(folio) && !folio_test_private(folio)) {

fs/orangefs/inode.c

646

if (orangefs_launder_folio(folio)) {

fs/orangefs/inode.c

651

if (folio_test_private(folio)) {

fs/orangefs/inode.c

652

wr = folio_get_private(folio);

fs/orangefs/inode.c

659

if (orangefs_launder_folio(folio)) {

fs/orangefs/inode.c

674

folio_attach_private(folio, wr);

fs/orangefs/inode.c

678

if (folio->mapping != inode->i_mapping) {

fs/orangefs/inode.c

679

folio_unlock(folio);

fs/orangefs/inode.c

689

folio_mark_dirty(folio);

fs/orangefs/inode.c

690

folio_wait_stable(folio);

fs/orangefs/inode.c

74

struct folio **folios;

fs/orangefs/orangefs-bufmap.c

142

struct folio **folio_array;

fs/orangefs/orangefs-bufmap.c

162

struct folio **folio_array;

fs/orangefs/orangefs-bufmap.c

254

bufmap->folio_array = kzalloc_objs(struct folio *, bufmap->page_count);

fs/orangefs/orangefs-bufmap.c

279

struct folio *folio;

fs/orangefs/orangefs-bufmap.c

283

folio = page_folio(page);

fs/orangefs/orangefs-bufmap.c

284

num_pages = folio_nr_pages(folio);

fs/orangefs/orangefs-bufmap.c

289

if (bufmap->page_array[i + k] != folio_page(folio, k)) {

fs/orangefs/orangefs-bufmap.c

296

bufmap->folio_array[f++] = folio;

fs/orangefs/orangefs-bufmap.c

324

struct folio *folio;

fs/orangefs/orangefs-bufmap.c

378

kzalloc_objs(struct folio *, pages_per_desc);

fs/orangefs/orangefs-bufmap.c

406

folio = bufmap->folio_array[current_folio++];

fs/orangefs/orangefs-bufmap.c

407

remaining_pages = folio_nr_pages(folio);

fs/orangefs/orangefs-bufmap.c

410

folio = bufmap->folio_array[current_folio - 1];

fs/orangefs/orangefs-bufmap.c

418

folio;

fs/orangefs/orangefs-bufmap.c

656

struct folio *folio;

fs/orangefs/orangefs-bufmap.c

722

folio = to->folio_array[folio_index];

fs/orangefs/orangefs-bufmap.c

724

folio_avail = folio_nr_pages(folio) * PAGE_SIZE - folio_offset;

fs/orangefs/orangefs-bufmap.c

726

kaddr = kmap_local_folio(folio, folio_offset);

fs/orangefs/orangefs-bufmap.c

751

struct folio *folio;

fs/orangefs/orangefs-bufmap.c

819

folio = from->folio_array[folio_index];

fs/orangefs/orangefs-bufmap.c

821

folio_avail = folio_nr_pages(folio) * PAGE_SIZE - folio_offset;

fs/orangefs/orangefs-bufmap.c

824

kaddr = kmap_local_folio(folio, folio_offset);

fs/proc/internal.h

186

static inline int folio_precise_page_mapcount(struct folio *folio,

fs/proc/internal.h

193

if (folio_test_large(folio))

fs/proc/internal.h

194

mapcount += folio_entire_mapcount(folio);

fs/proc/internal.h

199

static inline int folio_precise_page_mapcount(struct folio *folio,

fs/proc/internal.h

221

static inline int folio_average_page_mapcount(struct folio *folio)

fs/proc/internal.h

225

if (!folio_test_large(folio))

fs/proc/internal.h

226

return atomic_read(&folio->_mapcount) + 1;

fs/proc/internal.h

228

mapcount = folio_large_mapcount(folio);

fs/proc/internal.h

231

entire_mapcount = folio_entire_mapcount(folio);

fs/proc/internal.h

237

avg = ((unsigned int)mapcount + folio_large_nr_pages(folio) / 2) >> folio_large_order(folio);

fs/proc/page.c

148

const struct folio *folio;

fs/proc/page.c

163

folio = &ps.folio_snapshot;

fs/proc/page.c

165

k = folio->flags.f;

fs/proc/page.c

166

mapping = (unsigned long)folio->mapping;

fs/proc/page.c

172

if (folio_mapped(folio))

fs/proc/page.c

188

if (folio_test_hugetlb(folio))

fs/proc/page.c

190

else if (folio_test_large(folio) &&

fs/proc/page.c

191

folio_test_large_rmappable(folio)) {

fs/proc/page.c

204

if (folio_test_offline(folio))

fs/proc/page.c

206

if (folio_test_pgtable(folio))

fs/proc/page.c

208

if (folio_test_slab(folio))

fs/proc/task_mmu.c

1011

mapcount = folio_precise_page_mapcount(folio, page);

fs/proc/task_mmu.c

1017

smaps_page_accumulate(mss, folio, PAGE_SIZE, pss,

fs/proc/task_mmu.c

1104

struct folio *folio;

fs/proc/task_mmu.c

1119

folio = page_folio(page);

fs/proc/task_mmu.c

1120

if (folio_test_anon(folio))

fs/proc/task_mmu.c

1122

else if (folio_test_swapbacked(folio))

fs/proc/task_mmu.c

1124

else if (folio_is_zone_device(folio))

fs/proc/task_mmu.c

1269

struct folio *folio = NULL;

fs/proc/task_mmu.c

1277

folio = page_folio(pte_page(ptent));

fs/proc/task_mmu.c

1283

folio = softleaf_to_folio(entry);

fs/proc/task_mmu.c

1286

if (folio) {

fs/proc/task_mmu.c

1288

if (!present || folio_maybe_mapped_shared(folio) ||

fs/proc/task_mmu.c

1689

struct folio *folio;

fs/proc/task_mmu.c

1697

folio = vm_normal_folio(vma, addr, pte);

fs/proc/task_mmu.c

1698

if (!folio)

fs/proc/task_mmu.c

1700

return folio_maybe_dma_pinned(folio);

fs/proc/task_mmu.c

1774

struct folio *folio;

fs/proc/task_mmu.c

1786

folio = pmd_folio(*pmd);

fs/proc/task_mmu.c

1790

folio_test_clear_young(folio);

fs/proc/task_mmu.c

1791

folio_clear_referenced(folio);

fs/proc/task_mmu.c

1813

folio = vm_normal_folio(vma, addr, ptent);

fs/proc/task_mmu.c

1814

if (!folio)

fs/proc/task_mmu.c

1819

folio_test_clear_young(folio);

fs/proc/task_mmu.c

1820

folio_clear_referenced(folio);

fs/proc/task_mmu.c

1974

static bool __folio_page_mapped_exclusively(struct folio *folio, struct page *page)

fs/proc/task_mmu.c

1977

return folio_precise_page_mapcount(folio, page) == 1;

fs/proc/task_mmu.c

1978

return !folio_maybe_mapped_shared(folio);

fs/proc/task_mmu.c

2026

struct folio *folio;

fs/proc/task_mmu.c

2072

folio = page_folio(page);

fs/proc/task_mmu.c

2073

if (!folio_test_anon(folio))

fs/proc/task_mmu.c

2076

__folio_page_mapped_exclusively(folio, page))

fs/proc/task_mmu.c

2096

struct folio *folio = NULL;

fs/proc/task_mmu.c

2136

folio = page_folio(page);

fs/proc/task_mmu.c

2137

if (!folio_test_anon(folio))

fs/proc/task_mmu.c

2146

if (folio && (flags & PM_PRESENT) &&

fs/proc/task_mmu.c

2147

__folio_page_mapped_exclusively(folio, page))

fs/proc/task_mmu.c

2226

struct folio *folio = page_folio(pte_page(pte));

fs/proc/task_mmu.c

2228

if (!folio_test_anon(folio))

fs/proc/task_mmu.c

2231

if (!folio_maybe_mapped_shared(folio) &&

fs/proc/task_mmu.c

3312

struct folio *folio = page_folio(page);

fs/proc/task_mmu.c

3316

count = folio_precise_page_mapcount(folio, page);

fs/proc/task_mmu.c

3318

count = folio_average_page_mapcount(folio);

fs/proc/task_mmu.c

3321

if (pte_dirty || folio_test_dirty(folio))

fs/proc/task_mmu.c

3324

if (folio_test_swapcache(folio))

fs/proc/task_mmu.c

3327

if (folio_test_active(folio) || folio_test_unevictable(folio))

fs/proc/task_mmu.c

3330

if (folio_test_writeback(folio))

fs/proc/task_mmu.c

3333

if (folio_test_anon(folio))

fs/proc/task_mmu.c

3339

md->node[folio_nid(folio)] += nr_pages;

fs/proc/task_mmu.c

918

struct folio *folio, unsigned long size, unsigned long pss,

fs/proc/task_mmu.c

923

if (folio_test_anon(folio))

fs/proc/task_mmu.c

925

else if (folio_test_swapbacked(folio))

fs/proc/task_mmu.c

933

if (dirty || folio_test_dirty(folio)) {

fs/proc/task_mmu.c

951

struct folio *folio = page_folio(page);

fs/proc/task_mmu.c

961

if (folio_test_anon(folio)) {

fs/proc/task_mmu.c

963

if (!folio_test_swapbacked(folio) && !dirty &&

fs/proc/task_mmu.c

964

!folio_test_dirty(folio))

fs/proc/task_mmu.c

968

if (folio_test_ksm(folio))

fs/proc/task_mmu.c

973

if (young || folio_test_young(folio) || folio_test_referenced(folio))

fs/proc/task_mmu.c

991

if (folio_ref_count(folio) == 1 || !present) {

fs/proc/task_mmu.c

992

smaps_page_accumulate(mss, folio, size, size << PSS_SHIFT,

fs/proc/task_mmu.c

998

mapcount = folio_average_page_mapcount(folio);

fs/proc/task_mmu.c

999

exclusive = !folio_maybe_mapped_shared(folio);

fs/qnx4/inode.c

268

static int qnx4_read_folio(struct file *file, struct folio *folio)

fs/qnx4/inode.c

270

return block_read_full_folio(folio, qnx4_get_block);

fs/qnx6/dir.c

107

folio_release_kmap(folio, lf);

fs/qnx6/dir.c

111

folio_release_kmap(folio, lf);

fs/qnx6/dir.c

133

struct folio *folio;

fs/qnx6/dir.c

134

char *kaddr = qnx6_get_folio(inode, n, &folio);

fs/qnx6/dir.c

172

folio_release_kmap(folio, kaddr);

fs/qnx6/dir.c

185

struct folio *folio;

fs/qnx6/dir.c

187

struct qnx6_long_filename *lf = qnx6_longname(s, de, &folio);

fs/qnx6/dir.c

194

folio_release_kmap(folio, lf);

fs/qnx6/dir.c

198

folio_release_kmap(folio, lf);

fs/qnx6/dir.c

201

folio_release_kmap(folio, lf);

fs/qnx6/dir.c

222

struct folio *folio;

fs/qnx6/dir.c

237

de = qnx6_get_folio(dir, n, &folio);

fs/qnx6/dir.c

260

folio_release_kmap(folio, de - i);

fs/qnx6/dir.c

270

folio_release_kmap(folio, de);

fs/qnx6/dir.c

29

struct folio **foliop)

fs/qnx6/dir.c

31

struct folio *folio = read_mapping_folio(dir->i_mapping, n, NULL);

fs/qnx6/dir.c

33

if (IS_ERR(folio))

fs/qnx6/dir.c

34

return folio;

fs/qnx6/dir.c

35

*foliop = folio;

fs/qnx6/dir.c

36

return kmap_local_folio(folio, 0);

fs/qnx6/dir.c

50

struct folio **foliop)

fs/qnx6/dir.c

57

struct folio *folio = read_mapping_folio(mapping, n, NULL);

fs/qnx6/dir.c

59

if (IS_ERR(folio))

fs/qnx6/dir.c

60

return ERR_CAST(folio);

fs/qnx6/dir.c

61

offs = offset_in_folio(folio, s << sb->s_blocksize_bits);

fs/qnx6/dir.c

62

*foliop = folio;

fs/qnx6/dir.c

63

return kmap_local_folio(folio, offs);

fs/qnx6/dir.c

74

struct folio *folio;

fs/qnx6/dir.c

83

lf = qnx6_longname(s, de, &folio);

fs/qnx6/dir.c

94

folio_release_kmap(folio, lf);

fs/qnx6/inode.c

100

return mpage_read_folio(folio, qnx6_get_block);

fs/qnx6/inode.c

186

struct folio *folio = read_mapping_folio(mapping, 0, NULL);

fs/qnx6/inode.c

188

if (IS_ERR(folio))

fs/qnx6/inode.c

190

dir_entry = kmap_local_folio(folio, 0);

fs/qnx6/inode.c

194

folio_release_kmap(folio, dir_entry);

fs/qnx6/inode.c

518

struct folio *folio;

fs/qnx6/inode.c

539

folio = read_mapping_folio(mapping, n, NULL);

fs/qnx6/inode.c

540

if (IS_ERR(folio)) {

fs/qnx6/inode.c

544

return ERR_CAST(folio);

fs/qnx6/inode.c

546

offs = offset_in_folio(folio, (ino - 1) << QNX6_INODE_SIZE_BITS);

fs/qnx6/inode.c

547

raw_inode = kmap_local_folio(folio, offs);

fs/qnx6/inode.c

577

folio_release_kmap(folio, raw_inode);

fs/qnx6/inode.c

98

static int qnx6_read_folio(struct file *file, struct folio *folio)

fs/remap_range.c

160

static struct folio *vfs_dedupe_get_folio(struct file *file, loff_t pos)

fs/remap_range.c

169

static void vfs_lock_two_folios(struct folio *folio1, struct folio *folio2)

fs/remap_range.c

181

static void vfs_unlock_two_folios(struct folio *folio1, struct folio *folio2)

fs/remap_range.c

200

struct folio *src_folio, *dst_folio;

fs/romfs/super.c

102

static int romfs_read_folio(struct file *file, struct folio *folio)

fs/romfs/super.c

104

struct inode *inode = folio->mapping->host;

fs/romfs/super.c

110

buf = kmap_local_folio(folio, 0);

fs/romfs/super.c

112

offset = folio_pos(folio);

fs/romfs/super.c

129

buf = folio_zero_tail(folio, fillsize, buf + fillsize);

fs/romfs/super.c

131

folio_end_read(folio, ret == 0);

fs/smb/client/cifsfs.c

1349

struct folio *folio;

fs/smb/client/cifsfs.c

1355

folio = filemap_get_folio(inode->i_mapping, index);

fs/smb/client/cifsfs.c

1356

if (IS_ERR(folio))

fs/smb/client/cifsfs.c

1359

size = folio_size(folio);

fs/smb/client/cifsfs.c

1360

fpos = folio_pos(folio);

fs/smb/client/cifsfs.c

1369

folio_put(folio);

fs/smb/client/smb2ops.c

4693

struct folio *folio = folioq_folio(buffer, s);

fs/smb/client/smb2ops.c

4698

if (copy_folio_from_iter(folio, 0, part, iter) != part)

fs/smb/client/smb2ops.c

4850

struct folio *folio;

fs/smb/client/smb2ops.c

4856

folio = folioq_folio(folioq, s);

fs/smb/client/smb2ops.c

4857

fsize = folio_size(folio);

fs/smb/client/smb2ops.c

4860

n = copy_folio_to_iter(folio, skip, len, iter);

fs/smb/smbdirect/connection.c

2094

struct folio *folio = folioq_folio(folioq, slot);

fs/smb/smbdirect/connection.c

2102

folio_page(folio, 0),

fs/splice.c

104

folio_unlock(folio);

fs/splice.c

122

struct folio *folio = page_folio(buf->page);

fs/splice.c

125

if (!folio_test_uptodate(folio)) {

fs/splice.c

126

folio_lock(folio);

fs/splice.c

132

if (!folio->mapping) {

fs/splice.c

140

if (!folio_test_uptodate(folio)) {

fs/splice.c

146

folio_unlock(folio);

fs/splice.c

151

folio_unlock(folio);

fs/splice.c

67

struct folio *folio = page_folio(buf->page);

fs/splice.c

70

folio_lock(folio);

fs/splice.c

72

mapping = folio_mapping(folio);

fs/splice.c

74

WARN_ON(!folio_test_uptodate(folio));

fs/splice.c

84

folio_wait_writeback(folio);

fs/splice.c

86

if (!filemap_release_folio(folio, GFP_KERNEL))

fs/splice.c

93

if (remove_mapping(mapping, folio)) {

fs/squashfs/block.c

113

head_to_cache = folio;

fs/squashfs/block.c

115

tail_to_cache = folio;

fs/squashfs/block.c

119

cache_folios[idx] = folio;

fs/squashfs/block.c

83

struct folio *head_to_cache = NULL, *tail_to_cache = NULL;

fs/squashfs/block.c

91

struct folio **cache_folios = kmalloc_objs(*cache_folios, page_count,

fs/squashfs/block.c

96

struct folio *folio = fi.folio;

fs/squashfs/block.c

98

if (folio->mapping == cache_mapping) {

fs/squashfs/file.c

374

static bool squashfs_fill_page(struct folio *folio,

fs/squashfs/file.c

381

pageaddr = kmap_local_folio(folio, 0);

fs/squashfs/file.c

386

flush_dcache_folio(folio);

fs/squashfs/file.c

392

void squashfs_copy_cache(struct folio *folio,

fs/squashfs/file.c

396

struct address_space *mapping = folio->mapping;

fs/squashfs/file.c

400

int start_index = folio->index & ~mask, end_index = start_index | mask;

fs/squashfs/file.c

410

struct folio *push_folio;

fs/squashfs/file.c

416

push_folio = (i == folio->index) ? folio :

fs/squashfs/file.c

430

if (i != folio->index)

fs/squashfs/file.c

436

static int squashfs_readpage_fragment(struct folio *folio, int expected)

fs/squashfs/file.c

438

struct inode *inode = folio->mapping->host;

fs/squashfs/file.c

449

squashfs_copy_cache(folio, buffer, expected,

fs/squashfs/file.c

456

static int squashfs_readpage_sparse(struct folio *folio, int expected)

fs/squashfs/file.c

458

squashfs_copy_cache(folio, NULL, expected, 0);

fs/squashfs/file.c

462

static int squashfs_read_folio(struct file *file, struct folio *folio)

fs/squashfs/file.c

464

struct inode *inode = folio->mapping->host;

fs/squashfs/file.c

466

int index = folio->index >> (msblk->block_log - PAGE_SHIFT);

fs/squashfs/file.c

474

folio->index, squashfs_i(inode)->start);

fs/squashfs/file.c

476

if (folio->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>

fs/squashfs/file.c

489

res = squashfs_readpage_sparse(folio, expected);

fs/squashfs/file.c

491

res = squashfs_readpage_block(folio, block, res, expected);

fs/squashfs/file.c

493

res = squashfs_readpage_fragment(folio, expected);

fs/squashfs/file.c

499

folio_zero_segment(folio, 0, folio_size(folio));

fs/squashfs/file.c

500

folio_end_read(folio, res == 0);

fs/squashfs/file_cache.c

21

int squashfs_readpage_block(struct folio *folio, u64 block, int bsize, int expected)

fs/squashfs/file_cache.c

23

struct inode *i = folio->mapping->host;

fs/squashfs/file_cache.c

32

squashfs_copy_cache(folio, buffer, expected, 0);

fs/squashfs/file_direct.c

22

int squashfs_readpage_block(struct folio *folio, u64 block, int bsize,

fs/squashfs/file_direct.c

25

struct page *target_page = &folio->page;

fs/squashfs/file_direct.c

26

struct inode *inode = folio->mapping->host;

fs/squashfs/file_direct.c

30

loff_t start_index = folio->index & ~mask;

fs/squashfs/file_direct.c

49

page[i] = (index == folio->index) ? target_page :

fs/squashfs/file_direct.c

50

grab_cache_page_nowait(folio->mapping, index);

fs/squashfs/squashfs.h

76

void squashfs_copy_cache(struct folio *, struct squashfs_cache_entry *,

fs/squashfs/squashfs.h

80

int squashfs_readpage_block(struct folio *, u64 block, int bsize, int expected);

fs/squashfs/symlink.c

33

static int squashfs_symlink_read_folio(struct file *file, struct folio *folio)

fs/squashfs/symlink.c

35

struct inode *inode = folio->mapping->host;

fs/squashfs/symlink.c

38

int index = folio_pos(folio);

fs/squashfs/symlink.c

47

"%llx, offset %x\n", folio->index, block, offset);

fs/squashfs/symlink.c

82

pageaddr = kmap_local_folio(folio, 0);

fs/squashfs/symlink.c

93

flush_dcache_folio(folio);

fs/squashfs/symlink.c

96

folio_end_read(folio, error == 0);

fs/ubifs/compress.c

126

memcpy_from_folio(out_buf, in_ptr.folio, in_offset, in_len);

fs/ubifs/compress.c

181

void ubifs_compress_folio(const struct ubifs_info *c, struct folio *in_folio,

fs/ubifs/compress.c

185

union ubifs_in_ptr in_ptr = { .folio = in_folio };

fs/ubifs/compress.c

24

struct folio *folio;

fs/ubifs/compress.c

290

int in_len, struct folio *out_folio,

fs/ubifs/compress.c

99

acomp_request_set_src_folio(req, in_ptr.folio,

fs/ubifs/file.c

1005

if (folio_pos(folio) + len <= i_size) {

fs/ubifs/file.c

1006

if (folio_pos(folio) + len > synced_i_size) {

fs/ubifs/file.c

1019

return do_writepage(folio, len);

fs/ubifs/file.c

1029

len = i_size - folio_pos(folio);

fs/ubifs/file.c

1030

folio_zero_segment(folio, len, folio_size(folio));

fs/ubifs/file.c

1038

return do_writepage(folio, len);

fs/ubifs/file.c

104

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

1045

folio_redirty_for_writepage(wbc, folio);

fs/ubifs/file.c

1047

folio_unlock(folio);

fs/ubifs/file.c

1054

struct folio *folio = NULL;

fs/ubifs/file.c

1057

while ((folio = writeback_iter(mapping, wbc, folio, &error)))

fs/ubifs/file.c

1058

error = ubifs_writepage(folio, wbc);

fs/ubifs/file.c

110

inode->i_ino, folio->index, i_size, folio->flags.f);

fs/ubifs/file.c

111

ubifs_assert(c, !folio_test_checked(folio));

fs/ubifs/file.c

112

ubifs_assert(c, !folio->private);

fs/ubifs/file.c

1138

struct folio *folio;

fs/ubifs/file.c

114

block = folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;

fs/ubifs/file.c

1140

folio = filemap_lock_folio(inode->i_mapping, index);

fs/ubifs/file.c

1141

if (!IS_ERR(folio)) {

fs/ubifs/file.c

1142

if (folio_test_dirty(folio)) {

fs/ubifs/file.c

1151

ubifs_assert(c, folio->private != NULL);

fs/ubifs/file.c

1153

folio_clear_dirty_for_io(folio);

fs/ubifs/file.c

1155

offset = offset_in_folio(folio,

fs/ubifs/file.c

1157

err = do_writepage(folio, offset);

fs/ubifs/file.c

1158

folio_put(folio);

fs/ubifs/file.c

1171

folio_unlock(folio);

fs/ubifs/file.c

1172

folio_put(folio);

fs/ubifs/file.c

118

folio_set_checked(folio);

fs/ubifs/file.c

119

folio_zero_range(folio, 0, folio_size(folio));

fs/ubifs/file.c

1284

static void ubifs_invalidate_folio(struct folio *folio, size_t offset,

fs/ubifs/file.c

1287

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

1290

ubifs_assert(c, folio_test_private(folio));

fs/ubifs/file.c

1291

if (offset || length < folio_size(folio))

fs/ubifs/file.c

1295

if (folio_test_checked(folio))

fs/ubifs/file.c

1301

folio_detach_private(folio);

fs/ubifs/file.c

1302

folio_clear_checked(folio);

fs/ubifs/file.c

136

folio_zero_range(folio, offset, UBIFS_BLOCK_SIZE);

fs/ubifs/file.c

138

ret = read_block(inode, folio, offset, block, dn);

fs/ubifs/file.c

1444

struct folio *folio)

fs/ubifs/file.c

1449

ret = filemap_dirty_folio(mapping, folio);

fs/ubifs/file.c

1458

static bool ubifs_release_folio(struct folio *folio, gfp_t unused_gfp_flags)

fs/ubifs/file.c

1460

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

1463

if (folio_test_writeback(folio))

fs/ubifs/file.c

1473

ubifs_assert(c, folio_test_private(folio));

fs/ubifs/file.c

1474

if (folio_test_checked(folio))

fs/ubifs/file.c

148

folio_zero_range(folio, offset + ilen, dlen - ilen);

fs/ubifs/file.c

1480

folio_detach_private(folio);

fs/ubifs/file.c

1481

folio_clear_checked(folio);

fs/ubifs/file.c

1491

struct folio *folio = page_folio(vmf->page);

fs/ubifs/file.c

1498

dbg_gen("ino %llu, pg %lu, i_size %lld", inode->i_ino, folio->index,

fs/ubifs/file.c

151

if (++i >= (UBIFS_BLOCKS_PER_PAGE << folio_order(folio)))

fs/ubifs/file.c

1539

folio_lock(folio);

fs/ubifs/file.c

1540

if (unlikely(folio->mapping != inode->i_mapping ||

fs/ubifs/file.c

1541

folio_pos(folio) >= i_size_read(inode))) {

fs/ubifs/file.c

1546

if (folio->private)

fs/ubifs/file.c

1549

if (!folio_test_checked(folio))

fs/ubifs/file.c

1551

folio_attach_private(folio, (void *)1);

fs/ubifs/file.c

1553

filemap_dirty_folio(folio->mapping, folio);

fs/ubifs/file.c

1569

folio_wait_stable(folio);

fs/ubifs/file.c

1573

folio_unlock(folio);

fs/ubifs/file.c

161

folio_set_checked(folio);

fs/ubifs/file.c

166

folio->index, inode->i_ino, err);

fs/ubifs/file.c

173

folio_mark_uptodate(folio);

fs/ubifs/file.c

206

loff_t pos, unsigned len, struct folio **foliop)

fs/ubifs/file.c

213

struct folio *folio;

fs/ubifs/file.c

234

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/ubifs/file.c

236

if (IS_ERR(folio)) {

fs/ubifs/file.c

238

return PTR_ERR(folio);

fs/ubifs/file.c

241

if (!folio_test_uptodate(folio)) {

fs/ubifs/file.c

242

if (pos == folio_pos(folio) && len >= folio_size(folio))

fs/ubifs/file.c

243

folio_set_checked(folio);

fs/ubifs/file.c

245

err = do_readpage(folio);

fs/ubifs/file.c

247

folio_unlock(folio);

fs/ubifs/file.c

248

folio_put(folio);

fs/ubifs/file.c

255

if (folio->private)

fs/ubifs/file.c

267

else if (!folio_test_checked(folio))

fs/ubifs/file.c

293

*foliop = folio;

fs/ubifs/file.c

311

static int allocate_budget(struct ubifs_info *c, struct folio *folio,

fs/ubifs/file.c

316

if (folio->private) {

fs/ubifs/file.c

343

if (folio_test_checked(folio))

fs/ubifs/file.c

410

struct folio **foliop, void **fsdata)

fs/ubifs/file.c

418

struct folio *folio;

fs/ubifs/file.c

427

folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

fs/ubifs/file.c

429

if (IS_ERR(folio))

fs/ubifs/file.c

430

return PTR_ERR(folio);

fs/ubifs/file.c

432

if (!folio_test_uptodate(folio)) {

fs/ubifs/file.c

434

if (pos == folio_pos(folio) && len >= folio_size(folio)) {

fs/ubifs/file.c

444

folio_set_checked(folio);

fs/ubifs/file.c

447

err = do_readpage(folio);

fs/ubifs/file.c

449

folio_unlock(folio);

fs/ubifs/file.c

45

static int read_block(struct inode *inode, struct folio *folio, size_t offset,

fs/ubifs/file.c

450

folio_put(folio);

fs/ubifs/file.c

456

err = allocate_budget(c, folio, ui, appending);

fs/ubifs/file.c

464

folio_clear_checked(folio);

fs/ubifs/file.c

476

folio_unlock(folio);

fs/ubifs/file.c

477

folio_put(folio);

fs/ubifs/file.c

488

*foliop = folio;

fs/ubifs/file.c

502

static void cancel_budget(struct ubifs_info *c, struct folio *folio,

fs/ubifs/file.c

510

if (!folio->private) {

fs/ubifs/file.c

511

if (folio_test_checked(folio))

fs/ubifs/file.c

521

struct folio *folio, void *fsdata)

fs/ubifs/file.c

530

inode->i_ino, pos, folio->index, len, copied, inode->i_size);

fs/ubifs/file.c

532

if (unlikely(copied < len && !folio_test_uptodate(folio))) {

fs/ubifs/file.c

544

cancel_budget(c, folio, ui, appending);

fs/ubifs/file.c

545

folio_clear_checked(folio);

fs/ubifs/file.c

551

copied = do_readpage(folio);

fs/ubifs/file.c

555

if (len == folio_size(folio))

fs/ubifs/file.c

556

folio_mark_uptodate(folio);

fs/ubifs/file.c

558

if (!folio->private) {

fs/ubifs/file.c

559

folio_attach_private(folio, (void *)1);

fs/ubifs/file.c

561

filemap_dirty_folio(mapping, folio);

fs/ubifs/file.c

578

folio_unlock(folio);

fs/ubifs/file.c

579

folio_put(folio);

fs/ubifs/file.c

58

folio_zero_range(folio, offset, UBIFS_BLOCK_SIZE);

fs/ubifs/file.c

592

static int populate_page(struct ubifs_info *c, struct folio *folio,

fs/ubifs/file.c

596

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

603

inode->i_ino, folio->index, i_size, folio->flags.f);

fs/ubifs/file.c

606

if (!i_size || folio->index > end_index) {

fs/ubifs/file.c

608

folio_zero_range(folio, 0, folio_size(folio));

fs/ubifs/file.c

612

page_block = folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;

fs/ubifs/file.c

618

folio_zero_range(folio, offset, UBIFS_BLOCK_SIZE);

fs/ubifs/file.c

641

c, &dn->data, dlen, folio, offset, &out_len,

fs/ubifs/file.c

647

folio_zero_range(folio, offset + len,

fs/ubifs/file.c

657

folio_zero_range(folio, offset, UBIFS_BLOCK_SIZE);

fs/ubifs/file.c

665

if (end_index == folio->index) {

fs/ubifs/file.c

669

folio_zero_range(folio, len, read - len);

fs/ubifs/file.c

674

folio_set_checked(folio);

fs/ubifs/file.c

678

folio_mark_uptodate(folio);

fs/ubifs/file.c

697

struct folio *folio1)

fs/ubifs/file.c

764

struct folio *folio;

fs/ubifs/file.c

768

folio = __filemap_get_folio(mapping, page_offset,

fs/ubifs/file.c

77

err = ubifs_decompress_folio(c, &dn->data, dlen, folio, offset,

fs/ubifs/file.c

771

if (IS_ERR(folio))

fs/ubifs/file.c

773

if (!folio_test_uptodate(folio))

fs/ubifs/file.c

774

err = populate_page(c, folio, bu, &n);

fs/ubifs/file.c

775

folio_unlock(folio);

fs/ubifs/file.c

776

folio_put(folio);

fs/ubifs/file.c

808

static int ubifs_bulk_read(struct folio *folio)

fs/ubifs/file.c

810

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

813

pgoff_t index = folio->index, last_page_read = ui->last_page_read;

fs/ubifs/file.c

861

folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT);

fs/ubifs/file.c

862

err = ubifs_do_bulk_read(c, bu, folio);

fs/ubifs/file.c

874

static int ubifs_read_folio(struct file *file, struct folio *folio)

fs/ubifs/file.c

876

if (ubifs_bulk_read(folio))

fs/ubifs/file.c

878

do_readpage(folio);

fs/ubifs/file.c

879

folio_unlock(folio);

fs/ubifs/file.c

88

folio_zero_range(folio, offset + len, UBIFS_BLOCK_SIZE - len);

fs/ubifs/file.c

883

static int do_writepage(struct folio *folio, size_t len)

fs/ubifs/file.c

889

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

895

ubifs_assert(c, folio->index <= ui->synced_i_size >> PAGE_SHIFT);

fs/ubifs/file.c

899

folio_start_writeback(folio);

fs/ubifs/file.c

901

block = folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;

fs/ubifs/file.c

905

err = ubifs_jnl_write_data(c, inode, &key, folio, offset, blen);

fs/ubifs/file.c

915

mapping_set_error(folio->mapping, err);

fs/ubifs/file.c

917

folio->index, inode->i_ino, err);

fs/ubifs/file.c

921

ubifs_assert(c, folio->private != NULL);

fs/ubifs/file.c

922

if (folio_test_checked(folio))

fs/ubifs/file.c

928

folio_detach_private(folio);

fs/ubifs/file.c

929

folio_clear_checked(folio);

fs/ubifs/file.c

931

folio_unlock(folio);

fs/ubifs/file.c

932

folio_end_writeback(folio);

fs/ubifs/file.c

982

static int ubifs_writepage(struct folio *folio, struct writeback_control *wbc)

fs/ubifs/file.c

984

struct inode *inode = folio->mapping->host;

fs/ubifs/file.c

988

int err, len = folio_size(folio);

fs/ubifs/file.c

99

static int do_readpage(struct folio *folio)

fs/ubifs/file.c

991

inode->i_ino, folio->index, folio->flags.f);

fs/ubifs/file.c

992

ubifs_assert(c, folio->private != NULL);

fs/ubifs/file.c

995

if (folio_pos(folio) >= i_size) {

fs/ubifs/journal.c

856

const union ubifs_key *key, struct folio *folio,

fs/ubifs/journal.c

901

ubifs_compress_folio(c, folio, offset, len, &data->data, &compr_len,

fs/ubifs/ubifs.h

1793

const union ubifs_key *key, struct folio *folio,

fs/ubifs/ubifs.h

2095

void ubifs_compress_folio(const struct ubifs_info *c, struct folio *folio,

fs/ubifs/ubifs.h

2101

int len, struct folio *folio, size_t offset,

fs/ubifs/ubifs.h

266

struct folio;

fs/udf/file.c

43

struct folio *folio = page_folio(vmf->page);

fs/udf/file.c

52

folio_lock(folio);

fs/udf/file.c

54

if (folio->mapping != inode->i_mapping || folio_pos(folio) >= size) {

fs/udf/file.c

55

folio_unlock(folio);

fs/udf/file.c

62

if (folio->index == size >> PAGE_SHIFT)

fs/udf/file.c

66

err = __block_write_begin(folio, 0, end, udf_get_block);

fs/udf/file.c

68

folio_unlock(folio);

fs/udf/file.c

73

block_commit_write(folio, 0, end);

fs/udf/file.c

75

folio_mark_dirty(folio);

fs/udf/file.c

76

folio_wait_stable(folio);

fs/udf/inode.c

186

static int udf_handle_page_wb(struct folio *folio,

fs/udf/inode.c

189

struct inode *inode = folio->mapping->host;

fs/udf/inode.c

200

memcpy_from_file_folio(iinfo->i_data + iinfo->i_lenEAttr, folio,

fs/udf/inode.c

202

folio_unlock(folio);

fs/udf/inode.c

214

static void udf_adinicb_read_folio(struct folio *folio)

fs/udf/inode.c

216

struct inode *inode = folio->mapping->host;

fs/udf/inode.c

220

folio_fill_tail(folio, 0, iinfo->i_data + iinfo->i_lenEAttr, isize);

fs/udf/inode.c

221

folio_mark_uptodate(folio);

fs/udf/inode.c

224

static int udf_read_folio(struct file *file, struct folio *folio)

fs/udf/inode.c

229

udf_adinicb_read_folio(folio);

fs/udf/inode.c

230

folio_unlock(folio);

fs/udf/inode.c

233

return mpage_read_folio(folio, udf_get_block);

fs/udf/inode.c

253

struct folio **foliop, void **fsdata)

fs/udf/inode.c

257

struct folio *folio;

fs/udf/inode.c

269

folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN,

fs/udf/inode.c

271

if (IS_ERR(folio))

fs/udf/inode.c

272

return PTR_ERR(folio);

fs/udf/inode.c

273

*foliop = folio;

fs/udf/inode.c

274

if (!folio_test_uptodate(folio))

fs/udf/inode.c

275

udf_adinicb_read_folio(folio);

fs/udf/inode.c

282

struct folio *folio, void *fsdata)

fs/udf/inode.c

288

return generic_write_end(iocb, mapping, pos, len, copied, folio,

fs/udf/inode.c

293

folio_mark_dirty(folio);

fs/udf/inode.c

294

folio_unlock(folio);

fs/udf/inode.c

295

folio_put(folio);

fs/udf/inode.c

346

struct folio *folio;

fs/udf/inode.c

362

folio = __filemap_get_folio(inode->i_mapping, 0,

fs/udf/inode.c

364

if (IS_ERR(folio))

fs/udf/inode.c

365

return PTR_ERR(folio);

fs/udf/inode.c

367

if (!folio_test_uptodate(folio))

fs/udf/inode.c

368

udf_adinicb_read_folio(folio);

fs/udf/inode.c

377

folio_mark_dirty(folio);

fs/udf/inode.c

378

folio_unlock(folio);

fs/udf/inode.c

383

folio_lock(folio);

fs/udf/inode.c

386

folio, 0, inode->i_size);

fs/udf/inode.c

387

folio_unlock(folio);

fs/udf/inode.c

392

folio_put(folio);

fs/udf/symlink.c

100

static int udf_symlink_filler(struct file *file, struct folio *folio)

fs/udf/symlink.c

102

struct inode *inode = folio->mapping->host;

fs/udf/symlink.c

106

unsigned char *p = folio_address(folio);

fs/udf/symlink.c

130

folio_end_read(folio, err == 0);

fs/udf/symlink.c

140

struct folio *folio;

fs/udf/symlink.c

143

folio = read_mapping_folio(inode->i_mapping, 0, NULL);

fs/udf/symlink.c

144

if (IS_ERR(folio))

fs/udf/symlink.c

145

return PTR_ERR(folio);

fs/udf/symlink.c

155

stat->size = strlen(folio_address(folio));

fs/udf/symlink.c

156

folio_put(folio);

fs/ufs/balloc.c

236

sector_t newb, struct folio *locked_folio)

fs/ufs/balloc.c

238

struct folio *folio;

fs/ufs/balloc.c

261

folio = ufs_get_locked_folio(mapping, index);

fs/ufs/balloc.c

262

if (!folio) /* it was truncated */

fs/ufs/balloc.c

264

if (IS_ERR(folio)) {/* or EIO */

fs/ufs/balloc.c

271

folio = locked_folio;

fs/ufs/balloc.c

273

head = folio_buffers(folio);

fs/ufs/balloc.c

309

ufs_put_locked_folio(folio);

fs/ufs/balloc.c

335

struct folio *locked_folio)

fs/ufs/dir.c

103

ufs_commit_chunk(folio, pos, len);

fs/ufs/dir.c

110

static bool ufs_check_folio(struct folio *folio, char *kaddr)

fs/ufs/dir.c

112

struct inode *dir = folio->mapping->host;

fs/ufs/dir.c

115

unsigned limit = folio_size(folio);

fs/ufs/dir.c

120

if (dir->i_size < folio_pos(folio) + limit) {

fs/ufs/dir.c

121

limit = offset_in_folio(folio, dir->i_size);

fs/ufs/dir.c

146

folio_set_checked(folio);

fs/ufs/dir.c

174

dir->i_ino, error, folio_pos(folio) + offs,

fs/ufs/dir.c

182

dir->i_ino, folio_pos(folio) + offs);

fs/ufs/dir.c

188

struct folio **foliop)

fs/ufs/dir.c

191

struct folio *folio = read_mapping_folio(mapping, n, NULL);

fs/ufs/dir.c

194

if (IS_ERR(folio))

fs/ufs/dir.c

195

return ERR_CAST(folio);

fs/ufs/dir.c

196

kaddr = kmap_local_folio(folio, 0);

fs/ufs/dir.c

197

if (unlikely(!folio_test_checked(folio))) {

fs/ufs/dir.c

198

if (!ufs_check_folio(folio, kaddr))

fs/ufs/dir.c

201

*foliop = folio;

fs/ufs/dir.c

205

folio_release_kmap(folio, kaddr);

fs/ufs/dir.c

231

struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct folio **foliop)

fs/ufs/dir.c

250

struct folio **foliop)

fs/ufs/dir.c

307

struct folio *folio = NULL;

fs/ufs/dir.c

322

char *kaddr = ufs_get_folio(dir, n, &folio);

fs/ufs/dir.c

327

folio_lock(folio);

fs/ufs/dir.c

330

kaddr += folio_size(folio) - reclen;

fs/ufs/dir.c

357

folio_unlock(folio);

fs/ufs/dir.c

358

folio_release_kmap(folio, kaddr);

fs/ufs/dir.c

364

pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/ufs/dir.c

365

err = ufs_prepare_chunk(folio, pos, rec_len);

fs/ufs/dir.c

382

ufs_commit_chunk(folio, pos, rec_len);

fs/ufs/dir.c

389

folio_release_kmap(folio, de);

fs/ufs/dir.c

392

folio_unlock(folio);

fs/ufs/dir.c

431

struct folio *folio;

fs/ufs/dir.c

432

char *kaddr = ufs_get_folio(inode, n, &folio);

fs/ufs/dir.c

46

static void ufs_commit_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/ufs/dir.c

467

folio_release_kmap(folio, de);

fs/ufs/dir.c

473

folio_release_kmap(folio, kaddr);

fs/ufs/dir.c

48

struct address_space *mapping = folio->mapping;

fs/ufs/dir.c

484

struct folio *folio)

fs/ufs/dir.c

495

from = offset_in_folio(folio, dir);

fs/ufs/dir.c

516

from = offset_in_folio(folio, pde);

fs/ufs/dir.c

517

pos = folio_pos(folio) + from;

fs/ufs/dir.c

518

folio_lock(folio);

fs/ufs/dir.c

519

err = ufs_prepare_chunk(folio, pos, to - from);

fs/ufs/dir.c

52

block_write_end(pos, len, len, folio);

fs/ufs/dir.c

521

folio_unlock(folio);

fs/ufs/dir.c

527

ufs_commit_chunk(folio, pos, to - from);

fs/ufs/dir.c

537

struct folio *folio = filemap_grab_folio(mapping, 0);

fs/ufs/dir.c

543

if (IS_ERR(folio))

fs/ufs/dir.c

544

return PTR_ERR(folio);

fs/ufs/dir.c

546

err = ufs_prepare_chunk(folio, 0, chunk_size);

fs/ufs/dir.c

548

folio_unlock(folio);

fs/ufs/dir.c

552

kaddr = kmap_local_folio(folio, 0);

fs/ufs/dir.c

553

memset(kaddr, 0, folio_size(folio));

fs/ufs/dir.c

57

folio_unlock(folio);

fs/ufs/dir.c

571

ufs_commit_chunk(folio, 0, chunk_size);

fs/ufs/dir.c

574

folio_put(folio);

fs/ufs/dir.c

584

struct folio *folio;

fs/ufs/dir.c

591

kaddr = ufs_get_folio(inode, i, &folio);

fs/ufs/dir.c

621

folio_release_kmap(folio, kaddr);

fs/ufs/dir.c

626

folio_release_kmap(folio, kaddr);

fs/ufs/dir.c

74

struct folio *folio;

fs/ufs/dir.c

76

de = ufs_find_entry(dir, qstr, &folio);

fs/ufs/dir.c

79

folio_release_kmap(folio, de);

fs/ufs/dir.c

86

struct folio *folio, struct inode *inode,

fs/ufs/dir.c

89

loff_t pos = folio_pos(folio) + offset_in_folio(folio, de);

fs/ufs/dir.c

93

folio_lock(folio);

fs/ufs/dir.c

94

err = ufs_prepare_chunk(folio, pos, len);

fs/ufs/dir.c

96

folio_unlock(folio);

fs/ufs/inode.c

1041

struct folio *folio;

fs/ufs/inode.c

1052

folio = ufs_get_locked_folio(mapping, lastfrag >>

fs/ufs/inode.c

1054

if (IS_ERR(folio)) {

fs/ufs/inode.c

1060

bh = folio_buffers(folio);

fs/ufs/inode.c

1078

folio_mark_dirty(folio);

fs/ufs/inode.c

1096

ufs_put_locked_folio(folio);

fs/ufs/inode.c

223

int *err, struct folio *locked_folio)

fs/ufs/inode.c

257

int *new, struct folio *locked_folio)

fs/ufs/inode.c

315

int *new, struct folio *locked_folio)

fs/ufs/inode.c

455

static int ufs_read_folio(struct file *file, struct folio *folio)

fs/ufs/inode.c

457

return block_read_full_folio(folio, ufs_getfrag_block);

fs/ufs/inode.c

460

int ufs_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)

fs/ufs/inode.c

462

return __block_write_begin(folio, pos, len, ufs_getfrag_block);

fs/ufs/inode.c

480

struct folio **foliop, void **fsdata)

fs/ufs/inode.c

494

struct folio *folio, void *fsdata)

fs/ufs/inode.c

498

ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);

fs/ufs/namei.c

212

struct folio *folio;

fs/ufs/namei.c

215

de = ufs_find_entry(dir, &dentry->d_name, &folio);

fs/ufs/namei.c

219

err = ufs_delete_entry(dir, de, folio);

fs/ufs/namei.c

224

folio_release_kmap(folio, de);

fs/ufs/namei.c

250

struct folio *dir_folio = NULL;

fs/ufs/namei.c

252

struct folio *old_folio;

fs/ufs/namei.c

271

struct folio *new_folio;

fs/ufs/ufs.h

102

struct folio **);

fs/ufs/ufs.h

103

int ufs_delete_entry(struct inode *, struct ufs_dir_entry *, struct folio *);

fs/ufs/ufs.h

105

struct ufs_dir_entry *ufs_dotdot(struct inode *, struct folio **);

fs/ufs/ufs.h

107

struct folio *folio, struct inode *inode, bool update_times);

fs/ufs/ufs.h

89

unsigned count, int *err, struct folio *);

fs/ufs/util.c

197

struct folio *ufs_get_locked_folio(struct address_space *mapping,

fs/ufs/util.c

201

struct folio *folio = filemap_lock_folio(mapping, index);

fs/ufs/util.c

202

if (IS_ERR(folio)) {

fs/ufs/util.c

203

folio = read_mapping_folio(mapping, index, NULL);

fs/ufs/util.c

205

if (IS_ERR(folio)) {

fs/ufs/util.c

208

return folio;

fs/ufs/util.c

211

folio_lock(folio);

fs/ufs/util.c

213

if (unlikely(folio->mapping == NULL)) {

fs/ufs/util.c

215

folio_unlock(folio);

fs/ufs/util.c

216

folio_put(folio);

fs/ufs/util.c

220

if (!folio_buffers(folio))

fs/ufs/util.c

221

create_empty_buffers(folio, 1 << inode->i_blkbits, 0);

fs/ufs/util.c

222

return folio;

fs/ufs/util.h

255

int ufs_prepare_chunk(struct folio *folio, loff_t pos, unsigned len);

fs/ufs/util.h

271

struct folio *ufs_get_locked_folio(struct address_space *mapping, pgoff_t index);

fs/ufs/util.h

272

static inline void ufs_put_locked_folio(struct folio *folio)

fs/ufs/util.h

274

folio_unlock(folio);

fs/ufs/util.h

275

folio_put(folio);

fs/vboxsf/file.c

229

static int vboxsf_read_folio(struct file *file, struct folio *folio)

fs/vboxsf/file.c

232

loff_t off = folio_pos(folio);

fs/vboxsf/file.c

237

buf = kmap_local_folio(folio, 0);

fs/vboxsf/file.c

240

buf = folio_zero_tail(folio, nread, buf + nread);

fs/vboxsf/file.c

243

folio_end_read(folio, err == 0);

fs/vboxsf/file.c

269

struct folio *folio = NULL;

fs/vboxsf/file.c

279

while ((folio = writeback_iter(mapping, wbc, folio, &error))) {

fs/vboxsf/file.c

280

loff_t off = folio_pos(folio);

fs/vboxsf/file.c

281

u32 nwrite = folio_size(folio);

fs/vboxsf/file.c

287

buf = kmap_local_folio(folio, 0);

fs/vboxsf/file.c

292

folio_unlock(folio);

fs/vboxsf/file.c

306

struct folio *folio, void *fsdata)

fs/vboxsf/file.c

310

size_t from = offset_in_folio(folio, pos);

fs/vboxsf/file.c

316

if (!folio_test_uptodate(folio) && copied < len)

fs/vboxsf/file.c

317

folio_zero_range(folio, from + copied, len - copied);

fs/vboxsf/file.c

319

buf = kmap(&folio->page);

fs/vboxsf/file.c

322

kunmap(&folio->page);

fs/vboxsf/file.c

332

if (!folio_test_uptodate(folio) && nwritten == folio_size(folio))

fs/vboxsf/file.c

333

folio_mark_uptodate(folio);

fs/vboxsf/file.c

340

folio_unlock(folio);

fs/vboxsf/file.c

341

folio_put(folio);

fs/verity/pagecache.c

22

struct folio *folio;

fs/verity/pagecache.c

24

folio = read_mapping_folio(inode->i_mapping, index, NULL);

fs/verity/pagecache.c

25

if (IS_ERR(folio))

fs/verity/pagecache.c

26

return ERR_CAST(folio);

fs/verity/pagecache.c

27

return folio_file_page(folio, index);

fs/verity/pagecache.c

45

struct folio *folio;

fs/verity/pagecache.c

49

folio = __filemap_get_folio(inode->i_mapping, index, FGP_ACCESSED, 0);

fs/verity/pagecache.c

50

if (folio == ERR_PTR(-ENOENT) ||

fs/verity/pagecache.c

51

(!IS_ERR(folio) && !folio_test_uptodate(folio))) {

fs/verity/pagecache.c

56

if (!IS_ERR(folio))

fs/verity/pagecache.c

57

folio_put(folio);

fs/verity/pagecache.c

68

void fsverity_fill_zerohash(struct folio *folio, size_t offset, size_t len,

fs/verity/pagecache.c

77

memcpy_to_folio(folio, off, vi->tree_params.zero_digest,

fs/verity/verify.c

378

struct folio *data_folio, size_t len,

fs/verity/verify.c

417

bool fsverity_verify_blocks(struct fsverity_info *vi, struct folio *folio,

fs/verity/verify.c

424

if (fsverity_add_data_blocks(&ctx, folio, len, offset) &&

fs/verity/verify.c

456

if (!fsverity_add_data_blocks(&ctx, fi.folio, fi.length,

fs/xfs/scrub/trace.h

1175

if (si->folio) {

fs/xfs/scrub/trace.h

1176

__entry->folio_pos = folio_pos(si->folio);

fs/xfs/scrub/trace.h

1177

__entry->folio_bytes = folio_size(si->folio);

fs/xfs/scrub/xfarray.c

576

struct folio *folio;

fs/xfs/scrub/xfarray.c

586

folio = xfile_get_folio(si->array->xfile, lo_pos, len, XFILE_ALLOC);

fs/xfs/scrub/xfarray.c

587

if (IS_ERR(folio))

fs/xfs/scrub/xfarray.c

588

return PTR_ERR(folio);

fs/xfs/scrub/xfarray.c

589

if (!folio)

fs/xfs/scrub/xfarray.c

595

startp = folio_address(folio) + offset_in_folio(folio, lo_pos);

fs/xfs/scrub/xfarray.c

599

xfile_put_folio(si->array->xfile, folio);

fs/xfs/scrub/xfarray.c

792

if (si->folio)

fs/xfs/scrub/xfarray.c

793

xfile_put_folio(si->array->xfile, si->folio);

fs/xfs/scrub/xfarray.c

794

si->folio = NULL;

fs/xfs/scrub/xfarray.c

818

if (si->folio &&

fs/xfs/scrub/xfarray.c

823

if (!si->folio) {

fs/xfs/scrub/xfarray.c

824

struct folio *folio;

fs/xfs/scrub/xfarray.c

827

folio = xfile_get_folio(si->array->xfile, idx_pos,

fs/xfs/scrub/xfarray.c

829

if (IS_ERR(folio))

fs/xfs/scrub/xfarray.c

830

return PTR_ERR(folio);

fs/xfs/scrub/xfarray.c

831

si->folio = folio;

fs/xfs/scrub/xfarray.c

834

folio_pos(si->folio) + si->array->obj_size - 1);

fs/xfs/scrub/xfarray.c

836

next_pos = folio_next_pos(si->folio);

fs/xfs/scrub/xfarray.c

861

*ptrp = folio_address(si->folio) + offset_in_folio(si->folio, idx_pos);

fs/xfs/scrub/xfarray.h

134

struct folio *folio;

fs/xfs/scrub/xfile.c

126

struct folio *folio;

fs/xfs/scrub/xfile.c

130

if (shmem_get_folio(inode, pos >> PAGE_SHIFT, 0, &folio,

fs/xfs/scrub/xfile.c

133

if (!folio) {

fs/xfs/scrub/xfile.c

143

folio_unlock(folio);

fs/xfs/scrub/xfile.c

144

folio_put(folio);

fs/xfs/scrub/xfile.c

148

offset = offset_in_folio(folio, pos);

fs/xfs/scrub/xfile.c

149

len = min_t(ssize_t, count, folio_size(folio) - offset);

fs/xfs/scrub/xfile.c

150

memcpy(buf, folio_address(folio) + offset, len);

fs/xfs/scrub/xfile.c

152

folio_unlock(folio);

fs/xfs/scrub/xfile.c

153

folio_put(folio);

fs/xfs/scrub/xfile.c

196

struct folio *folio;

fs/xfs/scrub/xfile.c

200

if (shmem_get_folio(inode, pos >> PAGE_SHIFT, 0, &folio,

fs/xfs/scrub/xfile.c

204

folio_unlock(folio);

fs/xfs/scrub/xfile.c

205

folio_put(folio);

fs/xfs/scrub/xfile.c

209

offset = offset_in_folio(folio, pos);

fs/xfs/scrub/xfile.c

210

len = min_t(ssize_t, count, folio_size(folio) - offset);

fs/xfs/scrub/xfile.c

211

memcpy(folio_address(folio) + offset, buf, len);

fs/xfs/scrub/xfile.c

213

folio_mark_dirty(folio);

fs/xfs/scrub/xfile.c

214

folio_unlock(folio);

fs/xfs/scrub/xfile.c

215

folio_put(folio);

fs/xfs/scrub/xfile.c

246

struct folio *

fs/xfs/scrub/xfile.c

254

struct folio *folio = NULL;

fs/xfs/scrub/xfile.c

271

error = shmem_get_folio(inode, pos >> PAGE_SHIFT, 0, &folio,

fs/xfs/scrub/xfile.c

277

if (!folio)

fs/xfs/scrub/xfile.c

280

if (len > folio_size(folio) - offset_in_folio(folio, pos)) {

fs/xfs/scrub/xfile.c

281

folio_unlock(folio);

fs/xfs/scrub/xfile.c

282

folio_put(folio);

fs/xfs/scrub/xfile.c

287

folio_unlock(folio);

fs/xfs/scrub/xfile.c

288

folio_put(folio);

fs/xfs/scrub/xfile.c

297

folio_mark_dirty(folio);

fs/xfs/scrub/xfile.c

298

return folio;

fs/xfs/scrub/xfile.c

307

struct folio *folio)

fs/xfs/scrub/xfile.c

309

trace_xfile_put_folio(xf, folio_pos(folio), folio_size(folio));

fs/xfs/scrub/xfile.c

311

folio_unlock(folio);

fs/xfs/scrub/xfile.c

312

folio_put(folio);

fs/xfs/scrub/xfile.h

26

struct folio *xfile_get_folio(struct xfile *xf, loff_t offset, size_t len,

fs/xfs/scrub/xfile.h

28

void xfile_put_folio(struct xfile *xf, struct folio *folio);

fs/xfs/xfs_aops.c

271

struct folio *folio,

fs/xfs/xfs_aops.c

274

struct xfs_inode *ip = XFS_I(folio->mapping->host);

fs/xfs/xfs_aops.c

282

folio, I_INO(ip), pos);

fs/xfs/xfs_aops.c

290

folio_next_pos(folio), NULL);

fs/xfs/xfs_aops.c

498

struct folio *folio,

fs/xfs/xfs_aops.c

507

ret = iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/xfs/xfs_aops.c

509

xfs_discard_folio(folio, offset);

fs/xfs/xfs_aops.c

648

struct folio *folio,

fs/xfs/xfs_aops.c

657

ret = iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

fs/xfs/xfs_aops.c

659

xfs_discard_folio(folio, offset);

fs/xfs/xfs_aops.c

790

struct folio *folio)

fs/xfs/xfs_aops.c

792

struct iomap_read_folio_ctx ctx = { .cur_folio = folio };

fs/xfs/xfs_aops.c

794

ctx.ops = xfs_get_iomap_read_ops(folio->mapping);

fs/xfs/xfs_buf.c

129

struct folio *folio;

fs/xfs/xfs_buf.c

131

folio = folio_alloc(gfp_mask, get_order(size));

fs/xfs/xfs_buf.c

132

if (!folio)

fs/xfs/xfs_buf.c

134

bp->b_addr = folio_address(folio);

fs/xfs/xfs_buf_mem.c

129

struct folio *folio = NULL;

fs/xfs/xfs_buf_mem.c

144

error = shmem_get_folio(inode, pos >> PAGE_SHIFT, 0, &folio, SGP_CACHE);

fs/xfs/xfs_buf_mem.c

149

folio_unlock(folio);

fs/xfs/xfs_buf_mem.c

150

folio_put(folio);

fs/xfs/xfs_buf_mem.c

158

folio_set_dirty(folio);

fs/xfs/xfs_buf_mem.c

159

folio_unlock(folio);

fs/xfs/xfs_buf_mem.c

161

bp->b_addr = folio_address(folio) + offset_in_folio(folio, pos);

fs/xfs/xfs_trace.h

6347

const struct folio *folio),

fs/xfs/xfs_trace.h

6348

TP_ARGS(mp, me, fdev, daddr, bbcount, folio),

fs/xfs/xfs_trace.h

6367

__entry->bufsize = folio_size(folio);

fs/xfs/xfs_verify_media.c

192

static struct folio *

fs/xfs/xfs_verify_media.c

199

struct folio *folio =

fs/xfs/xfs_verify_media.c

202

if (folio)

fs/xfs/xfs_verify_media.c

203

return folio;

fs/xfs/xfs_verify_media.c

270

struct folio *folio;

fs/xfs/xfs_verify_media.c

329

folio = xfs_verify_alloc_folio(xfs_verify_iosize(me, btp, bbcount));

fs/xfs/xfs_verify_media.c

330

if (!folio)

fs/xfs/xfs_verify_media.c

333

trace_xfs_verify_media(mp, me, btp->bt_dev, daddr, bbcount, folio);

fs/xfs/xfs_verify_media.c

347

bio_add_folio_nofail(bio, folio,

fs/xfs/xfs_verify_media.c

348

min(bbcount << SECTOR_SHIFT, folio_size(folio)),

fs/xfs/xfs_verify_media.c

391

folio_put(folio);

fs/xfs/xfs_zone_gc.c

140

struct folio *scratch_folios[XFS_GC_NR_BUFS];

fs/zonefs/file.c

113

static int zonefs_read_folio(struct file *unused, struct folio *folio)

fs/zonefs/file.c

115

iomap_bio_read_folio(folio, &zonefs_read_iomap_ops);

fs/zonefs/file.c

129

struct folio *folio, u64 offset, unsigned len, u64 end_pos)

fs/zonefs/file.c

150

return iomap_add_to_ioend(wpc, folio, offset, end_pos, len);

include/crypto/acompress.h

437

struct folio *folio, size_t off,

include/crypto/acompress.h

441

sg_set_folio(&req->chain.ssg, folio, len, off);

include/crypto/acompress.h

516

struct folio *folio, size_t off,

include/crypto/acompress.h

520

sg_set_folio(&req->chain.dsg, folio, len, off);

include/crypto/acompress.h

54

struct folio;

include/crypto/acompress.h

63

struct folio *sfolio;

include/crypto/acompress.h

67

struct folio *dfolio;

include/drm/drm_pagemap.h

374

struct folio *folio = page_folio(page);

include/drm/drm_pagemap.h

376

return folio_zone_device_data(folio);

include/drm/ttm/ttm_backup.h

61

ttm_backup_backup_folio(struct file *backup, struct folio *folio,

include/linux/bio.h

254

static inline struct folio *bio_first_folio_all(struct bio *bio)

include/linux/bio.h

267

struct folio *folio;

include/linux/bio.h

271

struct folio *_next;

include/linux/bio.h

282

fi->folio = NULL;

include/linux/bio.h

286

fi->folio = bvec_folio(bvec);

include/linux/bio.h

288

PAGE_SIZE * folio_page_idx(fi->folio, bvec->bv_page);

include/linux/bio.h

290

fi->length = min(folio_size(fi->folio) - fi->offset, fi->_seg_count);

include/linux/bio.h

291

fi->_next = folio_next(fi->folio);

include/linux/bio.h

299

fi->folio = fi->_next;

include/linux/bio.h

301

fi->length = min(folio_size(fi->folio), fi->_seg_count);

include/linux/bio.h

302

fi->_next = folio_next(fi->folio);

include/linux/bio.h

314

for (bio_first_folio(&fi, bio, 0); fi.folio; bio_next_folio(&fi, bio))

include/linux/bio.h

449

bool __must_check bio_add_folio(struct bio *bio, struct folio *folio,

include/linux/bio.h

453

void bio_add_folio_nofail(struct bio *bio, struct folio *folio, size_t len,

include/linux/buffer_head.h

184

#define folio_buffers(folio) folio_get_private(folio)

include/linux/buffer_head.h

186

void buffer_check_dirty_writeback(struct folio *folio,

include/linux/buffer_head.h

196

void folio_set_bh(struct buffer_head *bh, struct folio *folio,

include/linux/buffer_head.h

198

struct buffer_head *folio_alloc_buffers(struct folio *folio, unsigned long size,

include/linux/buffer_head.h

201

struct buffer_head *create_empty_buffers(struct folio *folio,

include/linux/buffer_head.h

256

void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);

include/linux/buffer_head.h

257

int block_write_full_folio(struct folio *folio, struct writeback_control *wbc,

include/linux/buffer_head.h

259

int __block_write_full_folio(struct inode *inode, struct folio *folio,

include/linux/buffer_head.h

261

int block_read_full_folio(struct folio *, get_block_t *);

include/linux/buffer_head.h

262

bool block_is_partially_uptodate(struct folio *, size_t from, size_t count);

include/linux/buffer_head.h

264

struct folio **foliop, get_block_t *get_block);

include/linux/buffer_head.h

265

int __block_write_begin(struct folio *folio, loff_t pos, unsigned len,

include/linux/buffer_head.h

267

int block_write_end(loff_t pos, unsigned len, unsigned copied, struct folio *);

include/linux/buffer_head.h

270

struct folio *, void *);

include/linux/buffer_head.h

271

void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to);

include/linux/buffer_head.h

273

unsigned, struct folio **, void **,

include/linux/buffer_head.h

276

void block_commit_write(struct folio *folio, size_t from, size_t to);

include/linux/buffer_head.h

284

struct folio *dst, struct folio *src, enum migrate_mode);

include/linux/buffer_head.h

286

struct folio *dst, struct folio *src, enum migrate_mode);

include/linux/buffer_head.h

514

bool block_dirty_folio(struct address_space *mapping, struct folio *folio);

include/linux/buffer_head.h

519

bool try_to_free_buffers(struct folio *folio);

include/linux/buffer_head.h

532

static inline bool try_to_free_buffers(struct folio *folio) { return true; }

include/linux/buffer_head.h

64

struct folio *b_folio; /* the folio this bh is mapped to */

include/linux/buildid.h

31

struct folio *folio;

include/linux/bvec.h

56

static inline void bvec_set_folio(struct bio_vec *bv, struct folio *folio,

include/linux/bvec.h

62

bvec_set_page(bv, folio_page(folio, nr), len, offset % PAGE_SIZE);

include/linux/bvec.h

87

static inline struct folio *bvec_folio(const struct bio_vec *bv)

include/linux/cacheflush.h

11

void flush_dcache_folio(struct folio *folio);

include/linux/cacheflush.h

14

static inline void flush_dcache_folio(struct folio *folio)

include/linux/cacheflush.h

7

struct folio;

include/linux/dax.h

156

int dax_folio_reset_order(struct folio *folio);

include/linux/dax.h

160

dax_entry_t dax_lock_folio(struct folio *folio);

include/linux/dax.h

161

void dax_unlock_folio(struct folio *folio, dax_entry_t cookie);

include/linux/dax.h

192

static inline dax_entry_t dax_lock_folio(struct folio *folio)

include/linux/dax.h

194

if (IS_DAX(folio->mapping->host))

include/linux/dax.h

199

static inline void dax_unlock_folio(struct folio *folio, dax_entry_t cookie)

include/linux/f2fs_fs.h

276

#define ADDRS_PER_PAGE(folio, inode) (addrs_per_page(inode, IS_INODE(folio)))

include/linux/folio_batch.h

17

struct folio;

include/linux/folio_batch.h

32

struct folio *folios[FOLIO_BATCH_SIZE];

include/linux/folio_batch.h

75

struct folio *folio)

include/linux/folio_batch.h

77

fbatch->folios[fbatch->nr++] = folio;

include/linux/folio_batch.h

89

static inline struct folio *folio_batch_next(struct folio_batch *fbatch)

include/linux/folio_queue.h

192

static inline unsigned int folioq_append(struct folio_queue *folioq, struct folio *folio)

include/linux/folio_queue.h

196

folioq->vec.folios[slot] = folio;

include/linux/folio_queue.h

197

folioq->orders[slot] = folio_order(folio);

include/linux/folio_queue.h

214

static inline unsigned int folioq_append_mark(struct folio_queue *folioq, struct folio *folio)

include/linux/folio_queue.h

218

folioq->vec.folios[slot] = folio;

include/linux/folio_queue.h

219

folioq->orders[slot] = folio_order(folio);

include/linux/folio_queue.h

234

static inline struct folio *folioq_folio(const struct folio_queue *folioq, unsigned int slot)

include/linux/fs.h

3274

struct folio **foliop, void **fsdata);

include/linux/fs.h

402

int (*read_folio)(struct file *, struct folio *);

include/linux/fs.h

408

bool (*dirty_folio)(struct address_space *, struct folio *);

include/linux/fs.h

414

struct folio **foliop, void **fsdata);

include/linux/fs.h

417

struct folio *folio, void *fsdata);

include/linux/fs.h

421

void (*invalidate_folio) (struct folio *, size_t offset, size_t len);

include/linux/fs.h

422

bool (*release_folio)(struct folio *, gfp_t);

include/linux/fs.h

423

void (*free_folio)(struct folio *folio);

include/linux/fs.h

429

int (*migrate_folio)(struct address_space *, struct folio *dst,

include/linux/fs.h

430

struct folio *src, enum migrate_mode);

include/linux/fs.h

431

int (*launder_folio)(struct folio *);

include/linux/fs.h

432

bool (*is_partially_uptodate) (struct folio *, size_t from,

include/linux/fs.h

434

void (*is_dirty_writeback) (struct folio *, bool *dirty, bool *wb);

include/linux/fs.h

435

int (*error_remove_folio)(struct address_space *, struct folio *);

include/linux/fscrypt.h

349

struct page *fscrypt_encrypt_pagecache_blocks(struct folio *folio,

include/linux/fscrypt.h

355

int fscrypt_decrypt_pagecache_blocks(struct folio *folio, size_t len,

include/linux/fscrypt.h

371

static inline bool fscrypt_is_bounce_folio(const struct folio *folio)

include/linux/fscrypt.h

373

return folio->mapping == NULL;

include/linux/fscrypt.h

377

struct folio *fscrypt_pagecache_folio(const struct folio *bounce_folio)

include/linux/fscrypt.h

518

static inline struct page *fscrypt_encrypt_pagecache_blocks(struct folio *folio,

include/linux/fscrypt.h

532

static inline int fscrypt_decrypt_pagecache_blocks(struct folio *folio,

include/linux/fscrypt.h

557

static inline bool fscrypt_is_bounce_folio(const struct folio *folio)

include/linux/fscrypt.h

563

struct folio *fscrypt_pagecache_folio(const struct folio *bounce_folio)

include/linux/fsverity.h

200

bool fsverity_verify_blocks(struct fsverity_info *vi, struct folio *folio,

include/linux/fsverity.h

204

void fsverity_fill_zerohash(struct folio *folio, size_t offset, size_t len,

include/linux/fsverity.h

268

struct folio *folio, size_t len,

include/linux/fsverity.h

286

static inline void fsverity_fill_zerohash(struct folio *folio, size_t offset,

include/linux/fsverity.h

295

struct folio *folio)

include/linux/fsverity.h

297

return fsverity_verify_blocks(vi, folio, folio_size(folio), 0);

include/linux/gfp.h

233

struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,

include/linux/gfp.h

297

struct folio *__folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)

include/linux/gfp.h

325

struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order);

include/linux/gfp.h

326

struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,

include/linux/gfp.h

328

struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order, struct vm_area_struct *vma,

include/linux/gfp.h

335

static inline struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order)

include/linux/gfp.h

339

static inline struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,

include/linux/gfp.h

344

static inline struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order,

include/linux/gfp.h

361

struct folio *folio = vma_alloc_folio_noprof(gfp, 0, vma, addr);

include/linux/gfp.h

363

return &folio->page;

include/linux/highmem-internal.h

196

static inline void *kmap_local_folio(const struct folio *folio, size_t offset)

include/linux/highmem-internal.h

198

return folio_address(folio) + offset;

include/linux/highmem-internal.h

84

static inline void *kmap_local_folio(const struct folio *folio, size_t offset)

include/linux/highmem-internal.h

86

const struct page *page = folio_page(folio, offset / PAGE_SIZE);

include/linux/highmem.h

132

static inline void *kmap_local_folio(const struct folio *folio, size_t offset);

include/linux/highmem.h

320

struct folio *vma_alloc_zeroed_movable_folio(struct vm_area_struct *vma,

include/linux/highmem.h

323

struct folio *folio;

include/linux/highmem.h

325

folio = vma_alloc_folio(GFP_HIGHUSER_MOVABLE, 0, vma, vaddr);

include/linux/highmem.h

326

if (folio && user_alloc_needs_zeroing())

include/linux/highmem.h

327

clear_user_highpage(&folio->page, vaddr);

include/linux/highmem.h

329

return folio;

include/linux/highmem.h

500

static inline void memcpy_folio(struct folio *dst_folio, size_t dst_off,

include/linux/highmem.h

501

struct folio *src_folio, size_t src_off, size_t len)

include/linux/highmem.h

575

static inline void memcpy_from_folio(char *to, struct folio *folio,

include/linux/highmem.h

578

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

581

const char *from = kmap_local_folio(folio, offset);

include/linux/highmem.h

584

if (folio_test_partial_kmap(folio) &&

include/linux/highmem.h

603

static inline void memcpy_to_folio(struct folio *folio, size_t offset,

include/linux/highmem.h

606

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

609

char *to = kmap_local_folio(folio, offset);

include/linux/highmem.h

612

if (folio_test_partial_kmap(folio) &&

include/linux/highmem.h

623

flush_dcache_folio(folio);

include/linux/highmem.h

640

static inline __must_check void *folio_zero_tail(struct folio *folio,

include/linux/highmem.h

643

size_t len = folio_size(folio) - offset;

include/linux/highmem.h

645

if (folio_test_partial_kmap(folio)) {

include/linux/highmem.h

654

kaddr = kmap_local_folio(folio, offset);

include/linux/highmem.h

659

flush_dcache_folio(folio);

include/linux/highmem.h

676

static inline void folio_fill_tail(struct folio *folio, size_t offset,

include/linux/highmem.h

679

char *to = kmap_local_folio(folio, offset);

include/linux/highmem.h

681

VM_BUG_ON(offset + len > folio_size(folio));

include/linux/highmem.h

683

if (folio_test_partial_kmap(folio)) {

include/linux/highmem.h

693

to = kmap_local_folio(folio, offset);

include/linux/highmem.h

698

to = folio_zero_tail(folio, offset + len, to + len);

include/linux/highmem.h

714

static inline size_t memcpy_from_file_folio(char *to, struct folio *folio,

include/linux/highmem.h

717

size_t offset = offset_in_folio(folio, pos);

include/linux/highmem.h

718

char *from = kmap_local_folio(folio, offset);

include/linux/highmem.h

720

if (folio_test_partial_kmap(folio)) {

include/linux/highmem.h

724

len = min(len, folio_size(folio) - offset);

include/linux/highmem.h

740

static inline void folio_zero_segments(struct folio *folio,

include/linux/highmem.h

743

zero_user_segments(&folio->page, start1, xend1, start2, xend2);

include/linux/highmem.h

752

static inline void folio_zero_segment(struct folio *folio,

include/linux/highmem.h

755

zero_user_segments(&folio->page, start, xend, 0, 0);

include/linux/highmem.h

764

static inline void folio_zero_range(struct folio *folio,

include/linux/highmem.h

767

zero_user_segments(&folio->page, start, start + length, 0, 0);

include/linux/highmem.h

779

static inline void folio_release_kmap(struct folio *folio, void *addr)

include/linux/highmem.h

782

folio_put(folio);

include/linux/huge_mm.h

404

int folio_split_unmapped(struct folio *folio, unsigned int new_order);

include/linux/huge_mm.h

405

unsigned int min_order_for_split(struct folio *folio);

include/linux/huge_mm.h

406

int split_folio_to_list(struct folio *folio, struct list_head *list);

include/linux/huge_mm.h

407

int folio_check_splittable(struct folio *folio, unsigned int new_order,

include/linux/huge_mm.h

409

int folio_split(struct folio *folio, unsigned int new_order, struct page *page,

include/linux/huge_mm.h

427

int folio_memcg_alloc_deferred(struct folio *folio);

include/linux/huge_mm.h

429

void deferred_split_folio(struct folio *folio, bool partially_mapped);

include/linux/huge_mm.h

44

vm_fault_t vmf_insert_folio_pmd(struct vm_fault *vmf, struct folio *folio,

include/linux/huge_mm.h

46

vm_fault_t vmf_insert_folio_pud(struct vm_fault *vmf, struct folio *folio,

include/linux/huge_mm.h

525

static inline bool folio_test_pmd_mappable(struct folio *folio)

include/linux/huge_mm.h

527

return folio_order(folio) >= HPAGE_PMD_ORDER;

include/linux/huge_mm.h

534

extern struct folio *huge_zero_folio;

include/linux/huge_mm.h

537

static inline bool is_huge_zero_folio(const struct folio *folio)

include/linux/huge_mm.h

539

VM_WARN_ON_ONCE(!folio);

include/linux/huge_mm.h

541

return READ_ONCE(huge_zero_folio) == folio;

include/linux/huge_mm.h

554

struct folio *mm_get_huge_zero_folio(struct mm_struct *mm);

include/linux/huge_mm.h

557

static inline struct folio *get_persistent_huge_zero_folio(void)

include/linux/huge_mm.h

576

pmd_t *pmdp, struct folio *folio);

include/linux/huge_mm.h

577

void map_anon_folio_pmd_nopf(struct folio *folio, pmd_t *pmd,

include/linux/huge_mm.h

582

static inline bool folio_test_pmd_mappable(struct folio *folio)

include/linux/huge_mm.h

625

can_split_folio(struct folio *folio, int caller_pins, int *pextra_pins)

include/linux/huge_mm.h

647

static inline unsigned int min_order_for_split(struct folio *folio)

include/linux/huge_mm.h

649

VM_WARN_ON_ONCE_FOLIO(1, folio);

include/linux/huge_mm.h

653

static inline int split_folio_to_list(struct folio *folio, struct list_head *list)

include/linux/huge_mm.h

655

VM_WARN_ON_ONCE_FOLIO(1, folio);

include/linux/huge_mm.h

659

static inline int folio_split(struct folio *folio, unsigned int new_order,

include/linux/huge_mm.h

662

VM_WARN_ON_ONCE_FOLIO(1, folio);

include/linux/huge_mm.h

666

static inline int folio_memcg_alloc_deferred(struct folio *folio)

include/linux/huge_mm.h

671

static inline void deferred_split_folio(struct folio *folio, bool partially_mapped)

include/linux/huge_mm.h

688

struct folio *folio)

include/linux/huge_mm.h

736

static inline bool is_huge_zero_folio(const struct folio *folio)

include/linux/huge_mm.h

784

static inline struct folio *get_persistent_huge_zero_folio(void)

include/linux/huge_mm.h

800

static inline int split_folio_to_list_to_order(struct folio *folio,

include/linux/huge_mm.h

803

return split_huge_page_to_list_to_order(&folio->page, list, new_order);

include/linux/huge_mm.h

806

static inline int split_folio_to_order(struct folio *folio, int new_order)

include/linux/huge_mm.h

808

return split_folio_to_list_to_order(folio, NULL, new_order);

include/linux/huge_mm.h

824

static inline struct folio *largest_zero_folio(void)

include/linux/huge_mm.h

826

struct folio *folio = get_persistent_huge_zero_folio();

include/linux/huge_mm.h

828

if (folio)

include/linux/huge_mm.h

829

return folio;

include/linux/hugetlb.h

1091

static inline struct hugepage_subpool *hugetlb_folio_subpool(struct folio *folio)

include/linux/hugetlb.h

1096

static inline struct folio *filemap_lock_hugetlb_folio(struct hstate *h,

include/linux/hugetlb.h

1102

static inline int isolate_or_dissolve_huge_folio(struct folio *folio,

include/linux/hugetlb.h

1118

static inline struct folio *alloc_hugetlb_folio(struct vm_area_struct *vma,

include/linux/hugetlb.h

1125

static inline struct folio *

include/linux/hugetlb.h

1132

static inline struct folio *

include/linux/hugetlb.h

1160

static inline struct hstate *folio_hstate(struct folio *folio)

include/linux/hugetlb.h

1210

static inline int dissolve_free_hugetlb_folio(struct folio *folio)

include/linux/hugetlb.h

131

struct folio *, zap_flags_t);

include/linux/hugetlb.h

135

struct folio *, zap_flags_t zap_flags);

include/linux/hugetlb.h

148

struct folio **foliop);

include/linux/hugetlb.h

154

bool folio_isolate_hugetlb(struct folio *folio, struct list_head *list);

include/linux/hugetlb.h

155

int get_hwpoison_hugetlb_folio(struct folio *folio, bool *hugetlb, bool unpoison);

include/linux/hugetlb.h

156

void folio_putback_hugetlb(struct folio *folio);

include/linux/hugetlb.h

157

void move_hugetlb_state(struct folio *old_folio, struct folio *new_folio, int reason);

include/linux/hugetlb.h

168

struct address_space *hugetlb_folio_mapping_lock_write(struct folio *folio);

include/linux/hugetlb.h

22

void free_huge_folio(struct folio *folio);

include/linux/hugetlb.h

296

struct folio *folio)

include/linux/hugetlb.h

399

struct folio **foliop)

include/linux/hugetlb.h

412

static inline bool folio_isolate_hugetlb(struct folio *folio, struct list_head *list)

include/linux/hugetlb.h

417

static inline int get_hwpoison_hugetlb_folio(struct folio *folio, bool *hugetlb, bool unpoison)

include/linux/hugetlb.h

422

static inline void folio_putback_hugetlb(struct folio *folio)

include/linux/hugetlb.h

426

static inline void move_hugetlb_state(struct folio *old_folio,

include/linux/hugetlb.h

427

struct folio *new_folio, int reason)

include/linux/hugetlb.h

441

unsigned long end, struct folio *folio,

include/linux/hugetlb.h

598

bool folio_test_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

599

{ void *private = &folio->private; \

include/linux/hugetlb.h

605

void folio_set_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

606

{ void *private = &folio->private; \

include/linux/hugetlb.h

612

void folio_clear_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

613

{ void *private = &folio->private; \

include/linux/hugetlb.h

619

folio_test_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

624

folio_set_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

629

folio_clear_hugetlb_##flname(struct folio *folio) \

include/linux/hugetlb.h

691

int isolate_or_dissolve_huge_folio(struct folio *folio, struct list_head *list);

include/linux/hugetlb.h

694

struct folio *alloc_hugetlb_folio(struct vm_area_struct *vma,

include/linux/hugetlb.h

696

struct folio *alloc_hugetlb_folio_nodemask(struct hstate *h, int preferred_nid,

include/linux/hugetlb.h

699

struct folio *alloc_hugetlb_folio_reserve(struct hstate *h, int preferred_nid,

include/linux/hugetlb.h

702

int hugetlb_add_to_page_cache(struct folio *folio, struct address_space *mapping,

include/linux/hugetlb.h

705

unsigned long address, struct folio *folio);

include/linux/hugetlb.h

730

static inline struct hugepage_subpool *hugetlb_folio_subpool(struct folio *folio)

include/linux/hugetlb.h

732

return folio->_hugetlb_subpool;

include/linux/hugetlb.h

735

static inline void hugetlb_set_folio_subpool(struct folio *folio,

include/linux/hugetlb.h

738

folio->_hugetlb_subpool = subpool;

include/linux/hugetlb.h

819

static inline struct folio *filemap_lock_hugetlb_folio(struct hstate *h,

include/linux/hugetlb.h

837

static inline void arch_clear_hugetlb_flags(struct folio *folio) { }

include/linux/hugetlb.h

860

static inline struct hstate *folio_hstate(struct folio *folio)

include/linux/hugetlb.h

862

VM_BUG_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/hugetlb.h

863

return size_to_hstate(folio_size(folio));

include/linux/hugetlb.h

876

int dissolve_free_hugetlb_folio(struct folio *folio);

include/linux/hugetlb.h

881

extern void folio_clear_hugetlb_hwpoison(struct folio *folio);

include/linux/hugetlb.h

883

static inline void folio_clear_hugetlb_hwpoison(struct folio *folio)

include/linux/hugetlb_cgroup.h

100

__set_hugetlb_cgroup(folio, h_cg, true);

include/linux/hugetlb_cgroup.h

133

struct folio *folio);

include/linux/hugetlb_cgroup.h

136

struct folio *folio);

include/linux/hugetlb_cgroup.h

138

struct folio *folio);

include/linux/hugetlb_cgroup.h

140

struct folio *folio);

include/linux/hugetlb_cgroup.h

156

extern void hugetlb_cgroup_migrate(struct folio *old_folio,

include/linux/hugetlb_cgroup.h

157

struct folio *new_folio);

include/linux/hugetlb_cgroup.h

167

static inline struct hugetlb_cgroup *hugetlb_cgroup_from_folio(struct folio *folio)

include/linux/hugetlb_cgroup.h

173

hugetlb_cgroup_from_folio_rsvd(struct folio *folio)

include/linux/hugetlb_cgroup.h

178

static inline void set_hugetlb_cgroup(struct folio *folio,

include/linux/hugetlb_cgroup.h

183

static inline void set_hugetlb_cgroup_rsvd(struct folio *folio,

include/linux/hugetlb_cgroup.h

222

struct folio *folio)

include/linux/hugetlb_cgroup.h

229

struct folio *folio)

include/linux/hugetlb_cgroup.h

234

struct folio *folio)

include/linux/hugetlb_cgroup.h

240

struct folio *folio)

include/linux/hugetlb_cgroup.h

265

static inline void hugetlb_cgroup_migrate(struct folio *old_folio,

include/linux/hugetlb_cgroup.h

266

struct folio *new_folio)

include/linux/hugetlb_cgroup.h

61

__hugetlb_cgroup_from_folio(struct folio *folio, bool rsvd)

include/linux/hugetlb_cgroup.h

63

VM_BUG_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/hugetlb_cgroup.h

65

return folio->_hugetlb_cgroup_rsvd;

include/linux/hugetlb_cgroup.h

67

return folio->_hugetlb_cgroup;

include/linux/hugetlb_cgroup.h

70

static inline struct hugetlb_cgroup *hugetlb_cgroup_from_folio(struct folio *folio)

include/linux/hugetlb_cgroup.h

72

return __hugetlb_cgroup_from_folio(folio, false);

include/linux/hugetlb_cgroup.h

76

hugetlb_cgroup_from_folio_rsvd(struct folio *folio)

include/linux/hugetlb_cgroup.h

78

return __hugetlb_cgroup_from_folio(folio, true);

include/linux/hugetlb_cgroup.h

81

static inline void __set_hugetlb_cgroup(struct folio *folio,

include/linux/hugetlb_cgroup.h

84

VM_BUG_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/hugetlb_cgroup.h

86

folio->_hugetlb_cgroup_rsvd = h_cg;

include/linux/hugetlb_cgroup.h

88

folio->_hugetlb_cgroup = h_cg;

include/linux/hugetlb_cgroup.h

91

static inline void set_hugetlb_cgroup(struct folio *folio,

include/linux/hugetlb_cgroup.h

94

__set_hugetlb_cgroup(folio, h_cg, false);

include/linux/hugetlb_cgroup.h

97

static inline void set_hugetlb_cgroup_rsvd(struct folio *folio,

include/linux/iomap.h

163

struct folio *(*get_folio)(struct iomap_iter *iter, loff_t pos,

include/linux/iomap.h

166

struct folio *folio);

include/linux/iomap.h

193

struct folio *folio, loff_t pos, size_t len);

include/linux/iomap.h

363

bool iomap_is_partially_uptodate(struct folio *, size_t from, size_t count);

include/linux/iomap.h

364

struct folio *iomap_get_folio(struct iomap_iter *iter, loff_t pos, size_t len);

include/linux/iomap.h

365

bool iomap_release_folio(struct folio *folio, gfp_t gfp_flags);

include/linux/iomap.h

366

void iomap_invalidate_folio(struct folio *folio, size_t offset, size_t len);

include/linux/iomap.h

367

bool iomap_dirty_folio(struct address_space *mapping, struct folio *folio);

include/linux/iomap.h

462

struct folio *folio, u64 pos, unsigned int len,

include/linux/iomap.h

492

ssize_t iomap_add_to_ioend(struct iomap_writepage_ctx *wpc, struct folio *folio,

include/linux/iomap.h

496

void iomap_finish_folio_read(struct folio *folio, size_t off, size_t len,

include/linux/iomap.h

498

void iomap_finish_folio_write(struct inode *inode, struct folio *folio,

include/linux/iomap.h

501

int iomap_writeback_folio(struct iomap_writepage_ctx *wpc, struct folio *folio);

include/linux/iomap.h

506

struct folio *cur_folio;

include/linux/iomap.h

630

static inline void iomap_bio_read_folio(struct folio *folio,

include/linux/iomap.h

635

.cur_folio = folio,

include/linux/iov_iter.h

162

struct folio *folio = folioq_folio(folioq, slot);

include/linux/iov_iter.h

167

if (!folio)

include/linux/iov_iter.h

172

base = kmap_local_folio(folio, skip);

include/linux/iov_iter.h

207

struct folio *folio;

include/linux/iov_iter.h

214

xas_for_each(&xas, folio, ULONG_MAX) {

include/linux/iov_iter.h

217

if (xas_retry(&xas, folio))

include/linux/iov_iter.h

219

if (WARN_ON(xa_is_value(folio)))

include/linux/iov_iter.h

221

if (WARN_ON(folio_test_hugetlb(folio)))

include/linux/iov_iter.h

224

offset = offset_in_folio(folio, start + progress);

include/linux/iov_iter.h

225

flen = min(folio_size(folio) - offset, len);

include/linux/iov_iter.h

228

void *base = kmap_local_folio(folio, offset);

include/linux/jbd2.h

1543

int jbd2_journal_invalidate_folio(journal_t *, struct folio *,

include/linux/jbd2.h

1545

bool jbd2_journal_try_to_free_buffers(journal_t *journal, struct folio *folio);

include/linux/kexec_handover.h

16

struct folio;

include/linux/kexec_handover.h

23

int kho_preserve_folio(struct folio *folio);

include/linux/kexec_handover.h

24

void kho_unpreserve_folio(struct folio *folio);

include/linux/kexec_handover.h

32

struct folio *kho_restore_folio(phys_addr_t phys);

include/linux/kexec_handover.h

54

static inline int kho_preserve_folio(struct folio *folio)

include/linux/kexec_handover.h

59

static inline void kho_unpreserve_folio(struct folio *folio) { }

include/linux/kexec_handover.h

84

static inline struct folio *kho_restore_folio(phys_addr_t phys)

include/linux/ksm.h

134

static inline void collect_procs_ksm(const struct folio *folio,

include/linux/ksm.h

147

static inline struct folio *ksm_might_need_to_copy(struct folio *folio,

include/linux/ksm.h

150

return folio;

include/linux/ksm.h

153

static inline void rmap_walk_ksm(struct folio *folio,

include/linux/ksm.h

158

static inline void folio_migrate_ksm(struct folio *newfolio, struct folio *old)

include/linux/ksm.h

94

struct folio *ksm_might_need_to_copy(struct folio *folio,

include/linux/ksm.h

97

void rmap_walk_ksm(struct folio *folio, struct rmap_walk_control *rwc);

include/linux/ksm.h

98

void folio_migrate_ksm(struct folio *newfolio, struct folio *folio);

include/linux/ksm.h

99

void collect_procs_ksm(const struct folio *folio, const struct page *page,

include/linux/leafops.h

367

struct folio *folio)

include/linux/leafops.h

380

VM_WARN_ON_ONCE(!folio_test_locked(folio));

include/linux/leafops.h

406

static inline struct folio *softleaf_to_folio(softleaf_t entry)

include/linux/leafops.h

408

struct folio *folio = pfn_folio(softleaf_to_pfn(entry));

include/linux/leafops.h

412

softleaf_migration_sync(entry, folio);

include/linux/leafops.h

414

return folio;

include/linux/leafops.h

648

static inline struct folio *pmd_to_softleaf_folio(pmd_t pmd)

include/linux/list_lru.h

101

int folio_memcg_list_lru_alloc(struct folio *folio, struct list_lru *lru,

include/linux/list_lru.h

104

static inline int folio_memcg_list_lru_alloc(struct folio *folio,

include/linux/memcontrol.h

1021

void folio_split_memcg_refs(struct folio *folio, unsigned old_order,

include/linux/memcontrol.h

1050

static inline struct mem_cgroup *folio_memcg(struct folio *folio)

include/linux/memcontrol.h

1055

static inline bool folio_memcg_charged(struct folio *folio)

include/linux/memcontrol.h

1060

static inline struct mem_cgroup *folio_memcg_check(struct folio *folio)

include/linux/memcontrol.h

1075

static inline bool folio_memcg_kmem(struct folio *folio)

include/linux/memcontrol.h

1146

static inline int mem_cgroup_charge(struct folio *folio,

include/linux/memcontrol.h

1152

static inline int mem_cgroup_charge_hugetlb(struct folio* folio, gfp_t gfp)

include/linux/memcontrol.h

1157

static inline int mem_cgroup_swapin_charge_folio(struct folio *folio,

include/linux/memcontrol.h

1163

static inline void mem_cgroup_uncharge(struct folio *folio)

include/linux/memcontrol.h

1171

static inline void mem_cgroup_replace_folio(struct folio *old,

include/linux/memcontrol.h

1172

struct folio *new)

include/linux/memcontrol.h

1176

static inline void mem_cgroup_migrate(struct folio *old, struct folio *new)

include/linux/memcontrol.h

1186

static inline struct lruvec *folio_lruvec(struct folio *folio)

include/linux/memcontrol.h

1188

struct pglist_data *pgdat = folio_pgdat(folio);

include/linux/memcontrol.h

1213

static inline struct mem_cgroup *get_mem_cgroup_from_folio(struct folio *folio)

include/linux/memcontrol.h

1246

static inline struct lruvec *folio_lruvec_lock(struct folio *folio)

include/linux/memcontrol.h

1248

struct pglist_data *pgdat = folio_pgdat(folio);

include/linux/memcontrol.h

1255

static inline struct lruvec *folio_lruvec_lock_irq(struct folio *folio)

include/linux/memcontrol.h

1257

struct pglist_data *pgdat = folio_pgdat(folio);

include/linux/memcontrol.h

1264

static inline struct lruvec *folio_lruvec_lock_irqsave(struct folio *folio,

include/linux/memcontrol.h

1267

struct pglist_data *pgdat = folio_pgdat(folio);

include/linux/memcontrol.h

1430

static inline void count_memcg_folio_events(struct folio *folio,

include/linux/memcontrol.h

1449

static inline void folio_split_memcg_refs(struct folio *folio,

include/linux/memcontrol.h

1540

static inline bool folio_matches_lruvec(struct folio *folio,

include/linux/memcontrol.h

1543

return lruvec_pgdat(lruvec) == folio_pgdat(folio) &&

include/linux/memcontrol.h

1544

lruvec_memcg(lruvec) == folio_memcg(folio);

include/linux/memcontrol.h

1548

static inline struct lruvec *folio_lruvec_relock_irq(struct folio *folio,

include/linux/memcontrol.h

1552

if (folio_matches_lruvec(folio, locked_lruvec))

include/linux/memcontrol.h

1558

return folio_lruvec_lock_irq(folio);

include/linux/memcontrol.h

1562

static inline void folio_lruvec_relock_irqsave(struct folio *folio,

include/linux/memcontrol.h

1566

if (folio_matches_lruvec(folio, *lruvecp))

include/linux/memcontrol.h

1572

*lruvecp = folio_lruvec_lock_irqsave(folio, flags);

include/linux/memcontrol.h

1582

void mem_cgroup_track_foreign_dirty_slowpath(struct folio *folio,

include/linux/memcontrol.h

1585

static inline void mem_cgroup_track_foreign_dirty(struct folio *folio,

include/linux/memcontrol.h

1593

if (!folio_memcg_charged(folio))

include/linux/memcontrol.h

1597

memcg = folio_memcg(folio);

include/linux/memcontrol.h

1599

mem_cgroup_track_foreign_dirty_slowpath(folio, wb);

include/linux/memcontrol.h

1620

static inline void mem_cgroup_track_foreign_dirty(struct folio *folio,

include/linux/memcontrol.h

1739

struct obj_cgroup *get_obj_cgroup_from_folio(struct folio *folio);

include/linux/memcontrol.h

1842

static inline struct obj_cgroup *get_obj_cgroup_from_folio(struct folio *folio)

include/linux/memcontrol.h

1976

void __memcg1_swapout(struct folio *folio, struct swap_cluster_info *ci);

include/linux/memcontrol.h

1977

void memcg1_swapin(struct folio *folio);

include/linux/memcontrol.h

1981

static inline void __memcg1_swapout(struct folio *folio,

include/linux/memcontrol.h

1986

static inline void memcg1_swapin(struct folio *folio)

include/linux/memcontrol.h

389

static inline struct obj_cgroup *folio_objcg(struct folio *folio)

include/linux/memcontrol.h

391

unsigned long memcg_data = folio->memcg_data;

include/linux/memcontrol.h

393

VM_BUG_ON_FOLIO(folio_test_slab(folio), folio);

include/linux/memcontrol.h

394

VM_BUG_ON_FOLIO(memcg_data & MEMCG_DATA_OBJEXTS, folio);

include/linux/memcontrol.h

427

static inline struct mem_cgroup *folio_memcg(struct folio *folio)

include/linux/memcontrol.h

429

struct obj_cgroup *objcg = folio_objcg(folio);

include/linux/memcontrol.h

440

static inline bool folio_memcg_charged(struct folio *folio)

include/linux/memcontrol.h

442

return folio->memcg_data != 0;

include/linux/memcontrol.h

460

static inline struct mem_cgroup *folio_memcg_check(struct folio *folio)

include/linux/memcontrol.h

466

unsigned long memcg_data = READ_ONCE(folio->memcg_data);

include/linux/memcontrol.h

481

return folio_memcg_check((struct folio *)page);

include/linux/memcontrol.h

506

static inline bool folio_memcg_kmem(struct folio *folio)

include/linux/memcontrol.h

508

VM_BUG_ON_PGFLAGS(PageTail(&folio->page), &folio->page);

include/linux/memcontrol.h

509

VM_BUG_ON_FOLIO(folio->memcg_data & MEMCG_DATA_OBJEXTS, folio);

include/linux/memcontrol.h

510

return folio->memcg_data & MEMCG_DATA_KMEM;

include/linux/memcontrol.h

636

int __mem_cgroup_charge(struct folio *folio, struct mm_struct *mm, gfp_t gfp);

include/linux/memcontrol.h

652

static inline int mem_cgroup_charge(struct folio *folio, struct mm_struct *mm,

include/linux/memcontrol.h

657

return __mem_cgroup_charge(folio, mm, gfp);

include/linux/memcontrol.h

660

int mem_cgroup_charge_hugetlb(struct folio* folio, gfp_t gfp);

include/linux/memcontrol.h

662

int mem_cgroup_swapin_charge_folio(struct folio *folio, unsigned short id,

include/linux/memcontrol.h

665

void __mem_cgroup_uncharge(struct folio *folio);

include/linux/memcontrol.h

673

static inline void mem_cgroup_uncharge(struct folio *folio)

include/linux/memcontrol.h

677

__mem_cgroup_uncharge(folio);

include/linux/memcontrol.h

688

void mem_cgroup_replace_folio(struct folio *old, struct folio *new);

include/linux/memcontrol.h

689

void mem_cgroup_migrate(struct folio *old, struct folio *new);

include/linux/memcontrol.h

741

static inline struct lruvec *folio_lruvec(struct folio *folio)

include/linux/memcontrol.h

743

struct mem_cgroup *memcg = folio_memcg(folio);

include/linux/memcontrol.h

745

VM_WARN_ON_ONCE_FOLIO(!memcg && !mem_cgroup_disabled(), folio);

include/linux/memcontrol.h

746

return mem_cgroup_lruvec(memcg, folio_pgdat(folio));

include/linux/memcontrol.h

755

struct mem_cgroup *get_mem_cgroup_from_folio(struct folio *folio);

include/linux/memcontrol.h

757

struct lruvec *folio_lruvec_lock(struct folio *folio);

include/linux/memcontrol.h

758

struct lruvec *folio_lruvec_lock_irq(struct folio *folio);

include/linux/memcontrol.h

759

struct lruvec *folio_lruvec_lock_irqsave(struct folio *folio,

include/linux/memcontrol.h

883

struct cgroup_subsys_state *get_mem_cgroup_css_from_folio(struct folio *folio);

include/linux/memcontrol.h

961

static inline void count_memcg_folio_events(struct folio *folio,

include/linux/memcontrol.h

966

if (!folio_memcg_charged(folio))

include/linux/memcontrol.h

970

memcg = folio_memcg(folio);

include/linux/memfd.h

11

struct folio *memfd_alloc_folio(struct file *memfd, pgoff_t idx);

include/linux/memfd.h

28

static inline struct folio *memfd_alloc_folio(struct file *memfd, pgoff_t idx)

include/linux/mempolicy.h

172

int mpol_misplaced(struct folio *folio, struct vm_fault *vmf,

include/linux/mempolicy.h

290

static inline int mpol_misplaced(struct folio *folio,

include/linux/memremap.h

108

void (*folio_split)(struct folio *head, struct folio *tail);

include/linux/memremap.h

166

static inline bool folio_is_device_private(const struct folio *folio)

include/linux/memremap.h

169

folio_is_zone_device(folio) &&

include/linux/memremap.h

170

folio->pgmap->type == MEMORY_DEVICE_PRIVATE;

include/linux/memremap.h

179

static inline bool folio_is_pci_p2pdma(const struct folio *folio)

include/linux/memremap.h

182

folio_is_zone_device(folio) &&

include/linux/memremap.h

183

folio->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA;

include/linux/memremap.h

186

static inline void *folio_zone_device_data(const struct folio *folio)

include/linux/memremap.h

188

VM_WARN_ON_FOLIO(!folio_is_device_private(folio), folio);

include/linux/memremap.h

189

return folio->page.zone_device_data;

include/linux/memremap.h

192

static inline void folio_set_zone_device_data(struct folio *folio, void *data)

include/linux/memremap.h

194

VM_WARN_ON_FOLIO(!folio_is_device_private(folio), folio);

include/linux/memremap.h

195

folio->page.zone_device_data = data;

include/linux/memremap.h

204

static inline bool folio_is_device_coherent(const struct folio *folio)

include/linux/memremap.h

206

return folio_is_zone_device(folio) &&

include/linux/memremap.h

207

folio->pgmap->type == MEMORY_DEVICE_COHERENT;

include/linux/memremap.h

215

static inline bool folio_is_fsdax(const struct folio *folio)

include/linux/memremap.h

217

return folio_is_zone_device(folio) &&

include/linux/memremap.h

218

folio->pgmap->type == MEMORY_DEVICE_FS_DAX;

include/linux/memremap.h

238

static inline void zone_device_folio_init(struct folio *folio,

include/linux/memremap.h

242

zone_device_page_init(&folio->page, pgmap, order);

include/linux/memremap.h

244

folio_set_large_rmappable(folio);

include/linux/memremap.h

247

static inline void zone_device_private_split_cb(struct folio *original_folio,

include/linux/memremap.h

248

struct folio *new_folio)

include/linux/memremap.h

298

static inline void zone_device_private_split_cb(struct folio *original_folio,

include/linux/memremap.h

299

struct folio *new_folio)

include/linux/memremap.h

83

void (*folio_free)(struct folio *folio);

include/linux/migrate.h

10

typedef struct folio *new_folio_t(struct folio *folio, unsigned long private);

include/linux/migrate.h

11

typedef void free_folio_t(struct folio *folio, unsigned long private);

include/linux/migrate.h

111

int migrate_misplaced_folio_prepare(struct folio *folio,

include/linux/migrate.h

113

int migrate_misplaced_folio(struct folio *folio, int node);

include/linux/migrate.h

115

static inline int migrate_misplaced_folio_prepare(struct folio *folio,

include/linux/migrate.h

120

static inline int migrate_misplaced_folio(struct folio *folio, int node)

include/linux/migrate.h

57

int migrate_folio(struct address_space *mapping, struct folio *dst,

include/linux/migrate.h

58

struct folio *src, enum migrate_mode mode);

include/linux/migrate.h

62

struct folio *alloc_migration_target(struct folio *src, unsigned long private);

include/linux/migrate.h

64

bool isolate_folio_to_list(struct folio *folio, struct list_head *list);

include/linux/migrate.h

67

struct folio *dst, struct folio *src);

include/linux/migrate.h

70

void folio_migrate_flags(struct folio *newfolio, struct folio *folio);

include/linux/migrate.h

72

struct folio *newfolio, struct folio *folio, int extra_count);

include/linux/migrate.h

82

static inline struct folio *alloc_migration_target(struct folio *src,

include/linux/migrate.h

87

static inline bool isolate_folio_to_list(struct folio *folio, struct list_head *list)

include/linux/migrate.h

91

struct folio *dst, struct folio *src)

include/linux/mm.h

1724

static inline unsigned int folio_large_order(const struct folio *folio)

include/linux/mm.h

1726

return folio->_flags_1 & 0xff;

include/linux/mm.h

1730

static inline unsigned long folio_large_nr_pages(const struct folio *folio)

include/linux/mm.h

1732

return folio->_nr_pages;

include/linux/mm.h

1735

static inline unsigned long folio_large_nr_pages(const struct folio *folio)

include/linux/mm.h

1737

return 1L << folio_large_order(folio);

include/linux/mm.h

1750

const struct folio *folio = (struct folio *)page;

include/linux/mm.h

1752

if (!test_bit(PG_head, &folio->flags.f))

include/linux/mm.h

1754

return folio_large_order(folio);

include/linux/mm.h

1766

static inline unsigned int folio_order(const struct folio *folio)

include/linux/mm.h

1768

if (!folio_test_large(folio))

include/linux/mm.h

1770

return folio_large_order(folio);

include/linux/mm.h

1780

static inline void folio_reset_order(struct folio *folio)

include/linux/mm.h

1782

if (WARN_ON_ONCE(!folio_test_large(folio)))

include/linux/mm.h

1784

folio->_flags_1 &= ~0xffUL;

include/linux/mm.h

1786

folio->_nr_pages = 0;

include/linux/mm.h

1814

static inline int folio_put_testzero(struct folio *folio)

include/linux/mm.h

1816

return put_page_testzero(&folio->page);

include/linux/mm.h

1830

static inline struct folio *folio_get_nontail_page(struct page *page)

include/linux/mm.h

1834

return (struct folio *)page;

include/linux/mm.h

1877

static inline int folio_entire_mapcount(const struct folio *folio)

include/linux/mm.h

1879

VM_BUG_ON_FOLIO(!folio_test_large(folio), folio);

include/linux/mm.h

1880

if (!IS_ENABLED(CONFIG_64BIT) && unlikely(folio_large_order(folio) == 1))

include/linux/mm.h

1882

return atomic_read(&folio->_entire_mapcount) + 1;

include/linux/mm.h

1885

static inline int folio_large_mapcount(const struct folio *folio)

include/linux/mm.h

1887

VM_WARN_ON_FOLIO(!folio_test_large(folio), folio);

include/linux/mm.h

1888

return atomic_read(&folio->_large_mapcount) + 1;

include/linux/mm.h

1911

static inline int folio_mapcount(const struct folio *folio)

include/linux/mm.h

1915

if (likely(!folio_test_large(folio))) {

include/linux/mm.h

1916

mapcount = atomic_read(&folio->_mapcount) + 1;

include/linux/mm.h

1921

return folio_large_mapcount(folio);

include/linux/mm.h

1930

static inline bool folio_mapped(const struct folio *folio)

include/linux/mm.h

1932

return folio_mapcount(folio) >= 1;

include/linux/mm.h

1942

static inline struct folio *virt_to_folio(const void *x)

include/linux/mm.h

1949

void __folio_put(struct folio *folio);

include/linux/mm.h

1952

void folio_copy(struct folio *dst, struct folio *src);

include/linux/mm.h

1953

int folio_mc_copy(struct folio *dst, struct folio *src);

include/linux/mm.h

2004

vm_fault_t do_set_pmd(struct vm_fault *vmf, struct folio *folio, struct page *page);

include/linux/mm.h

2005

void set_pte_range(struct vm_fault *vmf, struct folio *folio,

include/linux/mm.h

2072

#define folio_ref_zero_or_close_to_overflow(folio) \

include/linux/mm.h

2073

((unsigned int) folio_ref_count(folio) + 127u <= 127u)

include/linux/mm.h

2083

static inline void folio_get(struct folio *folio)

include/linux/mm.h

2085

VM_BUG_ON_FOLIO(folio_ref_zero_or_close_to_overflow(folio), folio);

include/linux/mm.h

2086

folio_ref_inc(folio);

include/linux/mm.h

2091

struct folio *folio = page_folio(page);

include/linux/mm.h

2092

if (WARN_ON_ONCE(folio_test_slab(folio)))

include/linux/mm.h

2094

if (WARN_ON_ONCE(folio_test_large_kmalloc(folio)))

include/linux/mm.h

2096

folio_get(folio);

include/linux/mm.h

2121

static inline void folio_put(struct folio *folio)

include/linux/mm.h

2123

if (folio_put_testzero(folio))

include/linux/mm.h

2124

__folio_put(folio);

include/linux/mm.h

2141

static inline void folio_put_refs(struct folio *folio, int refs)

include/linux/mm.h

2143

if (folio_ref_sub_and_test(folio, refs))

include/linux/mm.h

2144

__folio_put(folio);

include/linux/mm.h

2162

struct folio **folios;

include/linux/mm.h

2188

struct folio *folio = page_folio(page);

include/linux/mm.h

2190

if (folio_test_slab(folio) || folio_test_large_kmalloc(folio))

include/linux/mm.h

2193

folio_put(folio);

include/linux/mm.h

2229

void unpin_folio(struct folio *folio);

include/linux/mm.h

2235

void unpin_user_folio(struct folio *folio, unsigned long npages);

include/linux/mm.h

2236

void unpin_folios(struct folio **folios, unsigned long nfolios);

include/linux/mm.h

2302

static inline int folio_nid(const struct folio *folio)

include/linux/mm.h

2304

return memdesc_nid(folio->flags);

include/linux/mm.h

2357

static inline int folio_xchg_last_cpupid(struct folio *folio, int cpupid)

include/linux/mm.h

2359

return xchg(&folio->_last_cpupid, cpupid & LAST_CPUPID_MASK);

include/linux/mm.h

2362

static inline int folio_last_cpupid(struct folio *folio)

include/linux/mm.h

2364

return folio->_last_cpupid;

include/linux/mm.h

2371

static inline int folio_last_cpupid(struct folio *folio)

include/linux/mm.h

2373

return (folio->flags.f >> LAST_CPUPID_PGSHIFT) & LAST_CPUPID_MASK;

include/linux/mm.h

2376

int folio_xchg_last_cpupid(struct folio *folio, int cpupid);

include/linux/mm.h

2384

static inline int folio_xchg_access_time(struct folio *folio, int time)

include/linux/mm.h

2388

last_time = folio_xchg_last_cpupid(folio,

include/linux/mm.h

240

static inline unsigned long folio_page_idx(const struct folio *folio,

include/linux/mm.h

2403

bool folio_use_access_time(struct folio *folio);

include/linux/mm.h

2405

static inline int folio_xchg_last_cpupid(struct folio *folio, int cpupid)

include/linux/mm.h

2407

return folio_nid(folio); /* XXX */

include/linux/mm.h

2410

static inline int folio_xchg_access_time(struct folio *folio, int time)

include/linux/mm.h

2415

static inline int folio_last_cpupid(struct folio *folio)

include/linux/mm.h

2417

return folio_nid(folio); /* XXX */

include/linux/mm.h

243

return page - &folio->page;

include/linux/mm.h

2457

static inline bool folio_use_access_time(struct folio *folio)

include/linux/mm.h

246

static inline struct folio *lru_to_folio(struct list_head *head)

include/linux/mm.h

248

return list_entry((head)->prev, struct folio, lru);

include/linux/mm.h

2527

static inline pg_data_t *folio_pgdat(const struct folio *folio)

include/linux/mm.h

2529

return NODE_DATA(folio_nid(folio));

include/linux/mm.h

2532

static inline struct zone *folio_zone(const struct folio *folio)

include/linux/mm.h

2534

return &folio_pgdat(folio)->node_zones[folio_zonenum(folio)];

include/linux/mm.h

2564

static inline unsigned long folio_pfn(const struct folio *folio)

include/linux/mm.h

2566

return page_to_pfn(&folio->page);

include/linux/mm.h

2569

static inline struct folio *pfn_folio(unsigned long pfn)

include/linux/mm.h

2590

static inline pte_t folio_mk_pte(const struct folio *folio, pgprot_t pgprot)

include/linux/mm.h

2592

return pfn_pte(folio_pfn(folio), pgprot);

include/linux/mm.h

2606

static inline pmd_t folio_mk_pmd(const struct folio *folio, pgprot_t pgprot)

include/linux/mm.h

2608

return pmd_mkhuge(pfn_pmd(folio_pfn(folio), pgprot));

include/linux/mm.h

2622

static inline pud_t folio_mk_pud(const struct folio *folio, pgprot_t pgprot)

include/linux/mm.h

2624

return pud_mkhuge(pfn_pud(folio_pfn(folio), pgprot));

include/linux/mm.h

2630

static inline bool folio_has_pincount(const struct folio *folio)

include/linux/mm.h

2633

return folio_test_large(folio);

include/linux/mm.h

2634

return folio_order(folio) > 1;

include/linux/mm.h

2662

static inline bool folio_maybe_dma_pinned(struct folio *folio)

include/linux/mm.h

2664

if (folio_has_pincount(folio))

include/linux/mm.h

2665

return atomic_read(&folio->_pincount) > 0;

include/linux/mm.h

2675

return ((unsigned int)folio_ref_count(folio)) >=

include/linux/mm.h

2686

struct folio *folio)

include/linux/mm.h

2693

return folio_maybe_dma_pinned(folio);

include/linux/mm.h

2713

static inline bool is_zero_folio(const struct folio *folio)

include/linux/mm.h

2715

return is_zero_page(&folio->page);

include/linux/mm.h

2720

static inline bool folio_is_longterm_pinnable(struct folio *folio)

include/linux/mm.h

2723

int mt = folio_migratetype(folio);

include/linux/mm.h

2729

if (is_zero_folio(folio))

include/linux/mm.h

2733

if (folio_is_device_coherent(folio))

include/linux/mm.h

2740

if (folio_is_fsdax(folio))

include/linux/mm.h

2744

return !folio_is_zone_movable(folio);

include/linux/mm.h

2748

static inline bool folio_is_longterm_pinnable(struct folio *folio)

include/linux/mm.h

2782

static inline unsigned long folio_nr_pages(const struct folio *folio)

include/linux/mm.h

2784

if (!folio_test_large(folio))

include/linux/mm.h

2786

return folio_large_nr_pages(folio);

include/linux/mm.h

2796

const struct folio *folio = (struct folio *)page;

include/linux/mm.h

2798

if (!test_bit(PG_head, &folio->flags.f))

include/linux/mm.h

2800

return folio_large_nr_pages(folio);

include/linux/mm.h

2817

static inline struct folio *folio_next(struct folio *folio)

include/linux/mm.h

2819

return (struct folio *)folio_page(folio, folio_nr_pages(folio));

include/linux/mm.h

2834

static inline unsigned int folio_shift(const struct folio *folio)

include/linux/mm.h

2836

return PAGE_SHIFT + folio_order(folio);

include/linux/mm.h

2847

static inline size_t folio_size(const struct folio *folio)

include/linux/mm.h

2849

return PAGE_SIZE << folio_order(folio);

include/linux/mm.h

2890

static inline bool folio_maybe_mapped_shared(struct folio *folio)

include/linux/mm.h

2892

int mapcount = folio_mapcount(folio);

include/linux/mm.h

2895

if (!folio_test_large(folio) || unlikely(folio_test_hugetlb(folio)))

include/linux/mm.h

2913

return test_bit(FOLIO_MM_IDS_SHARED_BITNUM, &folio->_mm_ids);

include/linux/mm.h

2949

static inline int folio_expected_ref_count(const struct folio *folio)

include/linux/mm.h

2951

const int order = folio_order(folio);

include/linux/mm.h

2954

if (WARN_ON_ONCE(page_has_type(&folio->page) && !folio_test_hugetlb(folio)))

include/linux/mm.h

2958

ref_count += folio_test_swapcache(folio) << order;

include/linux/mm.h

2960

if (!folio_test_anon(folio)) {

include/linux/mm.h

2962

ref_count += !!folio->mapping << order;

include/linux/mm.h

2964

ref_count += folio_test_private(folio);

include/linux/mm.h

2968

return ref_count + folio_mapcount(folio);

include/linux/mm.h

2972

static inline int arch_make_folio_accessible(struct folio *folio)

include/linux/mm.h

3016

static inline void *folio_address(const struct folio *folio)

include/linux/mm.h

3018

return page_address(&folio->page);

include/linux/mm.h

3041

static inline bool folio_is_pfmemalloc(const struct folio *folio)

include/linux/mm.h

3048

return (uintptr_t)folio->lru.next & BIT(1);

include/linux/mm.h

3071

#define offset_in_folio(folio, p) ((unsigned long)(p) & (folio_size(folio) - 1))

include/linux/mm.h

3077

struct folio *single_folio; /* Locked folio to be unmapped */

include/linux/mm.h

3102

struct folio *vm_normal_folio(struct vm_area_struct *vma, unsigned long addr,

include/linux/mm.h

3106

struct folio *vm_normal_folio_pmd(struct vm_area_struct *vma,

include/linux/mm.h

3172

struct folio *folio);

include/linux/mm.h

3277

struct folio **folios, unsigned int max_folios,

include/linux/mm.h

3279

int folio_add_pins(struct folio *folio, unsigned int pins);

include/linux/mm.h

3285

void folio_add_pin(struct folio *folio);

include/linux/mm.h

3294

bool folio_mark_dirty(struct folio *folio);

include/linux/mm.h

3295

bool folio_mark_dirty_lock(struct folio *folio);

include/linux/mm.h

3378

static inline int mm_counter_file(struct folio *folio)

include/linux/mm.h

3380

if (folio_test_swapbacked(folio))

include/linux/mm.h

3385

static inline int mm_counter(struct folio *folio)

include/linux/mm.h

3387

if (folio_test_anon(folio))

include/linux/mm.h

3389

return mm_counter_file(folio);

include/linux/mm.h

3800

struct folio *folio = ptdesc_folio(ptdesc);

include/linux/mm.h

3802

__folio_set_pgtable(folio);

include/linux/mm.h

3803

lruvec_stat_add_folio(folio, NR_PAGETABLE);

include/linux/mm.h

3808

struct folio *folio = ptdesc_folio(ptdesc);

include/linux/mm.h

3811

__folio_clear_pgtable(folio);

include/linux/mm.h

3812

lruvec_stat_sub_folio(folio, NR_PAGETABLE);

include/linux/mm.h

5083

void folio_zero_user(struct folio *folio, unsigned long addr_hint);

include/linux/mm.h

5084

int copy_user_large_folio(struct folio *dst, struct folio *src,

include/linux/mm.h

5087

long copy_folio_from_user(struct folio *dst_folio,

include/linux/mm.h

5258

struct folio folio_snapshot;

include/linux/mm.h

5272

void map_anon_folio_pte_nopf(struct folio *folio, pte_t *pte,

include/linux/mm_inline.h

145

static inline int folio_lru_refs(const struct folio *folio)

include/linux/mm_inline.h

147

unsigned long flags = READ_ONCE(folio->flags.f);

include/linux/mm_inline.h

158

static inline int folio_lru_gen(const struct folio *folio)

include/linux/mm_inline.h

160

unsigned long flags = READ_ONCE(folio->flags.f);

include/linux/mm_inline.h

175

static inline void lru_gen_update_size(struct lruvec *lruvec, struct folio *folio,

include/linux/mm_inline.h

178

int type = folio_is_file_lru(folio);

include/linux/mm_inline.h

179

int zone = folio_zonenum(folio);

include/linux/mm_inline.h

180

int delta = folio_nr_pages(folio);

include/linux/mm_inline.h

222

const struct folio *folio,

include/linux/mm_inline.h

226

int type = folio_is_file_lru(folio);

include/linux/mm_inline.h

241

if (folio_test_active(folio))

include/linux/mm_inline.h

242

gen = MIN_NR_GENS - folio_test_workingset(folio);

include/linux/mm_inline.h

245

else if ((!folio_is_file_lru(folio) && !folio_test_swapcache(folio)) ||

include/linux/mm_inline.h

246

(folio_test_reclaim(folio) &&

include/linux/mm_inline.h

247

(folio_test_dirty(folio) || folio_test_writeback(folio))))

include/linux/mm_inline.h

250

gen = MAX_NR_GENS - (folio_test_workingset(folio) || folio_test_referenced(folio));

include/linux/mm_inline.h

255

static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming)

include/linux/mm_inline.h

259

int gen = folio_lru_gen(folio);

include/linux/mm_inline.h

260

int type = folio_is_file_lru(folio);

include/linux/mm_inline.h

261

int zone = folio_zonenum(folio);

include/linux/mm_inline.h

264

VM_WARN_ON_ONCE_FOLIO(gen != -1, folio);

include/linux/mm_inline.h

266

if (folio_test_unevictable(folio) || !lrugen->enabled)

include/linux/mm_inline.h

269

seq = lru_gen_folio_seq(lruvec, folio, reclaiming);

include/linux/mm_inline.h

273

set_mask_bits(&folio->flags.f, LRU_GEN_MASK | BIT(PG_active), flags);

include/linux/mm_inline.h

275

lru_gen_update_size(lruvec, folio, -1, gen);

include/linux/mm_inline.h

278

list_add_tail(&folio->lru, &lrugen->folios[gen][type][zone]);

include/linux/mm_inline.h

28

static inline int folio_is_file_lru(const struct folio *folio)

include/linux/mm_inline.h

280

list_add(&folio->lru, &lrugen->folios[gen][type][zone]);

include/linux/mm_inline.h

285

static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming)

include/linux/mm_inline.h

288

int gen = folio_lru_gen(folio);

include/linux/mm_inline.h

293

VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio);

include/linux/mm_inline.h

294

VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio);

include/linux/mm_inline.h

298

flags = set_mask_bits(&folio->flags.f, LRU_GEN_MASK, flags);

include/linux/mm_inline.h

30

return !folio_test_swapbacked(folio);

include/linux/mm_inline.h

301

lru_gen_update_size(lruvec, folio, gen, -1);

include/linux/mm_inline.h

302

list_del(&folio->lru);

include/linux/mm_inline.h

307

static inline void folio_migrate_refs(struct folio *new, const struct folio *old)

include/linux/mm_inline.h

330

static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming)

include/linux/mm_inline.h

335

static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming)

include/linux/mm_inline.h

340

static inline void folio_migrate_refs(struct folio *new, const struct folio *old)

include/linux/mm_inline.h

347

void lruvec_add_folio(struct lruvec *lruvec, struct folio *folio)

include/linux/mm_inline.h

349

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

351

VM_WARN_ON_ONCE_FOLIO(!folio_matches_lruvec(folio, lruvec), folio);

include/linux/mm_inline.h

353

if (lru_gen_add_folio(lruvec, folio, false))

include/linux/mm_inline.h

356

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

357

folio_nr_pages(folio));

include/linux/mm_inline.h

359

list_add(&folio->lru, &lruvec->lists[lru]);

include/linux/mm_inline.h

363

void lruvec_add_folio_tail(struct lruvec *lruvec, struct folio *folio)

include/linux/mm_inline.h

365

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

367

VM_WARN_ON_ONCE_FOLIO(!folio_matches_lruvec(folio, lruvec), folio);

include/linux/mm_inline.h

369

if (lru_gen_add_folio(lruvec, folio, true))

include/linux/mm_inline.h

372

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

373

folio_nr_pages(folio));

include/linux/mm_inline.h

375

list_add_tail(&folio->lru, &lruvec->lists[lru]);

include/linux/mm_inline.h

379

void lruvec_del_folio(struct lruvec *lruvec, struct folio *folio)

include/linux/mm_inline.h

381

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

383

VM_WARN_ON_ONCE_FOLIO(!folio_matches_lruvec(folio, lruvec), folio);

include/linux/mm_inline.h

385

if (lru_gen_del_folio(lruvec, folio, false))

include/linux/mm_inline.h

389

list_del(&folio->lru);

include/linux/mm_inline.h

390

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

391

-folio_nr_pages(folio));

include/linux/mm_inline.h

61

static __always_inline void __folio_clear_lru_flags(struct folio *folio)

include/linux/mm_inline.h

63

VM_BUG_ON_FOLIO(!folio_test_lru(folio), folio);

include/linux/mm_inline.h

65

__folio_clear_lru(folio);

include/linux/mm_inline.h

68

if (folio_test_active(folio) && folio_test_unevictable(folio))

include/linux/mm_inline.h

71

__folio_clear_active(folio);

include/linux/mm_inline.h

72

__folio_clear_unevictable(folio);

include/linux/mm_inline.h

82

static __always_inline enum lru_list folio_lru_list(const struct folio *folio)

include/linux/mm_inline.h

86

VM_BUG_ON_FOLIO(folio_test_active(folio) && folio_test_unevictable(folio), folio);

include/linux/mm_inline.h

88

if (folio_test_unevictable(folio))

include/linux/mm_inline.h

91

lru = folio_is_file_lru(folio) ? LRU_INACTIVE_FILE : LRU_INACTIVE_ANON;

include/linux/mm_inline.h

92

if (folio_test_active(folio))

include/linux/mm_types.h

510

static_assert(offsetof(struct page, pg) == offsetof(struct folio, fl))

include/linux/mm_types.h

530

static_assert(offsetof(struct folio, fl) == \

include/linux/mm_types.h

538

static_assert(offsetof(struct folio, fl) == \

include/linux/mm_types.h

544

static_assert(offsetof(struct folio, fl) == \

include/linux/mm_types.h

631

const struct ptdesc *: (const struct folio *)(pt), \

include/linux/mm_types.h

632

struct ptdesc *: (struct folio *)(pt)))

include/linux/mm_types.h

687

static inline void *folio_get_private(const struct folio *folio)

include/linux/mm_types.h

689

return folio->private;

include/linux/mmdebug.h

129

#define VM_BUG_ON_FOLIO(cond, folio) VM_BUG_ON(cond)

include/linux/mmdebug.h

136

#define VM_WARN_ON_FOLIO(cond, folio) BUILD_BUG_ON_INVALID(cond)

include/linux/mmdebug.h

137

#define VM_WARN_ON_ONCE_FOLIO(cond, folio) BUILD_BUG_ON_INVALID(cond)

include/linux/mmdebug.h

29

#define VM_BUG_ON_FOLIO(cond, folio) \

include/linux/mmdebug.h

32

dump_page(&folio->page, "VM_BUG_ON_FOLIO(" __stringify(cond)")");\

include/linux/mmdebug.h

70

#define VM_WARN_ON_FOLIO(cond, folio) ({ \

include/linux/mmdebug.h

74

dump_page(&folio->page, "VM_WARN_ON_FOLIO(" __stringify(cond)")");\

include/linux/mmdebug.h

79

#define VM_WARN_ON_ONCE_FOLIO(cond, folio) ({ \

include/linux/mmdebug.h

84

dump_page(&folio->page, "VM_WARN_ON_ONCE_FOLIO(" __stringify(cond)")");\

include/linux/mmzone.h

1286

static inline enum zone_type folio_zonenum(const struct folio *folio)

include/linux/mmzone.h

1288

return memdesc_zonenum(folio->flags);

include/linux/mmzone.h

1344

static inline bool folio_is_zone_device(const struct folio *folio)

include/linux/mmzone.h

1346

return memdesc_is_zone_device(folio->flags);

include/linux/mmzone.h

1354

static inline bool folio_is_zone_movable(const struct folio *folio)

include/linux/mmzone.h

1356

return folio_zonenum(folio) == ZONE_MOVABLE;

include/linux/mmzone.h

156

# define is_migrate_cma_folio(folio, pfn) \

include/linux/mmzone.h

157

(get_pfnblock_migratetype(&folio->page, pfn) == MIGRATE_CMA)

include/linux/mmzone.h

161

# define is_migrate_cma_folio(folio, pfn) false

include/linux/mmzone.h

192

#define folio_migratetype(folio) \

include/linux/mmzone.h

193

get_pageblock_migratetype(&folio->page)

include/linux/mpage.h

19

int mpage_read_folio(struct folio *folio, get_block_t get_block);

include/linux/mpage.h

22

int (*write_folio)(struct folio *folio,

include/linux/netfs.h

112

static inline struct netfs_folio *netfs_folio_info(struct folio *folio)

include/linux/netfs.h

114

return __netfs_folio_info(folio_get_private(folio));

include/linux/netfs.h

117

static inline struct netfs_group *netfs_folio_group(struct folio *folio)

include/linux/netfs.h

120

void *priv = folio_get_private(folio);

include/linux/netfs.h

122

finfo = netfs_folio_info(folio);

include/linux/netfs.h

257

const struct folio *no_unlock_folio; /* Don't unlock this folio after read */

include/linux/netfs.h

303

struct folio **foliop, void **_fsdata);

include/linux/netfs.h

36

static inline void folio_start_private_2(struct folio *folio)

include/linux/netfs.h

38

VM_BUG_ON_FOLIO(folio_test_private_2(folio), folio);

include/linux/netfs.h

39

folio_get(folio);

include/linux/netfs.h

40

folio_set_private_2(folio);

include/linux/netfs.h

419

int netfs_read_folio(struct file *, struct folio *);

include/linux/netfs.h

422

struct folio **, void **fsdata);

include/linux/netfs.h

425

bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio);

include/linux/netfs.h

428

void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length);

include/linux/netfs.h

429

bool netfs_release_folio(struct folio *folio, gfp_t gfp);

include/linux/nfs_fs.h

614

extern int nfs_flush_incompatible(struct file *file, struct folio *folio);

include/linux/nfs_fs.h

615

extern int nfs_update_folio(struct file *file, struct folio *folio,

include/linux/nfs_fs.h

624

extern int nfs_wb_folio(struct inode *inode, struct folio *folio);

include/linux/nfs_fs.h

625

extern int nfs_wb_folio_reclaim(struct inode *inode, struct folio *folio);

include/linux/nfs_fs.h

626

int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio);

include/linux/nfs_fs.h

643

int nfs_read_folio(struct file *, struct folio *);

include/linux/nfs_page.h

132

struct folio *folio,

include/linux/nfs_page.h

173

static inline struct folio *nfs_page_to_folio(const struct nfs_page *req)

include/linux/nfs_page.h

192

struct folio *folio = nfs_page_to_folio(req);

include/linux/nfs_page.h

194

if (folio == NULL)

include/linux/nfs_page.h

196

return folio_page(folio, pgbase >> PAGE_SHIFT);

include/linux/nfs_page.h

205

struct folio *folio = nfs_page_to_folio(req);

include/linux/nfs_page.h

207

if (folio == NULL)

include/linux/nfs_page.h

209

return folio->mapping->host;

include/linux/nfs_page.h

220

struct folio *folio = nfs_page_to_folio(req);

include/linux/nfs_page.h

222

if (folio == NULL)

include/linux/nfs_page.h

224

return folio_size(folio);

include/linux/nfs_page.h

48

struct folio *wb_folio;

include/linux/nfs_xdr.h

1604

struct folio *scratch;

include/linux/nfs_xdr.h

1816

int (*symlink) (struct inode *, struct dentry *, struct folio *,

include/linux/nfs_xdr.h

867

struct folio * acl_scratch;

include/linux/page-flags.h

1078

const struct folio *folio;

include/linux/page-flags.h

1082

folio = page_folio(page);

include/linux/page-flags.h

1083

return folio_test_hugetlb(folio) && PageHWPoison(&folio->page);

include/linux/page-flags.h

1086

static inline bool folio_contain_hwpoisoned_page(struct folio *folio)

include/linux/page-flags.h

1088

return folio_test_hwpoison(folio) ||

include/linux/page-flags.h

1089

(folio_test_large(folio) && folio_test_has_hwpoisoned(folio));

include/linux/page-flags.h

1220

static inline int folio_has_private(const struct folio *folio)

include/linux/page-flags.h

1222

return !!(folio->flags.f & PAGE_FLAGS_PRIVATE);

include/linux/page-flags.h

301

const struct page *: (const struct folio *)_compound_head(p), \

include/linux/page-flags.h

302

struct page *: (struct folio *)_compound_head(p)))

include/linux/page-flags.h

313

#define folio_page(folio, n) (&(folio)->page + (n))

include/linux/page-flags.h

340

static const unsigned long *const_folio_flags(const struct folio *folio,

include/linux/page-flags.h

343

const struct page *page = &folio->page;

include/linux/page-flags.h

350

static unsigned long *folio_flags(struct folio *folio, unsigned n)

include/linux/page-flags.h

352

struct page *page = &folio->page;

include/linux/page-flags.h

411

static __always_inline bool folio_test_##name(const struct folio *folio) \

include/linux/page-flags.h

412

{ return test_bit(PG_##name, const_folio_flags(folio, page)); }

include/linux/page-flags.h

415

static __always_inline void folio_set_##name(struct folio *folio) \

include/linux/page-flags.h

416

{ set_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

419

static __always_inline void folio_clear_##name(struct folio *folio) \

include/linux/page-flags.h

420

{ clear_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

423

static __always_inline void __folio_set_##name(struct folio *folio) \

include/linux/page-flags.h

424

{ __set_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

427

static __always_inline void __folio_clear_##name(struct folio *folio) \

include/linux/page-flags.h

428

{ __clear_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

431

static __always_inline bool folio_test_set_##name(struct folio *folio) \

include/linux/page-flags.h

432

{ return test_and_set_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

435

static __always_inline bool folio_test_clear_##name(struct folio *folio) \

include/linux/page-flags.h

436

{ return test_and_clear_bit(PG_##name, folio_flags(folio, page)); }

include/linux/page-flags.h

493

static inline bool folio_test_##name(const struct folio *folio) \

include/linux/page-flags.h

496

static inline void folio_set_##name(struct folio *folio) { }

include/linux/page-flags.h

498

static inline void folio_clear_##name(struct folio *folio) { }

include/linux/page-flags.h

500

static inline void __folio_set_##name(struct folio *folio) { }

include/linux/page-flags.h

502

static inline void __folio_clear_##name(struct folio *folio) { }

include/linux/page-flags.h

504

static inline bool folio_test_set_##name(struct folio *folio) \

include/linux/page-flags.h

507

static inline bool folio_test_clear_##name(struct folio *folio) \

include/linux/page-flags.h

625

static __always_inline bool folio_test_swapcache(const struct folio *folio)

include/linux/page-flags.h

627

return folio_test_swapbacked(folio) &&

include/linux/page-flags.h

628

test_bit(PG_swapcache, const_folio_flags(folio, 0));

include/linux/page-flags.h

716

static __always_inline bool folio_test_anon(const struct folio *folio)

include/linux/page-flags.h

718

return ((unsigned long)folio->mapping & FOLIO_MAPPING_ANON) != 0;

include/linux/page-flags.h

721

static __always_inline bool folio_test_lazyfree(const struct folio *folio)

include/linux/page-flags.h

723

return folio_test_anon(folio) && !folio_test_swapbacked(folio);

include/linux/page-flags.h

744

static __always_inline bool folio_test_ksm(const struct folio *folio)

include/linux/page-flags.h

746

return ((unsigned long)folio->mapping & FOLIO_MAPPING_FLAGS) ==

include/linux/page-flags.h

768

static inline bool folio_xor_flags_has_waiters(struct folio *folio,

include/linux/page-flags.h

771

return xor_unlock_is_negative_byte(mask, folio_flags(folio, 0));

include/linux/page-flags.h

784

static inline bool folio_test_uptodate(const struct folio *folio)

include/linux/page-flags.h

786

bool ret = test_bit(PG_uptodate, const_folio_flags(folio, 0));

include/linux/page-flags.h

806

static __always_inline void __folio_mark_uptodate(struct folio *folio)

include/linux/page-flags.h

809

__set_bit(PG_uptodate, folio_flags(folio, 0));

include/linux/page-flags.h

812

static __always_inline void folio_mark_uptodate(struct folio *folio)

include/linux/page-flags.h

820

set_bit(PG_uptodate, folio_flags(folio, 0));

include/linux/page-flags.h

825

__folio_mark_uptodate((struct folio *)page);

include/linux/page-flags.h

830

folio_mark_uptodate((struct folio *)page);

include/linux/page-flags.h

835

void __folio_start_writeback(struct folio *folio, bool keep_write);

include/linux/page-flags.h

838

#define folio_start_writeback(folio) \

include/linux/page-flags.h

839

__folio_start_writeback(folio, false)

include/linux/page-flags.h

841

static __always_inline bool folio_test_head(const struct folio *folio)

include/linux/page-flags.h

843

return test_bit(PG_head, const_folio_flags(folio, FOLIO_PF_ANY));

include/linux/page-flags.h

862

static inline bool folio_test_large(const struct folio *folio)

include/linux/page-flags.h

864

return folio_test_head(folio);

include/linux/page-flags.h

947

static __always_inline bool folio_test_##fname(const struct folio *folio) \

include/linux/page-flags.h

949

return data_race(folio->page.page_type >> 24) == PGTY_##lname; \

include/linux/page-flags.h

951

static __always_inline void __folio_set_##fname(struct folio *folio) \

include/linux/page-flags.h

953

if (folio_test_##fname(folio)) \

include/linux/page-flags.h

955

VM_BUG_ON_FOLIO(data_race(folio->page.page_type) != UINT_MAX, \

include/linux/page-flags.h

956

folio); \

include/linux/page-flags.h

957

folio->page.page_type = (unsigned int)PGTY_##lname << 24; \

include/linux/page-flags.h

959

static __always_inline void __folio_clear_##fname(struct folio *folio) \

include/linux/page-flags.h

961

if (folio->page.page_type == UINT_MAX) \

include/linux/page-flags.h

963

VM_BUG_ON_FOLIO(!folio_test_##fname(folio), folio); \

include/linux/page-flags.h

964

folio->page.page_type = UINT_MAX; \

include/linux/page_idle.h

14

static inline bool folio_test_young(const struct folio *folio)

include/linux/page_idle.h

16

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_idle.h

28

static inline void folio_set_young(struct folio *folio)

include/linux/page_idle.h

30

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_idle.h

39

static inline bool folio_test_clear_young(struct folio *folio)

include/linux/page_idle.h

41

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_idle.h

53

static inline bool folio_test_idle(const struct folio *folio)

include/linux/page_idle.h

55

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_idle.h

67

static inline void folio_set_idle(struct folio *folio)

include/linux/page_idle.h

69

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_idle.h

78

static inline void folio_clear_idle(struct folio *folio)

include/linux/page_idle.h

80

struct page_ext *page_ext = page_ext_get(&folio->page);

include/linux/page_owner.h

16

extern void __folio_copy_owner(struct folio *newfolio, struct folio *old);

include/linux/page_owner.h

17

extern void __folio_set_owner_migrate_reason(struct folio *folio, int reason);

include/linux/page_owner.h

41

static inline void folio_copy_owner(struct folio *newfolio, struct folio *old)

include/linux/page_owner.h

46

static inline void folio_set_owner_migrate_reason(struct folio *folio, int reason)

include/linux/page_owner.h

49

__folio_set_owner_migrate_reason(folio, reason);

include/linux/page_owner.h

68

static inline void folio_copy_owner(struct folio *newfolio, struct folio *folio)

include/linux/page_owner.h

71

static inline void folio_set_owner_migrate_reason(struct folio *folio, int reason)

include/linux/page_ref.h

105

static inline int folio_ref_count(const struct folio *folio)

include/linux/page_ref.h

107

return page_ref_count(&folio->page);

include/linux/page_ref.h

122

static inline void folio_set_count(struct folio *folio, int v)

include/linux/page_ref.h

124

set_page_count(&folio->page, v);

include/linux/page_ref.h

143

static inline void folio_ref_add(struct folio *folio, int nr)

include/linux/page_ref.h

145

page_ref_add(&folio->page, nr);

include/linux/page_ref.h

155

static inline void folio_ref_sub(struct folio *folio, int nr)

include/linux/page_ref.h

157

page_ref_sub(&folio->page, nr);

include/linux/page_ref.h

160

static inline int folio_ref_sub_return(struct folio *folio, int nr)

include/linux/page_ref.h

162

int ret = atomic_sub_return(nr, &folio->_refcount);

include/linux/page_ref.h

165

__page_ref_mod_and_return(&folio->page, -nr, ret);

include/linux/page_ref.h

176

static inline void folio_ref_inc(struct folio *folio)

include/linux/page_ref.h

178

page_ref_inc(&folio->page);

include/linux/page_ref.h

188

static inline void folio_ref_dec(struct folio *folio)

include/linux/page_ref.h

190

page_ref_dec(&folio->page);

include/linux/page_ref.h

202

static inline int folio_ref_sub_and_test(struct folio *folio, int nr)

include/linux/page_ref.h

204

return page_ref_sub_and_test(&folio->page, nr);

include/linux/page_ref.h

216

static inline int folio_ref_inc_return(struct folio *folio)

include/linux/page_ref.h

218

return page_ref_inc_return(&folio->page);

include/linux/page_ref.h

230

static inline int folio_ref_dec_and_test(struct folio *folio)

include/linux/page_ref.h

232

return page_ref_dec_and_test(&folio->page);

include/linux/page_ref.h

244

static inline int folio_ref_dec_return(struct folio *folio)

include/linux/page_ref.h

246

return page_ref_dec_return(&folio->page);

include/linux/page_ref.h

258

static inline bool folio_ref_add_unless_zero(struct folio *folio, int nr)

include/linux/page_ref.h

260

return page_ref_add_unless_zero(&folio->page, nr);

include/linux/page_ref.h

274

static inline bool folio_try_get(struct folio *folio)

include/linux/page_ref.h

276

return folio_ref_add_unless_zero(folio, 1);

include/linux/page_ref.h

279

static inline bool folio_ref_try_add(struct folio *folio, int count)

include/linux/page_ref.h

281

return folio_ref_add_unless_zero(folio, count);

include/linux/page_ref.h

293

static inline int folio_ref_freeze(struct folio *folio, int count)

include/linux/page_ref.h

295

return page_ref_freeze(&folio->page, count);

include/linux/page_ref.h

308

static inline void folio_ref_unfreeze(struct folio *folio, int count)

include/linux/page_ref.h

310

page_ref_unfreeze(&folio->page, count);

include/linux/pagemap.h

1012

static inline struct folio *read_mapping_folio(struct address_space *mapping,

include/linux/pagemap.h

1033

static inline pgoff_t page_pgoff(const struct folio *folio,

include/linux/pagemap.h

1036

return folio->index + folio_page_idx(folio, page);

include/linux/pagemap.h

1043

static inline loff_t folio_pos(const struct folio *folio)

include/linux/pagemap.h

1045

return ((loff_t)folio->index) * PAGE_SIZE;

include/linux/pagemap.h

1053

struct folio *folio = page_folio(page);

include/linux/pagemap.h

1055

return folio_pos(folio) + folio_page_idx(folio, page) * PAGE_SIZE;

include/linux/pagemap.h

1061

static inline pgoff_t folio_pgoff(const struct folio *folio)

include/linux/pagemap.h

1063

return folio->index;

include/linux/pagemap.h

1076

struct folio *folio;

include/linux/pagemap.h

1082

struct folio *folio;

include/linux/pagemap.h

1090

if (wait_page->folio != key->folio)

include/linux/pagemap.h

1100

void __folio_lock(struct folio *folio);

include/linux/pagemap.h

1101

int __folio_lock_killable(struct folio *folio);

include/linux/pagemap.h

1102

vm_fault_t __folio_lock_or_retry(struct folio *folio, struct vm_fault *vmf);

include/linux/pagemap.h

1104

void folio_unlock(struct folio *folio);

include/linux/pagemap.h

1118

static inline bool folio_trylock(struct folio *folio)

include/linux/pagemap.h

1120

return likely(!test_and_set_bit_lock(PG_locked, folio_flags(folio, 0)));

include/linux/pagemap.h

1153

static inline void folio_lock(struct folio *folio)

include/linux/pagemap.h

1156

if (!folio_trylock(folio))

include/linux/pagemap.h

1157

__folio_lock(folio);

include/linux/pagemap.h

1173

struct folio *folio;

include/linux/pagemap.h

1176

folio = page_folio(page);

include/linux/pagemap.h

1177

if (!folio_trylock(folio))

include/linux/pagemap.h

1178

__folio_lock(folio);

include/linux/pagemap.h

1191

static inline int folio_lock_killable(struct folio *folio)

include/linux/pagemap.h

1194

if (!folio_trylock(folio))

include/linux/pagemap.h

1195

return __folio_lock_killable(folio);

include/linux/pagemap.h

1206

static inline vm_fault_t folio_lock_or_retry(struct folio *folio,

include/linux/pagemap.h

1210

if (!folio_trylock(folio))

include/linux/pagemap.h

1211

return __folio_lock_or_retry(folio, vmf);

include/linux/pagemap.h

1219

void folio_wait_bit(struct folio *folio, int bit_nr);

include/linux/pagemap.h

1220

int folio_wait_bit_killable(struct folio *folio, int bit_nr);

include/linux/pagemap.h

1229

static inline void folio_wait_locked(struct folio *folio)

include/linux/pagemap.h

1231

if (folio_test_locked(folio))

include/linux/pagemap.h

1232

folio_wait_bit(folio, PG_locked);

include/linux/pagemap.h

1235

static inline int folio_wait_locked_killable(struct folio *folio)

include/linux/pagemap.h

1237

if (!folio_test_locked(folio))

include/linux/pagemap.h

1239

return folio_wait_bit_killable(folio, PG_locked);

include/linux/pagemap.h

1242

void folio_end_read(struct folio *folio, bool success);

include/linux/pagemap.h

1244

void folio_wait_writeback(struct folio *folio);

include/linux/pagemap.h

1245

int folio_wait_writeback_killable(struct folio *folio);

include/linux/pagemap.h

1247

void folio_end_writeback(struct folio *folio);

include/linux/pagemap.h

1248

void folio_end_writeback_no_dropbehind(struct folio *folio);

include/linux/pagemap.h

1249

void folio_end_dropbehind(struct folio *folio);

include/linux/pagemap.h

1250

void folio_wait_stable(struct folio *folio);

include/linux/pagemap.h

1251

void __folio_mark_dirty(struct folio *folio, struct address_space *, int warn);

include/linux/pagemap.h

1252

void folio_account_cleaned(struct folio *folio, struct bdi_writeback *wb);

include/linux/pagemap.h

1253

void __folio_cancel_dirty(struct folio *folio);

include/linux/pagemap.h

1254

static inline void folio_cancel_dirty(struct folio *folio)

include/linux/pagemap.h

1257

if (folio_test_dirty(folio))

include/linux/pagemap.h

1258

__folio_cancel_dirty(folio);

include/linux/pagemap.h

1260

bool folio_clear_dirty_for_io(struct folio *folio);

include/linux/pagemap.h

1262

void folio_invalidate(struct folio *folio, size_t offset, size_t length);

include/linux/pagemap.h

1263

bool noop_dirty_folio(struct address_space *mapping, struct folio *folio);

include/linux/pagemap.h

1266

int filemap_migrate_folio(struct address_space *mapping, struct folio *dst,

include/linux/pagemap.h

1267

struct folio *src, enum migrate_mode mode);

include/linux/pagemap.h

1271

void folio_end_private_2(struct folio *folio);

include/linux/pagemap.h

1272

void folio_wait_private_2(struct folio *folio);

include/linux/pagemap.h

1273

int folio_wait_private_2_killable(struct folio *folio);

include/linux/pagemap.h

1285

int filemap_add_folio(struct address_space *mapping, struct folio *folio,

include/linux/pagemap.h

1287

void filemap_remove_folio(struct folio *folio);

include/linux/pagemap.h

1288

void __filemap_remove_folio(struct folio *folio, void *shadow);

include/linux/pagemap.h

1289

void replace_page_cache_folio(struct folio *old, struct folio *new);

include/linux/pagemap.h

1292

bool filemap_release_folio(struct folio *folio, gfp_t gfp);

include/linux/pagemap.h

1297

int __filemap_add_folio(struct address_space *mapping, struct folio *folio,

include/linux/pagemap.h

1371

void page_cache_async_ra(struct readahead_control *, struct folio *,

include/linux/pagemap.h

1414

struct folio *folio, unsigned long req_count)

include/linux/pagemap.h

1416

DEFINE_READAHEAD(ractl, file, ra, mapping, folio->index);

include/linux/pagemap.h

1417

page_cache_async_ra(&ractl, folio, req_count);

include/linux/pagemap.h

1420

static inline struct folio *__readahead_folio(struct readahead_control *ractl)

include/linux/pagemap.h

1422

struct folio *folio;

include/linux/pagemap.h

1433

folio = xa_load(&ractl->mapping->i_pages, ractl->_index);

include/linux/pagemap.h

1434

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

include/linux/pagemap.h

1435

ractl->_batch_count = folio_nr_pages(folio);

include/linux/pagemap.h

1437

return folio;

include/linux/pagemap.h

1448

static inline struct folio *readahead_folio(struct readahead_control *ractl)

include/linux/pagemap.h

1450

struct folio *folio = __readahead_folio(ractl);

include/linux/pagemap.h

1452

if (folio)

include/linux/pagemap.h

1453

folio_put(folio);

include/linux/pagemap.h

1454

return folio;

include/linux/pagemap.h

1462

struct folio *folio;

include/linux/pagemap.h

1471

xas_for_each(&xas, folio, rac->_index + rac->_nr_pages - 1) {

include/linux/pagemap.h

1472

if (xas_retry(&xas, folio))

include/linux/pagemap.h

1474

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

include/linux/pagemap.h

1475

array[i++] = folio_page(folio, 0);

include/linux/pagemap.h

1476

rac->_batch_count += folio_nr_pages(folio);

include/linux/pagemap.h

1544

static inline ssize_t folio_mkwrite_check_truncate(const struct folio *folio,

include/linux/pagemap.h

1549

size_t offset = offset_in_folio(folio, size);

include/linux/pagemap.h

1551

if (!folio->mapping)

include/linux/pagemap.h

1555

if (folio_next_index(folio) - 1 < index)

include/linux/pagemap.h

1556

return folio_size(folio);

include/linux/pagemap.h

1558

if (folio->index > index || !offset)

include/linux/pagemap.h

1577

const struct folio *folio)

include/linux/pagemap.h

1579

return folio_size(folio) >> inode->i_blkbits;

include/linux/pagemap.h

549

struct address_space *folio_mapping(const struct folio *folio);

include/linux/pagemap.h

563

static inline struct address_space *folio_flush_mapping(struct folio *folio)

include/linux/pagemap.h

565

if (unlikely(folio_test_swapcache(folio)))

include/linux/pagemap.h

568

return folio_mapping(folio);

include/linux/pagemap.h

580

static inline struct inode *folio_inode(struct folio *folio)

include/linux/pagemap.h

582

return folio->mapping->host;

include/linux/pagemap.h

593

static inline void folio_attach_private(struct folio *folio, void *data)

include/linux/pagemap.h

595

folio_get(folio);

include/linux/pagemap.h

596

folio->private = data;

include/linux/pagemap.h

597

folio_set_private(folio);

include/linux/pagemap.h

611

static inline void *folio_change_private(struct folio *folio, void *data)

include/linux/pagemap.h

613

void *old = folio_get_private(folio);

include/linux/pagemap.h

615

folio->private = data;

include/linux/pagemap.h

628

static inline void *folio_detach_private(struct folio *folio)

include/linux/pagemap.h

630

void *data = folio_get_private(folio);

include/linux/pagemap.h

632

if (!folio_test_private(folio))

include/linux/pagemap.h

634

folio_clear_private(folio);

include/linux/pagemap.h

635

folio->private = NULL;

include/linux/pagemap.h

636

folio_put(folio);

include/linux/pagemap.h

652

struct folio *filemap_alloc_folio_noprof(gfp_t gfp, unsigned int order,

include/linux/pagemap.h

655

static inline struct folio *filemap_alloc_folio_noprof(gfp_t gfp, unsigned int order,

include/linux/pagemap.h

675

typedef int filler_t(struct file *, struct folio *);

include/linux/pagemap.h

753

struct folio *__filemap_get_folio_mpol(struct address_space *mapping,

include/linux/pagemap.h

758

static inline struct folio *__filemap_get_folio(struct address_space *mapping,

include/linux/pagemap.h

777

static inline struct folio *write_begin_get_folio(const struct kiocb *iocb,

include/linux/pagemap.h

802

static inline struct folio *filemap_get_folio(struct address_space *mapping,

include/linux/pagemap.h

820

static inline struct folio *filemap_lock_folio(struct address_space *mapping,

include/linux/pagemap.h

838

static inline struct folio *filemap_grab_folio(struct address_space *mapping,

include/linux/pagemap.h

942

static inline pgoff_t folio_next_index(const struct folio *folio)

include/linux/pagemap.h

944

return folio->index + folio_nr_pages(folio);

include/linux/pagemap.h

953

static inline loff_t folio_next_pos(const struct folio *folio)

include/linux/pagemap.h

955

return (loff_t)folio_next_index(folio) << PAGE_SHIFT;

include/linux/pagemap.h

968

static inline struct page *folio_file_page(struct folio *folio, pgoff_t index)

include/linux/pagemap.h

970

return folio_page(folio, index & (folio_nr_pages(folio) - 1));

include/linux/pagemap.h

982

static inline bool folio_contains(const struct folio *folio, pgoff_t index)

include/linux/pagemap.h

984

VM_WARN_ON_ONCE_FOLIO(folio_test_swapcache(folio), folio);

include/linux/pagemap.h

985

return index - folio->index < folio_nr_pages(folio);

include/linux/pagemap.h

997

struct folio *read_cache_folio(struct address_space *, pgoff_t index,

include/linux/pagemap.h

999

struct folio *mapping_read_folio_gfp(struct address_space *, pgoff_t index,

include/linux/pagewalk.h

190

struct folio *folio_walk_start(struct folio_walk *fw,

include/linux/pgalloc_tag.h

199

void pgalloc_tag_split(struct folio *folio, int old_order, int new_order);

include/linux/pgalloc_tag.h

200

void pgalloc_tag_swap(struct folio *new, struct folio *old);

include/linux/pgalloc_tag.h

208

static inline void pgalloc_tag_split(struct folio *folio, int old_order, int new_order) {}

include/linux/pgalloc_tag.h

209

static inline void pgalloc_tag_swap(struct folio *new, struct folio *old) {}

include/linux/pgtable.h

1470

static inline int arch_prepare_to_swap(struct folio *folio)

include/linux/pgtable.h

1487

static inline void arch_swap_restore(swp_entry_t entry, struct folio *folio)

include/linux/rmap.h

112

static __always_inline void folio_lock_large_mapcount(struct folio *folio)

include/linux/rmap.h

114

bit_spin_lock(FOLIO_MM_IDS_LOCK_BITNUM, &folio->_mm_ids);

include/linux/rmap.h

117

static __always_inline void folio_unlock_large_mapcount(struct folio *folio)

include/linux/rmap.h

119

__bit_spin_unlock(FOLIO_MM_IDS_LOCK_BITNUM, &folio->_mm_ids);

include/linux/rmap.h

122

static inline unsigned int folio_mm_id(const struct folio *folio, int idx)

include/linux/rmap.h

125

return folio->_mm_id[idx] & MM_ID_MASK;

include/linux/rmap.h

128

static inline void folio_set_mm_id(struct folio *folio, int idx, mm_id_t id)

include/linux/rmap.h

131

folio->_mm_id[idx] &= ~MM_ID_MASK;

include/linux/rmap.h

132

folio->_mm_id[idx] |= id;

include/linux/rmap.h

135

static inline void __folio_large_mapcount_sanity_checks(const struct folio *folio,

include/linux/rmap.h

138

VM_WARN_ON_ONCE(!folio_test_large(folio) || folio_test_hugetlb(folio));

include/linux/rmap.h

148

VM_WARN_ON_ONCE(diff > folio_large_nr_pages(folio));

include/linux/rmap.h

149

VM_WARN_ON_ONCE(folio_large_nr_pages(folio) - 1 > MM_ID_MAPCOUNT_MAX);

include/linux/rmap.h

151

VM_WARN_ON_ONCE(folio_mm_id(folio, 0) == MM_ID_DUMMY &&

include/linux/rmap.h

152

folio->_mm_id_mapcount[0] != -1);

include/linux/rmap.h

153

VM_WARN_ON_ONCE(folio_mm_id(folio, 0) != MM_ID_DUMMY &&

include/linux/rmap.h

154

folio->_mm_id_mapcount[0] < 0);

include/linux/rmap.h

155

VM_WARN_ON_ONCE(folio_mm_id(folio, 1) == MM_ID_DUMMY &&

include/linux/rmap.h

156

folio->_mm_id_mapcount[1] != -1);

include/linux/rmap.h

157

VM_WARN_ON_ONCE(folio_mm_id(folio, 1) != MM_ID_DUMMY &&

include/linux/rmap.h

158

folio->_mm_id_mapcount[1] < 0);

include/linux/rmap.h

159

VM_WARN_ON_ONCE(!folio_mapped(folio) &&

include/linux/rmap.h

160

test_bit(FOLIO_MM_IDS_SHARED_BITNUM, &folio->_mm_ids));

include/linux/rmap.h

163

static __always_inline void folio_set_large_mapcount(struct folio *folio,

include/linux/rmap.h

166

__folio_large_mapcount_sanity_checks(folio, mapcount, vma->vm_mm->mm_id);

include/linux/rmap.h

168

VM_WARN_ON_ONCE(folio_mm_id(folio, 0) != MM_ID_DUMMY);

include/linux/rmap.h

169

VM_WARN_ON_ONCE(folio_mm_id(folio, 1) != MM_ID_DUMMY);

include/linux/rmap.h

172

atomic_set(&folio->_large_mapcount, mapcount - 1);

include/linux/rmap.h

173

folio->_mm_id_mapcount[0] = mapcount - 1;

include/linux/rmap.h

174

folio_set_mm_id(folio, 0, vma->vm_mm->mm_id);

include/linux/rmap.h

177

static __always_inline int folio_add_return_large_mapcount(struct folio *folio,

include/linux/rmap.h

183

folio_lock_large_mapcount(folio);

include/linux/rmap.h

184

__folio_large_mapcount_sanity_checks(folio, diff, mm_id);

include/linux/rmap.h

186

new_mapcount_val = atomic_read(&folio->_large_mapcount) + diff;

include/linux/rmap.h

187

atomic_set(&folio->_large_mapcount, new_mapcount_val);

include/linux/rmap.h

196

if (folio_mm_id(folio, 0) == mm_id) {

include/linux/rmap.h

197

folio->_mm_id_mapcount[0] += diff;

include/linux/rmap.h

198

if (!IS_ENABLED(CONFIG_64BIT) && unlikely(folio->_mm_id_mapcount[0] < 0)) {

include/linux/rmap.h

199

folio->_mm_id_mapcount[0] = -1;

include/linux/rmap.h

200

folio_set_mm_id(folio, 0, MM_ID_DUMMY);

include/linux/rmap.h

201

folio->_mm_ids |= FOLIO_MM_IDS_SHARED_BIT;

include/linux/rmap.h

203

} else if (folio_mm_id(folio, 1) == mm_id) {

include/linux/rmap.h

204

folio->_mm_id_mapcount[1] += diff;

include/linux/rmap.h

205

if (!IS_ENABLED(CONFIG_64BIT) && unlikely(folio->_mm_id_mapcount[1] < 0)) {

include/linux/rmap.h

206

folio->_mm_id_mapcount[1] = -1;

include/linux/rmap.h

207

folio_set_mm_id(folio, 1, MM_ID_DUMMY);

include/linux/rmap.h

208

folio->_mm_ids |= FOLIO_MM_IDS_SHARED_BIT;

include/linux/rmap.h

210

} else if (folio_mm_id(folio, 0) == MM_ID_DUMMY) {

include/linux/rmap.h

211

folio_set_mm_id(folio, 0, mm_id);

include/linux/rmap.h

212

folio->_mm_id_mapcount[0] = diff - 1;

include/linux/rmap.h

215

folio->_mm_ids |= FOLIO_MM_IDS_SHARED_BIT;

include/linux/rmap.h

216

} else if (folio_mm_id(folio, 1) == MM_ID_DUMMY) {

include/linux/rmap.h

217

folio_set_mm_id(folio, 1, mm_id);

include/linux/rmap.h

218

folio->_mm_id_mapcount[1] = diff - 1;

include/linux/rmap.h

220

folio->_mm_ids |= FOLIO_MM_IDS_SHARED_BIT;

include/linux/rmap.h

222

folio_unlock_large_mapcount(folio);

include/linux/rmap.h

227

static __always_inline int folio_sub_return_large_mapcount(struct folio *folio,

include/linux/rmap.h

233

folio_lock_large_mapcount(folio);

include/linux/rmap.h

234

__folio_large_mapcount_sanity_checks(folio, diff, mm_id);

include/linux/rmap.h

236

new_mapcount_val = atomic_read(&folio->_large_mapcount) - diff;

include/linux/rmap.h

237

atomic_set(&folio->_large_mapcount, new_mapcount_val);

include/linux/rmap.h

245

if (folio_mm_id(folio, 0) == mm_id) {

include/linux/rmap.h

246

folio->_mm_id_mapcount[0] -= diff;

include/linux/rmap.h

247

if (folio->_mm_id_mapcount[0] >= 0)

include/linux/rmap.h

249

folio->_mm_id_mapcount[0] = -1;

include/linux/rmap.h

250

folio_set_mm_id(folio, 0, MM_ID_DUMMY);

include/linux/rmap.h

251

} else if (folio_mm_id(folio, 1) == mm_id) {

include/linux/rmap.h

252

folio->_mm_id_mapcount[1] -= diff;

include/linux/rmap.h

253

if (folio->_mm_id_mapcount[1] >= 0)

include/linux/rmap.h

255

folio->_mm_id_mapcount[1] = -1;

include/linux/rmap.h

256

folio_set_mm_id(folio, 1, MM_ID_DUMMY);

include/linux/rmap.h

265

if (folio->_mm_id_mapcount[0] == new_mapcount_val ||

include/linux/rmap.h

266

folio->_mm_id_mapcount[1] == new_mapcount_val)

include/linux/rmap.h

267

folio->_mm_ids &= ~FOLIO_MM_IDS_SHARED_BIT;

include/linux/rmap.h

269

folio_unlock_large_mapcount(folio);

include/linux/rmap.h

278

static inline void folio_set_large_mapcount(struct folio *folio, int mapcount,

include/linux/rmap.h

282

atomic_set(&folio->_large_mapcount, mapcount - 1);

include/linux/rmap.h

285

static inline void folio_add_large_mapcount(struct folio *folio,

include/linux/rmap.h

288

atomic_add(diff, &folio->_large_mapcount);

include/linux/rmap.h

291

static inline int folio_add_return_large_mapcount(struct folio *folio,

include/linux/rmap.h

297

static inline void folio_sub_large_mapcount(struct folio *folio,

include/linux/rmap.h

300

atomic_sub(diff, &folio->_large_mapcount);

include/linux/rmap.h

303

static inline int folio_sub_return_large_mapcount(struct folio *folio,

include/linux/rmap.h

310

#define folio_inc_large_mapcount(folio, vma) \

include/linux/rmap.h

311

folio_add_large_mapcount(folio, 1, vma)

include/linux/rmap.h

312

#define folio_inc_return_large_mapcount(folio, vma) \

include/linux/rmap.h

313

folio_add_return_large_mapcount(folio, 1, vma)

include/linux/rmap.h

314

#define folio_dec_large_mapcount(folio, vma) \

include/linux/rmap.h

315

folio_sub_large_mapcount(folio, 1, vma)

include/linux/rmap.h

316

#define folio_dec_return_large_mapcount(folio, vma) \

include/linux/rmap.h

317

folio_sub_return_large_mapcount(folio, 1, vma)

include/linux/rmap.h

331

static __always_inline void __folio_rmap_sanity_checks(const struct folio *folio,

include/linux/rmap.h

335

VM_WARN_ON_FOLIO(folio_test_hugetlb(folio), folio);

include/linux/rmap.h

338

VM_WARN_ON_FOLIO(is_zero_folio(folio), folio);

include/linux/rmap.h

350

VM_WARN_ON_FOLIO(page_folio(page) != folio, folio);

include/linux/rmap.h

351

VM_WARN_ON_FOLIO(page_folio(page + nr_pages - 1) != folio, folio);

include/linux/rmap.h

362

VM_WARN_ON_FOLIO(folio_nr_pages(folio) != HPAGE_PMD_NR, folio);

include/linux/rmap.h

363

VM_WARN_ON_FOLIO(nr_pages != HPAGE_PMD_NR, folio);

include/linux/rmap.h

370

VM_WARN_ON_FOLIO(folio_nr_pages(folio) != HPAGE_PUD_NR, folio);

include/linux/rmap.h

371

VM_WARN_ON_FOLIO(nr_pages != HPAGE_PUD_NR, folio);

include/linux/rmap.h

391

if (folio_test_anon(folio) && !folio_test_ksm(folio)) {

include/linux/rmap.h

392

unsigned long mapping = (unsigned long)folio->mapping;

include/linux/rmap.h

396

VM_WARN_ON_FOLIO(atomic_read(&anon_vma->refcount) == 0, folio);

include/linux/rmap.h

403

void folio_move_anon_rmap(struct folio *, struct vm_area_struct *);

include/linux/rmap.h

404

void folio_add_anon_rmap_ptes(struct folio *, struct page *, int nr_pages,

include/linux/rmap.h

406

#define folio_add_anon_rmap_pte(folio, page, vma, address, flags) \

include/linux/rmap.h

407

folio_add_anon_rmap_ptes(folio, page, 1, vma, address, flags)

include/linux/rmap.h

408

void folio_add_anon_rmap_pmd(struct folio *, struct page *,

include/linux/rmap.h

410

void folio_add_new_anon_rmap(struct folio *, struct vm_area_struct *,

include/linux/rmap.h

412

void folio_add_file_rmap_ptes(struct folio *, struct page *, int nr_pages,

include/linux/rmap.h

414

#define folio_add_file_rmap_pte(folio, page, vma) \

include/linux/rmap.h

415

folio_add_file_rmap_ptes(folio, page, 1, vma)

include/linux/rmap.h

416

void folio_add_file_rmap_pmd(struct folio *, struct page *,

include/linux/rmap.h

418

void folio_add_file_rmap_pud(struct folio *, struct page *,

include/linux/rmap.h

420

void folio_remove_rmap_ptes(struct folio *, struct page *, int nr_pages,

include/linux/rmap.h

422

#define folio_remove_rmap_pte(folio, page, vma) \

include/linux/rmap.h

423

folio_remove_rmap_ptes(folio, page, 1, vma)

include/linux/rmap.h

424

void folio_remove_rmap_pmd(struct folio *, struct page *,

include/linux/rmap.h

426

void folio_remove_rmap_pud(struct folio *, struct page *,

include/linux/rmap.h

429

void hugetlb_add_anon_rmap(struct folio *, struct vm_area_struct *,

include/linux/rmap.h

431

void hugetlb_add_new_anon_rmap(struct folio *, struct vm_area_struct *,

include/linux/rmap.h

435

static inline int hugetlb_try_dup_anon_rmap(struct folio *folio,

include/linux/rmap.h

438

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/rmap.h

439

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

include/linux/rmap.h

441

if (PageAnonExclusive(&folio->page)) {

include/linux/rmap.h

442

if (unlikely(folio_needs_cow_for_dma(vma, folio)))

include/linux/rmap.h

444

ClearPageAnonExclusive(&folio->page);

include/linux/rmap.h

446

atomic_inc(&folio->_entire_mapcount);

include/linux/rmap.h

447

atomic_inc(&folio->_large_mapcount);

include/linux/rmap.h

452

static inline int hugetlb_try_share_anon_rmap(struct folio *folio)

include/linux/rmap.h

454

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/rmap.h

455

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

include/linux/rmap.h

456

VM_WARN_ON_FOLIO(!PageAnonExclusive(&folio->page), folio);

include/linux/rmap.h

462

if (unlikely(folio_maybe_dma_pinned(folio)))

include/linux/rmap.h

464

ClearPageAnonExclusive(&folio->page);

include/linux/rmap.h

475

static inline void hugetlb_add_file_rmap(struct folio *folio)

include/linux/rmap.h

477

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/rmap.h

478

VM_WARN_ON_FOLIO(folio_test_anon(folio), folio);

include/linux/rmap.h

480

atomic_inc(&folio->_entire_mapcount);

include/linux/rmap.h

481

atomic_inc(&folio->_large_mapcount);

include/linux/rmap.h

484

static inline void hugetlb_remove_rmap(struct folio *folio)

include/linux/rmap.h

486

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

include/linux/rmap.h

488

atomic_dec(&folio->_entire_mapcount);

include/linux/rmap.h

489

atomic_dec(&folio->_large_mapcount);

include/linux/rmap.h

492

static __always_inline void __folio_dup_file_rmap(struct folio *folio,

include/linux/rmap.h

498

__folio_rmap_sanity_checks(folio, page, nr_pages, level);

include/linux/rmap.h

502

if (!folio_test_large(folio)) {

include/linux/rmap.h

503

atomic_inc(&folio->_mapcount);

include/linux/rmap.h

512

folio_add_large_mapcount(folio, orig_nr_pages, dst_vma);

include/linux/rmap.h

516

atomic_inc(&folio->_entire_mapcount);

include/linux/rmap.h

517

folio_inc_large_mapcount(folio, dst_vma);

include/linux/rmap.h

535

static inline void folio_dup_file_rmap_ptes(struct folio *folio,

include/linux/rmap.h

538

__folio_dup_file_rmap(folio, page, nr_pages, dst_vma, PGTABLE_LEVEL_PTE);

include/linux/rmap.h

541

static __always_inline void folio_dup_file_rmap_pte(struct folio *folio,

include/linux/rmap.h

544

__folio_dup_file_rmap(folio, page, 1, dst_vma, PGTABLE_LEVEL_PTE);

include/linux/rmap.h

557

static inline void folio_dup_file_rmap_pmd(struct folio *folio,

include/linux/rmap.h

561

__folio_dup_file_rmap(folio, page, HPAGE_PMD_NR, dst_vma, PGTABLE_LEVEL_PTE);

include/linux/rmap.h

567

static __always_inline int __folio_try_dup_anon_rmap(struct folio *folio,

include/linux/rmap.h

575

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

include/linux/rmap.h

576

__folio_rmap_sanity_checks(folio, page, nr_pages, level);

include/linux/rmap.h

585

maybe_pinned = likely(!folio_is_device_private(folio)) &&

include/linux/rmap.h

586

unlikely(folio_needs_cow_for_dma(src_vma, folio));

include/linux/rmap.h

601

if (!folio_test_large(folio)) {

include/linux/rmap.h

604

atomic_inc(&folio->_mapcount);

include/linux/rmap.h

614

folio_add_large_mapcount(folio, orig_nr_pages, dst_vma);

include/linux/rmap.h

623

atomic_inc(&folio->_entire_mapcount);

include/linux/rmap.h

624

folio_inc_large_mapcount(folio, dst_vma);

include/linux/rmap.h

656

static inline int folio_try_dup_anon_rmap_ptes(struct folio *folio,

include/linux/rmap.h

660

return __folio_try_dup_anon_rmap(folio, page, nr_pages, dst_vma,

include/linux/rmap.h

664

static __always_inline int folio_try_dup_anon_rmap_pte(struct folio *folio,

include/linux/rmap.h

668

return __folio_try_dup_anon_rmap(folio, page, 1, dst_vma, src_vma,

include/linux/rmap.h

695

static inline int folio_try_dup_anon_rmap_pmd(struct folio *folio,

include/linux/rmap.h

700

return __folio_try_dup_anon_rmap(folio, page, HPAGE_PMD_NR, dst_vma,

include/linux/rmap.h

708

static __always_inline int __folio_try_share_anon_rmap(struct folio *folio,

include/linux/rmap.h

711

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

include/linux/rmap.h

712

VM_WARN_ON_FOLIO(!PageAnonExclusive(page), folio);

include/linux/rmap.h

713

__folio_rmap_sanity_checks(folio, page, nr_pages, level);

include/linux/rmap.h

716

if (unlikely(folio_is_device_private(folio))) {

include/linux/rmap.h

767

if (unlikely(folio_maybe_dma_pinned(folio)))

include/linux/rmap.h

801

static inline int folio_try_share_anon_rmap_pte(struct folio *folio,

include/linux/rmap.h

804

return __folio_try_share_anon_rmap(folio, page, 1, PGTABLE_LEVEL_PTE);

include/linux/rmap.h

830

static inline int folio_try_share_anon_rmap_pmd(struct folio *folio,

include/linux/rmap.h

834

return __folio_try_share_anon_rmap(folio, page, HPAGE_PMD_NR,

include/linux/rmap.h

845

int folio_referenced(struct folio *, int is_locked,

include/linux/rmap.h

848

void try_to_migrate(struct folio *folio, enum ttu_flags flags);

include/linux/rmap.h

849

void try_to_unmap(struct folio *, enum ttu_flags flags);

include/linux/rmap.h

852

void *owner, struct folio **foliop);

include/linux/rmap.h

920

unsigned long page_address_in_vma(const struct folio *folio,

include/linux/rmap.h

929

int folio_mkclean(struct folio *);

include/linux/rmap.h

937

void remove_migration_ptes(struct folio *src, struct folio *dst,

include/linux/rmap.h

959

bool (*rmap_one)(struct folio *folio, struct vm_area_struct *vma,

include/linux/rmap.h

961

int (*done)(struct folio *folio);

include/linux/rmap.h

962

struct anon_vma *(*anon_lock)(const struct folio *folio,

include/linux/rmap.h

967

void rmap_walk(struct folio *folio, struct rmap_walk_control *rwc);

include/linux/rmap.h

968

void rmap_walk_locked(struct folio *folio, struct rmap_walk_control *rwc);

include/linux/rmap.h

969

struct anon_vma *folio_lock_anon_vma_read(const struct folio *folio,

include/linux/rmap.h

977

static inline int folio_referenced(struct folio *folio, int is_locked,

include/linux/rmap.h

985

static inline void try_to_unmap(struct folio *folio, enum ttu_flags flags)

include/linux/rmap.h

989

static inline int folio_mkclean(struct folio *folio)

include/linux/rolling_buffer.h

51

ssize_t rolling_buffer_append(struct rolling_buffer *roll, struct folio *folio,

include/linux/scatterlist.h

181

static inline void sg_set_folio(struct scatterlist *sg, struct folio *folio,

include/linux/scatterlist.h

186

sg_assign_page(sg, &folio->page);

include/linux/sched/numa_balancing.h

33

bool should_numa_migrate_memory(struct task_struct *p, struct folio *folio,

include/linux/sched/numa_balancing.h

51

struct folio *folio, int src_nid, int dst_cpu)

include/linux/shmem_fs.h

126

int shmem_writeout(struct folio *folio, struct swap_iocb **plug,

include/linux/shmem_fs.h

176

struct folio **foliop, enum sgp_type sgp);

include/linux/shmem_fs.h

177

struct folio *shmem_read_folio_gfp(struct address_space *mapping,

include/linux/shmem_fs.h

180

static inline struct folio *shmem_read_folio(struct address_space *mapping,

include/linux/sunrpc/svc.h

217

struct folio *rq_scratch_folio;

include/linux/sunrpc/xdr.h

312

xdr_set_scratch_folio(struct xdr_stream *xdr, struct folio *folio)

include/linux/sunrpc/xdr.h

314

xdr_set_scratch_buffer(xdr, folio_address(folio), folio_size(folio));

include/linux/swap.h

289

struct folio *folio = page_folio(page);

include/linux/swap.h

290

swp_entry_t entry = folio->swap;

include/linux/swap.h

292

entry.val += folio_page_idx(folio, page);

include/linux/swap.h

300

void *workingset_eviction(struct folio *folio, struct mem_cgroup *target_memcg);

include/linux/swap.h

301

void workingset_refault(struct folio *folio, void *shadow);

include/linux/swap.h

302

void workingset_activation(struct folio *folio);

include/linux/swap.h

314

void lru_note_cost_refault(struct folio *);

include/linux/swap.h

315

void folio_add_lru(struct folio *);

include/linux/swap.h

316

void folio_add_lru_vma(struct folio *, struct vm_area_struct *);

include/linux/swap.h

318

void folio_mark_accessed(struct folio *);

include/linux/swap.h

320

static inline bool folio_may_be_lru_cached(struct folio *folio)

include/linux/swap.h

327

return !folio_test_large(folio);

include/linux/swap.h

347

void folio_deactivate(struct folio *folio);

include/linux/swap.h

348

void folio_mark_lazyfree(struct folio *folio);

include/linux/swap.h

376

long remove_mapping(struct address_space *mapping, struct folio *folio);

include/linux/swap.h

416

void free_swap_cache(struct folio *folio);

include/linux/swap.h

417

void free_folio_and_swap_cache(struct folio *folio);

include/linux/swap.h

447

sector_t swap_folio_sector(struct folio *folio);

include/linux/swap.h

466

bool folio_free_swap(struct folio *folio);

include/linux/swap.h

494

#define free_folio_and_swap_cache(folio) \

include/linux/swap.h

495

folio_put(folio)

include/linux/swap.h

499

static inline void free_swap_cache(struct folio *folio)

include/linux/swap.h

527

static inline bool folio_free_swap(struct folio *folio)

include/linux/swap.h

562

void __folio_throttle_swaprate(struct folio *folio, gfp_t gfp);

include/linux/swap.h

563

static inline void folio_throttle_swaprate(struct folio *folio, gfp_t gfp)

include/linux/swap.h

567

__folio_throttle_swaprate(folio, gfp);

include/linux/swap.h

570

static inline void folio_throttle_swaprate(struct folio *folio, gfp_t gfp)

include/linux/swap.h

576

int __mem_cgroup_try_charge_swap(struct folio *folio);

include/linux/swap.h

577

static inline int mem_cgroup_try_charge_swap(struct folio *folio)

include/linux/swap.h

581

return __mem_cgroup_try_charge_swap(folio);

include/linux/swap.h

593

extern bool mem_cgroup_swap_full(struct folio *folio);

include/linux/swap.h

595

static inline int mem_cgroup_try_charge_swap(struct folio *folio)

include/linux/swap.h

610

static inline bool mem_cgroup_swap_full(struct folio *folio)

include/linux/uio.h

194

size_t copy_folio_from_iter_atomic(struct folio *folio, size_t offset,

include/linux/uio.h

201

static inline size_t copy_folio_to_iter(struct folio *folio, size_t offset,

include/linux/uio.h

204

return copy_page_to_iter(&folio->page, offset, bytes, i);

include/linux/uio.h

207

static inline size_t copy_folio_from_iter(struct folio *folio, size_t offset,

include/linux/uio.h

210

return copy_page_from_iter(&folio->page, offset, bytes, i);

include/linux/userfaultfd_k.h

101

struct folio *(*alloc_folio)(struct vm_area_struct *vma,

include/linux/userfaultfd_k.h

109

int (*filemap_add)(struct folio *folio, struct vm_area_struct *vma,

include/linux/userfaultfd_k.h

116

void (*filemap_remove)(struct folio *folio, struct vm_area_struct *vma);

include/linux/userfaultfd_k.h

96

struct folio *(*get_folio_noalloc)(struct inode *inode, pgoff_t pgoff);

include/linux/vmstat.h

407

static inline void __zone_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

410

__mod_zone_page_state(folio_zone(folio), item, nr);

include/linux/vmstat.h

413

static inline void __zone_stat_add_folio(struct folio *folio,

include/linux/vmstat.h

416

__mod_zone_page_state(folio_zone(folio), item, folio_nr_pages(folio));

include/linux/vmstat.h

419

static inline void __zone_stat_sub_folio(struct folio *folio,

include/linux/vmstat.h

422

__mod_zone_page_state(folio_zone(folio), item, -folio_nr_pages(folio));

include/linux/vmstat.h

425

static inline void zone_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

428

mod_zone_page_state(folio_zone(folio), item, nr);

include/linux/vmstat.h

431

static inline void zone_stat_add_folio(struct folio *folio,

include/linux/vmstat.h

434

mod_zone_page_state(folio_zone(folio), item, folio_nr_pages(folio));

include/linux/vmstat.h

437

static inline void zone_stat_sub_folio(struct folio *folio,

include/linux/vmstat.h

440

mod_zone_page_state(folio_zone(folio), item, -folio_nr_pages(folio));

include/linux/vmstat.h

443

static inline void __node_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

446

__mod_node_page_state(folio_pgdat(folio), item, nr);

include/linux/vmstat.h

449

static inline void __node_stat_add_folio(struct folio *folio,

include/linux/vmstat.h

452

__mod_node_page_state(folio_pgdat(folio), item, folio_nr_pages(folio));

include/linux/vmstat.h

455

static inline void __node_stat_sub_folio(struct folio *folio,

include/linux/vmstat.h

458

__mod_node_page_state(folio_pgdat(folio), item, -folio_nr_pages(folio));

include/linux/vmstat.h

461

static inline void node_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

464

mod_node_page_state(folio_pgdat(folio), item, nr);

include/linux/vmstat.h

467

static inline void node_stat_add_folio(struct folio *folio,

include/linux/vmstat.h

470

mod_node_page_state(folio_pgdat(folio), item, folio_nr_pages(folio));

include/linux/vmstat.h

473

static inline void node_stat_sub_folio(struct folio *folio,

include/linux/vmstat.h

476

mod_node_page_state(folio_pgdat(folio), item, -folio_nr_pages(folio));

include/linux/vmstat.h

522

void lruvec_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

539

static inline void lruvec_stat_mod_folio(struct folio *folio,

include/linux/vmstat.h

542

mod_node_page_state(folio_pgdat(folio), idx, val);

include/linux/vmstat.h

553

static inline void lruvec_stat_add_folio(struct folio *folio,

include/linux/vmstat.h

556

lruvec_stat_mod_folio(folio, idx, folio_nr_pages(folio));

include/linux/vmstat.h

559

static inline void lruvec_stat_sub_folio(struct folio *folio,

include/linux/vmstat.h

562

lruvec_stat_mod_folio(folio, idx, -folio_nr_pages(folio));

include/linux/writeback.h

204

void __inode_attach_wb(struct inode *inode, struct folio *folio);

include/linux/writeback.h

206

void wbc_account_cgroup_owner(struct writeback_control *wbc, struct folio *folio,

include/linux/writeback.h

222

static inline void inode_attach_wb(struct inode *inode, struct folio *folio)

include/linux/writeback.h

225

__inode_attach_wb(inode, folio);

include/linux/writeback.h

272

static inline void inode_attach_wb(struct inode *inode, struct folio *folio)

include/linux/writeback.h

294

struct folio *folio, size_t bytes)

include/linux/writeback.h

358

struct folio *writeback_iter(struct address_space *mapping,

include/linux/writeback.h

359

struct writeback_control *wbc, struct folio *folio, int *error);

include/linux/writeback.h

366

bool filemap_dirty_folio(struct address_space *mapping, struct folio *folio);

include/linux/writeback.h

367

bool folio_redirty_for_writepage(struct writeback_control *, struct folio *);

include/linux/zswap.h

28

bool zswap_store(struct folio *folio);

include/linux/zswap.h

29

int zswap_load(struct folio *folio);

include/linux/zswap.h

35

void zswap_folio_swapin(struct folio *folio);

include/linux/zswap.h

42

static inline bool zswap_store(struct folio *folio)

include/linux/zswap.h

47

static inline int zswap_load(struct folio *folio)

include/linux/zswap.h

60

static inline void zswap_folio_swapin(struct folio *folio) {}

include/trace/events/btrfs.h

747

TP_PROTO(const struct folio *folio, const struct inode *inode,

include/trace/events/btrfs.h

750

TP_ARGS(folio, inode, wbc),

include/trace/events/btrfs.h

767

__entry->index = folio->index;

include/trace/events/btrfs.h

792

TP_PROTO(const struct folio *folio, const struct inode *inode,

include/trace/events/btrfs.h

795

TP_ARGS(folio, inode, wbc)

include/trace/events/erofs.h

101

__entry->index = folio->index;

include/trace/events/erofs.h

102

__entry->order = folio_order(folio);

include/trace/events/erofs.h

84

TP_PROTO(struct inode *inode, struct folio *folio, bool raw),

include/trace/events/erofs.h

86

TP_ARGS(inode, folio, raw),

include/trace/events/ext4.h

632

TP_PROTO(struct inode *inode, struct folio *folio),

include/trace/events/ext4.h

634

TP_ARGS(inode, folio),

include/trace/events/ext4.h

646

__entry->index = folio->index;

include/trace/events/ext4.h

657

TP_PROTO(struct inode *inode, struct folio *folio),

include/trace/events/ext4.h

659

TP_ARGS(inode, folio)

include/trace/events/ext4.h

664

TP_PROTO(struct inode *inode, struct folio *folio),

include/trace/events/ext4.h

666

TP_ARGS(inode, folio)

include/trace/events/ext4.h

670

TP_PROTO(struct folio *folio, size_t offset, size_t length),

include/trace/events/ext4.h

672

TP_ARGS(folio, offset, length),

include/trace/events/ext4.h

683

__entry->dev = folio->mapping->host->i_sb->s_dev;

include/trace/events/ext4.h

684

__entry->ino = folio->mapping->host->i_ino;

include/trace/events/ext4.h

685

__entry->index = folio->index;

include/trace/events/ext4.h

698

TP_PROTO(struct folio *folio, size_t offset, size_t length),

include/trace/events/ext4.h

700

TP_ARGS(folio, offset, length)

include/trace/events/ext4.h

704

TP_PROTO(struct folio *folio, size_t offset, size_t length),

include/trace/events/ext4.h

706

TP_ARGS(folio, offset, length)

include/trace/events/f2fs.h

1174

TP_PROTO(struct folio *folio, struct f2fs_io_info *fio),

include/trace/events/f2fs.h

1176

TP_ARGS(folio, fio),

include/trace/events/f2fs.h

1191

__entry->dev = folio->mapping->host->i_sb->s_dev;

include/trace/events/f2fs.h

1192

__entry->ino = folio->mapping->host->i_ino;

include/trace/events/f2fs.h

1193

__entry->index = folio->index;

include/trace/events/f2fs.h

1215

TP_PROTO(struct folio *folio, struct f2fs_io_info *fio),

include/trace/events/f2fs.h

1217

TP_ARGS(folio, fio),

include/trace/events/f2fs.h

1219

TP_CONDITION(folio->mapping)

include/trace/events/f2fs.h

1224

TP_PROTO(struct folio *folio, struct f2fs_io_info *fio),

include/trace/events/f2fs.h

1226

TP_ARGS(folio, fio),

include/trace/events/f2fs.h

1228

TP_CONDITION(folio->mapping)

include/trace/events/f2fs.h

1360

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1362

TP_ARGS(folio, type),

include/trace/events/f2fs.h

1376

__entry->dev = folio->mapping->host->i_sb->s_dev;

include/trace/events/f2fs.h

1377

__entry->ino = folio->mapping->host->i_ino;

include/trace/events/f2fs.h

1379

__entry->dir = S_ISDIR(folio->mapping->host->i_mode);

include/trace/events/f2fs.h

1380

__entry->index = folio->index;

include/trace/events/f2fs.h

1381

__entry->nrpages= folio_nr_pages(folio);

include/trace/events/f2fs.h

1382

__entry->dirty = folio_test_dirty(folio);

include/trace/events/f2fs.h

1383

__entry->uptodate = folio_test_uptodate(folio);

include/trace/events/f2fs.h

1399

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1401

TP_ARGS(folio, type)

include/trace/events/f2fs.h

1406

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1408

TP_ARGS(folio, type)

include/trace/events/f2fs.h

1413

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1415

TP_ARGS(folio, type)

include/trace/events/f2fs.h

1420

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1422

TP_ARGS(folio, type)

include/trace/events/f2fs.h

1427

TP_PROTO(struct folio *folio, int type),

include/trace/events/f2fs.h

1429

TP_ARGS(folio, type)

include/trace/events/filemap.h

18

TP_PROTO(struct folio *folio),

include/trace/events/filemap.h

20

TP_ARGS(folio),

include/trace/events/filemap.h

31

__entry->pfn = folio_pfn(folio);

include/trace/events/filemap.h

32

__entry->i_ino = folio->mapping->host->i_ino;

include/trace/events/filemap.h

33

__entry->index = folio->index;

include/trace/events/filemap.h

34

if (folio->mapping->host->i_sb)

include/trace/events/filemap.h

35

__entry->s_dev = folio->mapping->host->i_sb->s_dev;

include/trace/events/filemap.h

37

__entry->s_dev = folio->mapping->host->i_rdev;

include/trace/events/filemap.h

38

__entry->order = folio_order(folio);

include/trace/events/filemap.h

50

TP_PROTO(struct folio *folio),

include/trace/events/filemap.h

51

TP_ARGS(folio)

include/trace/events/filemap.h

55

TP_PROTO(struct folio *folio),

include/trace/events/filemap.h

56

TP_ARGS(folio)

include/trace/events/fs_dax.h

65

struct folio *zero_folio,

include/trace/events/fs_dax.h

72

__field(struct folio *, zero_folio)

include/trace/events/fs_dax.h

99

struct folio *zero_folio, void *radix_entry), \

include/trace/events/huge_memory.h

119

TP_PROTO(struct folio *folio, int none_or_zero,

include/trace/events/huge_memory.h

122

TP_ARGS(folio, none_or_zero, referenced, status, order),

include/trace/events/huge_memory.h

133

__entry->pfn = folio ? folio_pfn(folio) : -1;

include/trace/events/huge_memory.h

181

TP_PROTO(struct mm_struct *mm, struct folio *folio, struct file *file,

include/trace/events/huge_memory.h

184

TP_ARGS(mm, folio, file, present, swap, result),

include/trace/events/huge_memory.h

197

__entry->pfn = folio ? folio_pfn(folio) : -1;

include/trace/events/huge_memory.h

214

TP_PROTO(struct mm_struct *mm, struct folio *new_folio, pgoff_t index,

include/trace/events/huge_memory.h

58

TP_PROTO(struct mm_struct *mm, struct folio *folio,

include/trace/events/huge_memory.h

61

TP_ARGS(mm, folio, referenced, none_or_zero, status, unmapped),

include/trace/events/huge_memory.h

74

__entry->pfn = folio ? folio_pfn(folio) : -1;

include/trace/events/netfs.h

492

TP_PROTO(struct folio *folio, enum netfs_folio_trace why),

include/trace/events/netfs.h

494

TP_ARGS(folio, why),

include/trace/events/netfs.h

504

struct address_space *__m = READ_ONCE(folio->mapping);

include/trace/events/netfs.h

507

__entry->index = folio->index;

include/trace/events/netfs.h

508

__entry->nr = folio_nr_pages(folio);

include/trace/events/netfs.h

658

const struct folio *folio,

include/trace/events/netfs.h

662

TP_ARGS(wreq, folio, fend, collected_to),

include/trace/events/netfs.h

674

__entry->index = folio->index;

include/trace/events/pagemap.h

19

#define trace_pagemap_flags(folio) ( \

include/trace/events/pagemap.h

20

(folio_test_anon(folio) ? PAGEMAP_ANONYMOUS : PAGEMAP_FILE) | \

include/trace/events/pagemap.h

21

(folio_mapped(folio) ? PAGEMAP_MAPPED : 0) | \

include/trace/events/pagemap.h

22

(folio_test_swapcache(folio) ? PAGEMAP_SWAPCACHE : 0) | \

include/trace/events/pagemap.h

23

(folio_test_swapbacked(folio) ? PAGEMAP_SWAPBACKED : 0) | \

include/trace/events/pagemap.h

24

(folio_test_mappedtodisk(folio) ? PAGEMAP_MAPPEDDISK : 0) | \

include/trace/events/pagemap.h

25

(folio_test_private(folio) ? PAGEMAP_BUFFERS : 0) \

include/trace/events/pagemap.h

30

TP_PROTO(struct folio *folio),

include/trace/events/pagemap.h

32

TP_ARGS(folio),

include/trace/events/pagemap.h

35

__field(struct folio *, folio )

include/trace/events/pagemap.h

42

__entry->folio = folio;

include/trace/events/pagemap.h

43

__entry->pfn = folio_pfn(folio);

include/trace/events/pagemap.h

44

__entry->lru = folio_lru_list(folio);

include/trace/events/pagemap.h

45

__entry->flags = trace_pagemap_flags(folio);

include/trace/events/pagemap.h

50

__entry->folio,

include/trace/events/pagemap.h

63

TP_PROTO(struct folio *folio),

include/trace/events/pagemap.h

65

TP_ARGS(folio),

include/trace/events/pagemap.h

68

__field(struct folio *, folio )

include/trace/events/pagemap.h

73

__entry->folio = folio;

include/trace/events/pagemap.h

74

__entry->pfn = folio_pfn(folio);

include/trace/events/pagemap.h

77

TP_printk("folio=%p pfn=0x%lx", __entry->folio, __entry->pfn)

include/trace/events/vmscan.h

411

TP_PROTO(struct folio *folio),

include/trace/events/vmscan.h

413

TP_ARGS(folio),

include/trace/events/vmscan.h

421

__entry->pfn = folio_pfn(folio);

include/trace/events/vmscan.h

423

folio_is_file_lru(folio));

include/trace/events/writeback.h

101

TP_ARGS(folio, mapping)

include/trace/events/writeback.h

276

TP_PROTO(struct folio *folio, struct bdi_writeback *wb),

include/trace/events/writeback.h

278

TP_ARGS(folio, wb),

include/trace/events/writeback.h

290

struct address_space *mapping = folio_mapping(folio);

include/trace/events/writeback.h

300

__entry->page_cgroup_ino = cgroup_ino(folio_memcg(folio)->css.cgroup);

include/trace/events/writeback.h

65

TP_PROTO(struct folio *folio, struct address_space *mapping),

include/trace/events/writeback.h

67

TP_ARGS(folio, mapping),

include/trace/events/writeback.h

80

__entry->index = folio->index;

include/trace/events/writeback.h

92

TP_PROTO(struct folio *folio, struct address_space *mapping),

include/trace/events/writeback.h

94

TP_ARGS(folio, mapping)

include/trace/events/writeback.h

99

TP_PROTO(struct folio *folio, struct address_space *mapping),

io_uring/rsrc.c

155

struct folio *folio = bvec_folio(&imu->bvec[i]);

io_uring/rsrc.c

157

unpin_user_folio(folio, 1);

io_uring/rsrc.c

785

struct folio *folio = page_folio(p);

io_uring/rsrc.c

794

unpin_user_folio(folio, nr - 1);

io_uring/rsrc.c

811

struct folio *folio = page_folio(page_array[0]);

io_uring/rsrc.c

815

data->nr_pages_mid = folio_nr_pages(folio);

io_uring/rsrc.c

816

data->folio_shift = folio_shift(folio);

io_uring/rsrc.c

817

data->first_folio_page_idx = folio_page_idx(folio, page_array[0]);

io_uring/rsrc.c

824

if (page_folio(page_array[i]) == folio &&

io_uring/rsrc.c

831

if (folio_page_idx(folio, page_array[i-1]) !=

io_uring/rsrc.c

840

folio = page_folio(page_array[i]);

io_uring/rsrc.c

841

if (folio_size(folio) != (1UL << data->folio_shift) ||

io_uring/rsrc.c

842

folio_page_idx(folio, page_array[i]) != 0)

io_uring/zcrx.c

187

struct folio *last_folio = NULL;

io_uring/zcrx.c

192

struct folio *folio = page_folio(pages[i]);

io_uring/zcrx.c

194

if (folio == last_folio)

io_uring/zcrx.c

196

last_folio = folio;

io_uring/zcrx.c

197

res += folio_nr_pages(folio);

kernel/events/uprobes.c

387

struct folio *orig_folio = filemap_get_folio(vma->vm_file->f_mapping,

kernel/events/uprobes.c

404

struct folio_walk *fw, struct folio *folio,

kernel/events/uprobes.c

440

(folio_ref_count(folio) != folio_expected_ref_count(folio) + 1))

kernel/events/uprobes.c

451

folio_remove_rmap_pte(folio, fw->page, vma);

kernel/events/uprobes.c

452

if (!folio_mapped(folio) && folio_test_swapcache(folio) &&

kernel/events/uprobes.c

453

folio_trylock(folio)) {

kernel/events/uprobes.c

454

folio_free_swap(folio);

kernel/events/uprobes.c

455

folio_unlock(folio);

kernel/events/uprobes.c

457

folio_put(folio);

kernel/events/uprobes.c

509

struct folio *folio;

kernel/events/uprobes.c

532

folio = page_folio(page);

kernel/events/uprobes.c

536

folio_put(folio);

kernel/events/uprobes.c

544

folio_put(folio);

kernel/events/uprobes.c

552

if (unlikely(!folio_test_anon(folio) || folio_is_zone_device(folio))) {

kernel/events/uprobes.c

554

folio_put(folio);

kernel/events/uprobes.c

573

ret = __uprobe_write(vma, &fw, folio, insn_vaddr, insn, nbytes, is_register);

kernel/events/uprobes.c

580

folio_put(folio);

kernel/futex/core.c

508

struct folio *folio;

kernel/futex/core.c

623

folio = page_folio(page);

kernel/futex/core.c

624

mapping = READ_ONCE(folio->mapping);

kernel/futex/core.c

649

folio_lock(folio);

kernel/futex/core.c

650

shmem_swizzled = folio_test_swapcache(folio) || folio->mapping;

kernel/futex/core.c

651

folio_unlock(folio);

kernel/futex/core.c

652

folio_put(folio);

kernel/futex/core.c

670

if (folio_test_anon(folio)) {

kernel/futex/core.c

700

if (READ_ONCE(folio->mapping) != mapping) {

kernel/futex/core.c

702

folio_put(folio);

kernel/futex/core.c

710

folio_put(folio);

kernel/futex/core.c

717

key->shared.pgoff = page_pgoff(folio, page);

kernel/futex/core.c

722

folio_put(folio);

kernel/liveupdate/kexec_handover.c

1248

struct folio *folio;

kernel/liveupdate/kexec_handover.c

1258

folio = folio_alloc(GFP_KERNEL | __GFP_ZERO, order);

kernel/liveupdate/kexec_handover.c

1259

if (!folio)

kernel/liveupdate/kexec_handover.c

1262

ret = kho_preserve_folio(folio);

kernel/liveupdate/kexec_handover.c

1264

folio_put(folio);

kernel/liveupdate/kexec_handover.c

1268

return folio_address(folio);

kernel/liveupdate/kexec_handover.c

1282

struct folio *folio;

kernel/liveupdate/kexec_handover.c

1287

folio = virt_to_folio(mem);

kernel/liveupdate/kexec_handover.c

1288

kho_unpreserve_folio(folio);

kernel/liveupdate/kexec_handover.c

1289

folio_put(folio);

kernel/liveupdate/kexec_handover.c

1307

struct folio *folio;

kernel/liveupdate/kexec_handover.c

1312

folio = kho_restore_folio(__pa(mem));

kernel/liveupdate/kexec_handover.c

1313

if (!WARN_ON(!folio))

kernel/liveupdate/kexec_handover.c

1314

folio_put(folio);

kernel/liveupdate/kexec_handover.c

424

struct folio *kho_restore_folio(phys_addr_t phys)

kernel/liveupdate/kexec_handover.c

853

int kho_preserve_folio(struct folio *folio)

kernel/liveupdate/kexec_handover.c

856

const unsigned long pfn = folio_pfn(folio);

kernel/liveupdate/kexec_handover.c

857

const unsigned int order = folio_order(folio);

kernel/liveupdate/kexec_handover.c

874

void kho_unpreserve_folio(struct folio *folio)

kernel/liveupdate/kexec_handover.c

877

const unsigned long pfn = folio_pfn(folio);

kernel/liveupdate/kexec_handover.c

878

const unsigned int order = folio_order(folio);

kernel/sched/fair.c

2614

static int numa_hint_fault_latency(struct folio *folio)

kernel/sched/fair.c

2619

last_time = folio_xchg_access_time(folio, time);

kernel/sched/fair.c

2676

bool should_numa_migrate_memory(struct task_struct *p, struct folio *folio,

kernel/sched/fair.c

2693

if (folio_use_access_time(folio)) {

kernel/sched/fair.c

2697

long nr = folio_nr_pages(folio);

kernel/sched/fair.c

2712

latency = numa_hint_fault_latency(folio);

kernel/sched/fair.c

2720

last_cpupid = folio_xchg_last_cpupid(folio, this_cpupid);

lib/alloc_tag.c

183

void pgalloc_tag_split(struct folio *folio, int old_order, int new_order)

lib/alloc_tag.c

192

tag = __pgalloc_tag_get(&folio->page);

lib/alloc_tag.c

200

if (get_page_tag_ref(folio_page(folio, i), &ref, &handle)) {

lib/alloc_tag.c

209

void pgalloc_tag_swap(struct folio *new, struct folio *old)

lib/buildid.c

117

folio_sz = folio_size(r->folio);

lib/buildid.c

129

folio_sz = folio_size(r->folio);

lib/buildid.c

34

if (!r->folio)

lib/buildid.c

37

folio_put(r->folio);

lib/buildid.c

38

r->folio = NULL;

lib/buildid.c

44

if (r->folio && file_off >= r->folio_off &&

lib/buildid.c

45

file_off < r->folio_off + folio_size(r->folio))

lib/buildid.c

51

r->folio = filemap_get_folio(r->file->f_mapping, file_off >> PAGE_SHIFT);

lib/buildid.c

53

if (IS_ERR(r->folio) || !folio_test_uptodate(r->folio)) {

lib/buildid.c

54

if (!IS_ERR(r->folio))

lib/buildid.c

55

folio_put(r->folio);

lib/buildid.c

56

r->folio = NULL;

lib/buildid.c

60

r->folio_off = folio_pos(r->folio);

lib/buildid.c

61

r->addr = kmap_local_folio(r->folio, 0);

lib/iov_iter.c

1108

struct folio *folio = page_folio(page + k);

lib/iov_iter.c

1110

if (!folio_test_slab(folio))

lib/iov_iter.c

1111

folio_get(folio);

lib/iov_iter.c

1526

struct folio *folio = folioq_folio(folioq, slot);

lib/iov_iter.c

1536

p[nr++] = folio_page(folio, offset / PAGE_SIZE);

lib/iov_iter.c

1568

struct folio *folio;

lib/iov_iter.c

1583

for (folio = xas_load(&xas); folio; folio = xas_next(&xas)) {

lib/iov_iter.c

1584

if (xas_retry(&xas, folio))

lib/iov_iter.c

1588

if (unlikely(folio != xas_reload(&xas))) {

lib/iov_iter.c

1593

p[nr++] = folio_file_page(folio, xas.xa_index);

lib/iov_iter.c

1870

struct folio *folio = page_folio(pages[0]);

lib/iov_iter.c

1875

folio_offset = PAGE_SIZE * folio_page_idx(folio, pages[0]) + offset;

lib/iov_iter.c

1876

len = min(folio_size(folio) - folio_offset, left);

lib/iov_iter.c

1887

if (page_folio(pages[i]) != folio ||

lib/iov_iter.c

472

size_t copy_folio_from_iter_atomic(struct folio *folio, size_t offset,

lib/iov_iter.c

477

if (!page_copy_sane(&folio->page, offset, bytes))

lib/iov_iter.c

483

char *to = kmap_local_folio(folio, offset);

lib/iov_iter.c

486

if (folio_test_partial_kmap(folio) &&

lib/iov_iter.c

936

struct folio *folio = folioq_folio(folioq, slot);

lib/iov_iter.c

946

*pages = folio_page(folio, offset / PAGE_SIZE);

lib/iov_iter.c

976

struct folio *folio;

lib/iov_iter.c

980

for (folio = xas_load(&xas); folio; folio = xas_next(&xas)) {

lib/iov_iter.c

981

if (xas_retry(&xas, folio))

lib/iov_iter.c

985

if (unlikely(folio != xas_reload(&xas))) {

lib/iov_iter.c

990

pages[ret] = folio_file_page(folio, xas.xa_index);

lib/iov_iter.c

991

folio_get(folio);

lib/scatterlist.c

1296

struct folio *folio = folioq_folio(folioq, slot);

lib/scatterlist.c

1302

sg_set_page(sg, folio_page(folio, 0), part, offset);

lib/scatterlist.c

1343

struct folio *folio;

lib/scatterlist.c

1352

xas_for_each(&xas, folio, ULONG_MAX) {

lib/scatterlist.c

1353

if (xas_retry(&xas, folio))

lib/scatterlist.c

1355

if (WARN_ON(xa_is_value(folio)))

lib/scatterlist.c

1357

if (WARN_ON(folio_test_hugetlb(folio)))

lib/scatterlist.c

1360

offset = offset_in_folio(folio, start);

lib/scatterlist.c

1361

len = min_t(size_t, maxsize, folio_size(folio) - offset);

lib/scatterlist.c

1363

sg_set_page(sg, folio_page(folio, 0), len, offset);

lib/test_hmm.c

123

struct folio *free_folios;

lib/test_hmm.c

1470

struct folio *folio;

lib/test_hmm.c

1473

for (folio = mdevice->free_folios; folio; folio = folio_zone_device_data(folio))

lib/test_hmm.c

1474

if (dmirror_page_to_chunk(folio_page(folio, 0)) == devmem)

lib/test_hmm.c

1475

mdevice->free_folios = folio_zone_device_data(folio);

lib/test_hmm.c

1620

static void dmirror_devmem_free(struct folio *folio)

lib/test_hmm.c

1622

struct page *page = &folio->page;

lib/test_hmm.c

1625

struct folio *rfolio = page_folio(rpage);

lib/test_hmm.c

1732

static void dmirror_devmem_folio_split(struct folio *head, struct folio *tail)

lib/test_hmm.c

1736

struct folio *rfolio;

lib/test_hmm.c

774

struct folio *folio;

lib/test_hmm.c

785

folio = page_folio(spage);

lib/test_hmm.c

786

nr = folio_nr_pages(folio);

lib/test_hmm.c

825

struct folio *folio = page_folio(dpage);

lib/test_hmm.c

828

if (folio_test_large(folio)) {

lib/test_hmm.c

829

for (i = 0; i < folio_nr_pages(folio); i++) {

lib/test_hmm.c

967

struct folio *folio;

lib/test_hmm.c

970

page = make_device_exclusive(mm, addr, NULL, &folio);

lib/test_hmm.c

977

folio_unlock(folio);

lib/test_hmm.c

978

folio_put(folio);

lib/test_kho.c

169

struct folio *folio;

lib/test_kho.c

184

folio = folio_alloc(GFP_KERNEL | __GFP_NORETRY, order);

lib/test_kho.c

185

if (!folio)

lib/test_kho.c

188

state->folios[state->nr_folios++] = folio;

lib/test_kho.c

189

addr = folio_address(folio);

lib/test_kho.c

208

struct folio **folios;

lib/test_kho.c

266

struct folio *folio;

lib/test_kho.c

268

folio = kho_restore_folio(phys);

lib/test_kho.c

269

if (!folio)

lib/test_kho.c

272

if (folio_order(folio) != order)

lib/test_kho.c

275

csum = csum_partial(folio_address(folio), size, csum);

lib/test_kho.c

276

folio_put(folio);

lib/test_kho.c

35

struct folio **folios;

lib/test_kho.c

39

struct folio *fdt;

lib/test_kho.c

72

struct folio *folio = state->folios[i];

lib/test_kho.c

73

unsigned int order = folio_order(folio);

lib/test_kho.c

75

folios_info[i] = virt_to_phys(folio_address(folio)) | order;

lib/test_kho.c

76

err = kho_preserve_folio(folio);

mm/compaction.c

1005

if (folio_test_hugetlb(folio)) {

mm/compaction.c

1010

low_pfn += folio_nr_pages(folio) - folio_page_idx(folio, page) - 1;

mm/compaction.c

1079

folio = page_folio(page);

mm/compaction.c

1092

folio = folio_get_nontail_page(page);

mm/compaction.c

1093

if (unlikely(!folio))

mm/compaction.c

1101

mapping = folio_mapping(folio);

mm/compaction.c

1102

if (!mapping && (folio_ref_count(folio) - 1) > folio_mapcount(folio))

mm/compaction.c

1113

if (!folio_test_lru(folio))

mm/compaction.c

1116

is_unevictable = folio_test_unevictable(folio);

mm/compaction.c

1128

if ((mode & ISOLATE_ASYNC_MIGRATE) && folio_test_writeback(folio))

mm/compaction.c

1131

is_dirty = folio_test_dirty(folio);

mm/compaction.c

1156

if (!folio_trylock(folio))

mm/compaction.c

1159

mapping = folio_mapping(folio);

mm/compaction.c

1165

folio_unlock(folio);

mm/compaction.c

1171

if (!folio_test_clear_lru(folio))

mm/compaction.c

1175

lruvec = folio_lruvec(folio);

mm/compaction.c

1182

lruvec = compact_folio_lruvec_lock_irqsave(folio, &flags, cc);

mm/compaction.c

1202

if (unlikely(skip_isolation_on_order(folio_order(folio),

mm/compaction.c

1205

low_pfn += folio_nr_pages(folio) - 1;

mm/compaction.c

1206

nr_scanned += folio_nr_pages(folio) - 1;

mm/compaction.c

1207

folio_set_lru(folio);

mm/compaction.c

1213

if (folio_test_large(folio))

mm/compaction.c

1214

low_pfn += folio_nr_pages(folio) - 1;

mm/compaction.c

1217

lruvec_del_folio(lruvec, folio);

mm/compaction.c

1218

node_stat_mod_folio(folio,

mm/compaction.c

1219

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/compaction.c

1220

folio_nr_pages(folio));

mm/compaction.c

1223

list_add(&folio->lru, &cc->migratepages);

mm/compaction.c

1225

cc->nr_migratepages += folio_nr_pages(folio);

mm/compaction.c

1226

nr_isolated += folio_nr_pages(folio);

mm/compaction.c

1227

nr_scanned += folio_nr_pages(folio) - 1;

mm/compaction.c

1249

folio_put(folio);

mm/compaction.c

1290

folio = NULL;

mm/compaction.c

1295

if (folio) {

mm/compaction.c

1296

folio_set_lru(folio);

mm/compaction.c

1297

folio_put(folio);

mm/compaction.c

1814

static struct folio *compaction_alloc_noprof(struct folio *src, unsigned long data)

mm/compaction.c

1817

struct folio *dst;

mm/compaction.c

1851

dst = (struct folio *)freepage;

mm/compaction.c

1862

static struct folio *compaction_alloc(struct folio *src, unsigned long data)

mm/compaction.c

1872

static void compaction_free(struct folio *dst, unsigned long data)

mm/compaction.c

522

compact_folio_lruvec_lock_irqsave(struct folio *folio, unsigned long *flags,

mm/compaction.c

529

lruvec = folio_lruvec(folio);

mm/compaction.c

531

if (unlikely(lruvec_memcg(lruvec) != folio_memcg(folio))) {

mm/compaction.c

863

struct folio *folio = NULL;

mm/compaction.c

962

folio = NULL;

mm/compaction.c

989

folio = page_folio(page);

mm/compaction.c

990

ret = isolate_or_dissolve_huge_folio(folio, &cc->migratepages);

mm/damon/core.c

2699

struct folio *folio;

mm/damon/core.c

2704

folio = damon_get_folio(PHYS_PFN(addr));

mm/damon/core.c

2705

if (!folio) {

mm/damon/core.c

2719

folio_start = PFN_PHYS(folio_pfn(folio));

mm/damon/core.c

2720

folio_end = folio_start + folio_size(folio);

mm/damon/core.c

2728

if (folio_nid(folio) == nid)

mm/damon/core.c

2734

folio_put(folio);

mm/damon/ops-common.c

158

static bool damon_folio_mkold_one(struct folio *folio,

mm/damon/ops-common.c

161

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, addr, 0);

mm/damon/ops-common.c

173

void damon_folio_mkold(struct folio *folio)

mm/damon/ops-common.c

180

if (!folio_mapped(folio) || !folio_raw_mapping(folio)) {

mm/damon/ops-common.c

181

folio_set_idle(folio);

mm/damon/ops-common.c

185

if (!folio_trylock(folio))

mm/damon/ops-common.c

188

rmap_walk(folio, &rwc);

mm/damon/ops-common.c

189

folio_unlock(folio);

mm/damon/ops-common.c

193

static bool damon_folio_young_one(struct folio *folio,

mm/damon/ops-common.c

197

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, addr, 0);

mm/damon/ops-common.c

212

!folio_test_idle(folio) ||

mm/damon/ops-common.c

219

!folio_test_idle(folio) ||

mm/damon/ops-common.c

235

bool damon_folio_young(struct folio *folio)

mm/damon/ops-common.c

24

struct folio *damon_get_folio(unsigned long pfn)

mm/damon/ops-common.c

244

if (!folio_mapped(folio) || !folio_raw_mapping(folio)) {

mm/damon/ops-common.c

245

if (folio_test_idle(folio))

mm/damon/ops-common.c

251

if (!folio_trylock(folio))

mm/damon/ops-common.c

254

rmap_walk(folio, &rwc);

mm/damon/ops-common.c

255

folio_unlock(folio);

mm/damon/ops-common.c

260

bool damos_folio_filter_match(struct damos_filter *filter, struct folio *folio)

mm/damon/ops-common.c

268

matched = folio_test_anon(folio);

mm/damon/ops-common.c

27

struct folio *folio;

mm/damon/ops-common.c

271

matched = folio_test_active(folio);

mm/damon/ops-common.c

275

memcg = folio_memcg_check(folio);

mm/damon/ops-common.c

283

matched = damon_folio_young(folio);

mm/damon/ops-common.c

285

damon_folio_mkold(folio);

mm/damon/ops-common.c

288

folio_sz = folio_size(folio);

mm/damon/ops-common.c

293

matched = !folio_mapped(folio) || !folio_raw_mapping(folio);

mm/damon/ops-common.c

32

folio = page_folio(page);

mm/damon/ops-common.c

33

if (!folio_try_get(folio))

mm/damon/ops-common.c

337

struct folio *folio;

mm/damon/ops-common.c

342

struct folio *folio;

mm/damon/ops-common.c

346

folio = lru_to_folio(folio_list);

mm/damon/ops-common.c

347

list_del(&folio->lru);

mm/damon/ops-common.c

349

if (!folio_trylock(folio))

mm/damon/ops-common.c

35

if (unlikely(page_folio(page) != folio) || !folio_test_lru(folio)) {

mm/damon/ops-common.c

353

list_add(&folio->lru, &migrate_folios);

mm/damon/ops-common.c

354

folio_unlock(folio);

mm/damon/ops-common.c

357

list_add(&folio->lru, &ret_folios);

mm/damon/ops-common.c

36

folio_put(folio);

mm/damon/ops-common.c

37

folio = NULL;

mm/damon/ops-common.c

376

folio = lru_to_folio(folio_list);

mm/damon/ops-common.c

377

list_del(&folio->lru);

mm/damon/ops-common.c

378

folio_putback_lru(folio);

mm/damon/ops-common.c

39

return folio;

mm/damon/ops-common.c

402

struct folio *folio = lru_to_folio(folio_list);

mm/damon/ops-common.c

404

if (nid == folio_nid(folio)) {

mm/damon/ops-common.c

405

list_move(&folio->lru, &node_folio_list);

mm/damon/ops-common.c

45

struct folio *folio;

mm/damon/ops-common.c

54

folio = damon_get_folio(pfn);

mm/damon/ops-common.c

55

if (!folio)

mm/damon/ops-common.c

67

folio_set_young(folio);

mm/damon/ops-common.c

69

folio_set_idle(folio);

mm/damon/ops-common.c

70

folio_put(folio);

mm/damon/ops-common.c

77

struct folio *folio;

mm/damon/ops-common.c

86

folio = damon_get_folio(pfn);

mm/damon/ops-common.c

87

if (!folio)

mm/damon/ops-common.c

94

folio_set_young(folio);

mm/damon/ops-common.c

96

folio_set_idle(folio);

mm/damon/ops-common.c

97

folio_put(folio);

mm/damon/ops-common.h

12

void damon_folio_mkold(struct folio *folio);

mm/damon/ops-common.h

13

bool damon_folio_young(struct folio *folio);

mm/damon/ops-common.h

20

bool damos_folio_filter_match(struct damos_filter *filter, struct folio *folio);

mm/damon/ops-common.h

8

struct folio *damon_get_folio(unsigned long pfn);

mm/damon/paddr.c

122

struct folio *folio)

mm/damon/paddr.c

129

if (!folio) {

mm/damon/paddr.c

133

matched = folio_test_anon(folio);

mm/damon/paddr.c

136

if (!folio) {

mm/damon/paddr.c

141

memcg = folio_memcg_check(folio);

mm/damon/paddr.c

154

static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,

mm/damon/paddr.c

161

if (damon_pa_filter_match(f, folio)) {

mm/damon/paddr.c

180

struct folio *folio;

mm/damon/paddr.c

184

folio = damon_get_folio(PHYS_PFN(pa));

mm/damon/paddr.c

186

if (damon_pa_filter_pass(pa, folio, p))

mm/damon/paddr.c

190

if (folio)

mm/damon/paddr.c

191

folio_put(folio);

mm/damon/paddr.c

199

static bool damos_pa_filter_out(struct damos *scheme, struct folio *folio)

mm/damon/paddr.c

207

if (damos_folio_filter_match(filter, folio))

mm/damon/paddr.c

213

static bool damon_pa_invalid_damos_folio(struct folio *folio, struct damos *s)

mm/damon/paddr.c

215

if (!folio)

mm/damon/paddr.c

217

if (folio == s->last_applied) {

mm/damon/paddr.c

218

folio_put(folio);

mm/damon/paddr.c

232

struct folio *folio = NULL;

mm/damon/paddr.c

251

folio = damon_get_folio(PHYS_PFN(addr));

mm/damon/paddr.c

252

if (damon_pa_invalid_damos_folio(folio, s)) {

mm/damon/paddr.c

257

if (damos_pa_filter_out(s, folio))

mm/damon/paddr.c

260

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

262

folio_clear_referenced(folio);

mm/damon/paddr.c

263

folio_test_clear_young(folio);

mm/damon/paddr.c

264

if (!folio_isolate_lru(folio))

mm/damon/paddr.c

266

if (folio_test_unevictable(folio))

mm/damon/paddr.c

267

folio_putback_lru(folio);

mm/damon/paddr.c

269

list_add(&folio->lru, &folio_list);

mm/damon/paddr.c

271

addr += folio_size(folio);

mm/damon/paddr.c

272

folio_put(folio);

mm/damon/paddr.c

278

s->last_applied = folio;

mm/damon/paddr.c

288

struct folio *folio = NULL;

mm/damon/paddr.c

292

folio = damon_get_folio(PHYS_PFN(addr));

mm/damon/paddr.c

293

if (damon_pa_invalid_damos_folio(folio, s)) {

mm/damon/paddr.c

298

if (damos_pa_filter_out(s, folio))

mm/damon/paddr.c

301

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

304

folio_activate(folio);

mm/damon/paddr.c

306

folio_deactivate(folio);

mm/damon/paddr.c

307

applied += folio_nr_pages(folio);

mm/damon/paddr.c

309

addr += folio_size(folio);

mm/damon/paddr.c

310

folio_put(folio);

mm/damon/paddr.c

312

s->last_applied = folio;

mm/damon/paddr.c

336

struct folio *folio = NULL;

mm/damon/paddr.c

340

folio = damon_get_folio(PHYS_PFN(addr));

mm/damon/paddr.c

341

if (damon_pa_invalid_damos_folio(folio, s)) {

mm/damon/paddr.c

346

if (damos_pa_filter_out(s, folio))

mm/damon/paddr.c

349

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

351

if (!folio_isolate_lru(folio))

mm/damon/paddr.c

353

list_add(&folio->lru, &folio_list);

mm/damon/paddr.c

355

addr += folio_size(folio);

mm/damon/paddr.c

356

folio_put(folio);

mm/damon/paddr.c

360

s->last_applied = folio;

mm/damon/paddr.c

369

struct folio *folio = NULL;

mm/damon/paddr.c

376

folio = damon_get_folio(PHYS_PFN(addr));

mm/damon/paddr.c

377

if (damon_pa_invalid_damos_folio(folio, s)) {

mm/damon/paddr.c

382

if (!damos_pa_filter_out(s, folio))

mm/damon/paddr.c

383

*sz_filter_passed += folio_size(folio) / addr_unit;

mm/damon/paddr.c

384

addr += folio_size(folio);

mm/damon/paddr.c

385

folio_put(folio);

mm/damon/paddr.c

387

s->last_applied = folio;

mm/damon/paddr.c

40

struct folio *folio = damon_get_folio(PHYS_PFN(paddr));

mm/damon/paddr.c

42

if (!folio)

mm/damon/paddr.c

45

damon_folio_mkold(folio);

mm/damon/paddr.c

46

folio_put(folio);

mm/damon/paddr.c

70

struct folio *folio = damon_get_folio(PHYS_PFN(paddr));

mm/damon/paddr.c

73

if (!folio)

mm/damon/paddr.c

76

accessed = damon_folio_young(folio);

mm/damon/paddr.c

77

*folio_sz = folio_size(folio);

mm/damon/paddr.c

78

folio_put(folio);

mm/damon/vaddr.c

300

struct folio *folio = pfn_folio(pte_pfn(entry));

mm/damon/vaddr.c

303

folio_get(folio);

mm/damon/vaddr.c

316

folio_set_young(folio);

mm/damon/vaddr.c

318

folio_set_idle(folio);

mm/damon/vaddr.c

319

folio_put(folio);

mm/damon/vaddr.c

396

struct folio *folio;

mm/damon/vaddr.c

406

folio = vm_normal_folio_pmd(walk->vma, addr, pmde);

mm/damon/vaddr.c

407

if (!folio)

mm/damon/vaddr.c

409

if (pmd_young(pmde) || !folio_test_idle(folio) ||

mm/damon/vaddr.c

426

folio = vm_normal_folio(walk->vma, addr, ptent);

mm/damon/vaddr.c

427

if (!folio)

mm/damon/vaddr.c

429

if (pte_young(ptent) || !folio_test_idle(folio) ||

mm/damon/vaddr.c

432

*priv->folio_sz = folio_size(folio);

mm/damon/vaddr.c

445

struct folio *folio;

mm/damon/vaddr.c

454

folio = pfn_folio(pte_pfn(entry));

mm/damon/vaddr.c

455

folio_get(folio);

mm/damon/vaddr.c

457

if (pte_young(entry) || !folio_test_idle(folio) ||

mm/damon/vaddr.c

462

folio_put(folio);

mm/damon/vaddr.c

546

struct folio *folio, struct vm_area_struct *vma,

mm/damon/vaddr.c

556

young = young || !folio_test_idle(folio) ||

mm/damon/vaddr.c

567

static bool damos_va_filter_out(struct damos *scheme, struct folio *folio,

mm/damon/vaddr.c

585

matched = damos_va_filter_young_match(filter, folio,

mm/damon/vaddr.c

588

matched = damos_folio_filter_match(filter, folio);

mm/damon/vaddr.c

607

static void damos_va_migrate_dests_add(struct folio *folio,

mm/damon/vaddr.c

627

order = folio_order(folio);

mm/damon/vaddr.c

646

if (folio_nid(folio) == dests->node_id_arr[i])

mm/damon/vaddr.c

650

if (!folio_isolate_lru(folio))

mm/damon/vaddr.c

653

list_add(&folio->lru, &migration_lists[i]);

mm/damon/vaddr.c

663

struct folio *folio;

mm/damon/vaddr.c

675

folio = vm_normal_folio_pmd(walk->vma, addr, pmde);

mm/damon/vaddr.c

676

if (!folio)

mm/damon/vaddr.c

678

if (damos_va_filter_out(s, folio, walk->vma, addr, NULL, pmd))

mm/damon/vaddr.c

680

damos_va_migrate_dests_add(folio, walk->vma, addr, dests,

mm/damon/vaddr.c

698

folio = vm_normal_folio(walk->vma, addr, ptent);

mm/damon/vaddr.c

699

if (!folio)

mm/damon/vaddr.c

701

if (damos_va_filter_out(s, folio, walk->vma, addr, pte, NULL))

mm/damon/vaddr.c

703

damos_va_migrate_dests_add(folio, walk->vma, addr, dests,

mm/damon/vaddr.c

705

nr = folio_nr_pages(folio);

mm/damon/vaddr.c

810

static inline bool damos_va_invalid_folio(struct folio *folio,

mm/damon/vaddr.c

813

return !folio || folio == s->last_applied;

mm/damon/vaddr.c

823

struct folio *folio;

mm/damon/vaddr.c

836

folio = vm_normal_folio_pmd(vma, addr, pmde);

mm/damon/vaddr.c

838

if (damos_va_invalid_folio(folio, s))

mm/damon/vaddr.c

841

if (!damos_va_filter_out(s, folio, vma, addr, NULL, pmd))

mm/damon/vaddr.c

842

*sz_filter_passed += folio_size(folio);

mm/damon/vaddr.c

843

s->last_applied = folio;

mm/damon/vaddr.c

861

folio = vm_normal_folio(vma, addr, ptent);

mm/damon/vaddr.c

863

if (damos_va_invalid_folio(folio, s))

mm/damon/vaddr.c

866

if (!damos_va_filter_out(s, folio, vma, addr, pte, NULL))

mm/damon/vaddr.c

867

*sz_filter_passed += folio_size(folio);

mm/damon/vaddr.c

868

nr = folio_nr_pages(folio);

mm/damon/vaddr.c

869

s->last_applied = folio;

mm/debug.c

101

if (folio_test_ksm(folio))

mm/debug.c

103

else if (folio_test_anon(folio))

mm/debug.c

115

pr_warn("%sflags: %pGp%s\n", type, &folio->flags,

mm/debug.c

116

is_migrate_cma_folio(folio, pfn) ? " CMA" : "");

mm/debug.c

117

if (page_has_type(&folio->page))

mm/debug.c

118

pr_warn("page_type: %x(%s)\n", folio->page.page_type >> 24,

mm/debug.c

119

page_type_name(folio->page.page_type));

mm/debug.c

124

if (folio_test_large(folio))

mm/debug.c

126

sizeof(unsigned long), folio,

mm/debug.c

70

static void __dump_folio(const struct folio *folio, const struct page *page,

mm/debug.c

73

struct address_space *mapping = folio_mapping(folio);

mm/debug.c

81

folio_ref_count(folio), mapcount, mapping,

mm/debug.c

82

folio->index + idx, pfn);

mm/debug.c

83

if (folio_test_large(folio)) {

mm/debug.c

86

if (folio_has_pincount(folio))

mm/debug.c

87

pincount = atomic_read(&folio->_pincount);

mm/debug.c

90

folio_order(folio),

mm/debug.c

91

folio_mapcount(folio),

mm/debug.c

92

folio_entire_mapcount(folio),

mm/debug.c

93

folio_nr_pages_mapped(folio),

mm/debug.c

98

if (folio->memcg_data)

mm/debug.c

99

pr_warn("memcg:%lx\n", folio->memcg_data);

mm/filemap.c

1008

folio = __folio_alloc_node_noprof(gfp, order, n);

mm/filemap.c

1009

} while (!folio && read_mems_allowed_retry(cpuset_mems_cookie));

mm/filemap.c

1011

return folio;

mm/filemap.c

1070

static wait_queue_head_t *folio_waitqueue(struct folio *folio)

mm/filemap.c

1072

return &folio_wait_table[hash_ptr(folio, PAGE_WAIT_TABLE_BITS)];

mm/filemap.c

1149

if (test_bit(key->bit_nr, &key->folio->flags.f))

mm/filemap.c

1152

if (test_and_set_bit(key->bit_nr, &key->folio->flags.f))

mm/filemap.c

1184

static void folio_wake_bit(struct folio *folio, int bit_nr)

mm/filemap.c

1186

wait_queue_head_t *q = folio_waitqueue(folio);

mm/filemap.c

1190

key.folio = folio;

mm/filemap.c

1207

folio_clear_waiters(folio);

mm/filemap.c

1231

static inline bool folio_trylock_flag(struct folio *folio, int bit_nr,

mm/filemap.c

1235

if (test_and_set_bit(bit_nr, &folio->flags.f))

mm/filemap.c

1237

} else if (test_bit(bit_nr, &folio->flags.f))

mm/filemap.c

1244

static inline int folio_wait_bit_common(struct folio *folio, int bit_nr,

mm/filemap.c

1247

wait_queue_head_t *q = folio_waitqueue(folio);

mm/filemap.c

1256

!folio_test_uptodate(folio) && folio_test_workingset(folio)) {

mm/filemap.c

1264

wait_page.folio = folio;

mm/filemap.c

1290

folio_set_waiters(folio);

mm/filemap.c

1291

if (!folio_trylock_flag(folio, bit_nr, wait))

mm/filemap.c

130

struct folio *folio, void *shadow)

mm/filemap.c

1304

folio_put(folio);

mm/filemap.c

132

XA_STATE(xas, &mapping->i_pages, folio->index);

mm/filemap.c

1341

if (unlikely(test_and_set_bit(bit_nr, folio_flags(folio, 0))))

mm/filemap.c

137

xas_set_order(&xas, folio->index, folio_order(folio));

mm/filemap.c

138

nr = folio_nr_pages(folio);

mm/filemap.c

140

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/filemap.c

1408

struct folio *folio = softleaf_to_folio(entry);

mm/filemap.c

1410

q = folio_waitqueue(folio);

mm/filemap.c

1411

if (!folio_test_uptodate(folio) && folio_test_workingset(folio)) {

mm/filemap.c

1419

wait_page.folio = folio;

mm/filemap.c

1424

folio_set_waiters(folio);

mm/filemap.c

1425

if (!folio_trylock_flag(folio, PG_locked, wait))

mm/filemap.c

145

folio->mapping = NULL;

mm/filemap.c

1465

void folio_wait_bit(struct folio *folio, int bit_nr)

mm/filemap.c

1467

folio_wait_bit_common(folio, bit_nr, TASK_UNINTERRUPTIBLE, SHARED);

mm/filemap.c

1471

int folio_wait_bit_killable(struct folio *folio, int bit_nr)

mm/filemap.c

1473

return folio_wait_bit_common(folio, bit_nr, TASK_KILLABLE, SHARED);

mm/filemap.c

1490

static int folio_put_wait_locked(struct folio *folio, int state)

mm/filemap.c

1492

return folio_wait_bit_common(folio, PG_locked, state, DROP);

mm/filemap.c

1504

void folio_unlock(struct folio *folio)

mm/filemap.c

1509

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/filemap.c

151

struct folio *folio)

mm/filemap.c

1510

if (folio_xor_flags_has_waiters(folio, 1 << PG_locked))

mm/filemap.c

1511

folio_wake_bit(folio, PG_locked);

mm/filemap.c

1529

void folio_end_read(struct folio *folio, bool success)

mm/filemap.c

1535

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/filemap.c

1536

VM_BUG_ON_FOLIO(success && folio_test_uptodate(folio), folio);

mm/filemap.c

1540

if (folio_xor_flags_has_waiters(folio, mask))

mm/filemap.c

1541

folio_wake_bit(folio, PG_locked);

mm/filemap.c

155

VM_BUG_ON_FOLIO(folio_mapped(folio), folio);

mm/filemap.c

1556

void folio_end_private_2(struct folio *folio)

mm/filemap.c

1558

VM_BUG_ON_FOLIO(!folio_test_private_2(folio), folio);

mm/filemap.c

1559

clear_bit_unlock(PG_private_2, folio_flags(folio, 0));

mm/filemap.c

156

if (!IS_ENABLED(CONFIG_DEBUG_VM) && unlikely(folio_mapped(folio))) {

mm/filemap.c

1560

folio_wake_bit(folio, PG_private_2);

mm/filemap.c

1561

folio_put(folio);

mm/filemap.c

1571

void folio_wait_private_2(struct folio *folio)

mm/filemap.c

1573

while (folio_test_private_2(folio))

mm/filemap.c

1574

folio_wait_bit(folio, PG_private_2);

mm/filemap.c

158

current->comm, folio_pfn(folio));

mm/filemap.c

1589

int folio_wait_private_2_killable(struct folio *folio)

mm/filemap.c

159

dump_page(&folio->page, "still mapped when deleted");

mm/filemap.c

1593

while (folio_test_private_2(folio)) {

mm/filemap.c

1594

ret = folio_wait_bit_killable(folio, PG_private_2);

mm/filemap.c

1603

static void filemap_end_dropbehind(struct folio *folio)

mm/filemap.c

1605

struct address_space *mapping = folio->mapping;

mm/filemap.c

1607

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/filemap.c

1609

if (folio_test_writeback(folio) || folio_test_dirty(folio))

mm/filemap.c

1611

if (!folio_test_clear_dropbehind(folio))

mm/filemap.c

1614

folio_unmap_invalidate(mapping, folio, 0);

mm/filemap.c

1622

void folio_end_dropbehind(struct folio *folio)

mm/filemap.c

1624

if (!folio_test_dropbehind(folio))

mm/filemap.c

163

if (mapping_exiting(mapping) && !folio_test_large(folio)) {

mm/filemap.c

1634

if (in_task() && folio_trylock(folio)) {

mm/filemap.c

1635

filemap_end_dropbehind(folio);

mm/filemap.c

1636

folio_unlock(folio);

mm/filemap.c

164

int mapcount = folio_mapcount(folio);

mm/filemap.c

1650

void folio_end_writeback_no_dropbehind(struct folio *folio)

mm/filemap.c

1652

VM_BUG_ON_FOLIO(!folio_test_writeback(folio), folio);

mm/filemap.c

166

if (folio_ref_count(folio) >= mapcount + 2) {

mm/filemap.c

1661

if (folio_test_reclaim(folio)) {

mm/filemap.c

1662

folio_clear_reclaim(folio);

mm/filemap.c

1663

folio_rotate_reclaimable(folio);

mm/filemap.c

1666

if (__folio_end_writeback(folio))

mm/filemap.c

1667

folio_wake_bit(folio, PG_writeback);

mm/filemap.c

1669

acct_reclaim_writeback(folio);

mm/filemap.c

1681

void folio_end_writeback(struct folio *folio)

mm/filemap.c

1683

VM_BUG_ON_FOLIO(!folio_test_writeback(folio), folio);

mm/filemap.c

1691

folio_get(folio);

mm/filemap.c

1692

folio_end_writeback_no_dropbehind(folio);

mm/filemap.c

1693

folio_end_dropbehind(folio);

mm/filemap.c

1694

folio_put(folio);

mm/filemap.c

1702

void __folio_lock(struct folio *folio)

mm/filemap.c

1704

folio_wait_bit_common(folio, PG_locked, TASK_UNINTERRUPTIBLE,

mm/filemap.c

1709

int __folio_lock_killable(struct folio *folio)

mm/filemap.c

1711

return folio_wait_bit_common(folio, PG_locked, TASK_KILLABLE,

mm/filemap.c

1716

static int __folio_lock_async(struct folio *folio, struct wait_page_queue *wait)

mm/filemap.c

1718

struct wait_queue_head *q = folio_waitqueue(folio);

mm/filemap.c

1721

wait->folio = folio;

mm/filemap.c

1726

folio_set_waiters(folio);

mm/filemap.c

1727

ret = !folio_trylock(folio);

mm/filemap.c

173

atomic_set(&folio->_mapcount, -1);

mm/filemap.c

174

folio_ref_sub(folio, mapcount);

mm/filemap.c

1753

vm_fault_t __folio_lock_or_retry(struct folio *folio, struct vm_fault *vmf)

mm/filemap.c

1767

folio_wait_locked_killable(folio);

mm/filemap.c

1769

folio_wait_locked(folio);

mm/filemap.c

1775

ret = __folio_lock_killable(folio);

mm/filemap.c

1781

__folio_lock(folio);

mm/filemap.c

180

if (folio_test_hugetlb(folio))

mm/filemap.c

183

nr = folio_nr_pages(folio);

mm/filemap.c

185

lruvec_stat_mod_folio(folio, NR_FILE_PAGES, -nr);

mm/filemap.c

186

if (folio_test_swapbacked(folio)) {

mm/filemap.c

187

lruvec_stat_mod_folio(folio, NR_SHMEM, -nr);

mm/filemap.c

188

if (folio_test_pmd_mappable(folio))

mm/filemap.c

189

lruvec_stat_mod_folio(folio, NR_SHMEM_THPS, -nr);

mm/filemap.c

1896

struct folio *folio;

mm/filemap.c

190

} else if (folio_test_pmd_mappable(folio)) {

mm/filemap.c

1901

folio = xas_load(&xas);

mm/filemap.c

1902

if (xas_retry(&xas, folio))

mm/filemap.c

1908

if (!folio || xa_is_value(folio))

mm/filemap.c

191

lruvec_stat_mod_folio(folio, NR_FILE_THPS, -nr);

mm/filemap.c

1911

if (!folio_try_get(folio))

mm/filemap.c

1914

if (unlikely(folio != xas_reload(&xas))) {

mm/filemap.c

1915

folio_put(folio);

mm/filemap.c

1921

return folio;

mm/filemap.c

193

if (test_bit(AS_KERNEL_FILE, &folio->mapping->flags))

mm/filemap.c

194

mod_node_page_state(folio_pgdat(folio),

mm/filemap.c

1941

struct folio *__filemap_get_folio_mpol(struct address_space *mapping,

mm/filemap.c

1944

struct folio *folio;

mm/filemap.c

1947

folio = filemap_get_entry(mapping, index);

mm/filemap.c

1948

if (xa_is_value(folio))

mm/filemap.c

1949

folio = NULL;

mm/filemap.c

1950

if (!folio)

mm/filemap.c

1955

if (!folio_trylock(folio)) {

mm/filemap.c

1956

folio_put(folio);

mm/filemap.c

1960

folio_lock(folio);

mm/filemap.c

1964

if (unlikely(folio->mapping != mapping)) {

mm/filemap.c

1965

folio_unlock(folio);

mm/filemap.c

1966

folio_put(folio);

mm/filemap.c

1969

VM_BUG_ON_FOLIO(!folio_contains(folio, index), folio);

mm/filemap.c

1973

folio_mark_accessed(folio);

mm/filemap.c

1976

if (folio_test_idle(folio))

mm/filemap.c

1977

folio_clear_idle(folio);

mm/filemap.c

1981

folio_wait_stable(folio);

mm/filemap.c

1983

if (!folio && (fgp_flags & FGP_CREAT)) {

mm/filemap.c

2012

folio = filemap_alloc_folio(alloc_gfp, order, policy);

mm/filemap.c

2013

if (!folio)

mm/filemap.c

2018

__folio_set_referenced(folio);

mm/filemap.c

2020

__folio_set_dropbehind(folio);

mm/filemap.c

2022

err = filemap_add_folio(mapping, folio, index, gfp);

mm/filemap.c

2025

folio_put(folio);

mm/filemap.c

2026

folio = NULL;

mm/filemap.c

2048

if (folio && (fgp_flags & FGP_FOR_MMAP))

mm/filemap.c

2049

folio_unlock(folio);

mm/filemap.c

2052

if (!folio)

mm/filemap.c

2055

if (!(fgp_flags & FGP_DONTCACHE) && folio_test_clear_dropbehind(folio)) {

mm/filemap.c

2056

if (folio_test_dirty(folio) &&

mm/filemap.c

2061

long nr = folio_nr_pages(folio);

mm/filemap.c

2068

return folio;

mm/filemap.c

2072

static inline struct folio *find_get_entry(struct xa_state *xas, pgoff_t max,

mm/filemap.c

2075

struct folio *folio;

mm/filemap.c

2079

folio = xas_find(xas, max);

mm/filemap.c

2081

folio = xas_find_marked(xas, max, mark);

mm/filemap.c

2083

if (xas_retry(xas, folio))

mm/filemap.c

2090

if (!folio || xa_is_value(folio))

mm/filemap.c

2091

return folio;

mm/filemap.c

2093

if (!folio_try_get(folio))

mm/filemap.c

2096

if (unlikely(folio != xas_reload(xas))) {

mm/filemap.c

2097

folio_put(folio);

mm/filemap.c

2101

return folio;

mm/filemap.c

211

if (WARN_ON_ONCE(folio_test_dirty(folio) &&

mm/filemap.c

213

folio_account_cleaned(folio, inode_to_wb(mapping->host));

mm/filemap.c

2131

struct folio *folio;

mm/filemap.c

2134

while ((folio = find_get_entry(&xas, end, XA_PRESENT)) != NULL) {

mm/filemap.c

2136

if (!folio_batch_add(fbatch, folio))

mm/filemap.c

2144

folio = fbatch->folios[idx];

mm/filemap.c

2145

if (!xa_is_value(folio))

mm/filemap.c

2146

nr = folio_nr_pages(folio);

mm/filemap.c

2180

struct folio *folio;

mm/filemap.c

2183

while ((folio = find_get_entry(&xas, end, XA_PRESENT))) {

mm/filemap.c

2187

if (!xa_is_value(folio)) {

mm/filemap.c

2188

nr = folio_nr_pages(folio);

mm/filemap.c

2189

base = folio->index;

mm/filemap.c

2196

if (!folio_trylock(folio))

mm/filemap.c

2198

if (folio->mapping != mapping ||

mm/filemap.c

2199

folio_test_writeback(folio))

mm/filemap.c

2201

VM_BUG_ON_FOLIO(!folio_contains(folio, xas.xa_index),

mm/filemap.c

2202

folio);

mm/filemap.c

221

void __filemap_remove_folio(struct folio *folio, void *shadow)

mm/filemap.c

2217

if (!folio_batch_add(fbatch, folio))

mm/filemap.c

2221

folio_unlock(folio);

mm/filemap.c

2223

folio_put(folio);

mm/filemap.c

223

struct address_space *mapping = folio->mapping;

mm/filemap.c

225

trace_mm_filemap_delete_from_page_cache(folio);

mm/filemap.c

226

filemap_unaccount_folio(mapping, folio);

mm/filemap.c

227

page_cache_delete(mapping, folio, shadow);

mm/filemap.c

2271

struct folio *folio;

mm/filemap.c

2275

for (folio = xas_load(&xas); folio && xas.xa_index <= end;

mm/filemap.c

2276

folio = xas_next(&xas)) {

mm/filemap.c

2277

if (xas_retry(&xas, folio))

mm/filemap.c

2283

if (xa_is_value(folio))

mm/filemap.c

2287

if (xa_is_sibling(folio))

mm/filemap.c

2290

if (!folio_try_get(folio))

mm/filemap.c

2293

if (unlikely(folio != xas_reload(&xas)))

mm/filemap.c

2296

if (!folio_batch_add(fbatch, folio)) {

mm/filemap.c

2297

*start = folio_next_index(folio);

mm/filemap.c

2300

xas_advance(&xas, folio_next_index(folio) - 1);

mm/filemap.c

2303

folio_put(folio);

mm/filemap.c

231

struct folio *folio)

mm/filemap.c

2313

folio = fbatch->folios[nr - 1];

mm/filemap.c

2314

*start = folio_next_index(folio);

mm/filemap.c

233

void (*free_folio)(struct folio *);

mm/filemap.c

2345

struct folio *folio;

mm/filemap.c

2348

while ((folio = find_get_entry(&xas, end, tag)) != NULL) {

mm/filemap.c

2354

if (xa_is_value(folio))

mm/filemap.c

2356

if (!folio_batch_add(fbatch, folio)) {

mm/filemap.c

2357

*start = folio_next_index(folio);

mm/filemap.c

237

free_folio(folio);

mm/filemap.c

239

folio_put_refs(folio, folio_nr_pages(folio));

mm/filemap.c

2399

struct folio *folio;

mm/filemap.c

2402

while ((folio = find_get_entry(&xas, end, XA_PRESENT)) != NULL) {

mm/filemap.c

2403

if (xa_is_value(folio))

mm/filemap.c

2405

if (folio_trylock(folio)) {

mm/filemap.c

2406

bool clean = !folio_test_dirty(folio) &&

mm/filemap.c

2407

!folio_test_writeback(folio);

mm/filemap.c

2408

folio_unlock(folio);

mm/filemap.c

2410

folio_put(folio);

mm/filemap.c

2414

if (!folio_batch_add(fbatch, folio)) {

mm/filemap.c

2415

*start = folio_next_index(folio);

mm/filemap.c

2468

struct folio *folio;

mm/filemap.c

2471

for (folio = xas_load(&xas); folio; folio = xas_next(&xas)) {

mm/filemap.c

2472

if (xas_retry(&xas, folio))

mm/filemap.c

2474

if (xas.xa_index > max || xa_is_value(folio))

mm/filemap.c

2476

if (xa_is_sibling(folio))

mm/filemap.c

2478

if (!folio_try_get(folio))

mm/filemap.c

2481

if (unlikely(folio != xas_reload(&xas)))

mm/filemap.c

2484

if (!folio_batch_add(fbatch, folio))

mm/filemap.c

2486

if (!folio_test_uptodate(folio))

mm/filemap.c

2488

if (folio_test_readahead(folio))

mm/filemap.c

2490

xas_advance(&xas, folio_next_index(folio) - 1);

mm/filemap.c

2493

folio_put(folio);

mm/filemap.c

250

void filemap_remove_folio(struct folio *folio)

mm/filemap.c

2501

struct folio *folio)

mm/filemap.c

2503

bool workingset = folio_test_workingset(folio);

mm/filemap.c

2510

error = filler(file, folio);

mm/filemap.c

2516

error = folio_wait_locked_killable(folio);

mm/filemap.c

2519

if (folio_test_uptodate(folio))

mm/filemap.c

252

struct address_space *mapping = folio->mapping;

mm/filemap.c

2527

loff_t pos, size_t count, struct folio *folio,

mm/filemap.c

2530

if (folio_test_uptodate(folio))

mm/filemap.c

2537

if (mapping->host->i_blkbits >= folio_shift(folio))

mm/filemap.c

254

BUG_ON(!folio_test_locked(folio));

mm/filemap.c

2540

if (folio_pos(folio) > pos) {

mm/filemap.c

2541

count -= folio_pos(folio) - pos;

mm/filemap.c

2544

pos -= folio_pos(folio);

mm/filemap.c

2547

if (pos == 0 && count >= folio_size(folio))

mm/filemap.c

2550

return mapping->a_ops->is_partially_uptodate(folio, pos, count);

mm/filemap.c

2555

struct folio *folio, bool need_uptodate)

mm/filemap.c

2566

if (!folio_trylock(folio)) {

mm/filemap.c

257

__filemap_remove_folio(folio, NULL);

mm/filemap.c

2576

folio_put_wait_locked(folio, TASK_KILLABLE);

mm/filemap.c

2579

error = __folio_lock_async(folio, iocb->ki_waitq);

mm/filemap.c

2585

if (!folio->mapping)

mm/filemap.c

2589

if (filemap_range_uptodate(mapping, iocb->ki_pos, count, folio,

mm/filemap.c

2598

folio);

mm/filemap.c

2601

folio_unlock(folio);

mm/filemap.c

2605

folio_put(folio);

mm/filemap.c

2612

struct folio *folio;

mm/filemap.c

2620

folio = filemap_alloc_folio(mapping_gfp_mask(mapping), min_order, NULL);

mm/filemap.c

2621

if (!folio)

mm/filemap.c

2624

__folio_set_dropbehind(folio);

mm/filemap.c

263

filemap_free_folio(mapping, folio);

mm/filemap.c

2641

error = filemap_add_folio(mapping, folio, index,

mm/filemap.c

2649

folio);

mm/filemap.c

2654

folio_batch_add(fbatch, folio);

mm/filemap.c

2658

folio_put(folio);

mm/filemap.c

2663

struct address_space *mapping, struct folio *folio,

mm/filemap.c

2666

DEFINE_READAHEAD(ractl, file, &file->f_ra, mapping, folio->index);

mm/filemap.c

2672

page_cache_async_ra(&ractl, folio, last_index - folio->index);

mm/filemap.c

2683

struct folio *folio;

mm/filemap.c

2716

folio = fbatch->folios[folio_batch_count(fbatch) - 1];

mm/filemap.c

2717

if (folio_test_readahead(folio)) {

mm/filemap.c

2718

err = filemap_readahead(iocb, filp, mapping, folio, last_index);

mm/filemap.c

2722

if (!folio_test_uptodate(folio)) {

mm/filemap.c

2727

err = filemap_update_page(iocb, mapping, count, folio,

mm/filemap.c

2737

folio_put(folio);

mm/filemap.c

2745

static inline bool pos_same_folio(loff_t pos1, loff_t pos2, struct folio *folio)

mm/filemap.c

2747

unsigned int shift = folio_shift(folio);

mm/filemap.c

2752

static void filemap_end_dropbehind_read(struct folio *folio)

mm/filemap.c

2754

if (!folio_test_dropbehind(folio))

mm/filemap.c

2756

if (folio_test_writeback(folio) || folio_test_dirty(folio))

mm/filemap.c

2758

if (folio_trylock(folio)) {

mm/filemap.c

2759

filemap_end_dropbehind(folio);

mm/filemap.c

2760

folio_unlock(folio);

mm/filemap.c

2846

struct folio *folio = fbatch.folios[i];

mm/filemap.c

2847

size_t fsize = folio_size(folio);

mm/filemap.c

285

struct folio *folio;

mm/filemap.c

2853

if (end_offset < folio_pos(folio))

mm/filemap.c

2856

folio_mark_accessed(folio);

mm/filemap.c

2863

flush_dcache_folio(folio);

mm/filemap.c

2865

copied = copy_folio_to_iter(folio, offset, bytes, iter);

mm/filemap.c

2878

struct folio *folio = fbatch.folios[i];

mm/filemap.c

288

xas_for_each(&xas, folio, ULONG_MAX) {

mm/filemap.c

2880

filemap_end_dropbehind_read(folio);

mm/filemap.c

2881

folio_put(folio);

mm/filemap.c

293

if (xa_is_value(folio))

mm/filemap.c

3014

struct folio *folio, loff_t fpos, size_t size)

mm/filemap.c

3017

size_t spliced = 0, offset = offset_in_folio(folio, fpos);

mm/filemap.c

3019

page = folio_page(folio, offset / PAGE_SIZE);

mm/filemap.c

302

if (folio != fbatch->folios[i]) {

mm/filemap.c

3020

size = min(size, folio_size(folio) - offset);

mm/filemap.c

303

VM_BUG_ON_FOLIO(folio->index >

mm/filemap.c

3033

folio_get(folio);

mm/filemap.c

304

fbatch->folios[i]->index, folio);

mm/filemap.c

308

WARN_ON_ONCE(!folio_test_locked(folio));

mm/filemap.c

310

folio->mapping = NULL;

mm/filemap.c

3117

struct folio *folio = fbatch.folios[i];

mm/filemap.c

3120

if (folio_pos(folio) >= end_offset)

mm/filemap.c

3122

folio_mark_accessed(folio);

mm/filemap.c

3130

flush_dcache_folio(folio);

mm/filemap.c

3133

n = splice_folio_into_pipe(pipe, folio, *ppos, n);

mm/filemap.c

315

total_pages += folio_nr_pages(folio);

mm/filemap.c

3156

struct address_space *mapping, struct folio *folio,

mm/filemap.c

3162

if (xa_is_value(folio) || folio_test_uptodate(folio))

mm/filemap.c

3169

folio_lock(folio);

mm/filemap.c

3170

if (unlikely(folio->mapping != mapping))

mm/filemap.c

3173

offset = offset_in_folio(folio, start) & ~(bsz - 1);

mm/filemap.c

3176

if (ops->is_partially_uptodate(folio, offset, bsz) ==

mm/filemap.c

3181

} while (offset < folio_size(folio));

mm/filemap.c

3183

folio_unlock(folio);

mm/filemap.c

3188

static inline size_t seek_folio_size(struct xa_state *xas, struct folio *folio)

mm/filemap.c

3190

if (xa_is_value(folio))

mm/filemap.c

3192

return folio_size(folio);

mm/filemap.c

3219

struct folio *folio;

mm/filemap.c

3225

while ((folio = find_get_entry(&xas, max, XA_PRESENT))) {

mm/filemap.c

3235

seek_size = seek_folio_size(&xas, folio);

mm/filemap.c

3237

start = folio_seek_hole_data(&xas, mapping, folio, start, pos,

mm/filemap.c

3245

if (!xa_is_value(folio))

mm/filemap.c

3246

folio_put(folio);

mm/filemap.c

3252

if (folio && !xa_is_value(folio))

mm/filemap.c

3253

folio_put(folio);

mm/filemap.c

3273

static int lock_folio_maybe_drop_mmap(struct vm_fault *vmf, struct folio *folio,

mm/filemap.c

3276

if (folio_trylock(folio))

mm/filemap.c

3289

if (__folio_lock_killable(folio)) {

mm/filemap.c

3302

__folio_lock(folio);

mm/filemap.c

331

struct folio *folio = fbatch->folios[i];

mm/filemap.c

333

trace_mm_filemap_delete_from_page_cache(folio);

mm/filemap.c

334

filemap_unaccount_folio(mapping, folio);

mm/filemap.c

3438

struct folio *folio)

mm/filemap.c

3460

if (likely(!folio_test_locked(folio)) &&

mm/filemap.c

3467

if (folio_test_readahead(folio)) {

mm/filemap.c

3469

page_cache_async_ra(&ractl, folio, ra->ra_pages);

mm/filemap.c

3548

struct folio *folio;

mm/filemap.c

3561

folio = filemap_get_folio(mapping, index);

mm/filemap.c

3562

if (likely(!IS_ERR(folio))) {

mm/filemap.c

3568

fpin = do_async_mmap_readahead(vmf, folio);

mm/filemap.c

3569

if (unlikely(!folio_test_uptodate(folio))) {

mm/filemap.c

3592

folio = __filemap_get_folio(mapping, index,

mm/filemap.c

3595

if (IS_ERR(folio)) {

mm/filemap.c

3603

if (!lock_folio_maybe_drop_mmap(vmf, folio, &fpin))

mm/filemap.c

3607

if (unlikely(folio->mapping != mapping)) {

mm/filemap.c

3608

folio_unlock(folio);

mm/filemap.c

3609

folio_put(folio);

mm/filemap.c

3612

VM_BUG_ON_FOLIO(!folio_contains(folio, index), folio);

mm/filemap.c

3619

if (unlikely(!folio_test_uptodate(folio))) {

mm/filemap.c

3627

folio_unlock(folio);

mm/filemap.c

3628

folio_put(folio);

mm/filemap.c

3646

folio_unlock(folio);

mm/filemap.c

3658

folio_unlock(folio);

mm/filemap.c

3659

folio_put(folio);

mm/filemap.c

3663

vmf->page = folio_file_page(folio, index);

mm/filemap.c

3674

error = filemap_read_folio(file, mapping->a_ops->read_folio, folio);

mm/filemap.c

3677

folio_put(folio);

mm/filemap.c

3691

if (!IS_ERR(folio))

mm/filemap.c

3692

folio_put(folio);

mm/filemap.c

3701

static bool filemap_map_pmd(struct vm_fault *vmf, struct folio *folio,

mm/filemap.c

3708

folio_unlock(folio);

mm/filemap.c

3709

folio_put(folio);

mm/filemap.c

3713

if (pmd_none(*vmf->pmd) && folio_test_pmd_mappable(folio)) {

mm/filemap.c

3714

struct page *page = folio_file_page(folio, start);

mm/filemap.c

3715

vm_fault_t ret = do_set_pmd(vmf, folio, page);

mm/filemap.c

3718

folio_unlock(folio);

mm/filemap.c

3729

static struct folio *next_uptodate_folio(struct xa_state *xas,

mm/filemap.c

3732

struct folio *folio = xas_next_entry(xas, end_pgoff);

mm/filemap.c

3736

if (!folio)

mm/filemap.c

3738

if (xas_retry(xas, folio))

mm/filemap.c

3740

if (xa_is_value(folio))

mm/filemap.c

3742

if (!folio_try_get(folio))

mm/filemap.c

3744

if (folio_test_locked(folio))

mm/filemap.c

3747

if (unlikely(folio != xas_reload(xas)))

mm/filemap.c

3749

if (!folio_test_uptodate(folio) || folio_test_readahead(folio))

mm/filemap.c

3751

if (!folio_trylock(folio))

mm/filemap.c

3753

if (folio->mapping != mapping)

mm/filemap.c

3755

if (!folio_test_uptodate(folio))

mm/filemap.c

3760

return folio;

mm/filemap.c

3762

folio_unlock(folio);

mm/filemap.c

3764

folio_put(folio);

mm/filemap.c

3765

} while ((folio = xas_next_entry(xas, end_pgoff)) != NULL);

mm/filemap.c

3775

struct folio *folio, unsigned long start,

mm/filemap.c

3779

struct address_space *mapping = folio->mapping;

mm/filemap.c

3782

struct page *page = folio_page(folio, start);

mm/filemap.c

3796

if ((file_end >= folio_next_index(folio) || shmem_mapping(mapping)) &&

mm/filemap.c

3797

folio_within_vma(folio, vmf->vma) &&

mm/filemap.c

3798

(addr0 & PMD_MASK) == ((addr0 + folio_size(folio) - 1) & PMD_MASK)) {

mm/filemap.c

3802

nr_pages = folio_nr_pages(folio);

mm/filemap.c

3821

set_pte_range(vmf, folio, page, count, addr);

mm/filemap.c

3823

folio_ref_add(folio, count - ref_from_caller);

mm/filemap.c

3837

set_pte_range(vmf, folio, page, count, addr);

mm/filemap.c

3839

folio_ref_add(folio, count - ref_from_caller);

mm/filemap.c

3848

folio_ref_dec(folio);

mm/filemap.c

3854

struct folio *folio, unsigned long addr,

mm/filemap.c

3858

struct page *page = &folio->page;

mm/filemap.c

3874

set_pte_range(vmf, folio, page, 1, addr);

mm/filemap.c

3880

folio_ref_dec(folio);

mm/filemap.c

3893

struct folio *folio;

mm/filemap.c

3907

folio = next_uptodate_folio(&xas, mapping, end_pgoff);

mm/filemap.c

3908

if (!folio)

mm/filemap.c

3918

if ((file_end >= folio_next_index(folio) || shmem_mapping(mapping)) &&

mm/filemap.c

3919

filemap_map_pmd(vmf, folio, start_pgoff)) {

mm/filemap.c

3927

folio_unlock(folio);

mm/filemap.c

3928

folio_put(folio);

mm/filemap.c

3932

folio_type = mm_counter_file(folio);

mm/filemap.c

3940

end = folio_next_index(folio) - 1;

mm/filemap.c

3943

if (!folio_test_large(folio)) {

mm/filemap.c

3944

map_ret = filemap_map_order0_folio(vmf, folio, addr,

mm/filemap.c

3947

unsigned long start = xas.xa_index - folio->index;

mm/filemap.c

3949

map_ret = filemap_map_folio_range(vmf, folio, start,

mm/filemap.c

3968

!folio_test_workingset(folio) &&

mm/filemap.c

3978

folio_unlock(folio);

mm/filemap.c

3979

} while ((folio = next_uptodate_folio(&xas, mapping, end_pgoff)) != NULL);

mm/filemap.c

3993

struct folio *folio = page_folio(vmf->page);

mm/filemap.c

3998

folio_lock(folio);

mm/filemap.c

3999

if (folio->mapping != mapping) {

mm/filemap.c

4000

folio_unlock(folio);

mm/filemap.c

4009

folio_mark_dirty(folio);

mm/filemap.c

4010

folio_wait_stable(folio);

mm/filemap.c

4092

static struct folio *do_read_cache_folio(struct address_space *mapping,

mm/filemap.c

4095

struct folio *folio;

mm/filemap.c

4101

folio = filemap_get_folio(mapping, index);

mm/filemap.c

4102

if (IS_ERR(folio)) {

mm/filemap.c

4103

folio = filemap_alloc_folio(gfp, mapping_min_folio_order(mapping), NULL);

mm/filemap.c

4104

if (!folio)

mm/filemap.c

4107

err = filemap_add_folio(mapping, folio, index, gfp);

mm/filemap.c

4109

folio_put(folio);

mm/filemap.c

4118

if (folio_test_uptodate(folio))

mm/filemap.c

4121

if (!folio_trylock(folio)) {

mm/filemap.c

4122

folio_put_wait_locked(folio, TASK_UNINTERRUPTIBLE);

mm/filemap.c

4127

if (!folio->mapping) {

mm/filemap.c

4128

folio_unlock(folio);

mm/filemap.c

4129

folio_put(folio);

mm/filemap.c

4134

if (folio_test_uptodate(folio)) {

mm/filemap.c

4135

folio_unlock(folio);

mm/filemap.c

4140

err = filemap_read_folio(file, filler, folio);

mm/filemap.c

4142

folio_put(folio);

mm/filemap.c

4149

folio_mark_accessed(folio);

mm/filemap.c

4150

return folio;

mm/filemap.c

4169

struct folio *read_cache_folio(struct address_space *mapping, pgoff_t index,

mm/filemap.c

4194

struct folio *mapping_read_folio_gfp(struct address_space *mapping,

mm/filemap.c

4204

struct folio *folio;

mm/filemap.c

4206

folio = do_read_cache_folio(mapping, index, filler, file, gfp);

mm/filemap.c

4207

if (IS_ERR(folio))

mm/filemap.c

4208

return &folio->page;

mm/filemap.c

4209

return folio_file_page(folio, index);

mm/filemap.c

4341

struct folio *folio;

mm/filemap.c

4359

&folio, &fsdata);

mm/filemap.c

4363

offset = offset_in_folio(folio, pos);

mm/filemap.c

4364

if (bytes > folio_size(folio) - offset)

mm/filemap.c

4365

bytes = folio_size(folio) - offset;

mm/filemap.c

4368

flush_dcache_folio(folio);

mm/filemap.c

4376

copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);

mm/filemap.c

4377

flush_dcache_folio(folio);

mm/filemap.c

4380

folio, fsdata);

mm/filemap.c

4527

bool filemap_release_folio(struct folio *folio, gfp_t gfp)

mm/filemap.c

4529

struct address_space * const mapping = folio->mapping;

mm/filemap.c

4531

BUG_ON(!folio_test_locked(folio));

mm/filemap.c

4532

if (!folio_needs_release(folio))

mm/filemap.c

4534

if (folio_test_writeback(folio))

mm/filemap.c

4538

return mapping->a_ops->release_folio(folio, gfp);

mm/filemap.c

4539

return try_to_free_buffers(folio);

mm/filemap.c

4606

struct folio *folio;

mm/filemap.c

4612

xas_for_each(&xas, folio, last_index) {

mm/filemap.c

4628

if (xas_retry(&xas, folio))

mm/filemap.c

4643

if (xa_is_value(folio)) {

mm/filemap.c

4645

void *shadow = (void *)folio;

mm/filemap.c

4653

swp_entry_t swp = radix_to_swp_entry(folio);

mm/filemap.c

482

struct folio *folio;

mm/filemap.c

491

folio = xas_find(&xas, max);

mm/filemap.c

492

if (xas_retry(&xas, folio))

mm/filemap.c

495

if (xa_is_value(folio))

mm/filemap.c

506

return folio != NULL;

mm/filemap.c

530

struct folio *folio = fbatch.folios[i];

mm/filemap.c

532

folio_wait_writeback(folio);

mm/filemap.c

642

struct folio *folio;

mm/filemap.c

648

xas_for_each(&xas, folio, max) {

mm/filemap.c

649

if (xas_retry(&xas, folio))

mm/filemap.c

651

if (xa_is_value(folio))

mm/filemap.c

653

if (folio_test_dirty(folio) || folio_test_locked(folio) ||

mm/filemap.c

654

folio_test_writeback(folio))

mm/filemap.c

658

return folio != NULL;

mm/filemap.c

811

void replace_page_cache_folio(struct folio *old, struct folio *new)

mm/filemap.c

814

void (*free_folio)(struct folio *) = mapping->a_ops->free_folio;

mm/filemap.c

849

struct folio *folio, pgoff_t index, gfp_t gfp, void **shadowp)

mm/filemap.c

851

XA_STATE_ORDER(xas, &mapping->i_pages, index, folio_order(folio));

mm/filemap.c

854

unsigned int forder = folio_order(folio);

mm/filemap.c

856

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/filemap.c

857

VM_BUG_ON_FOLIO(folio_test_swapbacked(folio), folio);

mm/filemap.c

858

VM_BUG_ON_FOLIO(folio_order(folio) < mapping_min_folio_order(mapping),

mm/filemap.c

859

folio);

mm/filemap.c

862

VM_BUG_ON_FOLIO(index & (folio_nr_pages(folio) - 1), folio);

mm/filemap.c

863

huge = folio_test_hugetlb(folio);

mm/filemap.c

864

nr = folio_nr_pages(folio);

mm/filemap.c

867

folio_ref_add(folio, nr);

mm/filemap.c

868

folio->mapping = mapping;

mm/filemap.c

869

folio->index = xas.xa_index;

mm/filemap.c

915

xas_store(&xas, folio);

mm/filemap.c

923

lruvec_stat_mod_folio(folio, NR_FILE_PAGES, nr);

mm/filemap.c

924

if (folio_test_pmd_mappable(folio))

mm/filemap.c

925

lruvec_stat_mod_folio(folio,

mm/filemap.c

939

trace_mm_filemap_add_to_page_cache(folio);

mm/filemap.c

942

folio->mapping = NULL;

mm/filemap.c

944

folio_put_refs(folio, nr);

mm/filemap.c

949

int filemap_add_folio(struct address_space *mapping, struct folio *folio,

mm/filemap.c

959

ret = mem_cgroup_charge(folio, NULL, gfp);

mm/filemap.c

965

__folio_set_locked(folio);

mm/filemap.c

966

ret = __filemap_add_folio(mapping, folio, index, gfp, &shadow);

mm/filemap.c

968

mem_cgroup_uncharge(folio);

mm/filemap.c

969

__folio_clear_locked(folio);

mm/filemap.c

979

WARN_ON_ONCE(folio_test_active(folio));

mm/filemap.c

981

workingset_refault(folio, shadow);

mm/filemap.c

982

folio_add_lru(folio);

mm/filemap.c

984

mod_node_page_state(folio_pgdat(folio),

mm/filemap.c

986

folio_nr_pages(folio));

mm/filemap.c

993

struct folio *filemap_alloc_folio_noprof(gfp_t gfp, unsigned int order,

mm/filemap.c

997

struct folio *folio;

mm/folio-compat.c

80

struct folio *folio;

mm/folio-compat.c

82

folio = __filemap_get_folio(mapping, index, fgp_flags, gfp);

mm/folio-compat.c

83

if (IS_ERR(folio))

mm/folio-compat.c

85

return folio_file_page(folio, index);

mm/gup.c

102

static void gup_put_folio(struct folio *folio, int refs, unsigned int flags)

mm/gup.c

105

if (is_zero_folio(folio))

mm/gup.c

107

node_stat_mod_folio(folio, NR_FOLL_PIN_RELEASED, refs);

mm/gup.c

108

if (folio_has_pincount(folio))

mm/gup.c

109

atomic_sub(refs, &folio->_pincount);

mm/gup.c

114

folio_put_refs(folio, refs);

mm/gup.c

140

int __must_check try_grab_folio(struct folio *folio, int refs,

mm/gup.c

143

if (WARN_ON_ONCE(folio_ref_count(folio) <= 0))

mm/gup.c

146

if (unlikely(!(flags & FOLL_PCI_P2PDMA) && folio_is_pci_p2pdma(folio)))

mm/gup.c

1478

struct folio *folio = page_folio(page);

mm/gup.c

1484

if (try_grab_folio(folio, page_increm - 1,

mm/gup.c

1490

gup_put_folio(folio, 1, gup_flags);

mm/gup.c

150

folio_ref_add(folio, refs);

mm/gup.c

156

if (is_zero_folio(folio))

mm/gup.c

163

if (folio_has_pincount(folio)) {

mm/gup.c

164

folio_ref_add(folio, refs);

mm/gup.c

165

atomic_add(refs, &folio->_pincount);

mm/gup.c

167

folio_ref_add(folio, refs * GUP_PIN_COUNTING_BIAS);

mm/gup.c

170

node_stat_mod_folio(folio, NR_FOLL_PIN_ACQUIRED, refs);

mm/gup.c

199

void unpin_folio(struct folio *folio)

mm/gup.c

201

gup_put_folio(folio, 1, FOLL_PIN);

mm/gup.c

212

void folio_add_pin(struct folio *folio)

mm/gup.c

214

if (is_zero_folio(folio))

mm/gup.c

2210

struct folio **folios;

mm/gup.c

2217

static struct folio *pofs_get_folio(struct pages_or_folios *pofs, long i)

mm/gup.c

222

if (folio_has_pincount(folio)) {

mm/gup.c

223

WARN_ON_ONCE(atomic_read(&folio->_pincount) < 1);

mm/gup.c

2237

static struct folio *pofs_next_folio(struct folio *folio,

mm/gup.c

224

folio_ref_inc(folio);

mm/gup.c

2242

if (!pofs->has_folios && folio_test_large(folio)) {

mm/gup.c

2243

const unsigned long start_pfn = folio_pfn(folio);

mm/gup.c

2244

const unsigned long end_pfn = start_pfn + folio_nr_pages(folio);

mm/gup.c

225

atomic_inc(&folio->_pincount);

mm/gup.c

227

WARN_ON_ONCE(folio_ref_count(folio) < GUP_PIN_COUNTING_BIAS);

mm/gup.c

2270

struct folio *folio;

mm/gup.c

2274

for (folio = pofs_get_folio(pofs, i); folio;

mm/gup.c

2275

folio = pofs_next_folio(folio, pofs, &i)) {

mm/gup.c

2277

if (folio_is_longterm_pinnable(folio))

mm/gup.c

228

folio_ref_add(folio, GUP_PIN_COUNTING_BIAS);

mm/gup.c

2282

if (folio_is_device_coherent(folio))

mm/gup.c

2285

if (folio_test_hugetlb(folio)) {

mm/gup.c

2286

folio_isolate_hugetlb(folio, movable_folio_list);

mm/gup.c

2290

if (drained == 0 && folio_may_be_lru_cached(folio) &&

mm/gup.c

2291

folio_ref_count(folio) !=

mm/gup.c

2292

folio_expected_ref_count(folio) + 1) {

mm/gup.c

2296

if (drained == 1 && folio_may_be_lru_cached(folio) &&

mm/gup.c

2297

folio_ref_count(folio) !=

mm/gup.c

2298

folio_expected_ref_count(folio) + 1) {

mm/gup.c

2303

if (!folio_isolate_lru(folio))

mm/gup.c

2306

list_add_tail(&folio->lru, movable_folio_list);

mm/gup.c

2307

node_stat_mod_folio(folio,

mm/gup.c

2308

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/gup.c

2309

folio_nr_pages(folio));

mm/gup.c

232

static inline struct folio *gup_folio_range_next(struct page *start,

mm/gup.c

2328

struct folio *folio = pofs_get_folio(pofs, i);

mm/gup.c

2330

if (folio_is_device_coherent(folio)) {

mm/gup.c

2337

folio_get(folio);

mm/gup.c

2338

gup_put_folio(folio, 1, FOLL_PIN);

mm/gup.c

2340

if (migrate_device_coherent_folio(folio)) {

mm/gup.c

2355

unpin_folio(folio);

mm/gup.c

236

struct folio *folio = page_folio(next);

mm/gup.c

239

if (folio_test_large(folio))

mm/gup.c

241

folio_nr_pages(folio) - folio_page_idx(folio, next));

mm/gup.c

2421

struct folio **folios)

mm/gup.c

244

return folio;

mm/gup.c

2455

struct folio **folios)

mm/gup.c

247

static inline struct folio *gup_folio_next(struct page **list,

mm/gup.c

250

struct folio *folio = page_folio(list[i]);

mm/gup.c

254

if (page_folio(list[nr]) != folio)

mm/gup.c

259

return folio;

mm/gup.c

2738

static bool gup_fast_folio_allowed(struct folio *folio, unsigned int flags)

mm/gup.c

2756

if (IS_ENABLED(CONFIG_SECRETMEM) && !folio_test_large(folio))

mm/gup.c

2762

if (WARN_ON_ONCE(folio_test_slab(folio)))

mm/gup.c

2766

if (folio_test_hugetlb(folio))

mm/gup.c

2784

mapping = READ_ONCE(folio->mapping);

mm/gup.c

2842

struct folio *folio;

mm/gup.c

2864

folio = try_grab_folio_fast(page, 1, flags);

mm/gup.c

2865

if (!folio)

mm/gup.c

2870

gup_put_folio(folio, 1, flags);

mm/gup.c

2874

if (!gup_fast_folio_allowed(folio, flags)) {

mm/gup.c

2875

gup_put_folio(folio, 1, flags);

mm/gup.c

288

struct folio *folio;

mm/gup.c

2880

gup_put_folio(folio, 1, flags);

mm/gup.c

2890

if ((flags & FOLL_PIN) && arch_make_folio_accessible(folio)) {

mm/gup.c

2891

gup_put_folio(folio, 1, flags);

mm/gup.c

2894

folio_set_referenced(folio);

mm/gup.c

2929

struct folio *folio;

mm/gup.c

2941

folio = try_grab_folio_fast(page, refs, flags);

mm/gup.c

2942

if (!folio)

mm/gup.c

2946

gup_put_folio(folio, refs, flags);

mm/gup.c

2950

if (!gup_fast_folio_allowed(folio, flags)) {

mm/gup.c

2951

gup_put_folio(folio, refs, flags);

mm/gup.c

2954

if (!pmd_write(orig) && gup_must_unshare(NULL, flags, &folio->page)) {

mm/gup.c

2955

gup_put_folio(folio, refs, flags);

mm/gup.c

2963

folio_set_referenced(folio);

mm/gup.c

2972

struct folio *folio;

mm/gup.c

298

folio = gup_folio_next(pages, npages, i, &nr);

mm/gup.c

2984

folio = try_grab_folio_fast(page, refs, flags);

mm/gup.c

2985

if (!folio)

mm/gup.c

2989

gup_put_folio(folio, refs, flags);

mm/gup.c

2993

if (!gup_fast_folio_allowed(folio, flags)) {

mm/gup.c

2994

gup_put_folio(folio, refs, flags);

mm/gup.c

2998

if (!pud_write(orig) && gup_must_unshare(NULL, flags, &folio->page)) {

mm/gup.c

2999

gup_put_folio(folio, refs, flags);

mm/gup.c

3007

folio_set_referenced(folio);

mm/gup.c

319

if (!folio_test_dirty(folio)) {

mm/gup.c

320

folio_lock(folio);

mm/gup.c

321

folio_mark_dirty(folio);

mm/gup.c

322

folio_unlock(folio);

mm/gup.c

324

gup_put_folio(folio, nr, FOLL_PIN);

mm/gup.c

3437

struct folio **folios, unsigned int max_folios,

mm/gup.c

3443

struct folio *folio = NULL;

mm/gup.c

3487

if (folio) {

mm/gup.c

3488

folio_put(folio);

mm/gup.c

3489

folio = NULL;

mm/gup.c

3493

folio = fbatch.folios[i];

mm/gup.c

3495

if (try_grab_folio(folio, 1, FOLL_PIN)) {

mm/gup.c

3502

*offset = offset_in_folio(folio, start);

mm/gup.c

3504

folios[nr_folios] = folio;

mm/gup.c

3509

folio = NULL;

mm/gup.c

3512

folio = memfd_alloc_folio(memfd, start_idx);

mm/gup.c

3513

if (IS_ERR(folio)) {

mm/gup.c

3514

ret = PTR_ERR(folio);

mm/gup.c

3517

folio = NULL;

mm/gup.c

3551

int folio_add_pins(struct folio *folio, unsigned int pins)

mm/gup.c

3553

VM_WARN_ON_ONCE(!folio_maybe_dma_pinned(folio));

mm/gup.c

3555

return try_grab_folio(folio, pins, FOLL_PIN);

mm/gup.c

358

struct folio *folio;

mm/gup.c

364

folio = gup_folio_range_next(page, npages, i, &nr);

mm/gup.c

365

if (make_dirty && !folio_test_dirty(folio)) {

mm/gup.c

366

folio_lock(folio);

mm/gup.c

367

folio_mark_dirty(folio);

mm/gup.c

368

folio_unlock(folio);

mm/gup.c

370

gup_put_folio(folio, nr, FOLL_PIN);

mm/gup.c

378

struct folio *folio;

mm/gup.c

387

folio = gup_folio_next(pages, npages, i, &nr);

mm/gup.c

388

gup_put_folio(folio, nr, FOLL_PIN);

mm/gup.c

404

struct folio *folio;

mm/gup.c

421

folio = gup_folio_next(pages, npages, i, &nr);

mm/gup.c

422

gup_put_folio(folio, nr, FOLL_PIN);

mm/gup.c

434

void unpin_user_folio(struct folio *folio, unsigned long npages)

mm/gup.c

436

gup_put_folio(folio, npages, FOLL_PIN);

mm/gup.c

449

void unpin_folios(struct folio **folios, unsigned long nfolios)

mm/gup.c

51

struct folio *folio;

mm/gup.c

517

static struct folio *try_grab_folio_fast(struct page *page, int refs,

mm/gup.c

520

struct folio *folio;

mm/gup.c

543

folio = try_get_folio(page, refs);

mm/gup.c

544

if (!folio)

mm/gup.c

553

!folio_is_longterm_pinnable(folio))) {

mm/gup.c

554

folio_put_refs(folio, refs);

mm/gup.c

56

folio = page_folio(page);

mm/gup.c

566

if (folio_has_pincount(folio))

mm/gup.c

567

atomic_add(refs, &folio->_pincount);

mm/gup.c

569

folio_ref_add(folio,

mm/gup.c

578

node_stat_mod_folio(folio, NR_FOLL_PIN_ACQUIRED, refs);

mm/gup.c

580

return folio;

mm/gup.c

59

!folio_test_anon(folio))

mm/gup.c

61

if (!folio_test_large(folio) || folio_test_hugetlb(folio))

mm/gup.c

62

VM_WARN_ON_ONCE_FOLIO(!PageAnonExclusive(&folio->page), folio);

mm/gup.c

65

VM_WARN_ON_ONCE_PAGE(!PageAnonExclusive(&folio->page) &&

mm/gup.c

74

static inline struct folio *try_get_folio(struct page *page, int refs)

mm/gup.c

76

struct folio *folio;

mm/gup.c

79

folio = page_folio(page);

mm/gup.c

80

if (WARN_ON_ONCE(folio_ref_count(folio) < 0))

mm/gup.c

806

struct folio *folio;

mm/gup.c

82

if (unlikely(!folio_ref_try_add(folio, refs)))

mm/gup.c

847

folio = page_folio(page);

mm/gup.c

858

ret = try_grab_folio(folio, 1, flags);

mm/gup.c

870

ret = arch_make_folio_accessible(folio);

mm/gup.c

879

!pte_dirty(pte) && !folio_test_dirty(folio))

mm/gup.c

880

folio_mark_dirty(folio);

mm/gup.c

886

folio_mark_accessed(folio);

mm/gup.c

94

if (unlikely(page_folio(page) != folio)) {

mm/gup.c

95

folio_put_refs(folio, refs);

mm/gup.c

99

return folio;

mm/gup_test.c

44

struct folio *folio;

mm/gup_test.c

51

folio = page_folio(pages[i]);

mm/gup_test.c

53

if (WARN(!folio_maybe_dma_pinned(folio),

mm/gup_test.c

56

dump_page(&folio->page, "gup_test failure");

mm/gup_test.c

59

WARN(!folio_is_longterm_pinnable(folio),

mm/gup_test.c

62

dump_page(&folio->page, "gup_test failure");

mm/huge_memory.c

1187

static inline bool is_transparent_hugepage(const struct folio *folio)

mm/huge_memory.c

1189

if (!folio_test_large(folio))

mm/huge_memory.c

1192

return is_huge_zero_folio(folio) ||

mm/huge_memory.c

1193

folio_test_large_rmappable(folio);

mm/huge_memory.c

1263

static struct folio *vma_alloc_anon_folio_pmd(struct vm_area_struct *vma,

mm/huge_memory.c

1268

struct folio *folio;

mm/huge_memory.c

1270

folio = vma_alloc_folio(gfp, order, vma, addr & HPAGE_PMD_MASK);

mm/huge_memory.c

1272

if (unlikely(!folio)) {

mm/huge_memory.c

1278

VM_BUG_ON_FOLIO(!folio_test_large(folio), folio);

mm/huge_memory.c

1279

if (mem_cgroup_charge(folio, vma->vm_mm, gfp)) {

mm/huge_memory.c

1280

folio_put(folio);

mm/huge_memory.c

1288

if (folio_memcg_alloc_deferred(folio)) {

mm/huge_memory.c

1289

folio_put(folio);

mm/huge_memory.c

1295

folio_throttle_swaprate(folio, gfp);

mm/huge_memory.c

1304

folio_zero_user(folio, addr);

mm/huge_memory.c

1310

__folio_mark_uptodate(folio);

mm/huge_memory.c

1311

return folio;

mm/huge_memory.c

1314

void map_anon_folio_pmd_nopf(struct folio *folio, pmd_t *pmd,

mm/huge_memory.c

1319

entry = folio_mk_pmd(folio, vma->vm_page_prot);

mm/huge_memory.c

1321

folio_add_new_anon_rmap(folio, vma, haddr, RMAP_EXCLUSIVE);

mm/huge_memory.c

1322

folio_add_lru_vma(folio, vma);

mm/huge_memory.c

1325

deferred_split_folio(folio, false);

mm/huge_memory.c

1328

static void map_anon_folio_pmd_pf(struct folio *folio, pmd_t *pmd,

mm/huge_memory.c

1331

map_anon_folio_pmd_nopf(folio, pmd, vma, haddr);

mm/huge_memory.c

1342

struct folio *folio;

mm/huge_memory.c

1346

folio = vma_alloc_anon_folio_pmd(vma, vmf->address);

mm/huge_memory.c

1347

if (unlikely(!folio))

mm/huge_memory.c

1367

folio_put(folio);

mm/huge_memory.c

1374

map_anon_folio_pmd_pf(folio, vmf->pmd, vma, haddr);

mm/huge_memory.c

1385

folio_put(folio);

mm/huge_memory.c

1397

struct folio *folio;

mm/huge_memory.c

1412

folio = page_folio(page);

mm/huge_memory.c

1415

if (folio_trylock(folio)) {

mm/huge_memory.c

1416

folio_get(folio);

mm/huge_memory.c

1419

folio_unlock(folio);

mm/huge_memory.c

1420

folio_put(folio);

mm/huge_memory.c

1466

struct folio *zero_folio)

mm/huge_memory.c

1493

struct folio *zero_folio;

mm/huge_memory.c

1535

struct folio *folio;

mm/huge_memory.c

1561

const unsigned long pfn = fop.is_folio ? folio_pfn(fop.folio) :

mm/huge_memory.c

1578

entry = folio_mk_pmd(fop.folio, vma->vm_page_prot);

mm/huge_memory.c

1580

if (is_huge_zero_folio(fop.folio)) {

mm/huge_memory.c

1583

folio_get(fop.folio);

mm/huge_memory.c

1584

folio_add_file_rmap_pmd(fop.folio, &fop.folio->page, vma);

mm/huge_memory.c

1585

add_mm_counter(mm, mm_counter_file(fop.folio), HPAGE_PMD_NR);

mm/huge_memory.c

1648

vm_fault_t vmf_insert_folio_pmd(struct vm_fault *vmf, struct folio *folio,

mm/huge_memory.c

1654

.folio = folio,

mm/huge_memory.c

1658

if (WARN_ON_ONCE(folio_order(folio) != PMD_ORDER))

mm/huge_memory.c

1685

const unsigned long pfn = fop.is_folio ? folio_pfn(fop.folio) :

mm/huge_memory.c

1700

entry = folio_mk_pud(fop.folio, vma->vm_page_prot);

mm/huge_memory.c

1702

folio_get(fop.folio);

mm/huge_memory.c

1703

folio_add_file_rmap_pud(fop.folio, &fop.folio->page, vma);

mm/huge_memory.c

1704

add_mm_counter(mm, mm_counter_file(fop.folio), HPAGE_PUD_NR);

mm/huge_memory.c

1764

vm_fault_t vmf_insert_folio_pud(struct vm_fault *vmf, struct folio *folio,

mm/huge_memory.c

1770

.folio = folio,

mm/huge_memory.c

1774

if (WARN_ON_ONCE(folio_order(folio) != PUD_ORDER))

mm/huge_memory.c

1815

struct folio *src_folio;

mm/huge_memory.c

1870

struct folio *src_folio;

mm/huge_memory.c

2048

struct folio *folio;

mm/huge_memory.c

2051

folio = vma_alloc_anon_folio_pmd(vma, vmf->address);

mm/huge_memory.c

2052

if (unlikely(!folio))

mm/huge_memory.c

2065

map_anon_folio_pmd_pf(folio, vmf->pmd, vma, haddr);

mm/huge_memory.c

2068

folio_put(folio);

mm/huge_memory.c

2079

struct folio *folio;

mm/huge_memory.c

2105

folio = page_folio(page);

mm/huge_memory.c

2112

if (!folio_trylock(folio)) {

mm/huge_memory.c

2113

folio_get(folio);

mm/huge_memory.c

2115

folio_lock(folio);

mm/huge_memory.c

2119

folio_unlock(folio);

mm/huge_memory.c

2120

folio_put(folio);

mm/huge_memory.c

2123

folio_put(folio);

mm/huge_memory.c

2128

folio_unlock(folio);

mm/huge_memory.c

2137

if (folio_ref_count(folio) >

mm/huge_memory.c

2138

1 + folio_test_swapcache(folio) * folio_nr_pages(folio))

mm/huge_memory.c

2140

if (folio_test_swapcache(folio))

mm/huge_memory.c

2141

folio_free_swap(folio);

mm/huge_memory.c

2142

if (folio_ref_count(folio) == 1) {

mm/huge_memory.c

2145

folio_move_anon_rmap(folio, vma);

mm/huge_memory.c

2147

folio_unlock(folio);

mm/huge_memory.c

2162

folio_unlock(folio);

mm/huge_memory.c

2203

struct folio *folio;

mm/huge_memory.c

2230

folio = vm_normal_folio_pmd(vma, haddr, pmd);

mm/huge_memory.c

2231

if (!folio)

mm/huge_memory.c

2234

nid = folio_nid(folio);

mm/huge_memory.c

2236

target_nid = numa_migrate_check(folio, vmf, haddr, &flags, writable,

mm/huge_memory.c

2240

if (migrate_misplaced_folio_prepare(folio, vma, target_nid)) {

mm/huge_memory.c

2248

if (!migrate_misplaced_folio(folio, target_nid)) {

mm/huge_memory.c

226

struct folio *zero_folio;

mm/huge_memory.c

2285

struct folio *folio;

mm/huge_memory.c

2305

folio = pmd_folio(orig_pmd);

mm/huge_memory.c

2310

if (folio_maybe_mapped_shared(folio))

mm/huge_memory.c

2313

if (!folio_trylock(folio))

mm/huge_memory.c

2321

folio_get(folio);

mm/huge_memory.c

2323

split_folio(folio);

mm/huge_memory.c

2324

folio_unlock(folio);

mm/huge_memory.c

2325

folio_put(folio);

mm/huge_memory.c

2329

if (folio_test_dirty(folio))

mm/huge_memory.c

2330

folio_clear_dirty(folio);

mm/huge_memory.c

2331

folio_unlock(folio);

mm/huge_memory.c

2342

folio_mark_lazyfree(folio);

mm/huge_memory.c

2360

pmd_t pmdval, struct folio *folio, bool is_present)

mm/huge_memory.c

2362

const bool is_device_private = folio_is_device_private(folio);

mm/huge_memory.c

2366

folio_remove_rmap_pmd(folio, &folio->page, vma);

mm/huge_memory.c

2368

if (folio_test_anon(folio)) {

mm/huge_memory.c

2371

add_mm_counter(mm, mm_counter_file(folio),

mm/huge_memory.c

2376

folio_mark_accessed(folio);

mm/huge_memory.c

2381

folio_put(folio);

mm/huge_memory.c

2384

static struct folio *normal_or_softleaf_folio_pmd(struct vm_area_struct *vma,

mm/huge_memory.c

2396

struct folio *folio)

mm/huge_memory.c

2413

return folio && folio_test_anon(folio);

mm/huge_memory.c

2429

struct folio *folio = NULL;

mm/huge_memory.c

2452

folio = normal_or_softleaf_folio_pmd(vma, addr, orig_pmd, is_present);

mm/huge_memory.c

2453

has_deposit = has_deposited_pgtable(vma, orig_pmd, folio);

mm/huge_memory.c

2454

if (folio)

mm/huge_memory.c

2455

zap_huge_pmd_folio(mm, vma, orig_pmd, folio, is_present);

mm/huge_memory.c

2460

if (is_present && folio)

mm/huge_memory.c

2461

tlb_remove_page_size(tlb, &folio->page, HPAGE_PMD_SIZE);

mm/huge_memory.c

2560

const struct folio *folio = softleaf_to_folio(entry);

mm/huge_memory.c

2569

if (folio_test_anon(folio))

mm/huge_memory.c

264

struct folio *mm_get_huge_zero_folio(struct mm_struct *mm)

mm/huge_memory.c

2754

struct folio *src_folio;

mm/huge_memory.c

2914

struct folio *folio;

mm/huge_memory.c

2921

folio = page_folio(page);

mm/huge_memory.c

2922

folio_remove_rmap_pud(folio, page, vma);

mm/huge_memory.c

2923

add_mm_counter(tlb->mm, mm_counter_file(folio), -HPAGE_PUD_NR);

mm/huge_memory.c

2934

struct folio *folio;

mm/huge_memory.c

2951

folio = page_folio(page);

mm/huge_memory.c

2953

if (!folio_test_dirty(folio) && pud_dirty(old_pud))

mm/huge_memory.c

2954

folio_mark_dirty(folio);

mm/huge_memory.c

2955

if (!folio_test_referenced(folio) && pud_young(old_pud))

mm/huge_memory.c

2956

folio_set_referenced(folio);

mm/huge_memory.c

2957

folio_remove_rmap_pud(folio, page, vma);

mm/huge_memory.c

2958

add_mm_counter(vma->vm_mm, mm_counter_file(folio),

mm/huge_memory.c

2960

folio_put(folio);

mm/huge_memory.c

301

struct folio *zero_folio = xchg(&huge_zero_folio, NULL);

mm/huge_memory.c

3034

struct folio *folio;

mm/huge_memory.c

3065

folio = softleaf_to_folio(old_entry);

mm/huge_memory.c

3070

folio = page_folio(page);

mm/huge_memory.c

3071

if (!folio_test_dirty(folio) && pmd_dirty(old_pmd))

mm/huge_memory.c

3072

folio_mark_dirty(folio);

mm/huge_memory.c

3073

if (!folio_test_referenced(folio) && pmd_young(old_pmd))

mm/huge_memory.c

3074

folio_set_referenced(folio);

mm/huge_memory.c

3075

folio_remove_rmap_pmd(folio, page, vma);

mm/huge_memory.c

3076

add_mm_counter(mm, mm_counter_file(folio), -HPAGE_PMD_NR);

mm/huge_memory.c

3077

folio_put(folio);

mm/huge_memory.c

3080

add_mm_counter(mm, mm_counter_file(folio), -HPAGE_PMD_NR);

mm/huge_memory.c

3103

folio = page_folio(page);

mm/huge_memory.c

3119

folio = page_folio(page);

mm/huge_memory.c

3133

folio_try_share_anon_rmap_pmd(folio, page))

mm/huge_memory.c

3138

folio_ref_add(folio, HPAGE_PMD_NR - 1);

mm/huge_memory.c

3142

folio_add_anon_rmap_ptes(folio, page, HPAGE_PMD_NR,

mm/huge_memory.c

3171

folio = page_folio(page);

mm/huge_memory.c

3174

folio_set_dirty(folio);

mm/huge_memory.c

3181

VM_WARN_ON_FOLIO(!folio_ref_count(folio), folio);

mm/huge_memory.c

3182

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

mm/huge_memory.c

3201

folio_try_share_anon_rmap_pmd(folio, page))

mm/huge_memory.c

3206

folio_ref_add(folio, HPAGE_PMD_NR - 1);

mm/huge_memory.c

3209

folio_add_anon_rmap_ptes(folio, page, HPAGE_PMD_NR,

mm/huge_memory.c

3305

folio_remove_rmap_pmd(folio, page, vma);

mm/huge_memory.c

3376

static void unmap_folio(struct folio *folio)

mm/huge_memory.c

3381

VM_BUG_ON_FOLIO(!folio_test_large(folio), folio);

mm/huge_memory.c

3383

if (folio_test_pmd_mappable(folio))

mm/huge_memory.c

3391

if (folio_test_anon(folio))

mm/huge_memory.c

3392

try_to_migrate(folio, ttu_flags);

mm/huge_memory.c

3394

try_to_unmap(folio, ttu_flags | TTU_IGNORE_MLOCK);

mm/huge_memory.c

3401

struct folio *folio)

mm/huge_memory.c

3408

folio_set_dirty(folio);

mm/huge_memory.c

3409

if (folio_test_dirty(folio) && !(vma->vm_flags & VM_DROPPABLE)) {

mm/huge_memory.c

3410

folio_set_swapbacked(folio);

mm/huge_memory.c

3423

ref_count = folio_ref_count(folio);

mm/huge_memory.c

3424

map_count = folio_mapcount(folio);

mm/huge_memory.c

3440

folio_set_dirty(folio);

mm/huge_memory.c

3441

if (folio_test_dirty(folio) && !(vma->vm_flags & VM_DROPPABLE)) {

mm/huge_memory.c

3442

folio_set_swapbacked(folio);

mm/huge_memory.c

3452

folio_remove_rmap_pmd(folio, pmd_page(orig_pmd), vma);

mm/huge_memory.c

3457

folio_put(folio);

mm/huge_memory.c

3463

pmd_t *pmdp, struct folio *folio)

mm/huge_memory.c

3465

VM_WARN_ON_FOLIO(!folio_test_pmd_mappable(folio), folio);

mm/huge_memory.c

3466

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/huge_memory.c

3467

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

mm/huge_memory.c

3468

VM_WARN_ON_FOLIO(folio_test_swapbacked(folio), folio);

mm/huge_memory.c

3471

return __discard_anon_folio_pmd_locked(vma, addr, pmdp, folio);

mm/huge_memory.c

3474

static void remap_page(struct folio *folio, unsigned long nr, int flags)

mm/huge_memory.c

3479

if (!folio_test_anon(folio))

mm/huge_memory.c

3482

remove_migration_ptes(folio, folio, TTU_RMAP_LOCKED | flags);

mm/huge_memory.c

3483

i += folio_nr_pages(folio);

mm/huge_memory.c

3486

folio = folio_next(folio);

mm/huge_memory.c

3490

static void lru_add_split_folio(struct folio *folio, struct folio *new_folio,

mm/huge_memory.c

3493

VM_BUG_ON_FOLIO(folio_test_lru(new_folio), folio);

mm/huge_memory.c

3496

if (folio_is_device_private(folio))

mm/huge_memory.c

3501

VM_WARN_ON(folio_test_lru(folio));

mm/huge_memory.c

3506

VM_WARN_ON(!folio_test_lru(folio));

mm/huge_memory.c

3507

if (folio_test_unevictable(folio))

mm/huge_memory.c

3510

list_add_tail(&new_folio->lru, &folio->lru);

mm/huge_memory.c

3527

static void __split_folio_to_order(struct folio *folio, int old_order,

mm/huge_memory.c

3531

const bool handle_hwpoison = folio_test_has_hwpoisoned(folio) && new_order;

mm/huge_memory.c

3536

folio_clear_has_hwpoisoned(folio);

mm/huge_memory.c

3540

page_range_has_hwpoisoned(folio_page(folio, 0), new_nr_pages))

mm/huge_memory.c

3541

folio_set_has_hwpoisoned(folio);

mm/huge_memory.c

3547

struct page *new_head = &folio->page + i;

mm/huge_memory.c

3552

struct folio *new_folio = (struct folio *)new_head;

mm/huge_memory.c

3570

new_folio->flags.f |= (folio->flags.f &

mm/huge_memory.c

3590

new_folio->mapping = folio->mapping;

mm/huge_memory.c

3591

new_folio->index = folio->index + i;

mm/huge_memory.c

3593

if (folio_test_swapcache(folio))

mm/huge_memory.c

3594

new_folio->swap.val = folio->swap.val + i;

mm/huge_memory.c

3619

if (folio_test_young(folio))

mm/huge_memory.c

3621

if (folio_test_idle(folio))

mm/huge_memory.c

3624

new_folio->memcg_data = folio->memcg_data;

mm/huge_memory.c

3627

folio_xchg_last_cpupid(new_folio, folio_last_cpupid(folio));

mm/huge_memory.c

3631

folio_set_order(folio, new_order);

mm/huge_memory.c

3633

ClearPageCompound(&folio->page);

mm/huge_memory.c

3677

static int __split_unmapped_folio(struct folio *folio, int new_order,

mm/huge_memory.c

3681

const bool is_anon = folio_test_anon(folio);

mm/huge_memory.c

3682

int old_order = folio_order(folio);

mm/huge_memory.c

3684

struct folio *old_folio = folio;

mm/huge_memory.c

3713

xas_set_order(xas, folio->index, split_order);

mm/huge_memory.c

3720

folio_split_memcg_refs(folio, old_order, split_order);

mm/huge_memory.c

3721

split_page_owner(&folio->page, old_order, split_order);

mm/huge_memory.c

3722

pgalloc_tag_split(folio, old_order, split_order);

mm/huge_memory.c

3723

__split_folio_to_order(folio, old_order, split_order);

mm/huge_memory.c

3734

folio = page_folio(split_at);

mm/huge_memory.c

3757

int folio_check_splittable(struct folio *folio, unsigned int new_order,

mm/huge_memory.c

3760

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/huge_memory.c

3768

if (!folio->mapping && !folio_test_anon(folio))

mm/huge_memory.c

3772

if (folio_test_anon(folio) && new_order == 1)

mm/huge_memory.c

3783

if ((split_type == SPLIT_TYPE_NON_UNIFORM || new_order) && folio_test_swapcache(folio)) {

mm/huge_memory.c

3787

if (is_huge_zero_folio(folio))

mm/huge_memory.c

3790

if (folio_test_writeback(folio))

mm/huge_memory.c

3797

static unsigned int folio_cache_ref_count(const struct folio *folio)

mm/huge_memory.c

3799

if (folio_test_anon(folio) && !folio_test_swapcache(folio))

mm/huge_memory.c

3801

return folio_nr_pages(folio);

mm/huge_memory.c

3804

static int __folio_freeze_and_split_unmapped(struct folio *folio, unsigned int new_order,

mm/huge_memory.c

3810

struct folio *end_folio = folio_next(folio);

mm/huge_memory.c

3811

struct folio *new_folio, *next;

mm/huge_memory.c

3812

int old_order = folio_order(folio);

mm/huge_memory.c

3825

dequeue_deferred = folio_test_anon(folio) && old_order > 1;

mm/huge_memory.c

3830

memcg = folio_memcg(folio);

mm/huge_memory.c

3832

folio_nid(folio), &memcg);

mm/huge_memory.c

3834

if (folio_ref_freeze(folio, folio_cache_ref_count(folio) + 1)) {

mm/huge_memory.c

3840

&folio->_deferred_list, folio_nid(folio));

mm/huge_memory.c

3841

if (folio_test_partially_mapped(folio)) {

mm/huge_memory.c

3842

folio_clear_partially_mapped(folio);

mm/huge_memory.c

3851

int nr = folio_nr_pages(folio);

mm/huge_memory.c

3853

if (folio_test_pmd_mappable(folio) &&

mm/huge_memory.c

3855

if (folio_test_swapbacked(folio)) {

mm/huge_memory.c

3856

lruvec_stat_mod_folio(folio,

mm/huge_memory.c

3859

lruvec_stat_mod_folio(folio,

mm/huge_memory.c

3865

if (folio_test_swapcache(folio)) {

mm/huge_memory.c

3867

VM_WARN_ON_ONCE_FOLIO(mapping, folio);

mm/huge_memory.c

3871

ci = swap_cluster_get_and_lock(folio);

mm/huge_memory.c

3876

lruvec = folio_lruvec_lock(folio);

mm/huge_memory.c

3878

ret = __split_unmapped_folio(folio, new_order, split_at, xas,

mm/huge_memory.c

3889

for (new_folio = folio_next(folio); new_folio != end_folio;

mm/huge_memory.c

3895

zone_device_private_split_cb(folio, new_folio);

mm/huge_memory.c

3901

lru_add_split_folio(folio, new_folio, lruvec, list);

mm/huge_memory.c

3908

__swap_cache_replace_folio(ci, folio, new_folio);

mm/huge_memory.c

3934

zone_device_private_split_cb(folio, NULL);

mm/huge_memory.c

3941

folio_ref_unfreeze(folio, folio_cache_ref_count(folio) + 1);

mm/huge_memory.c

3980

static int __folio_split(struct folio *folio, unsigned int new_order,

mm/huge_memory.c

3984

XA_STATE(xas, &folio->mapping->i_pages, folio->index);

mm/huge_memory.c

3985

struct folio *end_folio = folio_next(folio);

mm/huge_memory.c

3986

bool is_anon = folio_test_anon(folio);

mm/huge_memory.c

3989

int old_order = folio_order(folio);

mm/huge_memory.c

3990

struct folio *new_folio, *next;

mm/huge_memory.c

3996

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/huge_memory.c

3997

VM_WARN_ON_ONCE_FOLIO(!folio_test_large(folio), folio);

mm/huge_memory.c

3999

if (folio != page_folio(split_at) || folio != page_folio(lock_at)) {

mm/huge_memory.c

4009

ret = folio_check_splittable(folio, new_order, split_type);

mm/huge_memory.c

4024

anon_vma = folio_get_anon_vma(folio);

mm/huge_memory.c

4035

mapping = folio->mapping;

mm/huge_memory.c

4036

min_order = mapping_min_folio_order(folio->mapping);

mm/huge_memory.c

4045

if (!filemap_release_folio(folio, gfp)) {

mm/huge_memory.c

4051

xas_set_order(&xas, folio->index, new_order);

mm/huge_memory.c

4052

xas_split_alloc(&xas, folio, old_order, gfp);

mm/huge_memory.c

4078

if (folio_expected_ref_count(folio) != folio_ref_count(folio) - 1) {

mm/huge_memory.c

4083

unmap_folio(folio);

mm/huge_memory.c

4094

if (xas_load(&xas) != folio) {

mm/huge_memory.c

4100

ret = __folio_freeze_and_split_unmapped(folio, new_order, split_at, &xas, mapping,

mm/huge_memory.c

4111

if (!ret && is_anon && !folio_is_device_private(folio))

mm/huge_memory.c

4114

remap_page(folio, 1 << old_order, ttu_flags);

mm/huge_memory.c

4132

for (new_folio = folio; new_folio != end_folio; new_folio = next) {

mm/huge_memory.c

4184

int folio_split_unmapped(struct folio *folio, unsigned int new_order)

mm/huge_memory.c

4188

VM_WARN_ON_ONCE_FOLIO(folio_mapped(folio), folio);

mm/huge_memory.c

4189

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/huge_memory.c

4190

VM_WARN_ON_ONCE_FOLIO(!folio_test_large(folio), folio);

mm/huge_memory.c

4191

VM_WARN_ON_ONCE_FOLIO(!folio_test_anon(folio), folio);

mm/huge_memory.c

4193

if (folio_expected_ref_count(folio) != folio_ref_count(folio) - 1)

mm/huge_memory.c

4197

ret = __folio_freeze_and_split_unmapped(folio, new_order, &folio->page, NULL,

mm/huge_memory.c

4254

struct folio *folio = page_folio(page);

mm/huge_memory.c

4256

return __folio_split(folio, new_order, &folio->page, page, list,

mm/huge_memory.c

4284

int folio_split(struct folio *folio, unsigned int new_order,

mm/huge_memory.c

4287

return __folio_split(folio, new_order, split_at, &folio->page, list,

mm/huge_memory.c

4301

unsigned int min_order_for_split(struct folio *folio)

mm/huge_memory.c

4303

if (folio_test_anon(folio))

mm/huge_memory.c

4312

if (!folio->mapping)

mm/huge_memory.c

4315

return mapping_min_folio_order(folio->mapping);

mm/huge_memory.c

4318

int split_folio_to_list(struct folio *folio, struct list_head *list)

mm/huge_memory.c

4320

return split_huge_page_to_list_to_order(&folio->page, list, 0);

mm/huge_memory.c

4337

bool __folio_unqueue_deferred_split(struct folio *folio)

mm/huge_memory.c

4341

int nid = folio_nid(folio);

mm/huge_memory.c

4345

WARN_ON_ONCE(folio_ref_count(folio));

mm/huge_memory.c

4346

WARN_ON_ONCE(!mem_cgroup_disabled() && !folio_memcg_charged(folio));

mm/huge_memory.c

4349

memcg = folio_memcg(folio);

mm/huge_memory.c

4351

if (__list_lru_del(&deferred_split_lru, lru, &folio->_deferred_list, nid)) {

mm/huge_memory.c

4352

if (folio_test_partially_mapped(folio)) {

mm/huge_memory.c

4353

folio_clear_partially_mapped(folio);

mm/huge_memory.c

4354

mod_mthp_stat(folio_order(folio),

mm/huge_memory.c

4366

void deferred_split_folio(struct folio *folio, bool partially_mapped)

mm/huge_memory.c

4377

if (folio_order(folio) <= 1)

mm/huge_memory.c

4390

if (folio_test_swapcache(folio))

mm/huge_memory.c

4393

nid = folio_nid(folio);

mm/huge_memory.c

4396

memcg = folio_memcg(folio);

mm/huge_memory.c

4399

if (!folio_test_partially_mapped(folio)) {

mm/huge_memory.c

4400

folio_set_partially_mapped(folio);

mm/huge_memory.c

4401

if (folio_test_pmd_mappable(folio))

mm/huge_memory.c

4403

count_mthp_stat(folio_order(folio), MTHP_STAT_SPLIT_DEFERRED);

mm/huge_memory.c

4404

mod_mthp_stat(folio_order(folio), MTHP_STAT_NR_ANON_PARTIALLY_MAPPED, 1);

mm/huge_memory.c

4408

VM_WARN_ON_FOLIO(folio_test_partially_mapped(folio), folio);

mm/huge_memory.c

4410

__list_lru_add(&deferred_split_lru, lru, &folio->_deferred_list, nid, memcg);

mm/huge_memory.c

4424

static bool thp_underused(struct folio *folio)

mm/huge_memory.c

4432

if (folio_contain_hwpoisoned_page(folio))

mm/huge_memory.c

4435

for (i = 0; i < folio_nr_pages(folio); i++) {

mm/huge_memory.c

4436

if (pages_identical(folio_page(folio, i), ZERO_PAGE(0))) {

mm/huge_memory.c

4455

struct folio *folio = container_of(item, struct folio, _deferred_list);

mm/huge_memory.c

4458

if (folio_try_get(folio)) {

mm/huge_memory.c

4468

if (folio_test_partially_mapped(folio)) {

mm/huge_memory.c

4469

folio_clear_partially_mapped(folio);

mm/huge_memory.c

4470

mod_mthp_stat(folio_order(folio),

mm/huge_memory.c

4481

struct folio *folio, *next;

mm/huge_memory.c

4488

list_for_each_entry_safe(folio, next, &dispose, _deferred_list) {

mm/huge_memory.c

4492

list_del_init(&folio->_deferred_list);

mm/huge_memory.c

4494

if (!folio_test_partially_mapped(folio)) {

mm/huge_memory.c

4500

if (folio_test_mlocked(folio))

mm/huge_memory.c

4502

underused = thp_underused(folio);

mm/huge_memory.c

4506

if (!folio_trylock(folio))

mm/huge_memory.c

4508

if (!split_folio(folio)) {

mm/huge_memory.c

4514

folio_unlock(folio);

mm/huge_memory.c

4522

if (!did_split && folio_test_partially_mapped(folio)) {

mm/huge_memory.c

4526

&folio->_deferred_list,

mm/huge_memory.c

4527

folio_nid(folio),

mm/huge_memory.c

4528

folio_memcg(folio));

mm/huge_memory.c

4531

folio_put(folio);

mm/huge_memory.c

4544

struct folio *folio;

mm/huge_memory.c

4559

folio = page_folio(page);

mm/huge_memory.c

4560

if (!folio_try_get(folio))

mm/huge_memory.c

4563

if (unlikely(page_folio(page) != folio))

mm/huge_memory.c

4566

if (zone != folio_zone(folio))

mm/huge_memory.c

4569

if (!folio_test_large(folio)

mm/huge_memory.c

4570

|| folio_test_hugetlb(folio)

mm/huge_memory.c

4571

|| !folio_test_lru(folio))

mm/huge_memory.c

4575

folio_lock(folio);

mm/huge_memory.c

4576

nr_pages = folio_nr_pages(folio);

mm/huge_memory.c

4577

if (!split_folio(folio))

mm/huge_memory.c

4580

folio_unlock(folio);

mm/huge_memory.c

4582

folio_put(folio);

mm/huge_memory.c

4643

struct folio *folio;

mm/huge_memory.c

4656

folio = folio_walk_start(&fw, vma, addr, 0);

mm/huge_memory.c

4657

if (!folio)

mm/huge_memory.c

4660

if (!is_transparent_hugepage(folio))

mm/huge_memory.c

4663

if (!folio_test_anon(folio)) {

mm/huge_memory.c

4664

mapping = folio->mapping;

mm/huge_memory.c

4669

if (target_order >= folio_order(folio))

mm/huge_memory.c

4678

if (!folio_test_private(folio) &&

mm/huge_memory.c

4679

folio_expected_ref_count(folio) != folio_ref_count(folio))

mm/huge_memory.c

4682

if (!folio_trylock(folio))

mm/huge_memory.c

4684

folio_get(folio);

mm/huge_memory.c

4687

if (!folio_test_anon(folio) && folio->mapping != mapping)

mm/huge_memory.c

4691

in_folio_offset >= folio_nr_pages(folio)) {

mm/huge_memory.c

4692

if (!split_folio_to_order(folio, target_order))

mm/huge_memory.c

4695

struct page *split_at = folio_page(folio,

mm/huge_memory.c

4697

if (!folio_split(folio, target_order, split_at, NULL))

mm/huge_memory.c

4703

folio_unlock(folio);

mm/huge_memory.c

4704

folio_put(folio);

mm/huge_memory.c

4746

struct folio *folio = filemap_get_folio(mapping, index);

mm/huge_memory.c

4749

if (IS_ERR(folio))

mm/huge_memory.c

4752

if (!folio_test_large(folio))

mm/huge_memory.c

4756

nr_pages = folio_nr_pages(folio);

mm/huge_memory.c

4758

if (target_order >= folio_order(folio))

mm/huge_memory.c

4761

if (!folio_trylock(folio))

mm/huge_memory.c

4764

if (folio->mapping != mapping)

mm/huge_memory.c

4768

if (!split_folio_to_order(folio, target_order))

mm/huge_memory.c

4771

struct page *split_at = folio_page(folio,

mm/huge_memory.c

4773

if (!folio_split(folio, target_order, split_at, NULL))

mm/huge_memory.c

4778

folio_unlock(folio);

mm/huge_memory.c

4780

folio_put(folio);

mm/huge_memory.c

4886

struct folio *folio = page_folio(page);

mm/huge_memory.c

4919

anon_exclusive = folio_test_anon(folio) && PageAnonExclusive(page);

mm/huge_memory.c

4920

if (anon_exclusive && folio_try_share_anon_rmap_pmd(folio, page)) {

mm/huge_memory.c

4937

folio_mark_dirty(folio);

mm/huge_memory.c

4950

folio_remove_rmap_pmd(folio, page, vma);

mm/huge_memory.c

4951

folio_put(folio);

mm/huge_memory.c

4959

struct folio *folio = page_folio(new);

mm/huge_memory.c

4971

folio_get(folio);

mm/huge_memory.c

4972

pmde = folio_mk_pmd(folio, READ_ONCE(vma->vm_page_prot));

mm/huge_memory.c

4983

if (folio_test_dirty(folio) && softleaf_is_migration_dirty(entry))

mm/huge_memory.c

4986

if (folio_is_device_private(folio)) {

mm/huge_memory.c

5003

if (folio_test_anon(folio)) {

mm/huge_memory.c

5009

folio_add_anon_rmap_pmd(folio, new, vma, haddr, rmap_flags);

mm/huge_memory.c

5011

folio_add_file_rmap_pmd(folio, new, vma);

mm/huge_memory.c

5013

VM_BUG_ON(pmd_write(pmde) && folio_test_anon(folio) && !PageAnonExclusive(new));

mm/huge_memory.c

81

struct folio *huge_zero_folio __read_mostly;

mm/huge_memory.c

949

int folio_memcg_alloc_deferred(struct folio *folio)

mm/huge_memory.c

953

return folio_memcg_list_lru_alloc(folio, &deferred_split_lru, GFP_KERNEL);

mm/hugetlb.c

1234

static void enqueue_hugetlb_folio(struct hstate *h, struct folio *folio)

mm/hugetlb.c

1236

int nid = folio_nid(folio);

mm/hugetlb.c

1239

VM_BUG_ON_FOLIO(folio_ref_count(folio), folio);

mm/hugetlb.c

1241

list_move(&folio->lru, &h->hugepage_freelists[nid]);

mm/hugetlb.c

1244

folio_set_hugetlb_freed(folio);

mm/hugetlb.c

1247

static struct folio *dequeue_hugetlb_folio_node_exact(struct hstate *h,

mm/hugetlb.c

1250

struct folio *folio;

mm/hugetlb.c

1254

list_for_each_entry(folio, &h->hugepage_freelists[nid], lru) {

mm/hugetlb.c

1255

if (pin && !folio_is_longterm_pinnable(folio))

mm/hugetlb.c

1258

if (folio_test_hwpoison(folio))

mm/hugetlb.c

1261

if (is_migrate_isolate_page(&folio->page))

mm/hugetlb.c

1264

list_move(&folio->lru, &h->hugepage_activelist);

mm/hugetlb.c

1265

folio_ref_unfreeze(folio, 1);

mm/hugetlb.c

1266

folio_clear_hugetlb_freed(folio);

mm/hugetlb.c

1269

return folio;

mm/hugetlb.c

1275

static struct folio *dequeue_hugetlb_folio_nodemask(struct hstate *h, gfp_t gfp_mask,

mm/hugetlb.c

1293

struct folio *folio;

mm/hugetlb.c

1305

folio = dequeue_hugetlb_folio_node_exact(h, node);

mm/hugetlb.c

1306

if (folio)

mm/hugetlb.c

1307

return folio;

mm/hugetlb.c

1320

static struct folio *dequeue_hugetlb_folio_vma(struct hstate *h,

mm/hugetlb.c

1324

struct folio *folio = NULL;

mm/hugetlb.c

1341

folio = dequeue_hugetlb_folio_nodemask(h, gfp_mask,

mm/hugetlb.c

1348

if (!folio)

mm/hugetlb.c

1349

folio = dequeue_hugetlb_folio_nodemask(h, gfp_mask,

mm/hugetlb.c

1353

return folio;

mm/hugetlb.c

1360

static struct folio *alloc_gigantic_frozen_folio(int order, gfp_t gfp_mask,

mm/hugetlb.c

1363

struct folio *folio;

mm/hugetlb.c

1365

folio = hugetlb_cma_alloc_frozen_folio(order, gfp_mask, nid, nodemask);

mm/hugetlb.c

1366

if (folio)

mm/hugetlb.c

1367

return folio;

mm/hugetlb.c

1372

folio = (struct folio *)alloc_contig_frozen_pages(1 << order, gfp_mask,

mm/hugetlb.c

1374

return folio;

mm/hugetlb.c

1377

static struct folio *alloc_gigantic_frozen_folio(int order, gfp_t gfp_mask, int nid,

mm/hugetlb.c

1392

void remove_hugetlb_folio(struct hstate *h, struct folio *folio,

mm/hugetlb.c

1395

int nid = folio_nid(folio);

mm/hugetlb.c

1397

VM_BUG_ON_FOLIO(hugetlb_cgroup_from_folio(folio), folio);

mm/hugetlb.c

1398

VM_BUG_ON_FOLIO(hugetlb_cgroup_from_folio_rsvd(folio), folio);

mm/hugetlb.c

1404

list_del(&folio->lru);

mm/hugetlb.c

1406

if (folio_test_hugetlb_freed(folio)) {

mm/hugetlb.c

1407

folio_clear_hugetlb_freed(folio);

mm/hugetlb.c

1421

if (!folio_test_hugetlb_vmemmap_optimized(folio))

mm/hugetlb.c

1422

__folio_clear_hugetlb(folio);

mm/hugetlb.c

1428

void add_hugetlb_folio(struct hstate *h, struct folio *folio,

mm/hugetlb.c

1431

int nid = folio_nid(folio);

mm/hugetlb.c

1433

VM_BUG_ON_FOLIO(!folio_test_hugetlb_vmemmap_optimized(folio), folio);

mm/hugetlb.c

1437

INIT_LIST_HEAD(&folio->lru);

mm/hugetlb.c

1446

__folio_set_hugetlb(folio);

mm/hugetlb.c

1447

folio_change_private(folio, NULL);

mm/hugetlb.c

1452

folio_set_hugetlb_vmemmap_optimized(folio);

mm/hugetlb.c

1454

arch_clear_hugetlb_flags(folio);

mm/hugetlb.c

1455

enqueue_hugetlb_folio(h, folio);

mm/hugetlb.c

1459

struct folio *folio)

mm/hugetlb.c

1461

bool clear_flag = folio_test_hugetlb_vmemmap_optimized(folio);

mm/hugetlb.c

1470

if (folio_test_hugetlb_raw_hwp_unreliable(folio))

mm/hugetlb.c

1478

if (clear_flag && hugetlb_vmemmap_restore_folio(h, folio)) {

mm/hugetlb.c

1485

add_hugetlb_folio(h, folio, true);

mm/hugetlb.c

1494

if (folio_test_hugetlb(folio)) {

mm/hugetlb.c

1496

__folio_clear_hugetlb(folio);

mm/hugetlb.c

1504

if (unlikely(folio_test_hwpoison(folio)))

mm/hugetlb.c

1505

folio_clear_hugetlb_hwpoison(folio);

mm/hugetlb.c

1507

VM_BUG_ON_FOLIO(folio_ref_count(folio), folio);

mm/hugetlb.c

1508

if (folio_test_hugetlb_cma(folio))

mm/hugetlb.c

1509

hugetlb_cma_free_frozen_folio(folio);

mm/hugetlb.c

1511

free_frozen_pages(&folio->page, folio_order(folio));

mm/hugetlb.c

1534

struct folio *folio;

mm/hugetlb.c

1537

folio = container_of((struct address_space **)node,

mm/hugetlb.c

1538

struct folio, mapping);

mm/hugetlb.c

1540

folio->mapping = NULL;

mm/hugetlb.c

1547

h = size_to_hstate(folio_size(folio));

mm/hugetlb.c

1549

__update_and_free_hugetlb_folio(h, folio);

mm/hugetlb.c

1562

static void update_and_free_hugetlb_folio(struct hstate *h, struct folio *folio,

mm/hugetlb.c

1565

if (!folio_test_hugetlb_vmemmap_optimized(folio) || !atomic) {

mm/hugetlb.c

1566

__update_and_free_hugetlb_folio(h, folio);

mm/hugetlb.c

1577

if (llist_add((struct llist_node *)&folio->mapping, &hpage_freelist))

mm/hugetlb.c

1585

struct folio *folio, *t_folio;

mm/hugetlb.c

1595

list_for_each_entry_safe(folio, t_folio, non_hvo_folios, lru) {

mm/hugetlb.c

1596

list_del(&folio->lru);

mm/hugetlb.c

1598

__folio_clear_hugetlb(folio);

mm/hugetlb.c

1600

update_and_free_hugetlb_folio(h, folio, false);

mm/hugetlb.c

1614

list_for_each_entry_safe(folio, t_folio, folio_list, lru)

mm/hugetlb.c

1615

if (hugetlb_vmemmap_restore_folio(h, folio)) {

mm/hugetlb.c

1616

list_del(&folio->lru);

mm/hugetlb.c

1618

add_hugetlb_folio(h, folio, true);

mm/hugetlb.c

1621

list_del(&folio->lru);

mm/hugetlb.c

1623

__folio_clear_hugetlb(folio);

mm/hugetlb.c

1625

update_and_free_hugetlb_folio(h, folio, false);

mm/hugetlb.c

1636

struct folio *folio, *t_folio;

mm/hugetlb.c

1662

list_for_each_entry(folio, &non_hvo_folios, lru)

mm/hugetlb.c

1663

__folio_clear_hugetlb(folio);

mm/hugetlb.c

1667

list_for_each_entry_safe(folio, t_folio, &non_hvo_folios, lru) {

mm/hugetlb.c

1668

update_and_free_hugetlb_folio(h, folio, false);

mm/hugetlb.c

1684

void free_huge_folio(struct folio *folio)

mm/hugetlb.c

1690

struct hstate *h = folio_hstate(folio);

mm/hugetlb.c

1691

int nid = folio_nid(folio);

mm/hugetlb.c

1692

struct hugepage_subpool *spool = hugetlb_folio_subpool(folio);

mm/hugetlb.c

1696

VM_BUG_ON_FOLIO(folio_ref_count(folio), folio);

mm/hugetlb.c

1697

VM_BUG_ON_FOLIO(folio_mapcount(folio), folio);

mm/hugetlb.c

1699

hugetlb_set_folio_subpool(folio, NULL);

mm/hugetlb.c

1700

if (folio_test_anon(folio))

mm/hugetlb.c

1701

__ClearPageAnonExclusive(&folio->page);

mm/hugetlb.c

1702

folio->mapping = NULL;

mm/hugetlb.c

1703

restore_reserve = folio_test_hugetlb_restore_reserve(folio);

mm/hugetlb.c

1704

folio_clear_hugetlb_restore_reserve(folio);

mm/hugetlb.c

1726

folio_clear_hugetlb_migratable(folio);

mm/hugetlb.c

1728

pages_per_huge_page(h), folio);

mm/hugetlb.c

1730

pages_per_huge_page(h), folio);

mm/hugetlb.c

1731

lruvec_stat_mod_folio(folio, NR_HUGETLB, -pages_per_huge_page(h));

mm/hugetlb.c

1732

mem_cgroup_uncharge(folio);

mm/hugetlb.c

1736

if (folio_test_hugetlb_temporary(folio)) {

mm/hugetlb.c

1737

remove_hugetlb_folio(h, folio, false);

mm/hugetlb.c

1739

update_and_free_hugetlb_folio(h, folio, true);

mm/hugetlb.c

1742

remove_hugetlb_folio(h, folio, true);

mm/hugetlb.c

1744

update_and_free_hugetlb_folio(h, folio, true);

mm/hugetlb.c

1746

arch_clear_hugetlb_flags(folio);

mm/hugetlb.c

1747

enqueue_hugetlb_folio(h, folio);

mm/hugetlb.c

1755

static void account_new_hugetlb_folio(struct hstate *h, struct folio *folio)

mm/hugetlb.c

1759

h->nr_huge_pages_node[folio_nid(folio)]++;

mm/hugetlb.c

1762

void init_new_hugetlb_folio(struct folio *folio)

mm/hugetlb.c

1764

__folio_set_hugetlb(folio);

mm/hugetlb.c

1765

INIT_LIST_HEAD(&folio->lru);

mm/hugetlb.c

1766

hugetlb_set_folio_subpool(folio, NULL);

mm/hugetlb.c

1767

set_hugetlb_cgroup(folio, NULL);

mm/hugetlb.c

1768

set_hugetlb_cgroup_rsvd(folio, NULL);

mm/hugetlb.c

1778

struct address_space *hugetlb_folio_mapping_lock_write(struct folio *folio)

mm/hugetlb.c

1780

struct address_space *mapping = folio_mapping(folio);

mm/hugetlb.c

1791

static struct folio *alloc_buddy_frozen_folio(int order, gfp_t gfp_mask,

mm/hugetlb.c

1794

struct folio *folio;

mm/hugetlb.c

1809

folio = (struct folio *)__alloc_frozen_pages(gfp_mask, order, nid, nmask);

mm/hugetlb.c

1816

if (node_alloc_noretry && folio && !alloc_try_hard)

mm/hugetlb.c

1824

if (node_alloc_noretry && !folio && alloc_try_hard)

mm/hugetlb.c

1827

if (!folio) {

mm/hugetlb.c

1833

return folio;

mm/hugetlb.c

1836

static struct folio *only_alloc_fresh_hugetlb_folio(struct hstate *h,

mm/hugetlb.c

1840

struct folio *folio;

mm/hugetlb.c

1847

folio = alloc_gigantic_frozen_folio(order, gfp_mask, nid, nmask);

mm/hugetlb.c

1849

folio = alloc_buddy_frozen_folio(order, gfp_mask, nid, nmask,

mm/hugetlb.c

1851

if (folio)

mm/hugetlb.c

1852

init_new_hugetlb_folio(folio);

mm/hugetlb.c

1853

return folio;

mm/hugetlb.c

1863

static struct folio *alloc_fresh_hugetlb_folio(struct hstate *h,

mm/hugetlb.c

1866

struct folio *folio;

mm/hugetlb.c

1868

folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, nid, nmask, NULL);

mm/hugetlb.c

1869

if (folio)

mm/hugetlb.c

1870

hugetlb_vmemmap_optimize_folio(h, folio);

mm/hugetlb.c

1871

return folio;

mm/hugetlb.c

1878

struct folio *folio, *tmp_f;

mm/hugetlb.c

1885

list_for_each_entry_safe(folio, tmp_f, folio_list, lru) {

mm/hugetlb.c

1886

account_new_hugetlb_folio(h, folio);

mm/hugetlb.c

1887

enqueue_hugetlb_folio(h, folio);

mm/hugetlb.c

1896

static struct folio *alloc_pool_huge_folio(struct hstate *h,

mm/hugetlb.c

1905

struct folio *folio;

mm/hugetlb.c

1907

folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, node,

mm/hugetlb.c

1909

if (folio)

mm/hugetlb.c

1910

return folio;

mm/hugetlb.c

1923

static struct folio *remove_pool_hugetlb_folio(struct hstate *h,

mm/hugetlb.c

1927

struct folio *folio = NULL;

mm/hugetlb.c

1937

folio = list_entry(h->hugepage_freelists[node].next,

mm/hugetlb.c

1938

struct folio, lru);

mm/hugetlb.c

1939

remove_hugetlb_folio(h, folio, acct_surplus);

mm/hugetlb.c

1944

return folio;

mm/hugetlb.c

1961

int dissolve_free_hugetlb_folio(struct folio *folio)

mm/hugetlb.c

1967

if (!folio_test_hugetlb(folio))

mm/hugetlb.c

1971

if (!folio_test_hugetlb(folio)) {

mm/hugetlb.c

1976

if (!folio_ref_count(folio)) {

mm/hugetlb.c

1977

struct hstate *h = folio_hstate(folio);

mm/hugetlb.c

1987

if (unlikely(!folio_test_hugetlb_freed(folio))) {

mm/hugetlb.c

2002

if (h->surplus_huge_pages_node[folio_nid(folio)])

mm/hugetlb.c

2004

remove_hugetlb_folio(h, folio, adjust_surplus);

mm/hugetlb.c

2020

if (folio_test_hugetlb(folio)) {

mm/hugetlb.c

2021

rc = hugetlb_vmemmap_restore_folio(h, folio);

mm/hugetlb.c

2024

add_hugetlb_folio(h, folio, adjust_surplus);

mm/hugetlb.c

2032

update_and_free_hugetlb_folio(h, folio, false);

mm/hugetlb.c

2051

struct folio *folio;

mm/hugetlb.c

2064

folio = pfn_folio(pfn);

mm/hugetlb.c

2065

rc = dissolve_free_hugetlb_folio(folio);

mm/hugetlb.c

2076

static struct folio *alloc_surplus_hugetlb_folio(struct hstate *h,

mm/hugetlb.c

2079

struct folio *folio = NULL;

mm/hugetlb.c

2089

folio = alloc_fresh_hugetlb_folio(h, gfp_mask, nid, nmask);

mm/hugetlb.c

2090

if (!folio)

mm/hugetlb.c

2099

account_new_hugetlb_folio(h, folio);

mm/hugetlb.c

2109

folio_set_hugetlb_temporary(folio);

mm/hugetlb.c

2111

free_huge_folio(folio);

mm/hugetlb.c

2116

h->surplus_huge_pages_node[folio_nid(folio)]++;

mm/hugetlb.c

2121

return folio;

mm/hugetlb.c

2124

static struct folio *alloc_migrate_hugetlb_folio(struct hstate *h, gfp_t gfp_mask,

mm/hugetlb.c

2127

struct folio *folio;

mm/hugetlb.c

2132

folio = alloc_fresh_hugetlb_folio(h, gfp_mask, nid, nmask);

mm/hugetlb.c

2133

if (!folio)

mm/hugetlb.c

2137

account_new_hugetlb_folio(h, folio);

mm/hugetlb.c

2141

folio_ref_unfreeze(folio, 1);

mm/hugetlb.c

2146

folio_set_hugetlb_temporary(folio);

mm/hugetlb.c

2148

return folio;

mm/hugetlb.c

2155

struct folio *alloc_buddy_hugetlb_folio_with_mpol(struct hstate *h,

mm/hugetlb.c

2158

struct folio *folio = NULL;

mm/hugetlb.c

2168

folio = alloc_surplus_hugetlb_folio(h, gfp, nid, nodemask);

mm/hugetlb.c

2174

if (!folio)

mm/hugetlb.c

2175

folio = alloc_surplus_hugetlb_folio(h, gfp_mask, nid, nodemask);

mm/hugetlb.c

2177

return folio;

mm/hugetlb.c

2180

struct folio *alloc_hugetlb_folio_reserve(struct hstate *h, int preferred_nid,

mm/hugetlb.c

2183

struct folio *folio;

mm/hugetlb.c

2191

folio = dequeue_hugetlb_folio_nodemask(h, gfp_mask, preferred_nid,

mm/hugetlb.c

2193

if (folio)

mm/hugetlb.c

2197

return folio;

mm/hugetlb.c

2201

struct folio *alloc_hugetlb_folio_nodemask(struct hstate *h, int preferred_nid,

mm/hugetlb.c

2206

struct folio *folio;

mm/hugetlb.c

2208

folio = dequeue_hugetlb_folio_nodemask(h, gfp_mask,

mm/hugetlb.c

2210

if (folio) {

mm/hugetlb.c

2212

return folio;

mm/hugetlb.c

2249

struct folio *folio, *tmp;

mm/hugetlb.c

2275

folio = NULL;

mm/hugetlb.c

2281

folio = alloc_surplus_hugetlb_folio(h, htlb_alloc_mask(h),

mm/hugetlb.c

2283

if (!folio) {

mm/hugetlb.c

2287

list_add(&folio->lru, &surplus_list);

mm/hugetlb.c

2322

list_for_each_entry_safe(folio, tmp, &surplus_list, lru) {

mm/hugetlb.c

2326

enqueue_hugetlb_folio(h, folio);

mm/hugetlb.c

2335

list_for_each_entry_safe(folio, tmp, &surplus_list, lru)

mm/hugetlb.c

2336

free_huge_folio(folio);

mm/hugetlb.c

2378

struct folio *folio;

mm/hugetlb.c

2380

folio = remove_pool_hugetlb_folio(h, &node_states[N_MEMORY], 1);

mm/hugetlb.c

2381

if (!folio)

mm/hugetlb.c

2384

list_add(&folio->lru, &page_list);

mm/hugetlb.c

2561

unsigned long address, struct folio *folio)

mm/hugetlb.c

2565

if (folio_test_hugetlb_restore_reserve(folio)) {

mm/hugetlb.c

2578

folio_clear_hugetlb_restore_reserve(folio);

mm/hugetlb.c

2603

folio_set_hugetlb_restore_reserve(folio);

mm/hugetlb.c

2624

folio_set_hugetlb_restore_reserve(folio);

mm/hugetlb.c

2641

static int alloc_and_dissolve_hugetlb_folio(struct folio *old_folio,

mm/hugetlb.c

2647

struct folio *new_folio = NULL;

mm/hugetlb.c

2727

int isolate_or_dissolve_huge_folio(struct folio *folio, struct list_head *list)

mm/hugetlb.c

2732

if (!folio_test_hugetlb(folio))

mm/hugetlb.c

2740

if (order_is_gigantic(folio_order(folio)))

mm/hugetlb.c

2743

if (folio_ref_count(folio) && folio_isolate_hugetlb(folio, list))

mm/hugetlb.c

2745

else if (!folio_ref_count(folio))

mm/hugetlb.c

2746

ret = alloc_and_dissolve_hugetlb_folio(folio, list);

mm/hugetlb.c

2784

struct folio *folio = page_folio(page);

mm/hugetlb.c

2786

nr = folio_nr_pages(folio) - folio_page_idx(folio, page);

mm/hugetlb.c

2792

if (folio_test_hugetlb(folio) && !folio_ref_count(folio)) {

mm/hugetlb.c

2793

if (order_is_gigantic(folio_order(folio))) {

mm/hugetlb.c

2798

ret = alloc_and_dissolve_hugetlb_folio(folio, &list);

mm/hugetlb.c

2855

struct folio *alloc_hugetlb_folio(struct vm_area_struct *vma,

mm/hugetlb.c

2860

struct folio *folio;

mm/hugetlb.c

2931

folio = dequeue_hugetlb_folio_vma(h, vma, addr, gbl_chg);

mm/hugetlb.c

2932

if (!folio) {

mm/hugetlb.c

2934

folio = alloc_buddy_hugetlb_folio_with_mpol(h, vma, addr);

mm/hugetlb.c

2935

if (!folio)

mm/hugetlb.c

2938

list_add(&folio->lru, &h->hugepage_activelist);

mm/hugetlb.c

2939

folio_ref_unfreeze(folio, 1);

mm/hugetlb.c

2948

folio_set_hugetlb_restore_reserve(folio);

mm/hugetlb.c

2952

hugetlb_cgroup_commit_charge(idx, pages_per_huge_page(h), h_cg, folio);

mm/hugetlb.c

2958

h_cg_rsvd, folio);

mm/hugetlb.c

2963

hugetlb_set_folio_subpool(folio, spool);

mm/hugetlb.c

2985

hstate_index(h), pages_per_huge_page(h), folio);

mm/hugetlb.c

2990

ret = mem_cgroup_charge_hugetlb(folio, gfp);

mm/hugetlb.c

2996

lruvec_stat_mod_folio(folio, NR_HUGETLB, pages_per_huge_page(h));

mm/hugetlb.c

2999

free_huge_folio(folio);

mm/hugetlb.c

3003

return folio;

mm/hugetlb.c

3118

static void __init hugetlb_folio_init_tail_vmemmap(struct folio *folio,

mm/hugetlb.c

3123

enum zone_type zone = folio_zonenum(folio);

mm/hugetlb.c

3124

int nid = folio_nid(folio);

mm/hugetlb.c

3125

struct page *page = folio_page(folio, start_page_number);

mm/hugetlb.c

3126

unsigned long head_pfn = folio_pfn(folio);

mm/hugetlb.c

3136

prep_compound_tail(page, &folio->page, order);

mm/hugetlb.c

3141

static void __init hugetlb_folio_init_vmemmap(struct folio *folio,

mm/hugetlb.c

3152

__folio_clear_reserved(folio);

mm/hugetlb.c

3153

__folio_set_head(folio);

mm/hugetlb.c

3154

ret = folio_ref_freeze(folio, 1);

mm/hugetlb.c

3156

hugetlb_folio_init_tail_vmemmap(folio, h, 1, nr_pages);

mm/hugetlb.c

3157

prep_compound_head(&folio->page, huge_page_order(h));

mm/hugetlb.c

3180

static void __init hugetlb_bootmem_init_migratetype(struct folio *folio,

mm/hugetlb.c

3185

WARN_ON_ONCE(!pageblock_aligned(folio_pfn(folio)));

mm/hugetlb.c

3188

if (folio_test_hugetlb_cma(folio))

mm/hugetlb.c

3189

init_cma_pageblock(folio_page(folio, i));

mm/hugetlb.c

3191

init_pageblock_migratetype(folio_page(folio, i),

mm/hugetlb.c

3200

struct folio *folio, *tmp_f;

mm/hugetlb.c

3205

list_for_each_entry_safe(folio, tmp_f, folio_list, lru) {

mm/hugetlb.c

3206

if (!folio_test_hugetlb_vmemmap_optimized(folio)) {

mm/hugetlb.c

3213

hugetlb_folio_init_tail_vmemmap(folio, h,

mm/hugetlb.c

3217

hugetlb_bootmem_init_migratetype(folio, h);

mm/hugetlb.c

3220

account_new_hugetlb_folio(h, folio);

mm/hugetlb.c

3221

enqueue_hugetlb_folio(h, folio);

mm/hugetlb.c

3289

struct folio *folio = (void *)page;

mm/hugetlb.c

3312

WARN_ON(folio_ref_count(folio) != 1);

mm/hugetlb.c

3314

hugetlb_folio_init_vmemmap(folio, h,

mm/hugetlb.c

3316

init_new_hugetlb_folio(folio);

mm/hugetlb.c

3324

folio_set_hugetlb_vmemmap_optimized(folio);

mm/hugetlb.c

3327

folio_set_hugetlb_cma(folio);

mm/hugetlb.c

3329

list_add(&folio->lru, &folio_list);

mm/hugetlb.c

3339

if (!folio_test_hugetlb_cma(folio))

mm/hugetlb.c

3383

struct folio *folio;

mm/hugetlb.c

3386

folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, nid,

mm/hugetlb.c

3388

if (!folio && !list_empty(&folio_list) &&

mm/hugetlb.c

3392

folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, nid,

mm/hugetlb.c

3395

if (!folio)

mm/hugetlb.c

3397

list_add(&folio->lru, &folio_list);

mm/hugetlb.c

3454

struct folio *folio;

mm/hugetlb.c

3461

folio = alloc_pool_huge_folio(h, &node_states[N_MEMORY],

mm/hugetlb.c

3463

if (!folio)

mm/hugetlb.c

3466

list_move(&folio->lru, &folio_list);

mm/hugetlb.c

3672

struct folio *folio, *next;

mm/hugetlb.c

3674

list_for_each_entry_safe(folio, next, freel, lru) {

mm/hugetlb.c

3677

if (folio_test_highmem(folio))

mm/hugetlb.c

3679

remove_hugetlb_folio(h, folio, false);

mm/hugetlb.c

3680

list_add(&folio->lru, &page_list);

mm/hugetlb.c

3736

struct folio *folio;

mm/hugetlb.c

3825

folio = alloc_pool_huge_folio(h, nodes_allowed,

mm/hugetlb.c

3828

if (!folio) {

mm/hugetlb.c

3834

list_add(&folio->lru, &page_list);

mm/hugetlb.c

3893

folio = remove_pool_hugetlb_folio(h, nodes_allowed, 0);

mm/hugetlb.c

3894

if (!folio)

mm/hugetlb.c

3897

list_add(&folio->lru, &page_list);

mm/hugetlb.c

3923

struct folio *folio, *next;

mm/hugetlb.c

3940

list_for_each_entry_safe(folio, next, src_list, lru) {

mm/hugetlb.c

3944

if (folio_test_hugetlb_vmemmap_optimized(folio))

mm/hugetlb.c

3947

cma = folio_test_hugetlb_cma(folio);

mm/hugetlb.c

3949

list_del(&folio->lru);

mm/hugetlb.c

3951

split_page_owner(&folio->page, huge_page_order(src), huge_page_order(dst));

mm/hugetlb.c

3952

pgalloc_tag_split(folio, huge_page_order(src), huge_page_order(dst));

mm/hugetlb.c

3955

struct page *page = folio_page(folio, i);

mm/hugetlb.c

3957

struct folio *new_folio = (struct folio *)page;

mm/hugetlb.c

3998

struct folio *folio, *next;

mm/hugetlb.c

4000

list_for_each_entry_safe(folio, next, &src->hugepage_freelists[node], lru) {

mm/hugetlb.c

4001

if (folio_test_hwpoison(folio))

mm/hugetlb.c

4004

remove_hugetlb_folio(src, folio, false);

mm/hugetlb.c

4005

list_add(&folio->lru, &list);

mm/hugetlb.c

4017

list_for_each_entry_safe(folio, next, &list, lru) {

mm/hugetlb.c

4018

list_del(&folio->lru);

mm/hugetlb.c

4019

add_hugetlb_folio(src, folio, false);

mm/hugetlb.c

4804

static pte_t make_huge_pte(struct vm_area_struct *vma, struct folio *folio,

mm/hugetlb.c

4807

pte_t entry = folio_mk_pte(folio, vma->vm_page_prot);

mm/hugetlb.c

4840

struct folio *new_folio, pte_t old, unsigned long sz)

mm/hugetlb.c

4858

struct folio *pte_folio;

mm/hugetlb.c

4970

struct folio *new_folio;

mm/hugetlb.c

5147

struct folio *folio, zap_flags_t zap_flags)

mm/hugetlb.c

5150

const bool folio_provided = !!folio;

mm/hugetlb.c

5221

if (folio != page_folio(pte_page(pte))) {

mm/hugetlb.c

5232

folio = page_folio(pte_page(pte));

mm/hugetlb.c

5238

folio_mark_dirty(folio);

mm/hugetlb.c

5246

hugetlb_remove_rmap(folio);

mm/hugetlb.c

5259

folio_test_anon(folio)) {

mm/hugetlb.c

5260

folio_set_hugetlb_restore_reserve(folio);

mm/hugetlb.c

5283

folio_clear_hugetlb_restore_reserve(folio);

mm/hugetlb.c

5288

tlb_remove_page_size(tlb, folio_page(folio, 0),

mm/hugetlb.c

5289

folio_size(folio));

mm/hugetlb.c

5341

unsigned long end, struct folio *folio,

mm/hugetlb.c

5354

folio, zap_flags);

mm/hugetlb.c

5367

struct folio *folio, unsigned long address)

mm/hugetlb.c

5412

folio, 0);

mm/hugetlb.c

5430

struct folio *old_folio;

mm/hugetlb.c

5431

struct folio *new_folio;

mm/hugetlb.c

5623

struct folio *folio;

mm/hugetlb.c

5625

folio = filemap_get_folio(mapping, idx);

mm/hugetlb.c

5626

if (IS_ERR(folio))

mm/hugetlb.c

5628

folio_put(folio);

mm/hugetlb.c

5632

int hugetlb_add_to_page_cache(struct folio *folio, struct address_space *mapping,

mm/hugetlb.c

5640

__folio_set_locked(folio);

mm/hugetlb.c

5641

err = __filemap_add_folio(mapping, folio, idx, GFP_KERNEL, NULL);

mm/hugetlb.c

5644

__folio_clear_locked(folio);

mm/hugetlb.c

5647

folio_clear_hugetlb_restore_reserve(folio);

mm/hugetlb.c

5653

folio_mark_dirty(folio);

mm/hugetlb.c

5705

struct folio *folio;

mm/hugetlb.c

5726

folio = filemap_lock_hugetlb_folio(h, mapping, vmf->pgoff);

mm/hugetlb.c

5727

if (IS_ERR(folio)) {

mm/hugetlb.c

5765

folio = alloc_hugetlb_folio(vma, vmf->address, false);

mm/hugetlb.c

5766

if (IS_ERR(folio)) {

mm/hugetlb.c

5780

ret = vmf_error(PTR_ERR(folio));

mm/hugetlb.c

5785

folio_zero_user(folio, vmf->real_address);

mm/hugetlb.c

5786

__folio_mark_uptodate(folio);

mm/hugetlb.c

5790

int err = hugetlb_add_to_page_cache(folio, mapping,

mm/hugetlb.c

5801

folio);

mm/hugetlb.c

5802

folio_put(folio);

mm/hugetlb.c

5808

folio_lock(folio);

mm/hugetlb.c

5816

if (unlikely(folio_test_hwpoison(folio))) {

mm/hugetlb.c

5824

folio_unlock(folio);

mm/hugetlb.c

5825

folio_put(folio);

mm/hugetlb.c

5858

hugetlb_add_new_anon_rmap(folio, vma, vmf->address);

mm/hugetlb.c

5860

hugetlb_add_file_rmap(folio);

mm/hugetlb.c

5861

new_pte = make_huge_pte(vma, folio, vma->vm_flags & VM_SHARED);

mm/hugetlb.c

5878

folio_unlock(folio);

mm/hugetlb.c

5892

folio_set_hugetlb_migratable(folio);

mm/hugetlb.c

5895

folio_unlock(folio);

mm/hugetlb.c

5914

restore_reserve_on_error(h, vma, vmf->address, folio);

mm/hugetlb.c

5916

folio_unlock(folio);

mm/hugetlb.c

5917

folio_put(folio);

mm/hugetlb.c

5950

struct folio *folio = NULL;

mm/hugetlb.c

6087

folio = page_folio(pte_page(vmf.orig_pte));

mm/hugetlb.c

6088

if (folio_test_anon(folio) && !folio_trylock(folio)) {

mm/hugetlb.c

6092

folio_get(folio);

mm/hugetlb.c

6094

if (folio_test_anon(folio))

mm/hugetlb.c

6095

folio_unlock(folio);

mm/hugetlb.c

6096

folio_put(folio);

mm/hugetlb.c

6132

folio_wait_locked(folio);

mm/hugetlb.c

6140

static struct folio *alloc_hugetlb_folio_vma(struct hstate *h,

mm/hugetlb.c

6145

struct folio *folio;

mm/hugetlb.c

6157

folio = alloc_hugetlb_folio_nodemask(h, node, nodemask, gfp_mask, false);

mm/hugetlb.c

6160

return folio;

mm/hugetlb.c

6172

struct folio **foliop)

mm/hugetlb.c

6185

struct folio *folio;

mm/hugetlb.c

6210

folio = filemap_lock_hugetlb_folio(h, mapping, idx);

mm/hugetlb.c

6211

if (IS_ERR(folio))

mm/hugetlb.c

6224

folio = alloc_hugetlb_folio(dst_vma, dst_addr, false);

mm/hugetlb.c

6225

if (IS_ERR(folio)) {

mm/hugetlb.c

6235

ret = copy_folio_from_user(folio, (const void __user *) src_addr,

mm/hugetlb.c

6244

restore_reserve_on_error(h, dst_vma, dst_addr, folio);

mm/hugetlb.c

6245

folio_put(folio);

mm/hugetlb.c

6250

folio = alloc_hugetlb_folio_vma(h, dst_vma, dst_addr);

mm/hugetlb.c

6251

if (!folio) {

mm/hugetlb.c

6255

*foliop = folio;

mm/hugetlb.c

6271

folio = alloc_hugetlb_folio(dst_vma, dst_addr, false);

mm/hugetlb.c

6272

if (IS_ERR(folio)) {

mm/hugetlb.c

6278

ret = copy_user_large_folio(folio, *foliop, dst_addr, dst_vma);

mm/hugetlb.c

6282

restore_reserve_on_error(h, dst_vma, dst_addr, folio);

mm/hugetlb.c

6283

folio_put(folio);

mm/hugetlb.c

6300

__folio_mark_uptodate(folio);

mm/hugetlb.c

6302

WARN_ON_ONCE(!folio_test_uptodate(folio));

mm/hugetlb.c

6316

ret = hugetlb_add_to_page_cache(folio, mapping, idx);

mm/hugetlb.c

6325

if (folio_test_hwpoison(folio))

mm/hugetlb.c

6339

hugetlb_add_file_rmap(folio);

mm/hugetlb.c

6341

hugetlb_add_new_anon_rmap(folio, dst_vma, dst_addr);

mm/hugetlb.c

6347

_dst_pte = make_huge_pte(dst_vma, folio,

mm/hugetlb.c

6370

folio_set_hugetlb_migratable(folio);

mm/hugetlb.c

6372

folio_unlock(folio);

mm/hugetlb.c

6379

folio_unlock(folio);

mm/hugetlb.c

6382

restore_reserve_on_error(h, dst_vma, dst_addr, folio);

mm/hugetlb.c

6383

folio_put(folio);

mm/hugetlb.c

6468

struct folio *folio = softleaf_to_folio(entry);

mm/hugetlb.c

6472

if (folio_test_anon(folio))

mm/hugetlb.c

7132

bool folio_isolate_hugetlb(struct folio *folio, struct list_head *list)

mm/hugetlb.c

7137

if (!folio_test_hugetlb(folio) ||

mm/hugetlb.c

7138

!folio_test_hugetlb_migratable(folio) ||

mm/hugetlb.c

7139

!folio_try_get(folio)) {

mm/hugetlb.c

7143

folio_clear_hugetlb_migratable(folio);

mm/hugetlb.c

7144

list_move_tail(&folio->lru, list);

mm/hugetlb.c

7150

int get_hwpoison_hugetlb_folio(struct folio *folio, bool *hugetlb, bool unpoison)

mm/hugetlb.c

7156

if (folio_test_hugetlb(folio)) {

mm/hugetlb.c

7158

if (folio_test_hugetlb_freed(folio))

mm/hugetlb.c

7160

else if (folio_test_hugetlb_migratable(folio) || unpoison)

mm/hugetlb.c

7161

ret = folio_try_get(folio);

mm/hugetlb.c

7180

void folio_putback_hugetlb(struct folio *folio)

mm/hugetlb.c

7183

folio_set_hugetlb_migratable(folio);

mm/hugetlb.c

7184

list_move_tail(&folio->lru, &(folio_hstate(folio))->hugepage_activelist);

mm/hugetlb.c

7186

folio_put(folio);

mm/hugetlb.c

7189

void move_hugetlb_state(struct folio *old_folio, struct folio *new_folio, int reason)

mm/hugetlb_cgroup.c

187

struct folio *folio)

mm/hugetlb_cgroup.c

194

hcg = hugetlb_cgroup_from_folio(folio);

mm/hugetlb_cgroup.c

203

nr_pages = folio_nr_pages(folio);

mm/hugetlb_cgroup.c

213

set_hugetlb_cgroup(folio, parent);

mm/hugetlb_cgroup.c

226

struct folio *folio;

mm/hugetlb_cgroup.c

231

list_for_each_entry(folio, &h->hugepage_activelist, lru)

mm/hugetlb_cgroup.c

232

hugetlb_cgroup_move_parent(hstate_index(h), h_cg, folio);

mm/hugetlb_cgroup.c

305

struct folio *folio, bool rsvd)

mm/hugetlb_cgroup.c

310

__set_hugetlb_cgroup(folio, h_cg, rsvd);

mm/hugetlb_cgroup.c

313

h_cg->nodeinfo[folio_nid(folio)]->usage[idx];

mm/hugetlb_cgroup.c

319

WRITE_ONCE(h_cg->nodeinfo[folio_nid(folio)]->usage[idx],

mm/hugetlb_cgroup.c

326

struct folio *folio)

mm/hugetlb_cgroup.c

328

__hugetlb_cgroup_commit_charge(idx, nr_pages, h_cg, folio, false);

mm/hugetlb_cgroup.c

333

struct folio *folio)

mm/hugetlb_cgroup.c

335

__hugetlb_cgroup_commit_charge(idx, nr_pages, h_cg, folio, true);

mm/hugetlb_cgroup.c

342

struct folio *folio, bool rsvd)

mm/hugetlb_cgroup.c

349

h_cg = __hugetlb_cgroup_from_folio(folio, rsvd);

mm/hugetlb_cgroup.c

352

__set_hugetlb_cgroup(folio, NULL, rsvd);

mm/hugetlb_cgroup.c

362

h_cg->nodeinfo[folio_nid(folio)]->usage[idx];

mm/hugetlb_cgroup.c

368

WRITE_ONCE(h_cg->nodeinfo[folio_nid(folio)]->usage[idx],

mm/hugetlb_cgroup.c

374

struct folio *folio)

mm/hugetlb_cgroup.c

376

__hugetlb_cgroup_uncharge_folio(idx, nr_pages, folio, false);

mm/hugetlb_cgroup.c

380

struct folio *folio)

mm/hugetlb_cgroup.c

382

__hugetlb_cgroup_uncharge_folio(idx, nr_pages, folio, true);

mm/hugetlb_cgroup.c

888

void hugetlb_cgroup_migrate(struct folio *old_folio, struct folio *new_folio)

mm/hugetlb_cma.c

21

void hugetlb_cma_free_frozen_folio(struct folio *folio)

mm/hugetlb_cma.c

23

WARN_ON_ONCE(!cma_release_frozen(hugetlb_cma[folio_nid(folio)],

mm/hugetlb_cma.c

24

&folio->page, folio_nr_pages(folio)));

mm/hugetlb_cma.c

27

struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,

mm/hugetlb_cma.c

31

struct folio *folio;

mm/hugetlb_cma.c

54

folio = page_folio(page);

mm/hugetlb_cma.c

55

folio_set_hugetlb_cma(folio);

mm/hugetlb_cma.c

56

return folio;

mm/hugetlb_cma.h

16

static inline void hugetlb_cma_free_frozen_folio(struct folio *folio)

mm/hugetlb_cma.h

20

static inline struct folio *hugetlb_cma_alloc_frozen_folio(int order,

mm/hugetlb_cma.h

6

void hugetlb_cma_free_frozen_folio(struct folio *folio);

mm/hugetlb_cma.h

7

struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,

mm/hugetlb_internal.h

95

extern void remove_hugetlb_folio(struct hstate *h, struct folio *folio,

mm/hugetlb_internal.h

97

extern void add_hugetlb_folio(struct hstate *h, struct folio *folio,

mm/hugetlb_internal.h

99

extern void init_new_hugetlb_folio(struct folio *folio);

mm/hugetlb_vmemmap.c

396

struct folio *folio, unsigned long flags)

mm/hugetlb_vmemmap.c

401

VM_WARN_ON_ONCE_FOLIO(!folio_test_hugetlb(folio), folio);

mm/hugetlb_vmemmap.c

402

VM_WARN_ON_ONCE_FOLIO(folio_ref_count(folio), folio);

mm/hugetlb_vmemmap.c

404

if (!folio_test_hugetlb_vmemmap_optimized(folio))

mm/hugetlb_vmemmap.c

407

vmemmap_start = (unsigned long)&folio->page;

mm/hugetlb_vmemmap.c

420

folio_clear_hugetlb_vmemmap_optimized(folio);

mm/hugetlb_vmemmap.c

435

int hugetlb_vmemmap_restore_folio(const struct hstate *h, struct folio *folio)

mm/hugetlb_vmemmap.c

437

return __hugetlb_vmemmap_restore_folio(h, folio, 0);

mm/hugetlb_vmemmap.c

457

struct folio *folio, *t_folio;

mm/hugetlb_vmemmap.c

462

list_for_each_entry_safe(folio, t_folio, folio_list, lru) {

mm/hugetlb_vmemmap.c

463

if (folio_test_hugetlb_vmemmap_optimized(folio)) {

mm/hugetlb_vmemmap.c

464

ret = __hugetlb_vmemmap_restore_folio(h, folio, flags);

mm/hugetlb_vmemmap.c

471

list_move(&folio->lru, non_hvo_folios);

mm/hugetlb_vmemmap.c

482

static bool vmemmap_should_optimize_folio(const struct hstate *h, struct folio *folio)

mm/hugetlb_vmemmap.c

484

if (folio_test_hugetlb_vmemmap_optimized(folio))

mm/hugetlb_vmemmap.c

523

struct folio *folio,

mm/hugetlb_vmemmap.c

531

VM_WARN_ON_ONCE_FOLIO(!folio_test_hugetlb(folio), folio);

mm/hugetlb_vmemmap.c

532

VM_WARN_ON_ONCE_FOLIO(folio_ref_count(folio), folio);

mm/hugetlb_vmemmap.c

534

if (!vmemmap_should_optimize_folio(h, folio))

mm/hugetlb_vmemmap.c

537

nid = folio_nid(folio);

mm/hugetlb_vmemmap.c

538

vmemmap_tail = vmemmap_get_tail(h->order, folio_zone(folio));

mm/hugetlb_vmemmap.c

553

folio_set_hugetlb_vmemmap_optimized(folio);

mm/hugetlb_vmemmap.c

561

copy_page(page_to_virt(vmemmap_head), folio);

mm/hugetlb_vmemmap.c

565

vmemmap_start = (unsigned long)&folio->page;

mm/hugetlb_vmemmap.c

578

folio_clear_hugetlb_vmemmap_optimized(folio);

mm/hugetlb_vmemmap.c

593

void hugetlb_vmemmap_optimize_folio(const struct hstate *h, struct folio *folio)

mm/hugetlb_vmemmap.c

597

__hugetlb_vmemmap_optimize_folio(h, folio, &vmemmap_pages, 0);

mm/hugetlb_vmemmap.c

601

static int hugetlb_vmemmap_split_folio(const struct hstate *h, struct folio *folio)

mm/hugetlb_vmemmap.c

605

if (!vmemmap_should_optimize_folio(h, folio))

mm/hugetlb_vmemmap.c

608

vmemmap_start = (unsigned long)&folio->page;

mm/hugetlb_vmemmap.c

622

struct folio *folio;

mm/hugetlb_vmemmap.c

628

list_for_each_entry(folio, folio_list, lru) {

mm/hugetlb_vmemmap.c

632

if (boot && folio_test_hugetlb_vmemmap_optimized(folio)) {

mm/hugetlb_vmemmap.c

637

spfn = (unsigned long)&folio->page;

mm/hugetlb_vmemmap.c

639

vmemmap_wrprotect_hvo(spfn, epfn, folio_nid(folio),

mm/hugetlb_vmemmap.c

642

&folio->page,

mm/hugetlb_vmemmap.c

649

ret = hugetlb_vmemmap_split_folio(h, folio);

mm/hugetlb_vmemmap.c

673

list_for_each_entry(folio, folio_list, lru) {

mm/hugetlb_vmemmap.c

676

ret = __hugetlb_vmemmap_optimize_folio(h, folio, &vmemmap_pages, flags);

mm/hugetlb_vmemmap.c

690

__hugetlb_vmemmap_optimize_folio(h, folio, &vmemmap_pages, flags);

mm/hugetlb_vmemmap.h

23

int hugetlb_vmemmap_restore_folio(const struct hstate *h, struct folio *folio);

mm/hugetlb_vmemmap.h

27

void hugetlb_vmemmap_optimize_folio(const struct hstate *h, struct folio *folio);

mm/hugetlb_vmemmap.h

54

static inline int hugetlb_vmemmap_restore_folio(const struct hstate *h, struct folio *folio)

mm/hugetlb_vmemmap.h

67

static inline void hugetlb_vmemmap_optimize_folio(const struct hstate *h, struct folio *folio)

mm/hwpoison-inject.c

106

struct folio *folio;

mm/hwpoison-inject.c

116

folio = page_folio(p);

mm/hwpoison-inject.c

121

shake_folio(folio);

mm/hwpoison-inject.c

125

if (!folio_test_lru(folio) && !folio_test_hugetlb(folio) &&

mm/hwpoison-inject.c

134

err = hwpoison_filter(&folio->page);

mm/hwpoison-inject.c

22

struct folio *folio = page_folio(p);

mm/hwpoison-inject.c

30

mapping = folio_mapping(folio);

mm/internal.h

1116

struct anon_vma *folio_anon_vma(const struct folio *folio);

mm/internal.h

1119

void unmap_mapping_folio(struct folio *folio);

mm/internal.h

1143

folio_within_range(struct folio *folio, struct vm_area_struct *vma,

mm/internal.h

1149

VM_WARN_ON_FOLIO(folio_test_ksm(folio), folio);

mm/internal.h

1159

pgoff = folio_pgoff(folio);

mm/internal.h

1167

return !(addr < start || end - addr < folio_size(folio));

mm/internal.h

1171

folio_within_vma(struct folio *folio, struct vm_area_struct *vma)

mm/internal.h

1173

return folio_within_range(folio, vma, vma->vm_start, vma->vm_end);

mm/internal.h

1185

void mlock_folio(struct folio *folio);

mm/internal.h

1186

static inline void mlock_vma_folio(struct folio *folio,

mm/internal.h

1198

mlock_folio(folio);

mm/internal.h

1201

void munlock_folio(struct folio *folio);

mm/internal.h

1202

static inline void munlock_vma_folio(struct folio *folio,

mm/internal.h

1215

munlock_folio(folio);

mm/internal.h

1218

void mlock_new_folio(struct folio *folio);

mm/internal.h

126

static inline int folio_nr_pages_mapped(const struct folio *folio)

mm/internal.h

130

return atomic_read(&folio->_nr_pages_mapped) & FOLIO_PAGES_MAPPED;

mm/internal.h

1309

static inline void unmap_mapping_folio(struct folio *folio) { }

mm/internal.h

1310

static inline void mlock_new_folio(struct folio *folio) { }

mm/internal.h

139

const struct folio *folio)

mm/internal.h

1410

int unmap_poisoned_folio(struct folio *folio, unsigned long pfn, bool must_kill);

mm/internal.h

1411

void shake_folio(struct folio *folio);

mm/internal.h

142

.val = ALIGN_DOWN(entry.val, folio_nr_pages(folio)),

mm/internal.h

1429

static inline int unmap_poisoned_folio(struct folio *folio, unsigned long pfn, bool must_kill)

mm/internal.h

148

static inline void *folio_raw_mapping(const struct folio *folio)

mm/internal.h

150

unsigned long mapping = (unsigned long)folio->mapping;

mm/internal.h

1527

struct folio *folio, loff_t fpos, size_t size);

mm/internal.h

1569

bool folio_can_map_prot_numa(struct folio *folio, struct vm_area_struct *vma,

mm/internal.h

1573

static inline bool folio_can_map_prot_numa(struct folio *folio,

mm/internal.h

1580

int numa_migrate_check(struct folio *folio, struct vm_fault *vmf,

mm/internal.h

1584

void free_zone_device_folio(struct folio *folio);

mm/internal.h

1585

int migrate_device_coherent_folio(struct folio *folio);

mm/internal.h

1596

int __must_check try_grab_folio(struct folio *folio, int refs,

mm/internal.h

1764

int shmem_add_to_page_cache(struct folio *folio,

mm/internal.h

248

struct anon_vma *folio_get_anon_vma(const struct folio *folio);

mm/internal.h

337

static inline unsigned int folio_pte_batch_flags(struct folio *folio,

mm/internal.h

345

VM_WARN_ON_FOLIO(!pte_present(pte), folio);

mm/internal.h

346

VM_WARN_ON_FOLIO(!folio_test_large(folio) || max_nr < 1, folio);

mm/internal.h

347

VM_WARN_ON_FOLIO(page_folio(pfn_to_page(pte_pfn(pte))) != folio, folio);

mm/internal.h

357

folio_pfn(folio) + folio_nr_pages(folio) - pte_pfn(pte));

mm/internal.h

392

unsigned int folio_pte_batch(struct folio *folio, pte_t *ptep, pte_t pte,

mm/internal.h

471

void __acct_reclaim_writeback(pg_data_t *pgdat, struct folio *folio,

mm/internal.h

473

static inline void acct_reclaim_writeback(struct folio *folio)

mm/internal.h

475

pg_data_t *pgdat = folio_pgdat(folio);

mm/internal.h

479

__acct_reclaim_writeback(pgdat, folio, nr_throttled);

mm/internal.h

502

void folio_rotate_reclaimable(struct folio *folio);

mm/internal.h

503

bool __folio_end_writeback(struct folio *folio);

mm/internal.h

504

void deactivate_file_folio(struct folio *folio);

mm/internal.h

505

void folio_activate(struct folio *folio);

mm/internal.h

535

int folio_unmap_invalidate(struct address_space *mapping, struct folio *folio,

mm/internal.h

551

int truncate_inode_folio(struct address_space *mapping, struct folio *folio);

mm/internal.h

552

bool truncate_inode_partial_folio(struct folio *folio, loff_t start,

mm/internal.h

554

long mapping_evict_folio(struct address_space *mapping, struct folio *folio);

mm/internal.h

569

static inline bool folio_evictable(struct folio *folio)

mm/internal.h

575

ret = !mapping_unevictable(folio_mapping(folio)) &&

mm/internal.h

576

!folio_test_mlocked(folio);

mm/internal.h

603

static inline bool folio_needs_release(struct folio *folio)

mm/internal.h

605

struct address_space *mapping = folio_mapping(folio);

mm/internal.h

607

return folio_has_private(folio) ||

mm/internal.h

622

bool folio_isolate_lru(struct folio *folio);

mm/internal.h

623

void folio_putback_lru(struct folio *folio);

mm/internal.h

834

static inline void folio_set_order(struct folio *folio, unsigned int order)

mm/internal.h

836

if (WARN_ON_ONCE(!order || !folio_test_large(folio)))

mm/internal.h

840

folio->_flags_1 = (folio->_flags_1 & ~0xffUL) | order;

mm/internal.h

842

folio->_nr_pages = 1U << order;

mm/internal.h

846

bool __folio_unqueue_deferred_split(struct folio *folio);

mm/internal.h

847

static inline bool folio_unqueue_deferred_split(struct folio *folio)

mm/internal.h

849

if (folio_order(folio) <= 1 || !folio_test_large_rmappable(folio))

mm/internal.h

857

if (data_race(list_empty(&folio->_deferred_list)))

mm/internal.h

860

return __folio_unqueue_deferred_split(folio);

mm/internal.h

863

static inline struct folio *page_rmappable_folio(struct page *page)

mm/internal.h

865

struct folio *folio = (struct folio *)page;

mm/internal.h

867

if (folio && folio_test_large(folio))

mm/internal.h

868

folio_set_large_rmappable(folio);

mm/internal.h

869

return folio;

mm/internal.h

874

struct folio *folio = (struct folio *)page;

mm/internal.h

876

folio_set_order(folio, order);

mm/internal.h

877

atomic_set(&folio->_large_mapcount, -1);

mm/internal.h

879

atomic_set(&folio->_nr_pages_mapped, 0);

mm/internal.h

881

folio->_mm_ids = 0;

mm/internal.h

882

folio->_mm_id_mapcount[0] = -1;

mm/internal.h

883

folio->_mm_id_mapcount[1] = -1;

mm/internal.h

886

atomic_set(&folio->_pincount, 0);

mm/internal.h

887

atomic_set(&folio->_entire_mapcount, -1);

mm/internal.h

890

INIT_LIST_HEAD(&folio->_deferred_list);

mm/khugepaged.c

1238

static enum scan_result alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,

mm/khugepaged.c

1244

struct folio *folio;

mm/khugepaged.c

1246

folio = __folio_alloc(gfp, order, node, &cc->alloc_nmask);

mm/khugepaged.c

1247

if (!folio) {

mm/khugepaged.c

1259

if (unlikely(mem_cgroup_charge(folio, mm, gfp))) {

mm/khugepaged.c

1260

folio_put(folio);

mm/khugepaged.c

1266

count_memcg_folio_events(folio, THP_COLLAPSE_ALLOC, 1);

mm/khugepaged.c

1268

*foliop = folio;

mm/khugepaged.c

1288

struct folio *folio;

mm/khugepaged.c

1295

result = alloc_charge_folio(&folio, mm, cc, order);

mm/khugepaged.c

1299

if (folio_memcg_alloc_deferred(folio)) {

mm/khugepaged.c

1412

result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,

mm/khugepaged.c

1423

__folio_mark_uptodate(folio);

mm/khugepaged.c

1429

map_anon_folio_pmd_nopf(folio, pmd, vma, pmd_addr);

mm/khugepaged.c

1440

map_anon_folio_pte_nopf(folio, pte, vma, start_addr,

mm/khugepaged.c

1447

folio = NULL;

mm/khugepaged.c

1457

if (folio)

mm/khugepaged.c

1458

folio_put(folio);

mm/khugepaged.c

1605

struct folio *folio = NULL;

mm/khugepaged.c

1694

folio = page_folio(page);

mm/khugepaged.c

1701

folio_test_lazyfree(folio) && !pte_dirty(pteval)) {

mm/khugepaged.c

1706

if (!folio_test_anon(folio)) {

mm/khugepaged.c

1715

if (folio_maybe_mapped_shared(folio)) {

mm/khugepaged.c

1733

node = folio_nid(folio);

mm/khugepaged.c

1739

if (!folio_test_lru(folio)) {

mm/khugepaged.c

1743

if (folio_test_locked(folio)) {

mm/khugepaged.c

1758

if (folio_expected_ref_count(folio) != folio_ref_count(folio)) {

mm/khugepaged.c

1768

(pte_young(pteval) || folio_test_young(folio) ||

mm/khugepaged.c

1769

folio_test_referenced(folio) ||

mm/khugepaged.c

1791

trace_mm_khugepaged_scan_pmd(mm, folio, referenced,

mm/khugepaged.c

1821

pmd_t *pmdp, struct folio *folio, struct page *page)

mm/khugepaged.c

1849

if (do_set_pmd(&vmf, folio, page))

mm/khugepaged.c

1852

folio_get(folio);

mm/khugepaged.c

1867

struct folio *folio;

mm/khugepaged.c

1899

folio = filemap_lock_folio(vma->vm_file->f_mapping,

mm/khugepaged.c

1901

if (IS_ERR(folio))

mm/khugepaged.c

1904

if (!is_pmd_order(folio_order(folio))) {

mm/khugepaged.c

1951

if (folio_page(folio, i) != page)

mm/khugepaged.c

2007

if (folio_page(folio, i) != page)

mm/khugepaged.c

2010

nr_batch_ptes = folio_pte_batch(folio, pte, ptent, max_nr_batch_ptes);

mm/khugepaged.c

2018

folio_remove_rmap_ptes(folio, page, nr_batch_ptes, vma);

mm/khugepaged.c

2027

folio_ref_sub(folio, nr_mapped_ptes);

mm/khugepaged.c

2028

add_mm_counter(mm, mm_counter_file(folio), -nr_mapped_ptes);

mm/khugepaged.c

2057

? set_huge_pmd(vma, haddr, pmd, folio, &folio->page)

mm/khugepaged.c

2063

folio_ref_sub(folio, nr_mapped_ptes);

mm/khugepaged.c

2064

add_mm_counter(mm, mm_counter_file(folio), -nr_mapped_ptes);

mm/khugepaged.c

2074

folio_unlock(folio);

mm/khugepaged.c

2075

folio_put(folio);

mm/khugepaged.c

2247

struct folio *folio, *tmp, *new_folio;

mm/khugepaged.c

2294

folio = xas_load(&xas);

mm/khugepaged.c

2298

if (!folio) {

mm/khugepaged.c

2315

if (xa_is_value(folio) || !folio_test_uptodate(folio)) {

mm/khugepaged.c

2319

&folio, SGP_NOALLOC)) {

mm/khugepaged.c

2325

} else if (folio_trylock(folio)) {

mm/khugepaged.c

2326

folio_get(folio);

mm/khugepaged.c

2333

if (!folio || xa_is_value(folio)) {

mm/khugepaged.c

2340

folio = filemap_lock_folio(mapping, index);

mm/khugepaged.c

2341

if (IS_ERR(folio)) {

mm/khugepaged.c

2345

} else if (folio_test_dirty(folio)) {

mm/khugepaged.c

2365

} else if (folio_test_writeback(folio)) {

mm/khugepaged.c

2369

} else if (folio_trylock(folio)) {

mm/khugepaged.c

2370

folio_get(folio);

mm/khugepaged.c

2382

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/khugepaged.c

2385

if (unlikely(!folio_test_uptodate(folio))) {

mm/khugepaged.c

2395

if (is_pmd_order(folio_order(folio))) {

mm/khugepaged.c

2400

if (folio_mapping(folio) != mapping) {

mm/khugepaged.c

2405

if (!is_shmem && (folio_test_dirty(folio) ||

mm/khugepaged.c

2406

folio_test_writeback(folio))) {

mm/khugepaged.c

2416

if (!folio_isolate_lru(folio)) {

mm/khugepaged.c

2421

if (!filemap_release_folio(folio, GFP_KERNEL)) {

mm/khugepaged.c

2423

folio_putback_lru(folio);

mm/khugepaged.c

2427

if (folio_mapped(folio))

mm/khugepaged.c

2428

try_to_unmap(folio,

mm/khugepaged.c

2433

VM_BUG_ON_FOLIO(folio != xa_load(xas.xa, index), folio);

mm/khugepaged.c

2446

if (folio_ref_count(folio) != 2 + folio_nr_pages(folio)) {

mm/khugepaged.c

2449

folio_putback_lru(folio);

mm/khugepaged.c

2467

if (!is_shmem && folio_test_dirty(folio)) {

mm/khugepaged.c

2470

folio_putback_lru(folio);

mm/khugepaged.c

2477

list_add_tail(&folio->lru, &pagelist);

mm/khugepaged.c

2478

index += folio_nr_pages(folio);

mm/khugepaged.c

2481

folio_unlock(folio);

mm/khugepaged.c

2482

folio_put(folio);

mm/khugepaged.c

2510

list_for_each_entry(folio, &pagelist, lru) {

mm/khugepaged.c

2511

int i, nr_pages = folio_nr_pages(folio);

mm/khugepaged.c

2513

while (index < folio->index) {

mm/khugepaged.c

2520

if (copy_mc_highpage(dst, folio_page(folio, i)) > 0) {

mm/khugepaged.c

2632

list_for_each_entry_safe(folio, tmp, &pagelist, lru) {

mm/khugepaged.c

2633

list_del(&folio->lru);

mm/khugepaged.c

2634

lruvec_stat_mod_folio(folio, NR_FILE_PAGES,

mm/khugepaged.c

2635

-folio_nr_pages(folio));

mm/khugepaged.c

2637

lruvec_stat_mod_folio(folio, NR_SHMEM,

mm/khugepaged.c

2638

-folio_nr_pages(folio));

mm/khugepaged.c

2639

folio->mapping = NULL;

mm/khugepaged.c

2640

folio_clear_active(folio);

mm/khugepaged.c

2641

folio_clear_unevictable(folio);

mm/khugepaged.c

2642

folio_unlock(folio);

mm/khugepaged.c

2643

folio_put_refs(folio, 2 + folio_nr_pages(folio));

mm/khugepaged.c

2657

list_for_each_entry_safe(folio, tmp, &pagelist, lru) {

mm/khugepaged.c

2658

list_del(&folio->lru);

mm/khugepaged.c

2659

folio_unlock(folio);

mm/khugepaged.c

2660

folio_putback_lru(folio);

mm/khugepaged.c

2661

folio_put(folio);

mm/khugepaged.c

2680

struct folio *folio = NULL;

mm/khugepaged.c

2692

xas_for_each(&xas, folio, start + HPAGE_PMD_NR - 1) {

mm/khugepaged.c

2693

if (xas_retry(&xas, folio))

mm/khugepaged.c

2696

if (xa_is_value(folio)) {

mm/khugepaged.c

2706

if (!folio_try_get(folio)) {

mm/khugepaged.c

2711

if (unlikely(folio != xas_reload(&xas))) {

mm/khugepaged.c

2712

folio_put(folio);

mm/khugepaged.c

2717

if (is_pmd_order(folio_order(folio))) {

mm/khugepaged.c

2723

folio_put(folio);

mm/khugepaged.c

2727

node = folio_nid(folio);

mm/khugepaged.c

2730

folio_put(folio);

mm/khugepaged.c

2735

if (!folio_test_lru(folio)) {

mm/khugepaged.c

2737

folio_put(folio);

mm/khugepaged.c

2741

if (folio_expected_ref_count(folio) + 1 != folio_ref_count(folio)) {

mm/khugepaged.c

2743

folio_put(folio);

mm/khugepaged.c

2754

present += folio_nr_pages(folio);

mm/khugepaged.c

2755

folio_put(folio);

mm/khugepaged.c

2777

trace_mm_khugepaged_scan_file(mm, folio, file, present, swap, result);

mm/khugepaged.c

631

static void release_pte_folio(struct folio *folio)

mm/khugepaged.c

633

node_stat_mod_folio(folio,

mm/khugepaged.c

634

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/khugepaged.c

635

-folio_nr_pages(folio));

mm/khugepaged.c

636

folio_unlock(folio);

mm/khugepaged.c

637

folio_putback_lru(folio);

mm/khugepaged.c

643

struct folio *folio, *tmp;

mm/khugepaged.c

655

folio = pfn_folio(pfn);

mm/khugepaged.c

656

if (folio_test_large(folio))

mm/khugepaged.c

658

release_pte_folio(folio);

mm/khugepaged.c

661

list_for_each_entry_safe(folio, tmp, compound_pagelist, lru) {

mm/khugepaged.c

662

list_del(&folio->lru);

mm/khugepaged.c

663

release_pte_folio(folio);

mm/khugepaged.c

675

struct folio *folio = NULL;

mm/khugepaged.c

708

folio = page_folio(page);

mm/khugepaged.c

709

VM_BUG_ON_FOLIO(!folio_test_anon(folio), folio);

mm/khugepaged.c

716

folio_test_lazyfree(folio) && !pte_dirty(pteval)) {

mm/khugepaged.c

722

if (folio_maybe_mapped_shared(folio)) {

mm/khugepaged.c

741

if (!is_pmd_order(order) && folio_order(folio) >= order) {

mm/khugepaged.c

746

if (folio_test_large(folio)) {

mm/khugepaged.c

747

struct folio *f;

mm/khugepaged.c

754

if (folio == f)

mm/khugepaged.c

765

if (!folio_trylock(folio)) {

mm/khugepaged.c

781

if (folio_expected_ref_count(folio) != folio_ref_count(folio)) {

mm/khugepaged.c

782

folio_unlock(folio);

mm/khugepaged.c

791

if (!folio_isolate_lru(folio)) {

mm/khugepaged.c

792

folio_unlock(folio);

mm/khugepaged.c

796

node_stat_mod_folio(folio,

mm/khugepaged.c

797

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/khugepaged.c

798

folio_nr_pages(folio));

mm/khugepaged.c

799

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/khugepaged.c

800

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/khugepaged.c

802

if (folio_test_large(folio))

mm/khugepaged.c

803

list_add_tail(&folio->lru, compound_pagelist);

mm/khugepaged.c

810

(pte_young(pteval) || folio_test_young(folio) ||

mm/khugepaged.c

811

folio_test_referenced(folio) ||

mm/khugepaged.c

820

trace_mm_collapse_huge_page_isolate(folio, none_or_zero,

mm/khugepaged.c

826

trace_mm_collapse_huge_page_isolate(folio, none_or_zero,

mm/khugepaged.c

838

struct folio *src, *tmp;

mm/khugepaged.c

933

static enum scan_result __collapse_huge_page_copy(pte_t *pte, struct folio *folio,

mm/khugepaged.c

947

struct page *page = folio_page(folio, i);

mm/ksm.c

1000

folio_lock(folio);

mm/ksm.c

1003

if (READ_ONCE(folio->mapping) != expected_mapping) {

mm/ksm.c

1004

folio_unlock(folio);

mm/ksm.c

1005

folio_put(folio);

mm/ksm.c

1009

return folio;

mm/ksm.c

1033

struct folio *folio;

mm/ksm.c

1036

folio = ksm_get_folio(stable_node, KSM_GET_FOLIO_LOCK);

mm/ksm.c

1037

if (!folio)

mm/ksm.c

1041

folio_unlock(folio);

mm/ksm.c

1042

folio_put(folio);

mm/ksm.c

1090

struct ksm_stable_node *folio_stable_node(const struct folio *folio)

mm/ksm.c

1092

return folio_test_ksm(folio) ? folio_raw_mapping(folio) : NULL;

mm/ksm.c

1095

static inline void folio_set_stable_node(struct folio *folio,

mm/ksm.c

1098

VM_WARN_ON_FOLIO(folio_test_anon(folio) && PageAnonExclusive(&folio->page), folio);

mm/ksm.c

1099

folio->mapping = (void *)((unsigned long)stable_node | FOLIO_MAPPING_KSM);

mm/ksm.c

1108

struct folio *folio;

mm/ksm.c

1111

folio = ksm_get_folio(stable_node, KSM_GET_FOLIO_LOCK);

mm/ksm.c

1112

if (!folio) {

mm/ksm.c

1125

if (!folio_mapped(folio)) {

mm/ksm.c

1134

folio_set_stable_node(folio, NULL);

mm/ksm.c

1139

folio_unlock(folio);

mm/ksm.c

1140

folio_put(folio);

mm/ksm.c

1275

static int write_protect_page(struct vm_area_struct *vma, struct folio *folio,

mm/ksm.c

1279

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, 0, 0);

mm/ksm.c

1286

if (WARN_ON_ONCE(folio_test_large(folio)))

mm/ksm.c

1289

pvmw.address = page_address_in_vma(folio, folio_page(folio, 0), vma);

mm/ksm.c

1310

anon_exclusive = PageAnonExclusive(&folio->page);

mm/ksm.c

1313

swapped = folio_test_swapcache(folio);

mm/ksm.c

1314

flush_cache_page(vma, pvmw.address, folio_pfn(folio));

mm/ksm.c

1334

if (folio_mapcount(folio) + 1 + swapped != folio_ref_count(folio)) {

mm/ksm.c

1341

folio_try_share_anon_rmap_pte(folio, &folio->page)) {

mm/ksm.c

1347

folio_mark_dirty(folio);

mm/ksm.c

1378

struct folio *kfolio = page_folio(kpage);

mm/ksm.c

1380

struct folio *folio = page_folio(page);

mm/ksm.c

1390

addr = page_address_in_vma(folio, page, vma);

mm/ksm.c

1456

folio_remove_rmap_pte(folio, page, vma);

mm/ksm.c

1457

if (!folio_mapped(folio))

mm/ksm.c

1458

folio_free_swap(folio);

mm/ksm.c

1459

folio_put(folio);

mm/ksm.c

1481

struct folio *folio = page_folio(page);

mm/ksm.c

1488

if (!folio_test_anon(folio))

mm/ksm.c

1497

if (!folio_trylock(folio))

mm/ksm.c

1500

if (folio_test_large(folio)) {

mm/ksm.c

1503

folio = page_folio(page);

mm/ksm.c

1512

if (write_protect_page(vma, folio, &orig_pte) == 0) {

mm/ksm.c

1519

folio_set_stable_node(folio, NULL);

mm/ksm.c

1520

folio_mark_accessed(folio);

mm/ksm.c

1525

if (!folio_test_dirty(folio))

mm/ksm.c

1526

folio_mark_dirty(folio);

mm/ksm.c

1533

folio_unlock(folio);

mm/ksm.c

1621

static struct folio *try_to_merge_two_pages(struct ksm_rmap_item *rmap_item,

mm/ksm.c

1662

static struct folio *stable_node_dup(struct ksm_stable_node **_stable_node_dup,

mm/ksm.c

1669

struct folio *folio, *tree_folio = NULL;

mm/ksm.c

1693

folio = ksm_get_folio(dup, KSM_GET_FOLIO_NOLOCK);

mm/ksm.c

1694

if (!folio)

mm/ksm.c

1704

tree_folio = folio;

mm/ksm.c

1711

folio_put(folio);

mm/ksm.c

1790

static struct folio *__stable_node_chain(struct ksm_stable_node **_stable_node_dup,

mm/ksm.c

1805

static __always_inline struct folio *chain_prune(struct ksm_stable_node **s_n_d,

mm/ksm.c

1812

static __always_inline struct folio *chain(struct ksm_stable_node **s_n_d,

mm/ksm.c

1828

static struct folio *stable_tree_search(struct page *page)

mm/ksm.c

1836

struct folio *folio;

mm/ksm.c

1838

folio = page_folio(page);

mm/ksm.c

1839

page_node = folio_stable_node(folio);

mm/ksm.c

1842

folio_get(folio);

mm/ksm.c

1843

return folio;

mm/ksm.c

1846

nid = get_kpfn_nid(folio_pfn(folio));

mm/ksm.c

1853

struct folio *tree_folio;

mm/ksm.c

1892

if (folio_mapcount(folio) > 1)

mm/ksm.c

1951

folio_get(folio);

mm/ksm.c

1952

return folio;

mm/ksm.c

1977

folio_get(folio);

mm/ksm.c

1979

folio = NULL;

mm/ksm.c

1982

folio = NULL;

mm/ksm.c

1993

folio_get(folio);

mm/ksm.c

1995

folio = NULL;

mm/ksm.c

1997

folio = NULL;

mm/ksm.c

2002

return folio;

mm/ksm.c

2042

static struct ksm_stable_node *stable_tree_insert(struct folio *kfolio)

mm/ksm.c

2060

struct folio *tree_folio;

mm/ksm.c

2253

struct folio *folio = page_folio(page);

mm/ksm.c

2257

struct folio *kfolio;

mm/ksm.c

2262

stable_node = folio_stable_node(folio);

mm/ksm.c

2301

if (kfolio == folio && rmap_item->head == stable_node) {

mm/ksm.c

2382

if (!folio_trylock(folio))

mm/ksm.c

2385

folio = page_folio(page);

mm/ksm.c

2386

folio_unlock(folio);

mm/ksm.c

2445

static bool should_skip_rmap_item(struct folio *folio,

mm/ksm.c

2458

if (folio_test_ksm(folio))

mm/ksm.c

2489

struct folio *folio;

mm/ksm.c

2501

struct folio *folio;

mm/ksm.c

2525

folio = page_folio(page);

mm/ksm.c

2527

if (folio_is_zone_device(folio) || !folio_test_anon(folio))

mm/ksm.c

2549

folio = page_folio(page);

mm/ksm.c

2551

if (folio_is_zone_device(folio) || !folio_test_anon(folio))

mm/ksm.c

2562

folio_get(folio);

mm/ksm.c

2567

private->folio = folio;

mm/ksm.c

2615

struct folio *folio;

mm/ksm.c

2619

folio = ksm_get_folio(stable_node,

mm/ksm.c

2621

if (folio)

mm/ksm.c

2622

folio_put(folio);

mm/ksm.c

2666

struct folio *folio;

mm/ksm.c

2679

folio = ksm_next_page_arg.folio;

mm/ksm.c

2696

if (should_skip_rmap_item(folio, rmap_item)) {

mm/ksm.c

2697

folio_put(folio);

mm/ksm.c

2704

folio_put(folio);

mm/ksm.c

3107

struct folio *ksm_might_need_to_copy(struct folio *folio,

mm/ksm.c

3110

struct page *page = folio_page(folio, 0);

mm/ksm.c

3111

struct anon_vma *anon_vma = folio_anon_vma(folio);

mm/ksm.c

3112

struct folio *new_folio;

mm/ksm.c

3114

if (folio_test_large(folio))

mm/ksm.c

3115

return folio;

mm/ksm.c

3117

if (folio_test_ksm(folio)) {

mm/ksm.c

3118

if (folio_stable_node(folio) &&

mm/ksm.c

3120

return folio; /* no need to copy it */

mm/ksm.c

3122

return folio; /* no need to copy it */

mm/ksm.c

3123

} else if (folio->index == linear_page_index(vma, addr) &&

mm/ksm.c

3125

return folio; /* still no need to copy it */

mm/ksm.c

3129

if (!folio_test_uptodate(folio))

mm/ksm.c

3130

return folio; /* let do_swap_page report the error */

mm/ksm.c

3155

void rmap_walk_ksm(struct folio *folio, struct rmap_walk_control *rwc)

mm/ksm.c

3161

VM_BUG_ON_FOLIO(!folio_test_ksm(folio), folio);

mm/ksm.c

3167

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/ksm.c

3169

stable_node = folio_stable_node(folio);

mm/ksm.c

3209

if (!rwc->rmap_one(folio, vma, addr, rwc->arg)) {

mm/ksm.c

3213

if (rwc->done && rwc->done(folio)) {

mm/ksm.c

3228

void collect_procs_ksm(const struct folio *folio, const struct page *page,

mm/ksm.c

3236

stable_node = folio_stable_node(folio);

mm/ksm.c

3269

void folio_migrate_ksm(struct folio *newfolio, struct folio *folio)

mm/ksm.c

3273

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/ksm.c

3275

VM_BUG_ON_FOLIO(newfolio->mapping != folio->mapping, newfolio);

mm/ksm.c

3277

stable_node = folio_stable_node(folio);

mm/ksm.c

3279

VM_BUG_ON_FOLIO(stable_node->kpfn != folio_pfn(folio), folio);

mm/ksm.c

3288

folio_set_stable_node(folio, NULL);

mm/ksm.c

630

struct folio *folio = NULL;

mm/ksm.c

633

folio = vm_normal_folio(walk->vma, addr, pte);

mm/ksm.c

642

folio = softleaf_to_folio(entry);

mm/ksm.c

645

found = (folio && folio_test_ksm(folio)) ||

mm/ksm.c

805

struct folio *folio;

mm/ksm.c

812

folio = folio_walk_start(&fw, vma, addr, 0);

mm/ksm.c

813

if (folio) {

mm/ksm.c

814

if (!folio_is_zone_device(folio) &&

mm/ksm.c

815

folio_test_anon(folio)) {

mm/ksm.c

816

folio_get(folio);

mm/ksm.c

949

static struct folio *ksm_get_folio(struct ksm_stable_node *stable_node,

mm/ksm.c

952

struct folio *folio;

mm/ksm.c

960

folio = pfn_folio(kpfn);

mm/ksm.c

961

if (READ_ONCE(folio->mapping) != expected_mapping)

mm/ksm.c

974

while (!folio_try_get(folio)) {

mm/ksm.c

984

if (!folio_test_swapcache(folio))

mm/ksm.c

989

if (READ_ONCE(folio->mapping) != expected_mapping) {

mm/ksm.c

990

folio_put(folio);

mm/ksm.c

995

if (!folio_trylock(folio)) {

mm/ksm.c

996

folio_put(folio);

mm/list_lru.c

631

int folio_memcg_list_lru_alloc(struct folio *folio, struct list_lru *lru,

mm/list_lru.c

642

memcg = folio_memcg(folio);

mm/list_lru.c

649

memcg = get_mem_cgroup_from_folio(folio);

mm/madvise.c

199

struct folio *folio;

mm/madvise.c

215

folio = read_swap_cache_async(entry, GFP_HIGHUSER_MOVABLE,

mm/madvise.c

217

if (folio)

mm/madvise.c

218

folio_put(folio);

mm/madvise.c

240

struct folio *folio;

mm/madvise.c

244

xas_for_each(&xas, folio, end_index) {

mm/madvise.c

248

if (!xa_is_value(folio))

mm/madvise.c

250

entry = radix_to_swp_entry(folio);

mm/madvise.c

260

folio = read_swap_cache_async(entry, mapping_gfp_mask(mapping),

mm/madvise.c

262

if (folio)

mm/madvise.c

263

folio_put(folio);

mm/madvise.c

344

struct folio *folio, pte_t *ptep,

mm/madvise.c

349

return folio_pte_batch_flags(folio, NULL, ptep, ptentp, max_nr,

mm/madvise.c

364

struct folio *folio = NULL;

mm/madvise.c

396

folio = pmd_folio(orig_pmd);

mm/madvise.c

399

if (folio_maybe_mapped_shared(folio))

mm/madvise.c

402

if (pageout_anon_only_filter && !folio_test_anon(folio))

mm/madvise.c

408

folio_get(folio);

mm/madvise.c

410

folio_lock(folio);

mm/madvise.c

411

err = split_folio(folio);

mm/madvise.c

412

folio_unlock(folio);

mm/madvise.c

413

folio_put(folio);

mm/madvise.c

427

folio_clear_referenced(folio);

mm/madvise.c

428

folio_test_clear_young(folio);

mm/madvise.c

429

if (folio_test_active(folio))

mm/madvise.c

430

folio_set_workingset(folio);

mm/madvise.c

432

if (folio_isolate_lru(folio)) {

mm/madvise.c

433

if (folio_test_unevictable(folio))

mm/madvise.c

434

folio_putback_lru(folio);

mm/madvise.c

436

list_add(&folio->lru, &folio_list);

mm/madvise.c

439

folio_deactivate(folio);

mm/madvise.c

476

folio = vm_normal_folio(vma, addr, ptent);

mm/madvise.c

477

if (!folio || folio_is_zone_device(folio))

mm/madvise.c

487

if (folio_test_large(folio)) {

mm/madvise.c

488

nr = madvise_folio_pte_batch(addr, end, folio, pte, &ptent);

mm/madvise.c

489

if (nr < folio_nr_pages(folio)) {

mm/madvise.c

492

if (folio_maybe_mapped_shared(folio))

mm/madvise.c

494

if (pageout_anon_only_filter && !folio_test_anon(folio))

mm/madvise.c

496

if (!folio_trylock(folio))

mm/madvise.c

498

folio_get(folio);

mm/madvise.c

502

err = split_folio(folio);

mm/madvise.c

503

folio_unlock(folio);

mm/madvise.c

504

folio_put(folio);

mm/madvise.c

523

if (!folio_test_lru(folio) ||

mm/madvise.c

524

folio_mapcount(folio) != folio_nr_pages(folio))

mm/madvise.c

527

if (pageout_anon_only_filter && !folio_test_anon(folio))

mm/madvise.c

542

folio_clear_referenced(folio);

mm/madvise.c

543

folio_test_clear_young(folio);

mm/madvise.c

544

if (folio_test_active(folio))

mm/madvise.c

545

folio_set_workingset(folio);

mm/madvise.c

547

if (folio_isolate_lru(folio)) {

mm/madvise.c

548

if (folio_test_unevictable(folio))

mm/madvise.c

549

folio_putback_lru(folio);

mm/madvise.c

551

list_add(&folio->lru, &folio_list);

mm/madvise.c

554

folio_deactivate(folio);

mm/madvise.c

662

struct folio *folio;

mm/madvise.c

705

folio = vm_normal_folio(vma, addr, ptent);

mm/madvise.c

706

if (!folio || folio_is_zone_device(folio))

mm/madvise.c

716

if (folio_test_large(folio)) {

mm/madvise.c

717

nr = madvise_folio_pte_batch(addr, end, folio, pte, &ptent);

mm/madvise.c

718

if (nr < folio_nr_pages(folio)) {

mm/madvise.c

721

if (folio_maybe_mapped_shared(folio))

mm/madvise.c

723

if (!folio_trylock(folio))

mm/madvise.c

725

folio_get(folio);

mm/madvise.c

729

err = split_folio(folio);

mm/madvise.c

730

folio_unlock(folio);

mm/madvise.c

731

folio_put(folio);

mm/madvise.c

744

if (folio_test_swapcache(folio) || folio_test_dirty(folio)) {

mm/madvise.c

745

if (!folio_trylock(folio))

mm/madvise.c

752

if (folio_mapcount(folio) != folio_nr_pages(folio)) {

mm/madvise.c

753

folio_unlock(folio);

mm/madvise.c

757

if (folio_test_swapcache(folio) &&

mm/madvise.c

758

!folio_free_swap(folio)) {

mm/madvise.c

759

folio_unlock(folio);

mm/madvise.c

763

folio_clear_dirty(folio);

mm/madvise.c

764

folio_unlock(folio);

mm/madvise.c

771

folio_mark_lazyfree(folio);

mm/memcontrol-v1.c

596

void memcg1_commit_charge(struct folio *folio, struct mem_cgroup *memcg)

mm/memcontrol-v1.c

601

memcg1_charge_statistics(memcg, folio_nr_pages(folio));

mm/memcontrol-v1.c

602

memcg1_check_events(memcg, folio_nid(folio));

mm/memcontrol-v1.c

618

void __memcg1_swapout(struct folio *folio, struct swap_cluster_info *ci)

mm/memcontrol-v1.c

624

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/memcontrol-v1.c

625

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/memcontrol-v1.c

626

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/memcontrol-v1.c

627

VM_BUG_ON_FOLIO(folio_ref_count(folio), folio);

mm/memcontrol-v1.c

635

objcg = folio_objcg(folio);

mm/memcontrol-v1.c

636

VM_WARN_ON_ONCE_FOLIO(!objcg, folio);

mm/memcontrol-v1.c

647

nr_entries = folio_nr_pages(folio);

mm/memcontrol-v1.c

651

__swap_cgroup_set(ci, swp_cluster_offset(folio->swap), nr_entries,

mm/memcontrol-v1.c

654

folio_unqueue_deferred_split(folio);

mm/memcontrol-v1.c

655

folio->memcg_data = 0;

mm/memcontrol-v1.c

673

memcg1_charge_statistics(memcg, -folio_nr_pages(folio));

mm/memcontrol-v1.c

675

memcg1_check_events(memcg, folio_nid(folio));

mm/memcontrol-v1.c

690

void memcg1_swapin(struct folio *folio)

mm/memcontrol-v1.c

696

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/memcontrol-v1.c

697

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/memcontrol-v1.c

719

nr_pages = folio_nr_pages(folio);

mm/memcontrol-v1.c

720

ci = swap_cluster_get_and_lock(folio);

mm/memcontrol-v1.c

721

id = __swap_cgroup_clear(ci, swp_cluster_offset(folio->swap),

mm/memcontrol-v1.h

118

static inline void memcg1_commit_charge(struct folio *folio,

mm/memcontrol-v1.h

71

void memcg1_commit_charge(struct folio *folio, struct mem_cgroup *memcg);

mm/memcontrol.c

1178

struct mem_cgroup *get_mem_cgroup_from_folio(struct folio *folio)

mm/memcontrol.c

1185

if (!folio_memcg_charged(folio))

mm/memcontrol.c

1190

memcg = folio_memcg(folio);

mm/memcontrol.c

1399

struct lruvec *folio_lruvec_lock(struct folio *folio)

mm/memcontrol.c

1405

lruvec = folio_lruvec(folio);

mm/memcontrol.c

1407

if (unlikely(lruvec_memcg(lruvec) != folio_memcg(folio))) {

mm/memcontrol.c

1427

struct lruvec *folio_lruvec_lock_irq(struct folio *folio)

mm/memcontrol.c

1433

lruvec = folio_lruvec(folio);

mm/memcontrol.c

1435

if (unlikely(lruvec_memcg(lruvec) != folio_memcg(folio))) {

mm/memcontrol.c

1456

struct lruvec *folio_lruvec_lock_irqsave(struct folio *folio,

mm/memcontrol.c

1463

lruvec = folio_lruvec(folio);

mm/memcontrol.c

1465

if (unlikely(lruvec_memcg(lruvec) != folio_memcg(folio))) {

mm/memcontrol.c

2800

static void commit_charge(struct folio *folio, struct obj_cgroup *objcg)

mm/memcontrol.c

2802

VM_BUG_ON_FOLIO(folio_memcg_charged(folio), folio);

mm/memcontrol.c

2810

folio->memcg_data = (unsigned long)objcg;

mm/memcontrol.c

3032

struct obj_cgroup *get_obj_cgroup_from_folio(struct folio *folio)

mm/memcontrol.c

3036

objcg = folio_objcg(folio);

mm/memcontrol.c

328

struct cgroup_subsys_state *get_mem_cgroup_css_from_folio(struct folio *folio)

mm/memcontrol.c

335

memcg = get_mem_cgroup_from_folio(folio);

mm/memcontrol.c

3676

void folio_split_memcg_refs(struct folio *folio, unsigned old_order,

mm/memcontrol.c

3681

if (mem_cgroup_disabled() || !folio_memcg_charged(folio))

mm/memcontrol.c

3685

obj_cgroup_get_many(folio_objcg(folio), new_refs);

mm/memcontrol.c

3831

void mem_cgroup_track_foreign_dirty_slowpath(struct folio *folio,

mm/memcontrol.c

3834

struct mem_cgroup *memcg = folio_memcg(folio);

mm/memcontrol.c

3841

trace_track_foreign_dirty(folio, wb);

mm/memcontrol.c

5117

static int charge_memcg(struct folio *folio, struct mem_cgroup *memcg,

mm/memcontrol.c

5126

ret = try_charge_memcg(memcg, gfp, folio_nr_pages(folio));

mm/memcontrol.c

5131

commit_charge(folio, objcg);

mm/memcontrol.c

5132

memcg1_commit_charge(folio, memcg);

mm/memcontrol.c

5137

int __mem_cgroup_charge(struct folio *folio, struct mm_struct *mm, gfp_t gfp)

mm/memcontrol.c

5143

ret = charge_memcg(folio, memcg, gfp);

mm/memcontrol.c

5161

int mem_cgroup_charge_hugetlb(struct folio *folio, gfp_t gfp)

mm/memcontrol.c

5175

if (charge_memcg(folio, memcg, gfp))

mm/memcontrol.c

5195

int mem_cgroup_swapin_charge_folio(struct folio *folio, unsigned short id,

mm/memcontrol.c

5210

ret = charge_memcg(folio, memcg, gfp);

mm/memcontrol.c

5251

static void uncharge_folio(struct folio *folio, struct uncharge_gather *ug)

mm/memcontrol.c

5256

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/memcontrol.c

5263

objcg = folio_objcg(folio);

mm/memcontrol.c

5273

ug->nid = folio_nid(folio);

mm/memcontrol.c

5279

nr_pages = folio_nr_pages(folio);

mm/memcontrol.c

5281

if (folio_memcg_kmem(folio)) {

mm/memcontrol.c

5290

WARN_ON_ONCE(folio_unqueue_deferred_split(folio));

mm/memcontrol.c

5293

folio->memcg_data = 0;

mm/memcontrol.c

5297

void __mem_cgroup_uncharge(struct folio *folio)

mm/memcontrol.c

5302

if (!folio_memcg_charged(folio))

mm/memcontrol.c

5306

uncharge_folio(folio, &ug);

mm/memcontrol.c

5332

void mem_cgroup_replace_folio(struct folio *old, struct folio *new)

mm/memcontrol.c

5381

void mem_cgroup_migrate(struct folio *old, struct folio *new)

mm/memcontrol.c

5582

int __mem_cgroup_try_charge_swap(struct folio *folio)

mm/memcontrol.c

5584

unsigned int nr_pages = folio_nr_pages(folio);

mm/memcontrol.c

5593

objcg = folio_objcg(folio);

mm/memcontrol.c

5594

VM_WARN_ON_ONCE_FOLIO(!objcg, folio);

mm/memcontrol.c

5600

if (!folio_test_swapcache(folio)) {

mm/memcontrol.c

5619

ci = swap_cluster_get_and_lock(folio);

mm/memcontrol.c

5620

__swap_cgroup_set(ci, swp_cluster_offset(folio->swap), nr_pages,

mm/memcontrol.c

5664

bool mem_cgroup_swap_full(struct folio *folio)

mm/memcontrol.c

5669

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/memcontrol.c

5673

if (do_memsw_account() || !folio_memcg_charged(folio))

mm/memcontrol.c

5677

memcg = folio_memcg(folio);

mm/memcontrol.c

976

void lruvec_stat_mod_folio(struct folio *folio, enum node_stat_item idx,

mm/memcontrol.c

980

pg_data_t *pgdat = folio_pgdat(folio);

mm/memcontrol.c

984

memcg = folio_memcg(folio);

mm/memfd.c

106

folio_zero_user(folio, 0);

mm/memfd.c

112

__folio_mark_uptodate(folio);

mm/memfd.c

122

err = hugetlb_add_to_page_cache(folio,

mm/memfd.c

129

folio_put(folio);

mm/memfd.c

133

hugetlb_set_folio_subpool(folio, subpool_inode(inode));

mm/memfd.c

134

folio_unlock(folio);

mm/memfd.c

135

return folio;

mm/memfd.c

158

struct folio *folio;

mm/memfd.c

177

xas_for_each_marked(&xas, folio, ULONG_MAX, MEMFD_TAG_PINNED) {

mm/memfd.c

180

if (!xa_is_value(folio) &&

mm/memfd.c

181

memfd_folio_has_extra_refs(folio)) {

mm/memfd.c

32

static bool memfd_folio_has_extra_refs(struct folio *folio)

mm/memfd.c

34

return folio_ref_count(folio) != folio_expected_ref_count(folio);

mm/memfd.c

39

struct folio *folio;

mm/memfd.c

45

xas_for_each(xas, folio, ULONG_MAX) {

mm/memfd.c

46

if (!xa_is_value(folio) && memfd_folio_has_extra_refs(folio))

mm/memfd.c

67

struct folio *memfd_alloc_folio(struct file *memfd, pgoff_t idx)

mm/memfd.c

70

struct folio *folio;

mm/memfd.c

93

folio = alloc_hugetlb_folio_reserve(h,

mm/memfd.c

97

if (folio) {

mm/memfd_luo.c

150

struct folio *folio = folios[i];

mm/memfd_luo.c

152

err = kho_preserve_folio(folio);

mm/memfd_luo.c

156

folio_lock(folio);

mm/memfd_luo.c

177

folio_mark_dirty(folio);

mm/memfd_luo.c

191

if (!folio_test_uptodate(folio)) {

mm/memfd_luo.c

192

folio_zero_range(folio, 0, folio_size(folio));

mm/memfd_luo.c

193

flush_dcache_folio(folio);

mm/memfd_luo.c

194

folio_mark_uptodate(folio);

mm/memfd_luo.c

197

folio_unlock(folio);

mm/memfd_luo.c

199

pfolio->pfn = folio_pfn(folio);

mm/memfd_luo.c

201

pfolio->index = folio->index;

mm/memfd_luo.c

244

struct folio *folio;

mm/memfd_luo.c

249

folio = pfn_folio(pfolio->pfn);

mm/memfd_luo.c

251

kho_unpreserve_folio(folio);

mm/memfd_luo.c

252

unpin_folio(folio);

mm/memfd_luo.c

369

struct folio *folio;

mm/memfd_luo.c

376

folio = kho_restore_folio(phys);

mm/memfd_luo.c

377

if (!folio) {

mm/memfd_luo.c

383

folio_put(folio);

mm/memfd_luo.c

423

struct folio *folio;

mm/memfd_luo.c

438

folio = kho_restore_folio(phys);

mm/memfd_luo.c

439

if (!folio) {

mm/memfd_luo.c

449

__folio_set_locked(folio);

mm/memfd_luo.c

450

__folio_set_swapbacked(folio);

mm/memfd_luo.c

452

err = mem_cgroup_charge(folio, NULL, mapping_gfp_mask(mapping));

mm/memfd_luo.c

459

err = shmem_add_to_page_cache(folio, mapping, index, NULL,

mm/memfd_luo.c

468

folio_mark_uptodate(folio);

mm/memfd_luo.c

470

folio_mark_dirty(folio);

mm/memfd_luo.c

472

npages = folio_nr_pages(folio);

mm/memfd_luo.c

481

folio_add_lru(folio);

mm/memfd_luo.c

482

folio_unlock(folio);

mm/memfd_luo.c

483

folio_put(folio);

mm/memfd_luo.c

491

filemap_remove_folio(folio);

mm/memfd_luo.c

493

folio_unlock(folio);

mm/memfd_luo.c

494

folio_put(folio);

mm/memfd_luo.c

508

folio = kho_restore_folio(phys);

mm/memfd_luo.c

509

if (folio)

mm/memfd_luo.c

510

folio_put(folio);

mm/memfd_luo.c

96

struct folio **folios;

mm/memory-failure.c

1010

struct folio *folio = page_folio(p);

mm/memory-failure.c

1015

delete_from_lru_cache(folio);

mm/memory-failure.c

1021

if (folio_test_anon(folio)) {

mm/memory-failure.c

1033

mapping = folio_mapping(folio);

mm/memory-failure.c

1051

ret = truncate_error_folio(folio, page_to_pfn(p), mapping);

mm/memory-failure.c

1056

folio_unlock(folio);

mm/memory-failure.c

1068

struct folio *folio = page_folio(p);

mm/memory-failure.c

1069

struct address_space *mapping = folio_mapping(folio);

mm/memory-failure.c

1106

struct folio *folio = page_folio(p);

mm/memory-failure.c

1110

folio_clear_dirty(folio);

mm/memory-failure.c

1112

folio_clear_uptodate(folio);

mm/memory-failure.c

1114

ret = delete_from_lru_cache(folio) ? MF_FAILED : MF_DELAYED;

mm/memory-failure.c

1115

folio_unlock(folio);

mm/memory-failure.c

1128

struct folio *folio = page_folio(p);

mm/memory-failure.c

1131

swap_cache_del_folio(folio);

mm/memory-failure.c

1133

ret = delete_from_lru_cache(folio) ? MF_FAILED : MF_RECOVERED;

mm/memory-failure.c

1134

folio_unlock(folio);

mm/memory-failure.c

1150

struct folio *folio = page_folio(p);

mm/memory-failure.c

1155

mapping = folio_mapping(folio);

mm/memory-failure.c

1157

res = truncate_error_folio(folio, page_to_pfn(p), mapping);

mm/memory-failure.c

1160

folio_unlock(folio);

mm/memory-failure.c

1162

folio_unlock(folio);

mm/memory-failure.c

1168

folio_put(folio);

mm/memory-failure.c

1344

struct folio *folio = page_folio(page);

mm/memory-failure.c

1348

ret = get_hwpoison_hugetlb_folio(folio, &hugetlb, false);

mm/memory-failure.c

1351

if (folio == page_folio(page))

mm/memory-failure.c

1354

folio_put(folio);

mm/memory-failure.c

1355

folio = page_folio(page);

mm/memory-failure.c

1364

if (!HWPoisonHandlable(&folio->page, flags))

mm/memory-failure.c

1367

if (folio_try_get(folio)) {

mm/memory-failure.c

1368

if (folio == page_folio(page))

mm/memory-failure.c

1372

folio_put(folio);

mm/memory-failure.c

1443

struct folio *folio = page_folio(page);

mm/memory-failure.c

1447

ret = get_hwpoison_hugetlb_folio(folio, &hugetlb, true);

mm/memory-failure.c

1450

if (folio == page_folio(page))

mm/memory-failure.c

1453

folio_put(folio);

mm/memory-failure.c

1512

int unmap_poisoned_folio(struct folio *folio, unsigned long pfn, bool must_kill)

mm/memory-failure.c

1517

if (folio_test_swapcache(folio)) {

mm/memory-failure.c

1528

mapping = folio_mapping(folio);

mm/memory-failure.c

1529

if (!must_kill && !folio_test_dirty(folio) && mapping &&

mm/memory-failure.c

1531

if (folio_mkclean(folio)) {

mm/memory-failure.c

1532

folio_set_dirty(folio);

mm/memory-failure.c

1540

if (folio_test_hugetlb(folio) && !folio_test_anon(folio)) {

mm/memory-failure.c

1548

mapping = hugetlb_folio_mapping_lock_write(folio);

mm/memory-failure.c

1551

folio_pfn(folio));

mm/memory-failure.c

1555

try_to_unmap(folio, ttu|TTU_RMAP_LOCKED);

mm/memory-failure.c

1558

try_to_unmap(folio, ttu);

mm/memory-failure.c

1561

return folio_mapped(folio) ? -EBUSY : 0;

mm/memory-failure.c

1568

static bool hwpoison_user_mappings(struct folio *folio, struct page *p,

mm/memory-failure.c

1574

bool mlocked = folio_test_mlocked(folio);

mm/memory-failure.c

1580

if (folio_test_reserved(folio) || folio_test_slab(folio) ||

mm/memory-failure.c

1581

folio_test_pgtable(folio) || folio_test_offline(folio))

mm/memory-failure.c

1583

if (!(folio_test_lru(folio) || folio_test_hugetlb(folio)))

mm/memory-failure.c

1590

if (!folio_mapped(folio))

mm/memory-failure.c

1598

collect_procs(folio, p, &tokill, flags & MF_ACTION_REQUIRED);

mm/memory-failure.c

1600

unmap_success = !unmap_poisoned_folio(folio, pfn, flags & MF_MUST_KILL);

mm/memory-failure.c

1603

pfn, folio_mapcount(folio));

mm/memory-failure.c

1610

shake_folio(folio);

mm/memory-failure.c

1622

forcekill = folio_test_dirty(folio) || (flags & MF_MUST_KILL) ||

mm/memory-failure.c

1709

struct folio *folio = pfn_folio(pfn);

mm/memory-failure.c

1721

cookie = dax_lock_folio(folio);

mm/memory-failure.c

1725

if (hwpoison_filter(&folio->page)) {

mm/memory-failure.c

1747

SetPageHWPoison(&folio->page);

mm/memory-failure.c

1756

collect_procs(folio, &folio->page, &to_kill, true);

mm/memory-failure.c

1758

unmap_and_kill(&to_kill, pfn, folio->mapping, folio->index, flags);

mm/memory-failure.c

1760

dax_unlock_folio(folio, cookie);

mm/memory-failure.c

1820

static inline struct llist_head *raw_hwp_list_head(struct folio *folio)

mm/memory-failure.c

1822

return (struct llist_head *)&folio->_hugetlb_hwpoison;

mm/memory-failure.c

1829

struct folio *folio = page_folio(page);

mm/memory-failure.c

1832

if (!folio_test_hwpoison(folio))

mm/memory-failure.c

1835

if (!folio_test_hugetlb(folio))

mm/memory-failure.c

1842

if (folio_test_hugetlb_raw_hwp_unreliable(folio))

mm/memory-failure.c

1847

raw_hwp_head = raw_hwp_list_head(folio);

mm/memory-failure.c

1860

static unsigned long __folio_free_raw_hwp(struct folio *folio, bool move_flag)

mm/memory-failure.c

1866

head = llist_del_all(raw_hwp_list_head(folio));

mm/memory-failure.c

1888

static int hugetlb_update_hwpoison(struct folio *folio, struct page *page)

mm/memory-failure.c

1893

int ret = folio_test_set_hwpoison(folio) ? MF_HUGETLB_FOLIO_PRE_POISONED : 0;

mm/memory-failure.c

1900

if (folio_test_hugetlb_raw_hwp_unreliable(folio))

mm/memory-failure.c

1902

head = raw_hwp_list_head(folio);

mm/memory-failure.c

1918

folio_set_hugetlb_raw_hwp_unreliable(folio);

mm/memory-failure.c

1923

__folio_free_raw_hwp(folio, false);

mm/memory-failure.c

1928

static unsigned long folio_free_raw_hwp(struct folio *folio, bool move_flag)

mm/memory-failure.c

1934

if (move_flag && folio_test_hugetlb_vmemmap_optimized(folio))

mm/memory-failure.c

1941

if (folio_test_hugetlb_raw_hwp_unreliable(folio))

mm/memory-failure.c

1944

return __folio_free_raw_hwp(folio, move_flag);

mm/memory-failure.c

1947

void folio_clear_hugetlb_hwpoison(struct folio *folio)

mm/memory-failure.c

1949

if (folio_test_hugetlb_raw_hwp_unreliable(folio))

mm/memory-failure.c

1951

if (folio_test_hugetlb_vmemmap_optimized(folio))

mm/memory-failure.c

1953

folio_clear_hwpoison(folio);

mm/memory-failure.c

1954

folio_free_raw_hwp(folio, true);

mm/memory-failure.c

1961

struct folio *folio;

mm/memory-failure.c

1966

folio = page_folio(page);

mm/memory-failure.c

1967

if (!folio_test_hugetlb(folio)) {

mm/memory-failure.c

1973

} else if (folio_test_hugetlb_freed(folio)) {

mm/memory-failure.c

1975

} else if (folio_test_hugetlb_migratable(folio)) {

mm/memory-failure.c

1976

if (folio_try_get(folio)) {

mm/memory-failure.c

1988

rc = hugetlb_update_hwpoison(folio, page);

mm/memory-failure.c

1998

if (count_increased && folio_test_hugetlb_migratable(folio)) {

mm/memory-failure.c

1999

folio_clear_hugetlb_migratable(folio);

mm/memory-failure.c

2008

folio_put(folio);

mm/memory-failure.c

2029

struct folio *folio;

mm/memory-failure.c

2059

folio = page_folio(p);

mm/memory-failure.c

2060

folio_lock(folio);

mm/memory-failure.c

2063

folio_clear_hugetlb_hwpoison(folio);

mm/memory-failure.c

2065

folio_set_hugetlb_migratable(folio);

mm/memory-failure.c

2066

folio_unlock(folio);

mm/memory-failure.c

2068

folio_put(folio);

mm/memory-failure.c

2077

folio_unlock(folio);

mm/memory-failure.c

2087

page_flags = folio->flags.f;

mm/memory-failure.c

2089

if (!hwpoison_user_mappings(folio, p, pfn, flags)) {

mm/memory-failure.c

2090

folio_unlock(folio);

mm/memory-failure.c

2103

static inline unsigned long folio_free_raw_hwp(struct folio *folio, bool flag)

mm/memory-failure.c

2158

struct folio *folio)

mm/memory-failure.c

2162

folio_lock(folio);

mm/memory-failure.c

2163

collect_procs(folio, p, &tokill, flags & MF_ACTION_REQUIRED);

mm/memory-failure.c

2164

folio_unlock(folio);

mm/memory-failure.c

2333

struct folio *folio;

mm/memory-failure.c

2429

folio = page_folio(p);

mm/memory-failure.c

2432

folio_lock(folio);

mm/memory-failure.c

2435

folio_unlock(folio);

mm/memory-failure.c

2436

folio_put(folio);

mm/memory-failure.c

2440

folio_unlock(folio);

mm/memory-failure.c

2442

if (folio_test_large(folio)) {

mm/memory-failure.c

2443

const int new_order = min_order_for_split(folio);

mm/memory-failure.c

2459

folio_set_has_hwpoisoned(folio);

mm/memory-failure.c

2469

folio = page_folio(p);

mm/memory-failure.c

2471

kill_procs_now(p, pfn, flags, folio);

mm/memory-failure.c

2477

folio = page_folio(p);

mm/memory-failure.c

2488

shake_folio(folio);

mm/memory-failure.c

2490

folio_lock(folio);

mm/memory-failure.c

2497

WARN_ON(folio_test_large(folio));

mm/memory-failure.c

2506

page_flags = folio->flags.f;

mm/memory-failure.c

2513

if (!folio_test_lru(folio) && !folio_test_writeback(folio))

mm/memory-failure.c

2520

folio_wait_writeback(folio);

mm/memory-failure.c

2526

if (!hwpoison_user_mappings(folio, p, pfn, flags)) {

mm/memory-failure.c

2534

if (folio_test_lru(folio) && !folio_test_swapcache(folio) &&

mm/memory-failure.c

2535

folio->mapping == NULL) {

mm/memory-failure.c

2545

folio_unlock(folio);

mm/memory-failure.c

2669

struct folio *folio;

mm/memory-failure.c

2680

folio = page_folio(p);

mm/memory-failure.c

2691

if (is_huge_zero_folio(folio)) {

mm/memory-failure.c

2704

if (folio_ref_count(folio) > 1) {

mm/memory-failure.c

2710

if (folio_test_slab(folio) || folio_test_pgtable(folio) ||

mm/memory-failure.c

2711

folio_test_reserved(folio) || folio_test_offline(folio))

mm/memory-failure.c

2714

if (folio_mapped(folio)) {

mm/memory-failure.c

2720

if (folio_mapping(folio)) {

mm/memory-failure.c

2728

if (folio_test_hugetlb(folio)) {

mm/memory-failure.c

2730

count = folio_free_raw_hwp(folio, false);

mm/memory-failure.c

2734

ret = folio_test_clear_hwpoison(folio) ? 0 : -EBUSY;

mm/memory-failure.c

2744

if (folio_test_hugetlb(folio)) {

mm/memory-failure.c

2746

count = folio_free_raw_hwp(folio, false);

mm/memory-failure.c

2748

folio_put(folio);

mm/memory-failure.c

2753

folio_put(folio);

mm/memory-failure.c

2755

folio_put(folio);

mm/memory-failure.c

2784

struct folio *folio = page_folio(page);

mm/memory-failure.c

2786

bool huge = folio_test_hugetlb(folio);

mm/memory-failure.c

2795

if (!huge && folio_test_large(folio)) {

mm/memory-failure.c

2796

const int new_order = min_order_for_split(folio);

mm/memory-failure.c

2810

folio = page_folio(page);

mm/memory-failure.c

2813

folio_lock(folio);

mm/memory-failure.c

2815

folio_wait_writeback(folio);

mm/memory-failure.c

2817

folio_unlock(folio);

mm/memory-failure.c

2818

folio_put(folio);

mm/memory-failure.c

2823

if (!huge && folio_test_lru(folio) && !folio_test_swapcache(folio))

mm/memory-failure.c

2828

ret = mapping_evict_folio(folio_mapping(folio), folio);

mm/memory-failure.c

2829

folio_unlock(folio);

mm/memory-failure.c

2837

isolated = isolate_folio_to_list(folio, &pagelist);

mm/memory-failure.c

2846

folio_put(folio);

mm/memory-failure.c

305

void shake_folio(struct folio *folio)

mm/memory-failure.c

307

if (folio_test_hugetlb(folio))

mm/memory-failure.c

313

if (folio_test_slab(folio))

mm/memory-failure.c

533

static void collect_procs_anon(const struct folio *folio,

mm/memory-failure.c

541

av = folio_lock_anon_vma_read(folio, NULL);

mm/memory-failure.c

545

pgoff = page_pgoff(folio, page);

mm/memory-failure.c

571

static void collect_procs_file(const struct folio *folio,

mm/memory-failure.c

577

struct address_space *mapping = folio->mapping;

mm/memory-failure.c

582

pgoff = page_pgoff(folio, page);

mm/memory-failure.c

600

addr = page_address_in_vma(folio, page, vma);

mm/memory-failure.c

654

static void collect_procs(const struct folio *folio, const struct page *page,

mm/memory-failure.c

657

if (!folio->mapping)

mm/memory-failure.c

659

if (unlikely(folio_test_ksm(folio)))

mm/memory-failure.c

660

collect_procs_ksm(folio, page, tokill, force_early);

mm/memory-failure.c

661

else if (folio_test_anon(folio))

mm/memory-failure.c

662

collect_procs_anon(folio, page, tokill, force_early);

mm/memory-failure.c

664

collect_procs_file(folio, page, tokill, force_early);

mm/memory-failure.c

898

static int delete_from_lru_cache(struct folio *folio)

mm/memory-failure.c

900

if (folio_isolate_lru(folio)) {

mm/memory-failure.c

905

folio_clear_active(folio);

mm/memory-failure.c

906

folio_clear_unevictable(folio);

mm/memory-failure.c

912

mem_cgroup_uncharge(folio);

mm/memory-failure.c

917

folio_put(folio);

mm/memory-failure.c

923

static int truncate_error_folio(struct folio *folio, unsigned long pfn,

mm/memory-failure.c

929

int err = mapping->a_ops->error_remove_folio(mapping, folio);

mm/memory-failure.c

933

else if (!filemap_release_folio(folio, GFP_NOIO))

mm/memory-failure.c

942

if (mapping_evict_folio(mapping, folio))

mm/memory-tiers.c

65

bool folio_use_access_time(struct folio *folio)

mm/memory-tiers.c

68

!node_is_toptier(folio_nid(folio));

mm/memory.c

1004

folio_get(folio);

mm/memory.c

1005

rss[mm_counter(folio)]++;

mm/memory.c

1007

folio_try_dup_anon_rmap_pte(folio, page, dst_vma, src_vma);

mm/memory.c

1065

struct folio **prealloc, struct page *page)

mm/memory.c

1067

struct folio *new_folio;

mm/memory.c

1131

int max_nr, int *rss, struct folio **prealloc)

mm/memory.c

1135

struct folio *folio;

mm/memory.c

1142

folio = page_folio(page);

mm/memory.c

1149

if (unlikely(!*prealloc && folio_test_large(folio) && max_nr != 1)) {

mm/memory.c

1155

nr = folio_pte_batch_flags(folio, src_vma, src_pte, &pte, max_nr, flags);

mm/memory.c

1156

folio_ref_add(folio, nr);

mm/memory.c

1157

if (folio_test_anon(folio)) {

mm/memory.c

1158

if (unlikely(folio_try_dup_anon_rmap_ptes(folio, page,

mm/memory.c

1160

folio_ref_sub(folio, nr);

mm/memory.c

1164

VM_WARN_ON_FOLIO(PageAnonExclusive(page), folio);

mm/memory.c

1166

folio_dup_file_rmap_ptes(folio, page, nr, dst_vma);

mm/memory.c

1167

rss[mm_counter_file(folio)] += nr;

mm/memory.c

1174

folio_get(folio);

mm/memory.c

1175

if (folio_test_anon(folio)) {

mm/memory.c

1182

if (unlikely(folio_try_dup_anon_rmap_pte(folio, page, dst_vma, src_vma))) {

mm/memory.c

1184

folio_put(folio);

mm/memory.c

1190

VM_WARN_ON_FOLIO(PageAnonExclusive(page), folio);

mm/memory.c

1192

folio_dup_file_rmap_pte(folio, page, dst_vma);

mm/memory.c

1193

rss[mm_counter_file(folio)]++;

mm/memory.c

1201

static inline struct folio *folio_prealloc(struct mm_struct *src_mm,

mm/memory.c

1204

struct folio *new_folio;

mm/memory.c

1238

struct folio *prealloc = NULL;

mm/memory.c

1584

struct folio *folio)

mm/memory.c

1591

return !folio_test_anon(folio);

mm/memory.c

1639

struct vm_area_struct *vma, struct folio *folio,

mm/memory.c

1647

if (!folio_test_anon(folio)) {

mm/memory.c

1650

folio_mark_dirty(folio);

mm/memory.c

1657

folio_mark_accessed(folio);

mm/memory.c

1658

rss[mm_counter(folio)] -= nr;

mm/memory.c

1672

folio_remove_rmap_ptes(folio, page, nr, vma);

mm/memory.c

1674

if (unlikely(folio_mapcount(folio) < 0))

mm/memory.c

1696

struct folio *folio;

mm/memory.c

1713

folio = page_folio(page);

mm/memory.c

1714

if (unlikely(!should_zap_folio(details, folio))) {

mm/memory.c

1723

if (unlikely(folio_test_large(folio) && max_nr != 1)) {

mm/memory.c

1724

nr = folio_pte_batch(folio, pte, ptent, max_nr);

mm/memory.c

1725

zap_present_folio_ptes(tlb, vma, folio, page, pte, ptent, nr,

mm/memory.c

1730

zap_present_folio_ptes(tlb, vma, folio, page, pte, ptent, 1, addr,

mm/memory.c

1748

struct folio *folio = page_folio(page);

mm/memory.c

1750

if (unlikely(!should_zap_folio(details, folio)))

mm/memory.c

1758

WARN_ON_ONCE(!folio_test_anon(folio));

mm/memory.c

1759

rss[mm_counter(folio)]--;

mm/memory.c

1760

folio_remove_rmap_pte(folio, page, vma);

mm/memory.c

1761

folio_put(folio);

mm/memory.c

1771

struct folio *folio = softleaf_to_folio(entry);

mm/memory.c

1773

if (!should_zap_folio(details, folio))

mm/memory.c

1775

rss[mm_counter(folio)]--;

mm/memory.c

2336

struct folio *folio = page_folio(page);

mm/memory.c

2338

if (!folio_ref_count(folio))

mm/memory.c

2340

if (unlikely(is_zero_folio(folio))) {

mm/memory.c

2345

if (folio_test_anon(folio) || page_has_type(page))

mm/memory.c

2347

flush_dcache_folio(folio);

mm/memory.c

2355

struct folio *folio = page_folio(page);

mm/memory.c

2376

if (unlikely(is_zero_folio(folio))) {

mm/memory.c

2379

folio_get(folio);

mm/memory.c

2385

inc_mm_counter(vma->vm_mm, mm_counter_file(folio));

mm/memory.c

2386

folio_add_file_rmap_pte(folio, page, vma);

mm/memory.c

3673

static vm_fault_t do_page_mkwrite(struct vm_fault *vmf, struct folio *folio)

mm/memory.c

3690

folio_lock(folio);

mm/memory.c

3691

if (!folio->mapping) {

mm/memory.c

3692

folio_unlock(folio);

mm/memory.c

3697

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/memory.c

3710

struct folio *folio = page_folio(vmf->page);

mm/memory.c

3714

dirtied = folio_mark_dirty(folio);

mm/memory.c

3715

VM_BUG_ON_FOLIO(folio_test_anon(folio), folio);

mm/memory.c

3722

mapping = folio_raw_mapping(folio);

mm/memory.c

3723

folio_unlock(folio);

mm/memory.c

3759

static inline void wp_page_reuse(struct vm_fault *vmf, struct folio *folio)

mm/memory.c

3768

if (folio) {

mm/memory.c

3769

VM_BUG_ON(folio_test_anon(folio) &&

mm/memory.c

3776

folio_xchg_last_cpupid(folio, (1 << LAST_CPUPID_SHIFT) - 1);

mm/memory.c

3858

struct folio *old_folio = NULL;

mm/memory.c

3859

struct folio *new_folio = NULL;

mm/memory.c

4021

static vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf, struct folio *folio)

mm/memory.c

4037

wp_page_reuse(vmf, folio);

mm/memory.c

4067

static vm_fault_t wp_page_shared(struct vm_fault *vmf, struct folio *folio)

mm/memory.c

4073

folio_get(folio);

mm/memory.c

4081

folio_put(folio);

mm/memory.c

4085

tmp = do_page_mkwrite(vmf, folio);

mm/memory.c

4088

folio_put(folio);

mm/memory.c

4091

tmp = finish_mkwrite_fault(vmf, folio);

mm/memory.c

4093

folio_unlock(folio);

mm/memory.c

4094

folio_put(folio);

mm/memory.c

4098

wp_page_reuse(vmf, folio);

mm/memory.c

4099

folio_lock(folio);

mm/memory.c

4102

folio_put(folio);

mm/memory.c

4108

static bool __wp_can_reuse_large_anon_folio(struct folio *folio,

mm/memory.c

4114

if (folio_large_mapcount(folio) <= 1)

mm/memory.c

4130

if (test_bit(FOLIO_MM_IDS_SHARED_BITNUM, &folio->_mm_ids))

mm/memory.c

4133

VM_WARN_ON_ONCE(folio_test_ksm(folio));

mm/memory.c

4135

if (unlikely(folio_test_swapcache(folio))) {

mm/memory.c

4140

if (!folio_trylock(folio))

mm/memory.c

4142

folio_free_swap(folio);

mm/memory.c

4143

folio_unlock(folio);

mm/memory.c

4146

if (folio_large_mapcount(folio) != folio_ref_count(folio))

mm/memory.c

4150

folio_lock_large_mapcount(folio);

mm/memory.c

4151

VM_WARN_ON_ONCE_FOLIO(folio_large_mapcount(folio) > folio_ref_count(folio), folio);

mm/memory.c

4153

if (test_bit(FOLIO_MM_IDS_SHARED_BITNUM, &folio->_mm_ids))

mm/memory.c

4155

if (folio_large_mapcount(folio) != folio_ref_count(folio))

mm/memory.c

4158

VM_WARN_ON_ONCE_FOLIO(folio_large_mapcount(folio) > folio_nr_pages(folio), folio);

mm/memory.c

4159

VM_WARN_ON_ONCE_FOLIO(folio_entire_mapcount(folio), folio);

mm/memory.c

4160

VM_WARN_ON_ONCE(folio_mm_id(folio, 0) != vma->vm_mm->mm_id &&

mm/memory.c

4161

folio_mm_id(folio, 1) != vma->vm_mm->mm_id);

mm/memory.c

4170

folio_unlock_large_mapcount(folio);

mm/memory.c

4174

static bool __wp_can_reuse_large_anon_folio(struct folio *folio,

mm/memory.c

4181

static bool wp_can_reuse_anon_folio(struct folio *folio,

mm/memory.c

4184

if (IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && folio_test_large(folio))

mm/memory.c

4185

return __wp_can_reuse_large_anon_folio(folio, vma);

mm/memory.c

4194

if (folio_test_ksm(folio) || folio_ref_count(folio) > 3)

mm/memory.c

4196

if (!folio_test_lru(folio))

mm/memory.c

4202

if (folio_ref_count(folio) > 1 + folio_test_swapcache(folio))

mm/memory.c

4204

if (!folio_trylock(folio))

mm/memory.c

4206

if (folio_test_swapcache(folio))

mm/memory.c

4207

folio_free_swap(folio);

mm/memory.c

4208

if (folio_test_ksm(folio) || folio_ref_count(folio) != 1) {

mm/memory.c

4209

folio_unlock(folio);

mm/memory.c

4217

folio_move_anon_rmap(folio, vma);

mm/memory.c

4218

folio_unlock(folio);

mm/memory.c

4249

struct folio *folio = NULL;

mm/memory.c

4286

folio = page_folio(vmf->page);

mm/memory.c

4304

return wp_page_shared(vmf, folio);

mm/memory.c

4314

if (folio && folio_test_anon(folio) &&

mm/memory.c

4315

(PageAnonExclusive(vmf->page) || wp_can_reuse_anon_folio(folio, vma))) {

mm/memory.c

4322

wp_page_reuse(vmf, folio);

mm/memory.c

4328

if (folio)

mm/memory.c

4329

folio_get(folio);

mm/memory.c

4333

if (folio && folio_test_ksm(folio))

mm/memory.c

4372

void unmap_mapping_folio(struct folio *folio)

mm/memory.c

4374

struct address_space *mapping = folio->mapping;

mm/memory.c

4379

VM_BUG_ON(!folio_test_locked(folio));

mm/memory.c

4381

first_index = folio->index;

mm/memory.c

4382

last_index = folio_next_index(folio) - 1;

mm/memory.c

4385

details.single_folio = folio;

mm/memory.c

4466

struct folio *folio = page_folio(vmf->page);

mm/memory.c

4479

if (!folio_try_get(folio))

mm/memory.c

4482

ret = folio_lock_or_retry(folio, vmf);

mm/memory.c

4484

folio_put(folio);

mm/memory.c

4495

restore_exclusive_pte(vma, folio, vmf->page, vmf->address,

mm/memory.c

4500

folio_unlock(folio);

mm/memory.c

4501

folio_put(folio);

mm/memory.c

4513

struct folio *folio,

mm/memory.c

4518

if (!folio_test_swapcache(folio))

mm/memory.c

4528

if (mem_cgroup_swap_full(folio) || (vma->vm_flags & VM_LOCKED) ||

mm/memory.c

4529

folio_test_mlocked(folio))

mm/memory.c

4537

return (fault_flags & FAULT_FLAG_WRITE) && !folio_test_ksm(folio) &&

mm/memory.c

4538

folio_ref_count(folio) == (extra_refs + folio_nr_pages(folio));

mm/memory.c

4729

static void check_swap_exclusive(struct folio *folio, swp_entry_t entry,

mm/memory.c

4734

VM_WARN_ON_ONCE_FOLIO(__swap_count(entry) != 1, folio);

mm/memory.c

4750

struct folio *swapcache = NULL, *folio;

mm/memory.c

4826

folio = swap_cache_get_folio(entry);

mm/memory.c

4827

if (folio)

mm/memory.c

4828

swap_update_readahead(folio, vma, vmf->address);

mm/memory.c

4829

if (!folio) {

mm/memory.c

4832

folio = swapin_sync(entry, GFP_HIGHUSER_MOVABLE,

mm/memory.c

4836

folio = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, vmf);

mm/memory.c

4838

if (IS_ERR_OR_NULL(folio)) {

mm/memory.c

4848

folio = NULL;

mm/memory.c

4858

swapcache = folio;

mm/memory.c

4859

ret |= folio_lock_or_retry(folio, vmf);

mm/memory.c

4863

page = folio_file_page(folio, swp_offset(entry));

mm/memory.c

4871

if (unlikely(!folio_matches_swap_entry(folio, entry)))

mm/memory.c

4888

folio = ksm_might_need_to_copy(folio, vma, vmf->address);

mm/memory.c

4889

if (unlikely(!folio)) {

mm/memory.c

4891

folio = swapcache;

mm/memory.c

4893

} else if (unlikely(folio == ERR_PTR(-EHWPOISON))) {

mm/memory.c

4895

folio = swapcache;

mm/memory.c

4897

} else if (folio != swapcache)

mm/memory.c

4898

page = folio_page(folio, 0);

mm/memory.c

4907

!folio_test_ksm(folio) && !folio_test_lru(folio))

mm/memory.c

4910

folio_throttle_swaprate(folio, GFP_KERNEL);

mm/memory.c

4920

if (unlikely(!folio_test_uptodate(folio))) {

mm/memory.c

4929

if (folio_test_large(folio) && folio_test_swapcache(folio)) {

mm/memory.c

4930

int nr = folio_nr_pages(folio);

mm/memory.c

4931

unsigned long idx = folio_page_idx(folio, page);

mm/memory.c

4952

entry = folio->swap;

mm/memory.c

4953

page = &folio->page;

mm/memory.c

4965

BUG_ON(!folio_test_anon(folio) && folio_test_mappedtodisk(folio));

mm/memory.c

4966

BUG_ON(folio_test_anon(folio) && PageAnonExclusive(page));

mm/memory.c

4980

if (!folio_test_anon(folio) && folio_test_large(folio) &&

mm/memory.c

4981

nr_pages != folio_nr_pages(folio)) {

mm/memory.c

4982

if (!WARN_ON_ONCE(folio_test_dirty(folio)))

mm/memory.c

4983

swap_cache_del_folio(folio);

mm/memory.c

4991

if (!folio_test_ksm(folio)) {

mm/memory.c

4998

check_swap_exclusive(folio, entry, nr_pages);

mm/memory.c

4999

if (folio != swapcache) {

mm/memory.c

5005

} else if (exclusive && folio_test_writeback(folio) &&

mm/memory.c

5034

arch_swap_restore(folio_swap(entry, folio), folio);

mm/memory.c

5050

if (!folio_test_ksm(folio) &&

mm/memory.c

5051

(exclusive || folio_ref_count(folio) == 1)) {

mm/memory.c

5062

folio_ref_add(folio, nr_pages - 1);

mm/memory.c

5067

if (unlikely(folio != swapcache)) {

mm/memory.c

5068

folio_add_new_anon_rmap(folio, vma, address, RMAP_EXCLUSIVE);

mm/memory.c

5069

folio_add_lru_vma(folio, vma);

mm/memory.c

5071

} else if (!folio_test_anon(folio)) {

mm/memory.c

5076

VM_WARN_ON_ONCE_FOLIO(folio_nr_pages(folio) != nr_pages, folio);

mm/memory.c

5077

VM_WARN_ON_ONCE_FOLIO(folio_mapped(folio), folio);

mm/memory.c

5078

folio_add_new_anon_rmap(folio, vma, address, rmap_flags);

mm/memory.c

5079

folio_put_swap(folio, NULL);

mm/memory.c

5081

VM_WARN_ON_ONCE(nr_pages != 1 && nr_pages != folio_nr_pages(folio));

mm/memory.c

5082

folio_add_anon_rmap_ptes(folio, page, nr_pages, vma, address,

mm/memory.c

5084

folio_put_swap(folio, nr_pages == 1 ? page : NULL);

mm/memory.c

5087

VM_BUG_ON(!folio_test_anon(folio) ||

mm/memory.c

5098

if (should_try_to_free_swap(si, folio, vma, nr_pages, vmf->flags))

mm/memory.c

5099

folio_free_swap(folio);

mm/memory.c

5101

folio_unlock(folio);

mm/memory.c

5102

if (unlikely(folio != swapcache)) {

mm/memory.c

5135

if (folio_test_swapcache(folio))

mm/memory.c

5136

folio_free_swap(folio);

mm/memory.c

5137

folio_unlock(folio);

mm/memory.c

5139

folio_put(folio);

mm/memory.c

5140

if (folio != swapcache) {

mm/memory.c

5161

static struct folio *alloc_anon_folio(struct vm_fault *vmf)

mm/memory.c

5166

struct folio *folio;

mm/memory.c

5217

folio = vma_alloc_folio(gfp, order, vma, addr);

mm/memory.c

5218

if (!folio)

mm/memory.c

5220

if (mem_cgroup_charge(folio, vma->vm_mm, gfp)) {

mm/memory.c

5222

folio_put(folio);

mm/memory.c

5225

if (order > 1 && folio_memcg_alloc_deferred(folio)) {

mm/memory.c

5226

folio_put(folio);

mm/memory.c

5229

folio_throttle_swaprate(folio, gfp);

mm/memory.c

5238

folio_zero_user(folio, vmf->address);

mm/memory.c

5239

return folio;

mm/memory.c

5250

void map_anon_folio_pte_nopf(struct folio *folio, pte_t *pte,

mm/memory.c

5254

const unsigned int nr_pages = folio_nr_pages(folio);

mm/memory.c

5255

pte_t entry = folio_mk_pte(folio, vma->vm_page_prot);

mm/memory.c

5264

folio_ref_add(folio, nr_pages - 1);

mm/memory.c

5265

folio_add_new_anon_rmap(folio, vma, addr, RMAP_EXCLUSIVE);

mm/memory.c

5266

folio_add_lru_vma(folio, vma);

mm/memory.c

5271

static void map_anon_folio_pte_pf(struct folio *folio, pte_t *pte,

mm/memory.c

5274

const unsigned int order = folio_order(folio);

mm/memory.c

5276

map_anon_folio_pte_nopf(folio, pte, vma, addr, uffd_wp);

mm/memory.c

5291

struct folio *folio;

mm/memory.c

5342

folio = alloc_anon_folio(vmf);

mm/memory.c

5343

if (IS_ERR(folio))

mm/memory.c

5345

if (!folio)

mm/memory.c

5348

nr_pages = folio_nr_pages(folio);

mm/memory.c

5356

__folio_mark_uptodate(folio);

mm/memory.c

5376

folio_put(folio);

mm/memory.c

5379

map_anon_folio_pte_pf(folio, vmf->pte, vma, addr,

mm/memory.c

5386

folio_put(folio);

mm/memory.c

5401

struct folio *folio;

mm/memory.c

5430

folio = page_folio(vmf->page);

mm/memory.c

5434

if (folio_mapped(folio))

mm/memory.c

5435

unmap_mapping_folio(folio);

mm/memory.c

5437

if (mapping_evict_folio(folio->mapping, folio))

mm/memory.c

5439

folio_unlock(folio);

mm/memory.c

5441

folio_put(folio);

mm/memory.c

5447

folio_lock(folio);

mm/memory.c

5449

VM_BUG_ON_PAGE(!folio_test_locked(folio), vmf->page);

mm/memory.c

5468

vm_fault_t do_set_pmd(struct vm_fault *vmf, struct folio *folio, struct page *page)

mm/memory.c

5490

if (!is_pmd_order(folio_order(folio)))

mm/memory.c

5492

page = &folio->page;

mm/memory.c

5500

if (unlikely(folio_test_has_hwpoisoned(folio)))

mm/memory.c

5519

entry = folio_mk_pmd(folio, vma->vm_page_prot);

mm/memory.c

5523

add_mm_counter(vma->vm_mm, mm_counter_file(folio), HPAGE_PMD_NR);

mm/memory.c

5524

folio_add_file_rmap_pmd(folio, page, vma);

mm/memory.c

5544

vm_fault_t do_set_pmd(struct vm_fault *vmf, struct folio *folio, struct page *page)

mm/memory.c

5558

void set_pte_range(struct vm_fault *vmf, struct folio *folio,

mm/memory.c

5576

else if (pte_write(entry) && folio_test_dirty(folio))

mm/memory.c

5582

VM_BUG_ON_FOLIO(nr != 1, folio);

mm/memory.c

5583

folio_add_new_anon_rmap(folio, vma, addr, RMAP_EXCLUSIVE);

mm/memory.c

5584

folio_add_lru_vma(folio, vma);

mm/memory.c

5586

folio_add_file_rmap_ptes(folio, page, nr, vma);

mm/memory.c

5621

struct folio *folio;

mm/memory.c

5638

folio = page_folio(page);

mm/memory.c

5663

file_end < folio_next_index(folio);

mm/memory.c

5667

if (!needs_fallback && folio_test_pmd_mappable(folio)) {

mm/memory.c

5668

ret = do_set_pmd(vmf, folio, page);

mm/memory.c

5679

nr_pages = folio_nr_pages(folio);

mm/memory.c

5685

pgoff_t idx = folio_page_idx(folio, page);

mm/memory.c

5703

page = &folio->page;

mm/memory.c

5723

folio_ref_add(folio, nr_pages - 1);

mm/memory.c

5724

set_pte_range(vmf, folio, page, nr_pages, addr);

mm/memory.c

5725

type = is_cow ? MM_ANONPAGES : mm_counter_file(folio);

mm/memory.c

5843

struct folio *folio;

mm/memory.c

5865

folio = page_folio(vmf->page);

mm/memory.c

5866

folio_unlock(folio);

mm/memory.c

5868

folio_put(folio);

mm/memory.c

5875

struct folio *folio;

mm/memory.c

5884

folio = folio_prealloc(vma->vm_mm, vma, vmf->address, false);

mm/memory.c

5885

if (!folio)

mm/memory.c

5888

vmf->cow_page = &folio->page;

mm/memory.c

5900

__folio_mark_uptodate(folio);

mm/memory.c

5910

folio_put(folio);

mm/memory.c

5918

struct folio *folio;

mm/memory.c

5928

folio = page_folio(vmf->page);

mm/memory.c

5935

folio_unlock(folio);

mm/memory.c

5936

tmp = do_page_mkwrite(vmf, folio);

mm/memory.c

5939

folio_put(folio);

mm/memory.c

5947

folio_unlock(folio);

mm/memory.c

5948

folio_put(folio);

mm/memory.c

6008

int numa_migrate_check(struct folio *folio, struct vm_fault *vmf,

mm/memory.c

6029

if (folio_maybe_mapped_shared(folio) && (vma->vm_flags & VM_SHARED))

mm/memory.c

6035

if (folio_use_access_time(folio))

mm/memory.c

6038

*last_cpupid = folio_last_cpupid(folio);

mm/memory.c

6045

count_memcg_folio_events(folio, NUMA_HINT_FAULTS, 1);

mm/memory.c

6047

if (folio_nid(folio) == numa_node_id()) {

mm/memory.c

6052

return mpol_misplaced(folio, vmf, addr);

mm/memory.c

6071

struct folio *folio, pte_t fault_pte,

mm/memory.c

6074

int nr = pte_pfn(fault_pte) - folio_pfn(folio);

mm/memory.c

6082

end = min3(addr_start + folio_size(folio), pt_start + PMD_SIZE,

mm/memory.c

6094

if (pfn_folio(pte_pfn(ptent)) != folio)

mm/memory.c

6112

struct folio *folio = NULL;

mm/memory.c

6145

folio = vm_normal_folio(vma, vmf->address, pte);

mm/memory.c

6146

if (!folio || folio_is_zone_device(folio))

mm/memory.c

6149

nid = folio_nid(folio);

mm/memory.c

6150

nr_pages = folio_nr_pages(folio);

mm/memory.c

6152

target_nid = numa_migrate_check(folio, vmf, vmf->address, &flags,

mm/memory.c

6156

if (migrate_misplaced_folio_prepare(folio, vma, target_nid)) {

mm/memory.c

6166

if (!migrate_misplaced_folio(folio, target_nid)) {

mm/memory.c

6187

if (folio && folio_test_large(folio))

mm/memory.c

6188

numa_rebuild_large_mapping(vmf, vma, folio, pte, ignore_writable,

mm/memory.c

7040

struct folio *folio;

mm/memory.c

7072

folio = page_folio(page);

mm/memory.c

7078

maddr = kmap_local_folio(folio, folio_page_idx(folio, page) * PAGE_SIZE);

mm/memory.c

7082

folio_mark_dirty_lock(folio);

mm/memory.c

7087

folio_release_kmap(folio, maddr);

mm/memory.c

7166

struct folio *folio;

mm/memory.c

7182

folio = page_folio(page);

mm/memory.c

7188

maddr = kmap_local_folio(folio, folio_page_idx(folio, page) * PAGE_SIZE);

mm/memory.c

7193

folio_release_kmap(folio, maddr);

mm/memory.c

7211

folio_release_kmap(folio, maddr);

mm/memory.c

7397

void folio_zero_user(struct folio *folio, unsigned long addr_hint)

mm/memory.c

7399

const unsigned long base_addr = ALIGN_DOWN(addr_hint, folio_size(folio));

mm/memory.c

7401

const struct range pg = DEFINE_RANGE(0, folio_nr_pages(folio) - 1);

mm/memory.c

7423

struct page *page = folio_page(folio, r[i].start);

mm/memory.c

7430

static int copy_user_gigantic_page(struct folio *dst, struct folio *src,

mm/memory.c

7453

struct folio *dst;

mm/memory.c

7454

struct folio *src;

mm/memory.c

7469

int copy_user_large_folio(struct folio *dst, struct folio *src,

mm/memory.c

7485

long copy_folio_from_user(struct folio *dst_folio,

mm/memory.c

786

struct folio *vm_normal_folio(struct vm_area_struct *vma, unsigned long addr,

mm/memory.c

828

struct folio *vm_normal_folio_pmd(struct vm_area_struct *vma,

mm/memory.c

885

struct folio *folio, struct page *page, unsigned long address,

mm/memory.c

890

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/memory.c

901

if (folio_test_dirty(folio))

mm/memory.c

923

struct folio *folio = page_folio(page);

mm/memory.c

925

if (folio_trylock(folio)) {

mm/memory.c

926

restore_exclusive_pte(vma, folio, page, addr, ptep, orig_pte);

mm/memory.c

927

folio_unlock(folio);

mm/memory.c

949

struct folio *folio;

mm/memory.c

971

folio = softleaf_to_folio(entry);

mm/memory.c

973

rss[mm_counter(folio)]++;

mm/memory.c

993

folio = page_folio(page);

mm/memory_hotplug.c

1754

struct folio *folio;

mm/memory_hotplug.c

1769

folio = page_folio(page);

mm/memory_hotplug.c

1770

if (!folio_test_hugetlb(folio))

mm/memory_hotplug.c

1779

if (folio_test_hugetlb_migratable(folio))

mm/memory_hotplug.c

1781

nr_pages = folio_nr_pages(folio);

mm/memory_hotplug.c

1795

struct folio *folio;

mm/memory_hotplug.c

1805

folio = page_folio(page);

mm/memory_hotplug.c

1807

if (!folio_try_get(folio))

mm/memory_hotplug.c

1810

if (unlikely(page_folio(page) != folio))

mm/memory_hotplug.c

1813

if (folio_test_large(folio))

mm/memory_hotplug.c

1814

pfn = folio_pfn(folio) + folio_nr_pages(folio) - 1;

mm/memory_hotplug.c

1816

if (folio_contain_hwpoisoned_page(folio)) {

mm/memory_hotplug.c

1821

if (folio_test_large(folio) && !folio_test_hugetlb(folio))

mm/memory_hotplug.c

1823

if (folio_test_lru(folio) && !folio_isolate_lru(folio))

mm/memory_hotplug.c

1825

if (folio_mapped(folio)) {

mm/memory_hotplug.c

1826

folio_lock(folio);

mm/memory_hotplug.c

1827

unmap_poisoned_folio(folio, pfn, false);

mm/memory_hotplug.c

1828

folio_unlock(folio);

mm/memory_hotplug.c

1834

if (!isolate_folio_to_list(folio, &source)) {

mm/memory_hotplug.c

1842

folio_put(folio);

mm/memory_hotplug.c

1857

mtc.nid = folio_nid(list_first_entry(&source, struct folio, lru));

mm/memory_hotplug.c

1870

list_for_each_entry(folio, &source, lru) {

mm/memory_hotplug.c

1873

folio_pfn(folio), ret);

mm/memory_hotplug.c

1874

dump_page(&folio->page,

mm/mempolicy.c

1249

static bool migrate_folio_add(struct folio *folio, struct list_head *foliolist,

mm/mempolicy.c

1259

if ((flags & MPOL_MF_MOVE_ALL) || !folio_maybe_mapped_shared(folio)) {

mm/mempolicy.c

1260

if (folio_isolate_lru(folio)) {

mm/mempolicy.c

1261

list_add_tail(&folio->lru, foliolist);

mm/mempolicy.c

1262

node_stat_mod_folio(folio,

mm/mempolicy.c

1263

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/mempolicy.c

1264

folio_nr_pages(folio));

mm/mempolicy.c

1434

static struct folio *alloc_migration_target_by_mpol(struct folio *src,

mm/mempolicy.c

1467

static bool migrate_folio_add(struct folio *folio, struct list_head *foliolist,

mm/mempolicy.c

1479

static struct folio *alloc_migration_target_by_mpol(struct folio *src,

mm/mempolicy.c

1583

struct folio *folio;

mm/mempolicy.c

1587

list_for_each_entry(folio, &pagelist, lru) {

mm/mempolicy.c

1588

if (!folio_test_ksm(folio))

mm/mempolicy.c

1591

if (!list_entry_is_head(folio, &pagelist, lru)) {

mm/mempolicy.c

1594

addr = page_address_in_vma(folio,

mm/mempolicy.c

1595

folio_page(folio, 0), vma);

mm/mempolicy.c

1601

order = folio_order(folio);

mm/mempolicy.c

1606

mmpol.ilx -= folio->index >> order;

mm/mempolicy.c

2506

struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,

mm/mempolicy.c

2533

struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order, struct vm_area_struct *vma,

mm/mempolicy.c

2538

struct folio *folio;

mm/mempolicy.c

2544

folio = folio_alloc_mpol_noprof(gfp, order, pol, ilx, numa_node_id());

mm/mempolicy.c

2546

return folio;

mm/mempolicy.c

2589

struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order)

mm/mempolicy.c

2984

int mpol_misplaced(struct folio *folio, struct vm_fault *vmf,

mm/mempolicy.c

2990

int curnid = folio_nid(folio);

mm/mempolicy.c

3002

pol = get_vma_policy(vma, addr, folio_order(folio), &ilx);

mm/mempolicy.c

3068

if (!should_numa_migrate_memory(current, folio, curnid,

mm/mempolicy.c

606

static bool migrate_folio_add(struct folio *folio, struct list_head *foliolist,

mm/mempolicy.c

633

struct folio *large; /* note last large folio encountered */

mm/mempolicy.c

643

static inline bool queue_folio_required(struct folio *folio,

mm/mempolicy.c

646

int nid = folio_nid(folio);

mm/mempolicy.c

654

struct folio *folio;

mm/mempolicy.c

661

folio = pmd_folio(*pmd);

mm/mempolicy.c

662

if (is_huge_zero_folio(folio)) {

mm/mempolicy.c

666

if (!queue_folio_required(folio, qp))

mm/mempolicy.c

670

!migrate_folio_add(folio, qp->pagelist, qp->flags))

mm/mempolicy.c

688

struct folio *folio;

mm/mempolicy.c

721

folio = vm_normal_folio(vma, addr, ptent);

mm/mempolicy.c

722

if (!folio || folio_is_zone_device(folio))

mm/mempolicy.c

724

if (folio_test_large(folio) && max_nr != 1)

mm/mempolicy.c

725

nr = folio_pte_batch(folio, pte, ptent, max_nr);

mm/mempolicy.c

730

if (folio_test_reserved(folio))

mm/mempolicy.c

732

if (!queue_folio_required(folio, qp))

mm/mempolicy.c

734

if (folio_test_large(folio)) {

mm/mempolicy.c

751

if (folio == qp->large)

mm/mempolicy.c

753

qp->large = folio;

mm/mempolicy.c

757

!migrate_folio_add(folio, qp->pagelist, flags)) {

mm/mempolicy.c

778

struct folio *folio;

mm/mempolicy.c

794

folio = pfn_folio(pte_pfn(ptep));

mm/mempolicy.c

795

if (!queue_folio_required(folio, qp))

mm/mempolicy.c

810

(!folio_maybe_mapped_shared(folio) && !hugetlb_pmd_shared(pte)))

mm/mempolicy.c

811

if (!folio_isolate_hugetlb(folio, qp->pagelist))

mm/mempolicy.c

835

bool folio_can_map_prot_numa(struct folio *folio, struct vm_area_struct *vma,

mm/mempolicy.c

840

if (!folio || folio_is_zone_device(folio) || folio_test_ksm(folio))

mm/mempolicy.c

844

if (is_cow_mapping(vma->vm_flags) && folio_maybe_mapped_shared(folio))

mm/mempolicy.c

848

if (folio_maybe_dma_pinned(folio))

mm/mempolicy.c

856

if (folio_is_file_lru(folio) && folio_test_dirty(folio))

mm/mempolicy.c

863

nid = folio_nid(folio);

mm/mempolicy.c

875

if (folio_use_access_time(folio))

mm/mempolicy.c

876

folio_xchg_access_time(folio, jiffies_to_msecs(jiffies));

mm/memremap.c

416

void free_zone_device_folio(struct folio *folio)

mm/memremap.c

418

struct dev_pagemap *pgmap = folio->pgmap;

mm/memremap.c

419

unsigned long nr = folio_nr_pages(folio);

mm/memremap.c

425

mem_cgroup_uncharge(folio);

mm/memremap.c

427

if (folio_test_anon(folio)) {

mm/memremap.c

428

mod_mthp_stat(folio_order(folio), MTHP_STAT_NR_ANON, -1);

mm/memremap.c

430

__ClearPageAnonExclusive(folio_page(folio, i));

mm/memremap.c

450

folio->mapping = NULL;

mm/memremap.c

457

pgmap->ops->folio_free(folio);

mm/memremap.c

466

folio_set_count(folio, 1);

mm/memremap.c

470

wake_up_var(&folio->page);

mm/memremap.c

476

pgmap->ops->folio_free(folio);

mm/memremap.c

490

struct folio *new_folio = (struct folio *)new_page;

mm/memremap.c

508

((struct folio *)(new_page - 1))->_nr_pages = 0;

mm/migrate.c

1024

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1045

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1053

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1063

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1093

static int move_to_new_folio(struct folio *dst, struct folio *src,

mm/migrate.c

1144

static void __migrate_folio_record(struct folio *dst,

mm/migrate.c

1150

static void __migrate_folio_extract(struct folio *dst,

mm/migrate.c

1161

static void migrate_folio_undo_src(struct folio *src,

mm/migrate.c

1179

static void migrate_folio_undo_dst(struct folio *dst, bool locked,

mm/migrate.c

119

struct folio *folio = folio_get_nontail_page(page);

mm/migrate.c

1191

static void migrate_folio_done(struct folio *src,

mm/migrate.c

1206

struct folio *src, struct folio **dstp, enum migrate_mode mode,

mm/migrate.c

1209

struct folio *dst;

mm/migrate.c

131

if (!folio)

mm/migrate.c

1355

struct folio *src, struct folio *dst,

mm/migrate.c

1472

struct folio *src, int force, enum migrate_mode mode,

mm/migrate.c

1475

struct folio *dst;

mm/migrate.c

156

if (unlikely(!folio_trylock(folio)))

mm/migrate.c

1581

static inline int try_split_folio(struct folio *folio, struct list_head *split_folios,

mm/migrate.c

1587

if (!folio_trylock(folio))

mm/migrate.c

1590

folio_lock(folio);

mm/migrate.c

1592

rc = split_folio_to_list(folio, split_folios);

mm/migrate.c

1593

folio_unlock(folio);

mm/migrate.c

1595

list_move_tail(&folio->lru, split_folios);

mm/migrate.c

1638

struct folio *folio, *folio2;

mm/migrate.c

1645

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

1646

if (!folio_test_hugetlb(folio))

mm/migrate.c

1649

nr_pages = folio_nr_pages(folio);

mm/migrate.c

1660

if (!hugepage_migration_supported(folio_hstate(folio))) {

mm/migrate.c

1663

list_move_tail(&folio->lru, ret_folios);

mm/migrate.c

1669

folio, pass > 2, mode,

mm/migrate.c

1726

struct folio *folio, *folio2, *dst, *dst2;

mm/migrate.c

173

folio_unlock(folio);

mm/migrate.c

1731

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

1733

list_for_each_entry_safe(folio, folio2, src_folios, lru) {

mm/migrate.c

1734

is_thp = folio_test_large(folio) && folio_test_pmd_mappable(folio);

mm/migrate.c

1735

nr_pages = folio_nr_pages(folio);

mm/migrate.c

1740

folio, dst, mode,

mm/migrate.c

1774

struct folio *folio, *folio2, *dst, *dst2;

mm/migrate.c

1776

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

1778

list_for_each_entry_safe(folio, folio2, src_folios, lru) {

mm/migrate.c

178

folio_unlock(folio);

mm/migrate.c

1783

migrate_folio_undo_src(folio, old_folio_state & FOLIO_WAS_MAPPED,

mm/migrate.c

180

folio_put(folio);

mm/migrate.c

1814

struct folio *folio, *folio2, *dst = NULL;

mm/migrate.c

1828

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

1829

is_large = folio_test_large(folio);

mm/migrate.c

1830

is_thp = folio_test_pmd_mappable(folio);

mm/migrate.c

1831

nr_pages = folio_nr_pages(folio);

mm/migrate.c

1859

!list_empty(&folio->_deferred_list) &&

mm/migrate.c

1860

folio_test_partially_mapped(folio)) {

mm/migrate.c

1861

if (!try_split_folio(folio, split_folios, mode)) {

mm/migrate.c

1883

if (!try_split_folio(folio, split_folios, mode)) {

mm/migrate.c

1889

list_move_tail(&folio->lru, ret_folios);

mm/migrate.c

1897

if (likely(!page_has_movable_ops(&folio->page)) &&

mm/migrate.c

1898

folio_ref_count(folio) == 1) {

mm/migrate.c

1899

folio_clear_active(folio);

mm/migrate.c

1900

folio_clear_unevictable(folio);

mm/migrate.c

1901

list_del(&folio->lru);

mm/migrate.c

1902

migrate_folio_done(folio, reason);

mm/migrate.c

1909

private, folio, &dst, mode, ret_folios);

mm/migrate.c

1928

int ret = try_split_folio(folio, split_folios, mode);

mm/migrate.c

1964

list_move_tail(&folio->lru, &unmap_folios);

mm/migrate.c

199

struct folio *folio = page_folio(page);

mm/migrate.c

203

folio_lock(folio);

mm/migrate.c

206

folio_unlock(folio);

mm/migrate.c

207

folio_put(folio);

mm/migrate.c

2096

struct folio *folio, *folio2;

mm/migrate.c

2113

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

2115

if (folio_test_hugetlb(folio)) {

mm/migrate.c

2116

list_move_tail(&folio->lru, &ret_folios);

mm/migrate.c

2120

nr_pages += folio_nr_pages(folio);

mm/migrate.c

2187

struct folio *alloc_migration_target(struct folio *src, unsigned long private)

mm/migrate.c

2254

static int __add_folio_for_migration(struct folio *folio, int node,

mm/migrate.c

2257

if (is_zero_folio(folio) || is_huge_zero_folio(folio))

mm/migrate.c

2260

if (folio_is_zone_device(folio))

mm/migrate.c

2263

if (folio_nid(folio) == node)

mm/migrate.c

2266

if (folio_maybe_mapped_shared(folio) && !migrate_all)

mm/migrate.c

2269

if (folio_test_hugetlb(folio)) {

mm/migrate.c

2270

if (folio_isolate_hugetlb(folio, pagelist))

mm/migrate.c

2272

} else if (folio_isolate_lru(folio)) {

mm/migrate.c

2273

list_add_tail(&folio->lru, pagelist);

mm/migrate.c

2274

node_stat_mod_folio(folio,

mm/migrate.c

2275

NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/migrate.c

2276

folio_nr_pages(folio));

mm/migrate.c

2296

struct folio *folio;

mm/migrate.c

2305

folio = folio_walk_start(&fw, vma, addr, FW_ZEROPAGE);

mm/migrate.c

2306

if (folio) {

mm/migrate.c

2307

err = __add_folio_for_migration(folio, node, pagelist,

mm/migrate.c

2458

struct folio *folio;

mm/migrate.c

2465

folio = folio_walk_start(&fw, vma, addr, FW_ZEROPAGE);

mm/migrate.c

2466

if (folio) {

mm/migrate.c

2467

if (is_zero_folio(folio) || is_huge_zero_folio(folio))

mm/migrate.c

2469

else if (folio_is_zone_device(folio))

mm/migrate.c

2472

err = folio_nid(folio);

mm/migrate.c

259

struct folio *folio;

mm/migrate.c

260

struct folio *folio2;

mm/migrate.c

262

list_for_each_entry_safe(folio, folio2, l, lru) {

mm/migrate.c

263

if (unlikely(folio_test_hugetlb(folio))) {

mm/migrate.c

264

folio_putback_hugetlb(folio);

mm/migrate.c

2659

static struct folio *alloc_misplaced_dst_folio(struct folio *src,

mm/migrate.c

267

list_del(&folio->lru);

mm/migrate.c

268

if (unlikely(page_has_movable_ops(&folio->page))) {

mm/migrate.c

2680

int migrate_misplaced_folio_prepare(struct folio *folio,

mm/migrate.c

2683

int nr_pages = folio_nr_pages(folio);

mm/migrate.c

2686

if (folio_is_file_lru(folio)) {

mm/migrate.c

269

putback_movable_ops_page(&folio->page);

mm/migrate.c

2695

if ((vma->vm_flags & VM_EXEC) && folio_maybe_mapped_shared(folio))

mm/migrate.c

2703

if (folio_test_dirty(folio))

mm/migrate.c

271

node_stat_mod_folio(folio, NR_ISOLATED_ANON +

mm/migrate.c

272

folio_is_file_lru(folio), -folio_nr_pages(folio));

mm/migrate.c

2726

folio_order(folio), ZONE_MOVABLE);

mm/migrate.c

273

folio_putback_lru(folio);

mm/migrate.c

2730

if (!folio_isolate_lru(folio))

mm/migrate.c

2733

node_stat_mod_folio(folio, NR_ISOLATED_ANON + folio_is_file_lru(folio),

mm/migrate.c

2745

int migrate_misplaced_folio(struct folio *folio, int node)

mm/migrate.c

2751

struct mem_cgroup *memcg = get_mem_cgroup_from_folio(folio);

mm/migrate.c

2754

list_add(&folio->lru, &migratepages);

mm/migrate.c

2764

&& !node_is_toptier(folio_nid(folio))

mm/migrate.c

279

bool isolate_folio_to_list(struct folio *folio, struct list_head *list)

mm/migrate.c

281

if (folio_test_hugetlb(folio))

mm/migrate.c

282

return folio_isolate_hugetlb(folio, list);

mm/migrate.c

284

if (page_has_movable_ops(&folio->page)) {

mm/migrate.c

285

if (!isolate_movable_ops_page(&folio->page,

mm/migrate.c

289

if (!folio_isolate_lru(folio))

mm/migrate.c

291

node_stat_add_folio(folio, NR_ISOLATED_ANON +

mm/migrate.c

292

folio_is_file_lru(folio));

mm/migrate.c

294

list_add(&folio->lru, list);

mm/migrate.c

299

struct folio *folio, pte_t old_pte, unsigned long idx)

mm/migrate.c

301

struct page *page = folio_page(folio, idx);

mm/migrate.c

310

VM_WARN_ON_ONCE_FOLIO(folio_is_device_private(folio), folio);

mm/migrate.c

312

if (folio_test_mlocked(folio) || (pvmw->vma->vm_flags & VM_LOCKED) ||

mm/migrate.c

334

dec_mm_counter(pvmw->vma->vm_mm, mm_counter(folio));

mm/migrate.c

339

struct folio *folio;

mm/migrate.c

346

static bool remove_migration_pte(struct folio *folio,

mm/migrate.c

350

DEFINE_FOLIO_VMA_WALK(pvmw, rmap_walk_arg->folio, vma, addr, PVMW_SYNC | PVMW_MIGRATION);

mm/migrate.c

361

if (folio_test_large(folio) && !folio_test_hugetlb(folio))

mm/migrate.c

363

new = folio_page(folio, idx);

mm/migrate.c

368

VM_BUG_ON_FOLIO(folio_test_hugetlb(folio) ||

mm/migrate.c

369

!folio_test_pmd_mappable(folio), folio);

mm/migrate.c

376

try_to_map_unused_to_zeropage(&pvmw, folio, old_pte, idx))

mm/migrate.c

379

folio_get(folio);

mm/migrate.c

385

if (folio_test_dirty(folio) && softleaf_is_migration_dirty(entry))

mm/migrate.c

397

if (folio_test_anon(folio) && !softleaf_is_migration_read(entry))

mm/migrate.c

415

if (folio_test_hugetlb(folio)) {

mm/migrate.c

421

if (folio_test_anon(folio))

mm/migrate.c

422

hugetlb_add_anon_rmap(folio, vma, pvmw.address,

mm/migrate.c

425

hugetlb_add_file_rmap(folio);

mm/migrate.c

431

if (folio_test_anon(folio))

mm/migrate.c

432

folio_add_anon_rmap_pte(folio, new, vma,

mm/migrate.c

435

folio_add_file_rmap_pte(folio, new, vma);

mm/migrate.c

455

void remove_migration_ptes(struct folio *src, struct folio *dst,

mm/migrate.c

459

.folio = src,

mm/migrate.c

572

struct folio *newfolio, struct folio *folio, int expected_count)

mm/migrate.c

574

XA_STATE(xas, &mapping->i_pages, folio->index);

mm/migrate.c

578

long nr = folio_nr_pages(folio);

mm/migrate.c

582

if (folio_test_large(folio) &&

mm/migrate.c

583

folio_test_large_rmappable(folio)) {

mm/migrate.c

584

if (!folio_ref_freeze(folio, expected_count))

mm/migrate.c

586

folio_unqueue_deferred_split(folio);

mm/migrate.c

587

folio_ref_unfreeze(folio, expected_count);

mm/migrate.c

591

newfolio->index = folio->index;

mm/migrate.c

592

newfolio->mapping = folio->mapping;

mm/migrate.c

593

if (folio_test_anon(folio) && folio_test_large(folio) &&

mm/migrate.c

594

!folio_test_hugetlb(folio))

mm/migrate.c

595

mod_mthp_stat(folio_order(folio), MTHP_STAT_NR_ANON, 1);

mm/migrate.c

596

if (folio_test_swapbacked(folio))

mm/migrate.c

602

oldzone = folio_zone(folio);

mm/migrate.c

605

if (folio_test_swapcache(folio))

mm/migrate.c

606

ci = swap_cluster_get_and_lock_irq(folio);

mm/migrate.c

610

if (!folio_ref_freeze(folio, expected_count)) {

mm/migrate.c

619

folio_unqueue_deferred_split(folio);

mm/migrate.c

625

newfolio->index = folio->index;

mm/migrate.c

626

newfolio->mapping = folio->mapping;

mm/migrate.c

627

if (folio_test_anon(folio) && folio_test_large(folio))

mm/migrate.c

628

mod_mthp_stat(folio_order(folio), MTHP_STAT_NR_ANON, 1);

mm/migrate.c

630

if (folio_test_swapbacked(folio))

mm/migrate.c

632

if (folio_test_swapcache(folio)) {

mm/migrate.c

634

newfolio->private = folio_get_private(folio);

mm/migrate.c

638

dirty = folio_test_dirty(folio);

mm/migrate.c

640

folio_clear_dirty(folio);

mm/migrate.c

644

if (folio_test_swapcache(folio))

mm/migrate.c

645

__swap_cache_replace_folio(ci, folio, newfolio);

mm/migrate.c

654

folio_ref_unfreeze(folio, expected_count - nr);

mm/migrate.c

677

memcg = folio_memcg(folio);

mm/migrate.c

683

if (folio_test_swapbacked(folio) && !folio_test_swapcache(folio)) {

mm/migrate.c

687

if (folio_test_pmd_mappable(folio)) {

mm/migrate.c

693

if (folio_test_swapcache(folio)) {

mm/migrate.c

712

struct folio *newfolio, struct folio *folio, int extra_count)

mm/migrate.c

714

int expected_count = folio_expected_ref_count(folio) + extra_count + 1;

mm/migrate.c

716

if (folio_ref_count(folio) != expected_count)

mm/migrate.c

719

return __folio_migrate_mapping(mapping, newfolio, folio, expected_count);

mm/migrate.c

728

struct folio *dst, struct folio *src)

mm/migrate.c

763

void folio_migrate_flags(struct folio *newfolio, struct folio *folio)

mm/migrate.c

767

if (folio_test_referenced(folio))

mm/migrate.c

769

if (folio_test_uptodate(folio))

mm/migrate.c

771

if (folio_test_clear_active(folio)) {

mm/migrate.c

772

VM_BUG_ON_FOLIO(folio_test_unevictable(folio), folio);

mm/migrate.c

774

} else if (folio_test_clear_unevictable(folio))

mm/migrate.c

776

if (folio_test_workingset(folio))

mm/migrate.c

778

if (folio_test_checked(folio))

mm/migrate.c

786

if (folio_test_mappedtodisk(folio))

mm/migrate.c

790

if (folio_test_dirty(folio))

mm/migrate.c

793

if (folio_test_young(folio))

mm/migrate.c

795

if (folio_test_idle(folio))

mm/migrate.c

798

folio_migrate_refs(newfolio, folio);

mm/migrate.c

803

cpupid = folio_xchg_last_cpupid(folio, -1);

mm/migrate.c

810

bool f_toptier = node_is_toptier(folio_nid(folio));

mm/migrate.c

818

folio_migrate_ksm(newfolio, folio);

mm/migrate.c

824

if (folio_test_swapcache(folio))

mm/migrate.c

825

folio_clear_swapcache(folio);

mm/migrate.c

826

folio_clear_private(folio);

mm/migrate.c

829

if (!folio_test_hugetlb(folio))

mm/migrate.c

830

folio->private = NULL;

mm/migrate.c

844

if (folio_test_readahead(folio))

mm/migrate.c

847

folio_copy_owner(newfolio, folio);

mm/migrate.c

848

pgalloc_tag_swap(newfolio, folio);

mm/migrate.c

850

mem_cgroup_migrate(folio, newfolio);

mm/migrate.c

858

static int __migrate_folio(struct address_space *mapping, struct folio *dst,

mm/migrate.c

859

struct folio *src, void *src_private,

mm/migrate.c

895

int migrate_folio(struct address_space *mapping, struct folio *dst,

mm/migrate.c

896

struct folio *src, enum migrate_mode mode)

mm/migrate.c

938

struct folio *dst, struct folio *src, enum migrate_mode mode,

mm/migrate_device.c

1021

if (mem_cgroup_charge(folio, vma->vm_mm, GFP_KERNEL))

mm/migrate_device.c

1029

__folio_mark_uptodate(folio);

mm/migrate_device.c

1031

if (folio_is_device_private(folio)) {

mm/migrate_device.c

1042

if (folio_is_zone_device(folio) &&

mm/migrate_device.c

1043

!folio_is_device_coherent(folio)) {

mm/migrate_device.c

1077

folio_add_new_anon_rmap(folio, vma, addr, RMAP_EXCLUSIVE);

mm/migrate_device.c

1078

if (!folio_is_zone_device(folio))

mm/migrate_device.c

1079

folio_add_lru_vma(folio, vma);

mm/migrate_device.c

1080

folio_get(folio);

mm/migrate_device.c

110

folio_unlock(folio);

mm/migrate_device.c

111

folio_put(folio);

mm/migrate_device.c

1112

struct folio *newfolio, *folio;

mm/migrate_device.c

112

} else if (folio != new_fault_folio) {

mm/migrate_device.c

1162

folio = page_folio(page);

mm/migrate_device.c

1163

mapping = folio_mapping(folio);

mm/migrate_device.c

117

folio_unlock(folio);

mm/migrate_device.c

1179

nr = 1 << folio_order(folio);

mm/migrate_device.c

118

folio_put(folio);

mm/migrate_device.c

1181

if (migrate_vma_split_unmapped_folio(migrate, i, addr, folio)) {

mm/migrate_device.c

1203

if (!folio_test_anon(folio) ||

mm/migrate_device.c

1204

!folio_free_swap(folio)) {

mm/migrate_device.c

1217

BUG_ON(folio_test_writeback(folio));

mm/migrate_device.c

1222

folio = page_folio(migrate_pfn_to_page(src_pfns[i+j]));

mm/migrate_device.c

1225

r = folio_migrate_mapping(mapping, newfolio, folio, extra_cnt);

mm/migrate_device.c

1229

folio_migrate_flags(newfolio, folio);

mm/migrate_device.c

1274

struct folio *fault_folio = fault_page ?

mm/migrate_device.c

1279

struct folio *dst = NULL, *src = NULL;

mm/migrate_device.c

1358

struct folio *folio;

mm/migrate_device.c

1360

folio = folio_get_nontail_page(pfn_to_page(pfn));

mm/migrate_device.c

1361

if (!folio)

mm/migrate_device.c

1364

if (!folio_trylock(folio)) {

mm/migrate_device.c

1365

folio_put(folio);

mm/migrate_device.c

138

struct folio *fault_folio)

mm/migrate_device.c

1398

struct folio *folio = page_folio(page);

mm/migrate_device.c

1402

nr = folio_nr_pages(folio);

mm/migrate_device.c

141

struct folio *folio;

mm/migrate_device.c

1432

struct folio *folio = page_folio(page);

mm/migrate_device.c

1436

nr = folio_nr_pages(folio);

mm/migrate_device.c

1456

int migrate_device_coherent_folio(struct folio *folio)

mm/migrate_device.c

1459

struct folio *dfolio;

mm/migrate_device.c

1461

WARN_ON_ONCE(folio_test_large(folio));

mm/migrate_device.c

1463

folio_lock(folio);

mm/migrate_device.c

1464

src_pfn = migrate_pfn(folio_pfn(folio)) | MIGRATE_PFN_MIGRATE;

mm/migrate_device.c

1483

folio_copy(dfolio, folio);

mm/migrate_device.c

159

folio = pmd_folio(*pmdp);

mm/migrate_device.c

160

if (is_huge_zero_folio(folio)) {

mm/migrate_device.c

169

folio = softleaf_to_folio(entry);

mm/migrate_device.c

173

(folio->pgmap->owner != migrate->pgmap_owner)) {

mm/migrate_device.c

185

folio_get(folio);

mm/migrate_device.c

186

if (folio != fault_folio && unlikely(!folio_trylock(folio))) {

mm/migrate_device.c

188

folio_put(folio);

mm/migrate_device.c

204

unsigned long pfn = page_to_pfn(folio_page(folio, 0));

mm/migrate_device.c

211

ret = set_pmd_migration_entry(&pvmw, folio_page(folio, 0));

mm/migrate_device.c

226

if (!folio_test_large(folio))

mm/migrate_device.c

228

ret = split_folio(folio);

mm/migrate_device.c

229

if (fault_folio != folio)

mm/migrate_device.c

230

folio_unlock(folio);

mm/migrate_device.c

231

folio_put(folio);

mm/migrate_device.c

251

struct folio *fault_folio = migrate->fault_page ?

mm/migrate_device.c

274

struct folio *folio;

mm/migrate_device.c

306

folio = page_folio(page);

mm/migrate_device.c

307

if (folio_test_large(folio)) {

mm/migrate_device.c

312

ret = migrate_vma_split_folio(folio,

mm/migrate_device.c

349

folio = page ? page_folio(page) : NULL;

mm/migrate_device.c

350

if (folio && folio_test_large(folio)) {

mm/migrate_device.c

355

ret = migrate_vma_split_folio(folio,

mm/migrate_device.c

385

folio = page_folio(page);

mm/migrate_device.c

386

folio_get(folio);

mm/migrate_device.c

400

if (fault_folio == folio || folio_trylock(folio)) {

mm/migrate_device.c

406

anon_exclusive = folio_test_anon(folio) &&

mm/migrate_device.c

411

if (folio_try_share_anon_rmap_pte(folio, page)) {

mm/migrate_device.c

413

if (fault_folio != folio)

mm/migrate_device.c

414

folio_unlock(folio);

mm/migrate_device.c

415

folio_put(folio);

mm/migrate_device.c

427

folio_mark_dirty(folio);

mm/migrate_device.c

464

folio_remove_rmap_pte(folio, page, vma);

mm/migrate_device.c

465

folio_put(folio);

mm/migrate_device.c

470

folio_put(folio);

mm/migrate_device.c

534

struct folio *folio = page_folio(page);

mm/migrate_device.c

544

if (folio_is_zone_device(folio))

mm/migrate_device.c

548

if (folio_mapping(folio))

mm/migrate_device.c

549

extra += 1 + folio_has_private(folio);

mm/migrate_device.c

551

if ((folio_ref_count(folio) - extra) > folio_mapcount(folio))

mm/migrate_device.c

565

struct folio *fault_folio = fault_page ?

mm/migrate_device.c

575

struct folio *folio;

mm/migrate_device.c

584

folio = page_folio(page);

mm/migrate_device.c

585

nr = folio_nr_pages(folio);

mm/migrate_device.c

592

if (!folio_is_zone_device(folio)) {

mm/migrate_device.c

593

if (!folio_test_lru(folio) && allow_drain) {

mm/migrate_device.c

599

if (!folio_isolate_lru(folio)) {

mm/migrate_device.c

606

folio_put(folio);

mm/migrate_device.c

609

if (folio_mapped(folio))

mm/migrate_device.c

610

try_to_migrate(folio, 0);

mm/migrate_device.c

612

if (folio_mapped(folio) ||

mm/migrate_device.c

614

if (!folio_is_zone_device(folio)) {

mm/migrate_device.c

615

folio_get(folio);

mm/migrate_device.c

616

folio_putback_lru(folio);

mm/migrate_device.c

631

struct folio *folio;

mm/migrate_device.c

636

folio = page_folio(page);

mm/migrate_device.c

637

remove_migration_ptes(folio, folio, 0);

mm/migrate_device.c

640

if (fault_folio != folio)

mm/migrate_device.c

641

folio_unlock(folio);

mm/migrate_device.c

642

folio_put(folio);

mm/migrate_device.c

796

struct folio *folio = page_folio(page);

mm/migrate_device.c

805

VM_WARN_ON_ONCE(!folio);

mm/migrate_device.c

814

folio_set_order(folio, HPAGE_PMD_ORDER);

mm/migrate_device.c

815

folio_set_large_rmappable(folio);

mm/migrate_device.c

817

if (mem_cgroup_charge(folio, migrate->vma->vm_mm, gfp)) {

mm/migrate_device.c

82

static int migrate_vma_split_folio(struct folio *folio,

mm/migrate_device.c

824

__folio_mark_uptodate(folio);

mm/migrate_device.c

830

if (folio_is_device_private(folio)) {

mm/migrate_device.c

841

if (folio_is_zone_device(folio) &&

mm/migrate_device.c

842

!folio_is_device_coherent(folio)) {

mm/migrate_device.c

845

entry = folio_mk_pmd(folio, vma->vm_page_prot);

mm/migrate_device.c

86

struct folio *fault_folio = fault_page ? page_folio(fault_page) : NULL;

mm/migrate_device.c

868

folio_add_new_anon_rmap(folio, vma, addr, RMAP_EXCLUSIVE);

mm/migrate_device.c

869

if (!folio_is_zone_device(folio))

mm/migrate_device.c

87

struct folio *new_fault_folio = NULL;

mm/migrate_device.c

870

folio_add_lru_vma(folio, vma);

mm/migrate_device.c

871

folio_get(folio);

mm/migrate_device.c

89

if (folio != fault_folio) {

mm/migrate_device.c

90

folio_get(folio);

mm/migrate_device.c

904

struct folio *folio)

mm/migrate_device.c

91

folio_lock(folio);

mm/migrate_device.c

915

folio_get(folio);

mm/migrate_device.c

917

ret = folio_split_unmapped(folio, 0);

mm/migrate_device.c

939

struct folio *folio)

mm/migrate_device.c

94

ret = split_folio(folio);

mm/migrate_device.c

96

if (folio != fault_folio) {

mm/migrate_device.c

97

folio_unlock(folio);

mm/migrate_device.c

972

struct folio *folio = page_folio(page);

mm/migrate_device.c

98

folio_put(folio);

mm/mincore.c

111

struct folio *folio;

mm/mincore.c

119

folio = filemap_get_entry(mapping, index);

mm/mincore.c

120

if (folio) {

mm/mincore.c

121

if (xa_is_value(folio)) {

mm/mincore.c

123

return mincore_swap(radix_to_swp_entry(folio),

mm/mincore.c

128

present = folio_test_uptodate(folio);

mm/mincore.c

129

folio_put(folio);

mm/mincore.c

64

struct folio *folio = NULL;

mm/mincore.c

90

folio = swap_cache_get_folio(entry);

mm/mincore.c

94

if (folio && !xa_is_value(folio)) {

mm/mincore.c

95

present = folio_test_uptodate(folio);

mm/mincore.c

96

folio_put(folio);

mm/mlock.c

103

static struct lruvec *__mlock_new_folio(struct folio *folio, struct lruvec *lruvec)

mm/mlock.c

105

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/mlock.c

107

lruvec = folio_lruvec_relock_irq(folio, lruvec);

mm/mlock.c

110

if (unlikely(folio_evictable(folio)))

mm/mlock.c

113

folio_set_unevictable(folio);

mm/mlock.c

114

folio->mlock_count = !!folio_test_mlocked(folio);

mm/mlock.c

115

__count_vm_events(UNEVICTABLE_PGCULLED, folio_nr_pages(folio));

mm/mlock.c

117

lruvec_add_folio(lruvec, folio);

mm/mlock.c

118

folio_set_lru(folio);

mm/mlock.c

122

static struct lruvec *__munlock_folio(struct folio *folio, struct lruvec *lruvec)

mm/mlock.c

124

int nr_pages = folio_nr_pages(folio);

mm/mlock.c

127

if (!folio_test_clear_lru(folio))

mm/mlock.c

131

lruvec = folio_lruvec_relock_irq(folio, lruvec);

mm/mlock.c

133

if (folio_test_unevictable(folio)) {

mm/mlock.c

135

if (folio->mlock_count)

mm/mlock.c

136

folio->mlock_count--;

mm/mlock.c

137

if (folio->mlock_count)

mm/mlock.c

143

if (folio_test_clear_mlocked(folio)) {

mm/mlock.c

144

__zone_stat_mod_folio(folio, NR_MLOCK, -nr_pages);

mm/mlock.c

145

if (isolated || !folio_test_unevictable(folio))

mm/mlock.c

152

if (isolated && folio_test_unevictable(folio) && folio_evictable(folio)) {

mm/mlock.c

153

lruvec_del_folio(lruvec, folio);

mm/mlock.c

154

folio_clear_unevictable(folio);

mm/mlock.c

155

lruvec_add_folio(lruvec, folio);

mm/mlock.c

160

folio_set_lru(folio);

mm/mlock.c

169

static inline struct folio *mlock_lru(struct folio *folio)

mm/mlock.c

171

return (struct folio *)((unsigned long)folio + LRU_FOLIO);

mm/mlock.c

174

static inline struct folio *mlock_new(struct folio *folio)

mm/mlock.c

176

return (struct folio *)((unsigned long)folio + NEW_FOLIO);

mm/mlock.c

190

struct folio *folio;

mm/mlock.c

194

folio = fbatch->folios[i];

mm/mlock.c

195

mlock = (unsigned long)folio & (LRU_FOLIO | NEW_FOLIO);

mm/mlock.c

196

folio = (struct folio *)((unsigned long)folio - mlock);

mm/mlock.c

197

fbatch->folios[i] = folio;

mm/mlock.c

200

lruvec = __mlock_folio(folio, lruvec);

mm/mlock.c

202

lruvec = __mlock_new_folio(folio, lruvec);

mm/mlock.c

204

lruvec = __munlock_folio(folio, lruvec);

mm/mlock.c

242

void mlock_folio(struct folio *folio)

mm/mlock.c

249

if (!folio_test_set_mlocked(folio)) {

mm/mlock.c

250

int nr_pages = folio_nr_pages(folio);

mm/mlock.c

252

zone_stat_mod_folio(folio, NR_MLOCK, nr_pages);

mm/mlock.c

256

folio_get(folio);

mm/mlock.c

257

if (!folio_batch_add(fbatch, mlock_lru(folio)) ||

mm/mlock.c

258

!folio_may_be_lru_cached(folio) || lru_cache_disabled())

mm/mlock.c

267

void mlock_new_folio(struct folio *folio)

mm/mlock.c

270

int nr_pages = folio_nr_pages(folio);

mm/mlock.c

274

folio_set_mlocked(folio);

mm/mlock.c

276

zone_stat_mod_folio(folio, NR_MLOCK, nr_pages);

mm/mlock.c

279

folio_get(folio);

mm/mlock.c

280

if (!folio_batch_add(fbatch, mlock_new(folio)) ||

mm/mlock.c

281

!folio_may_be_lru_cached(folio) || lru_cache_disabled())

mm/mlock.c

290

void munlock_folio(struct folio *folio)

mm/mlock.c

300

folio_get(folio);

mm/mlock.c

301

if (!folio_batch_add(fbatch, folio) ||

mm/mlock.c

302

!folio_may_be_lru_cached(folio) || lru_cache_disabled())

mm/mlock.c

307

static inline unsigned int folio_mlock_step(struct folio *folio,

mm/mlock.c

313

if (!folio_test_large(folio))

mm/mlock.c

316

return folio_pte_batch(folio, pte, ptent, count);

mm/mlock.c

319

static inline bool allow_mlock_munlock(struct folio *folio,

mm/mlock.c

336

if (!folio_test_large(folio))

mm/mlock.c

340

if (!folio_within_range(folio, vma, start, end))

mm/mlock.c

344

if (step != folio_nr_pages(folio))

mm/mlock.c

358

struct folio *folio;

mm/mlock.c

368

folio = pmd_folio(*pmd);

mm/mlock.c

369

if (folio_is_zone_device(folio))

mm/mlock.c

372

mlock_folio(folio);

mm/mlock.c

374

munlock_folio(folio);

mm/mlock.c

388

folio = vm_normal_folio(vma, addr, ptent);

mm/mlock.c

389

if (!folio || folio_is_zone_device(folio))

mm/mlock.c

392

step = folio_mlock_step(folio, pte, addr, end);

mm/mlock.c

393

if (!allow_mlock_munlock(folio, vma, start, end, step))

mm/mlock.c

397

mlock_folio(folio);

mm/mlock.c

399

munlock_folio(folio);

mm/mlock.c

61

static struct lruvec *__mlock_folio(struct folio *folio, struct lruvec *lruvec)

mm/mlock.c

64

if (!folio_test_clear_lru(folio))

mm/mlock.c

67

lruvec = folio_lruvec_relock_irq(folio, lruvec);

mm/mlock.c

69

if (unlikely(folio_evictable(folio))) {

mm/mlock.c

75

if (folio_test_unevictable(folio)) {

mm/mlock.c

76

lruvec_del_folio(lruvec, folio);

mm/mlock.c

77

folio_clear_unevictable(folio);

mm/mlock.c

78

lruvec_add_folio(lruvec, folio);

mm/mlock.c

81

folio_nr_pages(folio));

mm/mlock.c

86

if (folio_test_unevictable(folio)) {

mm/mlock.c

87

if (folio_test_mlocked(folio))

mm/mlock.c

88

folio->mlock_count++;

mm/mlock.c

92

lruvec_del_folio(lruvec, folio);

mm/mlock.c

93

folio_clear_active(folio);

mm/mlock.c

94

folio_set_unevictable(folio);

mm/mlock.c

95

folio->mlock_count = !!folio_test_mlocked(folio);

mm/mlock.c

96

lruvec_add_folio(lruvec, folio);

mm/mlock.c

97

__count_vm_events(UNEVICTABLE_PGCULLED, folio_nr_pages(folio));

mm/mlock.c

99

folio_set_lru(folio);

mm/mmzone.c

102

old_flags = READ_ONCE(folio->flags.f);

mm/mmzone.c

109

} while (unlikely(!try_cmpxchg(&folio->flags.f, &old_flags, flags)));

mm/mmzone.c

97

int folio_xchg_last_cpupid(struct folio *folio, int cpupid)

mm/mprotect.c

106

static int mprotect_folio_pte_batch(struct folio *folio, pte_t *ptep,

mm/mprotect.c

110

if (!folio)

mm/mprotect.c

113

if (!folio_test_large(folio))

mm/mprotect.c

116

return folio_pte_batch_flags(folio, NULL, ptep, &pte, max_nr_ptes, flags);

mm/mprotect.c

173

struct folio *folio, struct page *first_page, unsigned long addr, pte_t *ptep,

mm/mprotect.c

192

struct folio *folio, struct page *page, unsigned long addr, pte_t *ptep,

mm/mprotect.c

205

(folio && folio_test_anon(folio));

mm/mprotect.c

211

commit_anon_folio_batch(vma, folio, page, addr, ptep, oldpte, ptent, nr_ptes, tlb);

mm/mprotect.c

223

const struct folio *folio = softleaf_to_folio(entry);

mm/mprotect.c

229

if (folio_test_anon(folio))

mm/mprotect.c

283

struct folio *folio, struct page *page, unsigned long cp_flags)

mm/mprotect.c

312

set_write_prot_commit_flush_ptes(vma, folio, page,

mm/mprotect.c

347

struct folio *folio = NULL;

mm/mprotect.c

356

folio = page_folio(page);

mm/mprotect.c

363

!folio_can_map_prot_numa(folio, vma,

mm/mprotect.c

367

nr_ptes = mprotect_folio_pte_batch(folio,

mm/mprotect.c

372

nr_ptes = mprotect_folio_pte_batch(folio, pte, oldpte, max_nr_ptes, flags);

mm/mprotect.c

381

end, newprot, folio, page, cp_flags);

mm/mprotect.c

384

nr_ptes, end, newprot, folio, page,

mm/mremap.c

181

struct folio *folio;

mm/mremap.c

190

folio = vm_normal_folio(vma, addr, pte);

mm/mremap.c

191

if (!folio || !folio_test_large(folio))

mm/mremap.c

194

return folio_pte_batch_flags(folio, NULL, ptep, &pte, max_nr, FPB_RESPECT_WRITE);

mm/nommu.c

103

return folio_size(folio);

mm/nommu.c

67

struct folio *folio;

mm/nommu.c

76

folio = virt_to_folio(objp);

mm/nommu.c

82

if (folio_test_slab(folio))

mm/nommu.c

91

if (!folio_test_large(folio)) {

mm/page-writeback.c

2379

struct writeback_control *wbc, struct folio *folio)

mm/page-writeback.c

2388

if (unlikely(folio->mapping != mapping))

mm/page-writeback.c

2394

if (!folio_test_dirty(folio))

mm/page-writeback.c

2397

if (folio_test_writeback(folio)) {

mm/page-writeback.c

2400

folio_wait_writeback(folio);

mm/page-writeback.c

2402

BUG_ON(folio_test_writeback(folio));

mm/page-writeback.c

2404

if (!folio_clear_dirty_for_io(folio))

mm/page-writeback.c

2418

static struct folio *writeback_get_folio(struct address_space *mapping,

mm/page-writeback.c

2421

struct folio *folio;

mm/page-writeback.c

2424

folio = folio_batch_next(&wbc->fbatch);

mm/page-writeback.c

2425

if (!folio) {

mm/page-writeback.c

2430

folio = folio_batch_next(&wbc->fbatch);

mm/page-writeback.c

2431

if (!folio)

mm/page-writeback.c

2435

folio_lock(folio);

mm/page-writeback.c

2436

if (unlikely(!folio_prepare_writeback(mapping, wbc, folio))) {

mm/page-writeback.c

2437

folio_unlock(folio);

mm/page-writeback.c

2442

return folio;

mm/page-writeback.c

2471

struct folio *writeback_iter(struct address_space *mapping,

mm/page-writeback.c

2472

struct writeback_control *wbc, struct folio *folio, int *error)

mm/page-writeback.c

2474

if (!folio) {

mm/page-writeback.c

2505

wbc->nr_to_write -= folio_nr_pages(folio);

mm/page-writeback.c

2529

folio = writeback_get_folio(mapping, wbc);

mm/page-writeback.c

2530

if (!folio) {

mm/page-writeback.c

2550

return folio;

mm/page-writeback.c

2554

mapping->writeback_index = folio_next_index(folio);

mm/page-writeback.c

2601

bool noop_dirty_folio(struct address_space *mapping, struct folio *folio)

mm/page-writeback.c

2603

if (!folio_test_dirty(folio))

mm/page-writeback.c

2604

return !folio_test_set_dirty(folio);

mm/page-writeback.c

2614

static void folio_account_dirtied(struct folio *folio,

mm/page-writeback.c

2619

trace_writeback_dirty_folio(folio, mapping);

mm/page-writeback.c

2623

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2625

inode_attach_wb(inode, folio);

mm/page-writeback.c

2628

lruvec_stat_mod_folio(folio, NR_FILE_DIRTY, nr);

mm/page-writeback.c

2629

if (folio_test_dropbehind(folio))

mm/page-writeback.c

2631

__zone_stat_mod_folio(folio, NR_ZONE_WRITE_PENDING, nr);

mm/page-writeback.c

2632

__node_stat_mod_folio(folio, NR_DIRTIED, nr);

mm/page-writeback.c

2639

mem_cgroup_track_foreign_dirty(folio, wb);

mm/page-writeback.c

2647

void folio_account_cleaned(struct folio *folio, struct bdi_writeback *wb)

mm/page-writeback.c

2649

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2651

lruvec_stat_mod_folio(folio, NR_FILE_DIRTY, -nr);

mm/page-writeback.c

2652

if (folio_test_dropbehind(folio))

mm/page-writeback.c

2654

zone_stat_mod_folio(folio, NR_ZONE_WRITE_PENDING, -nr);

mm/page-writeback.c

2674

void __folio_mark_dirty(struct folio *folio, struct address_space *mapping,

mm/page-writeback.c

2683

VM_WARN_ON_ONCE(folio_test_swapcache(folio) || shmem_mapping(mapping));

mm/page-writeback.c

2686

if (folio->mapping) { /* Race with truncate? */

mm/page-writeback.c

2687

WARN_ON_ONCE(warn && !folio_test_uptodate(folio));

mm/page-writeback.c

2688

folio_account_dirtied(folio, mapping);

mm/page-writeback.c

2689

__xa_set_mark(&mapping->i_pages, folio->index,

mm/page-writeback.c

2714

bool filemap_dirty_folio(struct address_space *mapping, struct folio *folio)

mm/page-writeback.c

2716

if (folio_test_set_dirty(folio))

mm/page-writeback.c

2719

__folio_mark_dirty(folio, mapping, !folio_test_private(folio));

mm/page-writeback.c

2742

struct folio *folio)

mm/page-writeback.c

2744

struct address_space *mapping = folio->mapping;

mm/page-writeback.c

2745

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2749

ret = filemap_dirty_folio(mapping, folio);

mm/page-writeback.c

2757

node_stat_mod_folio(folio, NR_DIRTIED, -nr);

mm/page-writeback.c

2778

bool folio_mark_dirty(struct folio *folio)

mm/page-writeback.c

2780

struct address_space *mapping = folio_mapping(folio);

mm/page-writeback.c

2794

if (folio_test_reclaim(folio))

mm/page-writeback.c

2795

folio_clear_reclaim(folio);

mm/page-writeback.c

2796

return mapping->a_ops->dirty_folio(mapping, folio);

mm/page-writeback.c

2799

return noop_dirty_folio(mapping, folio);

mm/page-writeback.c

2813

bool folio_mark_dirty_lock(struct folio *folio)

mm/page-writeback.c

2817

folio_lock(folio);

mm/page-writeback.c

2818

ret = folio_mark_dirty(folio);

mm/page-writeback.c

2819

folio_unlock(folio);

mm/page-writeback.c

2837

void __folio_cancel_dirty(struct folio *folio)

mm/page-writeback.c

2839

struct address_space *mapping = folio_mapping(folio);

mm/page-writeback.c

2848

if (folio_test_clear_dirty(folio))

mm/page-writeback.c

2849

folio_account_cleaned(folio, wb);

mm/page-writeback.c

2853

folio_clear_dirty(folio);

mm/page-writeback.c

2872

bool folio_clear_dirty_for_io(struct folio *folio)

mm/page-writeback.c

2874

struct address_space *mapping = folio_mapping(folio);

mm/page-writeback.c

2877

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/page-writeback.c

2909

if (folio_mkclean(folio))

mm/page-writeback.c

2910

folio_mark_dirty(folio);

mm/page-writeback.c

2920

if (folio_test_clear_dirty(folio)) {

mm/page-writeback.c

2921

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2922

lruvec_stat_mod_folio(folio, NR_FILE_DIRTY, -nr);

mm/page-writeback.c

2923

if (folio_test_dropbehind(folio))

mm/page-writeback.c

2925

zone_stat_mod_folio(folio, NR_ZONE_WRITE_PENDING, -nr);

mm/page-writeback.c

2932

return folio_test_clear_dirty(folio);

mm/page-writeback.c

2958

bool __folio_end_writeback(struct folio *folio)

mm/page-writeback.c

2960

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2961

struct address_space *mapping = folio_mapping(folio);

mm/page-writeback.c

2970

ret = folio_xor_flags_has_waiters(folio, 1 << PG_writeback);

mm/page-writeback.c

2971

__xa_clear_mark(&mapping->i_pages, folio->index,

mm/page-writeback.c

2985

ret = folio_xor_flags_has_waiters(folio, 1 << PG_writeback);

mm/page-writeback.c

2988

lruvec_stat_mod_folio(folio, NR_WRITEBACK, -nr);

mm/page-writeback.c

2989

zone_stat_mod_folio(folio, NR_ZONE_WRITE_PENDING, -nr);

mm/page-writeback.c

2990

node_stat_mod_folio(folio, NR_WRITTEN, nr);

mm/page-writeback.c

2995

void __folio_start_writeback(struct folio *folio, bool keep_write)

mm/page-writeback.c

2997

long nr = folio_nr_pages(folio);

mm/page-writeback.c

2998

struct address_space *mapping = folio_mapping(folio);

mm/page-writeback.c

3001

VM_BUG_ON_FOLIO(folio_test_writeback(folio), folio);

mm/page-writeback.c

3002

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/page-writeback.c

3005

XA_STATE(xas, &mapping->i_pages, folio->index);

mm/page-writeback.c

3013

folio_test_set_writeback(folio);

mm/page-writeback.c

3031

if (!folio_test_dirty(folio))

mm/page-writeback.c

3037

folio_test_set_writeback(folio);

mm/page-writeback.c

3040

lruvec_stat_mod_folio(folio, NR_WRITEBACK, nr);

mm/page-writeback.c

3041

zone_stat_mod_folio(folio, NR_ZONE_WRITE_PENDING, nr);

mm/page-writeback.c

3043

access_ret = arch_make_folio_accessible(folio);

mm/page-writeback.c

3048

VM_BUG_ON_FOLIO(access_ret != 0, folio);

mm/page-writeback.c

3064

void folio_wait_writeback(struct folio *folio)

mm/page-writeback.c

3066

while (folio_test_writeback(folio)) {

mm/page-writeback.c

3067

trace_folio_wait_writeback(folio, folio_mapping(folio));

mm/page-writeback.c

3068

folio_wait_bit(folio, PG_writeback);

mm/page-writeback.c

3086

int folio_wait_writeback_killable(struct folio *folio)

mm/page-writeback.c

3088

while (folio_test_writeback(folio)) {

mm/page-writeback.c

3089

trace_folio_wait_writeback(folio, folio_mapping(folio));

mm/page-writeback.c

3090

if (folio_wait_bit_killable(folio, PG_writeback))

mm/page-writeback.c

3111

void folio_wait_stable(struct folio *folio)

mm/page-writeback.c

3113

if (mapping_stable_writes(folio_mapping(folio)))

mm/page-writeback.c

3114

folio_wait_writeback(folio);

mm/page_alloc.c

1089

struct folio *folio = (struct folio *)head_page;

mm/page_alloc.c

1105

if (unlikely(folio_large_mapcount(folio))) {

mm/page_alloc.c

1110

unlikely(atomic_read(&folio->_nr_pages_mapped))) {

mm/page_alloc.c

1115

if (unlikely(folio->_mm_id_mapcount[0] != -1)) {

mm/page_alloc.c

1119

if (unlikely(folio->_mm_id_mapcount[1] != -1)) {

mm/page_alloc.c

1125

if (unlikely(atomic_read(&folio->_entire_mapcount) + 1)) {

mm/page_alloc.c

1129

if (unlikely(atomic_read(&folio->_pincount))) {

mm/page_alloc.c

1137

if (unlikely(!list_empty(&folio->_deferred_list))) {

mm/page_alloc.c

1142

if (unlikely(atomic_read(&folio->_entire_mapcount) + 1)) {

mm/page_alloc.c

1146

if (unlikely(atomic_read(&folio->_pincount))) {

mm/page_alloc.c

1319

struct folio *folio = page_folio(page);

mm/page_alloc.c

1338

if (unlikely(folio_test_mlocked(folio))) {

mm/page_alloc.c

1339

long nr_pages = folio_nr_pages(folio);

mm/page_alloc.c

1341

__folio_clear_mlocked(folio);

mm/page_alloc.c

1342

zone_stat_mod_folio(folio, NR_MLOCK, -nr_pages);

mm/page_alloc.c

1373

folio->_nr_pages = 0;

mm/page_alloc.c

1388

if (folio_test_anon(folio)) {

mm/page_alloc.c

1390

folio->mapping = NULL;

mm/page_alloc.c

3007

struct folio *folio = folios->folios[i];

mm/page_alloc.c

3008

unsigned long pfn = folio_pfn(folio);

mm/page_alloc.c

3009

unsigned int order = folio_order(folio);

mm/page_alloc.c

3011

if (!__free_pages_prepare(&folio->page, order, FPI_NONE))

mm/page_alloc.c

3018

free_one_page(folio_zone(folio), &folio->page,

mm/page_alloc.c

3022

folio->private = (void *)(unsigned long)order;

mm/page_alloc.c

3024

folios->folios[j] = folio;

mm/page_alloc.c

3030

struct folio *folio = folios->folios[i];

mm/page_alloc.c

3031

struct zone *zone = folio_zone(folio);

mm/page_alloc.c

3032

unsigned long pfn = folio_pfn(folio);

mm/page_alloc.c

3033

unsigned int order = (unsigned long)folio->private;

mm/page_alloc.c

3036

folio->private = NULL;

mm/page_alloc.c

3037

migratetype = get_pfnblock_migratetype(&folio->page, pfn);

mm/page_alloc.c

3053

free_one_page(zone, &folio->page, pfn,

mm/page_alloc.c

3064

free_one_page(zone, &folio->page, pfn,

mm/page_alloc.c

3078

trace_mm_page_free_batched(&folio->page);

mm/page_alloc.c

3079

if (!free_frozen_page_commit(zone, pcp, &folio->page,

mm/page_alloc.c

5345

struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,

mm/page_idle.c

108

if (!folio_mapped(folio) || !folio_raw_mapping(folio))

mm/page_idle.c

111

if (!folio_trylock(folio))

mm/page_idle.c

114

rmap_walk(folio, &rwc);

mm/page_idle.c

115

folio_unlock(folio);

mm/page_idle.c

123

struct folio *folio;

mm/page_idle.c

142

folio = page_idle_get_folio(pfn);

mm/page_idle.c

143

if (folio) {

mm/page_idle.c

144

if (folio_test_idle(folio)) {

mm/page_idle.c

150

page_idle_clear_pte_refs(folio);

mm/page_idle.c

151

if (folio_test_idle(folio))

mm/page_idle.c

154

folio_put(folio);

mm/page_idle.c

168

struct folio *folio;

mm/page_idle.c

186

folio = page_idle_get_folio(pfn);

mm/page_idle.c

187

if (folio) {

mm/page_idle.c

188

page_idle_clear_pte_refs(folio);

mm/page_idle.c

189

folio_set_idle(folio);

mm/page_idle.c

190

folio_put(folio);

mm/page_idle.c

34

static struct folio *page_idle_get_folio(unsigned long pfn)

mm/page_idle.c

37

struct folio *folio;

mm/page_idle.c

42

folio = page_folio(page);

mm/page_idle.c

43

if (!folio_test_lru(folio) || !folio_try_get(folio))

mm/page_idle.c

45

if (unlikely(page_folio(page) != folio || !folio_test_lru(folio))) {

mm/page_idle.c

46

folio_put(folio);

mm/page_idle.c

47

folio = NULL;

mm/page_idle.c

49

return folio;

mm/page_idle.c

52

static bool page_idle_clear_pte_refs_one(struct folio *folio,

mm/page_idle.c

56

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, addr, 0);

mm/page_idle.c

86

folio_clear_idle(folio);

mm/page_idle.c

92

folio_set_young(folio);

mm/page_idle.c

97

static void page_idle_clear_pte_refs(struct folio *folio)

mm/page_io.c

175

static bool is_folio_zero_filled(struct folio *folio)

mm/page_io.c

182

for (i = 0; i < folio_nr_pages(folio); i++) {

mm/page_io.c

183

data = kmap_local_folio(folio, i * PAGE_SIZE);

mm/page_io.c

205

static void swap_zeromap_folio_set(struct folio *folio)

mm/page_io.c

207

struct obj_cgroup *objcg = get_obj_cgroup_from_folio(folio);

mm/page_io.c

208

int nr_pages = folio_nr_pages(folio);

mm/page_io.c

213

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/page_io.c

214

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/page_io.c

216

ci = swap_cluster_get_and_lock(folio);

mm/page_io.c

217

for (i = 0; i < folio_nr_pages(folio); i++) {

mm/page_io.c

218

entry = page_swap_entry(folio_page(folio, i));

mm/page_io.c

230

static void swap_zeromap_folio_clear(struct folio *folio)

mm/page_io.c

236

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/page_io.c

237

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/page_io.c

239

ci = swap_cluster_get_and_lock(folio);

mm/page_io.c

240

for (i = 0; i < folio_nr_pages(folio); i++) {

mm/page_io.c

241

entry = page_swap_entry(folio_page(folio, i));

mm/page_io.c

251

int swap_writeout(struct folio *folio, struct swap_iocb **swap_plug)

mm/page_io.c

255

if (folio_free_swap(folio))

mm/page_io.c

262

ret = arch_prepare_to_swap(folio);

mm/page_io.c

264

folio_mark_dirty(folio);

mm/page_io.c

273

if (is_folio_zero_filled(folio)) {

mm/page_io.c

274

swap_zeromap_folio_set(folio);

mm/page_io.c

283

swap_zeromap_folio_clear(folio);

mm/page_io.c

285

if (zswap_store(folio)) {

mm/page_io.c

286

count_mthp_stat(folio_order(folio), MTHP_STAT_ZSWPOUT);

mm/page_io.c

291

if (!mem_cgroup_zswap_writeback_enabled(folio_memcg(folio))) {

mm/page_io.c

293

folio_mark_dirty(folio);

mm/page_io.c

298

__swap_writepage(folio, swap_plug);

mm/page_io.c

301

folio_unlock(folio);

mm/page_io.c

305

static inline void count_swpout_vm_event(struct folio *folio)

mm/page_io.c

308

if (unlikely(folio_test_pmd_mappable(folio))) {

mm/page_io.c

309

count_memcg_folio_events(folio, THP_SWPOUT, 1);

mm/page_io.c

313

count_mthp_stat(folio_order(folio), MTHP_STAT_SWPOUT);

mm/page_io.c

314

count_memcg_folio_events(folio, PSWPOUT, folio_nr_pages(folio));

mm/page_io.c

315

count_vm_events(PSWPOUT, folio_nr_pages(folio));

mm/page_io.c

319

static void bio_associate_blkg_from_page(struct bio *bio, struct folio *folio)

mm/page_io.c

324

if (!folio_memcg_charged(folio))

mm/page_io.c

328

memcg = folio_memcg(folio);

mm/page_io.c

33

struct folio *folio = bio_first_folio_all(bio);

mm/page_io.c

339

#define bio_associate_blkg_from_page(bio, folio) do { } while (0)

mm/page_io.c

393

static void swap_writepage_fs(struct folio *folio, struct swap_iocb **swap_plug)

mm/page_io.c

396

struct swap_info_struct *sis = __swap_entry_to_info(folio->swap);

mm/page_io.c

398

loff_t pos = swap_dev_pos(folio->swap);

mm/page_io.c

400

count_swpout_vm_event(folio);

mm/page_io.c

401

folio_start_writeback(folio);

mm/page_io.c

402

folio_unlock(folio);

mm/page_io.c

418

bvec_set_folio(&sio->bvecs[sio->nr_bvecs], folio, folio_size(folio), 0);

mm/page_io.c

419

sio->len += folio_size(folio);

mm/page_io.c

429

static void swap_writepage_bdev_sync(struct folio *folio,

mm/page_io.c

436

bio.bi_iter.bi_sector = swap_folio_sector(folio);

mm/page_io.c

437

bio_add_folio_nofail(&bio, folio, folio_size(folio), 0);

mm/page_io.c

439

bio_associate_blkg_from_page(&bio, folio);

mm/page_io.c

44

folio_mark_dirty(folio);

mm/page_io.c

440

count_swpout_vm_event(folio);

mm/page_io.c

442

folio_start_writeback(folio);

mm/page_io.c

443

folio_unlock(folio);

mm/page_io.c

449

static void swap_writepage_bdev_async(struct folio *folio,

mm/page_io.c

455

bio->bi_iter.bi_sector = swap_folio_sector(folio);

mm/page_io.c

457

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

mm/page_io.c

459

bio_associate_blkg_from_page(bio, folio);

mm/page_io.c

460

count_swpout_vm_event(folio);

mm/page_io.c

461

folio_start_writeback(folio);

mm/page_io.c

462

folio_unlock(folio);

mm/page_io.c

466

void __swap_writepage(struct folio *folio, struct swap_iocb **swap_plug)

mm/page_io.c

468

struct swap_info_struct *sis = __swap_entry_to_info(folio->swap);

mm/page_io.c

470

VM_BUG_ON_FOLIO(!folio_test_swapcache(folio), folio);

mm/page_io.c

477

swap_writepage_fs(folio, swap_plug);

mm/page_io.c

48

folio_clear_reclaim(folio);

mm/page_io.c

484

swap_writepage_bdev_sync(folio, sis);

mm/page_io.c

486

swap_writepage_bdev_async(folio, sis);

mm/page_io.c

50

folio_end_writeback(folio);

mm/page_io.c

508

struct folio *folio = bvec_folio(&sio->bvecs[p]);

mm/page_io.c

510

count_mthp_stat(folio_order(folio), MTHP_STAT_SWPIN);

mm/page_io.c

511

count_memcg_folio_events(folio, PSWPIN, folio_nr_pages(folio));

mm/page_io.c

512

folio_mark_uptodate(folio);

mm/page_io.c

513

folio_unlock(folio);

mm/page_io.c

518

struct folio *folio = bvec_folio(&sio->bvecs[p]);

mm/page_io.c

520

folio_unlock(folio);

mm/page_io.c

557

static bool swap_read_folio_zeromap(struct folio *folio)

mm/page_io.c

559

int nr_pages = folio_nr_pages(folio);

mm/page_io.c

563

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/page_io.c

571

if (WARN_ON_ONCE(swap_zeromap_batch(folio->swap, nr_pages,

mm/page_io.c

578

objcg = get_obj_cgroup_from_folio(folio);

mm/page_io.c

585

folio_zero_range(folio, 0, folio_size(folio));

mm/page_io.c

586

folio_mark_uptodate(folio);

mm/page_io.c

590

static void swap_read_folio_fs(struct folio *folio, struct swap_iocb **plug)

mm/page_io.c

592

struct swap_info_struct *sis = __swap_entry_to_info(folio->swap);

mm/page_io.c

594

loff_t pos = swap_dev_pos(folio->swap);

mm/page_io.c

61

struct folio *folio = bio_first_folio_all(bio);

mm/page_io.c

613

bvec_set_folio(&sio->bvecs[sio->nr_bvecs], folio, folio_size(folio), 0);

mm/page_io.c

614

sio->len += folio_size(folio);

mm/page_io.c

624

static void swap_read_folio_bdev_sync(struct folio *folio,

mm/page_io.c

631

bio.bi_iter.bi_sector = swap_folio_sector(folio);

mm/page_io.c

632

bio_add_folio_nofail(&bio, folio, folio_size(folio), 0);

mm/page_io.c

638

count_mthp_stat(folio_order(folio), MTHP_STAT_SWPIN);

mm/page_io.c

639

count_memcg_folio_events(folio, PSWPIN, folio_nr_pages(folio));

mm/page_io.c

640

count_vm_events(PSWPIN, folio_nr_pages(folio));

mm/page_io.c

646

static void swap_read_folio_bdev_async(struct folio *folio,

mm/page_io.c

652

bio->bi_iter.bi_sector = swap_folio_sector(folio);

mm/page_io.c

654

bio_add_folio_nofail(bio, folio, folio_size(folio), 0);

mm/page_io.c

655

count_mthp_stat(folio_order(folio), MTHP_STAT_SWPIN);

mm/page_io.c

656

count_memcg_folio_events(folio, PSWPIN, folio_nr_pages(folio));

mm/page_io.c

657

count_vm_events(PSWPIN, folio_nr_pages(folio));

mm/page_io.c

661

void swap_read_folio(struct folio *folio, struct swap_iocb **plug)

mm/page_io.c

663

struct swap_info_struct *sis = __swap_entry_to_info(folio->swap);

mm/page_io.c

665

bool workingset = folio_test_workingset(folio);

mm/page_io.c

669

VM_BUG_ON_FOLIO(!folio_test_swapcache(folio) && !synchronous, folio);

mm/page_io.c

670

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/page_io.c

671

VM_BUG_ON_FOLIO(folio_test_uptodate(folio), folio);

mm/page_io.c

68

folio_mark_uptodate(folio);

mm/page_io.c

684

if (swap_read_folio_zeromap(folio)) {

mm/page_io.c

685

folio_unlock(folio);

mm/page_io.c

689

if (zswap_load(folio) != -ENOENT)

mm/page_io.c

693

zswap_folio_swapin(folio);

mm/page_io.c

696

swap_read_folio_fs(folio, plug);

mm/page_io.c

698

swap_read_folio_bdev_sync(folio, sis);

mm/page_io.c

70

folio_unlock(folio);

mm/page_io.c

700

swap_read_folio_bdev_async(folio, sis);

mm/page_isolation.c

45

struct folio *folio = page_folio(page);

mm/page_isolation.c

49

order = compound_order(&folio->page);

mm/page_isolation.c

53

if (folio_test_hugetlb(folio)) {

mm/page_owner.c

348

void __folio_set_owner_migrate_reason(struct folio *folio, int reason)

mm/page_owner.c

350

struct page_ext *page_ext = page_ext_get(&folio->page);

mm/page_owner.c

375

void __folio_copy_owner(struct folio *newfolio, struct folio *old)

mm/page_vma_mapped.c

352

const struct folio *folio = page_folio(page);

mm/page_vma_mapped.c

360

pvmw.address = vma_address(vma, page_pgoff(folio, page), 1);

mm/pagewalk.c

897

struct folio *folio_walk_start(struct folio_walk *fw,

mm/readahead.c

163

struct folio *folio;

mm/readahead.c

176

while ((folio = readahead_folio(rac)) != NULL) {

mm/readahead.c

177

folio_get(folio);

mm/readahead.c

178

filemap_remove_folio(folio);

mm/readahead.c

179

folio_unlock(folio);

mm/readahead.c

180

folio_put(folio);

mm/readahead.c

183

while ((folio = readahead_folio(rac)) != NULL)

mm/readahead.c

184

aops->read_folio(rac->file, folio);

mm/readahead.c

195

static struct folio *ractl_alloc_folio(struct readahead_control *ractl,

mm/readahead.c

198

struct folio *folio;

mm/readahead.c

200

folio = filemap_alloc_folio(gfp_mask, order, NULL);

mm/readahead.c

201

if (folio && ractl->dropbehind)

mm/readahead.c

202

__folio_set_dropbehind(folio);

mm/readahead.c

204

return folio;

mm/readahead.c

270

struct folio *folio = xa_load(&mapping->i_pages, index + i);

mm/readahead.c

273

if (folio && !xa_is_value(folio)) {

mm/readahead.c

288

folio = ractl_alloc_folio(ractl, gfp_mask,

mm/readahead.c

290

if (!folio)

mm/readahead.c

293

ret = filemap_add_folio(mapping, folio, index + i, gfp_mask);

mm/readahead.c

295

folio_put(folio);

mm/readahead.c

304

folio_set_readahead(folio);

mm/readahead.c

305

ractl->_workingset |= folio_test_workingset(folio);

mm/readahead.c

463

struct folio *folio = ractl_alloc_folio(ractl, gfp, order);

mm/readahead.c

465

if (!folio)

mm/readahead.c

469

folio_set_readahead(folio);

mm/readahead.c

470

err = filemap_add_folio(ractl->mapping, folio, index, gfp);

mm/readahead.c

472

folio_put(folio);

mm/readahead.c

477

ractl->_workingset |= folio_test_workingset(folio);

mm/readahead.c

654

struct folio *folio, unsigned long req_count)

mm/readahead.c

668

if (folio_test_writeback(folio))

mm/readahead.c

672

folio_clear_readahead(folio);

mm/readahead.c

683

folio_nr_pages(folio));

mm/readahead.c

806

struct folio *folio = xa_load(&mapping->i_pages, index);

mm/readahead.c

808

if (folio && !xa_is_value(folio))

mm/readahead.c

811

folio = ractl_alloc_folio(ractl, gfp_mask, min_order);

mm/readahead.c

812

if (!folio)

mm/readahead.c

816

if (filemap_add_folio(mapping, folio, index, gfp_mask) < 0) {

mm/readahead.c

817

folio_put(folio);

mm/readahead.c

820

if (unlikely(folio_test_workingset(folio)) &&

mm/readahead.c

826

ractl->_index = folio->index;

mm/readahead.c

835

struct folio *folio = xa_load(&mapping->i_pages, index);

mm/readahead.c

837

if (folio && !xa_is_value(folio))

mm/readahead.c

840

folio = ractl_alloc_folio(ractl, gfp_mask, min_order);

mm/readahead.c

841

if (!folio)

mm/readahead.c

845

if (filemap_add_folio(mapping, folio, index, gfp_mask) < 0) {

mm/readahead.c

846

folio_put(folio);

mm/readahead.c

849

if (unlikely(folio_test_workingset(folio)) &&

mm/rmap.c

1013

folio_clear_idle(folio);

mm/rmap.c

1014

if (folio_test_clear_young(folio))

mm/rmap.c

1064

int folio_referenced(struct folio *folio, int is_locked,

mm/rmap.c

1069

.mapcount = folio_mapcount(folio),

mm/rmap.c

1080

VM_WARN_ON_ONCE_FOLIO(folio_is_zone_device(folio), folio);

mm/rmap.c

1085

if (!folio_raw_mapping(folio))

mm/rmap.c

1089

we_locked = folio_trylock(folio);

mm/rmap.c

1094

rmap_walk(folio, &rwc);

mm/rmap.c

1098

folio_unlock(folio);

mm/rmap.c

1180

static bool page_mkclean_one(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

1183

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, address, PVMW_SYNC);

mm/rmap.c

1199

int folio_mkclean(struct folio *folio)

mm/rmap.c

1209

BUG_ON(!folio_test_locked(folio));

mm/rmap.c

1211

if (!folio_mapped(folio))

mm/rmap.c

1214

mapping = folio_mapping(folio);

mm/rmap.c

1218

rmap_walk(folio, &rwc);

mm/rmap.c

1231

static bool mapping_wrprotect_range_one(struct folio *folio,

mm/rmap.c

1249

static void __rmap_walk_file(struct folio *folio, struct address_space *mapping,

mm/rmap.c

1330

static void __folio_mod_stat(struct folio *folio, int nr, int nr_pmdmapped)

mm/rmap.c

1335

idx = folio_test_anon(folio) ? NR_ANON_MAPPED : NR_FILE_MAPPED;

mm/rmap.c

1336

lruvec_stat_mod_folio(folio, idx, nr);

mm/rmap.c

1339

if (folio_test_anon(folio)) {

mm/rmap.c

1341

lruvec_stat_mod_folio(folio, idx, nr_pmdmapped);

mm/rmap.c

1344

idx = folio_test_swapbacked(folio) ?

mm/rmap.c

1346

__mod_node_page_state(folio_pgdat(folio), idx,

mm/rmap.c

1352

static __always_inline void __folio_add_rmap(struct folio *folio,

mm/rmap.c

1356

atomic_t *mapped = &folio->_nr_pages_mapped;

mm/rmap.c

1360

__folio_rmap_sanity_checks(folio, page, nr_pages, level);

mm/rmap.c

1364

if (!folio_test_large(folio)) {

mm/rmap.c

1365

nr = atomic_inc_and_test(&folio->_mapcount);

mm/rmap.c

1370

nr = folio_add_return_large_mapcount(folio, orig_nr_pages, vma);

mm/rmap.c

1373

nr = folio_large_nr_pages(folio);

mm/rmap.c

1387

folio_add_large_mapcount(folio, orig_nr_pages, vma);

mm/rmap.c

1391

first = atomic_inc_and_test(&folio->_entire_mapcount);

mm/rmap.c

1394

nr_pmdmapped = folio_large_nr_pages(folio);

mm/rmap.c

1395

nr = folio_inc_return_large_mapcount(folio, vma);

mm/rmap.c

1398

nr = folio_large_nr_pages(folio);

mm/rmap.c

1407

nr_pages = folio_large_nr_pages(folio);

mm/rmap.c

1423

folio_inc_large_mapcount(folio, vma);

mm/rmap.c

1428

__folio_mod_stat(folio, nr, nr_pmdmapped);

mm/rmap.c

1440

void folio_move_anon_rmap(struct folio *folio, struct vm_area_struct *vma)

mm/rmap.c

1444

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/rmap.c

1453

WRITE_ONCE(folio->mapping, anon_vma);

mm/rmap.c

1463

static void __folio_set_anon(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

1484

WRITE_ONCE(folio->mapping, (struct address_space *) anon_vma);

mm/rmap.c

1485

folio->index = linear_page_index(vma, address);

mm/rmap.c

1495

static void __page_check_anon_rmap(const struct folio *folio,

mm/rmap.c

1510

VM_BUG_ON_FOLIO(folio_anon_vma(folio)->root != vma->anon_vma->root,

mm/rmap.c

1511

folio);

mm/rmap.c

1512

VM_BUG_ON_PAGE(page_pgoff(folio, page) != linear_page_index(vma, address),

mm/rmap.c

1516

static __always_inline void __folio_add_anon_rmap(struct folio *folio,

mm/rmap.c

1522

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

mm/rmap.c

1524

__folio_add_rmap(folio, page, nr_pages, vma, level);

mm/rmap.c

1526

if (likely(!folio_test_ksm(folio)))

mm/rmap.c

1527

__page_check_anon_rmap(folio, page, vma, address);

mm/rmap.c

1550

VM_WARN_ON_FOLIO(!folio_test_large(folio) && PageAnonExclusive(page) &&

mm/rmap.c

1551

atomic_read(&folio->_mapcount) > 0, folio);

mm/rmap.c

1555

VM_WARN_ON_FOLIO(folio_test_large(folio) &&

mm/rmap.c

1556

folio_entire_mapcount(folio) > 1 &&

mm/rmap.c

1557

PageAnonExclusive(cur_page), folio);

mm/rmap.c

1566

PageAnonExclusive(cur_page), folio);

mm/rmap.c

1575

if (folio_nr_pages(folio) == nr_pages)

mm/rmap.c

1576

mlock_vma_folio(folio, vma);

mm/rmap.c

1595

void folio_add_anon_rmap_ptes(struct folio *folio, struct page *page,

mm/rmap.c

1599

__folio_add_anon_rmap(folio, page, nr_pages, vma, address, flags,

mm/rmap.c

1616

void folio_add_anon_rmap_pmd(struct folio *folio, struct page *page,

mm/rmap.c

1620

__folio_add_anon_rmap(folio, page, HPAGE_PMD_NR, vma, address, flags,

mm/rmap.c

1642

void folio_add_new_anon_rmap(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

1648

VM_WARN_ON_FOLIO(folio_test_hugetlb(folio), folio);

mm/rmap.c

1649

VM_WARN_ON_FOLIO(!exclusive && !folio_test_locked(folio), folio);

mm/rmap.c

1655

if (!folio_test_swapbacked(folio) && !(vma->vm_flags & VM_DROPPABLE))

mm/rmap.c

1656

__folio_set_swapbacked(folio);

mm/rmap.c

1657

__folio_set_anon(folio, vma, address, exclusive);

mm/rmap.c

1659

if (likely(!folio_test_large(folio))) {

mm/rmap.c

1661

atomic_set(&folio->_mapcount, 0);

mm/rmap.c

1663

SetPageAnonExclusive(&folio->page);

mm/rmap.c

1664

} else if (!folio_test_pmd_mappable(folio)) {

mm/rmap.c

1667

nr = folio_large_nr_pages(folio);

mm/rmap.c

1669

struct page *page = folio_page(folio, i);

mm/rmap.c

1678

folio_set_large_mapcount(folio, nr, vma);

mm/rmap.c

1680

atomic_set(&folio->_nr_pages_mapped, nr);

mm/rmap.c

1682

nr = folio_large_nr_pages(folio);

mm/rmap.c

1684

atomic_set(&folio->_entire_mapcount, 0);

mm/rmap.c

1685

folio_set_large_mapcount(folio, 1, vma);

mm/rmap.c

1687

atomic_set(&folio->_nr_pages_mapped, ENTIRELY_MAPPED);

mm/rmap.c

1689

SetPageAnonExclusive(&folio->page);

mm/rmap.c

1696

__folio_mod_stat(folio, nr, nr_pmdmapped);

mm/rmap.c

1697

mod_mthp_stat(folio_order(folio), MTHP_STAT_NR_ANON, 1);

mm/rmap.c

1700

static __always_inline void __folio_add_file_rmap(struct folio *folio,

mm/rmap.c

1704

VM_WARN_ON_FOLIO(folio_test_anon(folio), folio);

mm/rmap.c

1706

__folio_add_rmap(folio, page, nr_pages, vma, level);

mm/rmap.c

1714

if (folio_nr_pages(folio) == nr_pages)

mm/rmap.c

1715

mlock_vma_folio(folio, vma);

mm/rmap.c

1729

void folio_add_file_rmap_ptes(struct folio *folio, struct page *page,

mm/rmap.c

1732

__folio_add_file_rmap(folio, page, nr_pages, vma, PGTABLE_LEVEL_PTE);

mm/rmap.c

1745

void folio_add_file_rmap_pmd(struct folio *folio, struct page *page,

mm/rmap.c

1749

__folio_add_file_rmap(folio, page, HPAGE_PMD_NR, vma, PGTABLE_LEVEL_PMD);

mm/rmap.c

1765

void folio_add_file_rmap_pud(struct folio *folio, struct page *page,

mm/rmap.c

1770

__folio_add_file_rmap(folio, page, HPAGE_PUD_NR, vma, PGTABLE_LEVEL_PUD);

mm/rmap.c

1776

static __always_inline void __folio_remove_rmap(struct folio *folio,

mm/rmap.c

1780

atomic_t *mapped = &folio->_nr_pages_mapped;

mm/rmap.c

1784

__folio_rmap_sanity_checks(folio, page, nr_pages, level);

mm/rmap.c

1788

if (!folio_test_large(folio)) {

mm/rmap.c

1789

nr = atomic_add_negative(-1, &folio->_mapcount);

mm/rmap.c

1794

nr = folio_sub_return_large_mapcount(folio, nr_pages, vma);

mm/rmap.c

1797

nr = folio_large_nr_pages(folio);

mm/rmap.c

1799

partially_mapped = nr < folio_large_nr_pages(folio) &&

mm/rmap.c

1800

!folio_entire_mapcount(folio);

mm/rmap.c

1806

folio_sub_large_mapcount(folio, nr_pages, vma);

mm/rmap.c

1820

last = atomic_add_negative(-1, &folio->_entire_mapcount);

mm/rmap.c

1822

nr_pmdmapped = folio_large_nr_pages(folio);

mm/rmap.c

1823

nr = folio_dec_return_large_mapcount(folio, vma);

mm/rmap.c

1826

nr = folio_large_nr_pages(folio);

mm/rmap.c

1829

nr < folio_large_nr_pages(folio);

mm/rmap.c

1835

folio_dec_large_mapcount(folio, vma);

mm/rmap.c

1836

last = atomic_add_negative(-1, &folio->_entire_mapcount);

mm/rmap.c

1840

nr_pages = folio_large_nr_pages(folio);

mm/rmap.c

1868

if (partially_mapped && folio_test_anon(folio) &&

mm/rmap.c

1869

!folio_test_partially_mapped(folio) &&

mm/rmap.c

1870

!folio_is_device_private(folio))

mm/rmap.c

1871

deferred_split_folio(folio, true);

mm/rmap.c

1873

__folio_mod_stat(folio, -nr, -nr_pmdmapped);

mm/rmap.c

1883

munlock_vma_folio(folio, vma);

mm/rmap.c

1897

void folio_remove_rmap_ptes(struct folio *folio, struct page *page,

mm/rmap.c

1900

__folio_remove_rmap(folio, page, nr_pages, vma, PGTABLE_LEVEL_PTE);

mm/rmap.c

1913

void folio_remove_rmap_pmd(struct folio *folio, struct page *page,

mm/rmap.c

1917

__folio_remove_rmap(folio, page, HPAGE_PMD_NR, vma, PGTABLE_LEVEL_PMD);

mm/rmap.c

1933

void folio_remove_rmap_pud(struct folio *folio, struct page *page,

mm/rmap.c

1938

__folio_remove_rmap(folio, page, HPAGE_PUD_NR, vma, PGTABLE_LEVEL_PUD);

mm/rmap.c

1944

static inline unsigned int folio_unmap_pte_batch(struct folio *folio,

mm/rmap.c

1954

if (!folio_test_large(folio))

mm/rmap.c

1962

if (folio_test_anon(folio) && folio_test_swapbacked(folio))

mm/rmap.c

1977

return folio_pte_batch_flags(folio, vma, pvmw->pte, &pte, max_nr,

mm/rmap.c

1984

static bool try_to_unmap_one(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

1988

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, address, 0);

mm/rmap.c

2019

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2066

mlock_vma_folio(folio, vma);

mm/rmap.c

2071

if (folio_test_lazyfree(folio)) {

mm/rmap.c

2072

if (unmap_huge_pmd_locked(vma, pvmw.address, pvmw.pmd, folio))

mm/rmap.c

2096

VM_BUG_ON_FOLIO(!pvmw.pte, folio);

mm/rmap.c

2109

VM_WARN_ON_FOLIO(folio_test_hugetlb(folio), folio);

mm/rmap.c

2112

subpage = folio_page(folio, pfn - folio_pfn(folio));

mm/rmap.c

2114

anon_exclusive = folio_test_anon(folio) &&

mm/rmap.c

2117

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2118

bool anon = folio_test_anon(folio);

mm/rmap.c

2167

folio_mark_dirty(folio);

mm/rmap.c

2169

nr_pages = folio_unmap_pte_batch(folio, &pvmw, flags, pteval);

mm/rmap.c

2188

folio_mark_dirty(folio);

mm/rmap.c

2205

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2206

hugetlb_count_sub(folio_nr_pages(folio), mm);

mm/rmap.c

2210

dec_mm_counter(mm, mm_counter(folio));

mm/rmap.c

2225

dec_mm_counter(mm, mm_counter(folio));

mm/rmap.c

2226

} else if (folio_test_anon(folio)) {

mm/rmap.c

2233

if (unlikely(folio_test_swapbacked(folio) !=

mm/rmap.c

2234

folio_test_swapcache(folio))) {

mm/rmap.c

2240

if (!folio_test_swapbacked(folio)) {

mm/rmap.c

2250

ref_count = folio_ref_count(folio);

mm/rmap.c

2251

map_count = folio_mapcount(folio);

mm/rmap.c

2259

if (folio_test_dirty(folio) && !(vma->vm_flags & VM_DROPPABLE)) {

mm/rmap.c

2265

folio_set_swapbacked(folio);

mm/rmap.c

2284

if (folio_dup_swap(folio, subpage) < 0) {

mm/rmap.c

2295

folio_put_swap(folio, subpage);

mm/rmap.c

2302

folio_try_share_anon_rmap_pte(folio, subpage)) {

mm/rmap.c

2303

folio_put_swap(folio, subpage);

mm/rmap.c

2342

add_mm_counter(mm, mm_counter_file(folio), -nr_pages);

mm/rmap.c

2345

if (unlikely(folio_test_hugetlb(folio))) {

mm/rmap.c

2346

hugetlb_remove_rmap(folio);

mm/rmap.c

2348

folio_remove_rmap_ptes(folio, subpage, nr_pages, vma);

mm/rmap.c

2352

folio_put_refs(folio, nr_pages);

mm/rmap.c

2358

if (nr_pages == folio_nr_pages(folio))

mm/rmap.c

2378

static int folio_not_mapped(struct folio *folio)

mm/rmap.c

2380

return !folio_mapped(folio);

mm/rmap.c

2394

void try_to_unmap(struct folio *folio, enum ttu_flags flags)

mm/rmap.c

2404

rmap_walk_locked(folio, &rwc);

mm/rmap.c

2406

rmap_walk(folio, &rwc);

mm/rmap.c

2415

static bool try_to_migrate_one(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

2419

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, address, 0);

mm/rmap.c

2448

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2487

subpage = folio_page(folio, pfn - folio_pfn(folio));

mm/rmap.c

2489

VM_BUG_ON_FOLIO(folio_test_hugetlb(folio) ||

mm/rmap.c

2490

!folio_test_pmd_mappable(folio), folio);

mm/rmap.c

2502

VM_BUG_ON_FOLIO(!pvmw.pte, folio);

mm/rmap.c

2515

VM_WARN_ON_FOLIO(folio_test_hugetlb(folio), folio);

mm/rmap.c

2518

subpage = folio_page(folio, pfn - folio_pfn(folio));

mm/rmap.c

2520

anon_exclusive = folio_test_anon(folio) &&

mm/rmap.c

2523

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2524

bool anon = folio_test_anon(folio);

mm/rmap.c

2573

folio_mark_dirty(folio);

mm/rmap.c

2594

folio_mark_dirty(folio);

mm/rmap.c

2604

VM_WARN_ON_FOLIO(writable && folio_test_anon(folio) &&

mm/rmap.c

2605

!anon_exclusive, folio);

mm/rmap.c

2611

VM_WARN_ON_FOLIO(folio_is_device_private(folio), folio);

mm/rmap.c

2614

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2615

hugetlb_count_sub(folio_nr_pages(folio), mm);

mm/rmap.c

2619

dec_mm_counter(mm, mm_counter(folio));

mm/rmap.c

2634

dec_mm_counter(mm, mm_counter(folio));

mm/rmap.c

2645

if (folio_test_hugetlb(folio))

mm/rmap.c

2656

if (folio_test_hugetlb(folio)) {

mm/rmap.c

2658

hugetlb_try_share_anon_rmap(folio)) {

mm/rmap.c

2666

folio_try_share_anon_rmap_pte(folio, subpage)) {

mm/rmap.c

2704

if (folio_test_hugetlb(folio))

mm/rmap.c

2710

folio_order(folio));

mm/rmap.c

2717

if (unlikely(folio_test_hugetlb(folio)))

mm/rmap.c

2718

hugetlb_remove_rmap(folio);

mm/rmap.c

2720

folio_remove_rmap_pte(folio, subpage, vma);

mm/rmap.c

2723

folio_put(folio);

mm/rmap.c

2739

void try_to_migrate(struct folio *folio, enum ttu_flags flags)

mm/rmap.c

2756

if (folio_is_zone_device(folio) &&

mm/rmap.c

2757

(!folio_is_device_private(folio) && !folio_is_device_coherent(folio)))

mm/rmap.c

2768

if (!folio_test_ksm(folio) && folio_test_anon(folio))

mm/rmap.c

2772

rmap_walk_locked(folio, &rwc);

mm/rmap.c

2774

rmap_walk(folio, &rwc);

mm/rmap.c

2817

void *owner, struct folio **foliop)

mm/rmap.c

2820

struct folio *folio, *fw_folio;

mm/rmap.c

2846

folio = page_folio(page);

mm/rmap.c

2848

if (!folio_test_anon(folio) || folio_test_hugetlb(folio)) {

mm/rmap.c

2849

folio_put(folio);

mm/rmap.c

2853

ret = folio_lock_killable(folio);

mm/rmap.c

2855

folio_put(folio);

mm/rmap.c

2875

if (fw_folio != folio || fw.page != page ||

mm/rmap.c

2880

folio_unlock(folio);

mm/rmap.c

2881

folio_put(folio);

mm/rmap.c

2891

folio_mark_dirty(folio);

mm/rmap.c

2907

*foliop = folio;

mm/rmap.c

2922

static struct anon_vma *rmap_walk_anon_lock(const struct folio *folio,

mm/rmap.c

2928

return rwc->anon_lock(folio, rwc);

mm/rmap.c

2936

anon_vma = folio_anon_vma(folio);

mm/rmap.c

2964

static void rmap_walk_anon(struct folio *folio,

mm/rmap.c

2975

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/rmap.c

2978

anon_vma = folio_anon_vma(folio);

mm/rmap.c

2980

VM_BUG_ON_FOLIO(!anon_vma, folio);

mm/rmap.c

2982

anon_vma = rmap_walk_anon_lock(folio, rwc);

mm/rmap.c

2987

pgoff_start = folio_pgoff(folio);

mm/rmap.c

2988

pgoff_end = pgoff_start + folio_nr_pages(folio) - 1;

mm/rmap.c

2993

folio_nr_pages(folio));

mm/rmap.c

3001

if (!rwc->rmap_one(folio, vma, address, rwc->arg))

mm/rmap.c

3003

if (rwc->done && rwc->done(folio))

mm/rmap.c

3031

static void __rmap_walk_file(struct folio *folio, struct address_space *mapping,

mm/rmap.c

3038

VM_WARN_ON_FOLIO(folio && mapping != folio_mapping(folio), folio);

mm/rmap.c

3039

VM_WARN_ON_FOLIO(folio && pgoff_start != folio_pgoff(folio), folio);

mm/rmap.c

3040

VM_WARN_ON_FOLIO(folio && nr_pages != folio_nr_pages(folio), folio);

mm/rmap.c

3064

if (!rwc->rmap_one(folio, vma, address, rwc->arg))

mm/rmap.c

3066

if (rwc->done && rwc->done(folio))

mm/rmap.c

3083

static void rmap_walk_file(struct folio *folio,

mm/rmap.c

3092

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/rmap.c

3094

if (!folio->mapping)

mm/rmap.c

3097

__rmap_walk_file(folio, folio->mapping, folio->index,

mm/rmap.c

3098

folio_nr_pages(folio), rwc, locked);

mm/rmap.c

3101

void rmap_walk(struct folio *folio, struct rmap_walk_control *rwc)

mm/rmap.c

3103

if (unlikely(folio_test_ksm(folio)))

mm/rmap.c

3104

rmap_walk_ksm(folio, rwc);

mm/rmap.c

3105

else if (folio_test_anon(folio))

mm/rmap.c

3106

rmap_walk_anon(folio, rwc, false);

mm/rmap.c

3108

rmap_walk_file(folio, rwc, false);

mm/rmap.c

3112

void rmap_walk_locked(struct folio *folio, struct rmap_walk_control *rwc)

mm/rmap.c

3115

VM_BUG_ON_FOLIO(folio_test_ksm(folio), folio);

mm/rmap.c

3116

if (folio_test_anon(folio))

mm/rmap.c

3117

rmap_walk_anon(folio, rwc, true);

mm/rmap.c

3119

rmap_walk_file(folio, rwc, true);

mm/rmap.c

3128

void hugetlb_add_anon_rmap(struct folio *folio, struct vm_area_struct *vma,

mm/rmap.c

3131

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

mm/rmap.c

3132

VM_WARN_ON_FOLIO(!folio_test_anon(folio), folio);

mm/rmap.c

3134

atomic_inc(&folio->_entire_mapcount);

mm/rmap.c

3135

atomic_inc(&folio->_large_mapcount);

mm/rmap.c

3137

SetPageAnonExclusive(&folio->page);

mm/rmap.c

3138

VM_WARN_ON_FOLIO(folio_entire_mapcount(folio) > 1 &&

mm/rmap.c

3139

PageAnonExclusive(&folio->page), folio);

mm/rmap.c

3142

void hugetlb_add_new_anon_rmap(struct folio *folio,

mm/rmap.c

3145

VM_WARN_ON_FOLIO(!folio_test_hugetlb(folio), folio);

mm/rmap.c

3149

atomic_set(&folio->_entire_mapcount, 0);

mm/rmap.c

3150

atomic_set(&folio->_large_mapcount, 0);

mm/rmap.c

3151

folio_clear_hugetlb_restore_reserve(folio);

mm/rmap.c

3152

__folio_set_anon(folio, vma, address, true);

mm/rmap.c

3153

SetPageAnonExclusive(&folio->page);

mm/rmap.c

587

struct anon_vma *folio_get_anon_vma(const struct folio *folio)

mm/rmap.c

592

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/rmap.c

595

anon_mapping = (unsigned long)READ_ONCE(folio->mapping);

mm/rmap.c

598

if (!folio_mapped(folio))

mm/rmap.c

614

if (!folio_mapped(folio)) {

mm/rmap.c

633

struct anon_vma *folio_lock_anon_vma_read(const struct folio *folio,

mm/rmap.c

640

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/rmap.c

643

anon_mapping = (unsigned long)READ_ONCE(folio->mapping);

mm/rmap.c

646

if (!folio_mapped(folio))

mm/rmap.c

657

if (!folio_mapped(folio)) {

mm/rmap.c

676

if (!folio_mapped(folio)) {

mm/rmap.c

856

unsigned long page_address_in_vma(const struct folio *folio,

mm/rmap.c

859

if (folio_test_anon(folio)) {

mm/rmap.c

860

struct anon_vma *anon_vma = folio_anon_vma(folio);

mm/rmap.c

870

} else if (vma->vm_file->f_mapping != folio->mapping) {

mm/rmap.c

875

return vma_address(vma, page_pgoff(folio, page), 1);

mm/rmap.c

917

static bool folio_referenced_one(struct folio *folio,

mm/rmap.c

921

DEFINE_FOLIO_VMA_WALK(pvmw, folio, vma, address, 0);

mm/rmap.c

948

mlock_vma_folio(folio, vma);

mm/rmap.c

961

folio_test_anon(folio) && folio_test_swapbacked(folio) &&

mm/rmap.c

962

!folio_maybe_mapped_shared(folio)) {

mm/rmap.c

968

if (pvmw.pte && folio_test_large(folio)) {

mm/rmap.c

973

nr = folio_pte_batch(folio, pvmw.pte, pteval, max_nr);

mm/secretmem.c

103

vmf->page = folio_file_page(folio, vmf->pgoff);

mm/secretmem.c

147

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/secretmem.c

152

static void secretmem_free_folio(struct folio *folio)

mm/secretmem.c

154

set_direct_map_default_noflush(folio_page(folio, 0));

mm/secretmem.c

155

folio_zero_segment(folio, 0, folio_size(folio));

mm/secretmem.c

57

struct folio *folio;

mm/secretmem.c

67

folio = filemap_lock_folio(mapping, offset);

mm/secretmem.c

68

if (IS_ERR(folio)) {

mm/secretmem.c

69

folio = folio_alloc(gfp | __GFP_ZERO, 0);

mm/secretmem.c

70

if (!folio) {

mm/secretmem.c

75

err = set_direct_map_invalid_noflush(folio_page(folio, 0));

mm/secretmem.c

77

folio_put(folio);

mm/secretmem.c

82

__folio_mark_uptodate(folio);

mm/secretmem.c

83

err = filemap_add_folio(mapping, folio, offset, gfp);

mm/secretmem.c

90

set_direct_map_default_noflush(folio_page(folio, 0));

mm/secretmem.c

91

folio_put(folio);

mm/secretmem.c

99

addr = (unsigned long)folio_address(folio);

mm/shmem.c

1011

struct folio *folio;

mm/shmem.c

1016

xas_for_each(&xas, folio, max) {

mm/shmem.c

1017

if (xas_retry(&xas, folio))

mm/shmem.c

1019

if (xa_is_value(folio))

mm/shmem.c

1086

static struct folio *shmem_get_partial_folio(struct inode *inode, pgoff_t index)

mm/shmem.c

1088

struct folio *folio;

mm/shmem.c

1094

folio = filemap_get_entry(inode->i_mapping, index);

mm/shmem.c

1095

if (!folio)

mm/shmem.c

1096

return folio;

mm/shmem.c

1097

if (!xa_is_value(folio)) {

mm/shmem.c

1098

folio_lock(folio);

mm/shmem.c

1099

if (folio->mapping == inode->i_mapping)

mm/shmem.c

1100

return folio;

mm/shmem.c

1102

folio_unlock(folio);

mm/shmem.c

1103

folio_put(folio);

mm/shmem.c

1109

folio = NULL;

mm/shmem.c

1110

shmem_get_folio(inode, index, 0, &folio, SGP_READ);

mm/shmem.c

1111

return folio;

mm/shmem.c

1127

struct folio *folio;

mm/shmem.c

1144

folio = fbatch.folios[i];

mm/shmem.c

1146

if (xa_is_value(folio)) {

mm/shmem.c

1150

end - 1, folio);

mm/shmem.c

1154

if (!unfalloc || !folio_test_uptodate(folio))

mm/shmem.c

1155

truncate_inode_folio(mapping, folio);

mm/shmem.c

1156

folio_unlock(folio);

mm/shmem.c

1173

folio = shmem_get_partial_folio(inode, lstart >> PAGE_SHIFT);

mm/shmem.c

1174

if (folio) {

mm/shmem.c

1175

same_folio = lend < folio_next_pos(folio);

mm/shmem.c

1176

folio_mark_dirty(folio);

mm/shmem.c

1177

if (!truncate_inode_partial_folio(folio, lstart, lend)) {

mm/shmem.c

1178

start = folio_next_index(folio);

mm/shmem.c

1180

end = folio->index;

mm/shmem.c

1182

folio_unlock(folio);

mm/shmem.c

1183

folio_put(folio);

mm/shmem.c

1184

folio = NULL;

mm/shmem.c

1188

folio = shmem_get_partial_folio(inode, lend >> PAGE_SHIFT);

mm/shmem.c

1189

if (folio) {

mm/shmem.c

1190

folio_mark_dirty(folio);

mm/shmem.c

1191

if (!truncate_inode_partial_folio(folio, lstart, lend))

mm/shmem.c

1192

end = folio->index;

mm/shmem.c

1193

folio_unlock(folio);

mm/shmem.c

1194

folio_put(folio);

mm/shmem.c

1213

folio = fbatch.folios[i];

mm/shmem.c

1215

if (xa_is_value(folio)) {

mm/shmem.c

1222

end - 1, folio);

mm/shmem.c

1227

radix_to_swp_entry(folio));

mm/shmem.c

1246

folio_lock(folio);

mm/shmem.c

1248

if (!unfalloc || !folio_test_uptodate(folio)) {

mm/shmem.c

1249

if (folio_mapping(folio) != mapping) {

mm/shmem.c

1251

folio_unlock(folio);

mm/shmem.c

1255

VM_BUG_ON_FOLIO(folio_test_writeback(folio),

mm/shmem.c

1256

folio);

mm/shmem.c

1258

if (!folio_test_large(folio)) {

mm/shmem.c

1259

truncate_inode_folio(mapping, folio);

mm/shmem.c

1260

} else if (truncate_inode_partial_folio(folio, lstart, lend)) {

mm/shmem.c

1269

if (!folio_test_large(folio)) {

mm/shmem.c

1270

folio_unlock(folio);

mm/shmem.c

1276

folio_unlock(folio);

mm/shmem.c

1454

struct folio *folio;

mm/shmem.c

1458

xas_for_each(&xas, folio, ULONG_MAX) {

mm/shmem.c

1459

if (xas_retry(&xas, folio))

mm/shmem.c

1462

if (!xa_is_value(folio))

mm/shmem.c

1465

entry = radix_to_swp_entry(folio);

mm/shmem.c

1474

if (!folio_batch_add(fbatch, folio))

mm/shmem.c

1500

struct folio *folio = fbatch->folios[i];

mm/shmem.c

1502

error = shmem_swapin_folio(inode, indices[i], &folio, SGP_CACHE,

mm/shmem.c

1505

folio_unlock(folio);

mm/shmem.c

1506

folio_put(folio);

mm/shmem.c

1601

int shmem_writeout(struct folio *folio, struct swap_iocb **plug,

mm/shmem.c

1604

struct address_space *mapping = folio->mapping;

mm/shmem.c

161

struct folio **foliop, enum sgp_type sgp, gfp_t gfp,

mm/shmem.c

1626

if (folio_test_large(folio)) {

mm/shmem.c

1629

if ((index > folio->index && index < folio_next_index(folio)) ||

mm/shmem.c

1638

order = folio_order(folio);

mm/shmem.c

1640

folio_test_set_dirty(folio);

mm/shmem.c

1641

if (split_folio_to_list(folio, folio_list))

mm/shmem.c

1646

count_memcg_folio_events(folio, THP_SWPOUT_FALLBACK, 1);

mm/shmem.c

1652

folio_clear_dirty(folio);

mm/shmem.c

1655

index = folio->index;

mm/shmem.c

1656

nr_pages = folio_nr_pages(folio);

mm/shmem.c

1669

if (!folio_test_uptodate(folio)) {

mm/shmem.c

1685

folio_zero_range(folio, 0, folio_size(folio));

mm/shmem.c

1686

flush_dcache_folio(folio);

mm/shmem.c

1687

folio_mark_uptodate(folio);

mm/shmem.c

1690

if (!folio_alloc_swap(folio)) {

mm/shmem.c

1709

folio_dup_swap(folio, NULL);

mm/shmem.c

1710

shmem_delete_from_page_cache(folio, swp_to_radix_entry(folio->swap));

mm/shmem.c

1712

BUG_ON(folio_mapped(folio));

mm/shmem.c

1713

error = swap_writeout(folio, plug);

mm/shmem.c

1724

error = shmem_add_to_page_cache(folio, mapping, index,

mm/shmem.c

1725

swp_to_radix_entry(folio->swap),

mm/shmem.c

1730

folio_put_swap(folio, NULL);

mm/shmem.c

1740

swap_cache_del_folio(folio);

mm/shmem.c

1746

folio_mark_dirty(folio);

mm/shmem.c

1788

static struct folio *shmem_swapin_cluster(swp_entry_t swap, gfp_t gfp,

mm/shmem.c

1793

struct folio *folio;

mm/shmem.c

1796

folio = swap_cluster_readahead(swap, gfp, mpol, ilx);

mm/shmem.c

1799

return folio;

mm/shmem.c

1909

static struct folio *shmem_alloc_folio(gfp_t gfp, int order,

mm/shmem.c

1914

struct folio *folio;

mm/shmem.c

1917

folio = folio_alloc_mpol(gfp, order, mpol, ilx, numa_node_id());

mm/shmem.c

1920

return folio;

mm/shmem.c

1923

static struct folio *shmem_alloc_and_add_folio(struct vm_fault *vmf,

mm/shmem.c

1930

struct folio *folio = NULL;

mm/shmem.c

1946

folio = shmem_alloc_folio(gfp, order, info, aligned_index);

mm/shmem.c

1947

if (folio) {

mm/shmem.c

1959

folio = shmem_alloc_folio(gfp, 0, info, index);

mm/shmem.c

1961

if (!folio)

mm/shmem.c

1965

__folio_set_locked(folio);

mm/shmem.c

1966

__folio_set_swapbacked(folio);

mm/shmem.c

1969

error = mem_cgroup_charge(folio, fault_mm, gfp);

mm/shmem.c

1979

count_mthp_stat(folio_order(folio), MTHP_STAT_SHMEM_FALLBACK);

mm/shmem.c

1980

count_mthp_stat(folio_order(folio), MTHP_STAT_SHMEM_FALLBACK_CHARGE);

mm/shmem.c

1985

error = shmem_add_to_page_cache(folio, mapping, index, NULL, gfp);

mm/shmem.c

2012

filemap_remove_folio(folio);

mm/shmem.c

2018

folio_add_lru(folio);

mm/shmem.c

2019

return folio;

mm/shmem.c

2022

folio_unlock(folio);

mm/shmem.c

2023

folio_put(folio);

mm/shmem.c

2027

static struct folio *shmem_swap_alloc_folio(struct inode *inode,

mm/shmem.c

2032

struct folio *folio;

mm/shmem.c

2042

folio = swapin_sync(entry, gfp, BIT(order), vmf, mpol, ilx);

mm/shmem.c

2045

if (!IS_ERR(folio))

mm/shmem.c

2046

return folio;

mm/shmem.c

2053

return folio;

mm/shmem.c

2068

static bool shmem_should_replace_folio(struct folio *folio, gfp_t gfp)

mm/shmem.c

2070

return folio_zonenum(folio) > gfp_zone(gfp);

mm/shmem.c

2073

static int shmem_replace_folio(struct folio **foliop, gfp_t gfp,

mm/shmem.c

2078

struct folio *new, *old = *foliop;

mm/shmem.c

2134

struct folio *folio, swp_entry_t swap)

mm/shmem.c

2148

nr_pages = folio_nr_pages(folio);

mm/shmem.c

2149

folio_wait_writeback(folio);

mm/shmem.c

2150

folio_put_swap(folio, NULL);

mm/shmem.c

2151

swap_cache_del_folio(folio);

mm/shmem.c

2239

struct folio **foliop, enum sgp_type sgp,

mm/shmem.c

2250

struct folio *folio = NULL;

mm/shmem.c

2282

folio = swap_cache_get_folio(swap);

mm/shmem.c

2283

if (!folio) {

mm/shmem.c

2286

folio = shmem_swap_alloc_folio(inode, vmf, index,

mm/shmem.c

2290

folio = shmem_swapin_cluster(swap, gfp, info, index);

mm/shmem.c

2292

if (IS_ERR_OR_NULL(folio)) {

mm/shmem.c

2293

if (IS_ERR(folio))

mm/shmem.c

2294

error = PTR_ERR(folio);

mm/shmem.c

2297

folio = NULL;

mm/shmem.c

2306

swap_update_readahead(folio, NULL, 0);

mm/shmem.c

2309

if (order > folio_order(folio)) {

mm/shmem.c

2333

nr_pages = folio_nr_pages(folio);

mm/shmem.c

2346

folio_lock(folio);

mm/shmem.c

2347

if (!folio_matches_swap_entry(folio, swap) ||

mm/shmem.c

2352

if (!folio_test_uptodate(folio)) {

mm/shmem.c

2356

folio_wait_writeback(folio);

mm/shmem.c

2362

arch_swap_restore(folio_swap(swap, folio), folio);

mm/shmem.c

2364

if (shmem_should_replace_folio(folio, gfp)) {

mm/shmem.c

2365

error = shmem_replace_folio(&folio, gfp, info, index, vma);

mm/shmem.c

2370

error = shmem_add_to_page_cache(folio, mapping, index,

mm/shmem.c

2378

folio_mark_accessed(folio);

mm/shmem.c

2380

folio_put_swap(folio, NULL);

mm/shmem.c

2381

swap_cache_del_folio(folio);

mm/shmem.c

2382

folio_mark_dirty(folio);

mm/shmem.c

2385

*foliop = folio;

mm/shmem.c

2391

shmem_set_folio_swapin_error(inode, index, folio, swap);

mm/shmem.c

2393

if (folio)

mm/shmem.c

2394

folio_unlock(folio);

mm/shmem.c

2396

if (folio)

mm/shmem.c

2397

folio_put(folio);

mm/shmem.c

2413

loff_t write_end, struct folio **foliop, enum sgp_type sgp,

mm/shmem.c

2418

struct folio *folio;

mm/shmem.c

2436

folio = filemap_get_entry(inode->i_mapping, index);

mm/shmem.c

2437

if (folio && vma && userfaultfd_minor(vma)) {

mm/shmem.c

2438

if (!xa_is_value(folio))

mm/shmem.c

2439

folio_put(folio);

mm/shmem.c

2444

if (xa_is_value(folio)) {

mm/shmem.c

2445

error = shmem_swapin_folio(inode, index, &folio,

mm/shmem.c

2450

*foliop = folio;

mm/shmem.c

2454

if (folio) {

mm/shmem.c

2455

folio_lock(folio);

mm/shmem.c

2458

if (unlikely(folio->mapping != inode->i_mapping)) {

mm/shmem.c

2459

folio_unlock(folio);

mm/shmem.c

2460

folio_put(folio);

mm/shmem.c

2464

folio_mark_accessed(folio);

mm/shmem.c

2465

if (folio_test_uptodate(folio))

mm/shmem.c

2470

folio_unlock(folio);

mm/shmem.c

2471

folio_put(folio);

mm/shmem.c

2500

folio = shmem_alloc_and_add_folio(vmf, huge_gfp,

mm/shmem.c

2502

if (!IS_ERR(folio)) {

mm/shmem.c

2503

if (folio_test_pmd_mappable(folio))

mm/shmem.c

2505

count_mthp_stat(folio_order(folio), MTHP_STAT_SHMEM_ALLOC);

mm/shmem.c

2508

if (PTR_ERR(folio) == -EEXIST)

mm/shmem.c

2512

folio = shmem_alloc_and_add_folio(vmf, gfp, inode, index, fault_mm, 0);

mm/shmem.c

2513

if (IS_ERR(folio)) {

mm/shmem.c

2514

error = PTR_ERR(folio);

mm/shmem.c

2517

folio = NULL;

mm/shmem.c

2523

if (folio_test_large(folio) &&

mm/shmem.c

2525

folio_next_index(folio)) {

mm/shmem.c

2546

folio_set_referenced(folio);

mm/shmem.c

2558

if (sgp != SGP_WRITE && !folio_test_uptodate(folio)) {

mm/shmem.c

2559

long i, n = folio_nr_pages(folio);

mm/shmem.c

2562

clear_highpage(folio_page(folio, i));

mm/shmem.c

2563

flush_dcache_folio(folio);

mm/shmem.c

2564

folio_mark_uptodate(folio);

mm/shmem.c

2574

*foliop = folio;

mm/shmem.c

2582

filemap_remove_folio(folio);

mm/shmem.c

2584

if (folio) {

mm/shmem.c

2585

folio_unlock(folio);

mm/shmem.c

2586

folio_put(folio);

mm/shmem.c

2616

struct folio **foliop, enum sgp_type sgp)

mm/shmem.c

2698

struct folio *folio = NULL;

mm/shmem.c

2713

err = shmem_get_folio_gfp(inode, vmf->pgoff, 0, &folio, SGP_CACHE,

mm/shmem.c

2717

if (folio) {

mm/shmem.c

2718

vmf->page = folio_file_page(folio, vmf->pgoff);

mm/shmem.c

3126

static struct folio *shmem_mfill_folio_alloc(struct vm_area_struct *vma,

mm/shmem.c

3134

struct folio *folio;

mm/shmem.c

3139

folio = shmem_alloc_folio(gfp, 0, info, pgoff);

mm/shmem.c

3140

if (!folio)

mm/shmem.c

3143

if (mem_cgroup_charge(folio, vma->vm_mm, GFP_KERNEL)) {

mm/shmem.c

3144

folio_put(folio);

mm/shmem.c

3148

return folio;

mm/shmem.c

3151

static int shmem_mfill_filemap_add(struct folio *folio,

mm/shmem.c

3161

__folio_set_locked(folio);

mm/shmem.c

3162

__folio_set_swapbacked(folio);

mm/shmem.c

3164

err = shmem_add_to_page_cache(folio, mapping, pgoff, NULL, gfp);

mm/shmem.c

3173

folio_add_lru(folio);

mm/shmem.c

3179

filemap_remove_folio(folio);

mm/shmem.c

3181

folio_unlock(folio);

mm/shmem.c

3185

static void shmem_mfill_filemap_remove(struct folio *folio,

mm/shmem.c

3190

filemap_remove_folio(folio);

mm/shmem.c

3192

folio_unlock(folio);

mm/shmem.c

3195

static struct folio *shmem_get_folio_noalloc(struct inode *inode, pgoff_t pgoff)

mm/shmem.c

3197

struct folio *folio;

mm/shmem.c

3200

err = shmem_get_folio(inode, pgoff, 0, &folio, SGP_NOALLOC);

mm/shmem.c

3204

return folio;

mm/shmem.c

3228

struct folio **foliop, void **fsdata)

mm/shmem.c

3233

struct folio *folio;

mm/shmem.c

3249

ret = shmem_get_folio(inode, index, pos + len, &folio, SGP_WRITE);

mm/shmem.c

3253

if (folio_contain_hwpoisoned_page(folio)) {

mm/shmem.c

3254

folio_unlock(folio);

mm/shmem.c

3255

folio_put(folio);

mm/shmem.c

3259

*foliop = folio;

mm/shmem.c

3266

struct folio *folio, void *fsdata)

mm/shmem.c

3273

if (!folio_test_uptodate(folio)) {

mm/shmem.c

3274

if (copied < folio_size(folio)) {

mm/shmem.c

3275

size_t from = offset_in_folio(folio, pos);

mm/shmem.c

3276

folio_zero_segments(folio, 0, from,

mm/shmem.c

3277

from + copied, folio_size(folio));

mm/shmem.c

3279

folio_mark_uptodate(folio);

mm/shmem.c

3281

folio_mark_dirty(folio);

mm/shmem.c

3282

folio_unlock(folio);

mm/shmem.c

3283

folio_put(folio);

mm/shmem.c

3299

struct folio *folio = NULL;

mm/shmem.c

3310

error = shmem_get_folio(inode, index, 0, &folio, SGP_READ);

mm/shmem.c

3316

if (folio) {

mm/shmem.c

3317

folio_unlock(folio);

mm/shmem.c

3319

page = folio_file_page(folio, index);

mm/shmem.c

3321

folio_put(folio);

mm/shmem.c

3326

if (folio_test_large(folio) &&

mm/shmem.c

3327

folio_test_has_hwpoisoned(folio))

mm/shmem.c

3337

if (folio)

mm/shmem.c

3338

folio_put(folio);

mm/shmem.c

3342

if (folio && likely(!fallback_page_copy))

mm/shmem.c

3343

fsize = folio_size(folio);

mm/shmem.c

3349

if (folio) {

mm/shmem.c

3357

flush_dcache_folio(folio);

mm/shmem.c

3366

folio_mark_accessed(folio);

mm/shmem.c

3372

ret = copy_folio_to_iter(folio, offset, nr, to);

mm/shmem.c

3375

folio_put(folio);

mm/shmem.c

3481

struct folio *folio = NULL;

mm/shmem.c

3501

error = shmem_get_folio(inode, index, 0, &folio, SGP_READ);

mm/shmem.c

3507

if (folio) {

mm/shmem.c

3508

folio_unlock(folio);

mm/shmem.c

3510

page = folio_file_page(folio, index);

mm/shmem.c

3516

if (folio_test_large(folio) &&

mm/shmem.c

3517

folio_test_has_hwpoisoned(folio))

mm/shmem.c

3544

if (folio) {

mm/shmem.c

3552

flush_dcache_folio(folio);

mm/shmem.c

3556

folio_mark_accessed(folio);

mm/shmem.c

3561

n = splice_folio_into_pipe(pipe, folio, *ppos, part);

mm/shmem.c

3562

folio_put(folio);

mm/shmem.c

3563

folio = NULL;

mm/shmem.c

3580

if (folio)

mm/shmem.c

3581

folio_put(folio);

mm/shmem.c

3698

struct folio *folio;

mm/shmem.c

3713

&folio, SGP_FALLOC);

mm/shmem.c

3730

index = folio_next_index(folio);

mm/shmem.c

3739

if (!folio_test_uptodate(folio))

mm/shmem.c

3750

folio_mark_dirty(folio);

mm/shmem.c

3751

folio_unlock(folio);

mm/shmem.c

3752

folio_put(folio);

mm/shmem.c

4032

struct folio *folio;

mm/shmem.c

4065

error = shmem_get_folio(inode, 0, 0, &folio, SGP_WRITE);

mm/shmem.c

4069

memcpy(folio_address(folio), symname, len);

mm/shmem.c

4070

folio_mark_uptodate(folio);

mm/shmem.c

4071

folio_mark_dirty(folio);

mm/shmem.c

4072

folio_unlock(folio);

mm/shmem.c

4073

folio_put(folio);

mm/shmem.c

4097

struct folio *folio = NULL;

mm/shmem.c

4101

folio = filemap_get_folio(inode->i_mapping, 0);

mm/shmem.c

4102

if (IS_ERR(folio))

mm/shmem.c

4104

if (PageHWPoison(folio_page(folio, 0)) ||

mm/shmem.c

4105

!folio_test_uptodate(folio)) {

mm/shmem.c

4106

folio_put(folio);

mm/shmem.c

4110

error = shmem_get_folio(inode, 0, 0, &folio, SGP_READ);

mm/shmem.c

4113

if (!folio)

mm/shmem.c

4115

if (PageHWPoison(folio_page(folio, 0))) {

mm/shmem.c

4116

folio_unlock(folio);

mm/shmem.c

4117

folio_put(folio);

mm/shmem.c

4120

folio_unlock(folio);

mm/shmem.c

4122

set_delayed_call(done, shmem_put_link, folio);

mm/shmem.c

4123

return folio_address(folio);

mm/shmem.c

5131

struct folio *folio)

mm/shmem.c

5932

struct folio *shmem_read_folio_gfp(struct address_space *mapping,

mm/shmem.c

5937

struct folio *folio;

mm/shmem.c

5941

&folio, SGP_CACHE, gfp, NULL, NULL);

mm/shmem.c

5945

folio_unlock(folio);

mm/shmem.c

5946

return folio;

mm/shmem.c

5959

struct folio *folio = shmem_read_folio_gfp(mapping, index, gfp);

mm/shmem.c

5962

if (IS_ERR(folio))

mm/shmem.c

5963

return &folio->page;

mm/shmem.c

5965

page = folio_file_page(folio, index);

mm/shmem.c

5967

folio_put(folio);

mm/shmem.c

733

struct folio *folio;

mm/shmem.c

773

folio = filemap_get_entry(inode->i_mapping, i_size / PAGE_SIZE);

mm/shmem.c

774

if (!folio || xa_is_value(folio))

mm/shmem.c

778

if (!folio_test_large(folio)) {

mm/shmem.c

779

folio_put(folio);

mm/shmem.c

784

next = folio_next_index(folio);

mm/shmem.c

786

if (end <= folio->index || end >= next) {

mm/shmem.c

787

folio_put(folio);

mm/shmem.c

798

if (!folio_trylock(folio)) {

mm/shmem.c

799

folio_put(folio);

mm/shmem.c

803

ret = split_folio(folio);

mm/shmem.c

804

folio_unlock(folio);

mm/shmem.c

805

folio_put(folio);

mm/shmem.c

880

static void shmem_update_stats(struct folio *folio, int nr_pages)

mm/shmem.c

882

if (folio_test_pmd_mappable(folio))

mm/shmem.c

883

lruvec_stat_mod_folio(folio, NR_SHMEM_THPS, nr_pages);

mm/shmem.c

884

lruvec_stat_mod_folio(folio, NR_FILE_PAGES, nr_pages);

mm/shmem.c

885

lruvec_stat_mod_folio(folio, NR_SHMEM, nr_pages);

mm/shmem.c

891

int shmem_add_to_page_cache(struct folio *folio,

mm/shmem.c

895

XA_STATE_ORDER(xas, &mapping->i_pages, index, folio_order(folio));

mm/shmem.c

896

unsigned long nr = folio_nr_pages(folio);

mm/shmem.c

900

VM_BUG_ON_FOLIO(index != round_down(index, nr), folio);

mm/shmem.c

901

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/shmem.c

902

VM_BUG_ON_FOLIO(!folio_test_swapbacked(folio), folio);

mm/shmem.c

904

folio_ref_add(folio, nr);

mm/shmem.c

905

folio->mapping = mapping;

mm/shmem.c

906

folio->index = index;

mm/shmem.c

909

folio_throttle_swaprate(folio, gfp);

mm/shmem.c

932

xas_store(&xas, folio);

mm/shmem.c

935

shmem_update_stats(folio, nr);

mm/shmem.c

942

folio->mapping = NULL;

mm/shmem.c

943

folio_ref_sub(folio, nr);

mm/shmem.c

953

static void shmem_delete_from_page_cache(struct folio *folio, void *radswap)

mm/shmem.c

955

struct address_space *mapping = folio->mapping;

mm/shmem.c

956

long nr = folio_nr_pages(folio);

mm/shmem.c

960

error = shmem_replace_entry(mapping, folio->index, folio, radswap);

mm/shmem.c

961

folio->mapping = NULL;

mm/shmem.c

963

shmem_update_stats(folio, -nr);

mm/shmem.c

965

folio_put_refs(folio, nr);

mm/slab.h

147

const struct slab *: (const struct folio *)s, \

mm/slab.h

148

struct slab *: (struct folio *)s))

mm/swap.c

100

free_zone_device_folio(folio);

mm/swap.c

1009

struct folio *folio = folios->folios[i];

mm/swap.c

1013

if (!folio)

mm/swap.c

1016

if (is_huge_zero_folio(folio))

mm/swap.c

1019

if (folio_is_zone_device(folio)) {

mm/swap.c

1024

if (folio_ref_sub_and_test(folio, nr_refs))

mm/swap.c

1025

free_zone_device_folio(folio);

mm/swap.c

1029

if (!folio_ref_sub_and_test(folio, nr_refs))

mm/swap.c

1033

if (folio_test_hugetlb(folio)) {

mm/swap.c

1038

free_huge_folio(folio);

mm/swap.c

104

if (folio_test_hugetlb(folio)) {

mm/swap.c

1041

folio_unqueue_deferred_split(folio);

mm/swap.c

1042

__page_cache_release(folio, &lruvec, &flags);

mm/swap.c

1045

folios->folios[j] = folio;

mm/swap.c

105

free_huge_folio(folio);

mm/swap.c

1083

struct folio *folio = page_folio(encoded_page_ptr(encoded[i]));

mm/swap.c

109

page_cache_release(folio);

mm/swap.c

1091

if (folio_batch_add(&fbatch, folio) > 0)

mm/swap.c

110

folio_unqueue_deferred_split(folio);

mm/swap.c

111

mem_cgroup_uncharge(folio);

mm/swap.c

112

free_frozen_pages(&folio->page, folio_order(folio));

mm/swap.c

1135

struct folio *folio = fbatch->folios[i];

mm/swap.c

1136

if (!xa_is_value(folio))

mm/swap.c

1137

fbatch->folios[j++] = folio;

mm/swap.c

116

typedef void (*move_fn_t)(struct lruvec *lruvec, struct folio *folio);

mm/swap.c

118

static void lru_add(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

120

int was_unevictable = folio_test_clear_unevictable(folio);

mm/swap.c

121

long nr_pages = folio_nr_pages(folio);

mm/swap.c

123

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/swap.c

136

if (folio_evictable(folio)) {

mm/swap.c

140

folio_clear_active(folio);

mm/swap.c

141

folio_set_unevictable(folio);

mm/swap.c

149

folio->mlock_count = 0;

mm/swap.c

154

lruvec_add_folio(lruvec, folio);

mm/swap.c

155

trace_mm_lru_insertion(folio);

mm/swap.c

174

struct folio *folio = fbatch->folios[i];

mm/swap.c

177

if (!is_lru_add && !folio_test_clear_lru(folio))

mm/swap.c

190

if (is_lru_add && folio_ref_freeze(folio, 1)) {

mm/swap.c

191

__folio_clear_active(folio);

mm/swap.c

192

__folio_clear_unevictable(folio);

mm/swap.c

193

folio_unqueue_deferred_split(folio);

mm/swap.c

195

folio_batch_add(&free_fbatch, folio);

mm/swap.c

199

folio_lruvec_relock_irqsave(folio, &lruvec, &flags);

mm/swap.c

200

move_fn(lruvec, folio);

mm/swap.c

202

folio_set_lru(folio);

mm/swap.c

218

struct folio *folio, move_fn_t move_fn, bool disable_irq)

mm/swap.c

222

folio_get(folio);

mm/swap.c

229

if (!folio_batch_add(this_cpu_ptr(fbatch), folio) ||

mm/swap.c

230

!folio_may_be_lru_cached(folio) || lru_cache_disabled())

mm/swap.c

239

#define folio_batch_add_and_move(folio, op) \

mm/swap.c

242

folio, \

mm/swap.c

248

static void lru_move_tail(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

250

if (folio_test_unevictable(folio))

mm/swap.c

253

lruvec_del_folio(lruvec, folio);

mm/swap.c

254

folio_clear_active(folio);

mm/swap.c

255

lruvec_add_folio_tail(lruvec, folio);

mm/swap.c

256

__count_vm_events(PGROTATED, folio_nr_pages(folio));

mm/swap.c

266

void folio_rotate_reclaimable(struct folio *folio)

mm/swap.c

268

if (folio_test_locked(folio) || folio_test_dirty(folio) ||

mm/swap.c

269

folio_test_unevictable(folio) || !folio_test_lru(folio))

mm/swap.c

272

folio_batch_add_and_move(folio, lru_move_tail);

mm/swap.c

333

void lru_note_cost_refault(struct folio *folio)

mm/swap.c

337

lruvec = folio_lruvec_lock_irq(folio);

mm/swap.c

338

lru_note_cost_unlock_irq(lruvec, folio_is_file_lru(folio),

mm/swap.c

339

folio_nr_pages(folio), 0);

mm/swap.c

342

static void lru_activate(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

344

long nr_pages = folio_nr_pages(folio);

mm/swap.c

346

if (folio_test_active(folio) || folio_test_unevictable(folio))

mm/swap.c

350

lruvec_del_folio(lruvec, folio);

mm/swap.c

351

folio_set_active(folio);

mm/swap.c

352

lruvec_add_folio(lruvec, folio);

mm/swap.c

353

trace_mm_lru_activate(folio);

mm/swap.c

368

void folio_activate(struct folio *folio)

mm/swap.c

370

if (folio_test_active(folio) || folio_test_unevictable(folio) ||

mm/swap.c

371

!folio_test_lru(folio))

mm/swap.c

374

folio_batch_add_and_move(folio, lru_activate);

mm/swap.c

382

void folio_activate(struct folio *folio)

mm/swap.c

386

if (!folio_test_clear_lru(folio))

mm/swap.c

389

lruvec = folio_lruvec_lock_irq(folio);

mm/swap.c

390

lru_activate(lruvec, folio);

mm/swap.c

392

folio_set_lru(folio);

mm/swap.c

396

static void __lru_cache_activate_folio(struct folio *folio)

mm/swap.c

415

struct folio *batch_folio = fbatch->folios[i];

mm/swap.c

417

if (batch_folio == folio) {

mm/swap.c

418

folio_set_active(folio);

mm/swap.c

428

static void lru_gen_inc_refs(struct folio *folio)

mm/swap.c

430

unsigned long new_flags, old_flags = READ_ONCE(folio->flags.f);

mm/swap.c

432

if (folio_test_unevictable(folio))

mm/swap.c

436

if (!folio_test_referenced(folio)) {

mm/swap.c

437

set_mask_bits(&folio->flags.f, LRU_REFS_MASK, BIT(PG_referenced));

mm/swap.c

443

if (!folio_test_workingset(folio))

mm/swap.c

444

folio_set_workingset(folio);

mm/swap.c

449

} while (!try_cmpxchg(&folio->flags.f, &old_flags, new_flags));

mm/swap.c

452

static bool lru_gen_clear_refs(struct folio *folio)

mm/swap.c

454

int gen = folio_lru_gen(folio);

mm/swap.c

455

int type = folio_is_file_lru(folio);

mm/swap.c

461

set_mask_bits(&folio->flags.f, LRU_REFS_FLAGS | BIT(PG_workingset), 0);

mm/swap.c

464

seq = READ_ONCE(folio_lruvec(folio)->lrugen.min_seq[type]);

mm/swap.c

472

static void lru_gen_inc_refs(struct folio *folio)

mm/swap.c

476

static bool lru_gen_clear_refs(struct folio *folio)

mm/swap.c

496

void folio_mark_accessed(struct folio *folio)

mm/swap.c

498

if (folio_test_dropbehind(folio))

mm/swap.c

501

lru_gen_inc_refs(folio);

mm/swap.c

505

if (!folio_test_referenced(folio)) {

mm/swap.c

506

folio_set_referenced(folio);

mm/swap.c

507

} else if (folio_test_unevictable(folio)) {

mm/swap.c

513

} else if (!folio_test_active(folio)) {

mm/swap.c

520

if (folio_test_lru(folio))

mm/swap.c

521

folio_activate(folio);

mm/swap.c

523

__lru_cache_activate_folio(folio);

mm/swap.c

524

folio_clear_referenced(folio);

mm/swap.c

525

workingset_activation(folio);

mm/swap.c

527

if (folio_test_idle(folio))

mm/swap.c

528

folio_clear_idle(folio);

mm/swap.c

541

void folio_add_lru(struct folio *folio)

mm/swap.c

543

VM_BUG_ON_FOLIO(folio_test_active(folio) &&

mm/swap.c

544

folio_test_unevictable(folio), folio);

mm/swap.c

545

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/swap.c

554

if (lru_gen_enabled() && !folio_test_unevictable(folio) &&

mm/swap.c

556

if (folio_test_workingset(folio))

mm/swap.c

557

folio_set_active(folio);

mm/swap.c

558

else if (!folio_test_referenced(folio))

mm/swap.c

559

folio_mark_accessed(folio);

mm/swap.c

562

folio_batch_add_and_move(folio, lru_add);

mm/swap.c

574

void folio_add_lru_vma(struct folio *folio, struct vm_area_struct *vma)

mm/swap.c

576

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/swap.c

579

mlock_new_folio(folio);

mm/swap.c

581

folio_add_lru(folio);

mm/swap.c

605

static void lru_deactivate_file(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

607

bool active = folio_test_active(folio) || lru_gen_enabled();

mm/swap.c

608

long nr_pages = folio_nr_pages(folio);

mm/swap.c

610

if (folio_test_unevictable(folio))

mm/swap.c

614

if (folio_mapped(folio))

mm/swap.c

617

lruvec_del_folio(lruvec, folio);

mm/swap.c

618

folio_clear_active(folio);

mm/swap.c

619

folio_clear_referenced(folio);

mm/swap.c

621

if (folio_test_writeback(folio) || folio_test_dirty(folio)) {

mm/swap.c

628

lruvec_add_folio(lruvec, folio);

mm/swap.c

629

folio_set_reclaim(folio);

mm/swap.c

635

lruvec_add_folio_tail(lruvec, folio);

mm/swap.c

646

static void lru_deactivate(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

648

long nr_pages = folio_nr_pages(folio);

mm/swap.c

650

if (folio_test_unevictable(folio) || !(folio_test_active(folio) || lru_gen_enabled()))

mm/swap.c

653

lruvec_del_folio(lruvec, folio);

mm/swap.c

654

folio_clear_active(folio);

mm/swap.c

655

folio_clear_referenced(folio);

mm/swap.c

656

lruvec_add_folio(lruvec, folio);

mm/swap.c

662

static void lru_lazyfree(struct lruvec *lruvec, struct folio *folio)

mm/swap.c

664

long nr_pages = folio_nr_pages(folio);

mm/swap.c

666

if (!folio_test_anon(folio) || !folio_test_swapbacked(folio) ||

mm/swap.c

667

folio_test_swapcache(folio) || folio_test_unevictable(folio))

mm/swap.c

670

lruvec_del_folio(lruvec, folio);

mm/swap.c

671

folio_clear_active(folio);

mm/swap.c

673

lru_gen_clear_refs(folio);

mm/swap.c

675

folio_clear_referenced(folio);

mm/swap.c

681

folio_clear_swapbacked(folio);

mm/swap.c

682

lruvec_add_folio(lruvec, folio);

mm/swap.c

73

static void __page_cache_release(struct folio *folio, struct lruvec **lruvecp,

mm/swap.c

737

void deactivate_file_folio(struct folio *folio)

mm/swap.c

740

if (folio_test_unevictable(folio) || !folio_test_lru(folio))

mm/swap.c

743

if (lru_gen_enabled() && lru_gen_clear_refs(folio))

mm/swap.c

746

folio_batch_add_and_move(folio, lru_deactivate_file);

mm/swap.c

757

void folio_deactivate(struct folio *folio)

mm/swap.c

759

if (folio_test_unevictable(folio) || !folio_test_lru(folio))

mm/swap.c

76

if (folio_test_lru(folio)) {

mm/swap.c

762

if (lru_gen_enabled() ? lru_gen_clear_refs(folio) : !folio_test_active(folio))

mm/swap.c

765

folio_batch_add_and_move(folio, lru_deactivate);

mm/swap.c

77

folio_lruvec_relock_irqsave(folio, lruvecp, flagsp);

mm/swap.c

775

void folio_mark_lazyfree(struct folio *folio)

mm/swap.c

777

if (!folio_test_anon(folio) || !folio_test_swapbacked(folio) ||

mm/swap.c

778

!folio_test_lru(folio) ||

mm/swap.c

779

folio_test_swapcache(folio) || folio_test_unevictable(folio))

mm/swap.c

78

lruvec_del_folio(*lruvecp, folio);

mm/swap.c

782

folio_batch_add_and_move(folio, lru_lazyfree);

mm/swap.c

79

__folio_clear_lru_flags(folio);

mm/swap.c

87

static void page_cache_release(struct folio *folio)

mm/swap.c

92

__page_cache_release(folio, &lruvec, &flags);

mm/swap.c

97

void __folio_put(struct folio *folio)

mm/swap.c

99

if (unlikely(folio_is_zone_device(folio))) {

mm/swap.h

160

const struct folio *folio, bool irq)

mm/swap.h

162

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/swap.h

163

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/swap.h

164

return __swap_cluster_lock(__swap_entry_to_info(folio->swap),

mm/swap.h

165

swp_offset(folio->swap), irq);

mm/swap.h

181

const struct folio *folio)

mm/swap.h

183

return __swap_cluster_get_and_lock(folio, false);

mm/swap.h

196

const struct folio *folio)

mm/swap.h

198

return __swap_cluster_get_and_lock(folio, true);

mm/swap.h

232

int folio_alloc_swap(struct folio *folio);

mm/swap.h

233

int folio_dup_swap(struct folio *folio, struct page *subpage);

mm/swap.h

234

void folio_put_swap(struct folio *folio, struct page *subpage);

mm/swap.h

244

void swap_read_folio(struct folio *folio, struct swap_iocb **plug);

mm/swap.h

252

int swap_writeout(struct folio *folio, struct swap_iocb **swap_plug);

mm/swap.h

253

void __swap_writepage(struct folio *folio, struct swap_iocb **swap_plug);

mm/swap.h

279

static inline bool folio_matches_swap_entry(const struct folio *folio,

mm/swap.h

282

swp_entry_t folio_entry = folio->swap;

mm/swap.h

283

long nr_pages = folio_nr_pages(folio);

mm/swap.h

285

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/swap.h

286

if (!folio_test_swapcache(folio))

mm/swap.h

288

VM_WARN_ON_ONCE_FOLIO(!IS_ALIGNED(folio_entry.val, nr_pages), folio);

mm/swap.h

304

struct folio *swap_cache_get_folio(swp_entry_t entry);

mm/swap.h

306

void swap_cache_del_folio(struct folio *folio);

mm/swap.h

307

struct folio *swap_cache_alloc_folio(swp_entry_t target_entry, gfp_t gfp_mask,

mm/swap.h

312

struct folio *folio, swp_entry_t entry);

mm/swap.h

314

struct folio *folio, swp_entry_t entry, void *shadow);

mm/swap.h

316

struct folio *old, struct folio *new);

mm/swap.h

320

struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,

mm/swap.h

323

struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t flag,

mm/swap.h

325

struct folio *swapin_readahead(swp_entry_t entry, gfp_t flag,

mm/swap.h

327

struct folio *swapin_sync(swp_entry_t entry, gfp_t flag, unsigned long orders,

mm/swap.h

329

void swap_update_readahead(struct folio *folio, struct vm_area_struct *vma,

mm/swap.h

332

static inline unsigned int folio_swap_flags(struct folio *folio)

mm/swap.h

334

return __swap_entry_to_info(folio->swap)->flags;

mm/swap.h

346

struct folio *folio)

mm/swap.h

352

struct folio *folio)

mm/swap.h

370

static inline int folio_alloc_swap(struct folio *folio)

mm/swap.h

375

static inline int folio_dup_swap(struct folio *folio, struct page *page)

mm/swap.h

380

static inline void folio_put_swap(struct folio *folio, struct page *page)

mm/swap.h

384

static inline void swap_read_folio(struct folio *folio, struct swap_iocb **plug)

mm/swap.h

397

static inline bool folio_matches_swap_entry(const struct folio *folio, swp_entry_t entry)

mm/swap.h

406

static inline struct folio *swap_cluster_readahead(swp_entry_t entry,

mm/swap.h

412

static inline struct folio *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,

mm/swap.h

418

static inline struct folio *swapin_sync(

mm/swap.h

425

static inline void swap_update_readahead(struct folio *folio,

mm/swap.h

430

static inline int swap_writeout(struct folio *folio,

mm/swap.h

446

static inline struct folio *swap_cache_get_folio(swp_entry_t entry)

mm/swap.h

456

static inline void swap_cache_del_folio(struct folio *folio)

mm/swap.h

461

struct folio *folio, swp_entry_t entry, void *shadow)

mm/swap.h

466

struct folio *old, struct folio *new)

mm/swap.h

470

static inline unsigned int folio_swap_flags(struct folio *folio)

mm/swap_state.c

204

struct folio *folio, swp_entry_t entry)

mm/swap_state.c

207

unsigned long nr_pages = folio_nr_pages(folio);

mm/swap_state.c

208

unsigned long pfn = folio_pfn(folio);

mm/swap_state.c

211

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/swap_state.c

212

VM_WARN_ON_ONCE_FOLIO(folio_test_swapcache(folio), folio);

mm/swap_state.c

213

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapbacked(folio), folio);

mm/swap_state.c

222

folio_ref_add(folio, nr_pages);

mm/swap_state.c

223

folio_set_swapcache(folio);

mm/swap_state.c

224

folio->swap = entry;

mm/swap_state.c

242

struct folio *folio, swp_entry_t entry)

mm/swap_state.c

244

unsigned long nr_pages = folio_nr_pages(folio);

mm/swap_state.c

246

__swap_cache_do_add_folio(ci, folio, entry);

mm/swap_state.c

247

node_stat_mod_folio(folio, NR_FILE_PAGES, nr_pages);

mm/swap_state.c

248

lruvec_stat_mod_folio(folio, NR_SWAPCACHE, nr_pages);

mm/swap_state.c

252

struct folio *folio,

mm/swap_state.c

259

unsigned long nr_pages = folio_nr_pages(folio);

mm/swap_state.c

262

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/swap_state.c

263

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/swap_state.c

264

VM_WARN_ON_ONCE_FOLIO(folio_test_writeback(folio), folio);

mm/swap_state.c

273

swp_tb_to_folio(old_tb) != folio);

mm/swap_state.c

283

folio->swap.val = 0;

mm/swap_state.c

284

folio_clear_swapcache(folio);

mm/swap_state.c

310

void __swap_cache_del_folio(struct swap_cluster_info *ci, struct folio *folio,

mm/swap_state.c

313

unsigned long nr_pages = folio_nr_pages(folio);

mm/swap_state.c

315

__swap_cache_do_del_folio(ci, folio, entry, shadow);

mm/swap_state.c

316

node_stat_mod_folio(folio, NR_FILE_PAGES, -nr_pages);

mm/swap_state.c

317

lruvec_stat_mod_folio(folio, NR_SWAPCACHE, -nr_pages);

mm/swap_state.c

330

void swap_cache_del_folio(struct folio *folio)

mm/swap_state.c

333

swp_entry_t entry = folio->swap;

mm/swap_state.c

336

__swap_cache_del_folio(ci, folio, entry, NULL);

mm/swap_state.c

339

folio_ref_sub(folio, folio_nr_pages(folio));

mm/swap_state.c

357

struct folio *old, struct folio *new)

mm/swap_state.c

403

static struct folio *__swap_cache_alloc(struct swap_cluster_info *ci,

mm/swap_state.c

410

struct folio *folio;

mm/swap_state.c

434

folio = folio_alloc_mpol(gfp, order, mpol, ilx, numa_node_id());

mm/swap_state.c

437

folio = vma_alloc_folio(gfp, order, vmf->vma, address);

mm/swap_state.c

439

if (unlikely(!folio))

mm/swap_state.c

447

folio_put(folio);

mm/swap_state.c

451

__folio_set_locked(folio);

mm/swap_state.c

452

__folio_set_swapbacked(folio);

mm/swap_state.c

453

__swap_cache_do_add_folio(ci, folio, entry);

mm/swap_state.c

456

if (mem_cgroup_swapin_charge_folio(folio, memcg_id,

mm/swap_state.c

459

__swap_cache_do_del_folio(ci, folio, entry, shadow);

mm/swap_state.c

461

folio_unlock(folio);

mm/swap_state.c

463

folio_put_refs(folio, nr_pages + 1);

mm/swap_state.c

468

if (order > 1 && folio_memcg_alloc_deferred(folio)) {

mm/swap_state.c

470

__swap_cache_do_del_folio(ci, folio, entry, shadow);

mm/swap_state.c

472

folio_unlock(folio);

mm/swap_state.c

474

folio_put_refs(folio, nr_pages + 1);

mm/swap_state.c

479

memcg1_swapin(folio);

mm/swap_state.c

481

workingset_refault(folio, shadow);

mm/swap_state.c

483

node_stat_mod_folio(folio, NR_FILE_PAGES, nr_pages);

mm/swap_state.c

484

lruvec_stat_mod_folio(folio, NR_SWAPCACHE, nr_pages);

mm/swap_state.c

487

folio_add_lru(folio);

mm/swap_state.c

488

return folio;

mm/swap_state.c

508

struct folio *swap_cache_alloc_folio(swp_entry_t targ_entry, gfp_t gfp,

mm/swap_state.c

513

struct folio *ret;

mm/swap_state.c

546

void free_swap_cache(struct folio *folio)

mm/swap_state.c

548

if (folio_test_swapcache(folio) && !folio_mapped(folio) &&

mm/swap_state.c

549

folio_trylock(folio)) {

mm/swap_state.c

550

folio_free_swap(folio);

mm/swap_state.c

551

folio_unlock(folio);

mm/swap_state.c

559

void free_folio_and_swap_cache(struct folio *folio)

mm/swap_state.c

561

free_swap_cache(folio);

mm/swap_state.c

562

if (!is_huge_zero_folio(folio))

mm/swap_state.c

563

folio_put(folio);

mm/swap_state.c

577

struct folio *folio = page_folio(encoded_page_ptr(pages[i]));

mm/swap_state.c

579

free_swap_cache(folio);

mm/swap_state.c

585

if (folio_batch_add(&folios, folio) == 0)

mm/swap_state.c

603

void swap_update_readahead(struct folio *folio, struct vm_area_struct *vma,

mm/swap_state.c

612

if (unlikely(folio_test_large(folio)))

mm/swap_state.c

615

readahead = folio_test_clear_readahead(folio);

mm/swap_state.c

636

static struct folio *swap_cache_read_folio(swp_entry_t entry, gfp_t gfp,

mm/swap_state.c

640

struct folio *folio;

mm/swap_state.c

643

folio = swap_cache_get_folio(entry);

mm/swap_state.c

644

if (folio)

mm/swap_state.c

645

return folio;

mm/swap_state.c

646

folio = swap_cache_alloc_folio(entry, gfp, BIT(0), NULL, mpol, ilx);

mm/swap_state.c

647

} while (PTR_ERR(folio) == -EEXIST);

mm/swap_state.c

649

if (IS_ERR_OR_NULL(folio))

mm/swap_state.c

652

swap_read_folio(folio, plug);

mm/swap_state.c

654

folio_set_readahead(folio);

mm/swap_state.c

658

return folio;

mm/swap_state.c

677

struct folio *swapin_sync(swp_entry_t entry, gfp_t gfp, unsigned long orders,

mm/swap_state.c

680

struct folio *folio;

mm/swap_state.c

683

folio = swap_cache_get_folio(entry);

mm/swap_state.c

684

if (folio)

mm/swap_state.c

685

return folio;

mm/swap_state.c

686

folio = swap_cache_alloc_folio(entry, gfp, orders, vmf, mpol, ilx);

mm/swap_state.c

687

} while (PTR_ERR(folio) == -EEXIST);

mm/swap_state.c

689

if (IS_ERR(folio))

mm/swap_state.c

690

return folio;

mm/swap_state.c

692

swap_read_folio(folio, NULL);

mm/swap_state.c

693

return folio;

mm/swap_state.c

702

struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,

mm/swap_state.c

709

struct folio *folio;

mm/swap_state.c

716

folio = swap_cache_read_folio(entry, gfp_mask, mpol, ilx, plug, false);

mm/swap_state.c

720

return folio;

mm/swap_state.c

802

struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask,

mm/swap_state.c

805

struct folio *folio;

mm/swap_state.c

831

folio = swap_cache_read_folio(ra_entry, gfp_mask, mpol, ilx,

mm/swap_state.c

833

if (!folio)

mm/swap_state.c

835

folio_put(folio);

mm/swap_state.c

87

struct folio *swap_cache_get_folio(swp_entry_t entry)

mm/swap_state.c

899

static struct folio *swap_vma_readahead(swp_entry_t targ_entry, gfp_t gfp_mask,

mm/swap_state.c

90

struct folio *folio;

mm/swap_state.c

904

struct folio *folio;

mm/swap_state.c

942

folio = swap_cache_read_folio(entry, gfp_mask, mpol, ilx,

mm/swap_state.c

946

if (!folio)

mm/swap_state.c

948

folio_put(folio);

mm/swap_state.c

957

folio = swap_cache_read_folio(targ_entry, gfp_mask, mpol, targ_ilx,

mm/swap_state.c

959

return folio;

mm/swap_state.c

97

folio = swp_tb_to_folio(swp_tb);

mm/swap_state.c

974

struct folio *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask,

mm/swap_state.c

979

struct folio *folio;

mm/swap_state.c

98

if (likely(folio_try_get(folio)))

mm/swap_state.c

982

folio = swap_use_vma_readahead() ?

mm/swap_state.c

987

return folio;

mm/swap_state.c

99

return folio;

mm/swap_table.h

129

static inline unsigned long folio_to_swp_tb(struct folio *folio, unsigned char flags)

mm/swap_table.h

131

return pfn_to_swp_tb(folio_pfn(folio), flags);

mm/swap_table.h

178

static inline struct folio *swp_tb_to_folio(unsigned long swp_tb)

mm/swapfile.c

1017

struct folio *folio,

mm/swapfile.c

1029

found = alloc_swap_scan_cluster(si, ci, folio, offset);

mm/swapfile.c

1093

struct folio *folio)

mm/swapfile.c

1096

unsigned int order = likely(folio) ? folio_order(folio) : 0;

mm/swapfile.c

1118

found = alloc_swap_scan_cluster(si, ci, folio, offset);

mm/swapfile.c

1132

found = alloc_swap_scan_list(si, &si->free_clusters, folio, false);

mm/swapfile.c

1138

found = alloc_swap_scan_list(si, &si->nonfull_clusters[order], folio, true);

mm/swapfile.c

1144

found = alloc_swap_scan_list(si, &si->free_clusters, folio, false);

mm/swapfile.c

1160

found = alloc_swap_scan_list(si, &si->frag_clusters[order], folio, false);

mm/swapfile.c

1174

found = alloc_swap_scan_list(si, &si->frag_clusters[o], folio, true);

mm/swapfile.c

1178

found = alloc_swap_scan_list(si, &si->nonfull_clusters[o], folio, true);

mm/swapfile.c

1361

static bool swap_alloc_fast(struct folio *folio)

mm/swapfile.c

1363

unsigned int order = folio_order(folio);

mm/swapfile.c

1381

alloc_swap_scan_cluster(si, ci, folio, offset);

mm/swapfile.c

1387

return folio_test_swapcache(folio);

mm/swapfile.c

1391

static void swap_alloc_slow(struct folio *folio)

mm/swapfile.c

1402

cluster_alloc_swap_entry(si, folio);

mm/swapfile.c

1404

if (folio_test_swapcache(folio))

mm/swapfile.c

1406

if (folio_test_large(folio))

mm/swapfile.c

1734

int folio_alloc_swap(struct folio *folio)

mm/swapfile.c

1736

unsigned int order = folio_order(folio);

mm/swapfile.c

1739

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

1740

VM_BUG_ON_FOLIO(!folio_test_uptodate(folio), folio);

mm/swapfile.c

1762

if (!swap_alloc_fast(folio))

mm/swapfile.c

1763

swap_alloc_slow(folio);

mm/swapfile.c

1766

if (!order && unlikely(!folio_test_swapcache(folio))) {

mm/swapfile.c

1772

if (unlikely(mem_cgroup_try_charge_swap(folio)))

mm/swapfile.c

1773

swap_cache_del_folio(folio);

mm/swapfile.c

1775

if (unlikely(!folio_test_swapcache(folio)))

mm/swapfile.c

1798

int folio_dup_swap(struct folio *folio, struct page *subpage)

mm/swapfile.c

1800

swp_entry_t entry = folio->swap;

mm/swapfile.c

1801

unsigned long nr_pages = folio_nr_pages(folio);

mm/swapfile.c

1803

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

1804

VM_WARN_ON_FOLIO(!folio_test_swapcache(folio), folio);

mm/swapfile.c

1807

entry.val += folio_page_idx(folio, subpage);

mm/swapfile.c

1824

void folio_put_swap(struct folio *folio, struct page *subpage)

mm/swapfile.c

1826

swp_entry_t entry = folio->swap;

mm/swapfile.c

1827

unsigned long nr_pages = folio_nr_pages(folio);

mm/swapfile.c

1830

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

1831

VM_WARN_ON_FOLIO(!folio_test_swapcache(folio), folio);

mm/swapfile.c

1834

entry.val += folio_page_idx(folio, subpage);

mm/swapfile.c

2023

static bool folio_maybe_swapped(struct folio *folio)

mm/swapfile.c

2025

swp_entry_t entry = folio->swap;

mm/swapfile.c

203

struct folio *folio;

mm/swapfile.c

2030

VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

2031

VM_WARN_ON_ONCE_FOLIO(!folio_test_swapcache(folio), folio);

mm/swapfile.c

2035

ci_end = ci_off + folio_nr_pages(folio);

mm/swapfile.c

2052

static bool folio_swapcache_freeable(struct folio *folio)

mm/swapfile.c

2054

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

2056

if (!folio_test_swapcache(folio))

mm/swapfile.c

2058

if (folio_test_writeback(folio))

mm/swapfile.c

208

folio = swap_cache_get_folio(entry);

mm/swapfile.c

209

if (!folio)

mm/swapfile.c

2091

bool folio_free_swap(struct folio *folio)

mm/swapfile.c

2093

if (!folio_swapcache_freeable(folio))

mm/swapfile.c

2095

if (folio_maybe_swapped(folio))

mm/swapfile.c

2098

swap_cache_del_folio(folio);

mm/swapfile.c

2099

folio_set_dirty(folio);

mm/swapfile.c

212

nr_pages = folio_nr_pages(folio);

mm/swapfile.c

221

if (!folio_trylock(folio))

mm/swapfile.c

228

if (!folio_matches_swap_entry(folio, entry)) {

mm/swapfile.c

229

folio_unlock(folio);

mm/swapfile.c

230

folio_put(folio);

mm/swapfile.c

233

offset = swp_offset(folio->swap);

mm/swapfile.c

236

((flags & TTRS_UNMAPPED) && !folio_mapped(folio)) ||

mm/swapfile.c

237

((flags & TTRS_FULL) && mem_cgroup_swap_full(folio)));

mm/swapfile.c

238

if (!need_reclaim || !folio_swapcache_freeable(folio))

mm/swapfile.c

2407

unsigned long addr, swp_entry_t entry, struct folio *folio)

mm/swapfile.c

2410

struct folio *swapcache;

mm/swapfile.c

2420

if (!folio_matches_swap_entry(folio, entry))

mm/swapfile.c

2423

swapcache = folio;

mm/swapfile.c

2424

folio = ksm_might_need_to_copy(folio, vma, addr);

mm/swapfile.c

2425

if (unlikely(!folio))

mm/swapfile.c

2427

else if (unlikely(folio == ERR_PTR(-EHWPOISON))) {

mm/swapfile.c

2429

folio = swapcache;

mm/swapfile.c

2432

page = folio_file_page(folio, swp_offset(entry));

mm/swapfile.c

2445

if (unlikely(hwpoisoned || !folio_test_uptodate(folio))) {

mm/swapfile.c

2464

arch_swap_restore(folio_swap(entry, folio), folio);

mm/swapfile.c

2468

folio_get(folio);

mm/swapfile.c

2469

if (folio == swapcache) {

mm/swapfile.c

2477

VM_BUG_ON_FOLIO(folio_test_writeback(folio), folio);

mm/swapfile.c

2485

if (!folio_test_anon(folio)) {

mm/swapfile.c

2486

VM_WARN_ON_ONCE(folio_test_large(folio));

mm/swapfile.c

2487

VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio);

mm/swapfile.c

2488

folio_add_new_anon_rmap(folio, vma, addr, rmap_flags);

mm/swapfile.c

2490

folio_add_anon_rmap_pte(folio, page, vma, addr, rmap_flags);

mm/swapfile.c

2493

folio_add_new_anon_rmap(folio, vma, addr, RMAP_EXCLUSIVE);

mm/swapfile.c

2494

folio_add_lru_vma(folio, vma);

mm/swapfile.c

2507

if (folio != swapcache) {

mm/swapfile.c

2508

folio_unlock(folio);

mm/swapfile.c

2509

folio_put(folio);

mm/swapfile.c

252

swap_cache_del_folio(folio);

mm/swapfile.c

2521

struct folio *folio;

mm/swapfile.c

253

folio_set_dirty(folio);

mm/swapfile.c

2544

folio = swap_cache_get_folio(entry);

mm/swapfile.c

2545

if (!folio) {

mm/swapfile.c

2553

folio = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE,

mm/swapfile.c

2556

if (!folio) {

mm/swapfile.c

256

folio_unlock(folio);

mm/swapfile.c

2564

folio_lock(folio);

mm/swapfile.c

2565

folio_wait_writeback(folio);

mm/swapfile.c

2566

ret = unuse_pte(vma, pmd, addr, entry, folio);

mm/swapfile.c

2568

folio_unlock(folio);

mm/swapfile.c

2569

folio_put(folio);

mm/swapfile.c

2573

folio_free_swap(folio);

mm/swapfile.c

2574

folio_unlock(folio);

mm/swapfile.c

2575

folio_put(folio);

mm/swapfile.c

258

folio_put(folio);

mm/swapfile.c

2725

struct folio *folio;

mm/swapfile.c

2775

folio = swap_cache_get_folio(entry);

mm/swapfile.c

2776

if (!folio)

mm/swapfile.c

2785

folio_lock(folio);

mm/swapfile.c

2786

folio_wait_writeback(folio);

mm/swapfile.c

2787

folio_free_swap(folio);

mm/swapfile.c

2788

folio_unlock(folio);

mm/swapfile.c

2789

folio_put(folio);

mm/swapfile.c

331

sector_t swap_folio_sector(struct folio *folio)

mm/swapfile.c

333

struct swap_info_struct *sis = __swap_entry_to_info(folio->swap);

mm/swapfile.c

338

offset = swp_offset(folio->swap);

mm/swapfile.c

3606

struct folio *folio = NULL;

mm/swapfile.c

3670

folio = read_mapping_folio(mapping, 0, swap_file);

mm/swapfile.c

3671

if (IS_ERR(folio)) {

mm/swapfile.c

3672

error = PTR_ERR(folio);

mm/swapfile.c

3675

swap_header = kmap_local_folio(folio, 0);

mm/swapfile.c

3816

if (!IS_ERR_OR_NULL(folio))

mm/swapfile.c

3817

folio_release_kmap(folio, swap_header);

mm/swapfile.c

3880

void __folio_throttle_swaprate(struct folio *folio, gfp_t gfp)

mm/swapfile.c

415

struct folio *folio;

mm/swapfile.c

417

folio = page_folio(container_of(head, struct page, rcu_head));

mm/swapfile.c

418

folio_put(folio);

mm/swapfile.c

452

struct folio *folio;

mm/swapfile.c

460

folio = folio_alloc(gfp | __GFP_ZERO, 0);

mm/swapfile.c

461

if (folio)

mm/swapfile.c

462

table = folio_address(folio);

mm/swapfile.c

54

static bool folio_swapcache_freeable(struct folio *folio);

mm/swapfile.c

913

struct folio *folio,

mm/swapfile.c

933

if (likely(folio)) {

mm/swapfile.c

934

order = folio_order(folio);

mm/swapfile.c

937

__swap_cache_add_folio(ci, folio, swp_entry(si->type,

mm/swapfile.c

966

struct folio *folio, unsigned long offset)

mm/swapfile.c

970

unsigned int order = likely(folio) ? folio_order(folio) : 0;

mm/swapfile.c

995

if (!__swap_cluster_alloc_entries(si, ci, folio, offset % SWAPFILE_CLUSTER))

mm/truncate.c

107

xas_for_each(&xas, folio, indices[nr-1]) {

mm/truncate.c

108

if (xa_is_value(folio))

mm/truncate.c

135

void folio_invalidate(struct folio *folio, size_t offset, size_t length)

mm/truncate.c

137

const struct address_space_operations *aops = folio->mapping->a_ops;

mm/truncate.c

140

aops->invalidate_folio(folio, offset, length);

mm/truncate.c

154

static void truncate_cleanup_folio(struct folio *folio)

mm/truncate.c

156

if (folio_mapped(folio))

mm/truncate.c

157

unmap_mapping_folio(folio);

mm/truncate.c

159

if (folio_needs_release(folio))

mm/truncate.c

160

folio_invalidate(folio, 0, folio_size(folio));

mm/truncate.c

167

folio_cancel_dirty(folio);

mm/truncate.c

170

int truncate_inode_folio(struct address_space *mapping, struct folio *folio)

mm/truncate.c

172

if (folio->mapping != mapping)

mm/truncate.c

175

truncate_cleanup_folio(folio);

mm/truncate.c

176

filemap_remove_folio(folio);

mm/truncate.c

180

static int folio_split_or_unmap(struct folio *folio, struct page *split_at,

mm/truncate.c

189

ret = folio_split(folio, min_order, split_at, NULL);

mm/truncate.c

198

if (ret && !shmem_mapping(folio->mapping)) {

mm/truncate.c

199

try_to_unmap(folio, ttu_flags);

mm/truncate.c

200

WARN_ON(folio_mapped(folio));

mm/truncate.c

217

bool truncate_inode_partial_folio(struct folio *folio, loff_t start, loff_t end)

mm/truncate.c

219

loff_t pos = folio_pos(folio);

mm/truncate.c

220

size_t size = folio_size(folio);

mm/truncate.c

234

folio_wait_writeback(folio);

mm/truncate.c

236

truncate_inode_folio(folio->mapping, folio);

mm/truncate.c

245

if (!mapping_inaccessible(folio->mapping))

mm/truncate.c

246

folio_zero_range(folio, offset, length);

mm/truncate.c

248

if (folio_needs_release(folio))

mm/truncate.c

249

folio_invalidate(folio, offset, length);

mm/truncate.c

250

if (!folio_test_large(folio))

mm/truncate.c

253

min_order = mapping_min_folio_order(folio->mapping);

mm/truncate.c

254

split_at = folio_page(folio, PAGE_ALIGN_DOWN(offset) / PAGE_SIZE);

mm/truncate.c

255

if (!folio_split_or_unmap(folio, split_at, min_order)) {

mm/truncate.c

261

struct folio *folio2;

mm/truncate.c

266

split_at2 = folio_page(folio,

mm/truncate.c

281

folio2->mapping == folio->mapping)

mm/truncate.c

290

if (folio_test_dirty(folio))

mm/truncate.c

292

truncate_inode_folio(folio->mapping, folio);

mm/truncate.c

30

struct folio *folio;

mm/truncate.c

300

struct folio *folio)

mm/truncate.c

310

return truncate_inode_folio(mapping, folio);

mm/truncate.c

325

long mapping_evict_folio(struct address_space *mapping, struct folio *folio)

mm/truncate.c

330

if (folio_test_dirty(folio) || folio_test_writeback(folio))

mm/truncate.c

333

if (folio_ref_count(folio) >

mm/truncate.c

334

folio_nr_pages(folio) + folio_has_private(folio) + 1)

mm/truncate.c

336

if (!filemap_release_folio(folio, 0))

mm/truncate.c

339

return remove_mapping(mapping, folio);

mm/truncate.c

375

struct folio *folio;

mm/truncate.c

413

folio = __filemap_get_folio(mapping, lstart >> PAGE_SHIFT, FGP_LOCK, 0);

mm/truncate.c

414

if (!IS_ERR(folio)) {

mm/truncate.c

415

same_folio = lend < folio_next_pos(folio);

mm/truncate.c

416

if (!truncate_inode_partial_folio(folio, lstart, lend)) {

mm/truncate.c

417

start = folio_next_index(folio);

mm/truncate.c

419

end = folio->index;

mm/truncate.c

42

xas_for_each(&xas, folio, max) {

mm/truncate.c

421

folio_unlock(folio);

mm/truncate.c

422

folio_put(folio);

mm/truncate.c

423

folio = NULL;

mm/truncate.c

427

folio = __filemap_get_folio(mapping, lend >> PAGE_SHIFT,

mm/truncate.c

429

if (!IS_ERR(folio)) {

mm/truncate.c

43

if (xa_is_value(folio))

mm/truncate.c

430

if (!truncate_inode_partial_folio(folio, lstart, lend))

mm/truncate.c

431

end = folio->index;

mm/truncate.c

432

folio_unlock(folio);

mm/truncate.c

433

folio_put(folio);

mm/truncate.c

451

struct folio *folio = fbatch.folios[i];

mm/truncate.c

455

if (xa_is_value(folio))

mm/truncate.c

458

folio_lock(folio);

mm/truncate.c

459

VM_BUG_ON_FOLIO(!folio_contains(folio, indices[i]), folio);

mm/truncate.c

460

folio_wait_writeback(folio);

mm/truncate.c

461

truncate_inode_folio(mapping, folio);

mm/truncate.c

462

folio_unlock(folio);

mm/truncate.c

550

struct folio *folio = fbatch.folios[i];

mm/truncate.c

554

if (xa_is_value(folio)) {

mm/truncate.c

560

ret = mapping_evict_folio(mapping, folio);

mm/truncate.c

561

folio_unlock(folio);

mm/truncate.c

567

deactivate_file_folio(folio);

mm/truncate.c

606

static int folio_launder(struct address_space *mapping, struct folio *folio)

mm/truncate.c

608

if (!folio_test_dirty(folio))

mm/truncate.c

610

if (folio->mapping != mapping || mapping->a_ops->launder_folio == NULL)

mm/truncate.c

612

return mapping->a_ops->launder_folio(folio);

mm/truncate.c

622

int folio_unmap_invalidate(struct address_space *mapping, struct folio *folio,

mm/truncate.c

625

void (*free_folio)(struct folio *);

mm/truncate.c

628

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/truncate.c

630

if (folio_mapped(folio))

mm/truncate.c

631

unmap_mapping_folio(folio);

mm/truncate.c

632

BUG_ON(folio_mapped(folio));

mm/truncate.c

634

ret = folio_launder(mapping, folio);

mm/truncate.c

637

if (folio->mapping != mapping)

mm/truncate.c

639

if (!filemap_release_folio(folio, gfp))

mm/truncate.c

644

if (folio_test_dirty(folio))

mm/truncate.c

647

BUG_ON(folio_has_private(folio));

mm/truncate.c

648

__filemap_remove_folio(folio, NULL);

mm/truncate.c

65

struct folio *folio;

mm/truncate.c

656

free_folio(folio);

mm/truncate.c

657

folio_put_refs(folio, folio_nr_pages(folio));

mm/truncate.c

697

struct folio *folio = fbatch.folios[i];

mm/truncate.c

701

if (xa_is_value(folio)) {

mm/truncate.c

709

if (!did_range_unmap && folio_mapped(folio)) {

mm/truncate.c

719

folio_lock(folio);

mm/truncate.c

720

if (unlikely(folio->mapping != mapping)) {

mm/truncate.c

721

folio_unlock(folio);

mm/truncate.c

724

VM_BUG_ON_FOLIO(!folio_contains(folio, indices[i]), folio);

mm/truncate.c

725

folio_wait_writeback(folio);

mm/truncate.c

726

ret2 = folio_unmap_invalidate(mapping, folio, GFP_KERNEL);

mm/truncate.c

729

folio_unlock(folio);

mm/truncate.c

850

struct folio *folio;

mm/truncate.c

861

folio = filemap_lock_folio(inode->i_mapping, from / PAGE_SIZE);

mm/truncate.c

863

if (IS_ERR(folio))

mm/truncate.c

869

if (folio_mkclean(folio))

mm/truncate.c

870

folio_mark_dirty(folio);

mm/truncate.c

877

if (folio_test_dirty(folio)) {

mm/truncate.c

880

offset = from - folio_pos(folio);

mm/truncate.c

881

end = min_t(unsigned int, to - folio_pos(folio),

mm/truncate.c

882

folio_size(folio));

mm/truncate.c

883

folio_zero_segment(folio, offset, end);

mm/truncate.c

886

folio_unlock(folio);

mm/truncate.c

887

folio_put(folio);

mm/userfaultfd.c

1211

static struct folio *check_ptes_for_batched_move(struct vm_area_struct *src_vma,

mm/userfaultfd.c

1216

struct folio *folio;

mm/userfaultfd.c

1226

folio = vm_normal_folio(src_vma, src_addr, orig_src_pte);

mm/userfaultfd.c

1227

if (!folio || !folio_trylock(folio))

mm/userfaultfd.c

1229

if (!PageAnonExclusive(&folio->page) || folio_test_large(folio)) {

mm/userfaultfd.c

1230

folio_unlock(folio);

mm/userfaultfd.c

1233

return folio;

mm/userfaultfd.c

1248

struct folio **first_src_folio, unsigned long len)

mm/userfaultfd.c

1251

struct folio *src_folio = *first_src_folio;

mm/userfaultfd.c

1328

struct folio *src_folio,

mm/userfaultfd.c

1429

struct folio *src_folio = NULL;

mm/userfaultfd.c

1518

struct folio *folio;

mm/userfaultfd.c

1532

folio = vm_normal_folio(src_vma, src_addr, orig_src_pte);

mm/userfaultfd.c

1533

if (!folio || !PageAnonExclusive(&folio->page)) {

mm/userfaultfd.c

1539

locked = folio_trylock(folio);

mm/userfaultfd.c

1547

if (!locked && folio_test_large(folio)) {

mm/userfaultfd.c

1553

folio_get(folio);

mm/userfaultfd.c

1554

src_folio = folio;

mm/userfaultfd.c

1595

struct folio *folio = NULL;

mm/userfaultfd.c

1634

folio = swap_cache_get_folio(entry);

mm/userfaultfd.c

1635

if (folio) {

mm/userfaultfd.c

1636

if (folio_test_large(folio)) {

mm/userfaultfd.c

1638

folio_put(folio);

mm/userfaultfd.c

1641

src_folio = folio;

mm/userfaultfd.c

2030

struct folio *folio = pmd_folio(*src_pmd);

mm/userfaultfd.c

2032

if (!is_huge_zero_folio(folio) &&

mm/userfaultfd.c

2033

!PageAnonExclusive(&folio->page)) {

mm/userfaultfd.c

368

struct folio *folio = page_folio(page);

mm/userfaultfd.c

369

bool page_in_cache = folio_mapping(folio);

mm/userfaultfd.c

404

folio_add_file_rmap_pte(folio, page, dst_vma);

mm/userfaultfd.c

406

folio_add_new_anon_rmap(folio, dst_vma, dst_addr, RMAP_EXCLUSIVE);

mm/userfaultfd.c

407

folio_add_lru_vma(folio, dst_vma);

mm/userfaultfd.c

414

inc_mm_counter(dst_mm, mm_counter(folio));

mm/userfaultfd.c

419

folio_unlock(folio);

mm/userfaultfd.c

430

static int mfill_copy_folio_locked(struct folio *folio, unsigned long src_addr)

mm/userfaultfd.c

435

kaddr = kmap_local_folio(folio, 0);

mm/userfaultfd.c

460

flush_dcache_folio(folio);

mm/userfaultfd.c

526

struct folio *folio)

mm/userfaultfd.c

539

kaddr = kmap_local_folio(folio, 0);

mm/userfaultfd.c

545

flush_dcache_folio(folio);

mm/userfaultfd.c

568

struct folio *folio;

mm/userfaultfd.c

576

folio = ops->alloc_folio(state->vma, state->dst_addr);

mm/userfaultfd.c

577

if (!folio)

mm/userfaultfd.c

581

ret = mfill_copy_folio_locked(folio, src_addr);

mm/userfaultfd.c

590

ret = mfill_copy_folio_retry(state, folio);

mm/userfaultfd.c

595

clear_user_highpage(&folio->page, state->dst_addr);

mm/userfaultfd.c

605

__folio_mark_uptodate(folio);

mm/userfaultfd.c

608

ret = ops->filemap_add(folio, state->vma, state->dst_addr);

mm/userfaultfd.c

61

static struct folio *anon_alloc_folio(struct vm_area_struct *vma,

mm/userfaultfd.c

614

&folio->page, flags);

mm/userfaultfd.c

622

ops->filemap_remove(folio, state->vma);

mm/userfaultfd.c

624

folio_put(folio);

mm/userfaultfd.c

64

struct folio *folio = vma_alloc_folio(GFP_HIGHUSER_MOVABLE, 0, vma,

mm/userfaultfd.c

67

if (!folio)

mm/userfaultfd.c

70

if (mem_cgroup_charge(folio, vma->vm_mm, GFP_KERNEL)) {

mm/userfaultfd.c

700

struct folio *folio;

mm/userfaultfd.c

709

folio = ops->get_folio_noalloc(inode, pgoff);

mm/userfaultfd.c

71

folio_put(folio);

mm/userfaultfd.c

711

if (IS_ERR_OR_NULL(folio))

mm/userfaultfd.c

714

page = folio_file_page(folio, pgoff);

mm/userfaultfd.c

728

folio_unlock(folio);

mm/userfaultfd.c

729

folio_put(folio);

mm/userfaultfd.c

75

return folio;

mm/userfaultfd.c

790

struct folio *folio;

mm/userfaultfd.c

811

folio = NULL;

mm/userfaultfd.c

887

src_addr, flags, &folio);

mm/userfaultfd.c

897

VM_WARN_ON_ONCE(!folio);

mm/userfaultfd.c

899

err = copy_folio_from_user(folio,

mm/userfaultfd.c

909

VM_WARN_ON_ONCE(folio);

mm/userfaultfd.c

928

if (folio)

mm/userfaultfd.c

929

folio_put(folio);

mm/util.c

1156

void flush_dcache_folio(struct folio *folio)

mm/util.c

1158

long i, nr = folio_nr_pages(folio);

mm/util.c

1161

flush_dcache_page(folio_page(folio, i));

mm/util.c

1285

static void set_ps_flags(struct page_snapshot *ps, const struct folio *folio,

mm/util.c

1298

if (folio_test_idle(folio))

mm/util.c

1320

struct folio *foliop;

mm/util.c

1327

memset(&ps->folio_snapshot, 0, sizeof(struct folio));

mm/util.c

1332

foliop = (struct folio *)&ps->page_snapshot;

mm/util.c

1339

foliop = (struct folio *)page;

mm/util.c

1345

foliop = (struct folio *)(p & info);

mm/util.c

1347

foliop = (struct folio *)(info - 1);

mm/util.c

1366

foliop = (struct folio *)&ps->page_snapshot;

mm/util.c

1567

unsigned int folio_pte_batch(struct folio *folio, pte_t *ptep, pte_t pte,

mm/util.c

1570

return folio_pte_batch_flags(folio, NULL, ptep, &pte, max_nr, 0);

mm/util.c

700

struct anon_vma *folio_anon_vma(const struct folio *folio)

mm/util.c

702

unsigned long mapping = (unsigned long)folio->mapping;

mm/util.c

721

struct address_space *folio_mapping(const struct folio *folio)

mm/util.c

726

if (unlikely(folio_test_slab(folio)))

mm/util.c

729

if (unlikely(folio_test_swapcache(folio)))

mm/util.c

730

return swap_address_space(folio->swap);

mm/util.c

732

mapping = folio->mapping;

mm/util.c

750

void folio_copy(struct folio *dst, struct folio *src)

mm/util.c

764

int folio_mc_copy(struct folio *dst, struct folio *src)

mm/vmscan.c

1036

static bool may_enter_fs(struct folio *folio, gfp_t gfp_mask)

mm/vmscan.c

1040

if (!folio_test_swapcache(folio) || !(gfp_mask & __GFP_IO))

mm/vmscan.c

1049

return !data_race(folio_swap_flags(folio) & SWP_FS_OPS);

mm/vmscan.c

1076

struct folio *folio;

mm/vmscan.c

1083

folio = lru_to_folio(folio_list);

mm/vmscan.c

1084

list_del(&folio->lru);

mm/vmscan.c

1086

if (!folio_trylock(folio))

mm/vmscan.c

1089

if (folio_contain_hwpoisoned_page(folio)) {

mm/vmscan.c

1095

if (folio_test_large(folio))

mm/vmscan.c

1098

unmap_poisoned_folio(folio, folio_pfn(folio), false);

mm/vmscan.c

1099

folio_unlock(folio);

mm/vmscan.c

1100

folio_put(folio);

mm/vmscan.c

1104

VM_BUG_ON_FOLIO(folio_test_active(folio), folio);

mm/vmscan.c

1106

nr_pages = folio_nr_pages(folio);

mm/vmscan.c

1111

if (unlikely(!folio_evictable(folio)))

mm/vmscan.c

1114

if (!sc->may_unmap && folio_mapped(folio))

mm/vmscan.c

1122

folio_check_dirty_writeback(folio, &dirty, &writeback);

mm/vmscan.c

1135

if (writeback && folio_test_reclaim(folio))

mm/vmscan.c

1184

if (folio_test_writeback(folio)) {

mm/vmscan.c

1185

mapping = folio_mapping(folio);

mm/vmscan.c

1189

folio_test_reclaim(folio) &&

mm/vmscan.c

1196

!folio_test_reclaim(folio) ||

mm/vmscan.c

1197

!may_enter_fs(folio, sc->gfp_mask) ||

mm/vmscan.c

1214

folio_set_reclaim(folio);

mm/vmscan.c

1220

folio_unlock(folio);

mm/vmscan.c

1221

folio_wait_writeback(folio);

mm/vmscan.c

1223

list_add_tail(&folio->lru, folio_list);

mm/vmscan.c

1229

references = folio_check_references(folio, sc);

mm/vmscan.c

1247

(thp_migration_supported() || !folio_test_large(folio))) {

mm/vmscan.c

1248

list_add(&folio->lru, &demote_folios);

mm/vmscan.c

1249

folio_unlock(folio);

mm/vmscan.c

1258

if (folio_test_anon(folio) && folio_test_swapbacked(folio) &&

mm/vmscan.c

1259

!folio_test_swapcache(folio)) {

mm/vmscan.c

1262

if (folio_maybe_dma_pinned(folio))

mm/vmscan.c

1264

if (folio_test_large(folio)) {

mm/vmscan.c

1266

if (folio_expected_ref_count(folio) !=

mm/vmscan.c

1267

folio_ref_count(folio) - 1)

mm/vmscan.c

1273

if (data_race(!list_empty(&folio->_deferred_list) &&

mm/vmscan.c

1274

folio_test_partially_mapped(folio)) &&

mm/vmscan.c

1275

split_folio_to_list(folio, folio_list))

mm/vmscan.c

1278

if (folio_alloc_swap(folio)) {

mm/vmscan.c

1279

int __maybe_unused order = folio_order(folio);

mm/vmscan.c

1281

if (!folio_test_large(folio))

mm/vmscan.c

1284

if (split_folio_to_list(folio, folio_list))

mm/vmscan.c

1288

count_memcg_folio_events(folio,

mm/vmscan.c

1294

if (folio_alloc_swap(folio))

mm/vmscan.c

1309

folio_mark_dirty(folio);

mm/vmscan.c

1317

if ((nr_pages > 1) && !folio_test_large(folio)) {

mm/vmscan.c

1326

if (folio_mapped(folio)) {

mm/vmscan.c

1328

bool was_swapbacked = folio_test_swapbacked(folio);

mm/vmscan.c

1330

if (folio_test_pmd_mappable(folio))

mm/vmscan.c

1344

if (folio_test_large(folio))

mm/vmscan.c

1347

try_to_unmap(folio, flags);

mm/vmscan.c

1348

if (folio_mapped(folio)) {

mm/vmscan.c

1351

folio_test_swapbacked(folio))

mm/vmscan.c

1364

if (folio_maybe_dma_pinned(folio))

mm/vmscan.c

1367

mapping = folio_mapping(folio);

mm/vmscan.c

1368

if (folio_test_dirty(folio)) {

mm/vmscan.c

1369

if (folio_is_file_lru(folio)) {

mm/vmscan.c

1376

node_stat_mod_folio(folio, NR_VMSCAN_IMMEDIATE,

mm/vmscan.c

1378

if (!folio_test_reclaim(folio))

mm/vmscan.c

1379

folio_set_reclaim(folio);

mm/vmscan.c

1386

if (!may_enter_fs(folio, sc->gfp_mask))

mm/vmscan.c

1397

switch (pageout(folio, mapping, &plug, folio_list)) {

mm/vmscan.c

1406

if (nr_pages > 1 && !folio_test_large(folio)) {

mm/vmscan.c

1412

if (nr_pages > 1 && !folio_test_large(folio)) {

mm/vmscan.c

1418

if (folio_test_writeback(folio))

mm/vmscan.c

1420

if (folio_test_dirty(folio))

mm/vmscan.c

1427

if (!folio_trylock(folio))

mm/vmscan.c

1429

if (folio_test_dirty(folio) ||

mm/vmscan.c

1430

folio_test_writeback(folio))

mm/vmscan.c

1432

mapping = folio_mapping(folio);

mm/vmscan.c

1462

if (folio_needs_release(folio)) {

mm/vmscan.c

1463

if (!filemap_release_folio(folio, sc->gfp_mask))

mm/vmscan.c

1465

if (!mapping && folio_ref_count(folio) == 1) {

mm/vmscan.c

1466

folio_unlock(folio);

mm/vmscan.c

1467

if (folio_put_testzero(folio))

mm/vmscan.c

1483

if (folio_test_lazyfree(folio)) {

mm/vmscan.c

1485

if (!folio_ref_freeze(folio, 1))

mm/vmscan.c

1496

count_memcg_folio_events(folio, PGLAZYFREED, nr_pages);

mm/vmscan.c

1497

} else if (!mapping || !__remove_mapping(mapping, folio, true,

mm/vmscan.c

1501

folio_unlock(folio);

mm/vmscan.c

1509

folio_unqueue_deferred_split(folio);

mm/vmscan.c

1510

if (folio_batch_add(&free_folios, folio) == 0) {

mm/vmscan.c

1528

if (folio_test_swapcache(folio) &&

mm/vmscan.c

1529

(mem_cgroup_swap_full(folio) || folio_test_mlocked(folio)))

mm/vmscan.c

1530

folio_free_swap(folio);

mm/vmscan.c

1531

VM_BUG_ON_FOLIO(folio_test_active(folio), folio);

mm/vmscan.c

1532

if (!folio_test_mlocked(folio)) {

mm/vmscan.c

1533

int type = folio_is_file_lru(folio);

mm/vmscan.c

1534

folio_set_active(folio);

mm/vmscan.c

1536

count_memcg_folio_events(folio, PGACTIVATE, nr_pages);

mm/vmscan.c

1539

folio_unlock(folio);

mm/vmscan.c

1541

list_add(&folio->lru, &ret_folios);

mm/vmscan.c

1542

VM_BUG_ON_FOLIO(folio_test_lru(folio) ||

mm/vmscan.c

1543

folio_test_unevictable(folio), folio);

mm/vmscan.c

1601

struct folio *folio, *next;

mm/vmscan.c

1605

list_for_each_entry_safe(folio, next, folio_list, lru) {

mm/vmscan.c

1607

if (page_has_movable_ops(&folio->page))

mm/vmscan.c

1609

if (!folio_test_hugetlb(folio) && folio_is_file_lru(folio) &&

mm/vmscan.c

1610

!folio_test_dirty(folio) && !folio_test_unevictable(folio)) {

mm/vmscan.c

1611

folio_clear_active(folio);

mm/vmscan.c

1612

list_move(&folio->lru, &clean_folios);

mm/vmscan.c

1698

struct folio *folio;

mm/vmscan.c

1700

folio = lru_to_folio(src);

mm/vmscan.c

1701

prefetchw_prev_lru_folio(folio, src, flags);

mm/vmscan.c

1703

nr_pages = folio_nr_pages(folio);

mm/vmscan.c

1708

(folio_zonenum(folio) > sc->reclaim_idx)) {

mm/vmscan.c

1709

nr_skipped[folio_zonenum(folio)] += nr_pages;

mm/vmscan.c

1724

if (!folio_test_lru(folio))

mm/vmscan.c

1726

if (!sc->may_unmap && folio_mapped(folio))

mm/vmscan.c

1734

if (unlikely(!folio_try_get(folio)))

mm/vmscan.c

1737

if (!folio_test_clear_lru(folio)) {

mm/vmscan.c

1739

folio_put(folio);

mm/vmscan.c

1744

nr_zone_taken[folio_zonenum(folio)] += nr_pages;

mm/vmscan.c

1747

list_move(&folio->lru, move_to);

mm/vmscan.c

1799

bool folio_isolate_lru(struct folio *folio)

mm/vmscan.c

1803

VM_BUG_ON_FOLIO(!folio_ref_count(folio), folio);

mm/vmscan.c

1805

if (folio_test_clear_lru(folio)) {

mm/vmscan.c

1808

folio_get(folio);

mm/vmscan.c

1809

lruvec = folio_lruvec_lock_irq(folio);

mm/vmscan.c

1810

lruvec_del_folio(lruvec, folio);

mm/vmscan.c

186

struct folio *prev; \

mm/vmscan.c

1877

struct folio *folio = lru_to_folio(list);

mm/vmscan.c

1879

lruvec = folio_lruvec_relock_irq(folio, lruvec);

mm/vmscan.c

1880

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/vmscan.c

1881

list_del(&folio->lru);

mm/vmscan.c

1882

if (unlikely(!folio_evictable(folio))) {

mm/vmscan.c

1884

folio_putback_lru(folio);

mm/vmscan.c

1900

folio_set_lru(folio);

mm/vmscan.c

1902

if (unlikely(folio_put_testzero(folio))) {

mm/vmscan.c

1903

__folio_clear_lru_flags(folio);

mm/vmscan.c

1905

folio_unqueue_deferred_split(folio);

mm/vmscan.c

1906

if (folio_batch_add(&free_folios, folio) == 0) {

mm/vmscan.c

1916

lruvec_add_folio(lruvec, folio);

mm/vmscan.c

1917

nr_pages = folio_nr_pages(folio);

mm/vmscan.c

1919

if (folio_test_active(folio))

mm/vmscan.c

2098

struct folio *folio;

mm/vmscan.c

2101

folio = lru_to_folio(&l_hold);

mm/vmscan.c

2102

list_del(&folio->lru);

mm/vmscan.c

2104

if (unlikely(!folio_evictable(folio))) {

mm/vmscan.c

2105

folio_putback_lru(folio);

mm/vmscan.c

2110

if (folio_needs_release(folio) &&

mm/vmscan.c

2111

folio_trylock(folio)) {

mm/vmscan.c

2112

filemap_release_folio(folio, 0);

mm/vmscan.c

2113

folio_unlock(folio);

mm/vmscan.c

2118

if (folio_referenced(folio, 0, sc->target_mem_cgroup,

mm/vmscan.c

2129

if ((vm_flags & VM_EXEC) && folio_is_file_lru(folio)) {

mm/vmscan.c

2130

nr_rotated += folio_nr_pages(folio);

mm/vmscan.c

2131

list_add(&folio->lru, &l_active);

mm/vmscan.c

2136

folio_clear_active(folio); /* we are de-activating */

mm/vmscan.c

2137

folio_set_workingset(folio);

mm/vmscan.c

2138

list_add(&folio->lru, &l_inactive);

mm/vmscan.c

2162

struct folio *folio;

mm/vmscan.c

2173

folio = lru_to_folio(folio_list);

mm/vmscan.c

2174

list_del(&folio->lru);

mm/vmscan.c

2175

folio_putback_lru(folio);

mm/vmscan.c

2196

struct folio *folio = lru_to_folio(folio_list);

mm/vmscan.c

2198

if (nid == folio_nid(folio)) {

mm/vmscan.c

2199

folio_clear_active(folio);

mm/vmscan.c

2200

list_move(&folio->lru, &node_folio_list);

mm/vmscan.c

3198

static int folio_update_gen(struct folio *folio, int gen)

mm/vmscan.c

3200

unsigned long new_flags, old_flags = READ_ONCE(folio->flags.f);

mm/vmscan.c

3205

if (!folio_test_referenced(folio) && !folio_test_workingset(folio)) {

mm/vmscan.c

3206

set_mask_bits(&folio->flags.f, LRU_REFS_MASK, BIT(PG_referenced));

mm/vmscan.c

3217

} while (!try_cmpxchg(&folio->flags.f, &old_flags, new_flags));

mm/vmscan.c

3223

static int folio_inc_gen(struct lruvec *lruvec, struct folio *folio)

mm/vmscan.c

3225

int type = folio_is_file_lru(folio);

mm/vmscan.c

3228

unsigned long new_flags, old_flags = READ_ONCE(folio->flags.f);

mm/vmscan.c

3230

VM_WARN_ON_ONCE_FOLIO(!(old_flags & LRU_GEN_MASK), folio);

mm/vmscan.c

3242

} while (!try_cmpxchg(&folio->flags.f, &old_flags, new_flags));

mm/vmscan.c

3244

lru_gen_update_size(lruvec, folio, old_gen, new_gen);

mm/vmscan.c

3249

static void update_batch_size(struct lru_gen_mm_walk *walk, struct folio *folio,

mm/vmscan.c

3252

int type = folio_is_file_lru(folio);

mm/vmscan.c

3253

int zone = folio_zonenum(folio);

mm/vmscan.c

3254

int delta = folio_nr_pages(folio);

mm/vmscan.c

3411

static struct folio *get_pfn_folio(unsigned long pfn, struct mem_cgroup *memcg,

mm/vmscan.c

3414

struct folio *folio = pfn_folio(pfn);

mm/vmscan.c

3416

if (folio_lru_gen(folio) < 0)

mm/vmscan.c

3419

if (folio_nid(folio) != pgdat->node_id)

mm/vmscan.c

3423

if (folio_memcg(folio) != memcg)

mm/vmscan.c

3424

folio = NULL;

mm/vmscan.c

3427

return folio;

mm/vmscan.c

3438

static void walk_update_folio(struct lru_gen_mm_walk *walk, struct folio *folio,

mm/vmscan.c

3443

if (!folio)

mm/vmscan.c

3446

if (dirty && !folio_test_dirty(folio) &&

mm/vmscan.c

3447

!(folio_test_anon(folio) && folio_test_swapbacked(folio) &&

mm/vmscan.c

3448

!folio_test_swapcache(folio)))

mm/vmscan.c

3449

folio_mark_dirty(folio);

mm/vmscan.c

3452

old_gen = folio_update_gen(folio, new_gen);

mm/vmscan.c

3454

update_batch_size(walk, folio, old_gen, new_gen);

mm/vmscan.c

3455

} else if (lru_gen_set_refs(folio)) {

mm/vmscan.c

3456

old_gen = folio_lru_gen(folio);

mm/vmscan.c

3458

folio_activate(folio);

mm/vmscan.c

3472

struct folio *last = NULL;

mm/vmscan.c

3499

struct folio *folio;

mm/vmscan.c

3511

folio = get_pfn_folio(pfn, memcg, pgdat);

mm/vmscan.c

3512

if (!folio)

mm/vmscan.c

3515

if (folio_test_large(folio)) {

mm/vmscan.c

3518

nr = folio_pte_batch_flags(folio, NULL, cur_pte, &ptent,

mm/vmscan.c

3527

if (last != folio) {

mm/vmscan.c

3530

last = folio;

mm/vmscan.c

3560

struct folio *last = NULL;

mm/vmscan.c

3592

struct folio *folio;

mm/vmscan.c

3611

folio = get_pfn_folio(pfn, memcg, pgdat);

mm/vmscan.c

3612

if (!folio)

mm/vmscan.c

3618

if (last != folio) {

mm/vmscan.c

3621

last = folio;

mm/vmscan.c

3845

struct folio *folio = lru_to_folio(head);

mm/vmscan.c

3846

int refs = folio_lru_refs(folio);

mm/vmscan.c

3847

bool workingset = folio_test_workingset(folio);

mm/vmscan.c

3849

VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio);

mm/vmscan.c

3850

VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio);

mm/vmscan.c

3851

VM_WARN_ON_ONCE_FOLIO(folio_is_file_lru(folio) != type, folio);

mm/vmscan.c

3852

VM_WARN_ON_ONCE_FOLIO(folio_zonenum(folio) != zone, folio);

mm/vmscan.c

3854

new_gen = folio_inc_gen(lruvec, folio);

mm/vmscan.c

3855

list_move_tail(&folio->lru, &lrugen->folios[new_gen][type][zone]);

mm/vmscan.c

3860

int delta = folio_nr_pages(folio);

mm/vmscan.c

4187

struct folio *last = NULL;

mm/vmscan.c

4192

struct folio *folio = pfn_folio(pvmw->pfn);

mm/vmscan.c

4194

struct pglist_data *pgdat = folio_pgdat(folio);

mm/vmscan.c

4201

VM_WARN_ON_ONCE_FOLIO(folio_test_lru(folio), folio);

mm/vmscan.c

4233

memcg = get_mem_cgroup_from_folio(folio);

mm/vmscan.c

4253

folio = get_pfn_folio(pfn, memcg, pgdat);

mm/vmscan.c

4254

if (!folio)

mm/vmscan.c

4257

if (folio_test_large(folio)) {

mm/vmscan.c

4260

nr = folio_pte_batch_flags(folio, NULL, pte, &ptent,

mm/vmscan.c

4267

if (last != folio) {

mm/vmscan.c

4270

last = folio;

mm/vmscan.c

4573

static bool sort_folio(struct lruvec *lruvec, struct folio *folio, struct scan_control *sc,

mm/vmscan.c

4577

int gen = folio_lru_gen(folio);

mm/vmscan.c

4578

int type = folio_is_file_lru(folio);

mm/vmscan.c

4579

int zone = folio_zonenum(folio);

mm/vmscan.c

4580

int delta = folio_nr_pages(folio);

mm/vmscan.c

4581

int refs = folio_lru_refs(folio);

mm/vmscan.c

4582

bool workingset = folio_test_workingset(folio);

mm/vmscan.c

4586

VM_WARN_ON_ONCE_FOLIO(gen >= MAX_NR_GENS, folio);

mm/vmscan.c

4589

if (!folio_evictable(folio)) {

mm/vmscan.c

4590

success = lru_gen_del_folio(lruvec, folio, true);

mm/vmscan.c

4591

VM_WARN_ON_ONCE_FOLIO(!success, folio);

mm/vmscan.c

4592

folio_set_unevictable(folio);

mm/vmscan.c

4593

lruvec_add_folio(lruvec, folio);

mm/vmscan.c

4600

list_move(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

4606

gen = folio_inc_gen(lruvec, folio);

mm/vmscan.c

4607

list_move(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

4621

gen = folio_inc_gen(lruvec, folio);

mm/vmscan.c

4622

list_move_tail(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

4629

static bool isolate_folio(struct lruvec *lruvec, struct folio *folio, struct scan_control *sc)

mm/vmscan.c

4634

if (!folio_try_get(folio))

mm/vmscan.c

4638

if (!folio_test_clear_lru(folio)) {

mm/vmscan.c

4639

folio_put(folio);

mm/vmscan.c

4644

if (!folio_test_referenced(folio))

mm/vmscan.c

4645

set_mask_bits(&folio->flags.f, LRU_REFS_MASK, 0);

mm/vmscan.c

4647

success = lru_gen_del_folio(lruvec, folio, true);

mm/vmscan.c

4648

VM_WARN_ON_ONCE_FOLIO(!success, folio);

mm/vmscan.c

4682

struct folio *folio = lru_to_folio(head);

mm/vmscan.c

4683

int delta = folio_nr_pages(folio);

mm/vmscan.c

4685

VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio);

mm/vmscan.c

4686

VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio);

mm/vmscan.c

4687

VM_WARN_ON_ONCE_FOLIO(folio_is_file_lru(folio) != type, folio);

mm/vmscan.c

4688

VM_WARN_ON_ONCE_FOLIO(folio_zonenum(folio) != zone, folio);

mm/vmscan.c

4692

if (sort_folio(lruvec, folio, sc, tier))

mm/vmscan.c

4694

else if (isolate_folio(lruvec, folio, sc)) {

mm/vmscan.c

4695

list_add(&folio->lru, list);

mm/vmscan.c

4698

list_move(&folio->lru, &moved);

mm/vmscan.c

472

struct folio *folio, int error)

mm/vmscan.c

474

folio_lock(folio);

mm/vmscan.c

475

if (folio_mapping(folio) == mapping)

mm/vmscan.c

477

folio_unlock(folio);

mm/vmscan.c

4806

struct folio *folio;

mm/vmscan.c

4807

struct folio *next;

mm/vmscan.c

4843

list_for_each_entry_safe_reverse(folio, next, &list, lru) {

mm/vmscan.c

4846

if (!folio_evictable(folio)) {

mm/vmscan.c

4847

list_del(&folio->lru);

mm/vmscan.c

4848

folio_putback_lru(folio);

mm/vmscan.c

4853

if (!skip_retry && !folio_test_active(folio) && !folio_mapped(folio) &&

mm/vmscan.c

4854

!folio_test_dirty(folio) && !folio_test_writeback(folio)) {

mm/vmscan.c

4855

list_move(&folio->lru, &clean);

mm/vmscan.c

4860

if (lru_gen_folio_seq(lruvec, folio, false) == min_seq[type])

mm/vmscan.c

4861

set_mask_bits(&folio->flags.f, LRU_REFS_FLAGS, BIT(PG_active));

mm/vmscan.c

5217

struct folio *folio = lru_to_folio(head);

mm/vmscan.c

5219

VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio);

mm/vmscan.c

5220

VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio) != active, folio);

mm/vmscan.c

5221

VM_WARN_ON_ONCE_FOLIO(folio_is_file_lru(folio) != type, folio);

mm/vmscan.c

5222

VM_WARN_ON_ONCE_FOLIO(folio_lru_gen(folio) != -1, folio);

mm/vmscan.c

5224

lruvec_del_folio(lruvec, folio);

mm/vmscan.c

5225

success = lru_gen_add_folio(lruvec, folio, false);

mm/vmscan.c

5246

struct folio *folio = lru_to_folio(head);

mm/vmscan.c

5248

VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio);

mm/vmscan.c

5249

VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio);

mm/vmscan.c

5250

VM_WARN_ON_ONCE_FOLIO(folio_is_file_lru(folio) != type, folio);

mm/vmscan.c

5251

VM_WARN_ON_ONCE_FOLIO(folio_zonenum(folio) != zone, folio);

mm/vmscan.c

5253

success = lru_gen_del_folio(lruvec, folio, false);

mm/vmscan.c

5255

lruvec_add_folio(lruvec, folio);

mm/vmscan.c

582

void __acct_reclaim_writeback(pg_data_t *pgdat, struct folio *folio,

mm/vmscan.c

587

node_stat_add_folio(folio, NR_THROTTLED_WRITTEN);

mm/vmscan.c

618

static pageout_t pageout(struct folio *folio, struct address_space *mapping,

mm/vmscan.c

640

if (folio_ref_count(folio) != 1 + folio_nr_pages(folio) || !mapping)

mm/vmscan.c

642

if (!shmem_mapping(mapping) && !folio_test_anon(folio))

mm/vmscan.c

644

if (!folio_clear_dirty_for_io(folio))

mm/vmscan.c

647

folio_set_reclaim(folio);

mm/vmscan.c

655

res = shmem_writeout(folio, plug, folio_list);

mm/vmscan.c

657

res = swap_writeout(folio, plug);

mm/vmscan.c

660

handle_write_error(mapping, folio, res);

mm/vmscan.c

662

folio_clear_reclaim(folio);

mm/vmscan.c

667

if (!folio_test_writeback(folio))

mm/vmscan.c

668

folio_clear_reclaim(folio);

mm/vmscan.c

670

trace_mm_vmscan_write_folio(folio);

mm/vmscan.c

671

node_stat_add_folio(folio, NR_VMSCAN_WRITE);

mm/vmscan.c

679

static int __remove_mapping(struct address_space *mapping, struct folio *folio,

mm/vmscan.c

686

BUG_ON(!folio_test_locked(folio));

mm/vmscan.c

687

BUG_ON(mapping != folio_mapping(folio));

mm/vmscan.c

689

if (folio_test_swapcache(folio)) {

mm/vmscan.c

690

ci = swap_cluster_get_and_lock_irq(folio);

mm/vmscan.c

721

refcount = 1 + folio_nr_pages(folio);

mm/vmscan.c

722

if (!folio_ref_freeze(folio, refcount))

mm/vmscan.c

725

if (unlikely(folio_test_dirty(folio))) {

mm/vmscan.c

726

folio_ref_unfreeze(folio, refcount);

mm/vmscan.c

730

if (folio_test_swapcache(folio)) {

mm/vmscan.c

731

swp_entry_t swap = folio->swap;

mm/vmscan.c

734

shadow = workingset_eviction(folio, target_memcg);

mm/vmscan.c

735

__memcg1_swapout(folio, ci);

mm/vmscan.c

736

__swap_cache_del_folio(ci, folio, swap, shadow);

mm/vmscan.c

739

void (*free_folio)(struct folio *);

mm/vmscan.c

758

if (reclaimed && folio_is_file_lru(folio) &&

mm/vmscan.c

760

shadow = workingset_eviction(folio, target_memcg);

mm/vmscan.c

761

__filemap_remove_folio(folio, shadow);

mm/vmscan.c

768

free_folio(folio);

mm/vmscan.c

774

if (folio_test_swapcache(folio)) {

mm/vmscan.c

795

long remove_mapping(struct address_space *mapping, struct folio *folio)

mm/vmscan.c

797

if (__remove_mapping(mapping, folio, false, NULL)) {

mm/vmscan.c

7986

struct folio *folio = fbatch->folios[i];

mm/vmscan.c

7987

int nr_pages = folio_nr_pages(folio);

mm/vmscan.c

7992

if (!folio_test_clear_lru(folio))

mm/vmscan.c

7995

lruvec = folio_lruvec_relock_irq(folio, lruvec);

mm/vmscan.c

7996

if (folio_evictable(folio) && folio_test_unevictable(folio)) {

mm/vmscan.c

7997

lruvec_del_folio(lruvec, folio);

mm/vmscan.c

7998

folio_clear_unevictable(folio);

mm/vmscan.c

7999

lruvec_add_folio(lruvec, folio);

mm/vmscan.c

8002

folio_set_lru(folio);

mm/vmscan.c

803

folio_ref_unfreeze(folio, 1);

mm/vmscan.c

804

return folio_nr_pages(folio);

mm/vmscan.c

818

void folio_putback_lru(struct folio *folio)

mm/vmscan.c

820

folio_add_lru(folio);

mm/vmscan.c

821

folio_put(folio); /* drop ref from isolate */

mm/vmscan.c

838

static bool lru_gen_set_refs(struct folio *folio)

mm/vmscan.c

841

if (!folio_test_referenced(folio) && !folio_test_workingset(folio)) {

mm/vmscan.c

842

set_mask_bits(&folio->flags.f, LRU_REFS_MASK, BIT(PG_referenced));

mm/vmscan.c

847

if (folio_lru_refs(folio) > 1)

mm/vmscan.c

848

set_mask_bits(&folio->flags.f, LRU_REFS_FLAGS, BIT(PG_workingset));

mm/vmscan.c

850

folio_mark_accessed(folio);

mm/vmscan.c

854

static bool lru_gen_set_refs(struct folio *folio)

mm/vmscan.c

860

static enum folio_references folio_check_references(struct folio *folio,

mm/vmscan.c

866

referenced_ptes = folio_referenced(folio, 1, sc->target_mem_cgroup,

mm/vmscan.c

889

return lru_gen_set_refs(folio) ? FOLIOREF_ACTIVATE : FOLIOREF_KEEP;

mm/vmscan.c

892

referenced_folio = folio_test_clear_referenced(folio);

mm/vmscan.c

909

folio_set_referenced(folio);

mm/vmscan.c

917

if ((vm_flags & VM_EXEC) && folio_is_file_lru(folio))

mm/vmscan.c

924

if (referenced_folio && folio_is_file_lru(folio))

mm/vmscan.c

931

static void folio_check_dirty_writeback(struct folio *folio,

mm/vmscan.c

943

if (!folio_is_file_lru(folio) || folio_test_lazyfree(folio)) {

mm/vmscan.c

950

*dirty = folio_test_dirty(folio);

mm/vmscan.c

951

*writeback = folio_test_writeback(folio);

mm/vmscan.c

954

if (!folio_test_private(folio))

mm/vmscan.c

957

mapping = folio_mapping(folio);

mm/vmscan.c

959

mapping->a_ops->is_dirty_writeback(folio, dirty, writeback);

mm/vmscan.c

962

static struct folio *alloc_demote_folio(struct folio *src,

mm/vmscan.c

966

struct folio *dst;

mm/workingset.c

235

static void *lru_gen_eviction(struct folio *folio)

mm/workingset.c

242

int type = folio_is_file_lru(folio);

mm/workingset.c

243

int delta = folio_nr_pages(folio);

mm/workingset.c

244

int refs = folio_lru_refs(folio);

mm/workingset.c

245

bool workingset = folio_test_workingset(folio);

mm/workingset.c

248

struct pglist_data *pgdat = folio_pgdat(folio);

mm/workingset.c

255

memcg = folio_memcg(folio);

mm/workingset.c

292

static void lru_gen_refault(struct folio *folio, void *shadow)

mm/workingset.c

300

int type = folio_is_file_lru(folio);

mm/workingset.c

301

int delta = folio_nr_pages(folio);

mm/workingset.c

306

if (lruvec != folio_lruvec(folio))

mm/workingset.c

329

folio_set_workingset(folio);

mm/workingset.c

332

set_mask_bits(&folio->flags.f, LRU_REFS_MASK, (refs - 1UL) << LRU_REFS_PGOFF);

mm/workingset.c

339

static void *lru_gen_eviction(struct folio *folio)

mm/workingset.c

350

static void lru_gen_refault(struct folio *folio, void *shadow)

mm/workingset.c

392

void *workingset_eviction(struct folio *folio, struct mem_cgroup *target_memcg)

mm/workingset.c

394

struct pglist_data *pgdat = folio_pgdat(folio);

mm/workingset.c

395

int file = folio_is_file_lru(folio);

mm/workingset.c

401

VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);

mm/workingset.c

402

VM_BUG_ON_FOLIO(folio_ref_count(folio), folio);

mm/workingset.c

403

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/workingset.c

406

return lru_gen_eviction(folio);

mm/workingset.c

413

workingset_age_nonresident(lruvec, folio_nr_pages(folio));

mm/workingset.c

415

folio_test_workingset(folio), file);

mm/workingset.c

548

void workingset_refault(struct folio *folio, void *shadow)

mm/workingset.c

550

bool file = folio_is_file_lru(folio);

mm/workingset.c

556

VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);

mm/workingset.c

559

lru_gen_refault(folio, shadow);

mm/workingset.c

572

nr = folio_nr_pages(folio);

mm/workingset.c

573

memcg = get_mem_cgroup_from_folio(folio);

mm/workingset.c

574

lruvec = mem_cgroup_lruvec(memcg, folio_pgdat(folio));

mm/workingset.c

580

folio_set_active(folio);

mm/workingset.c

586

folio_set_workingset(folio);

mm/workingset.c

591

lru_note_cost_refault(folio);

mm/workingset.c

602

void workingset_activation(struct folio *folio)

mm/workingset.c

608

if (mem_cgroup_disabled() || folio_memcg_charged(folio)) {

mm/workingset.c

610

workingset_age_nonresident(folio_lruvec(folio), folio_nr_pages(folio));

mm/zpdesc.h

92

const struct zpdesc *: (const struct folio *)(zp), \

mm/zpdesc.h

93

struct zpdesc *: (struct folio *)(zp)))

mm/zswap.c

1003

folio = swap_cache_alloc_folio(swpentry, GFP_KERNEL, BIT(0), NULL, mpol,

mm/zswap.c

1014

if (IS_ERR(folio))

mm/zswap.c

1015

return PTR_ERR(folio);

mm/zswap.c

1032

if (!zswap_decompress(entry, folio)) {

mm/zswap.c

1046

folio_mark_uptodate(folio);

mm/zswap.c

1049

folio_set_reclaim(folio);

mm/zswap.c

1052

__swap_writepage(folio, NULL);

mm/zswap.c

1056

swap_cache_del_folio(folio);

mm/zswap.c

1057

folio_unlock(folio);

mm/zswap.c

1059

folio_put(folio);

mm/zswap.c

1476

bool zswap_store(struct folio *folio)

mm/zswap.c

1478

long nr_pages = folio_nr_pages(folio);

mm/zswap.c

1479

swp_entry_t swp = folio->swap;

mm/zswap.c

1486

VM_WARN_ON_ONCE(!folio_test_locked(folio));

mm/zswap.c

1487

VM_WARN_ON_ONCE(!folio_test_swapcache(folio));

mm/zswap.c

1492

objcg = get_obj_cgroup_from_folio(folio);

mm/zswap.c

1519

struct page *page = folio_page(folio, index);

mm/zswap.c

1582

int zswap_load(struct folio *folio)

mm/zswap.c

1584

swp_entry_t swp = folio->swap;

mm/zswap.c

1589

VM_WARN_ON_ONCE(!folio_test_locked(folio));

mm/zswap.c

1590

VM_WARN_ON_ONCE(!folio_test_swapcache(folio));

mm/zswap.c

1600

if (WARN_ON_ONCE(folio_test_large(folio))) {

mm/zswap.c

1601

folio_unlock(folio);

mm/zswap.c

1609

if (!zswap_decompress(entry, folio)) {

mm/zswap.c

1610

folio_unlock(folio);

mm/zswap.c

1614

folio_mark_uptodate(folio);

mm/zswap.c

1627

folio_mark_dirty(folio);

mm/zswap.c

1631

folio_unlock(folio);

mm/zswap.c

708

void zswap_folio_swapin(struct folio *folio)

mm/zswap.c

712

if (folio) {

mm/zswap.c

714

lruvec = folio_lruvec(folio);

mm/zswap.c

924

static bool zswap_decompress(struct zswap_entry *entry, struct folio *folio)

mm/zswap.c

942

dst = kmap_local_folio(folio, 0);

mm/zswap.c

946

flush_dcache_folio(folio);

mm/zswap.c

949

sg_set_folio(&output, folio, PAGE_SIZE, 0);

mm/zswap.c

992

struct folio *folio;

net/sunrpc/auth_gss/gss_rpc_xdr.c

843

struct folio *scratch;

virt/kvm/guest_memfd.c

104

WARN_ON(!IS_ALIGNED(slot->gmem.pgoff, folio_nr_pages(folio)));

virt/kvm/guest_memfd.c

106

index = ALIGN_DOWN(index, folio_nr_pages(folio));

virt/kvm/guest_memfd.c

108

return __kvm_gmem_prepare_folio(kvm, slot, index, folio);

virt/kvm/guest_memfd.c

120

static struct folio *kvm_gmem_get_folio(struct inode *inode, pgoff_t index)

virt/kvm/guest_memfd.c

124

struct folio *folio;

virt/kvm/guest_memfd.c

130

folio = filemap_lock_folio(inode->i_mapping, index);

virt/kvm/guest_memfd.c

131

if (!IS_ERR(folio))

virt/kvm/guest_memfd.c

132

return folio;

virt/kvm/guest_memfd.c

135

folio = __filemap_get_folio_mpol(inode->i_mapping, index,

virt/kvm/guest_memfd.c

147

WARN_ON_ONCE(!IS_ERR(folio) && folio_order(folio));

virt/kvm/guest_memfd.c

149

return folio;

virt/kvm/guest_memfd.c

269

struct folio *folio;

virt/kvm/guest_memfd.c

276

folio = kvm_gmem_get_folio(inode, index);

virt/kvm/guest_memfd.c

277

if (IS_ERR(folio)) {

virt/kvm/guest_memfd.c

278

r = PTR_ERR(folio);

virt/kvm/guest_memfd.c

282

index = folio_next_index(folio);

virt/kvm/guest_memfd.c

284

folio_unlock(folio);

virt/kvm/guest_memfd.c

285

folio_put(folio);

virt/kvm/guest_memfd.c

394

struct folio *folio;

virt/kvm/guest_memfd.c

403

folio = kvm_gmem_get_folio(inode, vmf->pgoff);

virt/kvm/guest_memfd.c

404

if (IS_ERR(folio)) {

virt/kvm/guest_memfd.c

405

if (PTR_ERR(folio) == -EAGAIN)

virt/kvm/guest_memfd.c

408

return vmf_error(PTR_ERR(folio));

virt/kvm/guest_memfd.c

411

if (WARN_ON_ONCE(folio_test_large(folio))) {

virt/kvm/guest_memfd.c

416

if (!folio_test_uptodate(folio)) {

virt/kvm/guest_memfd.c

417

clear_highpage(folio_page(folio, 0));

virt/kvm/guest_memfd.c

418

folio_mark_uptodate(folio);

virt/kvm/guest_memfd.c

421

vmf->page = folio_file_page(folio, vmf->pgoff);

virt/kvm/guest_memfd.c

425

folio_unlock(folio);

virt/kvm/guest_memfd.c

426

folio_put(folio);

virt/kvm/guest_memfd.c

492

struct folio *dst, struct folio *src,

virt/kvm/guest_memfd.c

499

static int kvm_gmem_error_folio(struct address_space *mapping, struct folio *folio)

virt/kvm/guest_memfd.c

505

start = folio->index;

virt/kvm/guest_memfd.c

506

end = start + folio_nr_pages(folio);

virt/kvm/guest_memfd.c

527

static void kvm_gmem_free_folio(struct folio *folio)

virt/kvm/guest_memfd.c

529

struct page *page = folio_page(folio, 0);

virt/kvm/guest_memfd.c

53

static inline kvm_pfn_t folio_file_pfn(struct folio *folio, pgoff_t index)

virt/kvm/guest_memfd.c

531

int order = folio_order(folio);

virt/kvm/guest_memfd.c

55

return folio_pfn(folio) + (index & (folio_nr_pages(folio) - 1));

virt/kvm/guest_memfd.c

64

pgoff_t index, struct folio *folio)

virt/kvm/guest_memfd.c

67

kvm_pfn_t pfn = folio_file_pfn(folio, index);

virt/kvm/guest_memfd.c

69

int rc = kvm_arch_gmem_prepare(kvm, gfn, pfn, folio_order(folio));

virt/kvm/guest_memfd.c

754

static struct folio *__kvm_gmem_get_pfn(struct file *file,

virt/kvm/guest_memfd.c

761

struct folio *folio;

virt/kvm/guest_memfd.c

773

folio = kvm_gmem_get_folio(file_inode(file), index);

virt/kvm/guest_memfd.c

774

if (IS_ERR(folio))

virt/kvm/guest_memfd.c

775

return folio;

virt/kvm/guest_memfd.c

777

if (folio_test_hwpoison(folio)) {

virt/kvm/guest_memfd.c

778

folio_unlock(folio);

virt/kvm/guest_memfd.c

779

folio_put(folio);

virt/kvm/guest_memfd.c

783

*pfn = folio_file_pfn(folio, index);

virt/kvm/guest_memfd.c

787

return folio;

virt/kvm/guest_memfd.c

795

struct folio *folio;

virt/kvm/guest_memfd.c

802

folio = __kvm_gmem_get_pfn(file, slot, index, pfn, max_order);

virt/kvm/guest_memfd.c

803

if (IS_ERR(folio))

virt/kvm/guest_memfd.c

804

return PTR_ERR(folio);

virt/kvm/guest_memfd.c

806

if (!folio_test_uptodate(folio)) {

virt/kvm/guest_memfd.c

807

clear_highpage(folio_page(folio, 0));

virt/kvm/guest_memfd.c

808

folio_mark_uptodate(folio);

virt/kvm/guest_memfd.c

811

r = kvm_gmem_prepare_folio(kvm, slot, gfn, folio);

virt/kvm/guest_memfd.c

813

folio_unlock(folio);

virt/kvm/guest_memfd.c

816

*page = folio_file_page(folio, index);

virt/kvm/guest_memfd.c

818

folio_put(folio);

virt/kvm/guest_memfd.c

831

struct folio *folio;

virt/kvm/guest_memfd.c

837

folio = __kvm_gmem_get_pfn(file, slot, index, &pfn, NULL);

virt/kvm/guest_memfd.c

838

if (IS_ERR(folio)) {

virt/kvm/guest_memfd.c

839

ret = PTR_ERR(folio);

virt/kvm/guest_memfd.c

843

folio_unlock(folio);

virt/kvm/guest_memfd.c

854

folio_mark_uptodate(folio);

virt/kvm/guest_memfd.c

857

folio_put(folio);

virt/kvm/guest_memfd.c

87

gfn_t gfn, struct folio *folio)