inode.c (6913a9dbf18f08e3577695032da15812bda92b66) inode.c (bbf023c74dcf380769aec00aedd706a266b7d9ef)
1/*
2 * linux/fs/ext4/inode.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *

--- 2164 unchanged lines hidden (view full) ---

2173}
2174
2175/*
2176 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2177 * mpd->len and submit pages underlying it for IO
2178 *
2179 * @handle - handle for journal operations
2180 * @mpd - extent to map
1/*
2 * linux/fs/ext4/inode.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *

--- 2164 unchanged lines hidden (view full) ---

2173}
2174
2175/*
2176 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2177 * mpd->len and submit pages underlying it for IO
2178 *
2179 * @handle - handle for journal operations
2180 * @mpd - extent to map
2181 * @give_up_on_write - we set this to true iff there is a fatal error and there
2182 * is no hope of writing the data. The caller should discard
2183 * dirty pages to avoid infinite loops.
2181 *
2182 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2183 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2184 * them to initialized or split the described range from larger unwritten
2185 * extent. Note that we need not map all the described range since allocation
2186 * can return less blocks or the range is covered by more unwritten extents. We
2187 * cannot map more because we are limited by reserved transaction credits. On
2188 * the other hand we always make sure that the last touched page is fully

--- 101 unchanged lines hidden (view full) ---

2290 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2291 * case as we need to track IO to all buffers underlying a page in one io_end.
2292 */
2293static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
2294{
2295 struct address_space *mapping = mpd->inode->i_mapping;
2296 struct pagevec pvec;
2297 unsigned int nr_pages;
2184 *
2185 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2186 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2187 * them to initialized or split the described range from larger unwritten
2188 * extent. Note that we need not map all the described range since allocation
2189 * can return less blocks or the range is covered by more unwritten extents. We
2190 * cannot map more because we are limited by reserved transaction credits. On
2191 * the other hand we always make sure that the last touched page is fully

--- 101 unchanged lines hidden (view full) ---

2293 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2294 * case as we need to track IO to all buffers underlying a page in one io_end.
2295 */
2296static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
2297{
2298 struct address_space *mapping = mpd->inode->i_mapping;
2299 struct pagevec pvec;
2300 unsigned int nr_pages;
2301 long left = mpd->wbc->nr_to_write;
2298 pgoff_t index = mpd->first_page;
2299 pgoff_t end = mpd->last_page;
2300 int tag;
2301 int i, err = 0;
2302 int blkbits = mpd->inode->i_blkbits;
2303 ext4_lblk_t lblk;
2304 struct buffer_head *head;
2305

--- 19 unchanged lines hidden (view full) ---

2325 * invalidated (changing page->mapping to NULL), or
2326 * even swizzled back from swapper_space to tmpfs file
2327 * mapping. However, page->index will not change
2328 * because we have a reference on the page.
2329 */
2330 if (page->index > end)
2331 goto out;
2332
2302 pgoff_t index = mpd->first_page;
2303 pgoff_t end = mpd->last_page;
2304 int tag;
2305 int i, err = 0;
2306 int blkbits = mpd->inode->i_blkbits;
2307 ext4_lblk_t lblk;
2308 struct buffer_head *head;
2309

--- 19 unchanged lines hidden (view full) ---

2329 * invalidated (changing page->mapping to NULL), or
2330 * even swizzled back from swapper_space to tmpfs file
2331 * mapping. However, page->index will not change
2332 * because we have a reference on the page.
2333 */
2334 if (page->index > end)
2335 goto out;
2336
2337 /*
2338 * Accumulated enough dirty pages? This doesn't apply
2339 * to WB_SYNC_ALL mode. For integrity sync we have to
2340 * keep going because someone may be concurrently
2341 * dirtying pages, and we might have synced a lot of
2342 * newly appeared dirty pages, but have not synced all
2343 * of the old dirty pages.
2344 */
2345 if (mpd->wbc->sync_mode == WB_SYNC_NONE && left <= 0)
2346 goto out;
2347
2333 /* If we can't merge this page, we are done. */
2334 if (mpd->map.m_len > 0 && mpd->next_page != page->index)
2335 goto out;
2336
2337 lock_page(page);
2338 /*
2339 * If the page is no longer dirty, or its mapping no
2340 * longer corresponds to inode we are writing (which

--- 18 unchanged lines hidden (view full) ---

2359 /* Add all dirty buffers to mpd */
2360 lblk = ((ext4_lblk_t)page->index) <<
2361 (PAGE_CACHE_SHIFT - blkbits);
2362 head = page_buffers(page);
2363 err = mpage_process_page_bufs(mpd, head, head, lblk);
2364 if (err <= 0)
2365 goto out;
2366 err = 0;
2348 /* If we can't merge this page, we are done. */
2349 if (mpd->map.m_len > 0 && mpd->next_page != page->index)
2350 goto out;
2351
2352 lock_page(page);
2353 /*
2354 * If the page is no longer dirty, or its mapping no
2355 * longer corresponds to inode we are writing (which

--- 18 unchanged lines hidden (view full) ---

2374 /* Add all dirty buffers to mpd */
2375 lblk = ((ext4_lblk_t)page->index) <<
2376 (PAGE_CACHE_SHIFT - blkbits);
2377 head = page_buffers(page);
2378 err = mpage_process_page_bufs(mpd, head, head, lblk);
2379 if (err <= 0)
2380 goto out;
2381 err = 0;
2367
2368 /*
2369 * Accumulated enough dirty pages? This doesn't apply
2370 * to WB_SYNC_ALL mode. For integrity sync we have to
2371 * keep going because someone may be concurrently
2372 * dirtying pages, and we might have synced a lot of
2373 * newly appeared dirty pages, but have not synced all
2374 * of the old dirty pages.
2375 */
2376 if (mpd->wbc->sync_mode == WB_SYNC_NONE &&
2377 mpd->next_page - mpd->first_page >=
2378 mpd->wbc->nr_to_write)
2379 goto out;
2382 left--;
2380 }
2381 pagevec_release(&pvec);
2382 cond_resched();
2383 }
2384 return 0;
2385out:
2386 pagevec_release(&pvec);
2387 return err;

