extent_io.c (2d8ad8719591fa803b0d589ed057fa46f49b7155) extent_io.c (721a9602e6607417c6bc15b18e97a2f35266c690)
1#include <linux/bitops.h>
2#include <linux/slab.h>
3#include <linux/bio.h>
4#include <linux/mm.h>
5#include <linux/pagemap.h>
6#include <linux/page-flags.h>
7#include <linux/module.h>
8#include <linux/spinlock.h>

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

1860
1861 start = ((u64)page->index << PAGE_CACHE_SHIFT) + bvec->bv_offset;
1862
1863 bio->bi_private = NULL;
1864
1865 bio_get(bio);
1866
1867 if (tree->ops && tree->ops->submit_bio_hook)
1#include <linux/bitops.h>
2#include <linux/slab.h>
3#include <linux/bio.h>
4#include <linux/mm.h>
5#include <linux/pagemap.h>
6#include <linux/page-flags.h>
7#include <linux/module.h>
8#include <linux/spinlock.h>

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

1860
1861 start = ((u64)page->index << PAGE_CACHE_SHIFT) + bvec->bv_offset;
1862
1863 bio->bi_private = NULL;
1864
1865 bio_get(bio);
1866
1867 if (tree->ops && tree->ops->submit_bio_hook)
1868 tree->ops->submit_bio_hook(page->mapping->host, rw, bio,
1868 ret = tree->ops->submit_bio_hook(page->mapping->host, rw, bio,
1869 mirror_num, bio_flags, start);
1870 else
1871 submit_bio(rw, bio);
1872 if (bio_flagged(bio, BIO_EOPNOTSUPP))
1873 ret = -EOPNOTSUPP;
1874 bio_put(bio);
1875 return ret;
1876}

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

1915 }
1916 }
1917 if (this_compressed)
1918 nr = BIO_MAX_PAGES;
1919 else
1920 nr = bio_get_nr_vecs(bdev);
1921
1922 bio = btrfs_bio_alloc(bdev, sector, nr, GFP_NOFS | __GFP_HIGH);
1869 mirror_num, bio_flags, start);
1870 else
1871 submit_bio(rw, bio);
1872 if (bio_flagged(bio, BIO_EOPNOTSUPP))
1873 ret = -EOPNOTSUPP;
1874 bio_put(bio);
1875 return ret;
1876}

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

1915 }
1916 }
1917 if (this_compressed)
1918 nr = BIO_MAX_PAGES;
1919 else
1920 nr = bio_get_nr_vecs(bdev);
1921
1922 bio = btrfs_bio_alloc(bdev, sector, nr, GFP_NOFS | __GFP_HIGH);
1923 if (!bio)
1924 return -ENOMEM;
1923
1924 bio_add_page(bio, page, page_size, offset);
1925 bio->bi_end_io = end_io_func;
1926 bio->bi_private = tree;
1927
1928 if (bio_ret)
1929 *bio_ret = bio;
1930 else

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

1939 SetPagePrivate(page);
1940 page_cache_get(page);
1941 set_page_private(page, EXTENT_PAGE_PRIVATE);
1942 }
1943}
1944
1945static void set_page_extent_head(struct page *page, unsigned long len)
1946{
1925
1926 bio_add_page(bio, page, page_size, offset);
1927 bio->bi_end_io = end_io_func;
1928 bio->bi_private = tree;
1929
1930 if (bio_ret)
1931 *bio_ret = bio;
1932 else

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

1941 SetPagePrivate(page);
1942 page_cache_get(page);
1943 set_page_private(page, EXTENT_PAGE_PRIVATE);
1944 }
1945}
1946
1947static void set_page_extent_head(struct page *page, unsigned long len)
1948{
1949 WARN_ON(!PagePrivate(page));
1947 set_page_private(page, EXTENT_PAGE_PRIVATE_FIRST_PAGE | len << 2);
1948}
1949
1950/*
1951 * basic readpage implementation. Locked extent state structs are inserted
1952 * into the tree that are removed when the IO is done (by the end_io
1953 * handlers)
1954 */

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

2121{
2122 struct bio *bio = NULL;
2123 unsigned long bio_flags = 0;
2124 int ret;
2125
2126 ret = __extent_read_full_page(tree, page, get_extent, &bio, 0,
2127 &bio_flags);
2128 if (bio)
1950 set_page_private(page, EXTENT_PAGE_PRIVATE_FIRST_PAGE | len << 2);
1951}
1952
1953/*
1954 * basic readpage implementation. Locked extent state structs are inserted
1955 * into the tree that are removed when the IO is done (by the end_io
1956 * handlers)
1957 */

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

