linux - fs/buffer.c

3508 lines · 91.1 KiB

1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* linux/fs/buffer.c
4	*
5	* Copyright (C) 1991, 1992, 2002 Linus Torvalds
6	*/
7
8	/*
9	* Start bdflush() with kernel_thread not syscall - Paul Gortmaker, 12/95
10	*
11	* Removed a lot of unnecessary code and simplified things now that
12	* the buffer cache isn't our primary cache - Andrew Tridgell 12/96
13	*
14	* Speed up hash, lru, and free list operations. Use gfp() for allocating
15	* hash table, use SLAB cache for buffer heads. SMP threading. -DaveM
16	*
17	* Added 32k buffer block sizes - these are required older ARM systems. - RMK
18	*
19	* async buffer flushing, 1999 Andrea Arcangeli <[email protected]>
20	*/
21
22	#include <linux/kernel.h>
23	#include <linux/sched/signal.h>
24	#include <linux/syscalls.h>
25	#include <linux/fs.h>
26	#include <linux/iomap.h>
27	#include <linux/mm.h>
28	#include <linux/percpu.h>
29	#include <linux/slab.h>
30	#include <linux/capability.h>
31	#include <linux/blkdev.h>
32	#include <linux/file.h>
33	#include <linux/quotaops.h>
34	#include <linux/highmem.h>
35	#include <linux/export.h>
36	#include <linux/backing-dev.h>
37	#include <linux/writeback.h>
38	#include <linux/hash.h>
39	#include <linux/suspend.h>
40	#include <linux/buffer_head.h>
41	#include <linux/task_io_accounting_ops.h>
42	#include <linux/bio.h>
43	#include <linux/cpu.h>
44	#include <linux/bitops.h>
45	#include <linux/mpage.h>
46	#include <linux/bit_spinlock.h>
47	#include <linux/pagevec.h>
48	#include <linux/sched/mm.h>
49	#include <trace/events/block.h>
50	#include <linux/fscrypt.h>
51
52	#include "internal.h"
53
54	static int fsync_buffers_list(spinlock_t lock, struct list_head list);
55	static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
56	enum rw_hint hint, struct writeback_control *wbc);
57
58	#define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
59
60	inline void touch_buffer(struct buffer_head *bh)
61	{
62	trace_block_touch_buffer(bh);
63	mark_page_accessed(bh->b_page);
64	}
65	EXPORT_SYMBOL(touch_buffer);
66
67	void __lock_buffer(struct buffer_head *bh)
68	{
69	wait_on_bit_lock_io(&bh->b_state, BH_Lock, TASK_UNINTERRUPTIBLE);
70	}
71	EXPORT_SYMBOL(__lock_buffer);
72
73	void unlock_buffer(struct buffer_head *bh)
74	{
75	clear_bit_unlock(BH_Lock, &bh->b_state);
76	smp_mb__after_atomic();
77	wake_up_bit(&bh->b_state, BH_Lock);
78	}
79	EXPORT_SYMBOL(unlock_buffer);
80
81	/*
82	* Returns if the page has dirty or writeback buffers. If all the buffers
83	* are unlocked and clean then the PageDirty information is stale. If
84	* any of the pages are locked, it is assumed they are locked for IO.
85	*/
86	void buffer_check_dirty_writeback(struct page *page,
87	bool dirty, bool writeback)
88	{
89	struct buffer_head head, bh;
90	*dirty = false;
91	*writeback = false;
92
93	BUG_ON(!PageLocked(page));
94
95	if (!page_has_buffers(page))
96	return;
97
98	if (PageWriteback(page))
99	*writeback = true;
100
101	head = page_buffers(page);
102	bh = head;
103	do {
104	if (buffer_locked(bh))
105	*writeback = true;
106
107	if (buffer_dirty(bh))
108	*dirty = true;
109
110	bh = bh->b_this_page;
111	} while (bh != head);
112	}
113	EXPORT_SYMBOL(buffer_check_dirty_writeback);
114
115	/*
116	* Block until a buffer comes unlocked. This doesn't stop it
117	* from becoming locked again - you have to lock it yourself
118	* if you want to preserve its state.
119	*/
120	void __wait_on_buffer(struct buffer_head * bh)
121	{
122	wait_on_bit_io(&bh->b_state, BH_Lock, TASK_UNINTERRUPTIBLE);
123	}
124	EXPORT_SYMBOL(__wait_on_buffer);
125
126	static void
127	__clear_page_buffers(struct page *page)
128	{
129	ClearPagePrivate(page);
130	set_page_private(page, 0);
131	put_page(page);
132	}
133
134	static void buffer_io_error(struct buffer_head bh, char msg)
135	{
136	if (!test_bit(BH_Quiet, &bh->b_state))
137	printk_ratelimited(KERN_ERR
138	"Buffer I/O error on dev %pg, logical block %llu%s\n",
139	bh->b_bdev, (unsigned long long)bh->b_blocknr, msg);
140	}
141
142	/*
143	* End-of-IO handler helper function which does not touch the bh after
144	* unlocking it.
145	* Note: unlock_buffer() sort-of does touch the bh after unlocking it, but
146	* a race there is benign: unlock_buffer() only use the bh's address for
147	* hashing after unlocking the buffer, so it doesn't actually touch the bh
148	* itself.
149	*/
150	static void __end_buffer_read_notouch(struct buffer_head *bh, int uptodate)
151	{
152	if (uptodate) {
153	set_buffer_uptodate(bh);
154	} else {
155	/* This happens, due to failed read-ahead attempts. */
156	clear_buffer_uptodate(bh);
157	}
158	unlock_buffer(bh);
159	}
160
161	/*
162	* Default synchronous end-of-IO handler.. Just mark it up-to-date and
163	* unlock the buffer. This is what ll_rw_block uses too.
164	*/
165	void end_buffer_read_sync(struct buffer_head *bh, int uptodate)
166	{
167	__end_buffer_read_notouch(bh, uptodate);
168	put_bh(bh);
169	}
170	EXPORT_SYMBOL(end_buffer_read_sync);
171
172	void end_buffer_write_sync(struct buffer_head *bh, int uptodate)
173	{
174	if (uptodate) {
175	set_buffer_uptodate(bh);
176	} else {
177	buffer_io_error(bh, ", lost sync page write");
178	mark_buffer_write_io_error(bh);
179	clear_buffer_uptodate(bh);
180	}
181	unlock_buffer(bh);
182	put_bh(bh);
183	}
184	EXPORT_SYMBOL(end_buffer_write_sync);
185
186	/*
187	* Various filesystems appear to want __find_get_block to be non-blocking.
188	* But it's the page lock which protects the buffers. To get around this,
189	* we get exclusion from try_to_free_buffers with the blockdev mapping's
190	* private_lock.
191	*
192	* Hack idea: for the blockdev mapping, private_lock contention
193	* may be quite high. This code could TryLock the page, and if that
194	* succeeds, there is no need to take private_lock.
195	*/
196	static struct buffer_head *
197	__find_get_block_slow(struct block_device *bdev, sector_t block)
198	{
199	struct inode *bd_inode = bdev->bd_inode;
200	struct address_space *bd_mapping = bd_inode->i_mapping;
201	struct buffer_head *ret = NULL;
202	pgoff_t index;
203	struct buffer_head *bh;
204	struct buffer_head *head;
205	struct page *page;
206	int all_mapped = 1;
207	static DEFINE_RATELIMIT_STATE(last_warned, HZ, 1);
208
209	index = block >> (PAGE_SHIFT - bd_inode->i_blkbits);
210	page = find_get_page_flags(bd_mapping, index, FGP_ACCESSED);
211	if (!page)
212	goto out;
213
214	spin_lock(&bd_mapping->private_lock);
215	if (!page_has_buffers(page))
216	goto out_unlock;
217	head = page_buffers(page);
218	bh = head;
219	do {
220	if (!buffer_mapped(bh))
221	all_mapped = 0;
222	else if (bh->b_blocknr == block) {
223	ret = bh;
224	get_bh(bh);
225	goto out_unlock;
226	}
227	bh = bh->b_this_page;
228	} while (bh != head);
229
230	/* we might be here because some of the buffers on this page are
231	* not mapped. This is due to various races between
232	* file io on the block device and getblk. It gets dealt with
233	* elsewhere, don't buffer_error if we had some unmapped buffers
234	*/
235	ratelimit_set_flags(&last_warned, RATELIMIT_MSG_ON_RELEASE);
236	if (all_mapped && __ratelimit(&last_warned)) {
237	printk("__find_get_block_slow() failed. block=%llu, "
238	"b_blocknr=%llu, b_state=0x%08lx, b_size=%zu, "
239	"device %pg blocksize: %d\n",
240	(unsigned long long)block,
241	(unsigned long long)bh->b_blocknr,
242	bh->b_state, bh->b_size, bdev,
243	1 << bd_inode->i_blkbits);
244	}
245	out_unlock:
246	spin_unlock(&bd_mapping->private_lock);
247	put_page(page);
248	out:
249	return ret;
250	}
251
252	static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
253	{
254	unsigned long flags;
255	struct buffer_head *first;
256	struct buffer_head *tmp;
257	struct page *page;
258	int page_uptodate = 1;
259
260	BUG_ON(!buffer_async_read(bh));
261
262	page = bh->b_page;
263	if (uptodate) {
264	set_buffer_uptodate(bh);
265	} else {
266	clear_buffer_uptodate(bh);
267	buffer_io_error(bh, ", async page read");
268	SetPageError(page);
269	}
270
271	/*
272	* Be _very_ careful from here on. Bad things can happen if
273	* two buffer heads end IO at almost the same time and both
274	* decide that the page is now completely done.
275	*/
276	first = page_buffers(page);
277	local_irq_save(flags);
278	bit_spin_lock(BH_Uptodate_Lock, &first->b_state);
279	clear_buffer_async_read(bh);
280	unlock_buffer(bh);
281	tmp = bh;
282	do {
283	if (!buffer_uptodate(tmp))
284	page_uptodate = 0;
285	if (buffer_async_read(tmp)) {
286	BUG_ON(!buffer_locked(tmp));
287	goto still_busy;
288	}
289	tmp = tmp->b_this_page;
290	} while (tmp != bh);
291	bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
292	local_irq_restore(flags);
293
294	/*
295	* If none of the buffers had errors and they are all
296	* uptodate then we can set the page uptodate.
297	*/
298	if (page_uptodate && !PageError(page))
299	SetPageUptodate(page);
300	unlock_page(page);
301	return;
302
303	still_busy:
304	bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
305	local_irq_restore(flags);
306	return;
307	}
308
309	struct decrypt_bh_ctx {
310	struct work_struct work;
311	struct buffer_head *bh;
312	};
313
314	static void decrypt_bh(struct work_struct *work)
315	{
316	struct decrypt_bh_ctx *ctx =
317	container_of(work, struct decrypt_bh_ctx, work);
318	struct buffer_head *bh = ctx->bh;
319	int err;
320
321	err = fscrypt_decrypt_pagecache_blocks(bh->b_page, bh->b_size,
322	bh_offset(bh));
323	end_buffer_async_read(bh, err == 0);
324	kfree(ctx);
325	}
326
327	/*
328	* I/O completion handler for block_read_full_page() - pages
329	* which come unlocked at the end of I/O.
330	*/
331	static void end_buffer_async_read_io(struct buffer_head *bh, int uptodate)
332	{
333	/* Decrypt if needed */
334	if (uptodate && IS_ENABLED(CONFIG_FS_ENCRYPTION) &&
335	IS_ENCRYPTED(bh->b_page->mapping->host) &&
336	S_ISREG(bh->b_page->mapping->host->i_mode)) {
337	struct decrypt_bh_ctx ctx = kmalloc(sizeof(ctx), GFP_ATOMIC);
338
339	if (ctx) {
340	INIT_WORK(&ctx->work, decrypt_bh);
341	ctx->bh = bh;
342	fscrypt_enqueue_decrypt_work(&ctx->work);
343	return;
344	}
345	uptodate = 0;
346	}
347	end_buffer_async_read(bh, uptodate);
348	}
349
350	/*
351	* Completion handler for block_write_full_page() - pages which are unlocked
352	* during I/O, and which have PageWriteback cleared upon I/O completion.
353	*/
354	void end_buffer_async_write(struct buffer_head *bh, int uptodate)
355	{
356	unsigned long flags;
357	struct buffer_head *first;
358	struct buffer_head *tmp;
359	struct page *page;
360
361	BUG_ON(!buffer_async_write(bh));
362
363	page = bh->b_page;
364	if (uptodate) {
365	set_buffer_uptodate(bh);
366	} else {
367	buffer_io_error(bh, ", lost async page write");
368	mark_buffer_write_io_error(bh);
369	clear_buffer_uptodate(bh);
370	SetPageError(page);
371	}
372
373	first = page_buffers(page);
374	local_irq_save(flags);
375	bit_spin_lock(BH_Uptodate_Lock, &first->b_state);
376
377	clear_buffer_async_write(bh);
378	unlock_buffer(bh);
379	tmp = bh->b_this_page;
380	while (tmp != bh) {
381	if (buffer_async_write(tmp)) {
382	BUG_ON(!buffer_locked(tmp));
383	goto still_busy;
384	}
385	tmp = tmp->b_this_page;
386	}
387	bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
388	local_irq_restore(flags);
389	end_page_writeback(page);
390	return;
391
392	still_busy:
393	bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
394	local_irq_restore(flags);
395	return;
396	}
397	EXPORT_SYMBOL(end_buffer_async_write);
398
399	/*
400	* If a page's buffers are under async readin (end_buffer_async_read
401	* completion) then there is a possibility that another thread of
402	* control could lock one of the buffers after it has completed
403	* but while some of the other buffers have not completed. This
404	* locked buffer would confuse end_buffer_async_read() into not unlocking
405	* the page. So the absence of BH_Async_Read tells end_buffer_async_read()
406	* that this buffer is not under async I/O.
407	*
408	* The page comes unlocked when it has no locked buffer_async buffers
409	* left.
410	*
411	* PageLocked prevents anyone starting new async I/O reads any of
412	* the buffers.
413	*
414	* PageWriteback is used to prevent simultaneous writeout of the same
415	* page.
416	*
417	* PageLocked prevents anyone from starting writeback of a page which is
418	* under read I/O (PageWriteback is only ever set against a locked page).
419	*/
420	static void mark_buffer_async_read(struct buffer_head *bh)
421	{
422	bh->b_end_io = end_buffer_async_read_io;
423	set_buffer_async_read(bh);
424	}
425
426	static void mark_buffer_async_write_endio(struct buffer_head *bh,
427	bh_end_io_t *handler)
428	{
429	bh->b_end_io = handler;
430	set_buffer_async_write(bh);
431	}
432
433	void mark_buffer_async_write(struct buffer_head *bh)
434	{
435	mark_buffer_async_write_endio(bh, end_buffer_async_write);
436	}
437	EXPORT_SYMBOL(mark_buffer_async_write);
438
439
440	/*
441	* fs/buffer.c contains helper functions for buffer-backed address space's
442	* fsync functions. A common requirement for buffer-based filesystems is
443	* that certain data from the backing blockdev needs to be written out for
444	* a successful fsync(). For example, ext2 indirect blocks need to be
445	* written back and waited upon before fsync() returns.
446	*
447	* The functions mark_buffer_inode_dirty(), fsync_inode_buffers(),
448	* inode_has_buffers() and invalidate_inode_buffers() are provided for the
449	* management of a list of dependent buffers at ->i_mapping->private_list.
450	*
451	* Locking is a little subtle: try_to_free_buffers() will remove buffers
452	* from their controlling inode's queue when they are being freed. But
453	* try_to_free_buffers() will be operating against the blockdev mapping
454	* at the time, not against the S_ISREG file which depends on those buffers.
455	* So the locking for private_list is via the private_lock in the address_space
456	* which backs the buffers. Which is different from the address_space
457	* against which the buffers are listed. So for a particular address_space,
458	* mapping->private_lock does not protect mapping->private_list! In fact,
459	* mapping->private_list will always be protected by the backing blockdev's
460	* ->private_lock.
461	*
462	* Which introduces a requirement: all buffers on an address_space's
463	* ->private_list must be from the same address_space: the blockdev's.
464	*
465	* address_spaces which do not place buffers at ->private_list via these
466	* utility functions are free to use private_lock and private_list for
467	* whatever they want. The only requirement is that list_empty(private_list)
468	* be true at clear_inode() time.
469	*
470	* FIXME: clear_inode should not call invalidate_inode_buffers(). The
471	* filesystems should do that. invalidate_inode_buffers() should just go
472	* BUG_ON(!list_empty).
473	*
474	* FIXME: mark_buffer_dirty_inode() is a data-plane operation. It should
475	* take an address_space, not an inode. And it should be called
476	* mark_buffer_dirty_fsync() to clearly define why those buffers are being
477	* queued up.
478	*
479	* FIXME: mark_buffer_dirty_inode() doesn't need to add the buffer to the
480	* list if it is already on a list. Because if the buffer is on a list,
481	* it must already be on the right one. If not, the filesystem is being
482	* silly. This will save a ton of locking. But first we have to ensure
483	* that buffers are taken off the old inode's list when they are freed
484	* (presumably in truncate). That requires careful auditing of all
485	* filesystems (do it inside bforget()). It could also be done by bringing
486	* b_inode back.
487	*/
488
489	/*
490	* The buffer's backing address_space's private_lock must be held
491	*/
492	static void __remove_assoc_queue(struct buffer_head *bh)
493	{
494	list_del_init(&bh->b_assoc_buffers);
495	WARN_ON(!bh->b_assoc_map);
496	bh->b_assoc_map = NULL;
497	}
498
499	int inode_has_buffers(struct inode *inode)
500	{
501	return !list_empty(&inode->i_data.private_list);
502	}
503
504	/*
505	* osync is designed to support O_SYNC io. It waits synchronously for
506	* all already-submitted IO to complete, but does not queue any new
507	* writes to the disk.
508	*
509	* To do O_SYNC writes, just queue the buffer writes with ll_rw_block as
510	* you dirty the buffers, and then use osync_inode_buffers to wait for
511	* completion. Any other dirty buffers which are not yet queued for
512	* write will not be flushed to disk by the osync.
513	*/
514	static int osync_buffers_list(spinlock_t lock, struct list_head list)
515	{
516	struct buffer_head *bh;
517	struct list_head *p;
518	int err = 0;
519
520	spin_lock(lock);
521	repeat:
522	list_for_each_prev(p, list) {
523	bh = BH_ENTRY(p);
524	if (buffer_locked(bh)) {
525	get_bh(bh);
526	spin_unlock(lock);
527	wait_on_buffer(bh);
528	if (!buffer_uptodate(bh))
529	err = -EIO;
530	brelse(bh);
531	spin_lock(lock);
532	goto repeat;
533	}
534	}
535	spin_unlock(lock);
536	return err;
537	}
538
539	void emergency_thaw_bdev(struct super_block *sb)
540	{
541	while (sb->s_bdev && !thaw_bdev(sb->s_bdev, sb))
542	printk(KERN_WARNING "Emergency Thaw on %pg\n", sb->s_bdev);
543	}
544
545	/**
546	* sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers
547	* @mapping: the mapping which wants those buffers written
548	*
549	* Starts I/O against the buffers at mapping->private_list, and waits upon
550	* that I/O.
551	*
552	* Basically, this is a convenience function for fsync().
553	* @mapping is a file or directory which needs those buffers to be written for
554	* a successful fsync().
555	*/
556	int sync_mapping_buffers(struct address_space *mapping)
557	{
558	struct address_space *buffer_mapping = mapping->private_data;
559
560	if (buffer_mapping == NULL \|\| list_empty(&mapping->private_list))
561	return 0;
562
563	return fsync_buffers_list(&buffer_mapping->private_lock,
564	&mapping->private_list);
565	}
566	EXPORT_SYMBOL(sync_mapping_buffers);
567
568	/*
569	* Called when we've recently written block `bblock', and it is known that
570	* `bblock' was for a buffer_boundary() buffer. This means that the block at
571	* `bblock + 1' is probably a dirty indirect block. Hunt it down and, if it's
572	* dirty, schedule it for IO. So that indirects merge nicely with their data.
573	*/
574	void write_boundary_block(struct block_device *bdev,
575	sector_t bblock, unsigned blocksize)
576	{
577	struct buffer_head *bh = __find_get_block(bdev, bblock + 1, blocksize);
578	if (bh) {
579	if (buffer_dirty(bh))
580	ll_rw_block(REQ_OP_WRITE, 0, 1, &bh);
581	put_bh(bh);
582	}
583	}
584
585	void mark_buffer_dirty_inode(struct buffer_head bh, struct inode inode)
586	{
587	struct address_space *mapping = inode->i_mapping;
588	struct address_space *buffer_mapping = bh->b_page->mapping;
589
590	mark_buffer_dirty(bh);
591	if (!mapping->private_data) {
592	mapping->private_data = buffer_mapping;
593	} else {
594	BUG_ON(mapping->private_data != buffer_mapping);
595	}
596	if (!bh->b_assoc_map) {
597	spin_lock(&buffer_mapping->private_lock);
598	list_move_tail(&bh->b_assoc_buffers,
599	&mapping->private_list);
600	bh->b_assoc_map = mapping;
601	spin_unlock(&buffer_mapping->private_lock);
602	}
603	}
604	EXPORT_SYMBOL(mark_buffer_dirty_inode);
605
606	/*
607	* Mark the page dirty, and set it dirty in the page cache, and mark the inode
608	* dirty.
609	*
610	* If warn is true, then emit a warning if the page is not uptodate and has
611	* not been truncated.
612	*
613	* The caller must hold lock_page_memcg().
614	*/
615	void __set_page_dirty(struct page page, struct address_space mapping,
616	int warn)
617	{
618	unsigned long flags;
619
620	xa_lock_irqsave(&mapping->i_pages, flags);
621	if (page->mapping) { /* Race with truncate? */
622	WARN_ON_ONCE(warn && !PageUptodate(page));
623	account_page_dirtied(page, mapping);
624	__xa_set_mark(&mapping->i_pages, page_index(page),
625	PAGECACHE_TAG_DIRTY);
626	}
627	xa_unlock_irqrestore(&mapping->i_pages, flags);
628	}
629	EXPORT_SYMBOL_GPL(__set_page_dirty);
630
631	/*
632	* Add a page to the dirty page list.
633	*
634	* It is a sad fact of life that this function is called from several places
635	* deeply under spinlocking. It may not sleep.
636	*
637	* If the page has buffers, the uptodate buffers are set dirty, to preserve
638	* dirty-state coherency between the page and the buffers. It the page does
639	* not have buffers then when they are later attached they will all be set
640	* dirty.
641	*
642	* The buffers are dirtied before the page is dirtied. There's a small race
643	* window in which a writepage caller may see the page cleanness but not the
644	* buffer dirtiness. That's fine. If this code were to set the page dirty
645	* before the buffers, a concurrent writepage caller could clear the page dirty
646	* bit, see a bunch of clean buffers and we'd end up with dirty buffers/clean
647	* page on the dirty page list.
648	*
649	* We use private_lock to lock against try_to_free_buffers while using the
650	* page's buffer list. Also use this to protect against clean buffers being
651	* added to the page after it was set dirty.
652	*
653	* FIXME: may need to call ->reservepage here as well. That's rather up to the
654	* address_space though.
655	*/
656	int __set_page_dirty_buffers(struct page *page)
657	{
658	int newly_dirty;
659	struct address_space *mapping = page_mapping(page);
660
661	if (unlikely(!mapping))
662	return !TestSetPageDirty(page);
663
664	spin_lock(&mapping->private_lock);
665	if (page_has_buffers(page)) {
666	struct buffer_head *head = page_buffers(page);
667	struct buffer_head *bh = head;
668
669	do {
670	set_buffer_dirty(bh);
671	bh = bh->b_this_page;
672	} while (bh != head);
673	}
674	/*
675	* Lock out page->mem_cgroup migration to keep PageDirty
676	* synchronized with per-memcg dirty page counters.
677	*/
678	lock_page_memcg(page);
679	newly_dirty = !TestSetPageDirty(page);
680	spin_unlock(&mapping->private_lock);
681
682	if (newly_dirty)
683	__set_page_dirty(page, mapping, 1);
684
685	unlock_page_memcg(page);
686
687	if (newly_dirty)
688	__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
689
690	return newly_dirty;
691	}
692	EXPORT_SYMBOL(__set_page_dirty_buffers);
693
694	/*
695	* Write out and wait upon a list of buffers.
696	*
697	* We have conflicting pressures: we want to make sure that all
698	* initially dirty buffers get waited on, but that any subsequently
699	* dirtied buffers don't. After all, we don't want fsync to last
700	* forever if somebody is actively writing to the file.
701	*
702	* Do this in two main stages: first we copy dirty buffers to a
703	* temporary inode list, queueing the writes as we go. Then we clean
704	* up, waiting for those writes to complete.
705	*
706	* During this second stage, any subsequent updates to the file may end
707	* up refiling the buffer on the original inode's dirty list again, so
708	* there is a chance we will end up with a buffer queued for write but
709	* not yet completed on that list. So, as a final cleanup we go through
710	* the osync code to catch these locked, dirty buffers without requeuing
711	* any newly dirty buffers for write.
712	*/
713	static int fsync_buffers_list(spinlock_t lock, struct list_head list)
714	{
715	struct buffer_head *bh;
716	struct list_head tmp;
717	struct address_space *mapping;
718	int err = 0, err2;
719	struct blk_plug plug;
720
721	INIT_LIST_HEAD(&tmp);
722	blk_start_plug(&plug);
723
724	spin_lock(lock);
725	while (!list_empty(list)) {
726	bh = BH_ENTRY(list->next);
727	mapping = bh->b_assoc_map;
728	__remove_assoc_queue(bh);
729	/* Avoid race with mark_buffer_dirty_inode() which does
730	* a lockless check and we rely on seeing the dirty bit */
731	smp_mb();
732	if (buffer_dirty(bh) \|\| buffer_locked(bh)) {
733	list_add(&bh->b_assoc_buffers, &tmp);
734	bh->b_assoc_map = mapping;
735	if (buffer_dirty(bh)) {
736	get_bh(bh);
737	spin_unlock(lock);
738	/*
739	* Ensure any pending I/O completes so that
740	* write_dirty_buffer() actually writes the
741	* current contents - it is a noop if I/O is
742	* still in flight on potentially older
743	* contents.
744	*/
745	write_dirty_buffer(bh, REQ_SYNC);
746
747	/*
748	* Kick off IO for the previous mapping. Note
749	* that we will not run the very last mapping,
750	* wait_on_buffer() will do that for us
751	* through sync_buffer().
752	*/
753	brelse(bh);
754	spin_lock(lock);
755	}
756	}
757	}
758
759	spin_unlock(lock);
760	blk_finish_plug(&plug);
761	spin_lock(lock);
762
763	while (!list_empty(&tmp)) {
764	bh = BH_ENTRY(tmp.prev);
765	get_bh(bh);
766	mapping = bh->b_assoc_map;
767	__remove_assoc_queue(bh);
768	/* Avoid race with mark_buffer_dirty_inode() which does
769	* a lockless check and we rely on seeing the dirty bit */
770	smp_mb();
771	if (buffer_dirty(bh)) {
772	list_add(&bh->b_assoc_buffers,
773	&mapping->private_list);
774	bh->b_assoc_map = mapping;
775	}
776	spin_unlock(lock);
777	wait_on_buffer(bh);
778	if (!buffer_uptodate(bh))
779	err = -EIO;
780	brelse(bh);
781	spin_lock(lock);
782	}
783
784	spin_unlock(lock);
785	err2 = osync_buffers_list(lock, list);
786	if (err)
787	return err;
788	else
789	return err2;
790	}
791
792	/*
793	* Invalidate any and all dirty buffers on a given inode. We are
794	* probably unmounting the fs, but that doesn't mean we have already
795	* done a sync(). Just drop the buffers from the inode list.
796	*
797	* NOTE: we take the inode's blockdev's mapping's private_lock. Which
798	* assumes that all the buffers are against the blockdev. Not true
799	* for reiserfs.
800	*/
801	void invalidate_inode_buffers(struct inode *inode)
802	{
803	if (inode_has_buffers(inode)) {
804	struct address_space *mapping = &inode->i_data;
805	struct list_head *list = &mapping->private_list;
806	struct address_space *buffer_mapping = mapping->private_data;
807
808	spin_lock(&buffer_mapping->private_lock);
809	while (!list_empty(list))
810	__remove_assoc_queue(BH_ENTRY(list->next));
811	spin_unlock(&buffer_mapping->private_lock);
812	}
813	}
814	EXPORT_SYMBOL(invalidate_inode_buffers);
815
816	/*
817	* Remove any clean buffers from the inode's buffer list. This is called
818	* when we're trying to free the inode itself. Those buffers can pin it.
819	*
820	* Returns true if all buffers were removed.
821	*/
822	int remove_inode_buffers(struct inode *inode)
823	{
824	int ret = 1;
825
826	if (inode_has_buffers(inode)) {
827	struct address_space *mapping = &inode->i_data;
828	struct list_head *list = &mapping->private_list;
829	struct address_space *buffer_mapping = mapping->private_data;
830
831	spin_lock(&buffer_mapping->private_lock);
832	while (!list_empty(list)) {
833	struct buffer_head *bh = BH_ENTRY(list->next);
834	if (buffer_dirty(bh)) {
835	ret = 0;
836	break;
837	}
838	__remove_assoc_queue(bh);
839	}
840	spin_unlock(&buffer_mapping->private_lock);
841	}
842	return ret;
843	}
844
845	/*
846	* Create the appropriate buffers when given a page for data area and
847	* the size of each buffer.. Use the bh->b_this_page linked list to
848	* follow the buffers created. Return NULL if unable to create more
849	* buffers.
850	*
851	* The retry flag is used to differentiate async IO (paging, swapping)
852	* which may not fail from ordinary buffer allocations.
853	*/
854	struct buffer_head alloc_page_buffers(struct page page, unsigned long size,
855	bool retry)
856	{
857	struct buffer_head bh, head;
858	gfp_t gfp = GFP_NOFS \| __GFP_ACCOUNT;
859	long offset;
860	struct mem_cgroup *memcg;
861
862	if (retry)
863	gfp \|= __GFP_NOFAIL;
864
865	memcg = get_mem_cgroup_from_page(page);
866	memalloc_use_memcg(memcg);
867
868	head = NULL;
869	offset = PAGE_SIZE;
870	while ((offset -= size) >= 0) {
871	bh = alloc_buffer_head(gfp);
872	if (!bh)
873	goto no_grow;
874
875	bh->b_this_page = head;
876	bh->b_blocknr = -1;
877	head = bh;
878
879	bh->b_size = size;
880
881	/* Link the buffer to its page */
882	set_bh_page(bh, page, offset);
883	}
884	out:
885	memalloc_unuse_memcg();
886	mem_cgroup_put(memcg);
887	return head;
888	/*
889	* In case anything failed, we just free everything we got.
890	*/
891	no_grow:
892	if (head) {
893	do {
894	bh = head;
895	head = head->b_this_page;
896	free_buffer_head(bh);
897	} while (head);
898	}
899
900	goto out;
901	}
902	EXPORT_SYMBOL_GPL(alloc_page_buffers);
903
904	static inline void
905	link_dev_buffers(struct page page, struct buffer_head head)
906	{
907	struct buffer_head bh, tail;
908
909	bh = head;
910	do {
911	tail = bh;
912	bh = bh->b_this_page;
913	} while (bh);
914	tail->b_this_page = head;
915	attach_page_buffers(page, head);
916	}
917
918	static sector_t blkdev_max_block(struct block_device *bdev, unsigned int size)
919	{
920	sector_t retval = ~((sector_t)0);
921	loff_t sz = i_size_read(bdev->bd_inode);
922
923	if (sz) {
924	unsigned int sizebits = blksize_bits(size);
925	retval = (sz >> sizebits);
926	}
927	return retval;
928	}
929
930	/*
931	* Initialise the state of a blockdev page's buffers.
932	*/
933	static sector_t
934	init_page_buffers(struct page page, struct block_device bdev,
935	sector_t block, int size)
936	{
937	struct buffer_head *head = page_buffers(page);
938	struct buffer_head *bh = head;
939	int uptodate = PageUptodate(page);
940	sector_t end_block = blkdev_max_block(I_BDEV(bdev->bd_inode), size);
941
942	do {
943	if (!buffer_mapped(bh)) {
944	bh->b_end_io = NULL;
945	bh->b_private = NULL;
946	bh->b_bdev = bdev;
947	bh->b_blocknr = block;
948	if (uptodate)
949	set_buffer_uptodate(bh);
950	if (block < end_block)
951	set_buffer_mapped(bh);
952	}
953	block++;
954	bh = bh->b_this_page;
955	} while (bh != head);
956
957	/*
958	* Caller needs to validate requested block against end of device.
959	*/
960	return end_block;
961	}
962
963	/*
964	* Create the page-cache page that contains the requested block.
965	*
966	* This is used purely for blockdev mappings.
967	*/
968	static int
969	grow_dev_page(struct block_device *bdev, sector_t block,
970	pgoff_t index, int size, int sizebits, gfp_t gfp)
971	{
972	struct inode *inode = bdev->bd_inode;
973	struct page *page;
974	struct buffer_head *bh;
975	sector_t end_block;
976	int ret = 0; /* Will call free_more_memory() */
977	gfp_t gfp_mask;
978
979	gfp_mask = mapping_gfp_constraint(inode->i_mapping, ~__GFP_FS) \| gfp;
980
981	/*
982	* XXX: __getblk_slow() can not really deal with failure and
983	* will endlessly loop on improvised global reclaim. Prefer
984	* looping in the allocator rather than here, at least that
985	* code knows what it's doing.
986	*/
987	gfp_mask \|= __GFP_NOFAIL;
988
989	page = find_or_create_page(inode->i_mapping, index, gfp_mask);
990
991	BUG_ON(!PageLocked(page));
992
993	if (page_has_buffers(page)) {
994	bh = page_buffers(page);
995	if (bh->b_size == size) {
996	end_block = init_page_buffers(page, bdev,
997	(sector_t)index << sizebits,
998	size);
999	goto done;
1000	}
1001	if (!try_to_free_buffers(page))
1002	goto failed;
1003	}
1004
1005	/*
1006	* Allocate some buffers for this page
1007	*/
1008	bh = alloc_page_buffers(page, size, true);
1009
1010	/*
1011	* Link the page to the buffers and initialise them. Take the
1012	* lock to be atomic wrt __find_get_block(), which does not
1013	* run under the page lock.
1014	*/
1015	spin_lock(&inode->i_mapping->private_lock);
1016	link_dev_buffers(page, bh);
1017	end_block = init_page_buffers(page, bdev, (sector_t)index << sizebits,
1018	size);
1019	spin_unlock(&inode->i_mapping->private_lock);
1020	done:
1021	ret = (block < end_block) ? 1 : -ENXIO;
1022	failed:
1023	unlock_page(page);
1024	put_page(page);
1025	return ret;
1026	}
1027
1028	/*
1029	* Create buffers for the specified block device block's page. If
1030	* that page was dirty, the buffers are set dirty also.
1031	*/
1032	static int
1033	grow_buffers(struct block_device *bdev, sector_t block, int size, gfp_t gfp)
1034	{
1035	pgoff_t index;
1036	int sizebits;
1037
1038	sizebits = -1;
1039	do {
1040	sizebits++;
1041	} while ((size << sizebits) < PAGE_SIZE);
1042
1043	index = block >> sizebits;
1044
1045	/*
1046	* Check for a block which wants to lie outside our maximum possible
1047	* pagecache index. (this comparison is done using sector_t types).
1048	*/
1049	if (unlikely(index != block >> sizebits)) {
1050	printk(KERN_ERR "%s: requested out-of-range block %llu for "
1051	"device %pg\n",
1052	__func__, (unsigned long long)block,
1053	bdev);
1054	return -EIO;
1055	}
1056
1057	/* Create a page with the proper size buffers.. */
1058	return grow_dev_page(bdev, block, index, size, sizebits, gfp);
1059	}
1060
1061	static struct buffer_head *
1062	__getblk_slow(struct block_device *bdev, sector_t block,
1063	unsigned size, gfp_t gfp)
1064	{
1065	/* Size must be multiple of hard sectorsize */
1066	if (unlikely(size & (bdev_logical_block_size(bdev)-1) \|\|
1067	(size < 512 \|\| size > PAGE_SIZE))) {
1068	printk(KERN_ERR "getblk(): invalid block size %d requested\n",
1069	size);
1070	printk(KERN_ERR "logical block size: %d\n",
1071	bdev_logical_block_size(bdev));
1072
1073	dump_stack();
1074	return NULL;
1075	}
1076
1077	for (;;) {
1078	struct buffer_head *bh;
1079	int ret;
1080
1081	bh = __find_get_block(bdev, block, size);
1082	if (bh)
1083	return bh;
1084
1085	ret = grow_buffers(bdev, block, size, gfp);
1086	if (ret < 0)
1087	return NULL;
1088	}
1089	}
1090
1091	/*
1092	* The relationship between dirty buffers and dirty pages:
1093	*
1094	* Whenever a page has any dirty buffers, the page's dirty bit is set, and
1095	* the page is tagged dirty in the page cache.
1096	*
1097	* At all times, the dirtiness of the buffers represents the dirtiness of
1098	* subsections of the page. If the page has buffers, the page dirty bit is
1099	* merely a hint about the true dirty state.
1100	*
1101	* When a page is set dirty in its entirety, all its buffers are marked dirty
1102	* (if the page has buffers).
1103	*
1104	* When a buffer is marked dirty, its page is dirtied, but the page's other
1105	* buffers are not.
1106	*
1107	* Also. When blockdev buffers are explicitly read with bread(), they
1108	* individually become uptodate. But their backing page remains not
1109	* uptodate - even if all of its buffers are uptodate. A subsequent
1110	* block_read_full_page() against that page will discover all the uptodate
1111	* buffers, will set the page uptodate and will perform no I/O.
1112	*/
1113
1114	/**
1115	* mark_buffer_dirty - mark a buffer_head as needing writeout
1116	* @bh: the buffer_head to mark dirty
1117	*
1118	* mark_buffer_dirty() will set the dirty bit against the buffer, then set
1119	* its backing page dirty, then tag the page as dirty in the page cache
1120	* and then attach the address_space's inode to its superblock's dirty
1121	* inode list.
1122	*
1123	* mark_buffer_dirty() is atomic. It takes bh->b_page->mapping->private_lock,
1124	* i_pages lock and mapping->host->i_lock.
1125	*/
1126	void mark_buffer_dirty(struct buffer_head *bh)
1127	{
1128	WARN_ON_ONCE(!buffer_uptodate(bh));
1129
1130	trace_block_dirty_buffer(bh);
1131
1132	/*
1133	* Very carefully optimize the it-is-already-dirty case.
1134	*
1135	* Don't let the final "is it dirty" escape to before we
1136	* perhaps modified the buffer.
1137	*/
1138	if (buffer_dirty(bh)) {
1139	smp_mb();
1140	if (buffer_dirty(bh))
1141	return;
1142	}
1143
1144	if (!test_set_buffer_dirty(bh)) {
1145	struct page *page = bh->b_page;
1146	struct address_space *mapping = NULL;
1147
1148	lock_page_memcg(page);
1149	if (!TestSetPageDirty(page)) {
1150	mapping = page_mapping(page);
1151	if (mapping)
1152	__set_page_dirty(page, mapping, 0);
1153	}
1154	unlock_page_memcg(page);
1155	if (mapping)
1156	__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
1157	}
1158	}
1159	EXPORT_SYMBOL(mark_buffer_dirty);
1160
1161	void mark_buffer_write_io_error(struct buffer_head *bh)
1162	{
1163	set_buffer_write_io_error(bh);
1164	/* FIXME: do we need to set this in both places? */
1165	if (bh->b_page && bh->b_page->mapping)
1166	mapping_set_error(bh->b_page->mapping, -EIO);
1167	if (bh->b_assoc_map)
1168	mapping_set_error(bh->b_assoc_map, -EIO);
1169	}
1170	EXPORT_SYMBOL(mark_buffer_write_io_error);
1171
1172	/*
1173	* Decrement a buffer_head's reference count. If all buffers against a page
1174	* have zero reference count, are clean and unlocked, and if the page is clean
1175	* and unlocked then try_to_free_buffers() may strip the buffers from the page
1176	* in preparation for freeing it (sometimes, rarely, buffers are removed from
1177	* a page but it ends up not being freed, and buffers may later be reattached).
1178	*/
1179	void __brelse(struct buffer_head * buf)
1180	{
1181	if (atomic_read(&buf->b_count)) {
1182	put_bh(buf);
1183	return;
1184	}
1185	WARN(1, KERN_ERR "VFS: brelse: Trying to free free buffer\n");
1186	}
1187	EXPORT_SYMBOL(__brelse);
1188
1189	/*
1190	* bforget() is like brelse(), except it discards any
1191	* potentially dirty data.
1192	*/
1193	void __bforget(struct buffer_head *bh)
1194	{
1195	clear_buffer_dirty(bh);
1196	if (bh->b_assoc_map) {
1197	struct address_space *buffer_mapping = bh->b_page->mapping;
1198
1199	spin_lock(&buffer_mapping->private_lock);
1200	list_del_init(&bh->b_assoc_buffers);
1201	bh->b_assoc_map = NULL;
1202	spin_unlock(&buffer_mapping->private_lock);
1203	}
1204	__brelse(bh);
1205	}
1206	EXPORT_SYMBOL(__bforget);
1207
1208	static struct buffer_head __bread_slow(struct buffer_head bh)
1209	{
1210	lock_buffer(bh);
1211	if (buffer_uptodate(bh)) {
1212	unlock_buffer(bh);
1213	return bh;
1214	} else {
1215	get_bh(bh);
1216	bh->b_end_io = end_buffer_read_sync;
1217	submit_bh(REQ_OP_READ, 0, bh);
1218	wait_on_buffer(bh);
1219	if (buffer_uptodate(bh))
1220	return bh;
1221	}
1222	brelse(bh);
1223	return NULL;
1224	}
1225
1226	/*
1227	* Per-cpu buffer LRU implementation. To reduce the cost of __find_get_block().
1228	* The bhs[] array is sorted - newest buffer is at bhs[0]. Buffers have their
1229	* refcount elevated by one when they're in an LRU. A buffer can only appear
1230	* once in a particular CPU's LRU. A single buffer can be present in multiple
1231	* CPU's LRUs at the same time.
1232	*
1233	* This is a transparent caching front-end to sb_bread(), sb_getblk() and
1234	* sb_find_get_block().
1235	*
1236	* The LRUs themselves only need locking against invalidate_bh_lrus. We use
1237	* a local interrupt disable for that.
1238	*/
1239
1240	#define BH_LRU_SIZE 16
1241
1242	struct bh_lru {
1243	struct buffer_head *bhs[BH_LRU_SIZE];
1244	};
1245
1246	static DEFINE_PER_CPU(struct bh_lru, bh_lrus) = {{ NULL }};
1247
1248	#ifdef CONFIG_SMP
1249	#define bh_lru_lock() local_irq_disable()
1250	#define bh_lru_unlock() local_irq_enable()
1251	#else
1252	#define bh_lru_lock() preempt_disable()
1253	#define bh_lru_unlock() preempt_enable()
1254	#endif
1255
1256	static inline void check_irqs_on(void)
1257	{
1258	#ifdef irqs_disabled
1259	BUG_ON(irqs_disabled());
1260	#endif
1261	}
1262
1263	/*
1264	* Install a buffer_head into this cpu's LRU. If not already in the LRU, it is
1265	* inserted at the front, and the buffer_head at the back if any is evicted.
1266	* Or, if already in the LRU it is moved to the front.
1267	*/
1268	static void bh_lru_install(struct buffer_head *bh)
1269	{
1270	struct buffer_head *evictee = bh;
1271	struct bh_lru *b;
1272	int i;
1273
1274	check_irqs_on();
1275	bh_lru_lock();
1276
1277	b = this_cpu_ptr(&bh_lrus);
1278	for (i = 0; i < BH_LRU_SIZE; i++) {
1279	swap(evictee, b->bhs[i]);
1280	if (evictee == bh) {
1281	bh_lru_unlock();
1282	return;
1283	}
1284	}
1285
1286	get_bh(bh);
1287	bh_lru_unlock();
1288	brelse(evictee);
1289	}
1290
1291	/*
1292	* Look up the bh in this cpu's LRU. If it's there, move it to the head.
1293	*/
1294	static struct buffer_head *
1295	lookup_bh_lru(struct block_device *bdev, sector_t block, unsigned size)
1296	{
1297	struct buffer_head *ret = NULL;
1298	unsigned int i;
1299
1300	check_irqs_on();
1301	bh_lru_lock();
1302	for (i = 0; i < BH_LRU_SIZE; i++) {
1303	struct buffer_head *bh = __this_cpu_read(bh_lrus.bhs[i]);
1304
1305	if (bh && bh->b_blocknr == block && bh->b_bdev == bdev &&
1306	bh->b_size == size) {
1307	if (i) {
1308	while (i) {
1309	__this_cpu_write(bh_lrus.bhs[i],
1310	__this_cpu_read(bh_lrus.bhs[i - 1]));
1311	i--;
1312	}
1313	__this_cpu_write(bh_lrus.bhs[0], bh);
1314	}
1315	get_bh(bh);
1316	ret = bh;
1317	break;
1318	}
1319	}
1320	bh_lru_unlock();
1321	return ret;
1322	}
1323
1324	/*
1325	* Perform a pagecache lookup for the matching buffer. If it's there, refresh
1326	* it in the LRU and mark it as accessed. If it is not present then return
1327	* NULL
1328	*/
1329	struct buffer_head *
1330	__find_get_block(struct block_device *bdev, sector_t block, unsigned size)
1331	{
1332	struct buffer_head *bh = lookup_bh_lru(bdev, block, size);
1333
1334	if (bh == NULL) {
1335	/* __find_get_block_slow will mark the page accessed */
1336	bh = __find_get_block_slow(bdev, block);
1337	if (bh)
1338	bh_lru_install(bh);
1339	} else
1340	touch_buffer(bh);
1341
1342	return bh;
1343	}
1344	EXPORT_SYMBOL(__find_get_block);
1345
1346	/*
1347	* __getblk_gfp() will locate (and, if necessary, create) the buffer_head
1348	* which corresponds to the passed block_device, block and size. The
1349	* returned buffer has its reference count incremented.
1350	*
1351	* __getblk_gfp() will lock up the machine if grow_dev_page's
1352	* try_to_free_buffers() attempt is failing. FIXME, perhaps?
1353	*/
1354	struct buffer_head *
1355	__getblk_gfp(struct block_device *bdev, sector_t block,
1356	unsigned size, gfp_t gfp)
1357	{
1358	struct buffer_head *bh = __find_get_block(bdev, block, size);
1359
1360	might_sleep();
1361	if (bh == NULL)
1362	bh = __getblk_slow(bdev, block, size, gfp);
1363	return bh;
1364	}
1365	EXPORT_SYMBOL(__getblk_gfp);
1366
1367	/*
1368	* Do async read-ahead on a buffer..
1369	*/
1370	void __breadahead(struct block_device *bdev, sector_t block, unsigned size)
1371	{
1372	struct buffer_head *bh = __getblk(bdev, block, size);
1373	if (likely(bh)) {
1374	ll_rw_block(REQ_OP_READ, REQ_RAHEAD, 1, &bh);
1375	brelse(bh);
1376	}
1377	}
1378	EXPORT_SYMBOL(__breadahead);
1379
1380	/**
1381	* __bread_gfp() - reads a specified block and returns the bh
1382	* @bdev: the block_device to read from
1383	* @block: number of block
1384	* @size: size (in bytes) to read
1385	* @gfp: page allocation flag
1386	*
1387	* Reads a specified block, and returns buffer head that contains it.
1388	* The page cache can be allocated from non-movable area
1389	* not to prevent page migration if you set gfp to zero.
1390	* It returns NULL if the block was unreadable.
1391	*/
1392	struct buffer_head *
1393	__bread_gfp(struct block_device *bdev, sector_t block,
1394	unsigned size, gfp_t gfp)
1395	{
1396	struct buffer_head *bh = __getblk_gfp(bdev, block, size, gfp);
1397
1398	if (likely(bh) && !buffer_uptodate(bh))
1399	bh = __bread_slow(bh);
1400	return bh;
1401	}
1402	EXPORT_SYMBOL(__bread_gfp);
1403
1404	/*
1405	* invalidate_bh_lrus() is called rarely - but not only at unmount.
1406	* This doesn't race because it runs in each cpu either in irq
1407	* or with preempt disabled.
1408	*/
1409	static void invalidate_bh_lru(void *arg)
1410	{
1411	struct bh_lru *b = &get_cpu_var(bh_lrus);
1412	int i;
1413
1414	for (i = 0; i < BH_LRU_SIZE; i++) {
1415	brelse(b->bhs[i]);
1416	b->bhs[i] = NULL;
1417	}
1418	put_cpu_var(bh_lrus);
1419	}
1420
1421	static bool has_bh_in_lru(int cpu, void *dummy)
1422	{
1423	struct bh_lru *b = per_cpu_ptr(&bh_lrus, cpu);
1424	int i;
1425
1426	for (i = 0; i < BH_LRU_SIZE; i++) {
1427	if (b->bhs[i])
1428	return true;
1429	}
1430
1431	return false;
1432	}
1433
1434	void invalidate_bh_lrus(void)
1435	{
1436	on_each_cpu_cond(has_bh_in_lru, invalidate_bh_lru, NULL, 1, GFP_KERNEL);
1437	}
1438	EXPORT_SYMBOL_GPL(invalidate_bh_lrus);
1439
1440	void set_bh_page(struct buffer_head *bh,
1441	struct page *page, unsigned long offset)
1442	{
1443	bh->b_page = page;
1444	BUG_ON(offset >= PAGE_SIZE);
1445	if (PageHighMem(page))
1446	/*
1447	* This catches illegal uses and preserves the offset:
1448	*/
1449	bh->b_data = (char *)(0 + offset);
1450	else
1451	bh->b_data = page_address(page) + offset;
1452	}
1453	EXPORT_SYMBOL(set_bh_page);
1454
1455	/*
1456	* Called when truncating a buffer on a page completely.
1457	*/
1458
1459	/* Bits that are cleared during an invalidate */
1460	#define BUFFER_FLAGS_DISCARD \
1461	(1 << BH_Mapped \| 1 << BH_New \| 1 << BH_Req \| \
1462	1 << BH_Delay \| 1 << BH_Unwritten)
1463
1464	static void discard_buffer(struct buffer_head * bh)
1465	{
1466	unsigned long b_state, b_state_old;
1467
1468	lock_buffer(bh);
1469	clear_buffer_dirty(bh);
1470	bh->b_bdev = NULL;
1471	b_state = bh->b_state;
1472	for (;;) {
1473	b_state_old = cmpxchg(&bh->b_state, b_state,
1474	(b_state & ~BUFFER_FLAGS_DISCARD));
1475	if (b_state_old == b_state)
1476	break;
1477	b_state = b_state_old;
1478	}
1479	unlock_buffer(bh);
1480	}
1481
1482	/**
1483	* block_invalidatepage - invalidate part or all of a buffer-backed page
1484	*
1485	* @page: the page which is affected
1486	* @offset: start of the range to invalidate
1487	* @length: length of the range to invalidate
1488	*
1489	* block_invalidatepage() is called when all or part of the page has become
1490	* invalidated by a truncate operation.
1491	*
1492	* block_invalidatepage() does not have to release all buffers, but it must
1493	* ensure that no dirty buffer is left outside @offset and that no I/O
1494	* is underway against any of the blocks which are outside the truncation
1495	* point. Because the caller is about to free (and possibly reuse) those
1496	* blocks on-disk.
1497	*/
1498	void block_invalidatepage(struct page *page, unsigned int offset,
1499	unsigned int length)
1500	{
1501	struct buffer_head head, bh, *next;
1502	unsigned int curr_off = 0;
1503	unsigned int stop = length + offset;
1504
1505	BUG_ON(!PageLocked(page));
1506	if (!page_has_buffers(page))
1507	goto out;
1508
1509	/*
1510	* Check for overflow
1511	*/
1512	BUG_ON(stop > PAGE_SIZE \|\| stop < length);
1513
1514	head = page_buffers(page);
1515	bh = head;
1516	do {
1517	unsigned int next_off = curr_off + bh->b_size;
1518	next = bh->b_this_page;
1519
1520	/*
1521	* Are we still fully in range ?
1522	*/
1523	if (next_off > stop)
1524	goto out;
1525
1526	/*
1527	* is this block fully invalidated?
1528	*/
1529	if (offset <= curr_off)
1530	discard_buffer(bh);
1531	curr_off = next_off;
1532	bh = next;
1533	} while (bh != head);
1534
1535	/*
1536	* We release buffers only if the entire page is being invalidated.
1537	* The get_block cached value has been unconditionally invalidated,
1538	* so real IO is not possible anymore.
1539	*/
1540	if (length == PAGE_SIZE)
1541	try_to_release_page(page, 0);
1542	out:
1543	return;
1544	}
1545	EXPORT_SYMBOL(block_invalidatepage);
1546
1547
1548	/*
1549	* We attach and possibly dirty the buffers atomically wrt
1550	* __set_page_dirty_buffers() via private_lock. try_to_free_buffers
1551	* is already excluded via the page lock.
1552	*/
1553	void create_empty_buffers(struct page *page,
1554	unsigned long blocksize, unsigned long b_state)
1555	{
1556	struct buffer_head bh, head, *tail;
1557
1558	head = alloc_page_buffers(page, blocksize, true);
1559	bh = head;
1560	do {
1561	bh->b_state \|= b_state;
1562	tail = bh;
1563	bh = bh->b_this_page;
1564	} while (bh);
1565	tail->b_this_page = head;
1566
1567	spin_lock(&page->mapping->private_lock);
1568	if (PageUptodate(page) \|\| PageDirty(page)) {
1569	bh = head;
1570	do {
1571	if (PageDirty(page))
1572	set_buffer_dirty(bh);
1573	if (PageUptodate(page))
1574	set_buffer_uptodate(bh);
1575	bh = bh->b_this_page;
1576	} while (bh != head);
1577	}
1578	attach_page_buffers(page, head);
1579	spin_unlock(&page->mapping->private_lock);
1580	}
1581	EXPORT_SYMBOL(create_empty_buffers);
1582
1583	/**
1584	* clean_bdev_aliases: clean a range of buffers in block device
1585	* @bdev: Block device to clean buffers in
1586	* @block: Start of a range of blocks to clean
1587	* @len: Number of blocks to clean
1588	*
1589	* We are taking a range of blocks for data and we don't want writeback of any
1590	* buffer-cache aliases starting from return from this function and until the
1591	* moment when something will explicitly mark the buffer dirty (hopefully that
1592	* will not happen until we will free that block ;-) We don't even need to mark
1593	* it not-uptodate - nobody can expect anything from a newly allocated buffer
1594	* anyway. We used to use unmap_buffer() for such invalidation, but that was
1595	* wrong. We definitely don't want to mark the alias unmapped, for example - it
1596	* would confuse anyone who might pick it with bread() afterwards...
1597	*
1598	* Also.. Note that bforget() doesn't lock the buffer. So there can be
1599	* writeout I/O going on against recently-freed buffers. We don't wait on that
1600	* I/O in bforget() - it's more efficient to wait on the I/O only if we really
1601	* need to. That happens here.
1602	*/
1603	void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len)
1604	{
1605	struct inode *bd_inode = bdev->bd_inode;
1606	struct address_space *bd_mapping = bd_inode->i_mapping;
1607	struct pagevec pvec;
1608	pgoff_t index = block >> (PAGE_SHIFT - bd_inode->i_blkbits);
1609	pgoff_t end;
1610	int i, count;
1611	struct buffer_head *bh;
1612	struct buffer_head *head;
1613
1614	end = (block + len - 1) >> (PAGE_SHIFT - bd_inode->i_blkbits);
1615	pagevec_init(&pvec);
1616	while (pagevec_lookup_range(&pvec, bd_mapping, &index, end)) {
1617	count = pagevec_count(&pvec);
1618	for (i = 0; i < count; i++) {
1619	struct page *page = pvec.pages[i];
1620
1621	if (!page_has_buffers(page))
1622	continue;
1623	/*
1624	* We use page lock instead of bd_mapping->private_lock
1625	* to pin buffers here since we can afford to sleep and
1626	* it scales better than a global spinlock lock.
1627	*/
1628	lock_page(page);
1629	/* Recheck when the page is locked which pins bhs */
1630	if (!page_has_buffers(page))
1631	goto unlock_page;
1632	head = page_buffers(page);
1633	bh = head;
1634	do {
1635	if (!buffer_mapped(bh) \|\| (bh->b_blocknr < block))
1636	goto next;
1637	if (bh->b_blocknr >= block + len)
1638	break;
1639	clear_buffer_dirty(bh);
1640	wait_on_buffer(bh);
1641	clear_buffer_req(bh);
1642	next:
1643	bh = bh->b_this_page;
1644	} while (bh != head);
1645	unlock_page:
1646	unlock_page(page);
1647	}
1648	pagevec_release(&pvec);
1649	cond_resched();
1650	/* End of range already reached? */
1651	if (index > end \|\| !index)
1652	break;
1653	}
1654	}
1655	EXPORT_SYMBOL(clean_bdev_aliases);
1656
1657	/*
1658	* Size is a power-of-two in the range 512..PAGE_SIZE,
1659	* and the case we care about most is PAGE_SIZE.
1660	*
1661	* So this could possibly be written with those
1662	* constraints in mind (relevant mostly if some
1663	* architecture has a slow bit-scan instruction)
1664	*/
1665	static inline int block_size_bits(unsigned int blocksize)
1666	{
1667	return ilog2(blocksize);
1668	}
1669
1670	static struct buffer_head create_page_buffers(struct page page, struct inode *inode, unsigned int b_state)
1671	{
1672	BUG_ON(!PageLocked(page));
1673
1674	if (!page_has_buffers(page))
1675	create_empty_buffers(page, 1 << READ_ONCE(inode->i_blkbits),
1676	b_state);
1677	return page_buffers(page);
1678	}
1679
1680	/*
1681	* NOTE! All mapped/uptodate combinations are valid:
1682	*
1683	* Mapped Uptodate Meaning
1684	*
1685	* No No "unknown" - must do get_block()
1686	* No Yes "hole" - zero-filled
1687	* Yes No "allocated" - allocated on disk, not read in
1688	* Yes Yes "valid" - allocated and up-to-date in memory.
1689	*
1690	* "Dirty" is valid only with the last case (mapped+uptodate).
1691	*/
1692
1693	/*
1694	* While block_write_full_page is writing back the dirty buffers under
1695	* the page lock, whoever dirtied the buffers may decide to clean them
1696	* again at any time. We handle that by only looking at the buffer
1697	* state inside lock_buffer().
1698	*
1699	* If block_write_full_page() is called for regular writeback
1700	* (wbc->sync_mode == WB_SYNC_NONE) then it will redirty a page which has a
1701	* locked buffer. This only can happen if someone has written the buffer
1702	* directly, with submit_bh(). At the address_space level PageWriteback
1703	* prevents this contention from occurring.
1704	*
1705	* If block_write_full_page() is called with wbc->sync_mode ==
1706	* WB_SYNC_ALL, the writes are posted using REQ_SYNC; this
1707	* causes the writes to be flagged as synchronous writes.
1708	*/
1709	int __block_write_full_page(struct inode inode, struct page page,
1710	get_block_t get_block, struct writeback_control wbc,
1711	bh_end_io_t *handler)
1712	{
1713	int err;
1714	sector_t block;
1715	sector_t last_block;
1716	struct buffer_head bh, head;
1717	unsigned int blocksize, bbits;
1718	int nr_underway = 0;
1719	int write_flags = wbc_to_write_flags(wbc);
1720
1721	head = create_page_buffers(page, inode,
1722	(1 << BH_Dirty)\|(1 << BH_Uptodate));
1723
1724	/*
1725	* Be very careful. We have no exclusion from __set_page_dirty_buffers
1726	* here, and the (potentially unmapped) buffers may become dirty at
1727	* any time. If a buffer becomes dirty here after we've inspected it
1728	* then we just miss that fact, and the page stays dirty.
1729	*
1730	* Buffers outside i_size may be dirtied by __set_page_dirty_buffers;
1731	* handle that here by just cleaning them.
1732	*/
1733
1734	bh = head;
1735	blocksize = bh->b_size;
1736	bbits = block_size_bits(blocksize);
1737
1738	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
1739	last_block = (i_size_read(inode) - 1) >> bbits;
1740
1741	/*
1742	* Get all the dirty buffers mapped to disk addresses and
1743	* handle any aliases from the underlying blockdev's mapping.
1744	*/
1745	do {
1746	if (block > last_block) {
1747	/*
1748	* mapped buffers outside i_size will occur, because
1749	* this page can be outside i_size when there is a
1750	* truncate in progress.
1751	*/
1752	/*
1753	* The buffer was zeroed by block_write_full_page()
1754	*/
1755	clear_buffer_dirty(bh);
1756	set_buffer_uptodate(bh);
1757	} else if ((!buffer_mapped(bh) \|\| buffer_delay(bh)) &&
1758	buffer_dirty(bh)) {
1759	WARN_ON(bh->b_size != blocksize);
1760	err = get_block(inode, block, bh, 1);
1761	if (err)
1762	goto recover;
1763	clear_buffer_delay(bh);
1764	if (buffer_new(bh)) {
1765	/* blockdev mappings never come here */
1766	clear_buffer_new(bh);
1767	clean_bdev_bh_alias(bh);
1768	}
1769	}
1770	bh = bh->b_this_page;
1771	block++;
1772	} while (bh != head);
1773
1774	do {
1775	if (!buffer_mapped(bh))
1776	continue;
1777	/*
1778	* If it's a fully non-blocking write attempt and we cannot
1779	* lock the buffer then redirty the page. Note that this can
1780	* potentially cause a busy-wait loop from writeback threads
1781	* and kswapd activity, but those code paths have their own
1782	* higher-level throttling.
1783	*/
1784	if (wbc->sync_mode != WB_SYNC_NONE) {
1785	lock_buffer(bh);
1786	} else if (!trylock_buffer(bh)) {
1787	redirty_page_for_writepage(wbc, page);
1788	continue;
1789	}
1790	if (test_clear_buffer_dirty(bh)) {
1791	mark_buffer_async_write_endio(bh, handler);
1792	} else {
1793	unlock_buffer(bh);
1794	}
1795	} while ((bh = bh->b_this_page) != head);
1796
1797	/*
1798	* The page and its buffers are protected by PageWriteback(), so we can
1799	* drop the bh refcounts early.
1800	*/
1801	BUG_ON(PageWriteback(page));
1802	set_page_writeback(page);
1803
1804	do {
1805	struct buffer_head *next = bh->b_this_page;
1806	if (buffer_async_write(bh)) {
1807	submit_bh_wbc(REQ_OP_WRITE, write_flags, bh,
1808	inode->i_write_hint, wbc);
1809	nr_underway++;
1810	}
1811	bh = next;
1812	} while (bh != head);
1813	unlock_page(page);
1814
1815	err = 0;
1816	done:
1817	if (nr_underway == 0) {
1818	/*
1819	* The page was marked dirty, but the buffers were
1820	* clean. Someone wrote them back by hand with
1821	* ll_rw_block/submit_bh. A rare case.
1822	*/
1823	end_page_writeback(page);
1824
1825	/*
1826	* The page and buffer_heads can be released at any time from
1827	* here on.
1828	*/
1829	}
1830	return err;
1831
1832	recover:
1833	/*
1834	* ENOSPC, or some other error. We may already have added some
1835	* blocks to the file, so we need to write these out to avoid
1836	* exposing stale data.
1837	* The page is currently locked and not marked for writeback
1838	*/
1839	bh = head;
1840	/* Recovery: lock and submit the mapped buffers */
1841	do {
1842	if (buffer_mapped(bh) && buffer_dirty(bh) &&
1843	!buffer_delay(bh)) {
1844	lock_buffer(bh);
1845	mark_buffer_async_write_endio(bh, handler);
1846	} else {
1847	/*
1848	* The buffer may have been set dirty during
1849	* attachment to a dirty page.
1850	*/
1851	clear_buffer_dirty(bh);
1852	}
1853	} while ((bh = bh->b_this_page) != head);
1854	SetPageError(page);
1855	BUG_ON(PageWriteback(page));
1856	mapping_set_error(page->mapping, err);
1857	set_page_writeback(page);
1858	do {
1859	struct buffer_head *next = bh->b_this_page;
1860	if (buffer_async_write(bh)) {
1861	clear_buffer_dirty(bh);
1862	submit_bh_wbc(REQ_OP_WRITE, write_flags, bh,
1863	inode->i_write_hint, wbc);
1864	nr_underway++;
1865	}
1866	bh = next;
1867	} while (bh != head);
1868	unlock_page(page);
1869	goto done;
1870	}
1871	EXPORT_SYMBOL(__block_write_full_page);
1872
1873	/*
1874	* If a page has any new buffers, zero them out here, and mark them uptodate
1875	* and dirty so they'll be written out (in order to prevent uninitialised
1876	* block data from leaking). And clear the new bit.
1877	*/
1878	void page_zero_new_buffers(struct page *page, unsigned from, unsigned to)
1879	{
1880	unsigned int block_start, block_end;
1881	struct buffer_head head, bh;
1882
1883	BUG_ON(!PageLocked(page));
1884	if (!page_has_buffers(page))
1885	return;
1886
1887	bh = head = page_buffers(page);
1888	block_start = 0;
1889	do {
1890	block_end = block_start + bh->b_size;
1891
1892	if (buffer_new(bh)) {
1893	if (block_end > from && block_start < to) {
1894	if (!PageUptodate(page)) {
1895	unsigned start, size;
1896
1897	start = max(from, block_start);
1898	size = min(to, block_end) - start;
1899
1900	zero_user(page, start, size);
1901	set_buffer_uptodate(bh);
1902	}
1903
1904	clear_buffer_new(bh);
1905	mark_buffer_dirty(bh);
1906	}
1907	}
1908
1909	block_start = block_end;
1910	bh = bh->b_this_page;
1911	} while (bh != head);
1912	}
1913	EXPORT_SYMBOL(page_zero_new_buffers);
1914
1915	static void
1916	iomap_to_bh(struct inode inode, sector_t block, struct buffer_head bh,
1917	struct iomap *iomap)
1918	{
1919	loff_t offset = block << inode->i_blkbits;
1920
1921	bh->b_bdev = iomap->bdev;
1922
1923	/*
1924	* Block points to offset in file we need to map, iomap contains
1925	* the offset at which the map starts. If the map ends before the
1926	* current block, then do not map the buffer and let the caller
1927	* handle it.
1928	*/
1929	BUG_ON(offset >= iomap->offset + iomap->length);
1930
1931	switch (iomap->type) {
1932	case IOMAP_HOLE:
1933	/*
1934	* If the buffer is not up to date or beyond the current EOF,
1935	* we need to mark it as new to ensure sub-block zeroing is
1936	* executed if necessary.
1937	*/
1938	if (!buffer_uptodate(bh) \|\|
1939	(offset >= i_size_read(inode)))
1940	set_buffer_new(bh);
1941	break;
1942	case IOMAP_DELALLOC:
1943	if (!buffer_uptodate(bh) \|\|
1944	(offset >= i_size_read(inode)))
1945	set_buffer_new(bh);
1946	set_buffer_uptodate(bh);
1947	set_buffer_mapped(bh);
1948	set_buffer_delay(bh);
1949	break;
1950	case IOMAP_UNWRITTEN:
1951	/*
1952	* For unwritten regions, we always need to ensure that regions
1953	* in the block we are not writing to are zeroed. Mark the
1954	* buffer as new to ensure this.
1955	*/
1956	set_buffer_new(bh);
1957	set_buffer_unwritten(bh);
1958	/* FALLTHRU */
1959	case IOMAP_MAPPED:
1960	if ((iomap->flags & IOMAP_F_NEW) \|\|
1961	offset >= i_size_read(inode))
1962	set_buffer_new(bh);
1963	bh->b_blocknr = (iomap->addr + offset - iomap->offset) >>
1964	inode->i_blkbits;
1965	set_buffer_mapped(bh);
1966	break;
1967	}
1968	}
1969
1970	int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
1971	get_block_t get_block, struct iomap iomap)
1972	{
1973	unsigned from = pos & (PAGE_SIZE - 1);
1974	unsigned to = from + len;
1975	struct inode *inode = page->mapping->host;
1976	unsigned block_start, block_end;
1977	sector_t block;
1978	int err = 0;
1979	unsigned blocksize, bbits;
1980	struct buffer_head bh, head, wait[2], *wait_bh=wait;
1981
1982	BUG_ON(!PageLocked(page));
1983	BUG_ON(from > PAGE_SIZE);
1984	BUG_ON(to > PAGE_SIZE);
1985	BUG_ON(from > to);
1986
1987	head = create_page_buffers(page, inode, 0);
1988	blocksize = head->b_size;
1989	bbits = block_size_bits(blocksize);
1990
1991	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
1992
1993	for(bh = head, block_start = 0; bh != head \|\| !block_start;
1994	block++, block_start=block_end, bh = bh->b_this_page) {
1995	block_end = block_start + blocksize;
1996	if (block_end <= from \|\| block_start >= to) {
1997	if (PageUptodate(page)) {
1998	if (!buffer_uptodate(bh))
1999	set_buffer_uptodate(bh);
2000	}
2001	continue;
2002	}
2003	if (buffer_new(bh))
2004	clear_buffer_new(bh);
2005	if (!buffer_mapped(bh)) {
2006	WARN_ON(bh->b_size != blocksize);
2007	if (get_block) {
2008	err = get_block(inode, block, bh, 1);
2009	if (err)
2010	break;
2011	} else {
2012	iomap_to_bh(inode, block, bh, iomap);
2013	}
2014
2015	if (buffer_new(bh)) {
2016	clean_bdev_bh_alias(bh);
2017	if (PageUptodate(page)) {
2018	clear_buffer_new(bh);
2019	set_buffer_uptodate(bh);
2020	mark_buffer_dirty(bh);
2021	continue;
2022	}
2023	if (block_end > to \|\| block_start < from)
2024	zero_user_segments(page,
2025	to, block_end,
2026	block_start, from);
2027	continue;
2028	}
2029	}
2030	if (PageUptodate(page)) {
2031	if (!buffer_uptodate(bh))
2032	set_buffer_uptodate(bh);
2033	continue;
2034	}
2035	if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
2036	!buffer_unwritten(bh) &&
2037	(block_start < from \|\| block_end > to)) {
2038	ll_rw_block(REQ_OP_READ, 0, 1, &bh);
2039	*wait_bh++=bh;
2040	}
2041	}
2042	/*
2043	* If we issued read requests - let them complete.
2044	*/
2045	while(wait_bh > wait) {
2046	wait_on_buffer(*--wait_bh);
2047	if (!buffer_uptodate(*wait_bh))
2048	err = -EIO;
2049	}
2050	if (unlikely(err))
2051	page_zero_new_buffers(page, from, to);
2052	return err;
2053	}
2054
2055	int __block_write_begin(struct page *page, loff_t pos, unsigned len,
2056	get_block_t *get_block)
2057	{
2058	return __block_write_begin_int(page, pos, len, get_block, NULL);
2059	}
2060	EXPORT_SYMBOL(__block_write_begin);
2061
2062	static int __block_commit_write(struct inode inode, struct page page,
2063	unsigned from, unsigned to)
2064	{
2065	unsigned block_start, block_end;
2066	int partial = 0;
2067	unsigned blocksize;
2068	struct buffer_head bh, head;
2069
2070	bh = head = page_buffers(page);
2071	blocksize = bh->b_size;
2072
2073	block_start = 0;
2074	do {
2075	block_end = block_start + blocksize;
2076	if (block_end <= from \|\| block_start >= to) {
2077	if (!buffer_uptodate(bh))
2078	partial = 1;
2079	} else {
2080	set_buffer_uptodate(bh);
2081	mark_buffer_dirty(bh);
2082	}
2083	clear_buffer_new(bh);
2084
2085	block_start = block_end;
2086	bh = bh->b_this_page;
2087	} while (bh != head);
2088
2089	/*
2090	* If this is a partial write which happened to make all buffers
2091	* uptodate then we can optimize away a bogus readpage() for
2092	* the next read(). Here we 'discover' whether the page went
2093	* uptodate as a result of this (potentially partial) write.
2094	*/
2095	if (!partial)
2096	SetPageUptodate(page);
2097	return 0;
2098	}
2099
2100	/*
2101	* block_write_begin takes care of the basic task of block allocation and
2102	* bringing partial write blocks uptodate first.
2103	*
2104	* The filesystem needs to handle block truncation upon failure.
2105	*/
2106	int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
2107	unsigned flags, struct page *pagep, get_block_t get_block)
2108	{
2109	pgoff_t index = pos >> PAGE_SHIFT;
2110	struct page *page;
2111	int status;
2112
2113	page = grab_cache_page_write_begin(mapping, index, flags);
2114	if (!page)
2115	return -ENOMEM;
2116
2117	status = __block_write_begin(page, pos, len, get_block);
2118	if (unlikely(status)) {
2119	unlock_page(page);
2120	put_page(page);
2121	page = NULL;
2122	}
2123
2124	*pagep = page;
2125	return status;
2126	}
2127	EXPORT_SYMBOL(block_write_begin);
2128
2129	int block_write_end(struct file file, struct address_space mapping,
2130	loff_t pos, unsigned len, unsigned copied,
2131	struct page page, void fsdata)
2132	{
2133	struct inode *inode = mapping->host;
2134	unsigned start;
2135
2136	start = pos & (PAGE_SIZE - 1);
2137
2138	if (unlikely(copied < len)) {
2139	/*
2140	* The buffers that were written will now be uptodate, so we
2141	* don't have to worry about a readpage reading them and
2142	* overwriting a partial write. However if we have encountered
2143	* a short write and only partially written into a buffer, it
2144	* will not be marked uptodate, so a readpage might come in and
2145	* destroy our partial write.
2146	*
2147	* Do the simplest thing, and just treat any short write to a
2148	* non uptodate page as a zero-length write, and force the
2149	* caller to redo the whole thing.
2150	*/
2151	if (!PageUptodate(page))
2152	copied = 0;
2153
2154	page_zero_new_buffers(page, start+copied, start+len);
2155	}
2156	flush_dcache_page(page);
2157
2158	/* This could be a short (even 0-length) commit */
2159	__block_commit_write(inode, page, start, start+copied);
2160
2161	return copied;
2162	}
2163	EXPORT_SYMBOL(block_write_end);
2164
2165	int generic_write_end(struct file file, struct address_space mapping,
2166	loff_t pos, unsigned len, unsigned copied,
2167	struct page page, void fsdata)
2168	{
2169	struct inode *inode = mapping->host;
2170	loff_t old_size = inode->i_size;
2171	bool i_size_changed = false;
2172
2173	copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
2174
2175	/*
2176	* No need to use i_size_read() here, the i_size cannot change under us
2177	* because we hold i_rwsem.
2178	*
2179	* But it's important to update i_size while still holding page lock:
2180	* page writeout could otherwise come in and zero beyond i_size.
2181	*/
2182	if (pos + copied > inode->i_size) {
2183	i_size_write(inode, pos + copied);
2184	i_size_changed = true;
2185	}
2186
2187	unlock_page(page);
2188	put_page(page);
2189
2190	if (old_size < pos)
2191	pagecache_isize_extended(inode, old_size, pos);
2192	/*
2193	* Don't mark the inode dirty under page lock. First, it unnecessarily
2194	* makes the holding time of page lock longer. Second, it forces lock
2195	* ordering of page lock and transaction start for journaling
2196	* filesystems.
2197	*/
2198	if (i_size_changed)
2199	mark_inode_dirty(inode);
2200	return copied;
2201	}
2202	EXPORT_SYMBOL(generic_write_end);
2203
2204	/*
2205	* block_is_partially_uptodate checks whether buffers within a page are
2206	* uptodate or not.
2207	*
2208	* Returns true if all buffers which correspond to a file portion
2209	* we want to read are uptodate.
2210	*/
2211	int block_is_partially_uptodate(struct page *page, unsigned long from,
2212	unsigned long count)
2213	{
2214	unsigned block_start, block_end, blocksize;
2215	unsigned to;
2216	struct buffer_head bh, head;
2217	int ret = 1;
2218
2219	if (!page_has_buffers(page))
2220	return 0;
2221
2222	head = page_buffers(page);
2223	blocksize = head->b_size;
2224	to = min_t(unsigned, PAGE_SIZE - from, count);
2225	to = from + to;
2226	if (from < blocksize && to > PAGE_SIZE - blocksize)
2227	return 0;
2228
2229	bh = head;
2230	block_start = 0;
2231	do {
2232	block_end = block_start + blocksize;
2233	if (block_end > from && block_start < to) {
2234	if (!buffer_uptodate(bh)) {
2235	ret = 0;
2236	break;
2237	}
2238	if (block_end >= to)
2239	break;
2240	}
2241	block_start = block_end;
2242	bh = bh->b_this_page;
2243	} while (bh != head);
2244
2245	return ret;
2246	}
2247	EXPORT_SYMBOL(block_is_partially_uptodate);
2248
2249	/*
2250	* Generic "read page" function for block devices that have the normal
2251	* get_block functionality. This is most of the block device filesystems.
2252	* Reads the page asynchronously --- the unlock_buffer() and
2253	* set/clear_buffer_uptodate() functions propagate buffer state into the
2254	* page struct once IO has completed.
2255	*/
2256	int block_read_full_page(struct page page, get_block_t get_block)
2257	{
2258	struct inode *inode = page->mapping->host;
2259	sector_t iblock, lblock;
2260	struct buffer_head bh, head, *arr[MAX_BUF_PER_PAGE];
2261	unsigned int blocksize, bbits;
2262	int nr, i;
2263	int fully_mapped = 1;
2264
2265	head = create_page_buffers(page, inode, 0);
2266	blocksize = head->b_size;
2267	bbits = block_size_bits(blocksize);
2268
2269	iblock = (sector_t)page->index << (PAGE_SHIFT - bbits);
2270	lblock = (i_size_read(inode)+blocksize-1) >> bbits;
2271	bh = head;
2272	nr = 0;
2273	i = 0;
2274
2275	do {
2276	if (buffer_uptodate(bh))
2277	continue;
2278
2279	if (!buffer_mapped(bh)) {
2280	int err = 0;
2281
2282	fully_mapped = 0;
2283	if (iblock < lblock) {
2284	WARN_ON(bh->b_size != blocksize);
2285	err = get_block(inode, iblock, bh, 0);
2286	if (err)
2287	SetPageError(page);
2288	}
2289	if (!buffer_mapped(bh)) {
2290	zero_user(page, i * blocksize, blocksize);
2291	if (!err)
2292	set_buffer_uptodate(bh);
2293	continue;
2294	}
2295	/*
2296	* get_block() might have updated the buffer
2297	* synchronously
2298	*/
2299	if (buffer_uptodate(bh))
2300	continue;
2301	}
2302	arr[nr++] = bh;
2303	} while (i++, iblock++, (bh = bh->b_this_page) != head);
2304
2305	if (fully_mapped)
2306	SetPageMappedToDisk(page);
2307
2308	if (!nr) {
2309	/*
2310	* All buffers are uptodate - we can set the page uptodate
2311	* as well. But not if get_block() returned an error.
2312	*/
2313	if (!PageError(page))
2314	SetPageUptodate(page);
2315	unlock_page(page);
2316	return 0;
2317	}
2318
2319	/* Stage two: lock the buffers */
2320	for (i = 0; i < nr; i++) {
2321	bh = arr[i];
2322	lock_buffer(bh);
2323	mark_buffer_async_read(bh);
2324	}
2325
2326	/*
2327	* Stage 3: start the IO. Check for uptodateness
2328	* inside the buffer lock in case another process reading
2329	* the underlying blockdev brought it uptodate (the sct fix).
2330	*/
2331	for (i = 0; i < nr; i++) {
2332	bh = arr[i];
2333	if (buffer_uptodate(bh))
2334	end_buffer_async_read(bh, 1);
2335	else
2336	submit_bh(REQ_OP_READ, 0, bh);
2337	}
2338	return 0;
2339	}
2340	EXPORT_SYMBOL(block_read_full_page);
2341
2342	/* utility function for filesystems that need to do work on expanding
2343	* truncates. Uses filesystem pagecache writes to allow the filesystem to
2344	* deal with the hole.
2345	*/
2346	int generic_cont_expand_simple(struct inode *inode, loff_t size)
2347	{
2348	struct address_space *mapping = inode->i_mapping;
2349	struct page *page;
2350	void *fsdata;
2351	int err;
2352
2353	err = inode_newsize_ok(inode, size);
2354	if (err)
2355	goto out;
2356
2357	err = pagecache_write_begin(NULL, mapping, size, 0,
2358	AOP_FLAG_CONT_EXPAND, &page, &fsdata);
2359	if (err)
2360	goto out;
2361
2362	err = pagecache_write_end(NULL, mapping, size, 0, 0, page, fsdata);
2363	BUG_ON(err > 0);
2364
2365	out:
2366	return err;
2367	}
2368	EXPORT_SYMBOL(generic_cont_expand_simple);
2369
2370	static int cont_expand_zero(struct file file, struct address_space mapping,
2371	loff_t pos, loff_t *bytes)
2372	{
2373	struct inode *inode = mapping->host;
2374	unsigned int blocksize = i_blocksize(inode);
2375	struct page *page;
2376	void *fsdata;
2377	pgoff_t index, curidx;
2378	loff_t curpos;
2379	unsigned zerofrom, offset, len;
2380	int err = 0;
2381
2382	index = pos >> PAGE_SHIFT;
2383	offset = pos & ~PAGE_MASK;
2384
2385	while (index > (curidx = (curpos = *bytes)>>PAGE_SHIFT)) {
2386	zerofrom = curpos & ~PAGE_MASK;
2387	if (zerofrom & (blocksize-1)) {
2388	*bytes \|= (blocksize-1);
2389	(*bytes)++;
2390	}
2391	len = PAGE_SIZE - zerofrom;
2392
2393	err = pagecache_write_begin(file, mapping, curpos, len, 0,
2394	&page, &fsdata);
2395	if (err)
2396	goto out;
2397	zero_user(page, zerofrom, len);
2398	err = pagecache_write_end(file, mapping, curpos, len, len,
2399	page, fsdata);
2400	if (err < 0)
2401	goto out;
2402	BUG_ON(err != len);
2403	err = 0;
2404
2405	balance_dirty_pages_ratelimited(mapping);
2406
2407	if (fatal_signal_pending(current)) {
2408	err = -EINTR;
2409	goto out;
2410	}
2411	}
2412
2413	/* page covers the boundary, find the boundary offset */
2414	if (index == curidx) {
2415	zerofrom = curpos & ~PAGE_MASK;
2416	/* if we will expand the thing last block will be filled */
2417	if (offset <= zerofrom) {
2418	goto out;
2419	}
2420	if (zerofrom & (blocksize-1)) {
2421	*bytes \|= (blocksize-1);
2422	(*bytes)++;
2423	}
2424	len = offset - zerofrom;
2425
2426	err = pagecache_write_begin(file, mapping, curpos, len, 0,
2427	&page, &fsdata);
2428	if (err)
2429	goto out;
2430	zero_user(page, zerofrom, len);
2431	err = pagecache_write_end(file, mapping, curpos, len, len,
2432	page, fsdata);
2433	if (err < 0)
2434	goto out;
2435	BUG_ON(err != len);
2436	err = 0;
2437	}
2438	out:
2439	return err;
2440	}
2441
2442	/*
2443	* For moronic filesystems that do not allow holes in file.
2444	* We may have to extend the file.
2445	*/
2446	int cont_write_begin(struct file file, struct address_space mapping,
2447	loff_t pos, unsigned len, unsigned flags,
2448	struct page pagep, void fsdata,
2449	get_block_t get_block, loff_t bytes)
2450	{
2451	struct inode *inode = mapping->host;
2452	unsigned int blocksize = i_blocksize(inode);
2453	unsigned int zerofrom;
2454	int err;
2455
2456	err = cont_expand_zero(file, mapping, pos, bytes);
2457	if (err)
2458	return err;
2459
2460	zerofrom = *bytes & ~PAGE_MASK;
2461	if (pos+len > *bytes && zerofrom & (blocksize-1)) {
2462	*bytes \|= (blocksize-1);
2463	(*bytes)++;
2464	}
2465
2466	return block_write_begin(mapping, pos, len, flags, pagep, get_block);
2467	}
2468	EXPORT_SYMBOL(cont_write_begin);
2469
2470	int block_commit_write(struct page *page, unsigned from, unsigned to)
2471	{
2472	struct inode *inode = page->mapping->host;
2473	__block_commit_write(inode,page,from,to);
2474	return 0;
2475	}
2476	EXPORT_SYMBOL(block_commit_write);
2477
2478	/*
2479	* block_page_mkwrite() is not allowed to change the file size as it gets
2480	* called from a page fault handler when a page is first dirtied. Hence we must
2481	* be careful to check for EOF conditions here. We set the page up correctly
2482	* for a written page which means we get ENOSPC checking when writing into
2483	* holes and correct delalloc and unwritten extent mapping on filesystems that
2484	* support these features.
2485	*
2486	* We are not allowed to take the i_mutex here so we have to play games to
2487	* protect against truncate races as the page could now be beyond EOF. Because
2488	* truncate writes the inode size before removing pages, once we have the
2489	* page lock we can determine safely if the page is beyond EOF. If it is not
2490	* beyond EOF, then the page is guaranteed safe against truncation until we
2491	* unlock the page.
2492	*
2493	* Direct callers of this function should protect against filesystem freezing
2494	* using sb_start_pagefault() - sb_end_pagefault() functions.
2495	*/
2496	int block_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf,
2497	get_block_t get_block)
2498	{
2499	struct page *page = vmf->page;
2500	struct inode *inode = file_inode(vma->vm_file);
2501	unsigned long end;
2502	loff_t size;
2503	int ret;
2504
2505	lock_page(page);
2506	size = i_size_read(inode);
2507	if ((page->mapping != inode->i_mapping) \|\|
2508	(page_offset(page) > size)) {
2509	/* We overload EFAULT to mean page got truncated */
2510	ret = -EFAULT;
2511	goto out_unlock;
2512	}
2513
2514	/* page is wholly or partially inside EOF */
2515	if (((page->index + 1) << PAGE_SHIFT) > size)
2516	end = size & ~PAGE_MASK;
2517	else
2518	end = PAGE_SIZE;
2519
2520	ret = __block_write_begin(page, 0, end, get_block);
2521	if (!ret)
2522	ret = block_commit_write(page, 0, end);
2523
2524	if (unlikely(ret < 0))
2525	goto out_unlock;
2526	set_page_dirty(page);
2527	wait_for_stable_page(page);
2528	return 0;
2529	out_unlock:
2530	unlock_page(page);
2531	return ret;
2532	}
2533	EXPORT_SYMBOL(block_page_mkwrite);
2534
2535	/*
2536	* nobh_write_begin()'s prereads are special: the buffer_heads are freed
2537	* immediately, while under the page lock. So it needs a special end_io
2538	* handler which does not touch the bh after unlocking it.
2539	*/
2540	static void end_buffer_read_nobh(struct buffer_head *bh, int uptodate)
2541	{
2542	__end_buffer_read_notouch(bh, uptodate);
2543	}
2544
2545	/*
2546	* Attach the singly-linked list of buffers created by nobh_write_begin, to
2547	* the page (converting it to circular linked list and taking care of page
2548	* dirty races).
2549	*/
2550	static void attach_nobh_buffers(struct page page, struct buffer_head head)
2551	{
2552	struct buffer_head *bh;
2553
2554	BUG_ON(!PageLocked(page));
2555
2556	spin_lock(&page->mapping->private_lock);
2557	bh = head;
2558	do {
2559	if (PageDirty(page))
2560	set_buffer_dirty(bh);
2561	if (!bh->b_this_page)
2562	bh->b_this_page = head;
2563	bh = bh->b_this_page;
2564	} while (bh != head);
2565	attach_page_buffers(page, head);
2566	spin_unlock(&page->mapping->private_lock);
2567	}
2568
2569	/*
2570	* On entry, the page is fully not uptodate.
2571	* On exit the page is fully uptodate in the areas outside (from,to)
2572	* The filesystem needs to handle block truncation upon failure.
2573	*/
2574	int nobh_write_begin(struct address_space *mapping,
2575	loff_t pos, unsigned len, unsigned flags,
2576	struct page pagep, void fsdata,
2577	get_block_t *get_block)
2578	{
2579	struct inode *inode = mapping->host;
2580	const unsigned blkbits = inode->i_blkbits;
2581	const unsigned blocksize = 1 << blkbits;
2582	struct buffer_head head, bh;
2583	struct page *page;
2584	pgoff_t index;
2585	unsigned from, to;
2586	unsigned block_in_page;
2587	unsigned block_start, block_end;
2588	sector_t block_in_file;
2589	int nr_reads = 0;
2590	int ret = 0;
2591	int is_mapped_to_disk = 1;
2592
2593	index = pos >> PAGE_SHIFT;
2594	from = pos & (PAGE_SIZE - 1);
2595	to = from + len;
2596
2597	page = grab_cache_page_write_begin(mapping, index, flags);
2598	if (!page)
2599	return -ENOMEM;
2600	*pagep = page;
2601	*fsdata = NULL;
2602
2603	if (page_has_buffers(page)) {
2604	ret = __block_write_begin(page, pos, len, get_block);
2605	if (unlikely(ret))
2606	goto out_release;
2607	return ret;
2608	}
2609
2610	if (PageMappedToDisk(page))
2611	return 0;
2612
2613	/*
2614	* Allocate buffers so that we can keep track of state, and potentially
2615	* attach them to the page if an error occurs. In the common case of
2616	* no error, they will just be freed again without ever being attached
2617	* to the page (which is all OK, because we're under the page lock).
2618	*
2619	* Be careful: the buffer linked list is a NULL terminated one, rather
2620	* than the circular one we're used to.
2621	*/
2622	head = alloc_page_buffers(page, blocksize, false);
2623	if (!head) {
2624	ret = -ENOMEM;
2625	goto out_release;
2626	}
2627
2628	block_in_file = (sector_t)page->index << (PAGE_SHIFT - blkbits);
2629
2630	/*
2631	* We loop across all blocks in the page, whether or not they are
2632	* part of the affected region. This is so we can discover if the
2633	* page is fully mapped-to-disk.
2634	*/
2635	for (block_start = 0, block_in_page = 0, bh = head;
2636	block_start < PAGE_SIZE;
2637	block_in_page++, block_start += blocksize, bh = bh->b_this_page) {
2638	int create;
2639
2640	block_end = block_start + blocksize;
2641	bh->b_state = 0;
2642	create = 1;
2643	if (block_start >= to)
2644	create = 0;
2645	ret = get_block(inode, block_in_file + block_in_page,
2646	bh, create);
2647	if (ret)
2648	goto failed;
2649	if (!buffer_mapped(bh))
2650	is_mapped_to_disk = 0;
2651	if (buffer_new(bh))
2652	clean_bdev_bh_alias(bh);
2653	if (PageUptodate(page)) {
2654	set_buffer_uptodate(bh);
2655	continue;
2656	}
2657	if (buffer_new(bh) \|\| !buffer_mapped(bh)) {
2658	zero_user_segments(page, block_start, from,
2659	to, block_end);
2660	continue;
2661	}
2662	if (buffer_uptodate(bh))
2663	continue; /* reiserfs does this */
2664	if (block_start < from \|\| block_end > to) {
2665	lock_buffer(bh);
2666	bh->b_end_io = end_buffer_read_nobh;
2667	submit_bh(REQ_OP_READ, 0, bh);
2668	nr_reads++;
2669	}
2670	}
2671
2672	if (nr_reads) {
2673	/*
2674	* The page is locked, so these buffers are protected from
2675	* any VM or truncate activity. Hence we don't need to care
2676	* for the buffer_head refcounts.
2677	*/
2678	for (bh = head; bh; bh = bh->b_this_page) {
2679	wait_on_buffer(bh);
2680	if (!buffer_uptodate(bh))
2681	ret = -EIO;
2682	}
2683	if (ret)
2684	goto failed;
2685	}
2686
2687	if (is_mapped_to_disk)
2688	SetPageMappedToDisk(page);
2689
2690	fsdata = head; / to be released by nobh_write_end */
2691
2692	return 0;
2693
2694	failed:
2695	BUG_ON(!ret);
2696	/*
2697	* Error recovery is a bit difficult. We need to zero out blocks that
2698	* were newly allocated, and dirty them to ensure they get written out.
2699	* Buffers need to be attached to the page at this point, otherwise
2700	* the handling of potential IO errors during writeout would be hard
2701	* (could try doing synchronous writeout, but what if that fails too?)
2702	*/
2703	attach_nobh_buffers(page, head);
2704	page_zero_new_buffers(page, from, to);
2705
2706	out_release:
2707	unlock_page(page);
2708	put_page(page);
2709	*pagep = NULL;
2710
2711	return ret;
2712	}
2713	EXPORT_SYMBOL(nobh_write_begin);
2714
2715	int nobh_write_end(struct file file, struct address_space mapping,
2716	loff_t pos, unsigned len, unsigned copied,
2717	struct page page, void fsdata)
2718	{
2719	struct inode *inode = page->mapping->host;
2720	struct buffer_head *head = fsdata;
2721	struct buffer_head *bh;
2722	BUG_ON(fsdata != NULL && page_has_buffers(page));
2723
2724	if (unlikely(copied < len) && head)
2725	attach_nobh_buffers(page, head);
2726	if (page_has_buffers(page))
2727	return generic_write_end(file, mapping, pos, len,
2728	copied, page, fsdata);
2729
2730	SetPageUptodate(page);
2731	set_page_dirty(page);
2732	if (pos+copied > inode->i_size) {
2733	i_size_write(inode, pos+copied);
2734	mark_inode_dirty(inode);
2735	}
2736
2737	unlock_page(page);
2738	put_page(page);
2739
2740	while (head) {
2741	bh = head;
2742	head = head->b_this_page;
2743	free_buffer_head(bh);
2744	}
2745
2746	return copied;
2747	}
2748	EXPORT_SYMBOL(nobh_write_end);
2749
2750	/*
2751	* nobh_writepage() - based on block_full_write_page() except
2752	* that it tries to operate without attaching bufferheads to
2753	* the page.
2754	*/
2755	int nobh_writepage(struct page page, get_block_t get_block,
2756	struct writeback_control *wbc)
2757	{
2758	struct inode * const inode = page->mapping->host;
2759	loff_t i_size = i_size_read(inode);
2760	const pgoff_t end_index = i_size >> PAGE_SHIFT;
2761	unsigned offset;
2762	int ret;
2763
2764	/* Is the page fully inside i_size? */
2765	if (page->index < end_index)
2766	goto out;
2767
2768	/* Is the page fully outside i_size? (truncate in progress) */
2769	offset = i_size & (PAGE_SIZE-1);
2770	if (page->index >= end_index+1 \|\| !offset) {
2771	/*
2772	* The page may have dirty, unmapped buffers. For example,
2773	* they may have been added in ext3_writepage(). Make them
2774	* freeable here, so the page does not leak.
2775	*/
2776	#if 0
2777	/* Not really sure about this - do we need this ? */
2778	if (page->mapping->a_ops->invalidatepage)
2779	page->mapping->a_ops->invalidatepage(page, offset);
2780	#endif
2781	unlock_page(page);
2782	return 0; /* don't care */
2783	}
2784
2785	/*
2786	* The page straddles i_size. It must be zeroed out on each and every
2787	* writepage invocation because it may be mmapped. "A file is mapped
2788	* in multiples of the page size. For a file that is not a multiple of
2789	* the page size, the remaining memory is zeroed when mapped, and
2790	* writes to that region are not written out to the file."
2791	*/
2792	zero_user_segment(page, offset, PAGE_SIZE);
2793	out:
2794	ret = mpage_writepage(page, get_block, wbc);
2795	if (ret == -EAGAIN)
2796	ret = __block_write_full_page(inode, page, get_block, wbc,
2797	end_buffer_async_write);
2798	return ret;
2799	}
2800	EXPORT_SYMBOL(nobh_writepage);
2801
2802	int nobh_truncate_page(struct address_space *mapping,
2803	loff_t from, get_block_t *get_block)
2804	{
2805	pgoff_t index = from >> PAGE_SHIFT;
2806	unsigned offset = from & (PAGE_SIZE-1);
2807	unsigned blocksize;
2808	sector_t iblock;
2809	unsigned length, pos;
2810	struct inode *inode = mapping->host;
2811	struct page *page;
2812	struct buffer_head map_bh;
2813	int err;
2814
2815	blocksize = i_blocksize(inode);
2816	length = offset & (blocksize - 1);
2817
2818	/* Block boundary? Nothing to do */
2819	if (!length)
2820	return 0;
2821
2822	length = blocksize - length;
2823	iblock = (sector_t)index << (PAGE_SHIFT - inode->i_blkbits);
2824
2825	page = grab_cache_page(mapping, index);
2826	err = -ENOMEM;
2827	if (!page)
2828	goto out;
2829
2830	if (page_has_buffers(page)) {
2831	has_buffers:
2832	unlock_page(page);
2833	put_page(page);
2834	return block_truncate_page(mapping, from, get_block);
2835	}
2836
2837	/* Find the buffer that contains "offset" */
2838	pos = blocksize;
2839	while (offset >= pos) {
2840	iblock++;
2841	pos += blocksize;
2842	}
2843
2844	map_bh.b_size = blocksize;
2845	map_bh.b_state = 0;
2846	err = get_block(inode, iblock, &map_bh, 0);
2847	if (err)
2848	goto unlock;
2849	/* unmapped? It's a hole - nothing to do */
2850	if (!buffer_mapped(&map_bh))
2851	goto unlock;
2852
2853	/* Ok, it's mapped. Make sure it's up-to-date */
2854	if (!PageUptodate(page)) {
2855	err = mapping->a_ops->readpage(NULL, page);
2856	if (err) {
2857	put_page(page);
2858	goto out;
2859	}
2860	lock_page(page);
2861	if (!PageUptodate(page)) {
2862	err = -EIO;
2863	goto unlock;
2864	}
2865	if (page_has_buffers(page))
2866	goto has_buffers;
2867	}
2868	zero_user(page, offset, length);
2869	set_page_dirty(page);
2870	err = 0;
2871
2872	unlock:
2873	unlock_page(page);
2874	put_page(page);
2875	out:
2876	return err;
2877	}
2878	EXPORT_SYMBOL(nobh_truncate_page);
2879
2880	int block_truncate_page(struct address_space *mapping,
2881	loff_t from, get_block_t *get_block)
2882	{
2883	pgoff_t index = from >> PAGE_SHIFT;
2884	unsigned offset = from & (PAGE_SIZE-1);
2885	unsigned blocksize;
2886	sector_t iblock;
2887	unsigned length, pos;
2888	struct inode *inode = mapping->host;
2889	struct page *page;
2890	struct buffer_head *bh;
2891	int err;
2892
2893	blocksize = i_blocksize(inode);
2894	length = offset & (blocksize - 1);
2895
2896	/* Block boundary? Nothing to do */
2897	if (!length)
2898	return 0;
2899
2900	length = blocksize - length;
2901	iblock = (sector_t)index << (PAGE_SHIFT - inode->i_blkbits);
2902
2903	page = grab_cache_page(mapping, index);
2904	err = -ENOMEM;
2905	if (!page)
2906	goto out;
2907
2908	if (!page_has_buffers(page))
2909	create_empty_buffers(page, blocksize, 0);
2910
2911	/* Find the buffer that contains "offset" */
2912	bh = page_buffers(page);
2913	pos = blocksize;
2914	while (offset >= pos) {
2915	bh = bh->b_this_page;
2916	iblock++;
2917	pos += blocksize;
2918	}
2919
2920	err = 0;
2921	if (!buffer_mapped(bh)) {
2922	WARN_ON(bh->b_size != blocksize);
2923	err = get_block(inode, iblock, bh, 0);
2924	if (err)
2925	goto unlock;
2926	/* unmapped? It's a hole - nothing to do */
2927	if (!buffer_mapped(bh))
2928	goto unlock;
2929	}
2930
2931	/* Ok, it's mapped. Make sure it's up-to-date */
2932	if (PageUptodate(page))
2933	set_buffer_uptodate(bh);
2934
2935	if (!buffer_uptodate(bh) && !buffer_delay(bh) && !buffer_unwritten(bh)) {
2936	err = -EIO;
2937	ll_rw_block(REQ_OP_READ, 0, 1, &bh);
2938	wait_on_buffer(bh);
2939	/* Uhhuh. Read error. Complain and punt. */
2940	if (!buffer_uptodate(bh))
2941	goto unlock;
2942	}
2943
2944	zero_user(page, offset, length);
2945	mark_buffer_dirty(bh);
2946	err = 0;
2947
2948	unlock:
2949	unlock_page(page);
2950	put_page(page);
2951	out:
2952	return err;
2953	}
2954	EXPORT_SYMBOL(block_truncate_page);
2955
2956	/*
2957	* The generic ->writepage function for buffer-backed address_spaces
2958	*/
2959	int block_write_full_page(struct page page, get_block_t get_block,
2960	struct writeback_control *wbc)
2961	{
2962	struct inode * const inode = page->mapping->host;
2963	loff_t i_size = i_size_read(inode);
2964	const pgoff_t end_index = i_size >> PAGE_SHIFT;
2965	unsigned offset;
2966
2967	/* Is the page fully inside i_size? */
2968	if (page->index < end_index)
2969	return __block_write_full_page(inode, page, get_block, wbc,
2970	end_buffer_async_write);
2971
2972	/* Is the page fully outside i_size? (truncate in progress) */
2973	offset = i_size & (PAGE_SIZE-1);
2974	if (page->index >= end_index+1 \|\| !offset) {
2975	/*
2976	* The page may have dirty, unmapped buffers. For example,
2977	* they may have been added in ext3_writepage(). Make them
2978	* freeable here, so the page does not leak.
2979	*/
2980	do_invalidatepage(page, 0, PAGE_SIZE);
2981	unlock_page(page);
2982	return 0; /* don't care */
2983	}
2984
2985	/*
2986	* The page straddles i_size. It must be zeroed out on each and every
2987	* writepage invocation because it may be mmapped. "A file is mapped
2988	* in multiples of the page size. For a file that is not a multiple of
2989	* the page size, the remaining memory is zeroed when mapped, and
2990	* writes to that region are not written out to the file."
2991	*/
2992	zero_user_segment(page, offset, PAGE_SIZE);
2993	return __block_write_full_page(inode, page, get_block, wbc,
2994	end_buffer_async_write);
2995	}
2996	EXPORT_SYMBOL(block_write_full_page);
2997
2998	sector_t generic_block_bmap(struct address_space *mapping, sector_t block,
2999	get_block_t *get_block)
3000	{
3001	struct inode *inode = mapping->host;
3002	struct buffer_head tmp = {
3003	.b_size = i_blocksize(inode),
3004	};
3005
3006	get_block(inode, block, &tmp, 0);
3007	return tmp.b_blocknr;
3008	}
3009	EXPORT_SYMBOL(generic_block_bmap);
3010
3011	static void end_bio_bh_io_sync(struct bio *bio)
3012	{
3013	struct buffer_head *bh = bio->bi_private;
3014
3015	if (unlikely(bio_flagged(bio, BIO_QUIET)))
3016	set_bit(BH_Quiet, &bh->b_state);
3017
3018	bh->b_end_io(bh, !bio->bi_status);
3019	bio_put(bio);
3020	}
3021
3022	/*
3023	* This allows us to do IO even on the odd last sectors
3024	* of a device, even if the block size is some multiple
3025	* of the physical sector size.
3026	*
3027	* We'll just truncate the bio to the size of the device,
3028	* and clear the end of the buffer head manually.
3029	*
3030	* Truly out-of-range accesses will turn into actual IO
3031	* errors, this only handles the "we need to be able to
3032	* do IO at the final sector" case.
3033	*/
3034	void guard_bio_eod(int op, struct bio *bio)
3035	{
3036	sector_t maxsector;
3037	struct bio_vec *bvec = bio_last_bvec_all(bio);
3038	unsigned truncated_bytes;
3039	struct hd_struct *part;
3040
3041	rcu_read_lock();
3042	part = __disk_get_part(bio->bi_disk, bio->bi_partno);
3043	if (part)
3044	maxsector = part_nr_sects_read(part);
3045	else
3046	maxsector = get_capacity(bio->bi_disk);
3047	rcu_read_unlock();
3048
3049	if (!maxsector)
3050	return;
3051
3052	/*
3053	* If the whole IO is past the end of the device,
3054	* let it through, and the IO layer will turn it into
3055	* an EIO.
3056	*/
3057	if (unlikely(bio->bi_iter.bi_sector >= maxsector))
3058	return;
3059
3060	maxsector -= bio->bi_iter.bi_sector;
3061	if (likely((bio->bi_iter.bi_size >> 9) <= maxsector))
3062	return;
3063
3064	/* Uhhuh. We've got a bio that straddles the device size! */
3065	truncated_bytes = bio->bi_iter.bi_size - (maxsector << 9);
3066
3067	/*
3068	* The bio contains more than one segment which spans EOD, just return
3069	* and let IO layer turn it into an EIO
3070	*/
3071	if (truncated_bytes > bvec->bv_len)
3072	return;
3073
3074	/* Truncate the bio.. */
3075	bio->bi_iter.bi_size -= truncated_bytes;
3076	bvec->bv_len -= truncated_bytes;
3077
3078	/* ..and clear the end of the buffer for reads */
3079	if (op == REQ_OP_READ) {
3080	struct bio_vec bv;
3081
3082	mp_bvec_last_segment(bvec, &bv);
3083	zero_user(bv.bv_page, bv.bv_offset + bv.bv_len,
3084	truncated_bytes);
3085	}
3086	}
3087
3088	static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
3089	enum rw_hint write_hint, struct writeback_control *wbc)
3090	{
3091	struct bio *bio;
3092
3093	BUG_ON(!buffer_locked(bh));
3094	BUG_ON(!buffer_mapped(bh));
3095	BUG_ON(!bh->b_end_io);
3096	BUG_ON(buffer_delay(bh));
3097	BUG_ON(buffer_unwritten(bh));
3098
3099	/*
3100	* Only clear out a write error when rewriting
3101	*/
3102	if (test_set_buffer_req(bh) && (op == REQ_OP_WRITE))
3103	clear_buffer_write_io_error(bh);
3104
3105	/*
3106	* from here on down, it's all bio -- do the initial mapping,
3107	* submit_bio -> generic_make_request may further map this bio around
3108	*/
3109	bio = bio_alloc(GFP_NOIO, 1);
3110
3111	bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
3112	bio_set_dev(bio, bh->b_bdev);
3113	bio->bi_write_hint = write_hint;
3114
3115	bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh));
3116	BUG_ON(bio->bi_iter.bi_size != bh->b_size);
3117
3118	bio->bi_end_io = end_bio_bh_io_sync;
3119	bio->bi_private = bh;
3120
3121	/* Take care of bh's that straddle the end of the device */
3122	guard_bio_eod(op, bio);
3123
3124	if (buffer_meta(bh))
3125	op_flags \|= REQ_META;
3126	if (buffer_prio(bh))
3127	op_flags \|= REQ_PRIO;
3128	bio_set_op_attrs(bio, op, op_flags);
3129
3130	if (wbc) {
3131	wbc_init_bio(wbc, bio);
3132	wbc_account_cgroup_owner(wbc, bh->b_page, bh->b_size);
3133	}
3134
3135	submit_bio(bio);
3136	return 0;
3137	}
3138
3139	int submit_bh(int op, int op_flags, struct buffer_head *bh)
3140	{
3141	return submit_bh_wbc(op, op_flags, bh, 0, NULL);
3142	}
3143	EXPORT_SYMBOL(submit_bh);
3144
3145	/**
3146	* ll_rw_block: low-level access to block devices (DEPRECATED)
3147	* @op: whether to %READ or %WRITE
3148	* @op_flags: req_flag_bits
3149	* @nr: number of &struct buffer_heads in the array
3150	* @bhs: array of pointers to &struct buffer_head
3151	*
3152	* ll_rw_block() takes an array of pointers to &struct buffer_heads, and
3153	* requests an I/O operation on them, either a %REQ_OP_READ or a %REQ_OP_WRITE.
3154	* @op_flags contains flags modifying the detailed I/O behavior, most notably
3155	* %REQ_RAHEAD.
3156	*
3157	* This function drops any buffer that it cannot get a lock on (with the
3158	* BH_Lock state bit), any buffer that appears to be clean when doing a write
3159	* request, and any buffer that appears to be up-to-date when doing read
3160	* request. Further it marks as clean buffers that are processed for
3161	* writing (the buffer cache won't assume that they are actually clean
3162	* until the buffer gets unlocked).
3163	*
3164	* ll_rw_block sets b_end_io to simple completion handler that marks
3165	* the buffer up-to-date (if appropriate), unlocks the buffer and wakes
3166	* any waiters.
3167	*
3168	* All of the buffers must be for the same device, and must also be a
3169	* multiple of the current approved size for the device.
3170	*/
3171	void ll_rw_block(int op, int op_flags, int nr, struct buffer_head *bhs[])
3172	{
3173	int i;
3174
3175	for (i = 0; i < nr; i++) {
3176	struct buffer_head *bh = bhs[i];
3177
3178	if (!trylock_buffer(bh))
3179	continue;
3180	if (op == WRITE) {
3181	if (test_clear_buffer_dirty(bh)) {
3182	bh->b_end_io = end_buffer_write_sync;
3183	get_bh(bh);
3184	submit_bh(op, op_flags, bh);
3185	continue;
3186	}
3187	} else {
3188	if (!buffer_uptodate(bh)) {
3189	bh->b_end_io = end_buffer_read_sync;
3190	get_bh(bh);
3191	submit_bh(op, op_flags, bh);
3192	continue;
3193	}
3194	}
3195	unlock_buffer(bh);
3196	}
3197	}
3198	EXPORT_SYMBOL(ll_rw_block);
3199
3200	void write_dirty_buffer(struct buffer_head *bh, int op_flags)
3201	{
3202	lock_buffer(bh);
3203	if (!test_clear_buffer_dirty(bh)) {
3204	unlock_buffer(bh);
3205	return;
3206	}
3207	bh->b_end_io = end_buffer_write_sync;
3208	get_bh(bh);
3209	submit_bh(REQ_OP_WRITE, op_flags, bh);
3210	}
3211	EXPORT_SYMBOL(write_dirty_buffer);
3212
3213	/*
3214	* For a data-integrity writeout, we need to wait upon any in-progress I/O
3215	* and then start new I/O and then wait upon it. The caller must have a ref on
3216	* the buffer_head.
3217	*/
3218	int __sync_dirty_buffer(struct buffer_head *bh, int op_flags)
3219	{
3220	int ret = 0;
3221
3222	WARN_ON(atomic_read(&bh->b_count) < 1);
3223	lock_buffer(bh);
3224	if (test_clear_buffer_dirty(bh)) {
3225	get_bh(bh);
3226	bh->b_end_io = end_buffer_write_sync;
3227	ret = submit_bh(REQ_OP_WRITE, op_flags, bh);
3228	wait_on_buffer(bh);
3229	if (!ret && !buffer_uptodate(bh))
3230	ret = -EIO;
3231	} else {
3232	unlock_buffer(bh);
3233	}
3234	return ret;
3235	}
3236	EXPORT_SYMBOL(__sync_dirty_buffer);
3237
3238	int sync_dirty_buffer(struct buffer_head *bh)
3239	{
3240	return __sync_dirty_buffer(bh, REQ_SYNC);
3241	}
3242	EXPORT_SYMBOL(sync_dirty_buffer);
3243
3244	/*
3245	* try_to_free_buffers() checks if all the buffers on this particular page
3246	* are unused, and releases them if so.
3247	*
3248	* Exclusion against try_to_free_buffers may be obtained by either
3249	* locking the page or by holding its mapping's private_lock.
3250	*
3251	* If the page is dirty but all the buffers are clean then we need to
3252	* be sure to mark the page clean as well. This is because the page
3253	* may be against a block device, and a later reattachment of buffers
3254	* to a dirty page will set all buffers dirty. Which would corrupt
3255	* filesystem data on the same device.
3256	*
3257	* The same applies to regular filesystem pages: if all the buffers are
3258	* clean then we set the page clean and proceed. To do that, we require
3259	* total exclusion from __set_page_dirty_buffers(). That is obtained with
3260	* private_lock.
3261	*
3262	* try_to_free_buffers() is non-blocking.
3263	*/
3264	static inline int buffer_busy(struct buffer_head *bh)
3265	{
3266	return atomic_read(&bh->b_count) \|
3267	(bh->b_state & ((1 << BH_Dirty) \| (1 << BH_Lock)));
3268	}
3269
3270	static int
3271	drop_buffers(struct page page, struct buffer_head *buffers_to_free)
3272	{
3273	struct buffer_head *head = page_buffers(page);
3274	struct buffer_head *bh;
3275
3276	bh = head;
3277	do {
3278	if (buffer_busy(bh))
3279	goto failed;
3280	bh = bh->b_this_page;
3281	} while (bh != head);
3282
3283	do {
3284	struct buffer_head *next = bh->b_this_page;
3285
3286	if (bh->b_assoc_map)
3287	__remove_assoc_queue(bh);
3288	bh = next;
3289	} while (bh != head);
3290	*buffers_to_free = head;
3291	__clear_page_buffers(page);
3292	return 1;
3293	failed:
3294	return 0;
3295	}
3296
3297	int try_to_free_buffers(struct page *page)
3298	{
3299	struct address_space * const mapping = page->mapping;
3300	struct buffer_head *buffers_to_free = NULL;
3301	int ret = 0;
3302
3303	BUG_ON(!PageLocked(page));
3304	if (PageWriteback(page))
3305	return 0;
3306
3307	if (mapping == NULL) { /* can this still happen? */
3308	ret = drop_buffers(page, &buffers_to_free);
3309	goto out;
3310	}
3311
3312	spin_lock(&mapping->private_lock);
3313	ret = drop_buffers(page, &buffers_to_free);
3314
3315	/*
3316	* If the filesystem writes its buffers by hand (eg ext3)
3317	* then we can have clean buffers against a dirty page. We
3318	* clean the page here; otherwise the VM will never notice
3319	* that the filesystem did any IO at all.
3320	*
3321	* Also, during truncate, discard_buffer will have marked all
3322	* the page's buffers clean. We discover that here and clean
3323	* the page also.
3324	*
3325	* private_lock must be held over this entire operation in order
3326	* to synchronise against __set_page_dirty_buffers and prevent the
3327	* dirty bit from being lost.
3328	*/
3329	if (ret)
3330	cancel_dirty_page(page);
3331	spin_unlock(&mapping->private_lock);
3332	out:
3333	if (buffers_to_free) {
3334	struct buffer_head *bh = buffers_to_free;
3335
3336	do {
3337	struct buffer_head *next = bh->b_this_page;
3338	free_buffer_head(bh);
3339	bh = next;
3340	} while (bh != buffers_to_free);
3341	}
3342	return ret;
3343	}
3344	EXPORT_SYMBOL(try_to_free_buffers);
3345
3346	/*
3347	* There are no bdflush tunables left. But distributions are
3348	* still running obsolete flush daemons, so we terminate them here.
3349	*
3350	* Use of bdflush() is deprecated and will be removed in a future kernel.
3351	* The `flush-X' kernel threads fully replace bdflush daemons and this call.
3352	*/
3353	SYSCALL_DEFINE2(bdflush, int, func, long, data)
3354	{
3355	static int msg_count;
3356
3357	if (!capable(CAP_SYS_ADMIN))
3358	return -EPERM;
3359
3360	if (msg_count < 5) {
3361	msg_count++;
3362	printk(KERN_INFO
3363	"warning: process `%s' used the obsolete bdflush"
3364	" system call\n", current->comm);
3365	printk(KERN_INFO "Fix your initscripts?\n");
3366	}
3367
3368	if (func == 1)
3369	do_exit(0);
3370	return 0;
3371	}
3372
3373	/*
3374	* Buffer-head allocation
3375	*/
3376	static struct kmem_cache *bh_cachep __read_mostly;
3377
3378	/*
3379	* Once the number of bh's in the machine exceeds this level, we start
3380	* stripping them in writeback.
3381	*/
3382	static unsigned long max_buffer_heads;
3383
3384	int buffer_heads_over_limit;
3385
3386	struct bh_accounting {
3387	int nr; /* Number of live bh's */
3388	int ratelimit; /* Limit cacheline bouncing */
3389	};
3390
3391	static DEFINE_PER_CPU(struct bh_accounting, bh_accounting) = {0, 0};
3392
3393	static void recalc_bh_state(void)
3394	{
3395	int i;
3396	int tot = 0;
3397
3398	if (__this_cpu_inc_return(bh_accounting.ratelimit) - 1 < 4096)
3399	return;
3400	__this_cpu_write(bh_accounting.ratelimit, 0);
3401	for_each_online_cpu(i)
3402	tot += per_cpu(bh_accounting, i).nr;
3403	buffer_heads_over_limit = (tot > max_buffer_heads);
3404	}
3405
3406	struct buffer_head *alloc_buffer_head(gfp_t gfp_flags)
3407	{
3408	struct buffer_head *ret = kmem_cache_zalloc(bh_cachep, gfp_flags);
3409	if (ret) {
3410	INIT_LIST_HEAD(&ret->b_assoc_buffers);
3411	preempt_disable();
3412	__this_cpu_inc(bh_accounting.nr);
3413	recalc_bh_state();
3414	preempt_enable();
3415	}
3416	return ret;
3417	}
3418	EXPORT_SYMBOL(alloc_buffer_head);
3419
3420	void free_buffer_head(struct buffer_head *bh)
3421	{
3422	BUG_ON(!list_empty(&bh->b_assoc_buffers));
3423	kmem_cache_free(bh_cachep, bh);
3424	preempt_disable();
3425	__this_cpu_dec(bh_accounting.nr);
3426	recalc_bh_state();
3427	preempt_enable();
3428	}
3429	EXPORT_SYMBOL(free_buffer_head);
3430
3431	static int buffer_exit_cpu_dead(unsigned int cpu)
3432	{
3433	int i;
3434	struct bh_lru *b = &per_cpu(bh_lrus, cpu);
3435
3436	for (i = 0; i < BH_LRU_SIZE; i++) {
3437	brelse(b->bhs[i]);
3438	b->bhs[i] = NULL;
3439	}
3440	this_cpu_add(bh_accounting.nr, per_cpu(bh_accounting, cpu).nr);
3441	per_cpu(bh_accounting, cpu).nr = 0;
3442	return 0;
3443	}
3444
3445	/**
3446	* bh_uptodate_or_lock - Test whether the buffer is uptodate
3447	* @bh: struct buffer_head
3448	*
3449	* Return true if the buffer is up-to-date and false,
3450	* with the buffer locked, if not.
3451	*/
3452	int bh_uptodate_or_lock(struct buffer_head *bh)
3453	{
3454	if (!buffer_uptodate(bh)) {
3455	lock_buffer(bh);
3456	if (!buffer_uptodate(bh))
3457	return 0;
3458	unlock_buffer(bh);
3459	}
3460	return 1;
3461	}
3462	EXPORT_SYMBOL(bh_uptodate_or_lock);
3463
3464	/**
3465	* bh_submit_read - Submit a locked buffer for reading
3466	* @bh: struct buffer_head
3467	*
3468	* Returns zero on success and -EIO on error.
3469	*/
3470	int bh_submit_read(struct buffer_head *bh)
3471	{
3472	BUG_ON(!buffer_locked(bh));
3473
3474	if (buffer_uptodate(bh)) {
3475	unlock_buffer(bh);
3476	return 0;
3477	}
3478
3479	get_bh(bh);
3480	bh->b_end_io = end_buffer_read_sync;
3481	submit_bh(REQ_OP_READ, 0, bh);
3482	wait_on_buffer(bh);
3483	if (buffer_uptodate(bh))
3484	return 0;
3485	return -EIO;
3486	}
3487	EXPORT_SYMBOL(bh_submit_read);
3488
3489	void __init buffer_init(void)
3490	{
3491	unsigned long nrpages;
3492	int ret;
3493
3494	bh_cachep = kmem_cache_create("buffer_head",
3495	sizeof(struct buffer_head), 0,
3496	(SLAB_RECLAIM_ACCOUNT\|SLAB_PANIC\|
3497	SLAB_MEM_SPREAD),
3498	NULL);
3499
3500	/*
3501	* Limit the bh occupancy to 10% of ZONE_NORMAL
3502	*/
3503	nrpages = (nr_free_buffer_pages() * 10) / 100;
3504	max_buffer_heads = nrpages * (PAGE_SIZE / sizeof(struct buffer_head));
3505	ret = cpuhp_setup_state_nocalls(CPUHP_FS_BUFF_DEAD, "fs/buffer:dead",
3506	NULL, buffer_exit_cpu_dead);
3507	WARN_ON(ret < 0);
3508	}