tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'kmap-conversion-for-5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

Pull kmap conversion updates from David Sterba:
"This contains changes regarding kmap API use and eg conversion from
kmap_atomic to kmap_local_page.

The API belongs to memory management but to save cross-tree
dependency headaches we've agreed to take it through the btrfs tree
because there are some trivial conversions possible, while the rest
will need some time and getting the easy cases out of the way would be
convenient.

The changes can be grouped:

- function exports, new helpers

- new VM_BUG_ON for additional verification; it's been discussed if
it should be VM_BUG_ON or BUG_ON, the former was chosen due to
performance reasons

- code replaced by relevant helpers"

[ This is an updated version of a request that originally came in during
the merge window, but I asked for some updates:

https://lore.kernel.org/lkml/cover.1614090658.git.dsterba@suse.com/

which is why this got merge after the merge window closed. - Linus ]

* 'kmap-conversion-for-5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
btrfs: use copy_highpage() instead of 2 kmaps()
btrfs: use memcpy_[to|from]_page() and kmap_local_page()
mm/highmem: Add VM_BUG_ON() to mem*_page() calls
mm/highmem: Introduce memcpy_page(), memmove_page(), and memset_page()
mm/highmem: Convert memcpy_[to|from]_page() to kmap_local_page()
mm/highmem: Lift memcpy_[to|from]_page to core

Linus Torvalds 7a7fd0de c608aca5

