dax.c 47.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9 10 11
/*
 * fs/dax.c - Direct Access filesystem code
 * Copyright (c) 2013-2014 Intel Corporation
 * Author: Matthew Wilcox <matthew.r.wilcox@intel.com>
 * Author: Ross Zwisler <ross.zwisler@linux.intel.com>
 */

#include <linux/atomic.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
12
#include <linux/dax.h>
13
#include <linux/fs.h>
14 15 16
#include <linux/highmem.h>
#include <linux/memcontrol.h>
#include <linux/mm.h>
17
#include <linux/mutex.h>
18
#include <linux/pagevec.h>
19
#include <linux/sched.h>
20
#include <linux/sched/signal.h>
21
#include <linux/uio.h>
22
#include <linux/vmstat.h>
23
#include <linux/pfn_t.h>
24
#include <linux/sizes.h>
25
#include <linux/mmu_notifier.h>
26
#include <linux/iomap.h>
27
#include <linux/rmap.h>
28
#include <asm/pgalloc.h>
29

30 31 32
#define CREATE_TRACE_POINTS
#include <trace/events/fs_dax.h>

33 34 35 36 37 38 39 40 41 42 43
static inline unsigned int pe_order(enum page_entry_size pe_size)
{
	if (pe_size == PE_SIZE_PTE)
		return PAGE_SHIFT - PAGE_SHIFT;
	if (pe_size == PE_SIZE_PMD)
		return PMD_SHIFT - PAGE_SHIFT;
	if (pe_size == PE_SIZE_PUD)
		return PUD_SHIFT - PAGE_SHIFT;
	return ~0;
}

Jan Kara's avatar
Jan Kara committed
44 45 46 47
/* We choose 4096 entries - same as per-zone page wait tables */
#define DAX_WAIT_TABLE_BITS 12
#define DAX_WAIT_TABLE_ENTRIES (1 << DAX_WAIT_TABLE_BITS)

48 49
/* The 'colour' (ie low bits) within a PMD of a page offset.  */
#define PG_PMD_COLOUR	((PMD_SIZE >> PAGE_SHIFT) - 1)
50
#define PG_PMD_NR	(PMD_SIZE >> PAGE_SHIFT)
51

52 53 54
/* The order of a PMD entry */
#define PMD_ORDER	(PMD_SHIFT - PAGE_SHIFT)

55
static wait_queue_head_t wait_table[DAX_WAIT_TABLE_ENTRIES];
Jan Kara's avatar
Jan Kara committed
56 57 58 59 60 61 62 63 64 65 66

static int __init init_dax_wait_table(void)
{
	int i;

	for (i = 0; i < DAX_WAIT_TABLE_ENTRIES; i++)
		init_waitqueue_head(wait_table + i);
	return 0;
}
fs_initcall(init_dax_wait_table);

67
/*
68 69 70 71
 * DAX pagecache entries use XArray value entries so they can't be mistaken
 * for pages.  We use one bit for locking, one bit for the entry size (PMD)
 * and two more to tell us if the entry is a zero page or an empty entry that
 * is just used for locking.  In total four special bits.
72 73 74 75 76
 *
 * If the PMD bit isn't set the entry has size PAGE_SIZE, and if the ZERO_PAGE
 * and EMPTY bits aren't set the entry is a normal DAX entry with a filesystem
 * block allocation.
 */
77 78 79 80 81
#define DAX_SHIFT	(4)
#define DAX_LOCKED	(1UL << 0)
#define DAX_PMD		(1UL << 1)
#define DAX_ZERO_PAGE	(1UL << 2)
#define DAX_EMPTY	(1UL << 3)
82

83
static unsigned long dax_to_pfn(void *entry)
84
{
85
	return xa_to_value(entry) >> DAX_SHIFT;
86 87
}

88 89 90 91 92
static void *dax_make_entry(pfn_t pfn, unsigned long flags)
{
	return xa_mk_value(flags | (pfn_t_to_pfn(pfn) << DAX_SHIFT));
}

93 94 95 96 97
static bool dax_is_locked(void *entry)
{
	return xa_to_value(entry) & DAX_LOCKED;
}

98
static unsigned int dax_entry_order(void *entry)
99
{
100
	if (xa_to_value(entry) & DAX_PMD)
101
		return PMD_ORDER;
102 103 104
	return 0;
}

105
static unsigned long dax_is_pmd_entry(void *entry)
106
{
107
	return xa_to_value(entry) & DAX_PMD;
108 109
}

110
static bool dax_is_pte_entry(void *entry)
111
{
112
	return !(xa_to_value(entry) & DAX_PMD);
113 114
}

115
static int dax_is_zero_entry(void *entry)
116
{
117
	return xa_to_value(entry) & DAX_ZERO_PAGE;
118 119
}

120
static int dax_is_empty_entry(void *entry)
121
{
122
	return xa_to_value(entry) & DAX_EMPTY;
123 124
}

125 126 127 128 129 130 131 132 133
/*
 * true if the entry that was found is of a smaller order than the entry
 * we were looking for
 */
static bool dax_is_conflict(void *entry)
{
	return entry == XA_RETRY_ENTRY;
}

Jan Kara's avatar
Jan Kara committed
134
/*
135
 * DAX page cache entry locking
Jan Kara's avatar
Jan Kara committed
136 137
 */
struct exceptional_entry_key {
138
	struct xarray *xa;
139
	pgoff_t entry_start;
Jan Kara's avatar
Jan Kara committed
140 141 142
};

struct wait_exceptional_entry_queue {
143
	wait_queue_entry_t wait;
Jan Kara's avatar
Jan Kara committed
144 145 146
	struct exceptional_entry_key key;
};

147 148 149 150 151 152 153 154 155 156
/**
 * enum dax_wake_mode: waitqueue wakeup behaviour
 * @WAKE_ALL: wake all waiters in the waitqueue
 * @WAKE_NEXT: wake only the first waiter in the waitqueue
 */
enum dax_wake_mode {
	WAKE_ALL,
	WAKE_NEXT,
};

157 158
static wait_queue_head_t *dax_entry_waitqueue(struct xa_state *xas,
		void *entry, struct exceptional_entry_key *key)
159 160
{
	unsigned long hash;
161
	unsigned long index = xas->xa_index;
162 163 164 165 166 167

	/*
	 * If 'entry' is a PMD, align the 'index' that we use for the wait
	 * queue to the start of that PMD.  This ensures that all offsets in
	 * the range covered by the PMD map to the same bit lock.
	 */
168
	if (dax_is_pmd_entry(entry))
169
		index &= ~PG_PMD_COLOUR;
170
	key->xa = xas->xa;
171 172
	key->entry_start = index;

173
	hash = hash_long((unsigned long)xas->xa ^ index, DAX_WAIT_TABLE_BITS);
174 175 176
	return wait_table + hash;
}

177 178
static int wake_exceptional_entry_func(wait_queue_entry_t *wait,
		unsigned int mode, int sync, void *keyp)
Jan Kara's avatar
Jan Kara committed
179 180 181 182 183
{
	struct exceptional_entry_key *key = keyp;
	struct wait_exceptional_entry_queue *ewait =
		container_of(wait, struct wait_exceptional_entry_queue, wait);

184
	if (key->xa != ewait->key.xa ||
185
	    key->entry_start != ewait->key.entry_start)
Jan Kara's avatar
Jan Kara committed
186 187 188 189
		return 0;
	return autoremove_wake_function(wait, mode, sync, NULL);
}

190
/*
Matthew Wilcox's avatar
Matthew Wilcox committed
191 192 193
 * @entry may no longer be the entry at the index in the mapping.
 * The important information it's conveying is whether the entry at
 * this index used to be a PMD entry.
194
 */
195 196
static void dax_wake_entry(struct xa_state *xas, void *entry,
			   enum dax_wake_mode mode)
197 198 199 200
{
	struct exceptional_entry_key key;
	wait_queue_head_t *wq;

201
	wq = dax_entry_waitqueue(xas, entry, &key);
202 203 204

	/*
	 * Checking for locked entry and prepare_to_wait_exclusive() happens
Matthew Wilcox's avatar
Matthew Wilcox committed
205
	 * under the i_pages lock, ditto for entry handling in our callers.
206 207 208 209
	 * So at this point all tasks that could have seen our entry locked
	 * must be in the waitqueue and the following check will see them.
	 */
	if (waitqueue_active(wq))
210
		__wake_up(wq, TASK_NORMAL, mode == WAKE_ALL ? 0 : 1, &key);
211 212
}

213 214 215 216
/*
 * Look up entry in page cache, wait for it to become unlocked if it
 * is a DAX entry and return it.  The caller must subsequently call
 * put_unlocked_entry() if it did not lock the entry or dax_unlock_entry()
217 218 219
 * if it did.  The entry returned may have a larger order than @order.
 * If @order is larger than the order of the entry found in i_pages, this
 * function returns a dax_is_conflict entry.
220 221 222
 *
 * Must be called with the i_pages lock held.
 */
