1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/mm/page_io.c 4 * 5 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds 6 * 7 * Swap reorganised 29.12.95, 8 * Asynchronous swapping added 30.12.95. Stephen Tweedie 9 * Removed race in async swapping. 14.4.1996. Bruno Haible 10 * Add swap of shared pages through the page cache. 20.2.1998. Stephen Tweedie 11 * Always use brw_page, life becomes simpler. 12 May 1998 Eric Biederman 12 */ 13 14 #include <linux/mm.h> 15 #include <linux/kernel_stat.h> 16 #include <linux/gfp.h> 17 #include <linux/pagemap.h> 18 #include <linux/swap.h> 19 #include <linux/bio.h> 20 #include <linux/swapops.h> 21 #include <linux/buffer_head.h> 22 #include <linux/writeback.h> 23 #include <linux/frontswap.h> 24 #include <linux/blkdev.h> 25 #include <linux/psi.h> 26 #include <linux/uio.h> 27 #include <linux/sched/task.h> 28 #include <linux/delayacct.h> 29 #include "swap.h" 30 31 static void end_swap_bio_write(struct bio *bio) 32 { 33 struct page *page = bio_first_page_all(bio); 34 35 if (bio->bi_status) { 36 SetPageError(page); 37 /* 38 * We failed to write the page out to swap-space. 39 * Re-dirty the page in order to avoid it being reclaimed. 40 * Also print a dire warning that things will go BAD (tm) 41 * very quickly. 42 * 43 * Also clear PG_reclaim to avoid folio_rotate_reclaimable() 44 */ 45 set_page_dirty(page); 46 pr_alert_ratelimited("Write-error on swap-device (%u:%u:%llu)\n", 47 MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)), 48 (unsigned long long)bio->bi_iter.bi_sector); 49 ClearPageReclaim(page); 50 } 51 end_page_writeback(page); 52 bio_put(bio); 53 } 54 55 static void end_swap_bio_read(struct bio *bio) 56 { 57 struct page *page = bio_first_page_all(bio); 58 struct task_struct *waiter = bio->bi_private; 59 60 if (bio->bi_status) { 61 SetPageError(page); 62 ClearPageUptodate(page); 63 pr_alert_ratelimited("Read-error on swap-device (%u:%u:%llu)\n", 64 MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)), 65 (unsigned long long)bio->bi_iter.bi_sector); 66 goto out; 67 } 68 69 SetPageUptodate(page); 70 out: 71 unlock_page(page); 72 WRITE_ONCE(bio->bi_private, NULL); 73 bio_put(bio); 74 if (waiter) { 75 blk_wake_io_task(waiter); 76 put_task_struct(waiter); 77 } 78 } 79 80 int generic_swapfile_activate(struct swap_info_struct *sis, 81 struct file *swap_file, 82 sector_t *span) 83 { 84 struct address_space *mapping = swap_file->f_mapping; 85 struct inode *inode = mapping->host; 86 unsigned blocks_per_page; 87 unsigned long page_no; 88 unsigned blkbits; 89 sector_t probe_block; 90 sector_t last_block; 91 sector_t lowest_block = -1; 92 sector_t highest_block = 0; 93 int nr_extents = 0; 94 int ret; 95 96 blkbits = inode->i_blkbits; 97 blocks_per_page = PAGE_SIZE >> blkbits; 98 99 /* 100 * Map all the blocks into the extent tree. This code doesn't try 101 * to be very smart. 102 */ 103 probe_block = 0; 104 page_no = 0; 105 last_block = i_size_read(inode) >> blkbits; 106 while ((probe_block + blocks_per_page) <= last_block && 107 page_no < sis->max) { 108 unsigned block_in_page; 109 sector_t first_block; 110 111 cond_resched(); 112 113 first_block = probe_block; 114 ret = bmap(inode, &first_block); 115 if (ret || !first_block) 116 goto bad_bmap; 117 118 /* 119 * It must be PAGE_SIZE aligned on-disk 120 */ 121 if (first_block & (blocks_per_page - 1)) { 122 probe_block++; 123 goto reprobe; 124 } 125 126 for (block_in_page = 1; block_in_page < blocks_per_page; 127 block_in_page++) { 128 sector_t block; 129 130 block = probe_block + block_in_page; 131 ret = bmap(inode, &block); 132 if (ret || !block) 133 goto bad_bmap; 134 135 if (block != first_block + block_in_page) { 136 /* Discontiguity */ 137 probe_block++; 138 goto reprobe; 139 } 140 } 141 142 first_block >>= (PAGE_SHIFT - blkbits); 143 if (page_no) { /* exclude the header page */ 144 if (first_block < lowest_block) 145 lowest_block = first_block; 146 if (first_block > highest_block) 147 highest_block = first_block; 148 } 149 150 /* 151 * We found a PAGE_SIZE-length, PAGE_SIZE-aligned run of blocks 152 */ 153 ret = add_swap_extent(sis, page_no, 1, first_block); 154 if (ret < 0) 155 goto out; 156 nr_extents += ret; 157 page_no++; 158 probe_block += blocks_per_page; 159 reprobe: 160 continue; 161 } 162 ret = nr_extents; 163 *span = 1 + highest_block - lowest_block; 164 if (page_no == 0) 165 page_no = 1; /* force Empty message */ 166 sis->max = page_no; 167 sis->pages = page_no - 1; 168 sis->highest_bit = page_no - 1; 169 out: 170 return ret; 171 bad_bmap: 172 pr_err("swapon: swapfile has holes\n"); 173 ret = -EINVAL; 174 goto out; 175 } 176 177 /* 178 * We may have stale swap cache pages in memory: notice 179 * them here and get rid of the unnecessary final write. 180 */ 181 int swap_writepage(struct page *page, struct writeback_control *wbc) 182 { 183 struct folio *folio = page_folio(page); 184 int ret = 0; 185 186 if (folio_free_swap(folio)) { 187 folio_unlock(folio); 188 goto out; 189 } 190 /* 191 * Arch code may have to preserve more data than just the page 192 * contents, e.g. memory tags. 193 */ 194 ret = arch_prepare_to_swap(&folio->page); 195 if (ret) { 196 folio_mark_dirty(folio); 197 folio_unlock(folio); 198 goto out; 199 } 200 if (frontswap_store(&folio->page) == 0) { 201 folio_start_writeback(folio); 202 folio_unlock(folio); 203 folio_end_writeback(folio); 204 goto out; 205 } 206 ret = __swap_writepage(&folio->page, wbc); 207 out: 208 return ret; 209 } 210 211 static inline void count_swpout_vm_event(struct page *page) 212 { 213 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 214 if (unlikely(PageTransHuge(page))) 215 count_vm_event(THP_SWPOUT); 216 #endif 217 count_vm_events(PSWPOUT, thp_nr_pages(page)); 218 } 219 220 #if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP) 221 static void bio_associate_blkg_from_page(struct bio *bio, struct page *page) 222 { 223 struct cgroup_subsys_state *css; 224 struct mem_cgroup *memcg; 225 226 memcg = page_memcg(page); 227 if (!memcg) 228 return; 229 230 rcu_read_lock(); 231 css = cgroup_e_css(memcg->css.cgroup, &io_cgrp_subsys); 232 bio_associate_blkg_from_css(bio, css); 233 rcu_read_unlock(); 234 } 235 #else 236 #define bio_associate_blkg_from_page(bio, page) do { } while (0) 237 #endif /* CONFIG_MEMCG && CONFIG_BLK_CGROUP */ 238 239 struct swap_iocb { 240 struct kiocb iocb; 241 struct bio_vec bvec[SWAP_CLUSTER_MAX]; 242 int pages; 243 int len; 244 }; 245 static mempool_t *sio_pool; 246 247 int sio_pool_init(void) 248 { 249 if (!sio_pool) { 250 mempool_t *pool = mempool_create_kmalloc_pool( 251 SWAP_CLUSTER_MAX, sizeof(struct swap_iocb)); 252 if (cmpxchg(&sio_pool, NULL, pool)) 253 mempool_destroy(pool); 254 } 255 if (!sio_pool) 256 return -ENOMEM; 257 return 0; 258 } 259 260 static void sio_write_complete(struct kiocb *iocb, long ret) 261 { 262 struct swap_iocb *sio = container_of(iocb, struct swap_iocb, iocb); 263 struct page *page = sio->bvec[0].bv_page; 264 int p; 265 266 if (ret != sio->len) { 267 /* 268 * In the case of swap-over-nfs, this can be a 269 * temporary failure if the system has limited 270 * memory for allocating transmit buffers. 271 * Mark the page dirty and avoid 272 * folio_rotate_reclaimable but rate-limit the 273 * messages but do not flag PageError like 274 * the normal direct-to-bio case as it could 275 * be temporary. 276 */ 277 pr_err_ratelimited("Write error %ld on dio swapfile (%llu)\n", 278 ret, page_file_offset(page)); 279 for (p = 0; p < sio->pages; p++) { 280 page = sio->bvec[p].bv_page; 281 set_page_dirty(page); 282 ClearPageReclaim(page); 283 } 284 } else { 285 for (p = 0; p < sio->pages; p++) 286 count_swpout_vm_event(sio->bvec[p].bv_page); 287 } 288 289 for (p = 0; p < sio->pages; p++) 290 end_page_writeback(sio->bvec[p].bv_page); 291 292 mempool_free(sio, sio_pool); 293 } 294 295 static int swap_writepage_fs(struct page *page, struct writeback_control *wbc) 296 { 297 struct swap_iocb *sio = NULL; 298 struct swap_info_struct *sis = page_swap_info(page); 299 struct file *swap_file = sis->swap_file; 300 loff_t pos = page_file_offset(page); 301 302 set_page_writeback(page); 303 unlock_page(page); 304 if (wbc->swap_plug) 305 sio = *wbc->swap_plug; 306 if (sio) { 307 if (sio->iocb.ki_filp != swap_file || 308 sio->iocb.ki_pos + sio->len != pos) { 309 swap_write_unplug(sio); 310 sio = NULL; 311 } 312 } 313 if (!sio) { 314 sio = mempool_alloc(sio_pool, GFP_NOIO); 315 init_sync_kiocb(&sio->iocb, swap_file); 316 sio->iocb.ki_complete = sio_write_complete; 317 sio->iocb.ki_pos = pos; 318 sio->pages = 0; 319 sio->len = 0; 320 } 321 bvec_set_page(&sio->bvec[sio->pages], page, thp_size(page), 0); 322 sio->len += thp_size(page); 323 sio->pages += 1; 324 if (sio->pages == ARRAY_SIZE(sio->bvec) || !wbc->swap_plug) { 325 swap_write_unplug(sio); 326 sio = NULL; 327 } 328 if (wbc->swap_plug) 329 *wbc->swap_plug = sio; 330 331 return 0; 332 } 333 334 int __swap_writepage(struct page *page, struct writeback_control *wbc) 335 { 336 struct bio *bio; 337 int ret; 338 struct swap_info_struct *sis = page_swap_info(page); 339 340 VM_BUG_ON_PAGE(!PageSwapCache(page), page); 341 /* 342 * ->flags can be updated non-atomicially (scan_swap_map_slots), 343 * but that will never affect SWP_FS_OPS, so the data_race 344 * is safe. 345 */ 346 if (data_race(sis->flags & SWP_FS_OPS)) 347 return swap_writepage_fs(page, wbc); 348 349 ret = bdev_write_page(sis->bdev, swap_page_sector(page), page, wbc); 350 if (!ret) { 351 count_swpout_vm_event(page); 352 return 0; 353 } 354 355 bio = bio_alloc(sis->bdev, 1, 356 REQ_OP_WRITE | REQ_SWAP | wbc_to_write_flags(wbc), 357 GFP_NOIO); 358 bio->bi_iter.bi_sector = swap_page_sector(page); 359 bio->bi_end_io = end_swap_bio_write; 360 bio_add_page(bio, page, thp_size(page), 0); 361 362 bio_associate_blkg_from_page(bio, page); 363 count_swpout_vm_event(page); 364 set_page_writeback(page); 365 unlock_page(page); 366 submit_bio(bio); 367 368 return 0; 369 } 370 371 void swap_write_unplug(struct swap_iocb *sio) 372 { 373 struct iov_iter from; 374 struct address_space *mapping = sio->iocb.ki_filp->f_mapping; 375 int ret; 376 377 iov_iter_bvec(&from, ITER_SOURCE, sio->bvec, sio->pages, sio->len); 378 ret = mapping->a_ops->swap_rw(&sio->iocb, &from); 379 if (ret != -EIOCBQUEUED) 380 sio_write_complete(&sio->iocb, ret); 381 } 382 383 static void sio_read_complete(struct kiocb *iocb, long ret) 384 { 385 struct swap_iocb *sio = container_of(iocb, struct swap_iocb, iocb); 386 int p; 387 388 if (ret == sio->len) { 389 for (p = 0; p < sio->pages; p++) { 390 struct page *page = sio->bvec[p].bv_page; 391 392 SetPageUptodate(page); 393 unlock_page(page); 394 } 395 count_vm_events(PSWPIN, sio->pages); 396 } else { 397 for (p = 0; p < sio->pages; p++) { 398 struct page *page = sio->bvec[p].bv_page; 399 400 SetPageError(page); 401 ClearPageUptodate(page); 402 unlock_page(page); 403 } 404 pr_alert_ratelimited("Read-error on swap-device\n"); 405 } 406 mempool_free(sio, sio_pool); 407 } 408 409 static void swap_readpage_fs(struct page *page, 410 struct swap_iocb **plug) 411 { 412 struct swap_info_struct *sis = page_swap_info(page); 413 struct swap_iocb *sio = NULL; 414 loff_t pos = page_file_offset(page); 415 416 if (plug) 417 sio = *plug; 418 if (sio) { 419 if (sio->iocb.ki_filp != sis->swap_file || 420 sio->iocb.ki_pos + sio->len != pos) { 421 swap_read_unplug(sio); 422 sio = NULL; 423 } 424 } 425 if (!sio) { 426 sio = mempool_alloc(sio_pool, GFP_KERNEL); 427 init_sync_kiocb(&sio->iocb, sis->swap_file); 428 sio->iocb.ki_pos = pos; 429 sio->iocb.ki_complete = sio_read_complete; 430 sio->pages = 0; 431 sio->len = 0; 432 } 433 bvec_set_page(&sio->bvec[sio->pages], page, thp_size(page), 0); 434 sio->len += thp_size(page); 435 sio->pages += 1; 436 if (sio->pages == ARRAY_SIZE(sio->bvec) || !plug) { 437 swap_read_unplug(sio); 438 sio = NULL; 439 } 440 if (plug) 441 *plug = sio; 442 } 443 444 int swap_readpage(struct page *page, bool synchronous, 445 struct swap_iocb **plug) 446 { 447 struct bio *bio; 448 int ret = 0; 449 struct swap_info_struct *sis = page_swap_info(page); 450 bool workingset = PageWorkingset(page); 451 unsigned long pflags; 452 bool in_thrashing; 453 454 VM_BUG_ON_PAGE(!PageSwapCache(page) && !synchronous, page); 455 VM_BUG_ON_PAGE(!PageLocked(page), page); 456 VM_BUG_ON_PAGE(PageUptodate(page), page); 457 458 /* 459 * Count submission time as memory stall and delay. When the device 460 * is congested, or the submitting cgroup IO-throttled, submission 461 * can be a significant part of overall IO time. 462 */ 463 if (workingset) { 464 delayacct_thrashing_start(&in_thrashing); 465 psi_memstall_enter(&pflags); 466 } 467 delayacct_swapin_start(); 468 469 if (frontswap_load(page) == 0) { 470 SetPageUptodate(page); 471 unlock_page(page); 472 goto out; 473 } 474 475 if (data_race(sis->flags & SWP_FS_OPS)) { 476 swap_readpage_fs(page, plug); 477 goto out; 478 } 479 480 if (sis->flags & SWP_SYNCHRONOUS_IO) { 481 ret = bdev_read_page(sis->bdev, swap_page_sector(page), page); 482 if (!ret) { 483 count_vm_event(PSWPIN); 484 goto out; 485 } 486 } 487 488 ret = 0; 489 bio = bio_alloc(sis->bdev, 1, REQ_OP_READ, GFP_KERNEL); 490 bio->bi_iter.bi_sector = swap_page_sector(page); 491 bio->bi_end_io = end_swap_bio_read; 492 bio_add_page(bio, page, thp_size(page), 0); 493 /* 494 * Keep this task valid during swap readpage because the oom killer may 495 * attempt to access it in the page fault retry time check. 496 */ 497 if (synchronous) { 498 get_task_struct(current); 499 bio->bi_private = current; 500 } 501 count_vm_event(PSWPIN); 502 bio_get(bio); 503 submit_bio(bio); 504 while (synchronous) { 505 set_current_state(TASK_UNINTERRUPTIBLE); 506 if (!READ_ONCE(bio->bi_private)) 507 break; 508 509 blk_io_schedule(); 510 } 511 __set_current_state(TASK_RUNNING); 512 bio_put(bio); 513 514 out: 515 if (workingset) { 516 delayacct_thrashing_end(&in_thrashing); 517 psi_memstall_leave(&pflags); 518 } 519 delayacct_swapin_end(); 520 return ret; 521 } 522 523 void __swap_read_unplug(struct swap_iocb *sio) 524 { 525 struct iov_iter from; 526 struct address_space *mapping = sio->iocb.ki_filp->f_mapping; 527 int ret; 528 529 iov_iter_bvec(&from, ITER_DEST, sio->bvec, sio->pages, sio->len); 530 ret = mapping->a_ops->swap_rw(&sio->iocb, &from); 531 if (ret != -EIOCBQUEUED) 532 sio_read_complete(&sio->iocb, ret); 533 } 534