+68 -46
+2 -4
fs/btrfs/compression.c
··· 1261 1261 unsigned long prev_start_byte; 1262 1262 unsigned long working_bytes = total_out - buf_start; 1263 1263 unsigned long bytes; 1264 - char *kaddr; 1265 1264 struct bio_vec bvec = bio_iter_iovec(bio, bio->bi_iter); 1266 1265 1267 1266 /* ··· 1291 1292 PAGE_SIZE - (buf_offset % PAGE_SIZE)); 1292 1293 bytes = min(bytes, working_bytes); 1293 1294 1294 - kaddr = kmap_atomic(bvec.bv_page); 1295 - memcpy(kaddr + bvec.bv_offset, buf + buf_offset, bytes); 1296 - kunmap_atomic(kaddr); 1295 + memcpy_to_page(bvec.bv_page, bvec.bv_offset, buf + buf_offset, 1296 + bytes); 1297 1297 flush_dcache_page(bvec.bv_page); 1298 1298 1299 1299 buf_offset += bytes;
+2 -2
fs/btrfs/lzo.c
··· 467 467 destlen = min_t(unsigned long, destlen, PAGE_SIZE); 468 468 bytes = min_t(unsigned long, destlen, out_len - start_byte); 469 469 470 - kaddr = kmap_atomic(dest_page); 470 + kaddr = kmap_local_page(dest_page); 471 471 memcpy(kaddr, workspace->buf + start_byte, bytes); 472 472 473 473 /* ··· 477 477 */ 478 478 if (bytes < destlen) 479 479 memset(kaddr+bytes, 0, destlen-bytes); 480 - kunmap_atomic(kaddr); 480 + kunmap_local(kaddr); 481 481 out: 482 482 return ret; 483 483 }
+1 -9
fs/btrfs/raid56.c
··· 249 249 static void cache_rbio_pages(struct btrfs_raid_bio *rbio) 250 250 { 251 251 int i; 252 - char *s; 253 - char *d; 254 252 int ret; 255 253 256 254 ret = alloc_rbio_pages(rbio); ··· 259 261 if (!rbio->bio_pages[i]) 260 262 continue; 261 263 262 - s = kmap(rbio->bio_pages[i]); 263 - d = kmap(rbio->stripe_pages[i]); 264 - 265 - copy_page(d, s); 266 - 267 - kunmap(rbio->bio_pages[i]); 268 - kunmap(rbio->stripe_pages[i]); 264 + copy_highpage(rbio->stripe_pages[i], rbio->bio_pages[i]); 269 265 SetPageUptodate(rbio->stripe_pages[i]); 270 266 } 271 267 set_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
+1 -5
fs/btrfs/reflink.c
··· 106 106 set_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &inode->runtime_flags); 107 107 108 108 if (comp_type == BTRFS_COMPRESS_NONE) { 109 - char *map; 110 - 111 - map = kmap(page); 112 - memcpy(map, data_start, datal); 109 + memcpy_to_page(page, 0, data_start, datal); 113 110 flush_dcache_page(page); 114 - kunmap(page); 115 111 } else { 116 112 ret = btrfs_decompress(comp_type, data_start, page, 0, 117 113 inline_size, datal);
+2 -5
fs/btrfs/send.c
··· 4932 4932 struct btrfs_fs_info *fs_info = root->fs_info; 4933 4933 struct inode *inode; 4934 4934 struct page *page; 4935 - char *addr; 4936 4935 pgoff_t index = offset >> PAGE_SHIFT; 4937 4936 pgoff_t last_index; 4938 4937 unsigned pg_offset = offset_in_page(offset); ··· 4984 4985 } 4985 4986 } 4986 4987 4987 - addr = kmap(page); 4988 - memcpy(sctx->send_buf + sctx->send_size, addr + pg_offset, 4989 - cur_len); 4990 - kunmap(page); 4988 + memcpy_from_page(sctx->send_buf + sctx->send_size, page, 4989 + pg_offset, cur_len); 4991 4990 unlock_page(page); 4992 4991 put_page(page); 4993 4992 index++;
+2 -3
fs/btrfs/zlib.c
··· 432 432 PAGE_SIZE - (buf_offset % PAGE_SIZE)); 433 433 bytes = min(bytes, bytes_left); 434 434 435 - kaddr = kmap_atomic(dest_page); 436 - memcpy(kaddr + pg_offset, workspace->buf + buf_offset, bytes); 437 - kunmap_atomic(kaddr); 435 + memcpy_to_page(dest_page, pg_offset, 436 + workspace->buf + buf_offset, bytes); 438 437 439 438 pg_offset += bytes; 440 439 bytes_left -= bytes;
+2 -4
fs/btrfs/zstd.c
··· 688 688 bytes = min_t(unsigned long, destlen - pg_offset, 689 689 workspace->out_buf.size - buf_offset); 690 690 691 - kaddr = kmap_atomic(dest_page); 692 - memcpy(kaddr + pg_offset, workspace->out_buf.dst + buf_offset, 693 - bytes); 694 - kunmap_atomic(kaddr); 691 + memcpy_to_page(dest_page, pg_offset, 692 + workspace->out_buf.dst + buf_offset, bytes); 695 693 696 694 pg_offset += bytes; 697 695 }
+56
include/linux/highmem.h
··· 276 276 277 277 #endif 278 278 279 + static inline void memcpy_page(struct page *dst_page, size_t dst_off, 280 + struct page *src_page, size_t src_off, 281 + size_t len) 282 + { 283 + char *dst = kmap_local_page(dst_page); 284 + char *src = kmap_local_page(src_page); 285 + 286 + VM_BUG_ON(dst_off + len > PAGE_SIZE || src_off + len > PAGE_SIZE); 287 + memcpy(dst + dst_off, src + src_off, len); 288 + kunmap_local(src); 289 + kunmap_local(dst); 290 + } 291 + 292 + static inline void memmove_page(struct page *dst_page, size_t dst_off, 293 + struct page *src_page, size_t src_off, 294 + size_t len) 295 + { 296 + char *dst = kmap_local_page(dst_page); 297 + char *src = kmap_local_page(src_page); 298 + 299 + VM_BUG_ON(dst_off + len > PAGE_SIZE || src_off + len > PAGE_SIZE); 300 + memmove(dst + dst_off, src + src_off, len); 301 + kunmap_local(src); 302 + kunmap_local(dst); 303 + } 304 + 305 + static inline void memset_page(struct page *page, size_t offset, int val, 306 + size_t len) 307 + { 308 + char *addr = kmap_local_page(page); 309 + 310 + VM_BUG_ON(offset + len > PAGE_SIZE); 311 + memset(addr + offset, val, len); 312 + kunmap_local(addr); 313 + } 314 + 315 + static inline void memcpy_from_page(char *to, struct page *page, 316 + size_t offset, size_t len) 317 + { 318 + char *from = kmap_local_page(page); 319 + 320 + VM_BUG_ON(offset + len > PAGE_SIZE); 321 + memcpy(to, from + offset, len); 322 + kunmap_local(from); 323 + } 324 + 325 + static inline void memcpy_to_page(struct page *page, size_t offset, 326 + const char *from, size_t len) 327 + { 328 + char *to = kmap_local_page(page); 329 + 330 + VM_BUG_ON(offset + len > PAGE_SIZE); 331 + memcpy(to + offset, from, len); 332 + kunmap_local(to); 333 + } 334 + 279 335 #endif /* _LINUX_HIGHMEM_H */
-14
lib/iov_iter.c
··· 464 464 } 465 465 EXPORT_SYMBOL(iov_iter_init); 466 466 467 - static void memcpy_from_page(char *to, struct page *page, size_t offset, size_t len) 468 - { 469 - char *from = kmap_atomic(page); 470 - memcpy(to, from + offset, len); 471 - kunmap_atomic(from); 472 - } 473 - 474 - static void memcpy_to_page(struct page *page, size_t offset, const char *from, size_t len) 475 - { 476 - char *to = kmap_atomic(page); 477 - memcpy(to + offset, from, len); 478 - kunmap_atomic(to); 479 - } 480 - 481 467 static void memzero_page(struct page *page, size_t offset, size_t len) 482 468 { 483 469 char *addr = kmap_atomic(page);