223
static void *get_unlocked_entry(struct xa_state *xas, unsigned int order)
224 225 226 227 228 229 230 231 232
{
	void *entry;
	struct wait_exceptional_entry_queue ewait;
	wait_queue_head_t *wq;

	init_wait(&ewait.wait);
	ewait.wait.func = wake_exceptional_entry_func;

	for (;;) {
Matthew Wilcox's avatar
Matthew Wilcox committed
233
		entry = xas_find_conflict(xas);
234 235
		if (!entry || WARN_ON_ONCE(!xa_is_value(entry)))
			return entry;
236 237
		if (dax_entry_order(entry) < order)
			return XA_RETRY_ENTRY;
238
		if (!dax_is_locked(entry))
239 240
			return entry;

241
		wq = dax_entry_waitqueue(xas, entry, &ewait.key);
242 243 244 245 246 247 248 249 250 251
		prepare_to_wait_exclusive(wq, &ewait.wait,
					  TASK_UNINTERRUPTIBLE);
		xas_unlock_irq(xas);
		xas_reset(xas);
		schedule();
		finish_wait(wq, &ewait.wait);
		xas_lock_irq(xas);
	}
}

252 253 254 255 256 257 258 259 260 261 262 263 264 265
/*
 * The only thing keeping the address space around is the i_pages lock
 * (it's cycled in clear_inode() after removing the entries from i_pages)
 * After we call xas_unlock_irq(), we cannot touch xas->xa.
 */
static void wait_entry_unlocked(struct xa_state *xas, void *entry)
{
	struct wait_exceptional_entry_queue ewait;
	wait_queue_head_t *wq;

	init_wait(&ewait.wait);
	ewait.wait.func = wake_exceptional_entry_func;

	wq = dax_entry_waitqueue(xas, entry, &ewait.key);
266 267 268 269 270 271 272
	/*
	 * Unlike get_unlocked_entry() there is no guarantee that this
	 * path ever successfully retrieves an unlocked entry before an
	 * inode dies. Perform a non-exclusive wait in case this path
	 * never successfully performs its own wake up.
	 */
	prepare_to_wait(wq, &ewait.wait, TASK_UNINTERRUPTIBLE);
273 274 275 276 277
	xas_unlock_irq(xas);
	schedule();
	finish_wait(wq, &ewait.wait);
}

278 279
static void put_unlocked_entry(struct xa_state *xas, void *entry,
			       enum dax_wake_mode mode)
280
{
281
	if (entry && !dax_is_conflict(entry))
282
		dax_wake_entry(xas, entry, mode);
283 284 285 286 287 288 289 290 291 292 293
}

/*
 * We used the xa_state to get the entry, but then we locked the entry and
 * dropped the xa_lock, so we know the xa_state is stale and must be reset
 * before use.
 */
static void dax_unlock_entry(struct xa_state *xas, void *entry)
{
	void *old;

294
	BUG_ON(dax_is_locked(entry));
295 296 297 298 299
	xas_reset(xas);
	xas_lock_irq(xas);
	old = xas_store(xas, entry);
	xas_unlock_irq(xas);
	BUG_ON(!dax_is_locked(old));
300
	dax_wake_entry(xas, entry, WAKE_NEXT);
301 302 303 304 305 306 307 308 309 310 311
}

/*
 * Return: The entry stored at this location before it was locked.
 */
static void *dax_lock_entry(struct xa_state *xas, void *entry)
{
	unsigned long v = xa_to_value(entry);
	return xas_store(xas, xa_mk_value(v | DAX_LOCKED));
}

312 313 314 315 316 317 318 319 320 321 322 323
static unsigned long dax_entry_size(void *entry)
{
	if (dax_is_zero_entry(entry))
		return 0;
	else if (dax_is_empty_entry(entry))
		return 0;
	else if (dax_is_pmd_entry(entry))
		return PMD_SIZE;
	else
		return PAGE_SIZE;
}

324
static unsigned long dax_end_pfn(void *entry)
325
{
326
	return dax_to_pfn(entry) + dax_entry_size(entry) / PAGE_SIZE;
327 328 329 330 331 332 333
}

/*
 * Iterate through all mapped pfns represented by an entry, i.e. skip
 * 'empty' and 'zero' entries.
 */
#define for_each_mapped_pfn(entry, pfn) \
334 335
	for (pfn = dax_to_pfn(entry); \
			pfn < dax_end_pfn(entry); pfn++)
336

337 338 339 340 341
static inline bool dax_mapping_is_cow(struct address_space *mapping)
{
	return (unsigned long)mapping == PAGE_MAPPING_DAX_COW;
}

342
/*
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
 * Set the page->mapping with FS_DAX_MAPPING_COW flag, increase the refcount.
 */
static inline void dax_mapping_set_cow(struct page *page)
{
	if ((uintptr_t)page->mapping != PAGE_MAPPING_DAX_COW) {
		/*
		 * Reset the index if the page was already mapped
		 * regularly before.
		 */
		if (page->mapping)
			page->index = 1;
		page->mapping = (void *)PAGE_MAPPING_DAX_COW;
	}
	page->index++;
}

/*
 * When it is called in dax_insert_entry(), the cow flag will indicate that
 * whether this entry is shared by multiple files.  If so, set the page->mapping
 * FS_DAX_MAPPING_COW, and use page->index as refcount.
363 364
 */
static void dax_associate_entry(void *entry, struct address_space *mapping,
365
		struct vm_area_struct *vma, unsigned long address, bool cow)
366
{
367 368
	unsigned long size = dax_entry_size(entry), pfn, index;
	int i = 0;
369 370 371 372

	if (IS_ENABLED(CONFIG_FS_DAX_LIMITED))
		return;

373
	index = linear_page_index(vma, address & ~(size - 1));
374 375 376
	for_each_mapped_pfn(entry, pfn) {
		struct page *page = pfn_to_page(pfn);

377 378 379 380 381 382 383
		if (cow) {
			dax_mapping_set_cow(page);
		} else {
			WARN_ON_ONCE(page->mapping);
			page->mapping = mapping;
			page->index = index + i++;
		}
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	}
}

static void dax_disassociate_entry(void *entry, struct address_space *mapping,
		bool trunc)
{
	unsigned long pfn;

	if (IS_ENABLED(CONFIG_FS_DAX_LIMITED))
		return;

	for_each_mapped_pfn(entry, pfn) {
		struct page *page = pfn_to_page(pfn);

		WARN_ON_ONCE(trunc && page_ref_count(page) > 1);
399 400 401 402 403 404
		if (dax_mapping_is_cow(page->mapping)) {
			/* keep the CoW flag if this page is still shared */
			if (page->index-- > 0)
				continue;
		} else
			WARN_ON_ONCE(page->mapping && page->mapping != mapping);
405
		page->mapping = NULL;
406
		page->index = 0;
407 408 409
	}
}

410 411 412 413 414 415 416 417 418 419 420 421 422
static struct page *dax_busy_page(void *entry)
{
	unsigned long pfn;

	for_each_mapped_pfn(entry, pfn) {
		struct page *page = pfn_to_page(pfn);

		if (page_ref_count(page) > 1)
			return page;
	}
	return NULL;
}

423
/*
424
 * dax_lock_page - Lock the DAX entry corresponding to a page
425 426 427
 * @page: The page whose entry we want to lock
 *
 * Context: Process context.
428 429
 * Return: A cookie to pass to dax_unlock_page() or 0 if the entry could
 * not be locked.
430
 */
431
dax_entry_t dax_lock_page(struct page *page)
432
{
433 434
	XA_STATE(xas, NULL, 0);
	void *entry;
435

436 437
	/* Ensure page->mapping isn't freed while we look at it */
	rcu_read_lock();
438
	for (;;) {
439
		struct address_space *mapping = READ_ONCE(page->mapping);
440

441
		entry = NULL;
442
		if (!mapping || !dax_mapping(mapping))
443
			break;
444 445 446 447 448 449 450 451

		/*
		 * In the device-dax case there's no need to lock, a
		 * struct dev_pagemap pin is sufficient to keep the
		 * inode alive, and we assume we have dev_pagemap pin
		 * otherwise we would not have a valid pfn_to_page()
		 * translation.
		 */
452
		entry = (void *)~0UL;
453
		if (S_ISCHR(mapping->host->i_mode))
454
			break;
455

456 457
		xas.xa = &mapping->i_pages;
		xas_lock_irq(&xas);
458
		if (mapping != page->mapping) {
459
			xas_unlock_irq(&xas);
460 461
			continue;
		}
462 463 464
		xas_set(&xas, page->index);
		entry = xas_load(&xas);
		if (dax_is_locked(entry)) {
465
			rcu_read_unlock();
466
			wait_entry_unlocked(&xas, entry);
467
			rcu_read_lock();
468
			continue;
469
		}
470 471
		dax_lock_entry(&xas, entry);
		xas_unlock_irq(&xas);
472
		break;
473
	}
474
	rcu_read_unlock();
475
	return (dax_entry_t)entry;
476 477
}

