Branch data Line data Source code
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 <asm/pgtable.h>
29 : :
30 : 0 : static struct bio *get_swap_bio(gfp_t gfp_flags,
31 : : struct page *page, bio_end_io_t end_io)
32 : : {
33 : 0 : struct bio *bio;
34 : :
35 : 0 : bio = bio_alloc(gfp_flags, 1);
36 [ # # ]: 0 : if (bio) {
37 : 0 : struct block_device *bdev;
38 : :
39 : 0 : bio->bi_iter.bi_sector = map_swap_page(page, &bdev);
40 [ # # ]: 0 : bio_set_dev(bio, bdev);
41 : 0 : bio->bi_iter.bi_sector <<= PAGE_SHIFT - 9;
42 : 0 : bio->bi_end_io = end_io;
43 : :
44 : 0 : bio_add_page(bio, page, PAGE_SIZE * hpage_nr_pages(page), 0);
45 : : }
46 : 0 : return bio;
47 : : }
48 : :
49 : 0 : void end_swap_bio_write(struct bio *bio)
50 : : {
51 [ # # ]: 0 : struct page *page = bio_first_page_all(bio);
52 : :
53 [ # # ]: 0 : if (bio->bi_status) {
54 : 0 : SetPageError(page);
55 : : /*
56 : : * We failed to write the page out to swap-space.
57 : : * Re-dirty the page in order to avoid it being reclaimed.
58 : : * Also print a dire warning that things will go BAD (tm)
59 : : * very quickly.
60 : : *
61 : : * Also clear PG_reclaim to avoid rotate_reclaimable_page()
62 : : */
63 : 0 : set_page_dirty(page);
64 : 0 : pr_alert("Write-error on swap-device (%u:%u:%llu)\n",
65 : : MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)),
66 : : (unsigned long long)bio->bi_iter.bi_sector);
67 : 0 : ClearPageReclaim(page);
68 : : }
69 : 0 : end_page_writeback(page);
70 : 0 : bio_put(bio);
71 : 0 : }
72 : :
73 : 0 : static void swap_slot_free_notify(struct page *page)
74 : : {
75 : 0 : struct swap_info_struct *sis;
76 : 0 : struct gendisk *disk;
77 : 0 : swp_entry_t entry;
78 : :
79 : : /*
80 : : * There is no guarantee that the page is in swap cache - the software
81 : : * suspend code (at least) uses end_swap_bio_read() against a non-
82 : : * swapcache page. So we must check PG_swapcache before proceeding with
83 : : * this optimization.
84 : : */
85 [ # # # # ]: 0 : if (unlikely(!PageSwapCache(page)))
86 : : return;
87 : :
88 : 0 : sis = page_swap_info(page);
89 [ # # ]: 0 : if (!(sis->flags & SWP_BLKDEV))
90 : : return;
91 : :
92 : : /*
93 : : * The swap subsystem performs lazy swap slot freeing,
94 : : * expecting that the page will be swapped out again.
95 : : * So we can avoid an unnecessary write if the page
96 : : * isn't redirtied.
97 : : * This is good for real swap storage because we can
98 : : * reduce unnecessary I/O and enhance wear-leveling
99 : : * if an SSD is used as the as swap device.
100 : : * But if in-memory swap device (eg zram) is used,
101 : : * this causes a duplicated copy between uncompressed
102 : : * data in VM-owned memory and compressed data in
103 : : * zram-owned memory. So let's free zram-owned memory
104 : : * and make the VM-owned decompressed page *dirty*,
105 : : * so the page should be swapped out somewhere again if
106 : : * we again wish to reclaim it.
107 : : */
108 : 0 : disk = sis->bdev->bd_disk;
109 : 0 : entry.val = page_private(page);
110 [ # # # # ]: 0 : if (disk->fops->swap_slot_free_notify && __swap_count(entry) == 1) {
111 : 0 : unsigned long offset;
112 : :
113 [ # # ]: 0 : offset = swp_offset(entry);
114 : :
115 [ # # ]: 0 : SetPageDirty(page);
116 : 0 : disk->fops->swap_slot_free_notify(sis->bdev,
117 : : offset);
118 : : }
119 : : }
120 : :
121 : 0 : static void end_swap_bio_read(struct bio *bio)
122 : : {
123 [ # # ]: 0 : struct page *page = bio_first_page_all(bio);
124 : 0 : struct task_struct *waiter = bio->bi_private;
125 : :
126 [ # # ]: 0 : if (bio->bi_status) {
127 [ # # ]: 0 : SetPageError(page);
128 [ # # ]: 0 : ClearPageUptodate(page);
129 : 0 : pr_alert("Read-error on swap-device (%u:%u:%llu)\n",
130 : : MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)),
131 : : (unsigned long long)bio->bi_iter.bi_sector);
132 : 0 : goto out;
133 : : }
134 : :
135 : 0 : SetPageUptodate(page);
136 : 0 : swap_slot_free_notify(page);
137 : 0 : out:
138 : 0 : unlock_page(page);
139 : 0 : WRITE_ONCE(bio->bi_private, NULL);
140 : 0 : bio_put(bio);
141 [ # # ]: 0 : if (waiter) {
142 [ # # ]: 0 : blk_wake_io_task(waiter);
143 : 0 : put_task_struct(waiter);
144 : : }
145 : 0 : }
146 : :
147 : 0 : int generic_swapfile_activate(struct swap_info_struct *sis,
148 : : struct file *swap_file,
149 : : sector_t *span)
150 : : {
151 : 0 : struct address_space *mapping = swap_file->f_mapping;
152 : 0 : struct inode *inode = mapping->host;
153 : 0 : unsigned blocks_per_page;
154 : 0 : unsigned long page_no;
155 : 0 : unsigned blkbits;
156 : 0 : sector_t probe_block;
157 : 0 : sector_t last_block;
158 : 0 : sector_t lowest_block = -1;
159 : 0 : sector_t highest_block = 0;
160 : 0 : int nr_extents = 0;
161 : 0 : int ret;
162 : :
163 : 0 : blkbits = inode->i_blkbits;
164 : 0 : blocks_per_page = PAGE_SIZE >> blkbits;
165 : :
166 : : /*
167 : : * Map all the blocks into the extent tree. This code doesn't try
168 : : * to be very smart.
169 : : */
170 : 0 : probe_block = 0;
171 : 0 : page_no = 0;
172 : 0 : last_block = i_size_read(inode) >> blkbits;
173 [ # # ]: 0 : while ((probe_block + blocks_per_page) <= last_block &&
174 [ # # ]: 0 : page_no < sis->max) {
175 : 0 : unsigned block_in_page;
176 : 0 : sector_t first_block;
177 : :
178 : 0 : cond_resched();
179 : :
180 : 0 : first_block = probe_block;
181 : 0 : ret = bmap(inode, &first_block);
182 [ # # # # ]: 0 : if (ret || !first_block)
183 : 0 : goto bad_bmap;
184 : :
185 : : /*
186 : : * It must be PAGE_SIZE aligned on-disk
187 : : */
188 [ # # ]: 0 : if (first_block & (blocks_per_page - 1)) {
189 : 0 : probe_block++;
190 : 0 : goto reprobe;
191 : : }
192 : :
193 [ # # ]: 0 : for (block_in_page = 1; block_in_page < blocks_per_page;
194 : 0 : block_in_page++) {
195 : 0 : sector_t block;
196 : :
197 : 0 : block = probe_block + block_in_page;
198 : 0 : ret = bmap(inode, &block);
199 [ # # # # ]: 0 : if (ret || !block)
200 : 0 : goto bad_bmap;
201 : :
202 [ # # ]: 0 : if (block != first_block + block_in_page) {
203 : : /* Discontiguity */
204 : 0 : probe_block++;
205 : 0 : goto reprobe;
206 : : }
207 : : }
208 : :
209 : 0 : first_block >>= (PAGE_SHIFT - blkbits);
210 [ # # ]: 0 : if (page_no) { /* exclude the header page */
211 : 0 : if (first_block < lowest_block)
212 : : lowest_block = first_block;
213 : 0 : if (first_block > highest_block)
214 : : highest_block = first_block;
215 : : }
216 : :
217 : : /*
218 : : * We found a PAGE_SIZE-length, PAGE_SIZE-aligned run of blocks
219 : : */
220 : 0 : ret = add_swap_extent(sis, page_no, 1, first_block);
221 [ # # ]: 0 : if (ret < 0)
222 : 0 : goto out;
223 : 0 : nr_extents += ret;
224 : 0 : page_no++;
225 : 0 : probe_block += blocks_per_page;
226 : 0 : reprobe:
227 : 0 : continue;
228 : : }
229 : 0 : ret = nr_extents;
230 : 0 : *span = 1 + highest_block - lowest_block;
231 : 0 : if (page_no == 0)
232 : : page_no = 1; /* force Empty message */
233 : 0 : sis->max = page_no;
234 : 0 : sis->pages = page_no - 1;
235 : 0 : sis->highest_bit = page_no - 1;
236 : 0 : out:
237 : 0 : return ret;
238 : : bad_bmap:
239 : 0 : pr_err("swapon: swapfile has holes\n");
240 : 0 : ret = -EINVAL;
241 : 0 : goto out;
242 : : }
243 : :
244 : : /*
245 : : * We may have stale swap cache pages in memory: notice
246 : : * them here and get rid of the unnecessary final write.
247 : : */
248 : 0 : int swap_writepage(struct page *page, struct writeback_control *wbc)
249 : : {
250 : 0 : int ret = 0;
251 : :
252 [ # # ]: 0 : if (try_to_free_swap(page)) {
253 : 0 : unlock_page(page);
254 : 0 : goto out;
255 : : }
256 : 0 : if (frontswap_store(page) == 0) {
257 : : set_page_writeback(page);
258 : : unlock_page(page);
259 : : end_page_writeback(page);
260 : : goto out;
261 : : }
262 : 0 : ret = __swap_writepage(page, wbc, end_swap_bio_write);
263 : 0 : out:
264 : 0 : return ret;
265 : : }
266 : :
267 : 0 : static sector_t swap_page_sector(struct page *page)
268 : : {
269 : 0 : return (sector_t)__page_file_index(page) << (PAGE_SHIFT - 9);
270 : : }
271 : :
272 : 0 : static inline void count_swpout_vm_event(struct page *page)
273 : : {
274 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
275 : : if (unlikely(PageTransHuge(page)))
276 : : count_vm_event(THP_SWPOUT);
277 : : #endif
278 : 0 : count_vm_events(PSWPOUT, hpage_nr_pages(page));
279 : : }
280 : :
281 : 0 : int __swap_writepage(struct page *page, struct writeback_control *wbc,
282 : : bio_end_io_t end_write_func)
283 : : {
284 : 0 : struct bio *bio;
285 : 0 : int ret;
286 : 0 : struct swap_info_struct *sis = page_swap_info(page);
287 : :
288 : 0 : VM_BUG_ON_PAGE(!PageSwapCache(page), page);
289 [ # # ]: 0 : if (sis->flags & SWP_FS) {
290 : 0 : struct kiocb kiocb;
291 : 0 : struct file *swap_file = sis->swap_file;
292 : 0 : struct address_space *mapping = swap_file->f_mapping;
293 : 0 : struct bio_vec bv = {
294 : : .bv_page = page,
295 : : .bv_len = PAGE_SIZE,
296 : : .bv_offset = 0
297 : : };
298 : 0 : struct iov_iter from;
299 : :
300 : 0 : iov_iter_bvec(&from, WRITE, &bv, 1, PAGE_SIZE);
301 : 0 : init_sync_kiocb(&kiocb, swap_file);
302 : 0 : kiocb.ki_pos = page_file_offset(page);
303 : :
304 : 0 : set_page_writeback(page);
305 : 0 : unlock_page(page);
306 : 0 : ret = mapping->a_ops->direct_IO(&kiocb, &from);
307 [ # # ]: 0 : if (ret == PAGE_SIZE) {
308 : 0 : count_vm_event(PSWPOUT);
309 : 0 : ret = 0;
310 : : } else {
311 : : /*
312 : : * In the case of swap-over-nfs, this can be a
313 : : * temporary failure if the system has limited
314 : : * memory for allocating transmit buffers.
315 : : * Mark the page dirty and avoid
316 : : * rotate_reclaimable_page but rate-limit the
317 : : * messages but do not flag PageError like
318 : : * the normal direct-to-bio case as it could
319 : : * be temporary.
320 : : */
321 : 0 : set_page_dirty(page);
322 [ # # ]: 0 : ClearPageReclaim(page);
323 [ # # ]: 0 : pr_err_ratelimited("Write error on dio swapfile (%llu)\n",
324 : : page_file_offset(page));
325 : : }
326 : 0 : end_page_writeback(page);
327 : 0 : return ret;
328 : : }
329 : :
330 : 0 : ret = bdev_write_page(sis->bdev, swap_page_sector(page), page, wbc);
331 [ # # ]: 0 : if (!ret) {
332 : 0 : count_swpout_vm_event(page);
333 : 0 : return 0;
334 : : }
335 : :
336 : 0 : ret = 0;
337 : 0 : bio = get_swap_bio(GFP_NOIO, page, end_write_func);
338 [ # # ]: 0 : if (bio == NULL) {
339 : 0 : set_page_dirty(page);
340 : 0 : unlock_page(page);
341 : 0 : ret = -ENOMEM;
342 : 0 : goto out;
343 : : }
344 [ # # ]: 0 : bio->bi_opf = REQ_OP_WRITE | REQ_SWAP | wbc_to_write_flags(wbc);
345 : 0 : bio_associate_blkg_from_page(bio, page);
346 : 0 : count_swpout_vm_event(page);
347 : 0 : set_page_writeback(page);
348 : 0 : unlock_page(page);
349 : 0 : submit_bio(bio);
350 : : out:
351 : : return ret;
352 : : }
353 : :
354 : 0 : int swap_readpage(struct page *page, bool synchronous)
355 : : {
356 : 0 : struct bio *bio;
357 : 0 : int ret = 0;
358 : 0 : struct swap_info_struct *sis = page_swap_info(page);
359 : 0 : blk_qc_t qc;
360 : 0 : struct gendisk *disk;
361 : 0 : unsigned long pflags;
362 : :
363 : 0 : VM_BUG_ON_PAGE(!PageSwapCache(page) && !synchronous, page);
364 : 0 : VM_BUG_ON_PAGE(!PageLocked(page), page);
365 : 0 : VM_BUG_ON_PAGE(PageUptodate(page), page);
366 : :
367 : : /*
368 : : * Count submission time as memory stall. When the device is congested,
369 : : * or the submitting cgroup IO-throttled, submission can be a
370 : : * significant part of overall IO time.
371 : : */
372 [ # # ]: 0 : psi_memstall_enter(&pflags);
373 : :
374 [ # # ]: 0 : if (frontswap_load(page) == 0) {
375 : : SetPageUptodate(page);
376 : : unlock_page(page);
377 : : goto out;
378 : : }
379 : :
380 [ # # ]: 0 : if (sis->flags & SWP_FS) {
381 : 0 : struct file *swap_file = sis->swap_file;
382 : 0 : struct address_space *mapping = swap_file->f_mapping;
383 : :
384 : 0 : ret = mapping->a_ops->readpage(swap_file, page);
385 [ # # ]: 0 : if (!ret)
386 : 0 : count_vm_event(PSWPIN);
387 : 0 : goto out;
388 : : }
389 : :
390 : 0 : ret = bdev_read_page(sis->bdev, swap_page_sector(page), page);
391 [ # # ]: 0 : if (!ret) {
392 [ # # # # ]: 0 : if (trylock_page(page)) {
393 : 0 : swap_slot_free_notify(page);
394 : 0 : unlock_page(page);
395 : : }
396 : :
397 : 0 : count_vm_event(PSWPIN);
398 : 0 : goto out;
399 : : }
400 : :
401 : 0 : ret = 0;
402 : 0 : bio = get_swap_bio(GFP_KERNEL, page, end_swap_bio_read);
403 [ # # ]: 0 : if (bio == NULL) {
404 : 0 : unlock_page(page);
405 : 0 : ret = -ENOMEM;
406 : 0 : goto out;
407 : : }
408 : 0 : disk = bio->bi_disk;
409 : : /*
410 : : * Keep this task valid during swap readpage because the oom killer may
411 : : * attempt to access it in the page fault retry time check.
412 : : */
413 [ # # ]: 0 : bio_set_op_attrs(bio, REQ_OP_READ, 0);
414 [ # # ]: 0 : if (synchronous) {
415 : 0 : bio->bi_opf |= REQ_HIPRI;
416 : 0 : get_task_struct(current);
417 : 0 : bio->bi_private = current;
418 : : }
419 : 0 : count_vm_event(PSWPIN);
420 : 0 : bio_get(bio);
421 : 0 : qc = submit_bio(bio);
422 [ # # ]: 0 : while (synchronous) {
423 : 0 : set_current_state(TASK_UNINTERRUPTIBLE);
424 [ # # ]: 0 : if (!READ_ONCE(bio->bi_private))
425 : : break;
426 : :
427 [ # # ]: 0 : if (!blk_poll(disk->queue, qc, true))
428 : 0 : io_schedule();
429 : : }
430 : 0 : __set_current_state(TASK_RUNNING);
431 : 0 : bio_put(bio);
432 : :
433 : 0 : out:
434 : 0 : psi_memstall_leave(&pflags);
435 : 0 : return ret;
436 : : }
437 : :
438 : 0 : int swap_set_page_dirty(struct page *page)
439 : : {
440 : 0 : struct swap_info_struct *sis = page_swap_info(page);
441 : :
442 [ # # ]: 0 : if (sis->flags & SWP_FS) {
443 : 0 : struct address_space *mapping = sis->swap_file->f_mapping;
444 : :
445 : 0 : VM_BUG_ON_PAGE(!PageSwapCache(page), page);
446 : 0 : return mapping->a_ops->set_page_dirty(page);
447 : : } else {
448 : 0 : return __set_page_dirty_no_writeback(page);
449 : : }
450 : : }
|
