Kernel

Kernel Git Source Tree

Root/mm/filemap.c

1	/*
2	* linux/mm/filemap.c
3	*
4	* Copyright (C) 1994-1999 Linus Torvalds
5	*/
6
7	/*
8	* This file handles the generic file mmap semantics used by
9	* most "normal" filesystems (but you don't /have/ to use this:
10	* the NFS filesystem used to do this differently, for example)
11	*/
12	#include <linux/export.h>
13	#include <linux/compiler.h>
14	#include <linux/fs.h>
15	#include <linux/uaccess.h>
16	#include <linux/aio.h>
17	#include <linux/capability.h>
18	#include <linux/kernel_stat.h>
19	#include <linux/gfp.h>
20	#include <linux/mm.h>
21	#include <linux/swap.h>
22	#include <linux/mman.h>
23	#include <linux/pagemap.h>
24	#include <linux/file.h>
25	#include <linux/uio.h>
26	#include <linux/hash.h>
27	#include <linux/writeback.h>
28	#include <linux/backing-dev.h>
29	#include <linux/pagevec.h>
30	#include <linux/blkdev.h>
31	#include <linux/security.h>
32	#include <linux/cpuset.h>
33	#include <linux/hardirq.h> /* for BUG_ON(!in_atomic()) only */
34	#include <linux/memcontrol.h>
35	#include <linux/cleancache.h>
36	#include "internal.h"
37
38	/*
39	* FIXME: remove all knowledge of the buffer layer from the core VM
40	*/
41	#include <linux/buffer_head.h> /* for try_to_free_buffers */
42
43	#include <asm/mman.h>
44
45	/*
46	* Shared mappings implemented 30.11.1994. It's not fully working yet,
47	* though.
48	*
49	* Shared mappings now work. 15.8.1995 Bruno.
50	*
51	* finished 'unifying' the page and buffer cache and SMP-threaded the
52	* page-cache, 21.05.1999, Ingo Molnar <mingo@redhat.com>
53	*
54	* SMP-threaded pagemap-LRU 1999, Andrea Arcangeli <andrea@suse.de>
55	*/
56
57	/*
58	* Lock ordering:
59	*
60	* ->i_mmap_mutex (truncate_pagecache)
61	* ->private_lock (__free_pte->__set_page_dirty_buffers)
62	* ->swap_lock (exclusive_swap_page, others)
63	* ->mapping->tree_lock
64	*
65	* ->i_mutex
66	* ->i_mmap_mutex (truncate->unmap_mapping_range)
67	*
68	* ->mmap_sem
69	* ->i_mmap_mutex
70	* ->page_table_lock or pte_lock (various, mainly in memory.c)
71	* ->mapping->tree_lock (arch-dependent flush_dcache_mmap_lock)
72	*
73	* ->mmap_sem
74	* ->lock_page (access_process_vm)
75	*
76	* ->i_mutex (generic_file_buffered_write)
77	* ->mmap_sem (fault_in_pages_readable->do_page_fault)
78	*
79	* bdi->wb.list_lock
80	* sb_lock (fs/fs-writeback.c)
81	* ->mapping->tree_lock (__sync_single_inode)
82	*
83	* ->i_mmap_mutex
84	* ->anon_vma.lock (vma_adjust)
85	*
86	* ->anon_vma.lock
87	* ->page_table_lock or pte_lock (anon_vma_prepare and various)
88	*
89	* ->page_table_lock or pte_lock
90	* ->swap_lock (try_to_unmap_one)
91	* ->private_lock (try_to_unmap_one)
92	* ->tree_lock (try_to_unmap_one)
93	* ->zone.lru_lock (follow_page->mark_page_accessed)
94	* ->zone.lru_lock (check_pte_range->isolate_lru_page)
95	* ->private_lock (page_remove_rmap->set_page_dirty)
96	* ->tree_lock (page_remove_rmap->set_page_dirty)
97	* bdi.wb->list_lock (page_remove_rmap->set_page_dirty)
98	* ->inode->i_lock (page_remove_rmap->set_page_dirty)
99	* bdi.wb->list_lock (zap_pte_range->set_page_dirty)
100	* ->inode->i_lock (zap_pte_range->set_page_dirty)
101	* ->private_lock (zap_pte_range->__set_page_dirty_buffers)
102	*
103	* ->i_mmap_mutex
104	* ->tasklist_lock (memory_failure, collect_procs_ao)
105	*/
106
107	/*
108	* Delete a page from the page cache and free it. Caller has to make
109	* sure the page is locked and that nobody else uses it - or that usage
110	* is safe. The caller must hold the mapping's tree_lock.
111	*/
112	void __delete_from_page_cache(struct page *page)
113	{
114	struct address_space *mapping = page->mapping;
115
116	/*
117	* if we're uptodate, flush out into the cleancache, otherwise
118	* invalidate any existing cleancache entries. We can't leave
119	* stale data around in the cleancache once our page is gone
120	*/
121	if (PageUptodate(page) && PageMappedToDisk(page))
122	cleancache_put_page(page);
123	else
124	cleancache_invalidate_page(mapping, page);
125
126	radix_tree_delete(&mapping->page_tree, page->index);
127	page->mapping = NULL;
128	/* Leave page->index set: truncation lookup relies upon it */
129	mapping->nrpages--;
130	__dec_zone_page_state(page, NR_FILE_PAGES);
131	if (PageSwapBacked(page))
132	__dec_zone_page_state(page, NR_SHMEM);
133	BUG_ON(page_mapped(page));
134
135	/*
136	* Some filesystems seem to re-dirty the page even after
137	* the VM has canceled the dirty bit (eg ext3 journaling).
138	*
139	* Fix it up by doing a final dirty accounting check after
140	* having removed the page entirely.
141	*/
142	if (PageDirty(page) && mapping_cap_account_dirty(mapping)) {
143	dec_zone_page_state(page, NR_FILE_DIRTY);
144	dec_bdi_stat(mapping->backing_dev_info, BDI_RECLAIMABLE);
145	}
146	}
147
148	/**
149	* delete_from_page_cache - delete page from page cache
150	* @page: the page which the kernel is trying to remove from page cache
151	*
152	* This must be called only on pages that have been verified to be in the page
153	* cache and locked. It will never put the page into the free list, the caller
154	* has a reference on the page.
155	*/
156	void delete_from_page_cache(struct page *page)
157	{
158	struct address_space *mapping = page->mapping;
159	void (freepage)(struct page );
160
161	BUG_ON(!PageLocked(page));
162
163	freepage = mapping->a_ops->freepage;
164	spin_lock_irq(&mapping->tree_lock);
165	__delete_from_page_cache(page);
166	spin_unlock_irq(&mapping->tree_lock);
167	mem_cgroup_uncharge_cache_page(page);
168
169	if (freepage)
170	freepage(page);
171	page_cache_release(page);
172	}
173	EXPORT_SYMBOL(delete_from_page_cache);
174
175	static int sleep_on_page(void *word)
176	{
177	io_schedule();
178	return 0;
179	}
180
181	static int sleep_on_page_killable(void *word)
182	{
183	sleep_on_page(word);
184	return fatal_signal_pending(current) ? -EINTR : 0;
185	}
186
187	/**
188	* __filemap_fdatawrite_range - start writeback on mapping dirty pages in range
189	* @mapping: address space structure to write
190	* @start: offset in bytes where the range starts
191	* @end: offset in bytes where the range ends (inclusive)
192	* @sync_mode: enable synchronous operation
193	*
194	* Start writeback against all of a mapping's dirty pages that lie
195	* within the byte offsets <start, end> inclusive.
196	*
197	* If sync_mode is WB_SYNC_ALL then this is a "data integrity" operation, as
198	* opposed to a regular memory cleansing writeback. The difference between
199	* these two operations is that if a dirty page/buffer is encountered, it must
200	* be waited upon, and not just skipped over.
201	*/
202	int __filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
203	loff_t end, int sync_mode)
204	{
205	int ret;
206	struct writeback_control wbc = {
207	.sync_mode = sync_mode,
208	.nr_to_write = LONG_MAX,
209	.range_start = start,
210	.range_end = end,
211	};
212
213	if (!mapping_cap_writeback_dirty(mapping))
214	return 0;
215
216	ret = do_writepages(mapping, &wbc);
217	return ret;
218	}
219
220	static inline int __filemap_fdatawrite(struct address_space *mapping,
221	int sync_mode)
222	{
223	return __filemap_fdatawrite_range(mapping, 0, LLONG_MAX, sync_mode);
224	}
225
226	int filemap_fdatawrite(struct address_space *mapping)
227	{
228	return __filemap_fdatawrite(mapping, WB_SYNC_ALL);
229	}
230	EXPORT_SYMBOL(filemap_fdatawrite);
231
232	int filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
233	loff_t end)
234	{
235	return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_ALL);
236	}
237	EXPORT_SYMBOL(filemap_fdatawrite_range);
238
239	/**
240	* filemap_flush - mostly a non-blocking flush
241	* @mapping: target address_space
242	*
243	* This is a mostly non-blocking flush. Not suitable for data-integrity
244	* purposes - I/O may not be started against all dirty pages.
245	*/
246	int filemap_flush(struct address_space *mapping)
247	{
248	return __filemap_fdatawrite(mapping, WB_SYNC_NONE);
249	}
250	EXPORT_SYMBOL(filemap_flush);
251
252	/**
253	* filemap_fdatawait_range - wait for writeback to complete
254	* @mapping: address space structure to wait for
255	* @start_byte: offset in bytes where the range starts
256	* @end_byte: offset in bytes where the range ends (inclusive)
257	*
258	* Walk the list of under-writeback pages of the given address space
259	* in the given range and wait for all of them.
260	*/
261	int filemap_fdatawait_range(struct address_space *mapping, loff_t start_byte,
262	loff_t end_byte)
263	{
264	pgoff_t index = start_byte >> PAGE_CACHE_SHIFT;
265	pgoff_t end = end_byte >> PAGE_CACHE_SHIFT;
266	struct pagevec pvec;
267	int nr_pages;
268	int ret = 0;
269
270	if (end_byte < start_byte)
271	return 0;
272
273	pagevec_init(&pvec, 0);
274	while ((index <= end) &&
275	(nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
276	PAGECACHE_TAG_WRITEBACK,
277	min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1)) != 0) {
278	unsigned i;
279
280	for (i = 0; i < nr_pages; i++) {
281	struct page *page = pvec.pages[i];
282
283	/* until radix tree lookup accepts end_index */
284	if (page->index > end)
285	continue;
286
287	wait_on_page_writeback(page);
288	if (TestClearPageError(page))
289	ret = -EIO;
290	}
291	pagevec_release(&pvec);
292	cond_resched();
293	}
294
295	/* Check for outstanding write errors */
296	if (test_and_clear_bit(AS_ENOSPC, &mapping->flags))
297	ret = -ENOSPC;
298	if (test_and_clear_bit(AS_EIO, &mapping->flags))
299	ret = -EIO;
300
301	return ret;
302	}
303	EXPORT_SYMBOL(filemap_fdatawait_range);
304
305	/**
306	* filemap_fdatawait - wait for all under-writeback pages to complete
307	* @mapping: address space structure to wait for
308	*
309	* Walk the list of under-writeback pages of the given address space
310	* and wait for all of them.
311	*/
312	int filemap_fdatawait(struct address_space *mapping)
313	{
314	loff_t i_size = i_size_read(mapping->host);
315
316	if (i_size == 0)
317	return 0;
318
319	return filemap_fdatawait_range(mapping, 0, i_size - 1);
320	}
321	EXPORT_SYMBOL(filemap_fdatawait);
322
323	int filemap_write_and_wait(struct address_space *mapping)
324	{
325	int err = 0;
326
327	if (mapping->nrpages) {
328	err = filemap_fdatawrite(mapping);
329	/*
330	* Even if the above returned error, the pages may be
331	* written partially (e.g. -ENOSPC), so we wait for it.
332	* But the -EIO is special case, it may indicate the worst
333	* thing (e.g. bug) happened, so we avoid waiting for it.
334	*/
335	if (err != -EIO) {
336	int err2 = filemap_fdatawait(mapping);
337	if (!err)
338	err = err2;
339	}
340	}
341	return err;
342	}
343	EXPORT_SYMBOL(filemap_write_and_wait);
344
345	/**
346	* filemap_write_and_wait_range - write out & wait on a file range
347	* @mapping: the address_space for the pages
348	* @lstart: offset in bytes where the range starts
349	* @lend: offset in bytes where the range ends (inclusive)
350	*
351	* Write out and wait upon file offsets lstart->lend, inclusive.
352	*
353	* Note that `lend' is inclusive (describes the last byte to be written) so
354	* that this function can be used to write to the very end-of-file (end = -1).
355	*/
356	int filemap_write_and_wait_range(struct address_space *mapping,
357	loff_t lstart, loff_t lend)
358	{
359	int err = 0;
360
361	if (mapping->nrpages) {
362	err = __filemap_fdatawrite_range(mapping, lstart, lend,
363	WB_SYNC_ALL);
364	/* See comment of filemap_write_and_wait() */
365	if (err != -EIO) {
366	int err2 = filemap_fdatawait_range(mapping,
367	lstart, lend);
368	if (!err)
369	err = err2;
370	}
371	}
372	return err;
373	}
374	EXPORT_SYMBOL(filemap_write_and_wait_range);
375
376	/**
377	* replace_page_cache_page - replace a pagecache page with a new one
378	* @old: page to be replaced
379	* @new: page to replace with
380	* @gfp_mask: allocation mode
381	*
382	* This function replaces a page in the pagecache with a new one. On
383	* success it acquires the pagecache reference for the new page and
384	* drops it for the old page. Both the old and new pages must be
385	* locked. This function does not add the new page to the LRU, the
386	* caller must do that.
387	*
388	* The remove + add is atomic. The only way this function can fail is
389	* memory allocation failure.
390	*/
391	int replace_page_cache_page(struct page old, struct page new, gfp_t gfp_mask)
392	{
393	int error;
394
395	VM_BUG_ON(!PageLocked(old));
396	VM_BUG_ON(!PageLocked(new));
397	VM_BUG_ON(new->mapping);
398
399	error = radix_tree_preload(gfp_mask & ~__GFP_HIGHMEM);
400	if (!error) {
401	struct address_space *mapping = old->mapping;
402	void (freepage)(struct page );
403
404	pgoff_t offset = old->index;
405	freepage = mapping->a_ops->freepage;
406
407	page_cache_get(new);
408	new->mapping = mapping;
409	new->index = offset;
410
411	spin_lock_irq(&mapping->tree_lock);
412	__delete_from_page_cache(old);
413	error = radix_tree_insert(&mapping->page_tree, offset, new);
414	BUG_ON(error);
415	mapping->nrpages++;
416	__inc_zone_page_state(new, NR_FILE_PAGES);
417	if (PageSwapBacked(new))
418	__inc_zone_page_state(new, NR_SHMEM);
419	spin_unlock_irq(&mapping->tree_lock);
420	/* mem_cgroup codes must not be called under tree_lock */
421	mem_cgroup_replace_page_cache(old, new);
422	radix_tree_preload_end();
423	if (freepage)
424	freepage(old);
425	page_cache_release(old);
426	}
427
428	return error;
429	}
430	EXPORT_SYMBOL_GPL(replace_page_cache_page);
431
432	/**
433	* add_to_page_cache_locked - add a locked page to the pagecache
434	* @page: page to add
435	* @mapping: the page's address_space
436	* @offset: page index
437	* @gfp_mask: page allocation mode
438	*
439	* This function is used to add a page to the pagecache. It must be locked.
440	* This function does not add the page to the LRU. The caller must do that.
441	*/
442	int add_to_page_cache_locked(struct page page, struct address_space mapping,
443	pgoff_t offset, gfp_t gfp_mask)
444	{
445	int error;
446
447	VM_BUG_ON(!PageLocked(page));
448	VM_BUG_ON(PageSwapBacked(page));
449
450	error = mem_cgroup_cache_charge(page, current->mm,
451	gfp_mask & GFP_RECLAIM_MASK);
452	if (error)
453	goto out;
454
455	error = radix_tree_preload(gfp_mask & ~__GFP_HIGHMEM);
456	if (error == 0) {
457	page_cache_get(page);
458	page->mapping = mapping;
459	page->index = offset;
460
461	spin_lock_irq(&mapping->tree_lock);
462	error = radix_tree_insert(&mapping->page_tree, offset, page);
463	if (likely(!error)) {
464	mapping->nrpages++;
465	__inc_zone_page_state(page, NR_FILE_PAGES);
466	spin_unlock_irq(&mapping->tree_lock);
467	} else {
468	page->mapping = NULL;
469	/* Leave page->index set: truncation relies upon it */
470	spin_unlock_irq(&mapping->tree_lock);
471	mem_cgroup_uncharge_cache_page(page);
472	page_cache_release(page);
473	}
474	radix_tree_preload_end();
475	} else
476	mem_cgroup_uncharge_cache_page(page);
477	out:
478	return error;
479	}
480	EXPORT_SYMBOL(add_to_page_cache_locked);
481
482	int add_to_page_cache_lru(struct page page, struct address_space mapping,
483	pgoff_t offset, gfp_t gfp_mask)
484	{
485	int ret;
486
487	ret = add_to_page_cache(page, mapping, offset, gfp_mask);
488	if (ret == 0)
489	lru_cache_add_file(page);
490	return ret;
491	}
492	EXPORT_SYMBOL_GPL(add_to_page_cache_lru);
493
494	#ifdef CONFIG_NUMA
495	struct page *__page_cache_alloc(gfp_t gfp)
496	{
497	int n;
498	struct page *page;
499
500	if (cpuset_do_page_mem_spread()) {
501	unsigned int cpuset_mems_cookie;
502	do {
503	cpuset_mems_cookie = get_mems_allowed();
504	n = cpuset_mem_spread_node();
505	page = alloc_pages_exact_node(n, gfp, 0);
506	} while (!put_mems_allowed(cpuset_mems_cookie) && !page);
507
508	return page;
509	}
510	return alloc_pages(gfp, 0);
511	}
512	EXPORT_SYMBOL(__page_cache_alloc);
513	#endif
514
515	/*
516	* In order to wait for pages to become available there must be
517	* waitqueues associated with pages. By using a hash table of
518	* waitqueues where the bucket discipline is to maintain all
519	* waiters on the same queue and wake all when any of the pages
520	* become available, and for the woken contexts to check to be
521	* sure the appropriate page became available, this saves space
522	* at a cost of "thundering herd" phenomena during rare hash
523	* collisions.
524	*/
525	static wait_queue_head_t page_waitqueue(struct page page)
526	{
527	const struct zone *zone = page_zone(page);
528
529	return &zone->wait_table[hash_ptr(page, zone->wait_table_bits)];
530	}
531
532	static inline void wake_up_page(struct page *page, int bit)
533	{
534	__wake_up_bit(page_waitqueue(page), &page->flags, bit);
535	}
536
537	void wait_on_page_bit(struct page *page, int bit_nr)
538	{
539	DEFINE_WAIT_BIT(wait, &page->flags, bit_nr);
540
541	if (test_bit(bit_nr, &page->flags))
542	__wait_on_bit(page_waitqueue(page), &wait, sleep_on_page,
543	TASK_UNINTERRUPTIBLE);
544	}
545	EXPORT_SYMBOL(wait_on_page_bit);
546
547	int wait_on_page_bit_killable(struct page *page, int bit_nr)
548	{
549	DEFINE_WAIT_BIT(wait, &page->flags, bit_nr);
550
551	if (!test_bit(bit_nr, &page->flags))
552	return 0;
553
554	return __wait_on_bit(page_waitqueue(page), &wait,
555	sleep_on_page_killable, TASK_KILLABLE);
556	}
557
558	/**
559	* add_page_wait_queue - Add an arbitrary waiter to a page's wait queue
560	* @page: Page defining the wait queue of interest
561	* @waiter: Waiter to add to the queue
562	*
563	* Add an arbitrary @waiter to the wait queue for the nominated @page.
564	*/
565	void add_page_wait_queue(struct page page, wait_queue_t waiter)
566	{
567	wait_queue_head_t *q = page_waitqueue(page);
568	unsigned long flags;
569
570	spin_lock_irqsave(&q->lock, flags);
571	__add_wait_queue(q, waiter);
572	spin_unlock_irqrestore(&q->lock, flags);
573	}
574	EXPORT_SYMBOL_GPL(add_page_wait_queue);
575
576	/**
577	* unlock_page - unlock a locked page
578	* @page: the page
579	*
580	* Unlocks the page and wakes up sleepers in ___wait_on_page_locked().
581	* Also wakes sleepers in wait_on_page_writeback() because the wakeup
582	* mechananism between PageLocked pages and PageWriteback pages is shared.
583	* But that's OK - sleepers in wait_on_page_writeback() just go back to sleep.
584	*
585	* The mb is necessary to enforce ordering between the clear_bit and the read
586	* of the waitqueue (to avoid SMP races with a parallel wait_on_page_locked()).
587	*/
588	void unlock_page(struct page *page)
589	{
590	VM_BUG_ON(!PageLocked(page));
591	clear_bit_unlock(PG_locked, &page->flags);
592	smp_mb__after_clear_bit();
593	wake_up_page(page, PG_locked);
594	}
595	EXPORT_SYMBOL(unlock_page);
596
597	/**
598	* end_page_writeback - end writeback against a page
599	* @page: the page
600	*/
601	void end_page_writeback(struct page *page)
602	{
603	if (TestClearPageReclaim(page))
604	rotate_reclaimable_page(page);
605
606	if (!test_clear_page_writeback(page))
607	BUG();
608
609	smp_mb__after_clear_bit();
610	wake_up_page(page, PG_writeback);
611	}
612	EXPORT_SYMBOL(end_page_writeback);
613
614	/**
615	* __lock_page - get a lock on the page, assuming we need to sleep to get it
616	* @page: the page to lock
617	*/
618	void __lock_page(struct page *page)
619	{
620	DEFINE_WAIT_BIT(wait, &page->flags, PG_locked);
621
622	__wait_on_bit_lock(page_waitqueue(page), &wait, sleep_on_page,
623	TASK_UNINTERRUPTIBLE);
624	}
625	EXPORT_SYMBOL(__lock_page);
626
627	int __lock_page_killable(struct page *page)
628	{
629	DEFINE_WAIT_BIT(wait, &page->flags, PG_locked);
630
631	return __wait_on_bit_lock(page_waitqueue(page), &wait,
632	sleep_on_page_killable, TASK_KILLABLE);
633	}
634	EXPORT_SYMBOL_GPL(__lock_page_killable);
635
636	int __lock_page_or_retry(struct page page, struct mm_struct mm,
637	unsigned int flags)
638	{
639	if (flags & FAULT_FLAG_ALLOW_RETRY) {
640	/*
641	* CAUTION! In this case, mmap_sem is not released
642	* even though return 0.
643	*/
644	if (flags & FAULT_FLAG_RETRY_NOWAIT)
645	return 0;
646
647	up_read(&mm->mmap_sem);
648	if (flags & FAULT_FLAG_KILLABLE)
649	wait_on_page_locked_killable(page);
650	else
651	wait_on_page_locked(page);
652	return 0;
653	} else {
654	if (flags & FAULT_FLAG_KILLABLE) {
655	int ret;
656
657	ret = __lock_page_killable(page);
658	if (ret) {
659	up_read(&mm->mmap_sem);
660	return 0;
661	}
662	} else
663	__lock_page(page);
664	return 1;
665	}
666	}
667
668	/**
669	* find_get_page - find and get a page reference
670	* @mapping: the address_space to search
671	* @offset: the page index
672	*
673	* Is there a pagecache struct page at the given (mapping, offset) tuple?
674	* If yes, increment its refcount and return it; if no, return NULL.
675	*/
676	struct page find_get_page(struct address_space mapping, pgoff_t offset)
677	{
678	void **pagep;
679	struct page *page;
680
681	rcu_read_lock();
682	repeat:
683	page = NULL;
684	pagep = radix_tree_lookup_slot(&mapping->page_tree, offset);
685	if (pagep) {
686	page = radix_tree_deref_slot(pagep);
687	if (unlikely(!page))
688	goto out;
689	if (radix_tree_exception(page)) {
690	if (radix_tree_deref_retry(page))
691	goto repeat;
692	/*
693	* Otherwise, shmem/tmpfs must be storing a swap entry
694	* here as an exceptional entry: so return it without
695	* attempting to raise page count.
696	*/
697	goto out;
698	}
699	if (!page_cache_get_speculative(page))
700	goto repeat;
701
702	/*
703	* Has the page moved?
704	* This is part of the lockless pagecache protocol. See
705	* include/linux/pagemap.h for details.
706	*/
707	if (unlikely(page != *pagep)) {
708	page_cache_release(page);
709	goto repeat;
710	}
711	}
712	out:
713	rcu_read_unlock();
714
715	return page;
716	}
717	EXPORT_SYMBOL(find_get_page);
718
719	/**
720	* find_lock_page - locate, pin and lock a pagecache page
721	* @mapping: the address_space to search
722	* @offset: the page index
723	*
724	* Locates the desired pagecache page, locks it, increments its reference
725	* count and returns its address.
726	*
727	* Returns zero if the page was not present. find_lock_page() may sleep.
728	*/
729	struct page find_lock_page(struct address_space mapping, pgoff_t offset)
730	{
731	struct page *page;
732
733	repeat:
734	page = find_get_page(mapping, offset);
735	if (page && !radix_tree_exception(page)) {
736	lock_page(page);
737	/* Has the page been truncated? */
738	if (unlikely(page->mapping != mapping)) {
739	unlock_page(page);
740	page_cache_release(page);
741	goto repeat;
742	}
743	VM_BUG_ON(page->index != offset);
744	}
745	return page;
746	}
747	EXPORT_SYMBOL(find_lock_page);
748
749	/**
750	* find_or_create_page - locate or add a pagecache page
751	* @mapping: the page's address_space
752	* @index: the page's index into the mapping
753	* @gfp_mask: page allocation mode
754	*
755	* Locates a page in the pagecache. If the page is not present, a new page
756	* is allocated using @gfp_mask and is added to the pagecache and to the VM's
757	* LRU list. The returned page is locked and has its reference count
758	* incremented.
759	*
760	* find_or_create_page() may sleep, even if @gfp_flags specifies an atomic
761	* allocation!
762	*
763	* find_or_create_page() returns the desired page's address, or zero on
764	* memory exhaustion.
765	*/
766	struct page find_or_create_page(struct address_space mapping,
767	pgoff_t index, gfp_t gfp_mask)
768	{
769	struct page *page;
770	int err;
771	repeat:
772	page = find_lock_page(mapping, index);
773	if (!page) {
774	page = __page_cache_alloc(gfp_mask);
775	if (!page)
776	return NULL;
777	/*
778	* We want a regular kernel memory (not highmem or DMA etc)
779	* allocation for the radix tree nodes, but we need to honour
780	* the context-specific requirements the caller has asked for.
781	* GFP_RECLAIM_MASK collects those requirements.
782	*/
783	err = add_to_page_cache_lru(page, mapping, index,
784	(gfp_mask & GFP_RECLAIM_MASK));
785	if (unlikely(err)) {
786	page_cache_release(page);
787	page = NULL;
788	if (err == -EEXIST)
789	goto repeat;
790	}
791	}
792	return page;
793	}
794	EXPORT_SYMBOL(find_or_create_page);
795
796	/**
797	* find_get_pages - gang pagecache lookup
798	* @mapping: The address_space to search
799	* @start: The starting page index
800	* @nr_pages: The maximum number of pages
801	* @pages: Where the resulting pages are placed
802	*
803	* find_get_pages() will search for and return a group of up to
804	* @nr_pages pages in the mapping. The pages are placed at @pages.
805	* find_get_pages() takes a reference against the returned pages.
806	*
807	* The search returns a group of mapping-contiguous pages with ascending
808	* indexes. There may be holes in the indices due to not-present pages.
809	*
810	* find_get_pages() returns the number of pages which were found.
811	*/
812	unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
813	unsigned int nr_pages, struct page **pages)
814	{
815	struct radix_tree_iter iter;
816	void **slot;
817	unsigned ret = 0;
818
819	if (unlikely(!nr_pages))
820	return 0;
821
822	rcu_read_lock();
823	restart:
824	radix_tree_for_each_slot(slot, &mapping->page_tree, &iter, start) {
825	struct page *page;
826	repeat:
827	page = radix_tree_deref_slot(slot);
828	if (unlikely(!page))
829	continue;
830
831	if (radix_tree_exception(page)) {
832	if (radix_tree_deref_retry(page)) {
833	/*
834	* Transient condition which can only trigger
835	* when entry at index 0 moves out of or back
836	* to root: none yet gotten, safe to restart.
837	*/
838	WARN_ON(iter.index);
839	goto restart;
840	}
841	/*
842	* Otherwise, shmem/tmpfs must be storing a swap entry
843	* here as an exceptional entry: so skip over it -
844	* we only reach this from invalidate_mapping_pages().
845	*/
846	continue;
847	}
848
849	if (!page_cache_get_speculative(page))
850	goto repeat;
851
852	/* Has the page moved? */
853	if (unlikely(page != *slot)) {
854	page_cache_release(page);
855	goto repeat;
856	}
857
858	pages[ret] = page;
859	if (++ret == nr_pages)
860	break;
861	}
862
863	rcu_read_unlock();
864	return ret;
865	}
866
867	/**
868	* find_get_pages_contig - gang contiguous pagecache lookup
869	* @mapping: The address_space to search
870	* @index: The starting page index
871	* @nr_pages: The maximum number of pages
872	* @pages: Where the resulting pages are placed
873	*
874	* find_get_pages_contig() works exactly like find_get_pages(), except
875	* that the returned number of pages are guaranteed to be contiguous.
876	*
877	* find_get_pages_contig() returns the number of pages which were found.
878	*/
879	unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t index,
880	unsigned int nr_pages, struct page **pages)
881	{
882	struct radix_tree_iter iter;
883	void **slot;
884	unsigned int ret = 0;
885
886	if (unlikely(!nr_pages))
887	return 0;
888
889	rcu_read_lock();
890	restart:
891	radix_tree_for_each_contig(slot, &mapping->page_tree, &iter, index) {
892	struct page *page;
893	repeat:
894	page = radix_tree_deref_slot(slot);
895	/* The hole, there no reason to continue */
896	if (unlikely(!page))
897	break;
898
899	if (radix_tree_exception(page)) {
900	if (radix_tree_deref_retry(page)) {
901	/*
902	* Transient condition which can only trigger
903	* when entry at index 0 moves out of or back
904	* to root: none yet gotten, safe to restart.
905	*/
906	goto restart;
907	}
908	/*
909	* Otherwise, shmem/tmpfs must be storing a swap entry
910	* here as an exceptional entry: so stop looking for
911	* contiguous pages.
912	*/
913	break;
914	}
915
916	if (!page_cache_get_speculative(page))
917	goto repeat;
918
919	/* Has the page moved? */
920	if (unlikely(page != *slot)) {
921	page_cache_release(page);
922	goto repeat;
923	}
924
925	/*
926	* must check mapping and index after taking the ref.
927	* otherwise we can get both false positives and false
928	* negatives, which is just confusing to the caller.
929	*/
930	if (page->mapping == NULL \|\| page->index != iter.index) {
931	page_cache_release(page);
932	break;
933	}
934
935	pages[ret] = page;
936	if (++ret == nr_pages)
937	break;
938	}
939	rcu_read_unlock();
940	return ret;
941	}
942	EXPORT_SYMBOL(find_get_pages_contig);
943
944	/**
945	* find_get_pages_tag - find and return pages that match @tag
946	* @mapping: the address_space to search
947	* @index: the starting page index
948	* @tag: the tag index
949	* @nr_pages: the maximum number of pages
950	* @pages: where the resulting pages are placed
951	*
952	* Like find_get_pages, except we only return pages which are tagged with
953	* @tag. We update @index to index the next page for the traversal.
954	*/
955	unsigned find_get_pages_tag(struct address_space mapping, pgoff_t index,
956	int tag, unsigned int nr_pages, struct page **pages)
957	{
958	struct radix_tree_iter iter;
959	void **slot;
960	unsigned ret = 0;
961
962	if (unlikely(!nr_pages))
963	return 0;
964
965	rcu_read_lock();
966	restart:
967	radix_tree_for_each_tagged(slot, &mapping->page_tree,
968	&iter, *index, tag) {
969	struct page *page;
970	repeat:
971	page = radix_tree_deref_slot(slot);
972	if (unlikely(!page))
973	continue;
974
975	if (radix_tree_exception(page)) {
976	if (radix_tree_deref_retry(page)) {
977	/*
978	* Transient condition which can only trigger
979	* when entry at index 0 moves out of or back
980	* to root: none yet gotten, safe to restart.
981	*/
982	goto restart;
983	}
984	/*
985	* This function is never used on a shmem/tmpfs
986	* mapping, so a swap entry won't be found here.
987	*/
988	BUG();
989	}
990
991	if (!page_cache_get_speculative(page))
992	goto repeat;
993
994	/* Has the page moved? */
995	if (unlikely(page != *slot)) {
996	page_cache_release(page);
997	goto repeat;
998	}
999
1000	pages[ret] = page;
1001	if (++ret == nr_pages)
1002	break;
1003	}
1004
1005	rcu_read_unlock();
1006
1007	if (ret)
1008	*index = pages[ret - 1]->index + 1;
1009
1010	return ret;
1011	}
1012	EXPORT_SYMBOL(find_get_pages_tag);
1013
1014	/**
1015	* grab_cache_page_nowait - returns locked page at given index in given cache
1016	* @mapping: target address_space
1017	* @index: the page index
1018	*
1019	* Same as grab_cache_page(), but do not wait if the page is unavailable.
1020	* This is intended for speculative data generators, where the data can
1021	* be regenerated if the page couldn't be grabbed. This routine should
1022	* be safe to call while holding the lock for another page.
1023	*
1024	* Clear __GFP_FS when allocating the page to avoid recursion into the fs
1025	* and deadlock against the caller's locked page.
1026	*/
1027	struct page *
1028	grab_cache_page_nowait(struct address_space *mapping, pgoff_t index)
1029	{
1030	struct page *page = find_get_page(mapping, index);
1031
1032	if (page) {
1033	if (trylock_page(page))
1034	return page;
1035	page_cache_release(page);
1036	return NULL;
1037	}
1038	page = __page_cache_alloc(mapping_gfp_mask(mapping) & ~__GFP_FS);
1039	if (page && add_to_page_cache_lru(page, mapping, index, GFP_NOFS)) {
1040	page_cache_release(page);
1041	page = NULL;
1042	}
1043	return page;
1044	}
1045	EXPORT_SYMBOL(grab_cache_page_nowait);
1046
1047	/*
1048	* CD/DVDs are error prone. When a medium error occurs, the driver may fail
1049	* a _large_ part of the i/o request. Imagine the worst scenario:
1050	*
1051	* ---R__________________________________________B__________
1052	* ^ reading here ^ bad block(assume 4k)
1053	*
1054	* read(R) => miss => readahead(R...B) => media error => frustrating retries
1055	* => failing the whole request => read(R) => read(R+1) =>
1056	* readahead(R+1...B+1) => bang => read(R+2) => read(R+3) =>
1057	* readahead(R+3...B+2) => bang => read(R+3) => read(R+4) =>
1058	* readahead(R+4...B+3) => bang => read(R+4) => read(R+5) => ......
1059	*
1060	* It is going insane. Fix it by quickly scaling down the readahead size.
1061	*/
1062	static void shrink_readahead_size_eio(struct file *filp,
1063	struct file_ra_state *ra)
1064	{
1065	ra->ra_pages /= 4;
1066	}
1067
1068	/**
1069	* do_generic_file_read - generic file read routine
1070	* @filp: the file to read
1071	* @ppos: current file position
1072	* @desc: read_descriptor
1073	* @actor: read method
1074	*
1075	* This is a generic file read routine, and uses the
1076	* mapping->a_ops->readpage() function for the actual low-level stuff.
1077	*
1078	* This is really ugly. But the goto's actually try to clarify some
1079	* of the logic when it comes to error handling etc.
1080	*/
1081	static void do_generic_file_read(struct file filp, loff_t ppos,
1082	read_descriptor_t *desc, read_actor_t actor)
1083	{
1084	struct address_space *mapping = filp->f_mapping;
1085	struct inode *inode = mapping->host;
1086	struct file_ra_state *ra = &filp->f_ra;
1087	pgoff_t index;
1088	pgoff_t last_index;
1089	pgoff_t prev_index;
1090	unsigned long offset; /* offset into pagecache page */
1091	unsigned int prev_offset;
1092	int error;
1093
1094	index = *ppos >> PAGE_CACHE_SHIFT;
1095	prev_index = ra->prev_pos >> PAGE_CACHE_SHIFT;
1096	prev_offset = ra->prev_pos & (PAGE_CACHE_SIZE-1);
1097	last_index = (*ppos + desc->count + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT;
1098	offset = *ppos & ~PAGE_CACHE_MASK;
1099
1100	for (;;) {
1101	struct page *page;
1102	pgoff_t end_index;
1103	loff_t isize;
1104	unsigned long nr, ret;
1105
1106	cond_resched();
1107	find_page:
1108	page = find_get_page(mapping, index);
1109	if (!page) {
1110	page_cache_sync_readahead(mapping,
1111	ra, filp,
1112	index, last_index - index);
1113	page = find_get_page(mapping, index);
1114	if (unlikely(page == NULL))
1115	goto no_cached_page;
1116	}
1117	if (PageReadahead(page)) {
1118	page_cache_async_readahead(mapping,
1119	ra, filp, page,
1120	index, last_index - index);
1121	}
1122	if (!PageUptodate(page)) {
1123	if (inode->i_blkbits == PAGE_CACHE_SHIFT \|\|
1124	!mapping->a_ops->is_partially_uptodate)
1125	goto page_not_up_to_date;
1126	if (!trylock_page(page))
1127	goto page_not_up_to_date;
1128	/* Did it get truncated before we got the lock? */
1129	if (!page->mapping)
1130	goto page_not_up_to_date_locked;
1131	if (!mapping->a_ops->is_partially_uptodate(page,
1132	desc, offset))
1133	goto page_not_up_to_date_locked;
1134	unlock_page(page);
1135	}
1136	page_ok:
1137	/*
1138	* i_size must be checked after we know the page is Uptodate.
1139	*
1140	* Checking i_size after the check allows us to calculate
1141	* the correct value for "nr", which means the zero-filled
1142	* part of the page is not copied back to userspace (unless
1143	* another truncate extends the file - this is desired though).
1144	*/
1145
1146	isize = i_size_read(inode);
1147	end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
1148	if (unlikely(!isize \|\| index > end_index)) {
1149	page_cache_release(page);
1150	goto out;
1151	}
1152
1153	/* nr is the maximum number of bytes to copy from this page */
1154	nr = PAGE_CACHE_SIZE;
1155	if (index == end_index) {
1156	nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
1157	if (nr <= offset) {
1158	page_cache_release(page);
1159	goto out;
1160	}
1161	}
1162	nr = nr - offset;
1163
1164	/* If users can be writing to this page using arbitrary
1165	* virtual addresses, take care about potential aliasing
1166	* before reading the page on the kernel side.
1167	*/
1168	if (mapping_writably_mapped(mapping))
1169	flush_dcache_page(page);
1170
1171	/*
1172	* When a sequential read accesses a page several times,
1173	* only mark it as accessed the first time.
1174	*/
1175	if (prev_index != index \|\| offset != prev_offset)
1176	mark_page_accessed(page);
1177	prev_index = index;
1178
1179	/*
1180	* Ok, we have the page, and it's up-to-date, so
1181	* now we can copy it to user space...
1182	*
1183	* The actor routine returns how many bytes were actually used..
1184	* NOTE! This may not be the same as how much of a user buffer
1185	* we filled up (we may be padding etc), so we can only update
1186	* "pos" here (the actor routine has to update the user buffer
1187	* pointers and the remaining count).
1188	*/
1189	ret = actor(desc, page, offset, nr);
1190	offset += ret;
1191	index += offset >> PAGE_CACHE_SHIFT;
1192	offset &= ~PAGE_CACHE_MASK;
1193	prev_offset = offset;
1194
1195	page_cache_release(page);
1196	if (ret == nr && desc->count)
1197	continue;
1198	goto out;
1199
1200	page_not_up_to_date:
1201	/* Get exclusive access to the page ... */
1202	error = lock_page_killable(page);
1203	if (unlikely(error))
1204	goto readpage_error;
1205
1206	page_not_up_to_date_locked:
1207	/* Did it get truncated before we got the lock? */
1208	if (!page->mapping) {
1209	unlock_page(page);
1210	page_cache_release(page);
1211	continue;
1212	}
1213
1214	/* Did somebody else fill it already? */
1215	if (PageUptodate(page)) {
1216	unlock_page(page);
1217	goto page_ok;
1218	}
1219
1220	readpage:
1221	/*
1222	* A previous I/O error may have been due to temporary
1223	* failures, eg. multipath errors.
1224	* PG_error will be set again if readpage fails.
1225	*/
1226	ClearPageError(page);
1227	/* Start the actual read. The read will unlock the page. */
1228	error = mapping->a_ops->readpage(filp, page);
1229
1230	if (unlikely(error)) {
1231	if (error == AOP_TRUNCATED_PAGE) {
1232	page_cache_release(page);
1233	goto find_page;
1234	}
1235	goto readpage_error;
1236	}
1237
1238	if (!PageUptodate(page)) {
1239	error = lock_page_killable(page);
1240	if (unlikely(error))
1241	goto readpage_error;
1242	if (!PageUptodate(page)) {
1243	if (page->mapping == NULL) {
1244	/*
1245	* invalidate_mapping_pages got it
1246	*/
1247	unlock_page(page);
1248	page_cache_release(page);
1249	goto find_page;
1250	}
1251	unlock_page(page);
1252	shrink_readahead_size_eio(filp, ra);
1253	error = -EIO;
1254	goto readpage_error;
1255	}
1256	unlock_page(page);
1257	}
1258
1259	goto page_ok;
1260
1261	readpage_error:
1262	/* UHHUH! A synchronous read error occurred. Report it */
1263	desc->error = error;
1264	page_cache_release(page);
1265	goto out;
1266
1267	no_cached_page:
1268	/*
1269	* Ok, it wasn't cached, so we need to create a new
1270	* page..
1271	*/
1272	page = page_cache_alloc_cold(mapping);
1273	if (!page) {
1274	desc->error = -ENOMEM;
1275	goto out;
1276	}
1277	error = add_to_page_cache_lru(page, mapping,
1278	index, GFP_KERNEL);
1279	if (error) {
1280	page_cache_release(page);
1281	if (error == -EEXIST)
1282	goto find_page;
1283	desc->error = error;
1284	goto out;
1285	}
1286	goto readpage;
1287	}
1288
1289	out:
1290	ra->prev_pos = prev_index;
1291	ra->prev_pos <<= PAGE_CACHE_SHIFT;
1292	ra->prev_pos \|= prev_offset;
1293
1294	*ppos = ((loff_t)index << PAGE_CACHE_SHIFT) + offset;
1295	file_accessed(filp);
1296	}
1297
1298	int file_read_actor(read_descriptor_t desc, struct page page,
1299	unsigned long offset, unsigned long size)
1300	{
1301	char *kaddr;
1302	unsigned long left, count = desc->count;
1303
1304	if (size > count)
1305	size = count;
1306
1307	/*
1308	* Faults on the destination of a read are common, so do it before
1309	* taking the kmap.
1310	*/
1311	if (!fault_in_pages_writeable(desc->arg.buf, size)) {
1312	kaddr = kmap_atomic(page);
1313	left = __copy_to_user_inatomic(desc->arg.buf,
1314	kaddr + offset, size);
1315	kunmap_atomic(kaddr);
1316	if (left == 0)
1317	goto success;
1318	}
1319
1320	/* Do it the slow way */
1321	kaddr = kmap(page);
1322	left = __copy_to_user(desc->arg.buf, kaddr + offset, size);
1323	kunmap(page);
1324
1325	if (left) {
1326	size -= left;
1327	desc->error = -EFAULT;
1328	}
1329	success:
1330	desc->count = count - size;
1331	desc->written += size;
1332	desc->arg.buf += size;
1333	return size;
1334	}
1335
1336	/*
1337	* Performs necessary checks before doing a write
1338	* @iov: io vector request
1339	* @nr_segs: number of segments in the iovec
1340	* @count: number of bytes to write
1341	* @access_flags: type of access: %VERIFY_READ or %VERIFY_WRITE
1342	*
1343	* Adjust number of segments and amount of bytes to write (nr_segs should be
1344	* properly initialized first). Returns appropriate error code that caller
1345	* should return or zero in case that write should be allowed.
1346	*/
1347	int generic_segment_checks(const struct iovec *iov,
1348	unsigned long nr_segs, size_t count, int access_flags)
1349	{
1350	unsigned long seg;
1351	size_t cnt = 0;
1352	for (seg = 0; seg < *nr_segs; seg++) {
1353	const struct iovec *iv = &iov[seg];
1354
1355	/*
1356	* If any segment has a negative length, or the cumulative
1357	* length ever wraps negative then return -EINVAL.
1358	*/
1359	cnt += iv->iov_len;
1360	if (unlikely((ssize_t)(cnt\|iv->iov_len) < 0))
1361	return -EINVAL;
1362	if (access_ok(access_flags, iv->iov_base, iv->iov_len))
1363	continue;
1364	if (seg == 0)
1365	return -EFAULT;
1366	*nr_segs = seg;
1367	cnt -= iv->iov_len; /* This segment is no good */
1368	break;
1369	}
1370	*count = cnt;
1371	return 0;
1372	}
1373	EXPORT_SYMBOL(generic_segment_checks);
1374
1375	/**
1376	* generic_file_aio_read - generic filesystem read routine
1377	* @iocb: kernel I/O control block
1378	* @iov: io vector request
1379	* @nr_segs: number of segments in the iovec
1380	* @pos: current file position
1381	*
1382	* This is the "read()" routine for all filesystems
1383	* that can use the page cache directly.
1384	*/
1385	ssize_t
1386	generic_file_aio_read(struct kiocb iocb, const struct iovec iov,
1387	unsigned long nr_segs, loff_t pos)
1388	{
1389	struct file *filp = iocb->ki_filp;
1390	ssize_t retval;
1391	unsigned long seg = 0;
1392	size_t count;
1393	loff_t *ppos = &iocb->ki_pos;
1394
1395	count = 0;
1396	retval = generic_segment_checks(iov, &nr_segs, &count, VERIFY_WRITE);
1397	if (retval)
1398	return retval;
1399
1400	/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
1401	if (filp->f_flags & O_DIRECT) {
1402	loff_t size;
1403	struct address_space *mapping;
1404	struct inode *inode;
1405
1406	mapping = filp->f_mapping;
1407	inode = mapping->host;
1408	if (!count)
1409	goto out; /* skip atime */
1410	size = i_size_read(inode);
1411	if (pos < size) {
1412	retval = filemap_write_and_wait_range(mapping, pos,
1413	pos + iov_length(iov, nr_segs) - 1);
1414	if (!retval) {
1415	struct blk_plug plug;
1416
1417	blk_start_plug(&plug);
1418	retval = mapping->a_ops->direct_IO(READ, iocb,
1419	iov, pos, nr_segs);
1420	blk_finish_plug(&plug);
1421	}
1422	if (retval > 0) {
1423	*ppos = pos + retval;
1424	count -= retval;
1425	}
1426
1427	/*
1428	* Btrfs can have a short DIO read if we encounter
1429	* compressed extents, so if there was an error, or if
1430	* we've already read everything we wanted to, or if
1431	* there was a short read because we hit EOF, go ahead
1432	* and return. Otherwise fallthrough to buffered io for
1433	* the rest of the read.
1434	*/
1435	if (retval < 0 \|\| !count \|\| *ppos >= size) {
1436	file_accessed(filp);
1437	goto out;
1438	}
1439	}
1440	}
1441
1442	count = retval;
1443	for (seg = 0; seg < nr_segs; seg++) {
1444	read_descriptor_t desc;
1445	loff_t offset = 0;
1446
1447	/*
1448	* If we did a short DIO read we need to skip the section of the
1449	* iov that we've already read data into.
1450	*/
1451	if (count) {
1452	if (count > iov[seg].iov_len) {
1453	count -= iov[seg].iov_len;
1454	continue;
1455	}
1456	offset = count;
1457	count = 0;
1458	}
1459
1460	desc.written = 0;
1461	desc.arg.buf = iov[seg].iov_base + offset;
1462	desc.count = iov[seg].iov_len - offset;
1463	if (desc.count == 0)
1464	continue;
1465	desc.error = 0;
1466	do_generic_file_read(filp, ppos, &desc, file_read_actor);
1467	retval += desc.written;
1468	if (desc.error) {
1469	retval = retval ?: desc.error;
1470	break;
1471	}
1472	if (desc.count > 0)
1473	break;
1474	}
1475	out:
1476	return retval;
1477	}
1478	EXPORT_SYMBOL(generic_file_aio_read);
1479
1480	#ifdef CONFIG_MMU
1481	/**
1482	* page_cache_read - adds requested page to the page cache if not already there
1483	* @file: file to read
1484	* @offset: page index
1485	*
1486	* This adds the requested page to the page cache if it isn't already there,
1487	* and schedules an I/O to read in its contents from disk.
1488	*/
1489	static int page_cache_read(struct file *file, pgoff_t offset)
1490	{
1491	struct address_space *mapping = file->f_mapping;
1492	struct page *page;
1493	int ret;
1494
1495	do {
1496	page = page_cache_alloc_cold(mapping);
1497	if (!page)
1498	return -ENOMEM;
1499
1500	ret = add_to_page_cache_lru(page, mapping, offset, GFP_KERNEL);
1501	if (ret == 0)
1502	ret = mapping->a_ops->readpage(file, page);
1503	else if (ret == -EEXIST)
1504	ret = 0; /* losing race to add is OK */
1505
1506	page_cache_release(page);
1507
1508	} while (ret == AOP_TRUNCATED_PAGE);
1509
1510	return ret;
1511	}
1512
1513	#define MMAP_LOTSAMISS (100)
1514
1515	/*
1516	* Synchronous readahead happens when we don't even find
1517	* a page in the page cache at all.
1518	*/
1519	static void do_sync_mmap_readahead(struct vm_area_struct *vma,
1520	struct file_ra_state *ra,
1521	struct file *file,
1522	pgoff_t offset)
1523	{
1524	unsigned long ra_pages;
1525	struct address_space *mapping = file->f_mapping;
1526
1527	/* If we don't want any read-ahead, don't bother */
1528	if (VM_RandomReadHint(vma))
1529	return;
1530	if (!ra->ra_pages)
1531	return;
1532
1533	if (VM_SequentialReadHint(vma)) {
1534	page_cache_sync_readahead(mapping, ra, file, offset,
1535	ra->ra_pages);
1536	return;
1537	}
1538
1539	/* Avoid banging the cache line if not needed */
1540	if (ra->mmap_miss < MMAP_LOTSAMISS * 10)
1541	ra->mmap_miss++;
1542
1543	/*
1544	* Do we miss much more than hit in this file? If so,
1545	* stop bothering with read-ahead. It will only hurt.
1546	*/
1547	if (ra->mmap_miss > MMAP_LOTSAMISS)
1548	return;
1549
1550	/*
1551	* mmap read-around
1552	*/
1553	ra_pages = max_sane_readahead(ra->ra_pages);
1554	ra->start = max_t(long, 0, offset - ra_pages / 2);
1555	ra->size = ra_pages;
1556	ra->async_size = ra_pages / 4;
1557	ra_submit(ra, mapping, file);
1558	}
1559
1560	/*
1561	* Asynchronous readahead happens when we find the page and PG_readahead,
1562	* so we want to possibly extend the readahead further..
1563	*/
1564	static void do_async_mmap_readahead(struct vm_area_struct *vma,
1565	struct file_ra_state *ra,
1566	struct file *file,
1567	struct page *page,
1568	pgoff_t offset)
1569	{
1570	struct address_space *mapping = file->f_mapping;
1571
1572	/* If we don't want any read-ahead, don't bother */
1573	if (VM_RandomReadHint(vma))
1574	return;
1575	if (ra->mmap_miss > 0)
1576	ra->mmap_miss--;
1577	if (PageReadahead(page))
1578	page_cache_async_readahead(mapping, ra, file,
1579	page, offset, ra->ra_pages);
1580	}
1581
1582	/**
1583	* filemap_fault - read in file data for page fault handling
1584	* @vma: vma in which the fault was taken
1585	* @vmf: struct vm_fault containing details of the fault
1586	*
1587	* filemap_fault() is invoked via the vma operations vector for a
1588	* mapped memory region to read in file data during a page fault.
1589	*
1590	* The goto's are kind of ugly, but this streamlines the normal case of having
1591	* it in the page cache, and handles the special cases reasonably without
1592	* having a lot of duplicated code.
1593	*/
1594	int filemap_fault(struct vm_area_struct vma, struct vm_fault vmf)
1595	{
1596	int error;
1597	struct file *file = vma->vm_file;
1598	struct address_space *mapping = file->f_mapping;
1599	struct file_ra_state *ra = &file->f_ra;
1600	struct inode *inode = mapping->host;
1601	pgoff_t offset = vmf->pgoff;
1602	struct page *page;
1603	pgoff_t size;
1604	int ret = 0;
1605
1606	size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
1607	if (offset >= size)
1608	return VM_FAULT_SIGBUS;
1609
1610	/*
1611	* Do we have something in the page cache already?
1612	*/
1613	page = find_get_page(mapping, offset);
1614	if (likely(page)) {
1615	/*
1616	* We found the page, so try async readahead before
1617	* waiting for the lock.
1618	*/
1619	do_async_mmap_readahead(vma, ra, file, page, offset);
1620	} else {
1621	/* No page in the page cache at all */
1622	do_sync_mmap_readahead(vma, ra, file, offset);
1623	count_vm_event(PGMAJFAULT);
1624	mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
1625	ret = VM_FAULT_MAJOR;
1626	retry_find:
1627	page = find_get_page(mapping, offset);
1628	if (!page)
1629	goto no_cached_page;
1630	}
1631
1632	if (!lock_page_or_retry(page, vma->vm_mm, vmf->flags)) {
1633	page_cache_release(page);
1634	return ret \| VM_FAULT_RETRY;
1635	}
1636
1637	/* Did it get truncated? */
1638	if (unlikely(page->mapping != mapping)) {
1639	unlock_page(page);
1640	put_page(page);
1641	goto retry_find;
1642	}
1643	VM_BUG_ON(page->index != offset);
1644
1645	/*
1646	* We have a locked page in the page cache, now we need to check
1647	* that it's up-to-date. If not, it is going to be due to an error.
1648	*/
1649	if (unlikely(!PageUptodate(page)))
1650	goto page_not_uptodate;
1651
1652	/*
1653	* Found the page and have a reference on it.
1654	* We must recheck i_size under page lock.
1655	*/
1656	size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
1657	if (unlikely(offset >= size)) {
1658	unlock_page(page);
1659	page_cache_release(page);
1660	return VM_FAULT_SIGBUS;
1661	}
1662
1663	vmf->page = page;
1664	return ret \| VM_FAULT_LOCKED;
1665
1666	no_cached_page:
1667	/*
1668	* We're only likely to ever get here if MADV_RANDOM is in
1669	* effect.
1670	*/
1671	error = page_cache_read(file, offset);
1672
1673	/*
1674	* The page we want has now been added to the page cache.
1675	* In the unlikely event that someone removed it in the
1676	* meantime, we'll just come back here and read it again.
1677	*/
1678	if (error >= 0)
1679	goto retry_find;
1680
1681	/*
1682	* An error return from page_cache_read can result if the
1683	* system is low on memory, or a problem occurs while trying
1684	* to schedule I/O.
1685	*/
1686	if (error == -ENOMEM)
1687	return VM_FAULT_OOM;
1688	return VM_FAULT_SIGBUS;
1689
1690	page_not_uptodate:
1691	/*
1692	* Umm, take care of errors if the page isn't up-to-date.
1693	* Try to re-read it _once_. We do this synchronously,
1694	* because there really aren't any performance issues here
1695	* and we need to check for errors.
1696	*/
1697	ClearPageError(page);
1698	error = mapping->a_ops->readpage(file, page);
1699	if (!error) {
1700	wait_on_page_locked(page);
1701	if (!PageUptodate(page))
1702	error = -EIO;
1703	}
1704	page_cache_release(page);
1705
1706	if (!error \|\| error == AOP_TRUNCATED_PAGE)
1707	goto retry_find;
1708
1709	/* Things didn't work out. Return zero to tell the mm layer so. */
1710	shrink_readahead_size_eio(file, ra);
1711	return VM_FAULT_SIGBUS;
1712	}
1713	EXPORT_SYMBOL(filemap_fault);
1714
1715	int filemap_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf)
1716	{
1717	struct page *page = vmf->page;
1718	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
1719	int ret = VM_FAULT_LOCKED;
1720
1721	sb_start_pagefault(inode->i_sb);
1722	file_update_time(vma->vm_file);
1723	lock_page(page);
1724	if (page->mapping != inode->i_mapping) {
1725	unlock_page(page);
1726	ret = VM_FAULT_NOPAGE;
1727	goto out;
1728	}
1729	/*
1730	* We mark the page dirty already here so that when freeze is in
1731	* progress, we are guaranteed that writeback during freezing will
1732	* see the dirty page and writeprotect it again.
1733	*/
1734	set_page_dirty(page);
1735	out:
1736	sb_end_pagefault(inode->i_sb);
1737	return ret;
1738	}
1739	EXPORT_SYMBOL(filemap_page_mkwrite);
1740
1741	const struct vm_operations_struct generic_file_vm_ops = {
1742	.fault = filemap_fault,
1743	.page_mkwrite = filemap_page_mkwrite,
1744	};
1745
1746	/* This is used for a general mmap of a disk file */
1747
1748	int generic_file_mmap(struct file * file, struct vm_area_struct * vma)
1749	{
1750	struct address_space *mapping = file->f_mapping;
1751
1752	if (!mapping->a_ops->readpage)
1753	return -ENOEXEC;
1754	file_accessed(file);
1755	vma->vm_ops = &generic_file_vm_ops;
1756	vma->vm_flags \|= VM_CAN_NONLINEAR;
1757	return 0;
1758	}
1759
1760	/*
1761	* This is for filesystems which do not implement ->writepage.
1762	*/
1763	int generic_file_readonly_mmap(struct file file, struct vm_area_struct vma)
1764	{
1765	if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE))
1766	return -EINVAL;
1767	return generic_file_mmap(file, vma);
1768	}
1769	#else
1770	int generic_file_mmap(struct file * file, struct vm_area_struct * vma)
1771	{
1772	return -ENOSYS;
1773	}
1774	int generic_file_readonly_mmap(struct file * file, struct vm_area_struct * vma)
1775	{
1776	return -ENOSYS;
1777	}
1778	#endif /* CONFIG_MMU */
1779
1780	EXPORT_SYMBOL(generic_file_mmap);
1781	EXPORT_SYMBOL(generic_file_readonly_mmap);
1782
1783	static struct page __read_cache_page(struct address_space mapping,
1784	pgoff_t index,
1785	int (filler)(void , struct page *),
1786	void *data,
1787	gfp_t gfp)
1788	{
1789	struct page *page;
1790	int err;
1791	repeat:
1792	page = find_get_page(mapping, index);
1793	if (!page) {
1794	page = __page_cache_alloc(gfp \| __GFP_COLD);
1795	if (!page)
1796	return ERR_PTR(-ENOMEM);
1797	err = add_to_page_cache_lru(page, mapping, index, gfp);
1798	if (unlikely(err)) {
1799	page_cache_release(page);
1800	if (err == -EEXIST)
1801	goto repeat;
1802	/* Presumably ENOMEM for radix tree node */
1803	return ERR_PTR(err);
1804	}
1805	err = filler(data, page);
1806	if (err < 0) {
1807	page_cache_release(page);
1808	page = ERR_PTR(err);
1809	}
1810	}
1811	return page;
1812	}
1813
1814	static struct page do_read_cache_page(struct address_space mapping,
1815	pgoff_t index,
1816	int (filler)(void , struct page *),
1817	void *data,
1818	gfp_t gfp)
1819
1820	{
1821	struct page *page;
1822	int err;
1823
1824	retry:
1825	page = __read_cache_page(mapping, index, filler, data, gfp);
1826	if (IS_ERR(page))
1827	return page;
1828	if (PageUptodate(page))
1829	goto out;
1830
1831	lock_page(page);
1832	if (!page->mapping) {
1833	unlock_page(page);
1834	page_cache_release(page);
1835	goto retry;
1836	}
1837	if (PageUptodate(page)) {
1838	unlock_page(page);
1839	goto out;
1840	}
1841	err = filler(data, page);
1842	if (err < 0) {
1843	page_cache_release(page);
1844	return ERR_PTR(err);
1845	}
1846	out:
1847	mark_page_accessed(page);
1848	return page;
1849	}
1850
1851	/**
1852	* read_cache_page_async - read into page cache, fill it if needed
1853	* @mapping: the page's address_space
1854	* @index: the page index
1855	* @filler: function to perform the read
1856	* @data: first arg to filler(data, page) function, often left as NULL
1857	*
1858	* Same as read_cache_page, but don't wait for page to become unlocked
1859	* after submitting it to the filler.
1860	*
1861	* Read into the page cache. If a page already exists, and PageUptodate() is
1862	* not set, try to fill the page but don't wait for it to become unlocked.
1863	*
1864	* If the page does not get brought uptodate, return -EIO.
1865	*/
1866	struct page read_cache_page_async(struct address_space mapping,
1867	pgoff_t index,
1868	int (filler)(void , struct page *),
1869	void *data)
1870	{
1871	return do_read_cache_page(mapping, index, filler, data, mapping_gfp_mask(mapping));
1872	}
1873	EXPORT_SYMBOL(read_cache_page_async);
1874
1875	static struct page wait_on_page_read(struct page page)
1876	{
1877	if (!IS_ERR(page)) {
1878	wait_on_page_locked(page);
1879	if (!PageUptodate(page)) {
1880	page_cache_release(page);
1881	page = ERR_PTR(-EIO);
1882	}
1883	}
1884	return page;
1885	}
1886
1887	/**
1888	* read_cache_page_gfp - read into page cache, using specified page allocation flags.
1889	* @mapping: the page's address_space
1890	* @index: the page index
1891	* @gfp: the page allocator flags to use if allocating
1892	*
1893	* This is the same as "read_mapping_page(mapping, index, NULL)", but with
1894	* any new page allocations done using the specified allocation flags.
1895	*
1896	* If the page does not get brought uptodate, return -EIO.
1897	*/
1898	struct page read_cache_page_gfp(struct address_space mapping,
1899	pgoff_t index,
1900	gfp_t gfp)
1901	{
1902	filler_t filler = (filler_t )mapping->a_ops->readpage;
1903
1904	return wait_on_page_read(do_read_cache_page(mapping, index, filler, NULL, gfp));
1905	}
1906	EXPORT_SYMBOL(read_cache_page_gfp);
1907
1908	/**
1909	* read_cache_page - read into page cache, fill it if needed
1910	* @mapping: the page's address_space
1911	* @index: the page index
1912	* @filler: function to perform the read
1913	* @data: first arg to filler(data, page) function, often left as NULL
1914	*
1915	* Read into the page cache. If a page already exists, and PageUptodate() is
1916	* not set, try to fill the page then wait for it to become unlocked.
1917	*
1918	* If the page does not get brought uptodate, return -EIO.
1919	*/
1920	struct page read_cache_page(struct address_space mapping,
1921	pgoff_t index,
1922	int (filler)(void , struct page *),
1923	void *data)
1924	{
1925	return wait_on_page_read(read_cache_page_async(mapping, index, filler, data));
1926	}
1927	EXPORT_SYMBOL(read_cache_page);
1928
1929	static size_t __iovec_copy_from_user_inatomic(char *vaddr,
1930	const struct iovec *iov, size_t base, size_t bytes)
1931	{
1932	size_t copied = 0, left = 0;
1933
1934	while (bytes) {
1935	char __user *buf = iov->iov_base + base;
1936	int copy = min(bytes, iov->iov_len - base);
1937
1938	base = 0;
1939	left = __copy_from_user_inatomic(vaddr, buf, copy);
1940	copied += copy;
1941	bytes -= copy;
1942	vaddr += copy;
1943	iov++;
1944
1945	if (unlikely(left))
1946	break;
1947	}
1948	return copied - left;
1949	}
1950
1951	/*
1952	* Copy as much as we can into the page and return the number of bytes which
1953	* were successfully copied. If a fault is encountered then return the number of
1954	* bytes which were copied.
1955	*/
1956	size_t iov_iter_copy_from_user_atomic(struct page *page,
1957	struct iov_iter *i, unsigned long offset, size_t bytes)
1958	{
1959	char *kaddr;
1960	size_t copied;
1961
1962	BUG_ON(!in_atomic());
1963	kaddr = kmap_atomic(page);
1964	if (likely(i->nr_segs == 1)) {
1965	int left;
1966	char __user *buf = i->iov->iov_base + i->iov_offset;
1967	left = __copy_from_user_inatomic(kaddr + offset, buf, bytes);
1968	copied = bytes - left;
1969	} else {
1970	copied = __iovec_copy_from_user_inatomic(kaddr + offset,
1971	i->iov, i->iov_offset, bytes);
1972	}
1973	kunmap_atomic(kaddr);
1974
1975	return copied;
1976	}
1977	EXPORT_SYMBOL(iov_iter_copy_from_user_atomic);
1978
1979	/*
1980	* This has the same sideeffects and return value as
1981	* iov_iter_copy_from_user_atomic().
1982	* The difference is that it attempts to resolve faults.
1983	* Page must not be locked.
1984	*/
1985	size_t iov_iter_copy_from_user(struct page *page,
1986	struct iov_iter *i, unsigned long offset, size_t bytes)
1987	{
1988	char *kaddr;
1989	size_t copied;
1990
1991	kaddr = kmap(page);
1992	if (likely(i->nr_segs == 1)) {
1993	int left;
1994	char __user *buf = i->iov->iov_base + i->iov_offset;
1995	left = __copy_from_user(kaddr + offset, buf, bytes);
1996	copied = bytes - left;
1997	} else {
1998	copied = __iovec_copy_from_user_inatomic(kaddr + offset,
1999	i->iov, i->iov_offset, bytes);
2000	}
2001	kunmap(page);
2002	return copied;
2003	}
2004	EXPORT_SYMBOL(iov_iter_copy_from_user);
2005
2006	void iov_iter_advance(struct iov_iter *i, size_t bytes)
2007	{
2008	BUG_ON(i->count < bytes);
2009
2010	if (likely(i->nr_segs == 1)) {
2011	i->iov_offset += bytes;
2012	i->count -= bytes;
2013	} else {
2014	const struct iovec *iov = i->iov;
2015	size_t base = i->iov_offset;
2016	unsigned long nr_segs = i->nr_segs;
2017
2018	/*
2019	* The !iov->iov_len check ensures we skip over unlikely
2020	* zero-length segments (without overruning the iovec).
2021	*/
2022	while (bytes \|\| unlikely(i->count && !iov->iov_len)) {
2023	int copy;
2024
2025	copy = min(bytes, iov->iov_len - base);
2026	BUG_ON(!i->count \|\| i->count < copy);
2027	i->count -= copy;
2028	bytes -= copy;
2029	base += copy;
2030	if (iov->iov_len == base) {
2031	iov++;
2032	nr_segs--;
2033	base = 0;
2034	}
2035	}
2036	i->iov = iov;
2037	i->iov_offset = base;
2038	i->nr_segs = nr_segs;
2039	}
2040	}
2041	EXPORT_SYMBOL(iov_iter_advance);
2042
2043	/*
2044	* Fault in the first iovec of the given iov_iter, to a maximum length
2045	* of bytes. Returns 0 on success, or non-zero if the memory could not be
2046	* accessed (ie. because it is an invalid address).
2047	*
2048	* writev-intensive code may want this to prefault several iovecs -- that
2049	* would be possible (callers must not rely on the fact that _only_ the
2050	* first iovec will be faulted with the current implementation).
2051	*/
2052	int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
2053	{
2054	char __user *buf = i->iov->iov_base + i->iov_offset;
2055	bytes = min(bytes, i->iov->iov_len - i->iov_offset);
2056	return fault_in_pages_readable(buf, bytes);
2057	}
2058	EXPORT_SYMBOL(iov_iter_fault_in_readable);
2059
2060	/*
2061	* Return the count of just the current iov_iter segment.
2062	*/
2063	size_t iov_iter_single_seg_count(struct iov_iter *i)
2064	{
2065	const struct iovec *iov = i->iov;
2066	if (i->nr_segs == 1)
2067	return i->count;
2068	else
2069	return min(i->count, iov->iov_len - i->iov_offset);
2070	}
2071	EXPORT_SYMBOL(iov_iter_single_seg_count);
2072
2073	/*
2074	* Performs necessary checks before doing a write
2075	*
2076	* Can adjust writing position or amount of bytes to write.
2077	* Returns appropriate error code that caller should return or
2078	* zero in case that write should be allowed.
2079	*/
2080	inline int generic_write_checks(struct file file, loff_t pos, size_t *count, int isblk)
2081	{
2082	struct inode *inode = file->f_mapping->host;
2083	unsigned long limit = rlimit(RLIMIT_FSIZE);
2084
2085	if (unlikely(*pos < 0))
2086	return -EINVAL;
2087
2088	if (!isblk) {
2089	/* FIXME: this is for backwards compatibility with 2.4 */
2090	if (file->f_flags & O_APPEND)
2091	*pos = i_size_read(inode);
2092
2093	if (limit != RLIM_INFINITY) {
2094	if (*pos >= limit) {
2095	send_sig(SIGXFSZ, current, 0);
2096	return -EFBIG;
2097	}
2098	if (count > limit - (typeof(limit))pos) {
2099	count = limit - (typeof(limit))pos;
2100	}
2101	}
2102	}
2103
2104	/*
2105	* LFS rule
2106	*/
2107	if (unlikely(pos + count > MAX_NON_LFS &&
2108	!(file->f_flags & O_LARGEFILE))) {
2109	if (*pos >= MAX_NON_LFS) {
2110	return -EFBIG;
2111	}
2112	if (count > MAX_NON_LFS - (unsigned long)pos) {
2113	count = MAX_NON_LFS - (unsigned long)pos;
2114	}
2115	}
2116
2117	/*
2118	* Are we about to exceed the fs block limit ?
2119	*
2120	* If we have written data it becomes a short write. If we have
2121	* exceeded without writing data we send a signal and return EFBIG.
2122	* Linus frestrict idea will clean these up nicely..
2123	*/
2124	if (likely(!isblk)) {
2125	if (unlikely(*pos >= inode->i_sb->s_maxbytes)) {
2126	if (count \|\| pos > inode->i_sb->s_maxbytes) {
2127	return -EFBIG;
2128	}
2129	/* zero-length writes at ->s_maxbytes are OK */
2130	}
2131
2132	if (unlikely(pos + count > inode->i_sb->s_maxbytes))
2133	count = inode->i_sb->s_maxbytes - pos;
2134	} else {
2135	#ifdef CONFIG_BLOCK
2136	loff_t isize;
2137	if (bdev_read_only(I_BDEV(inode)))
2138	return -EPERM;
2139	isize = i_size_read(inode);
2140	if (*pos >= isize) {
2141	if (count \|\| pos > isize)
2142	return -ENOSPC;
2143	}
2144
2145	if (pos + count > isize)
2146	count = isize - pos;
2147	#else
2148	return -EPERM;
2149	#endif
2150	}
2151	return 0;
2152	}
2153	EXPORT_SYMBOL(generic_write_checks);
2154
2155	int pagecache_write_begin(struct file file, struct address_space mapping,
2156	loff_t pos, unsigned len, unsigned flags,
2157	struct page pagep, void fsdata)
2158	{
2159	const struct address_space_operations *aops = mapping->a_ops;
2160
2161	return aops->write_begin(file, mapping, pos, len, flags,
2162	pagep, fsdata);
2163	}
2164	EXPORT_SYMBOL(pagecache_write_begin);
2165
2166	int pagecache_write_end(struct file file, struct address_space mapping,
2167	loff_t pos, unsigned len, unsigned copied,
2168	struct page page, void fsdata)
2169	{
2170	const struct address_space_operations *aops = mapping->a_ops;
2171
2172	mark_page_accessed(page);
2173	return aops->write_end(file, mapping, pos, len, copied, page, fsdata);
2174	}
2175	EXPORT_SYMBOL(pagecache_write_end);
2176
2177	ssize_t
2178	generic_file_direct_write(struct kiocb iocb, const struct iovec iov,
2179	unsigned long nr_segs, loff_t pos, loff_t ppos,
2180	size_t count, size_t ocount)
2181	{
2182	struct file *file = iocb->ki_filp;
2183	struct address_space *mapping = file->f_mapping;
2184	struct inode *inode = mapping->host;
2185	ssize_t written;
2186	size_t write_len;
2187	pgoff_t end;
2188
2189	if (count != ocount)
2190	nr_segs = iov_shorten((struct iovec )iov, *nr_segs, count);
2191
2192	write_len = iov_length(iov, *nr_segs);
2193	end = (pos + write_len - 1) >> PAGE_CACHE_SHIFT;
2194
2195	written = filemap_write_and_wait_range(mapping, pos, pos + write_len - 1);
2196	if (written)
2197	goto out;
2198
2199	/*
2200	* After a write we want buffered reads to be sure to go to disk to get
2201	* the new data. We invalidate clean cached page from the region we're
2202	* about to write. We do this before the write so that we can return
2203	* without clobbering -EIOCBQUEUED from ->direct_IO().
2204	*/
2205	if (mapping->nrpages) {
2206	written = invalidate_inode_pages2_range(mapping,
2207	pos >> PAGE_CACHE_SHIFT, end);
2208	/*
2209	* If a page can not be invalidated, return 0 to fall back
2210	* to buffered write.
2211	*/
2212	if (written) {
2213	if (written == -EBUSY)
2214	return 0;
2215	goto out;
2216	}
2217	}
2218
2219	written = mapping->a_ops->direct_IO(WRITE, iocb, iov, pos, *nr_segs);
2220
2221	/*
2222	* Finally, try again to invalidate clean pages which might have been
2223	* cached by non-direct readahead, or faulted in by get_user_pages()
2224	* if the source of the write was an mmap'ed region of the file
2225	* we're writing. Either one is a pretty crazy thing to do,
2226	* so we don't support it 100%. If this invalidation
2227	* fails, tough, the write still worked...
2228	*/
2229	if (mapping->nrpages) {
2230	invalidate_inode_pages2_range(mapping,
2231	pos >> PAGE_CACHE_SHIFT, end);
2232	}
2233
2234	if (written > 0) {
2235	pos += written;
2236	if (pos > i_size_read(inode) && !S_ISBLK(inode->i_mode)) {
2237	i_size_write(inode, pos);
2238	mark_inode_dirty(inode);
2239	}
2240	*ppos = pos;
2241	}
2242	out:
2243	return written;
2244	}
2245	EXPORT_SYMBOL(generic_file_direct_write);
2246
2247	/*
2248	* Find or create a page at the given pagecache position. Return the locked
2249	* page. This function is specifically for buffered writes.
2250	*/
2251	struct page grab_cache_page_write_begin(struct address_space mapping,
2252	pgoff_t index, unsigned flags)
2253	{
2254	int status;
2255	gfp_t gfp_mask;
2256	struct page *page;
2257	gfp_t gfp_notmask = 0;
2258
2259	gfp_mask = mapping_gfp_mask(mapping);
2260	if (mapping_cap_account_dirty(mapping))
2261	gfp_mask \|= __GFP_WRITE;
2262	if (flags & AOP_FLAG_NOFS)
2263	gfp_notmask = __GFP_FS;
2264	repeat:
2265	page = find_lock_page(mapping, index);
2266	if (page)
2267	goto found;
2268
2269	page = __page_cache_alloc(gfp_mask & ~gfp_notmask);
2270	if (!page)
2271	return NULL;
2272	status = add_to_page_cache_lru(page, mapping, index,
2273	GFP_KERNEL & ~gfp_notmask);
2274	if (unlikely(status)) {
2275	page_cache_release(page);
2276	if (status == -EEXIST)
2277	goto repeat;
2278	return NULL;
2279	}
2280	found:
2281	wait_on_page_writeback(page);
2282	return page;
2283	}
2284	EXPORT_SYMBOL(grab_cache_page_write_begin);
2285
2286	static ssize_t generic_perform_write(struct file *file,
2287	struct iov_iter *i, loff_t pos)
2288	{
2289	struct address_space *mapping = file->f_mapping;
2290	const struct address_space_operations *a_ops = mapping->a_ops;
2291	long status = 0;
2292	ssize_t written = 0;
2293	unsigned int flags = 0;
2294
2295	/*
2296	* Copies from kernel address space cannot fail (NFSD is a big user).
2297	*/
2298	if (segment_eq(get_fs(), KERNEL_DS))
2299	flags \|= AOP_FLAG_UNINTERRUPTIBLE;
2300
2301	do {
2302	struct page *page;
2303	unsigned long offset; /* Offset into pagecache page */
2304	unsigned long bytes; /* Bytes to write to page */
2305	size_t copied; /* Bytes copied from user */
2306	void *fsdata;
2307
2308	offset = (pos & (PAGE_CACHE_SIZE - 1));
2309	bytes = min_t(unsigned long, PAGE_CACHE_SIZE - offset,
2310	iov_iter_count(i));
2311
2312	again:
2313	/*
2314	* Bring in the user page that we will copy from _first_.
2315	* Otherwise there's a nasty deadlock on copying from the
2316	* same page as we're writing to, without it being marked
2317	* up-to-date.
2318	*
2319	* Not only is this an optimisation, but it is also required
2320	* to check that the address is actually valid, when atomic
2321	* usercopies are used, below.
2322	*/
2323	if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
2324	status = -EFAULT;
2325	break;
2326	}
2327
2328	status = a_ops->write_begin(file, mapping, pos, bytes, flags,
2329	&page, &fsdata);
2330	if (unlikely(status))
2331	break;
2332
2333	if (mapping_writably_mapped(mapping))
2334	flush_dcache_page(page);
2335
2336	pagefault_disable();
2337	copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);
2338	pagefault_enable();
2339	flush_dcache_page(page);
2340
2341	mark_page_accessed(page);
2342	status = a_ops->write_end(file, mapping, pos, bytes, copied,
2343	page, fsdata);
2344	if (unlikely(status < 0))
2345	break;
2346	copied = status;
2347
2348	cond_resched();
2349
2350	iov_iter_advance(i, copied);
2351	if (unlikely(copied == 0)) {
2352	/*
2353	* If we were unable to copy any data at all, we must
2354	* fall back to a single segment length write.
2355	*
2356	* If we didn't fallback here, we could livelock
2357	* because not all segments in the iov can be copied at
2358	* once without a pagefault.
2359	*/
2360	bytes = min_t(unsigned long, PAGE_CACHE_SIZE - offset,
2361	iov_iter_single_seg_count(i));
2362	goto again;
2363	}
2364	pos += copied;
2365	written += copied;
2366
2367	balance_dirty_pages_ratelimited(mapping);
2368	if (fatal_signal_pending(current)) {
2369	status = -EINTR;
2370	break;
2371	}
2372	} while (iov_iter_count(i));
2373
2374	return written ? written : status;
2375	}
2376
2377	ssize_t
2378	generic_file_buffered_write(struct kiocb iocb, const struct iovec iov,
2379	unsigned long nr_segs, loff_t pos, loff_t *ppos,
2380	size_t count, ssize_t written)
2381	{
2382	struct file *file = iocb->ki_filp;
2383	ssize_t status;
2384	struct iov_iter i;
2385
2386	iov_iter_init(&i, iov, nr_segs, count, written);
2387	status = generic_perform_write(file, &i, pos);
2388
2389	if (likely(status >= 0)) {
2390	written += status;
2391	*ppos = pos + status;
2392	}
2393
2394	return written ? written : status;
2395	}
2396	EXPORT_SYMBOL(generic_file_buffered_write);
2397
2398	/**
2399	* __generic_file_aio_write - write data to a file
2400	* @iocb: IO state structure (file, offset, etc.)
2401	* @iov: vector with data to write
2402	* @nr_segs: number of segments in the vector
2403	* @ppos: position where to write
2404	*
2405	* This function does all the work needed for actually writing data to a
2406	* file. It does all basic checks, removes SUID from the file, updates
2407	* modification times and calls proper subroutines depending on whether we
2408	* do direct IO or a standard buffered write.
2409	*
2410	* It expects i_mutex to be grabbed unless we work on a block device or similar
2411	* object which does not need locking at all.
2412	*
2413	* This function does not take care of syncing data in case of O_SYNC write.
2414	* A caller has to handle it. This is mainly due to the fact that we want to
2415	* avoid syncing under i_mutex.
2416	*/
2417	ssize_t __generic_file_aio_write(struct kiocb iocb, const struct iovec iov,
2418	unsigned long nr_segs, loff_t *ppos)
2419	{
2420	struct file *file = iocb->ki_filp;
2421	struct address_space * mapping = file->f_mapping;
2422	size_t ocount; /* original count */
2423	size_t count; /* after file limit checks */
2424	struct inode *inode = mapping->host;
2425	loff_t pos;
2426	ssize_t written;
2427	ssize_t err;
2428
2429	ocount = 0;
2430	err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
2431	if (err)
2432	return err;
2433
2434	count = ocount;
2435	pos = *ppos;
2436
2437	/* We can write back this queue in page reclaim */
2438	current->backing_dev_info = mapping->backing_dev_info;
2439	written = 0;
2440
2441	err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
2442	if (err)
2443	goto out;
2444
2445	if (count == 0)
2446	goto out;
2447
2448	err = file_remove_suid(file);
2449	if (err)
2450	goto out;
2451
2452	err = file_update_time(file);
2453	if (err)
2454	goto out;
2455
2456	/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
2457	if (unlikely(file->f_flags & O_DIRECT)) {
2458	loff_t endbyte;
2459	ssize_t written_buffered;
2460
2461	written = generic_file_direct_write(iocb, iov, &nr_segs, pos,
2462	ppos, count, ocount);
2463	if (written < 0 \|\| written == count)
2464	goto out;
2465	/*
2466	* direct-io write to a hole: fall through to buffered I/O
2467	* for completing the rest of the request.
2468	*/
2469	pos += written;
2470	count -= written;
2471	written_buffered = generic_file_buffered_write(iocb, iov,
2472	nr_segs, pos, ppos, count,
2473	written);
2474	/*
2475	* If generic_file_buffered_write() retuned a synchronous error
2476	* then we want to return the number of bytes which were
2477	* direct-written, or the error code if that was zero. Note
2478	* that this differs from normal direct-io semantics, which
2479	* will return -EFOO even if some bytes were written.
2480	*/
2481	if (written_buffered < 0) {
2482	err = written_buffered;
2483	goto out;
2484	}
2485
2486	/*
2487	* We need to ensure that the page cache pages are written to
2488	* disk and invalidated to preserve the expected O_DIRECT
2489	* semantics.
2490	*/
2491	endbyte = pos + written_buffered - written - 1;
2492	err = filemap_write_and_wait_range(file->f_mapping, pos, endbyte);
2493	if (err == 0) {
2494	written = written_buffered;
2495	invalidate_mapping_pages(mapping,
2496	pos >> PAGE_CACHE_SHIFT,
2497	endbyte >> PAGE_CACHE_SHIFT);
2498	} else {
2499	/*
2500	* We don't know how much we wrote, so just return
2501	* the number of bytes which were direct-written
2502	*/
2503	}
2504	} else {
2505	written = generic_file_buffered_write(iocb, iov, nr_segs,
2506	pos, ppos, count, written);
2507	}
2508	out:
2509	current->backing_dev_info = NULL;
2510	return written ? written : err;
2511	}
2512	EXPORT_SYMBOL(__generic_file_aio_write);
2513
2514	/**
2515	* generic_file_aio_write - write data to a file
2516	* @iocb: IO state structure
2517	* @iov: vector with data to write
2518	* @nr_segs: number of segments in the vector
2519	* @pos: position in file where to write
2520	*
2521	* This is a wrapper around __generic_file_aio_write() to be used by most
2522	* filesystems. It takes care of syncing the file in case of O_SYNC file
2523	* and acquires i_mutex as needed.
2524	*/
2525	ssize_t generic_file_aio_write(struct kiocb iocb, const struct iovec iov,
2526	unsigned long nr_segs, loff_t pos)
2527	{
2528	struct file *file = iocb->ki_filp;
2529	struct inode *inode = file->f_mapping->host;
2530	struct blk_plug plug;
2531	ssize_t ret;
2532
2533	BUG_ON(iocb->ki_pos != pos);
2534
2535	sb_start_write(inode->i_sb);
2536	mutex_lock(&inode->i_mutex);
2537	blk_start_plug(&plug);
2538	ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
2539	mutex_unlock(&inode->i_mutex);
2540
2541	if (ret > 0 \|\| ret == -EIOCBQUEUED) {
2542	ssize_t err;
2543
2544	err = generic_write_sync(file, pos, ret);
2545	if (err < 0 && ret > 0)
2546	ret = err;
2547	}
2548	blk_finish_plug(&plug);
2549	sb_end_write(inode->i_sb);
2550	return ret;
2551	}
2552	EXPORT_SYMBOL(generic_file_aio_write);
2553
2554	/**
2555	* try_to_release_page() - release old fs-specific metadata on a page
2556	*
2557	* @page: the page which the kernel is trying to free
2558	* @gfp_mask: memory allocation flags (and I/O mode)
2559	*
2560	* The address_space is to try to release any data against the page
2561	* (presumably at page->private). If the release was successful, return `1'.
2562	* Otherwise return zero.
2563	*
2564	* This may also be called if PG_fscache is set on a page, indicating that the
2565	* page is known to the local caching routines.
2566	*
2567	* The @gfp_mask argument specifies whether I/O may be performed to release
2568	* this page (__GFP_IO), and whether the call may block (__GFP_WAIT & __GFP_FS).
2569	*
2570	*/
2571	int try_to_release_page(struct page *page, gfp_t gfp_mask)
2572	{
2573	struct address_space * const mapping = page->mapping;
2574
2575	BUG_ON(!PageLocked(page));
2576	if (PageWriteback(page))
2577	return 0;
2578
2579	if (mapping && mapping->a_ops->releasepage)
2580	return mapping->a_ops->releasepage(page, gfp_mask);
2581	return try_to_free_buffers(page);
2582	}
2583
2584	EXPORT_SYMBOL(try_to_release_page);
2585

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/mm/filemap.c

interactive