478
void dax_unlock_page(struct page *page, dax_entry_t cookie)
479 480
{
	struct address_space *mapping = page->mapping;
481
	XA_STATE(xas, &mapping->i_pages, page->index);
482

483
	if (S_ISCHR(mapping->host->i_mode))
484 485
		return;

486
	dax_unlock_entry(&xas, (void *)cookie);
487 488
}

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
/*
 * dax_lock_mapping_entry - Lock the DAX entry corresponding to a mapping
 * @mapping: the file's mapping whose entry we want to lock
 * @index: the offset within this file
 * @page: output the dax page corresponding to this dax entry
 *
 * Return: A cookie to pass to dax_unlock_mapping_entry() or 0 if the entry
 * could not be locked.
 */
dax_entry_t dax_lock_mapping_entry(struct address_space *mapping, pgoff_t index,
		struct page **page)
{
	XA_STATE(xas, NULL, 0);
	void *entry;

	rcu_read_lock();
	for (;;) {
		entry = NULL;
		if (!dax_mapping(mapping))
			break;

		xas.xa = &mapping->i_pages;
		xas_lock_irq(&xas);
		xas_set(&xas, index);
		entry = xas_load(&xas);
		if (dax_is_locked(entry)) {
			rcu_read_unlock();
			wait_entry_unlocked(&xas, entry);
			rcu_read_lock();
			continue;
		}
		if (!entry ||
		    dax_is_zero_entry(entry) || dax_is_empty_entry(entry)) {
			/*
			 * Because we are looking for entry from file's mapping
			 * and index, so the entry may not be inserted for now,
			 * or even a zero/empty entry.  We don't think this is
			 * an error case.  So, return a special value and do
			 * not output @page.
			 */
			entry = (void *)~0UL;
		} else {
			*page = pfn_to_page(dax_to_pfn(entry));
			dax_lock_entry(&xas, entry);
		}
		xas_unlock_irq(&xas);
		break;
	}
	rcu_read_unlock();
	return (dax_entry_t)entry;
}

void dax_unlock_mapping_entry(struct address_space *mapping, pgoff_t index,
		dax_entry_t cookie)
{
	XA_STATE(xas, &mapping->i_pages, index);

	if (cookie == ~0UL)
		return;

	dax_unlock_entry(&xas, (void *)cookie);
}

Jan Kara's avatar
Jan Kara committed
552
/*
553 554 555
 * Find page cache entry at given index. If it is a DAX entry, return it
 * with the entry locked. If the page cache doesn't contain an entry at
 * that index, add a locked empty entry.
Jan Kara's avatar
Jan Kara committed
556
 *
557
 * When requesting an entry with size DAX_PMD, grab_mapping_entry() will
558 559 560
 * either return that locked entry or will return VM_FAULT_FALLBACK.
 * This will happen if there are any PTE entries within the PMD range
 * that we are requesting.
561
 *
562 563 564 565 566 567
 * We always favor PTE entries over PMD entries. There isn't a flow where we
 * evict PTE entries in order to 'upgrade' them to a PMD entry.  A PMD
 * insertion will fail if it finds any PTE entries already in the tree, and a
 * PTE insertion will cause an existing PMD entry to be unmapped and
 * downgraded to PTE entries.  This happens for both PMD zero pages as
 * well as PMD empty entries.
568
 *
569 570 571
 * The exception to this downgrade path is for PMD entries that have
 * real storage backing them.  We will leave these real PMD entries in
 * the tree, and PTE writes will simply dirty the entire PMD entry.
572
 *
Jan Kara's avatar
Jan Kara committed
573 574 575
 * Note: Unlike filemap_fault() we don't honor FAULT_FLAG_RETRY flags. For
 * persistent memory the benefit is doubtful. We can add that later if we can
 * show it helps.
576 577 578 579
 *
 * On error, this function does not return an ERR_PTR.  Instead it returns
 * a VM_FAULT code, encoded as an xarray internal entry.  The ERR_PTR values
 * overlap with xarray value entries.
Jan Kara's avatar
Jan Kara committed
580
 */
581
static void *grab_mapping_entry(struct xa_state *xas,
582
		struct address_space *mapping, unsigned int order)
Jan Kara's avatar
Jan Kara committed
583
{
584
	unsigned long index = xas->xa_index;
585
	bool pmd_downgrade;	/* splitting PMD entry into PTE entries? */
586
	void *entry;
587

588
retry:
589
	pmd_downgrade = false;
590
	xas_lock_irq(xas);
591
	entry = get_unlocked_entry(xas, order);
592

593
	if (entry) {
594 595
		if (dax_is_conflict(entry))
			goto fallback;
Matthew Wilcox's avatar
Matthew Wilcox committed
596
		if (!xa_is_value(entry)) {
597
			xas_set_err(xas, -EIO);
598 599 600
			goto out_unlock;
		}

601
		if (order == 0) {
602
			if (dax_is_pmd_entry(entry) &&
603 604 605 606 607 608 609
			    (dax_is_zero_entry(entry) ||
			     dax_is_empty_entry(entry))) {
				pmd_downgrade = true;
			}
		}
	}

610 611 612 613 614 615
	if (pmd_downgrade) {
		/*
		 * Make sure 'entry' remains valid while we drop
		 * the i_pages lock.
		 */
		dax_lock_entry(xas, entry);
616 617 618 619 620 621

		/*
		 * Besides huge zero pages the only other thing that gets
		 * downgraded are empty entries which don't need to be
		 * unmapped.
		 */
622 623 624 625 626 627 628
		if (dax_is_zero_entry(entry)) {
			xas_unlock_irq(xas);
			unmap_mapping_pages(mapping,
					xas->xa_index & ~PG_PMD_COLOUR,
					PG_PMD_NR, false);
			xas_reset(xas);
			xas_lock_irq(xas);
629 630
		}

631 632
		dax_disassociate_entry(entry, mapping, false);
		xas_store(xas, NULL);	/* undo the PMD join */
633
		dax_wake_entry(xas, entry, WAKE_ALL);
634
		mapping->nrpages -= PG_PMD_NR;
635 636 637
		entry = NULL;
		xas_set(xas, index);
	}
638

639 640 641
	if (entry) {
		dax_lock_entry(xas, entry);
	} else {
642 643 644 645 646
		unsigned long flags = DAX_EMPTY;

		if (order > 0)
			flags |= DAX_PMD;
		entry = dax_make_entry(pfn_to_pfn_t(0), flags);
647 648 649
		dax_lock_entry(xas, entry);
		if (xas_error(xas))
			goto out_unlock;
650
		mapping->nrpages += 1UL << order;
Jan Kara's avatar
Jan Kara committed
651
	}
652 653 654 655 656 657 658 659 660

out_unlock:
	xas_unlock_irq(xas);
	if (xas_nomem(xas, mapping_gfp_mask(mapping) & ~__GFP_HIGHMEM))
		goto retry;
	if (xas->xa_node == XA_ERROR(-ENOMEM))
		return xa_mk_internal(VM_FAULT_OOM);
	if (xas_error(xas))
		return xa_mk_internal(VM_FAULT_SIGBUS);
661
	return entry;
662 663 664
fallback:
	xas_unlock_irq(xas);
	return xa_mk_internal(VM_FAULT_FALLBACK);
Jan Kara's avatar
Jan Kara committed
665 666
}

667
/**
668
 * dax_layout_busy_page_range - find first pinned page in @mapping
669
 * @mapping: address space to scan for a page with ref count > 1
670 671 672
 * @start: Starting offset. Page containing 'start' is included.
 * @end: End offset. Page containing 'end' is included. If 'end' is LLONG_MAX,
 *       pages from 'start' till the end of file are included.
673 674 675 676 677 678 679 680 681 682 683 684
 *
 * DAX requires ZONE_DEVICE mapped pages. These pages are never
 * 'onlined' to the page allocator so they are considered idle when
 * page->count == 1. A filesystem uses this interface to determine if
 * any page in the mapping is busy, i.e. for DMA, or other
 * get_user_pages() usages.
 *
 * It is expected that the filesystem is holding locks to block the
 * establishment of new mappings in this address_space. I.e. it expects
 * to be able to run unmap_mapping_range() and subsequently not race
 * mapping_mapped() becoming true.
 */
685 686
struct page *dax_layout_busy_page_range(struct address_space *mapping,
					loff_t start, loff_t end)