2124{
2125 struct bio *bio = NULL;
2126 unsigned long bio_flags = 0;
2127 int ret;
2128
2129 ret = __extent_read_full_page(tree, page, get_extent, &bio, 0,
2130 &bio_flags);
2131 if (bio)
2129 submit_one_bio(READ, bio, 0, bio_flags);
2132 ret = submit_one_bio(READ, bio, 0, bio_flags);
2130 return ret;
2131}
2132
2133static noinline void update_nr_written(struct page *page,
2134 struct writeback_control *wbc,
2135 unsigned long nr_written)
2136{
2137 wbc->nr_to_write -= nr_written;

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

2174 u64 nr_delalloc;
2175 u64 delalloc_end;
2176 int page_started;
2177 int compressed;
2178 int write_flags;
2179 unsigned long nr_written = 0;
2180
2181 if (wbc->sync_mode == WB_SYNC_ALL)
2133 return ret;
2134}
2135
2136static noinline void update_nr_written(struct page *page,
2137 struct writeback_control *wbc,
2138 unsigned long nr_written)
2139{
2140 wbc->nr_to_write -= nr_written;

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

2177 u64 nr_delalloc;
2178 u64 delalloc_end;
2179 int page_started;
2180 int compressed;
2181 int write_flags;
2182 unsigned long nr_written = 0;
2183
2184 if (wbc->sync_mode == WB_SYNC_ALL)
2182 write_flags = WRITE_SYNC_PLUG;
2185 write_flags = WRITE_SYNC;
2183 else
2184 write_flags = WRITE;
2185
2186 WARN_ON(!PageLocked(page));
2187 pg_offset = i_size & (PAGE_CACHE_SIZE - 1);
2188 if (page->index > end_index ||
2189 (page->index == end_index && !pg_offset)) {
2190 page->mapping->a_ops->invalidatepage(page, 0);

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

2814 ret = 0;
2815 else {
2816 if ((mask & GFP_NOFS) == GFP_NOFS)
2817 mask = GFP_NOFS;
2818 /*
2819 * at this point we can safely clear everything except the
2820 * locked bit and the nodatasum bit
2821 */
2186 else
2187 write_flags = WRITE;
2188
2189 WARN_ON(!PageLocked(page));
2190 pg_offset = i_size & (PAGE_CACHE_SIZE - 1);
2191 if (page->index > end_index ||
2192 (page->index == end_index && !pg_offset)) {
2193 page->mapping->a_ops->invalidatepage(page, 0);

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

2817 ret = 0;
2818 else {
2819 if ((mask & GFP_NOFS) == GFP_NOFS)
2820 mask = GFP_NOFS;
2821 /*
2822 * at this point we can safely clear everything except the
2823 * locked bit and the nodatasum bit
2824 */
2822 clear_extent_bit(tree, start, end,
2825 ret = clear_extent_bit(tree, start, end,
2823 ~(EXTENT_LOCKED | EXTENT_NODATASUM),
2824 0, 0, NULL, mask);
2826 ~(EXTENT_LOCKED | EXTENT_NODATASUM),
2827 0, 0, NULL, mask);
2828
2829 /* if clear_extent_bit failed for enomem reasons,
2830 * we can't allow the release to continue.
2831 */
2832 if (ret < 0)
2833 ret = 0;
2834 else
2835 ret = 1;
2825 }
2826 return ret;
2827}
2828
2829/*
2830 * a helper for releasepage. As long as there are no locked extents
2831 * in the range corresponding to the page, both state records and extent
2832 * map records are removed

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

3187 if (i == 0) {
3188 eb->first_page = p;
3189 set_page_extent_head(p, len);
3190 } else {
3191 set_page_private(p, EXTENT_PAGE_PRIVATE);
3192 }
3193 if (!PageUptodate(p))
3194 uptodate = 0;
2836 }
2837 return ret;
2838}
2839
2840/*
2841 * a helper for releasepage. As long as there are no locked extents
2842 * in the range corresponding to the page, both state records and extent
2843 * map records are removed

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

3198 if (i == 0) {
3199 eb->first_page = p;
3200 set_page_extent_head(p, len);
3201 } else {
3202 set_page_private(p, EXTENT_PAGE_PRIVATE);
3203 }
3204 if (!PageUptodate(p))
3205 uptodate = 0;
3195 unlock_page(p);
3206
3207 /*
3208 * see below about how we avoid a nasty race with release page
3209 * and why we unlock later
3210 */
3211 if (i != 0)
3212 unlock_page(p);
3196 }
3197 if (uptodate)
3198 set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
3199
3200 ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
3201 if (ret)
3202 goto free_eb;
3203

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

3211 spin_unlock(&tree->buffer_lock);
3212 radix_tree_preload_end();
3213 goto free_eb;
3214 }
3215 /* add one reference for the tree */
3216 atomic_inc(&eb->refs);
3217 spin_unlock(&tree->buffer_lock);
3218 radix_tree_preload_end();
3213 }
3214 if (uptodate)
3215 set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
3216
3217 ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
3218 if (ret)
3219 goto free_eb;
3220

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

