extent_map.c (bcd987feefe8da66bc59b4e6bd51761a9820588c) extent_map.c (55c69072d6bd5be170a85467f64a20963cddf490)
1#include <linux/bitops.h>
2#include <linux/slab.h>
3#include <linux/bio.h>
4#include <linux/mm.h>
5#include <linux/gfp.h>
6#include <linux/pagemap.h>
7#include <linux/page-flags.h>
8#include <linux/module.h>

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

1658 if (!PagePrivate(page)) {
1659 SetPagePrivate(page);
1660 WARN_ON(!page->mapping->a_ops->invalidatepage);
1661 set_page_private(page, EXTENT_PAGE_PRIVATE);
1662 page_cache_get(page);
1663 }
1664}
1665
1#include <linux/bitops.h>
2#include <linux/slab.h>
3#include <linux/bio.h>
4#include <linux/mm.h>
5#include <linux/gfp.h>
6#include <linux/pagemap.h>
7#include <linux/page-flags.h>
8#include <linux/module.h>

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

1658 if (!PagePrivate(page)) {
1659 SetPagePrivate(page);
1660 WARN_ON(!page->mapping->a_ops->invalidatepage);
1661 set_page_private(page, EXTENT_PAGE_PRIVATE);
1662 page_cache_get(page);
1663 }
1664}
1665
1666void set_page_extent_head(struct page *page, unsigned long len)
1667{
1668 WARN_ON(page->private && page->private == EXTENT_PAGE_PRIVATE &&
1669 PageDirty(page));
1670 set_page_private(page, EXTENT_PAGE_PRIVATE_FIRST_PAGE | len << 2);
1671}
1672
1666/*
1667 * basic readpage implementation. Locked extent state structs are inserted
1668 * into the tree that are removed when the IO is done (by the end_io
1669 * handlers)
1670 */
1671static int __extent_read_full_page(struct extent_map_tree *tree,
1672 struct page *page,
1673 get_extent_t *get_extent,

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

2485 if (page0) {
2486 eb->first_page = page0;
2487 i = 1;
2488 index++;
2489 page_cache_get(page0);
2490 mark_page_accessed(page0);
2491 set_page_extent_mapped(page0);
2492 WARN_ON(!PageUptodate(page0));
1673/*
1674 * basic readpage implementation. Locked extent state structs are inserted
1675 * into the tree that are removed when the IO is done (by the end_io
1676 * handlers)
1677 */
1678static int __extent_read_full_page(struct extent_map_tree *tree,
1679 struct page *page,
1680 get_extent_t *get_extent,

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

2492 if (page0) {
2493 eb->first_page = page0;
2494 i = 1;
2495 index++;
2496 page_cache_get(page0);
2497 mark_page_accessed(page0);
2498 set_page_extent_mapped(page0);
2499 WARN_ON(!PageUptodate(page0));
2493 set_page_private(page0, EXTENT_PAGE_PRIVATE_FIRST_PAGE |
2494 len << 2);
2500 set_page_extent_head(page0, len);
2495 } else {
2496 i = 0;
2497 }
2498 for (; i < num_pages; i++, index++) {
2499 p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
2500 if (!p) {
2501 WARN_ON(1);
2502 goto fail;
2503 }
2504 set_page_extent_mapped(p);
2505 mark_page_accessed(p);
2506 if (i == 0) {
2507 eb->first_page = p;
2501 } else {
2502 i = 0;
2503 }
2504 for (; i < num_pages; i++, index++) {
2505 p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
2506 if (!p) {
2507 WARN_ON(1);
2508 goto fail;
2509 }
2510 set_page_extent_mapped(p);
2511 mark_page_accessed(p);
2512 if (i == 0) {
2513 eb->first_page = p;
2508 set_page_private(p, EXTENT_PAGE_PRIVATE_FIRST_PAGE |
2509 len << 2);
2514 set_page_extent_head(p, len);
2510 } else {
2511 set_page_private(p, EXTENT_PAGE_PRIVATE);
2512 }
2513 if (!PageUptodate(p))
2514 uptodate = 0;
2515 unlock_page(p);
2516 }
2517 if (uptodate)

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

2564 if (!p) {
2565 goto fail;
2566 }
2567 set_page_extent_mapped(p);
2568 mark_page_accessed(p);
2569
2570 if (i == 0) {
2571 eb->first_page = p;
2515 } else {
2516 set_page_private(p, EXTENT_PAGE_PRIVATE);
2517 }
2518 if (!PageUptodate(p))
2519 uptodate = 0;
2520 unlock_page(p);
2521 }
2522 if (uptodate)

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

2569 if (!p) {
2570 goto fail;
2571 }
2572 set_page_extent_mapped(p);
2573 mark_page_accessed(p);
2574
2575 if (i == 0) {
2576 eb->first_page = p;
2572 set_page_private(p, EXTENT_PAGE_PRIVATE_FIRST_PAGE |
2573 len << 2);
2577 set_page_extent_head(p, len);
2574 } else {
2575 set_page_private(p, EXTENT_PAGE_PRIVATE);
2576 }
2577
2578 if (!PageUptodate(p))
2579 uptodate = 0;
2580 unlock_page(p);
2581 }

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

2638 u64 end = start + eb->len - 1;
2639
2640 set = clear_extent_dirty(tree, start, end, GFP_NOFS);
2641 num_pages = num_extent_pages(eb->start, eb->len);
2642
2643 for (i = 0; i < num_pages; i++) {
2644 page = extent_buffer_page(eb, i);
2645 lock_page(page);
2578 } else {
2579 set_page_private(p, EXTENT_PAGE_PRIVATE);
2580 }
2581
2582 if (!PageUptodate(p))
2583 uptodate = 0;
2584 unlock_page(p);
2585 }

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

2642 u64 end = start + eb->len - 1;
2643
2644 set = clear_extent_dirty(tree, start, end, GFP_NOFS);
2645 num_pages = num_extent_pages(eb->start, eb->len);
2646
2647 for (i = 0; i < num_pages; i++) {
2648 page = extent_buffer_page(eb, i);
2649 lock_page(page);
2650 if (i == 0)
2651 set_page_extent_head(page, eb->len);
2652 else
2653 set_page_private(page, EXTENT_PAGE_PRIVATE);
2654
2646 /*
2647 * if we're on the last page or the first page and the
2648 * block isn't aligned on a page boundary, do extra checks
2649 * to make sure we don't clean page that is partially dirty
2650 */
2651 if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
2652 ((i == num_pages - 1) &&
2653 ((eb->start + eb->len) & (PAGE_CACHE_SIZE - 1)))) {

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

2692 struct page *page = extent_buffer_page(eb, i);
2693 /* writepage may need to do something special for the
2694 * first page, we have to make sure page->private is
2695 * properly set. releasepage may drop page->private
2696 * on us if the page isn't already dirty.
2697 */
2698 if (i == 0) {
2699 lock_page(page);
2655 /*
2656 * if we're on the last page or the first page and the
2657 * block isn't aligned on a page boundary, do extra checks
2658 * to make sure we don't clean page that is partially dirty
2659 */
2660 if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
2661 ((i == num_pages - 1) &&
2662 ((eb->start + eb->len) & (PAGE_CACHE_SIZE - 1)))) {

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

2701 struct page *page = extent_buffer_page(eb, i);
2702 /* writepage may need to do something special for the
2703 * first page, we have to make sure page->private is
2704 * properly set. releasepage may drop page->private
2705 * on us if the page isn't already dirty.
2706 */
2707 if (i == 0) {
2708 lock_page(page);
2700 set_page_private(page,
2701 EXTENT_PAGE_PRIVATE_FIRST_PAGE |
2702 eb->len << 2);
2709 set_page_extent_head(page, eb->len);
2710 } else if (PagePrivate(page) &&
2711 page->private != EXTENT_PAGE_PRIVATE) {
2712 lock_page(page);
2713 set_page_extent_mapped(page);
2714 unlock_page(page);
2703 }
2704 __set_page_dirty_nobuffers(extent_buffer_page(eb, i));
2705 if (i == 0)
2706 unlock_page(page);
2707 }
2708 return set_extent_dirty(tree, eb->start,
2709 eb->start + eb->len - 1, GFP_NOFS);
2710}

--- 483 unchanged lines hidden --- 		2715 }
2716 __set_page_dirty_nobuffers(extent_buffer_page(eb, i));
2717 if (i == 0)
2718 unlock_page(page);
2719 }
2720 return set_extent_dirty(tree, eb->start,
2721 eb->start + eb->len - 1, GFP_NOFS);
2722}

--- 483 unchanged lines hidden ---