687
{
688 689
	void *entry;
	unsigned int scanned = 0;
690
	struct page *page = NULL;
691 692 693
	pgoff_t start_idx = start >> PAGE_SHIFT;
	pgoff_t end_idx;
	XA_STATE(xas, &mapping->i_pages, start_idx);
694 695 696 697 698 699 700 701 702 703

	/*
	 * In the 'limited' case get_user_pages() for dax is disabled.
	 */
	if (IS_ENABLED(CONFIG_FS_DAX_LIMITED))
		return NULL;

	if (!dax_mapping(mapping) || !mapping_mapped(mapping))
		return NULL;

704 705 706 707 708
	/* If end == LLONG_MAX, all pages from start to till end of file */
	if (end == LLONG_MAX)
		end_idx = ULONG_MAX;
	else
		end_idx = end >> PAGE_SHIFT;
709 710
	/*
	 * If we race get_user_pages_fast() here either we'll see the
711
	 * elevated page count in the iteration and wait, or
712 713 714 715
	 * get_user_pages_fast() will see that the page it took a reference
	 * against is no longer mapped in the page tables and bail to the
	 * get_user_pages() slow path.  The slow path is protected by
	 * pte_lock() and pmd_lock(). New references are not taken without
716
	 * holding those locks, and unmap_mapping_pages() will not zero the
717 718 719 720
	 * pte or pmd without holding the respective lock, so we are
	 * guaranteed to either see new references or prevent new
	 * references from being established.
	 */
721
	unmap_mapping_pages(mapping, start_idx, end_idx - start_idx + 1, 0);
722

723
	xas_lock_irq(&xas);
724
	xas_for_each(&xas, entry, end_idx) {
725 726 727
		if (WARN_ON_ONCE(!xa_is_value(entry)))
			continue;
		if (unlikely(dax_is_locked(entry)))
728
			entry = get_unlocked_entry(&xas, 0);
729 730
		if (entry)
			page = dax_busy_page(entry);
731
		put_unlocked_entry(&xas, entry, WAKE_NEXT);
732 733
		if (page)
			break;
734 735 736 737 738 739 740
		if (++scanned % XA_CHECK_SCHED)
			continue;

		xas_pause(&xas);
		xas_unlock_irq(&xas);
		cond_resched();
		xas_lock_irq(&xas);
741
	}
742
	xas_unlock_irq(&xas);
743 744
	return page;
}
745 746 747 748 749 750
EXPORT_SYMBOL_GPL(dax_layout_busy_page_range);

struct page *dax_layout_busy_page(struct address_space *mapping)
{
	return dax_layout_busy_page_range(mapping, 0, LLONG_MAX);
}
751 752
EXPORT_SYMBOL_GPL(dax_layout_busy_page);

753
static int __dax_invalidate_entry(struct address_space *mapping,
754 755
					  pgoff_t index, bool trunc)
{
756
	XA_STATE(xas, &mapping->i_pages, index);
757 758 759
	int ret = 0;
	void *entry;

760
	xas_lock_irq(&xas);
761
	entry = get_unlocked_entry(&xas, 0);
762
	if (!entry || WARN_ON_ONCE(!xa_is_value(entry)))
763 764
		goto out;
	if (!trunc &&
765 766
	    (xas_get_mark(&xas, PAGECACHE_TAG_DIRTY) ||
	     xas_get_mark(&xas, PAGECACHE_TAG_TOWRITE)))
767
		goto out;
768
	dax_disassociate_entry(entry, mapping, trunc);
769
	xas_store(&xas, NULL);
770
	mapping->nrpages -= 1UL << dax_entry_order(entry);
771 772
	ret = 1;
out:
773
	put_unlocked_entry(&xas, entry, WAKE_ALL);
774
	xas_unlock_irq(&xas);
775 776
	return ret;
}
777

Jan Kara's avatar
Jan Kara committed
778
/*
779 780
 * Delete DAX entry at @index from @mapping.  Wait for it
 * to be unlocked before deleting it.
Jan Kara's avatar
Jan Kara committed
781 782 783
 */
int dax_delete_mapping_entry(struct address_space *mapping, pgoff_t index)
{
784
	int ret = __dax_invalidate_entry(mapping, index, true);
Jan Kara's avatar
Jan Kara committed
785 786 787 788

	/*
	 * This gets called from truncate / punch_hole path. As such, the caller
	 * must hold locks protecting against concurrent modifications of the
789
	 * page cache (usually fs-private i_mmap_sem for writing). Since the
790
	 * caller has seen a DAX entry for this index, we better find it
Jan Kara's avatar
Jan Kara committed
791 792
	 * at that index as well...
	 */
793 794 795 796 797
	WARN_ON_ONCE(!ret);
	return ret;
}

/*
798
 * Invalidate DAX entry if it is clean.
799 800 801 802
 */
int dax_invalidate_mapping_entry_sync(struct address_space *mapping,
				      pgoff_t index)
{
803
	return __dax_invalidate_entry(mapping, index, false);
Jan Kara's avatar
Jan Kara committed
804 805
}

806
static pgoff_t dax_iomap_pgoff(const struct iomap *iomap, loff_t pos)
807
{
808
	return PHYS_PFN(iomap->addr + (pos & PAGE_MASK) - iomap->offset);
809 810 811 812
}

static int copy_cow_page_dax(struct vm_fault *vmf, const struct iomap_iter *iter)
{
813
	pgoff_t pgoff = dax_iomap_pgoff(&iter->iomap, iter->pos);
814 815 816 817 818
	void *vto, *kaddr;
	long rc;
	int id;

	id = dax_read_lock();
819 820
	rc = dax_direct_access(iter->iomap.dax_dev, pgoff, 1, DAX_ACCESS,
				&kaddr, NULL);
821 822 823 824
	if (rc < 0) {
		dax_read_unlock(id);
		return rc;
	}
825 826
	vto = kmap_atomic(vmf->cow_page);
	copy_user_page(vto, kaddr, vmf->address, vmf->cow_page);
827
	kunmap_atomic(vto);
828
	dax_read_unlock(id);
829 830 831
	return 0;
}

832 833 834 835 836 837 838
/*
 * By this point grab_mapping_entry() has ensured that we have a locked entry
 * of the appropriate size so we don't have to worry about downgrading PMDs to
 * PTEs.  If we happen to be trying to insert a PTE and there is a PMD
 * already in the tree, we will skip the insertion and just dirty the PMD as
 * appropriate.
 */
839 840 841
static void *dax_insert_entry(struct xa_state *xas,
		struct address_space *mapping, struct vm_fault *vmf,
		void *entry, pfn_t pfn, unsigned long flags, bool dirty)
842
{
843
	void *new_entry = dax_make_entry(pfn, flags);
844

845
	if (dirty)
846
		__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
847

848
	if (dax_is_zero_entry(entry) && !(flags & DAX_ZERO_PAGE)) {
849
		unsigned long index = xas->xa_index;
850 851
		/* we are replacing a zero page with block mapping */
		if (dax_is_pmd_entry(entry))
852
			unmap_mapping_pages(mapping, index & ~PG_PMD_COLOUR,
853
					PG_PMD_NR, false);
854
		else /* pte entry */
855
			unmap_mapping_pages(mapping, index, 1, false);
856 857
	}

858 859
	xas_reset(xas);
	xas_lock_irq(xas);
860 861 862
	if (dax_is_zero_entry(entry) || dax_is_empty_entry(entry)) {
		void *old;

863
		dax_disassociate_entry(entry, mapping, false);
864 865
		dax_associate_entry(new_entry, mapping, vmf->vma, vmf->address,
				false);
866
		/*
867
		 * Only swap our new entry into the page cache if the current
868
		 * entry is a zero page or an empty entry.  If a normal PTE or
869
		 * PMD entry is already in the cache, we leave it alone.  This
870 871 872 873
		 * means that if we are trying to insert a PTE and the
		 * existing entry is a PMD, we will just leave the PMD in the
		 * tree and dirty it if necessary.
		 */
874
		old = dax_lock_entry(xas, new_entry);
875 876
		WARN_ON_ONCE(old != xa_mk_value(xa_to_value(entry) |
					DAX_LOCKED));
877
		entry = new_entry;
878 879
	} else {
		xas_load(xas);	/* Walk the xa_state */
880
	}
881

882
	if (dirty)
883
		xas_set_mark(xas, PAGECACHE_TAG_DIRTY);
884

885
	xas_unlock_irq(xas);
886
	return entry;
887 888
}

889 890
static int dax_writeback_one(struct xa_state *xas, struct dax_device *dax_dev,
		struct address_space *mapping, void *entry)