3228 spin_unlock(&tree->buffer_lock);
3229 radix_tree_preload_end();
3230 goto free_eb;
3231 }
3232 /* add one reference for the tree */
3233 atomic_inc(&eb->refs);
3234 spin_unlock(&tree->buffer_lock);
3235 radix_tree_preload_end();
3236
3237 /*
3238 * there is a race where release page may have
3239 * tried to find this extent buffer in the radix
3240 * but failed. It will tell the VM it is safe to
3241 * reclaim the, and it will clear the page private bit.
3242 * We must make sure to set the page private bit properly
3243 * after the extent buffer is in the radix tree so
3244 * it doesn't get lost
3245 */
3246 set_page_extent_mapped(eb->first_page);
3247 set_page_extent_head(eb->first_page, eb->len);
3248 if (!page0)
3249 unlock_page(eb->first_page);
3219 return eb;
3220
3221free_eb:
3250 return eb;
3251
3252free_eb:
3253 if (eb->first_page && !page0)
3254 unlock_page(eb->first_page);
3255
3222 if (!atomic_dec_and_test(&eb->refs))
3223 return exists;
3224 btrfs_release_extent_buffer(eb);
3225 return exists;
3226}
3227
3228struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
3229 u64 start, unsigned long len,

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

3264 num_pages = num_extent_pages(eb->start, eb->len);
3265
3266 for (i = 0; i < num_pages; i++) {
3267 page = extent_buffer_page(eb, i);
3268 if (!PageDirty(page))
3269 continue;
3270
3271 lock_page(page);
3256 if (!atomic_dec_and_test(&eb->refs))
3257 return exists;
3258 btrfs_release_extent_buffer(eb);
3259 return exists;
3260}
3261
3262struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
3263 u64 start, unsigned long len,

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

3298 num_pages = num_extent_pages(eb->start, eb->len);
3299
3300 for (i = 0; i < num_pages; i++) {
3301 page = extent_buffer_page(eb, i);
3302 if (!PageDirty(page))
3303 continue;
3304
3305 lock_page(page);
3306 WARN_ON(!PagePrivate(page));
3307
3308 set_page_extent_mapped(page);
3272 if (i == 0)
3273 set_page_extent_head(page, eb->len);
3309 if (i == 0)
3310 set_page_extent_head(page, eb->len);
3274 else
3275 set_page_private(page, EXTENT_PAGE_PRIVATE);
3276
3277 clear_page_dirty_for_io(page);
3278 spin_lock_irq(&page->mapping->tree_lock);
3279 if (!PageDirty(page)) {
3280 radix_tree_tag_clear(&page->mapping->page_tree,
3281 page_index(page),
3282 PAGECACHE_TAG_DIRTY);
3283 }

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

3457 if (all_uptodate) {
3458 if (start_i == 0)
3459 set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
3460 goto unlock_exit;
3461 }
3462
3463 for (i = start_i; i < num_pages; i++) {
3464 page = extent_buffer_page(eb, i);
3311
3312 clear_page_dirty_for_io(page);
3313 spin_lock_irq(&page->mapping->tree_lock);
3314 if (!PageDirty(page)) {
3315 radix_tree_tag_clear(&page->mapping->page_tree,
3316 page_index(page),
3317 PAGECACHE_TAG_DIRTY);
3318 }

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

3492 if (all_uptodate) {
3493 if (start_i == 0)
3494 set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
3495 goto unlock_exit;
3496 }
3497
3498 for (i = start_i; i < num_pages; i++) {
3499 page = extent_buffer_page(eb, i);
3500
3501 WARN_ON(!PagePrivate(page));
3502
3503 set_page_extent_mapped(page);
3504 if (i == 0)
3505 set_page_extent_head(page, eb->len);
3506
3465 if (inc_all_pages)
3466 page_cache_get(page);
3467 if (!PageUptodate(page)) {
3468 if (start_i == 0)
3469 inc_all_pages = 1;
3470 ClearPageError(page);
3471 err = __extent_read_full_page(tree, page,
3472 get_extent, &bio,

--- 444 unchanged lines hidden --- 		3507 if (inc_all_pages)
3508 page_cache_get(page);
3509 if (!PageUptodate(page)) {
3510 if (start_i == 0)
3511 inc_all_pages = 1;
3512 ClearPageError(page);
3513 err = __extent_read_full_page(tree, page,
3514 get_extent, &bio,

--- 444 unchanged lines hidden ---