extent_map.c (1a5bc167f6707542b79a55452075525620ed43f5) extent_map.c (db94535db75e67fab12ccbb7f5ee548e33fed891)
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>

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

1958 }
1959}
1960
1961static inline struct page *extent_buffer_page(struct extent_buffer *eb, int i)
1962{
1963 struct page *p;
1964 if (i == 0)
1965 return eb->first_page;
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>

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

1958 }
1959}
1960
1961static inline struct page *extent_buffer_page(struct extent_buffer *eb, int i)
1962{
1963 struct page *p;
1964 if (i == 0)
1965 return eb->first_page;
1966
1966 i += eb->start >> PAGE_CACHE_SHIFT;
1967 i += eb->start >> PAGE_CACHE_SHIFT;
1968 if (eb->last_page && eb->last_page->index == i)
1969 return eb->last_page;
1970
1967 p = find_get_page(eb->first_page->mapping, i);
1968 page_cache_release(p);
1971 p = find_get_page(eb->first_page->mapping, i);
1972 page_cache_release(p);
1973 eb->last_page = p;
1969 return p;
1970}
1971
1974 return p;
1975}
1976
1977static inline unsigned long num_extent_pages(u64 start, u64 len)
1978{
1979 return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
1980 (start >> PAGE_CACHE_SHIFT);
1981}
1972struct extent_buffer *alloc_extent_buffer(struct extent_map_tree *tree,
1973 u64 start, unsigned long len,
1974 gfp_t mask)
1975{
1982struct extent_buffer *alloc_extent_buffer(struct extent_map_tree *tree,
1983 u64 start, unsigned long len,
1984 gfp_t mask)
1985{
1976 unsigned long num_pages = ((start + len - 1) >> PAGE_CACHE_SHIFT) -
1977 (start >> PAGE_CACHE_SHIFT) + 1;
1986 unsigned long num_pages = num_extent_pages(start, len);
1978 unsigned long i;
1979 unsigned long index = start >> PAGE_CACHE_SHIFT;
1980 struct extent_buffer *eb;
1981 struct page *p;
1982 struct address_space *mapping = tree->mapping;
1983 int uptodate = 0;
1984
1985 eb = __alloc_extent_buffer(mask);
1986 if (!eb || IS_ERR(eb))
1987 return NULL;
1988
1987 unsigned long i;
1988 unsigned long index = start >> PAGE_CACHE_SHIFT;
1989 struct extent_buffer *eb;
1990 struct page *p;
1991 struct address_space *mapping = tree->mapping;
1992 int uptodate = 0;
1993
1994 eb = __alloc_extent_buffer(mask);
1995 if (!eb || IS_ERR(eb))
1996 return NULL;
1997
1989 eb->alloc_addr = __builtin_return_address(0);
1998 eb->alloc_addr = (unsigned long)__builtin_return_address(0);
1990 eb->start = start;
1991 eb->len = len;
1992 atomic_set(&eb->refs, 1);
1993
1994 for (i = 0; i < num_pages; i++, index++) {
1995 p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
1996 if (!p) {
1999 eb->start = start;
2000 eb->len = len;
2001 atomic_set(&eb->refs, 1);
2002
2003 for (i = 0; i < num_pages; i++, index++) {
2004 p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
2005 if (!p) {
2006 WARN_ON(1);
1997 /* make sure the free only frees the pages we've
1998 * grabbed a reference on
1999 */
2000 eb->len = i << PAGE_CACHE_SHIFT;
2001 eb->start &= ~((u64)PAGE_CACHE_SIZE - 1);
2002 goto fail;
2003 }
2004 set_page_extent_mapped(p);

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

2016 return NULL;
2017}
2018EXPORT_SYMBOL(alloc_extent_buffer);
2019
2020struct extent_buffer *find_extent_buffer(struct extent_map_tree *tree,
2021 u64 start, unsigned long len,
2022 gfp_t mask)
2023{
2007 /* make sure the free only frees the pages we've
2008 * grabbed a reference on
2009 */
2010 eb->len = i << PAGE_CACHE_SHIFT;
2011 eb->start &= ~((u64)PAGE_CACHE_SIZE - 1);
2012 goto fail;
2013 }
2014 set_page_extent_mapped(p);

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

2026 return NULL;
2027}
2028EXPORT_SYMBOL(alloc_extent_buffer);
2029
2030struct extent_buffer *find_extent_buffer(struct extent_map_tree *tree,
2031 u64 start, unsigned long len,
2032 gfp_t mask)
2033{
2024 unsigned long num_pages = ((start + len - 1) >> PAGE_CACHE_SHIFT) -
2025 (start >> PAGE_CACHE_SHIFT) + 1;
2034 unsigned long num_pages = num_extent_pages(start, len);
2026 unsigned long i;
2027 unsigned long index = start >> PAGE_CACHE_SHIFT;
2028 struct extent_buffer *eb;
2029 struct page *p;
2030 struct address_space *mapping = tree->mapping;
2031
2032 eb = __alloc_extent_buffer(mask);
2033 if (!eb || IS_ERR(eb))
2034 return NULL;
2035
2035 unsigned long i;
2036 unsigned long index = start >> PAGE_CACHE_SHIFT;
2037 struct extent_buffer *eb;
2038 struct page *p;
2039 struct address_space *mapping = tree->mapping;
2040
2041 eb = __alloc_extent_buffer(mask);
2042 if (!eb || IS_ERR(eb))
2043 return NULL;
2044
2036 eb->alloc_addr = __builtin_return_address(0);
2045 eb->alloc_addr = (unsigned long)__builtin_return_address(0);
2037 eb->start = start;
2038 eb->len = len;
2039 atomic_set(&eb->refs, 1);
2040
2041 for (i = 0; i < num_pages; i++, index++) {
2042 p = find_get_page(mapping, index);
2043 if (!p) {
2044 /* make sure the free only frees the pages we've

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

2065 unsigned long num_pages;
2066
2067 if (!eb)
2068 return;
2069
2070 if (!atomic_dec_and_test(&eb->refs))
2071 return;
2072
2046 eb->start = start;
2047 eb->len = len;
2048 atomic_set(&eb->refs, 1);
2049
2050 for (i = 0; i < num_pages; i++, index++) {
2051 p = find_get_page(mapping, index);
2052 if (!p) {
2053 /* make sure the free only frees the pages we've

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

2074 unsigned long num_pages;
2075
2076 if (!eb)
2077 return;
2078
2079 if (!atomic_dec_and_test(&eb->refs))
2080 return;
2081
2073 num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
2074 (eb->start >> PAGE_CACHE_SHIFT) + 1;
2082 num_pages = num_extent_pages(eb->start, eb->len);
2075
2076 if (eb->first_page)
2077 page_cache_release(eb->first_page);
2078 for (i = 1; i < num_pages; i++) {
2079 page_cache_release(extent_buffer_page(eb, i));
2080 }
2081 __free_extent_buffer(eb);
2082}

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

2089 unsigned long i;
2090 unsigned long num_pages;
2091 struct page *page;
2092
2093 u64 start = eb->start;
2094 u64 end = start + eb->len - 1;
2095
2096 set = clear_extent_dirty(tree, start, end, GFP_NOFS);
2083
2084 if (eb->first_page)
2085 page_cache_release(eb->first_page);
2086 for (i = 1; i < num_pages; i++) {
2087 page_cache_release(extent_buffer_page(eb, i));
2088 }
2089 __free_extent_buffer(eb);
2090}

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

2097 unsigned long i;
2098 unsigned long num_pages;
2099 struct page *page;
2100
2101 u64 start = eb->start;
2102 u64 end = start + eb->len - 1;
2103
2104 set = clear_extent_dirty(tree, start, end, GFP_NOFS);
2097 num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
2098 (eb->start >> PAGE_CACHE_SHIFT) + 1;
2105 num_pages = num_extent_pages(eb->start, eb->len);
2099
2100 for (i = 0; i < num_pages; i++) {
2101 page = extent_buffer_page(eb, i);
2102 lock_page(page);
2103 /*
2104 * if we're on the last page or the first page and the
2105 * block isn't aligned on a page boundary, do extra checks
2106 * to make sure we don't clean page that is partially dirty

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

2140
2141int set_extent_buffer_uptodate(struct extent_map_tree *tree,
2142 struct extent_buffer *eb)
2143{
2144 unsigned long i;
2145 struct page *page;
2146 unsigned long num_pages;
2147
2106
2107 for (i = 0; i < num_pages; i++) {
2108 page = extent_buffer_page(eb, i);
2109 lock_page(page);
2110 /*
2111 * if we're on the last page or the first page and the
2112 * block isn't aligned on a page boundary, do extra checks
2113 * to make sure we don't clean page that is partially dirty

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

2147
2148int set_extent_buffer_uptodate(struct extent_map_tree *tree,
2149 struct extent_buffer *eb)
2150{
2151 unsigned long i;
2152 struct page *page;
2153 unsigned long num_pages;
2154
2148 num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
2149 (eb->start >> PAGE_CACHE_SHIFT) + 1;
2155 num_pages = num_extent_pages(eb->start, eb->len);
2150
2151 set_extent_uptodate(tree, eb->start, eb->start + eb->len - 1,
2152 GFP_NOFS);
2153 for (i = 0; i < num_pages; i++) {
2154 page = extent_buffer_page(eb, i);
2155 if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
2156 ((i == num_pages - 1) &&
2157 ((eb->start + eb->len - 1) & (PAGE_CACHE_SIZE - 1)))) {

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

2186 if (eb->flags & EXTENT_UPTODATE)
2187 return 0;
2188
2189 if (test_range_bit(tree, eb->start, eb->start + eb->len - 1,
2190 EXTENT_UPTODATE, 1)) {
2191 return 0;
2192 }
2193
2156
2157 set_extent_uptodate(tree, eb->start, eb->start + eb->len - 1,
2158 GFP_NOFS);
2159 for (i = 0; i < num_pages; i++) {
2160 page = extent_buffer_page(eb, i);
2161 if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
2162 ((i == num_pages - 1) &&
2163 ((eb->start + eb->len - 1) & (PAGE_CACHE_SIZE - 1)))) {

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

2192 if (eb->flags & EXTENT_UPTODATE)
2193 return 0;
2194
2195 if (test_range_bit(tree, eb->start, eb->start + eb->len - 1,
2196 EXTENT_UPTODATE, 1)) {
2197 return 0;
2198 }
2199
2194 num_pages = ((eb->start + eb->len - 1) >> PAGE_CACHE_SHIFT) -
2195 (eb->start >> PAGE_CACHE_SHIFT) + 1;
2200 num_pages = num_extent_pages(eb->start, eb->len);
2196 for (i = 0; i < num_pages; i++) {
2197 page = extent_buffer_page(eb, i);
2198 if (PageUptodate(page)) {
2199 continue;
2200 }
2201 if (!wait) {
2202 if (TestSetPageLocked(page)) {
2203 continue;

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

2262 dst += cur;
2263 len -= cur;
2264 offset = 0;
2265 i++;
2266 }
2267}
2268EXPORT_SYMBOL(read_extent_buffer);
2269
2201 for (i = 0; i < num_pages; i++) {
2202 page = extent_buffer_page(eb, i);
2203 if (PageUptodate(page)) {
2204 continue;
2205 }
2206 if (!wait) {
2207 if (TestSetPageLocked(page)) {
2208 continue;

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

2267 dst += cur;
2268 len -= cur;
2269 offset = 0;
2270 i++;
2271 }
2272}
2273EXPORT_SYMBOL(read_extent_buffer);
2274
2270int map_extent_buffer(struct extent_buffer *eb, unsigned long start,
2271 unsigned long min_len,
2272 char **token, char **map,
2273 unsigned long *map_start,
2274 unsigned long *map_len, int km)
2275static int __map_extent_buffer(struct extent_buffer *eb, unsigned long start,
2276 unsigned long min_len, char **token, char **map,
2277 unsigned long *map_start,
2278 unsigned long *map_len, int km)
2275{
2276 size_t offset = start & (PAGE_CACHE_SIZE - 1);
2277 char *kaddr;
2279{
2280 size_t offset = start & (PAGE_CACHE_SIZE - 1);
2281 char *kaddr;
2282 struct page *p;
2278 size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
2279 unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
2280 unsigned long end_i = (start_offset + start + min_len) >>
2281 PAGE_CACHE_SHIFT;
2282
2283 if (i != end_i)
2284 return -EINVAL;
2285
2283 size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
2284 unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
2285 unsigned long end_i = (start_offset + start + min_len) >>
2286 PAGE_CACHE_SHIFT;
2287
2288 if (i != end_i)
2289 return -EINVAL;
2290
2286 WARN_ON(start > eb->len);
2291 if (start >= eb->len) {
2292 printk("bad start in map eb start %Lu len %lu caller start %lu min %lu\n", eb->start, eb->len, start, min_len);
2293 WARN_ON(1);
2294 }
2287
2288 if (i == 0) {
2289 offset = start_offset;
2290 *map_start = 0;
2291 } else {
2295
2296 if (i == 0) {
2297 offset = start_offset;
2298 *map_start = 0;
2299 } else {
2300 offset = 0;
2292 *map_start = (i << PAGE_CACHE_SHIFT) - start_offset;
2293 }
2294
2301 *map_start = (i << PAGE_CACHE_SHIFT) - start_offset;
2302 }
2303
2295 kaddr = kmap_atomic(extent_buffer_page(eb, i), km);
2304 p = extent_buffer_page(eb, i);
2305 WARN_ON(!PageUptodate(p));
2306 kaddr = kmap_atomic(p, km);
2296 *token = kaddr;
2297 *map = kaddr + offset;
2298 *map_len = PAGE_CACHE_SIZE - offset;
2299 return 0;
2300}
2307 *token = kaddr;
2308 *map = kaddr + offset;
2309 *map_len = PAGE_CACHE_SIZE - offset;
2310 return 0;
2311}
2312
2313int map_extent_buffer(struct extent_buffer *eb, unsigned long start,
2314 unsigned long min_len,
2315 char **token, char **map,
2316 unsigned long *map_start,
2317 unsigned long *map_len, int km)
2318{
2319 int err;
2320 int save = 0;
2321 if (eb->map_token) {
2322 if (start >= eb->map_start &&
2323 start + min_len <= eb->map_start + eb->map_len) {
2324 *token = eb->map_token;
2325 *map = eb->kaddr;
2326 *map_start = eb->map_start;
2327 *map_len = eb->map_len;
2328 return 0;
2329 }
2330 unmap_extent_buffer(eb, eb->map_token, km);
2331 eb->map_token = NULL;
2332 save = 1;
2333 }
2334 err = __map_extent_buffer(eb, start, min_len, token, map,
2335 map_start, map_len, km);
2336 if (!err && save) {
2337 eb->map_token = *token;
2338 eb->kaddr = *map;
2339 eb->map_start = *map_start;
2340 eb->map_len = *map_len;
2341 }
2342 return err;
2343}
2301EXPORT_SYMBOL(map_extent_buffer);
2302
2303void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km)
2304{
2305 kunmap_atomic(token, km);
2306}
2307EXPORT_SYMBOL(unmap_extent_buffer);
2308

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

2569 while(len > 0) {
2570 dst_i = (start_offset + dst_end) >> PAGE_CACHE_SHIFT;
2571 src_i = (start_offset + src_end) >> PAGE_CACHE_SHIFT;
2572
2573 dst_off_in_page = dst_end &
2574 ((unsigned long)PAGE_CACHE_SIZE - 1);
2575 src_off_in_page = src_end &
2576 ((unsigned long)PAGE_CACHE_SIZE - 1);
2344EXPORT_SYMBOL(map_extent_buffer);
2345
2346void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km)
2347{
2348 kunmap_atomic(token, km);
2349}
2350EXPORT_SYMBOL(unmap_extent_buffer);
2351

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

2612 while(len > 0) {
2613 dst_i = (start_offset + dst_end) >> PAGE_CACHE_SHIFT;
2614 src_i = (start_offset + src_end) >> PAGE_CACHE_SHIFT;
2615
2616 dst_off_in_page = dst_end &
2617 ((unsigned long)PAGE_CACHE_SIZE - 1);
2618 src_off_in_page = src_end &
2619 ((unsigned long)PAGE_CACHE_SIZE - 1);
2577
2578 if (src_i == 0)
2579 src_off_in_page += start_offset;
2580 if (dst_i == 0)
2581 dst_off_in_page += start_offset;
2582
2583 cur = min(len, src_off_in_page + 1);
2584 cur = min(cur, dst_off_in_page + 1);
2620 if (src_i == 0)
2621 src_off_in_page += start_offset;
2622 if (dst_i == 0)
2623 dst_off_in_page += start_offset;
2624
2625 cur = min(len, src_off_in_page + 1);
2626 cur = min(cur, dst_off_in_page + 1);
2585
2586 move_pages(extent_buffer_page(dst, dst_i),
2587 extent_buffer_page(dst, src_i),
2588 dst_off_in_page - cur + 1,
2589 src_off_in_page - cur + 1, cur);
2590
2627 move_pages(extent_buffer_page(dst, dst_i),
2628 extent_buffer_page(dst, src_i),
2629 dst_off_in_page - cur + 1,
2630 src_off_in_page - cur + 1, cur);
2631
2591 dst_end -= cur - 1;
2592 src_end -= cur - 1;
2632 dst_end -= cur;
2633 src_end -= cur;
2593 len -= cur;
2594 }
2595}
2596EXPORT_SYMBOL(memmove_extent_buffer);
2634 len -= cur;
2635 }
2636}
2637EXPORT_SYMBOL(memmove_extent_buffer);