891
{
892
	unsigned long pfn, index, count, end;
893
	long ret = 0;
894
	struct vm_area_struct *vma;
895 896

	/*
897 898
	 * A page got tagged dirty in DAX mapping? Something is seriously
	 * wrong.
899
	 */
900
	if (WARN_ON(!xa_is_value(entry)))
901
		return -EIO;
902

903 904 905
	if (unlikely(dax_is_locked(entry))) {
		void *old_entry = entry;

906
		entry = get_unlocked_entry(xas, 0);
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926

		/* Entry got punched out / reallocated? */
		if (!entry || WARN_ON_ONCE(!xa_is_value(entry)))
			goto put_unlocked;
		/*
		 * Entry got reallocated elsewhere? No need to writeback.
		 * We have to compare pfns as we must not bail out due to
		 * difference in lockbit or entry type.
		 */
		if (dax_to_pfn(old_entry) != dax_to_pfn(entry))
			goto put_unlocked;
		if (WARN_ON_ONCE(dax_is_empty_entry(entry) ||
					dax_is_zero_entry(entry))) {
			ret = -EIO;
			goto put_unlocked;
		}

		/* Another fsync thread may have already done this entry */
		if (!xas_get_mark(xas, PAGECACHE_TAG_TOWRITE))
			goto put_unlocked;
927 928
	}

929
	/* Lock the entry to serialize with page faults */
930 931
	dax_lock_entry(xas, entry);

932 933 934 935
	/*
	 * We can clear the tag now but we have to be careful so that concurrent
	 * dax_writeback_one() calls for the same index cannot finish before we
	 * actually flush the caches. This is achieved as the calls will look
Matthew Wilcox's avatar
Matthew Wilcox committed
936 937
	 * at the entry only under the i_pages lock and once they do that
	 * they will see the entry locked and wait for it to unlock.
938
	 */
939 940
	xas_clear_mark(xas, PAGECACHE_TAG_TOWRITE);
	xas_unlock_irq(xas);
941

942
	/*
943 944 945
	 * If dax_writeback_mapping_range() was given a wbc->range_start
	 * in the middle of a PMD, the 'index' we use needs to be
	 * aligned to the start of the PMD.
946 947
	 * This allows us to flush for PMD_SIZE and not have to worry about
	 * partial PMD writebacks.
948
	 */
949
	pfn = dax_to_pfn(entry);
950 951
	count = 1UL << dax_entry_order(entry);
	index = xas->xa_index & ~(count - 1);
952 953 954 955 956 957 958 959 960
	end = index + count - 1;

	/* Walk all mappings of a given index of a file and writeprotect them */
	i_mmap_lock_read(mapping);
	vma_interval_tree_foreach(vma, &mapping->i_mmap, index, end) {
		pfn_mkclean_range(pfn, count, index, vma);
		cond_resched();
	}
	i_mmap_unlock_read(mapping);
961

962
	dax_flush(dax_dev, page_address(pfn_to_page(pfn)), count * PAGE_SIZE);
963 964 965 966 967 968
	/*
	 * After we have flushed the cache, we can clear the dirty tag. There
	 * cannot be new dirty data in the pfn after the flush has completed as
	 * the pfn mappings are writeprotected and fault waits for mapping
	 * entry lock.
	 */
969 970 971 972
	xas_reset(xas);
	xas_lock_irq(xas);
	xas_store(xas, entry);
	xas_clear_mark(xas, PAGECACHE_TAG_DIRTY);
973
	dax_wake_entry(xas, entry, WAKE_NEXT);
974

975
	trace_dax_writeback_one(mapping->host, index, count);
976 977
	return ret;

978
 put_unlocked:
979
	put_unlocked_entry(xas, entry, WAKE_NEXT);
980 981 982 983 984 985 986 987
	return ret;
}

/*
 * Flush the mapping to the persistent domain within the byte range of [start,
 * end]. This is required by data integrity operations to ensure file data is
 * on persistent storage prior to completion of the operation.
 */
988
int dax_writeback_mapping_range(struct address_space *mapping,
989
		struct dax_device *dax_dev, struct writeback_control *wbc)
990
{
991
	XA_STATE(xas, &mapping->i_pages, wbc->range_start >> PAGE_SHIFT);
992
	struct inode *inode = mapping->host;
993 994 995 996
	pgoff_t end_index = wbc->range_end >> PAGE_SHIFT;
	void *entry;
	int ret = 0;
	unsigned int scanned = 0;
997 998 999 1000

	if (WARN_ON_ONCE(inode->i_blkbits != PAGE_SHIFT))
		return -EIO;

1001
	if (mapping_empty(mapping) || wbc->sync_mode != WB_SYNC_ALL)
1002 1003
		return 0;

1004
	trace_dax_writeback_range(inode, xas.xa_index, end_index);
1005

1006
	tag_pages_for_writeback(mapping, xas.xa_index, end_index);
1007

1008 1009 1010 1011 1012
	xas_lock_irq(&xas);
	xas_for_each_marked(&xas, entry, end_index, PAGECACHE_TAG_TOWRITE) {
		ret = dax_writeback_one(&xas, dax_dev, mapping, entry);
		if (ret < 0) {
			mapping_set_error(mapping, ret);
1013 1014
			break;
		}
1015 1016 1017 1018 1019 1020 1021
		if (++scanned % XA_CHECK_SCHED)
			continue;

		xas_pause(&xas);
		xas_unlock_irq(&xas);
		cond_resched();
		xas_lock_irq(&xas);
1022
	}
1023 1024 1025
	xas_unlock_irq(&xas);
	trace_dax_writeback_range_done(inode, xas.xa_index, end_index);
	return ret;
1026 1027 1028
}
EXPORT_SYMBOL_GPL(dax_writeback_mapping_range);

1029 1030
static int dax_iomap_direct_access(const struct iomap *iomap, loff_t pos,
		size_t size, void **kaddr, pfn_t *pfnp)
1031
{
1032
	pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);
1033
	int id, rc = 0;
1034
	long length;
1035

1036
	id = dax_read_lock();
1037
	length = dax_direct_access(iomap->dax_dev, pgoff, PHYS_PFN(size),
1038
				   DAX_ACCESS, kaddr, pfnp);
1039 1040 1041
	if (length < 0) {
		rc = length;
		goto out;
1042
	}
1043 1044
	if (!pfnp)
		goto out_check_addr;
1045 1046 1047 1048 1049 1050 1051 1052 1053
	rc = -EINVAL;
	if (PFN_PHYS(length) < size)
		goto out;
	if (pfn_t_to_pfn(*pfnp) & (PHYS_PFN(size)-1))
		goto out;
	/* For larger pages we need devmap */
	if (length > 1 && !pfn_t_devmap(*pfnp))
		goto out;
	rc = 0;
1054 1055 1056 1057 1058 1059

out_check_addr:
	if (!kaddr)
		goto out;
	if (!*kaddr)
		rc = -EFAULT;
1060
out:
1061
	dax_read_unlock(id);
1062
	return rc;
1063 1064
}

1065
/*
1066 1067 1068 1069 1070
 * The user has performed a load from a hole in the file.  Allocating a new
 * page in the file would cause excessive storage usage for workloads with
 * sparse files.  Instead we insert a read-only mapping of the 4k zero page.
 * If this page is ever written to we will re-fault and change the mapping to
 * point to real DAX storage instead.
1071
 */
1072 1073 1074
static vm_fault_t dax_load_hole(struct xa_state *xas,
		struct address_space *mapping, void **entry,
		struct vm_fault *vmf)
1075 1076
{
	struct inode *inode = mapping->host;
1077
	unsigned long vaddr = vmf->address;
1078 1079
	pfn_t pfn = pfn_to_pfn_t(my_zero_pfn(vaddr));
	vm_fault_t ret;
1080

1081
	*entry = dax_insert_entry(xas, mapping, vmf, *entry, pfn,
1082 1083
			DAX_ZERO_PAGE, false);

1084
	ret = vmf_insert_mixed(vmf->vma, vaddr, pfn);
1085 1086 1087 1088
	trace_dax_load_hole(inode, vmf, ret);
	return ret;
}

1089 1090
#ifdef CONFIG_FS_DAX_PMD
static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf,
1091
		const struct iomap *iomap, void **entry)
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
{
	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
	unsigned long pmd_addr = vmf->address & PMD_MASK;
	struct vm_area_struct *vma = vmf->vma;
	struct inode *inode = mapping->host;
	pgtable_t pgtable = NULL;
	struct page *zero_page;
	spinlock_t *ptl;
	pmd_t pmd_entry;
	pfn_t pfn;

	zero_page = mm_get_huge_zero_page(vmf->vma->vm_mm);

	if (unlikely(!zero_page))
		goto fallback;

	pfn = page_to_pfn_t(zero_page);
	*entry = dax_insert_entry(xas, mapping, vmf, *entry, pfn,
			DAX_PMD | DAX_ZERO_PAGE, false);

	if (arch_needs_pgtable_deposit()) {
		pgtable = pte_alloc_one(vma->vm_mm);
		if (!pgtable)
			return VM_FAULT_OOM;
	}

	ptl = pmd_lock(vmf->vma->vm_mm, vmf->pmd);
	if (!pmd_none(*(vmf->pmd))) {
		spin_unlock(ptl);
		goto fallback;
	}

	if (pgtable) {
		pgtable_trans_huge_deposit(vma->vm_mm, vmf->pmd, pgtable);
		mm_inc_nr_ptes(vma->vm_mm);
	}
	pmd_entry = mk_pmd(zero_page, vmf->vma->vm_page_prot);
	pmd_entry = pmd_mkhuge(pmd_entry);
	set_pmd_at(vmf->vma->vm_mm, pmd_addr, vmf->pmd, pmd_entry);
	spin_unlock(ptl);
	trace_dax_pmd_load_hole(inode, vmf, zero_page, *entry);
	return VM_FAULT_NOPAGE;

fallback:
	if (pgtable)
		pte_free(vma->vm_mm, pgtable);
	trace_dax_pmd_load_hole_fallback(inode, vmf, zero_page, *entry);
	return VM_FAULT_FALLBACK;
}
#else
static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf,
1143
		const struct iomap *iomap, void **entry)