--- 27 unchanged lines hidden (view full) ---

2415 trace_ext4_writepages(inode, wbc);
2416
2417 /*
2418 * No pages to write? This is mainly a kludge to avoid starting
2419 * a transaction for special inodes like journal inode on last iput()
2420 * because that could violate lock ordering on umount
2421 */
2422 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2383 }
2384 pagevec_release(&pvec);
2385 cond_resched();
2386 }
2387 return 0;
2388out:
2389 pagevec_release(&pvec);
2390 return err;

--- 27 unchanged lines hidden (view full) ---

2418 trace_ext4_writepages(inode, wbc);
2419
2420 /*
2421 * No pages to write? This is mainly a kludge to avoid starting
2422 * a transaction for special inodes like journal inode on last iput()
2423 * because that could violate lock ordering on umount
2424 */
2425 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2423 return 0;
2426 goto out_writepages;
2424
2425 if (ext4_should_journal_data(inode)) {
2426 struct blk_plug plug;
2427
2428 if (ext4_should_journal_data(inode)) {
2429 struct blk_plug plug;
2427 int ret;
2428
2429 blk_start_plug(&plug);
2430 ret = write_cache_pages(mapping, wbc, __writepage, mapping);
2431 blk_finish_plug(&plug);
2430
2431 blk_start_plug(&plug);
2432 ret = write_cache_pages(mapping, wbc, __writepage, mapping);
2433 blk_finish_plug(&plug);
2432 return ret;
2434 goto out_writepages;
2433 }
2434
2435 /*
2436 * If the filesystem has aborted, it is read-only, so return
2437 * right away instead of dumping stack traces later on that
2438 * will obscure the real source of the problem. We test
2439 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2440 * the latter could be true if the filesystem is mounted
2441 * read-only, and in that case, ext4_writepages should
2442 * *never* be called, so if that ever happens, we would want
2443 * the stack trace.
2444 */
2435 }
2436
2437 /*
2438 * If the filesystem has aborted, it is read-only, so return
2439 * right away instead of dumping stack traces later on that
2440 * will obscure the real source of the problem. We test
2441 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2442 * the latter could be true if the filesystem is mounted
2443 * read-only, and in that case, ext4_writepages should
2444 * *never* be called, so if that ever happens, we would want
2445 * the stack trace.
2446 */
2445 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2446 return -EROFS;
2447 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2448 ret = -EROFS;
2449 goto out_writepages;
2450 }
2447
2448 if (ext4_should_dioread_nolock(inode)) {
2449 /*
2450 * We may need to convert up to one extent per block in
2451 * the page and we may dirty the inode.
2452 */
2453 rsv_blocks = 1 + (PAGE_CACHE_SIZE >> inode->i_blkbits);
2454 }

--- 2705 unchanged lines hidden --- 		2451
2452 if (ext4_should_dioread_nolock(inode)) {
2453 /*
2454 * We may need to convert up to one extent per block in
2455 * the page and we may dirty the inode.
2456 */
2457 rsv_blocks = 1 + (PAGE_CACHE_SIZE >> inode->i_blkbits);
2458 }

--- 2705 unchanged lines hidden ---