1144 1145 1146 1147 1148
{
	return VM_FAULT_FALLBACK;
}
#endif /* CONFIG_FS_DAX_PMD */

1149 1150 1151 1152 1153 1154
static int dax_memzero(struct dax_device *dax_dev, pgoff_t pgoff,
		unsigned int offset, size_t size)
{
	void *kaddr;
	long ret;

1155
	ret = dax_direct_access(dax_dev, pgoff, 1, DAX_ACCESS, &kaddr, NULL);
1156 1157 1158 1159 1160 1161 1162
	if (ret > 0) {
		memset(kaddr + offset, 0, size);
		dax_flush(dax_dev, kaddr + offset, size);
	}
	return ret;
}

1163
static s64 dax_zero_iter(struct iomap_iter *iter, bool *did_zero)
1164
{
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
	const struct iomap *iomap = &iter->iomap;
	const struct iomap *srcmap = iomap_iter_srcmap(iter);
	loff_t pos = iter->pos;
	u64 length = iomap_length(iter);
	s64 written = 0;

	/* already zeroed?  we're done. */
	if (srcmap->type == IOMAP_HOLE || srcmap->type == IOMAP_UNWRITTEN)
		return length;

	do {
		unsigned offset = offset_in_page(pos);
		unsigned size = min_t(u64, PAGE_SIZE - offset, length);
		pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);
		long rc;
		int id;

		id = dax_read_lock();
		if (IS_ALIGNED(pos, PAGE_SIZE) && size == PAGE_SIZE)
			rc = dax_zero_page_range(iomap->dax_dev, pgoff, 1);
		else
			rc = dax_memzero(iomap->dax_dev, pgoff, offset, size);
		dax_read_unlock(id);
1188

1189 1190 1191 1192 1193 1194 1195 1196
		if (rc < 0)
			return rc;
		pos += size;
		length -= size;
		written += size;
		if (did_zero)
			*did_zero = true;
	} while (length > 0);
1197

1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
	return written;
}

int dax_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,
		const struct iomap_ops *ops)
{
	struct iomap_iter iter = {
		.inode		= inode,
		.pos		= pos,
		.len		= len,
1208
		.flags		= IOMAP_DAX | IOMAP_ZERO,
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
	};
	int ret;

	while ((ret = iomap_iter(&iter, ops)) > 0)
		iter.processed = dax_zero_iter(&iter, did_zero);
	return ret;
}
EXPORT_SYMBOL_GPL(dax_zero_range);

int dax_truncate_page(struct inode *inode, loff_t pos, bool *did_zero,
		const struct iomap_ops *ops)
{
	unsigned int blocksize = i_blocksize(inode);
	unsigned int off = pos & (blocksize - 1);

	/* Block boundary? Nothing to do */
	if (!off)
		return 0;
	return dax_zero_range(inode, pos, blocksize - off, did_zero, ops);
1228
}
1229
EXPORT_SYMBOL_GPL(dax_truncate_page);
1230

1231 1232
static loff_t dax_iomap_iter(const struct iomap_iter *iomi,
		struct iov_iter *iter)
1233
{
1234 1235 1236
	const struct iomap *iomap = &iomi->iomap;
	loff_t length = iomap_length(iomi);
	loff_t pos = iomi->pos;
1237
	struct dax_device *dax_dev = iomap->dax_dev;
1238 1239
	loff_t end = pos + length, done = 0;
	ssize_t ret = 0;
1240
	size_t xfer;
1241
	int id;
1242 1243

	if (iov_iter_rw(iter) == READ) {
1244
		end = min(end, i_size_read(iomi->inode));
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
		if (pos >= end)
			return 0;

		if (iomap->type == IOMAP_HOLE || iomap->type == IOMAP_UNWRITTEN)
			return iov_iter_zero(min(length, end - pos), iter);
	}

	if (WARN_ON_ONCE(iomap->type != IOMAP_MAPPED))
		return -EIO;

1255 1256 1257 1258 1259
	/*
	 * Write can allocate block for an area which has a hole page mapped
	 * into page tables. We have to tear down these mappings so that data
	 * written by write(2) is visible in mmap.
	 */
1260
	if (iomap->flags & IOMAP_F_NEW) {
1261
		invalidate_inode_pages2_range(iomi->inode->i_mapping,
1262 1263 1264 1265
					      pos >> PAGE_SHIFT,
					      (end - 1) >> PAGE_SHIFT);
	}

1266
	id = dax_read_lock();
1267 1268
	while (pos < end) {
		unsigned offset = pos & (PAGE_SIZE - 1);
1269
		const size_t size = ALIGN(length + offset, PAGE_SIZE);
1270
		pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);
1271
		ssize_t map_len;
1272
		bool recovery = false;
1273
		void *kaddr;
1274

1275 1276 1277 1278 1279
		if (fatal_signal_pending(current)) {
			ret = -EINTR;
			break;
		}

1280
		map_len = dax_direct_access(dax_dev, pgoff, PHYS_PFN(size),
1281
				DAX_ACCESS, &kaddr, NULL);
1282 1283 1284 1285 1286 1287 1288
		if (map_len == -EIO && iov_iter_rw(iter) == WRITE) {
			map_len = dax_direct_access(dax_dev, pgoff,
					PHYS_PFN(size), DAX_RECOVERY_WRITE,
					&kaddr, NULL);
			if (map_len > 0)
				recovery = true;
		}
1289 1290 1291 1292 1293
		if (map_len < 0) {
			ret = map_len;
			break;
		}

1294 1295
		map_len = PFN_PHYS(map_len);
		kaddr += offset;
1296 1297 1298 1299
		map_len -= offset;
		if (map_len > end - pos)
			map_len = end - pos;

1300 1301 1302 1303
		if (recovery)
			xfer = dax_recovery_write(dax_dev, pgoff, kaddr,
					map_len, iter);
		else if (iov_iter_rw(iter) == WRITE)
1304
			xfer = dax_copy_from_iter(dax_dev, pgoff, kaddr,
1305
					map_len, iter);
1306
		else
1307
			xfer = dax_copy_to_iter(dax_dev, pgoff, kaddr,
1308
					map_len, iter);
1309

1310 1311 1312 1313 1314 1315 1316 1317
		pos += xfer;
		length -= xfer;
		done += xfer;

		if (xfer == 0)
			ret = -EFAULT;
		if (xfer < map_len)
			break;
1318
	}
1319
	dax_read_unlock(id);
1320 1321 1322 1323 1324

	return done ? done : ret;
}

/**
1325
 * dax_iomap_rw - Perform I/O to a DAX file
1326 1327 1328 1329 1330 1331 1332 1333 1334
 * @iocb:	The control block for this I/O
 * @iter:	The addresses to do I/O from or to
 * @ops:	iomap ops passed from the file system
 *
 * This function performs read and write operations to directly mapped
 * persistent memory.  The callers needs to take care of read/write exclusion
 * and evicting any page cache pages in the region under I/O.
 */
ssize_t
1335
dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,
1336
		const struct iomap_ops *ops)
1337
{
1338 1339 1340 1341
	struct iomap_iter iomi = {
		.inode		= iocb->ki_filp->f_mapping->host,
		.pos		= iocb->ki_pos,
		.len		= iov_iter_count(iter),
1342
		.flags		= IOMAP_DAX,
1343 1344 1345
	};
	loff_t done = 0;
	int ret;
1346

1347
	if (iov_iter_rw(iter) == WRITE) {
1348 1349
		lockdep_assert_held_write(&iomi.inode->i_rwsem);
		iomi.flags |= IOMAP_WRITE;
1350
	} else {
1351
		lockdep_assert_held(&iomi.inode->i_rwsem);
1352
	}
1353

1354
	if (iocb->ki_flags & IOCB_NOWAIT)
1355
		iomi.flags |= IOMAP_NOWAIT;
1356

1357 1358
	while ((ret = iomap_iter(&iomi, ops)) > 0)
		iomi.processed = dax_iomap_iter(&iomi, iter);
1359

1360 1361
	done = iomi.pos - iocb->ki_pos;
	iocb->ki_pos = iomi.pos;
1362 1363
	return done ? done : ret;
}
1364
EXPORT_SYMBOL_GPL(dax_iomap_rw);
1365

1366
static vm_fault_t dax_fault_return(int error)
1367 1368 1369
{
	if (error == 0)
		return VM_FAULT_NOPAGE;
1370
	return vmf_error(error);
1371 1372
}

1373 1374 1375 1376 1377
/*
 * MAP_SYNC on a dax mapping guarantees dirty metadata is
 * flushed on write-faults (non-cow), but not read-faults.
 */
static bool dax_fault_is_synchronous(unsigned long flags,
1378
		struct vm_area_struct *vma, const struct iomap *iomap)
1379 1380 1381 1382 1383
{
	return (flags & IOMAP_WRITE) && (vma->vm_flags & VM_SYNC)
		&& (iomap->flags & IOMAP_F_DIRTY);
}

1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
/*
 * When handling a synchronous page fault and the inode need a fsync, we can
 * insert the PTE/PMD into page tables only after that fsync happened. Skip
 * insertion for now and return the pfn so that caller can insert it after the
 * fsync is done.
 */
static vm_fault_t dax_fault_synchronous_pfnp(pfn_t *pfnp, pfn_t pfn)
{
	if (WARN_ON_ONCE(!pfnp))
		return VM_FAULT_SIGBUS;
	*pfnp = pfn;
	return VM_FAULT_NEEDDSYNC;
}

1398 1399
static vm_fault_t dax_fault_cow_page(struct vm_fault *vmf,
		const struct iomap_iter *iter)
1400 1401 1402 1403
{
	vm_fault_t ret;
	int error = 0;

1404
	switch (iter->iomap.type) {
1405 1406
	case IOMAP_HOLE:
	case IOMAP_UNWRITTEN:
1407
		clear_user_highpage(vmf->cow_page, vmf->address);
1408 1409
		break;
	case IOMAP_MAPPED:
1410
		error = copy_cow_page_dax(vmf, iter);
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
		break;
	default:
		WARN_ON_ONCE(1);
		error = -EIO;
		break;
	}

	if (error)
		return dax_fault_return(error);

	__SetPageUptodate(vmf->cow_page);
	ret = finish_fault(vmf);
	if (!ret)
		return VM_FAULT_DONE_COW;
	return ret;
}

1428
/**
1429
 * dax_fault_iter - Common actor to handle pfn insertion in PTE/PMD fault.
1430
 * @vmf:	vm fault instance
1431
 * @iter:	iomap iter
1432 1433 1434 1435 1436
 * @pfnp:	pfn to be returned
 * @xas:	the dax mapping tree of a file
 * @entry:	an unlocked dax entry to be inserted
 * @pmd:	distinguish whether it is a pmd fault
 */
1437 1438 1439
static vm_fault_t dax_fault_iter(struct vm_fault *vmf,
		const struct iomap_iter *iter, pfn_t *pfnp,
		struct xa_state *xas, void **entry, bool pmd)
1440 1441
{
	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
1442
	const struct iomap *iomap = &iter->iomap;
1443 1444 1445
	size_t size = pmd ? PMD_SIZE : PAGE_SIZE;
	loff_t pos = (loff_t)xas->xa_index << PAGE_SHIFT;
	bool write = vmf->flags & FAULT_FLAG_WRITE;
1446
	bool sync = dax_fault_is_synchronous(iter->flags, vmf->vma, iomap);
1447 1448 1449 1450
	unsigned long entry_flags = pmd ? DAX_PMD : 0;
	int err = 0;
	pfn_t pfn;

1451 1452 1453
	if (!pmd && vmf->cow_page)
		return dax_fault_cow_page(vmf, iter);

1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
	/* if we are reading UNWRITTEN and HOLE, return a hole. */
	if (!write &&
	    (iomap->type == IOMAP_UNWRITTEN || iomap->type == IOMAP_HOLE)) {
		if (!pmd)
			return dax_load_hole(xas, mapping, entry, vmf);
		return dax_pmd_load_hole(xas, vmf, iomap, entry);
	}

	if (iomap->type != IOMAP_MAPPED) {
		WARN_ON_ONCE(1);
		return pmd ? VM_FAULT_FALLBACK : VM_FAULT_SIGBUS;
	}

1467
	err = dax_iomap_direct_access(&iter->iomap, pos, size, NULL, &pfn);
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
	if (err)
		return pmd ? VM_FAULT_FALLBACK : dax_fault_return(err);

	*entry = dax_insert_entry(xas, mapping, vmf, *entry, pfn, entry_flags,
				  write && !sync);

	if (sync)
		return dax_fault_synchronous_pfnp(pfnp, pfn);

	/* insert PMD pfn */
	if (pmd)
		return vmf_insert_pfn_pmd(vmf, pfn, write);

	/* insert PTE pfn */
	if (write)
		return vmf_insert_mixed_mkwrite(vmf->vma, vmf->address, pfn);
	return vmf_insert_mixed(vmf->vma, vmf->address, pfn);
}

1487
static vm_fault_t dax_iomap_pte_fault(struct vm_fault *vmf, pfn_t *pfnp,
1488
			       int *iomap_errp, const struct iomap_ops *ops)
1489
{
1490
	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
1491
	XA_STATE(xas, &mapping->i_pages, vmf->pgoff);
1492 1493 1494 1495
	struct iomap_iter iter = {
		.inode		= mapping->host,
		.pos		= (loff_t)vmf->pgoff << PAGE_SHIFT,
		.len		= PAGE_SIZE,
1496
		.flags		= IOMAP_DAX | IOMAP_FAULT,
1497
	};
1498
	vm_fault_t ret = 0;
1499
	void *entry;
1500
	int error;
1501

1502
	trace_dax_pte_fault(iter.inode, vmf, ret);
1503 1504 1505 1506 1507
	/*
	 * Check whether offset isn't beyond end of file now. Caller is supposed
	 * to hold locks serializing us with truncate / punch hole so this is
	 * a reliable test.
	 */
1508
	if (iter.pos >= i_size_read(iter.inode)) {
1509
		ret = VM_FAULT_SIGBUS;
1510 1511
		goto out;
	}
1512

1513 1514
	if ((vmf->flags & FAULT_FLAG_WRITE) && !vmf->cow_page)
		iter.flags |= IOMAP_WRITE;
1515

1516 1517 1518
	entry = grab_mapping_entry(&xas, mapping, 0);
	if (xa_is_internal(entry)) {
		ret = xa_to_internal(entry);
1519 1520 1521
		goto out;
	}

1522 1523 1524 1525 1526 1527 1528
	/*
	 * It is possible, particularly with mixed reads & writes to private
	 * mappings, that we have raced with a PMD fault that overlaps with
	 * the PTE we need to set up.  If so just return and the fault will be
	 * retried.
	 */
	if (pmd_trans_huge(*vmf->pmd) || pmd_devmap(*vmf->pmd)) {
1529
		ret = VM_FAULT_NOPAGE;
1530 1531 1532
		goto unlock_entry;
	}

1533 1534 1535 1536
	while ((error = iomap_iter(&iter, ops)) > 0) {
		if (WARN_ON_ONCE(iomap_length(&iter) < PAGE_SIZE)) {
			iter.processed = -EIO;	/* fs corruption? */
			continue;
1537 1538
		}

1539 1540 1541
		ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, false);
		if (ret != VM_FAULT_SIGBUS &&
		    (iter.iomap.flags & IOMAP_F_NEW)) {
1542
			count_vm_event(PGMAJFAULT);
1543 1544
			count_memcg_event_mm(vmf->vma->vm_mm, PGMAJFAULT);
			ret |= VM_FAULT_MAJOR;
1545
		}
1546

1547 1548
		if (!(ret & VM_FAULT_ERROR))
			iter.processed = PAGE_SIZE;
1549 1550
	}

1551 1552 1553 1554
	if (iomap_errp)
		*iomap_errp = error;
	if (!ret && error)
		ret = dax_fault_return(error);
1555

1556
unlock_entry:
1557
	dax_unlock_entry(&xas, entry);
1558
out:
1559 1560
	trace_dax_pte_fault_done(iter.inode, vmf, ret);
	return ret;
1561
}
1562 1563

#ifdef CONFIG_FS_DAX_PMD
1564 1565
static bool dax_fault_check_fallback(struct vm_fault *vmf, struct xa_state *xas,
		pgoff_t max_pgoff)
1566
{
1567
	unsigned long pmd_addr = vmf->address & PMD_MASK;
1568
	bool write = vmf->flags & FAULT_FLAG_WRITE;
1569

1570 1571 1572 1573 1574 1575 1576 1577 1578
	/*
	 * Make sure that the faulting address's PMD offset (color) matches
	 * the PMD offset from the start of the file.  This is necessary so
	 * that a PMD range in the page table overlaps exactly with a PMD
	 * range in the page cache.
	 */
	if ((vmf->pgoff & PG_PMD_COLOUR) !=
	    ((vmf->address >> PAGE_SHIFT) & PG_PMD_COLOUR))
		return true;
1579

1580 1581 1582
	/* Fall back to PTEs if we're going to COW */
	if (write && !(vmf->vma->vm_flags & VM_SHARED))
		return true;
1583

1584 1585 1586 1587 1588
	/* If the PMD would extend outside the VMA */
	if (pmd_addr < vmf->vma->vm_start)
		return true;
	if ((pmd_addr + PMD_SIZE) > vmf->vma->vm_end)
		return true;
1589

1590 1591 1592
	/* If the PMD would extend beyond the file size */
	if ((xas->xa_index | PG_PMD_COLOUR) >= max_pgoff)
		return true;
1593

1594
	return false;
1595 1596
}

1597
static vm_fault_t dax_iomap_pmd_fault(struct vm_fault *vmf, pfn_t *pfnp,
1598
			       const struct iomap_ops *ops)
1599
{
1600
	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
1601
	XA_STATE_ORDER(xas, &mapping->i_pages, vmf->pgoff, PMD_ORDER);
1602 1603 1604
	struct iomap_iter iter = {
		.inode		= mapping->host,
		.len		= PMD_SIZE,
1605
		.flags		= IOMAP_DAX | IOMAP_FAULT,
1606
	};
1607
	vm_fault_t ret = VM_FAULT_FALLBACK;
1608
	pgoff_t max_pgoff;
1609 1610 1611
	void *entry;
	int error;

1612 1613
	if (vmf->flags & FAULT_FLAG_WRITE)
		iter.flags |= IOMAP_WRITE;
1614

1615 1616 1617 1618 1619
	/*
	 * Check whether offset isn't beyond end of file now. Caller is
	 * supposed to hold locks serializing us with truncate / punch hole so
	 * this is a reliable test.
	 */
1620
	max_pgoff = DIV_ROUND_UP(i_size_read(iter.inode), PAGE_SIZE);
1621

1622
	trace_dax_pmd_fault(iter.inode, vmf, max_pgoff, 0);
1623

1624
	if (xas.xa_index >= max_pgoff) {
1625
		ret = VM_FAULT_SIGBUS;
1626 1627
		goto out;
	}
1628

1629
	if (dax_fault_check_fallback(vmf, &xas, max_pgoff))
1630 1631
		goto fallback;

1632
	/*
1633 1634 1635 1636
	 * grab_mapping_entry() will make sure we get an empty PMD entry,
	 * a zero PMD entry or a DAX PMD.  If it can't (because a PTE
	 * entry is already in the array, for instance), it will return
	 * VM_FAULT_FALLBACK.
1637
	 */
1638
	entry = grab_mapping_entry(&xas, mapping, PMD_ORDER);
1639
	if (xa_is_internal(entry)) {
1640
		ret = xa_to_internal(entry);
1641
		goto fallback;
1642
	}
1643

1644 1645 1646 1647 1648 1649 1650 1651
	/*
	 * It is possible, particularly with mixed reads & writes to private
	 * mappings, that we have raced with a PTE fault that overlaps with
	 * the PMD we need to set up.  If so just return and the fault will be
	 * retried.
	 */
	if (!pmd_none(*vmf->pmd) && !pmd_trans_huge(*vmf->pmd) &&
			!pmd_devmap(*vmf->pmd)) {
1652
		ret = 0;
1653 1654 1655
		goto unlock_entry;
	}

1656 1657 1658 1659
	iter.pos = (loff_t)xas.xa_index << PAGE_SHIFT;
	while ((error = iomap_iter(&iter, ops)) > 0) {
		if (iomap_length(&iter) < PMD_SIZE)
			continue; /* actually breaks out of the loop */
1660

1661 1662 1663
		ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, true);
		if (ret != VM_FAULT_FALLBACK)
			iter.processed = PMD_SIZE;
1664 1665
	}

1666
unlock_entry:
1667
	dax_unlock_entry(&xas, entry);
1668 1669
fallback:
	if (ret == VM_FAULT_FALLBACK) {
1670
		split_huge_pmd(vmf->vma, vmf->pmd, vmf->address);
1671 1672
		count_vm_event(THP_FAULT_FALLBACK);
	}
1673
out:
1674
	trace_dax_pmd_fault_done(iter.inode, vmf, max_pgoff, ret);
1675
	return ret;
1676
}
1677
#else
1678
static vm_fault_t dax_iomap_pmd_fault(struct vm_fault *vmf, pfn_t *pfnp,
1679
			       const struct iomap_ops *ops)
1680 1681 1682
{
	return VM_FAULT_FALLBACK;
}
1683
#endif /* CONFIG_FS_DAX_PMD */
1684 1685 1686 1687

/**
 * dax_iomap_fault - handle a page fault on a DAX file
 * @vmf: The description of the fault
1688
 * @pe_size: Size of the page to fault in
1689
 * @pfnp: PFN to insert for synchronous faults if fsync is required
1690
 * @iomap_errp: Storage for detailed error code in case of error
1691
 * @ops: Iomap ops passed from the file system
1692 1693 1694 1695 1696 1697
 *
 * When a page fault occurs, filesystems may call this helper in
 * their fault handler for DAX files. dax_iomap_fault() assumes the caller
 * has done all the necessary locking for page fault to proceed
 * successfully.
 */
1698
vm_fault_t dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
1699
		    pfn_t *pfnp, int *iomap_errp, const struct iomap_ops *ops)
1700
{
1701 1702
	switch (pe_size) {
	case PE_SIZE_PTE:
1703
		return dax_iomap_pte_fault(vmf, pfnp, iomap_errp, ops);
1704
	case PE_SIZE_PMD:
1705
		return dax_iomap_pmd_fault(vmf, pfnp, ops);
1706 1707 1708 1709 1710
	default:
		return VM_FAULT_FALLBACK;
	}
}
EXPORT_SYMBOL_GPL(dax_iomap_fault);
1711

1712
/*
1713 1714 1715
 * dax_insert_pfn_mkwrite - insert PTE or PMD entry into page tables
 * @vmf: The description of the fault
 * @pfn: PFN to insert
1716
 * @order: Order of entry to insert.
1717
 *
1718 1719
 * This function inserts a writeable PTE or PMD entry into the page tables
 * for an mmaped DAX file.  It also marks the page cache entry as dirty.
1720
 */
1721 1722
static vm_fault_t
dax_insert_pfn_mkwrite(struct vm_fault *vmf, pfn_t pfn, unsigned int order)
1723 1724
{
	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
1725 1726
	XA_STATE_ORDER(xas, &mapping->i_pages, vmf->pgoff, order);
	void *entry;
1727
	vm_fault_t ret;
1728

1729
	xas_lock_irq(&xas);
1730
	entry = get_unlocked_entry(&xas, order);
1731
	/* Did we race with someone splitting entry or so? */
1732 1733
	if (!entry || dax_is_conflict(entry) ||
	    (order == 0 && !dax_is_pte_entry(entry))) {
1734
		put_unlocked_entry(&xas, entry, WAKE_NEXT);
1735
		xas_unlock_irq(&xas);
1736 1737 1738 1739
		trace_dax_insert_pfn_mkwrite_no_entry(mapping->host, vmf,
						      VM_FAULT_NOPAGE);
		return VM_FAULT_NOPAGE;
	}
1740 1741 1742 1743
	xas_set_mark(&xas, PAGECACHE_TAG_DIRTY);
	dax_lock_entry(&xas, entry);
	xas_unlock_irq(&xas);
	if (order == 0)
1744
		ret = vmf_insert_mixed_mkwrite(vmf->vma, vmf->address, pfn);
1745
#ifdef CONFIG_FS_DAX_PMD
1746
	else if (order == PMD_ORDER)
1747
		ret = vmf_insert_pfn_pmd(vmf, pfn, FAULT_FLAG_WRITE);
1748
#endif
1749
	else
1750
		ret = VM_FAULT_FALLBACK;
1751
	dax_unlock_entry(&xas, entry);
1752 1753
	trace_dax_insert_pfn_mkwrite(mapping->host, vmf, ret);
	return ret;
1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
}

/**
 * dax_finish_sync_fault - finish synchronous page fault
 * @vmf: The description of the fault
 * @pe_size: Size of entry to be inserted
 * @pfn: PFN to insert
 *
 * This function ensures that the file range touched by the page fault is
 * stored persistently on the media and handles inserting of appropriate page
 * table entry.
 */
1766 1767
vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf,
		enum page_entry_size pe_size, pfn_t pfn)
1768 1769 1770
{
	int err;
	loff_t start = ((loff_t)vmf->pgoff) << PAGE_SHIFT;
1771 1772
	unsigned int order = pe_order(pe_size);
	size_t len = PAGE_SIZE << order;
1773 1774 1775 1776

	err = vfs_fsync_range(vmf->vma->vm_file, start, start + len - 1, 1);
	if (err)
		return VM_FAULT_SIGBUS;
1777
	return dax_insert_pfn_mkwrite(vmf, pfn, order);
1778 1779
}
EXPORT_SYMBOL_GPL(dax_finish_sync_fault);