Merge tag 'jfs-6.11' of github.com:kleikamp/linux-shaggy

+2

fs/jfs/jfs_dmap.c

··· 1626 1626 } else if (rc == -ENOSPC) { 1627 1627 /* search for next smaller log2 block */ 1628 1628 l2nb = BLKSTOL2(nblocks) - 1; 1629 + if (unlikely(l2nb < 0)) 1630 + break; 1629 1631 nblocks = 1LL << l2nb; 1630 1632 } else { 1631 1633 /* Trim any already allocated blocks */

+2

fs/jfs/jfs_dtree.c

··· 834 834 * the full page. 835 835 */ 836 836 DT_GETSEARCH(ip, btstack->top, bn, mp, p, index); 837 + if (p->header.freelist == 0) 838 + return -EINVAL; 837 839 838 840 /* 839 841 * insert entry for new key

+4 -1

fs/jfs/jfs_imap.c

··· 290 290 int diRead(struct inode *ip) 291 291 { 292 292 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 293 - int iagno, ino, extno, rc; 293 + int iagno, ino, extno, rc, agno; 294 294 struct inode *ipimap; 295 295 struct dinode *dp; 296 296 struct iag *iagp; ··· 339 339 340 340 /* get the ag for the iag */ 341 341 agstart = le64_to_cpu(iagp->agstart); 342 + agno = BLKTOAG(agstart, JFS_SBI(ip->i_sb)); 342 343 343 344 release_metapage(mp); 345 + if (agno >= MAXAG || agno < 0) 346 + return -EIO; 344 347 345 348 rel_inode = (ino & (INOSPERPAGE - 1)); 346 349 pageno = blkno >> sbi->l2nbperpage;

+1 -1

fs/jfs/jfs_logmgr.c

··· 1600 1600 mp, sizeof(struct metapage), 0); 1601 1601 print_hex_dump(KERN_ERR, "page: ", 1602 1602 DUMP_PREFIX_ADDRESS, 16, 1603 - sizeof(long), mp->page, 1603 + sizeof(long), mp->folio, 1604 1604 sizeof(struct page), 0); 1605 1605 } else 1606 1606 print_hex_dump(KERN_ERR, "tblock:",

+157 -159

fs/jfs/jfs_metapage.c

··· 4 4 * Portions Copyright (C) Christoph Hellwig, 2001-2002 5 5 */ 6 6 7 + #include <linux/blkdev.h> 7 8 #include <linux/fs.h> 8 9 #include <linux/mm.h> 9 10 #include <linux/module.h> ··· 47 46 do { 48 47 set_current_state(TASK_UNINTERRUPTIBLE); 49 48 if (metapage_locked(mp)) { 50 - unlock_page(mp->page); 49 + folio_unlock(mp->folio); 51 50 io_schedule(); 52 - lock_page(mp->page); 51 + folio_lock(mp->folio); 53 52 } 54 53 } while (trylock_metapage(mp)); 55 54 __set_current_state(TASK_RUNNING); ··· 57 56 } 58 57 59 58 /* 60 - * Must have mp->page locked 59 + * Must have mp->folio locked 61 60 */ 62 61 static inline void lock_metapage(struct metapage *mp) 63 62 { ··· 76 75 struct meta_anchor { 77 76 int mp_count; 78 77 atomic_t io_count; 78 + blk_status_t status; 79 79 struct metapage *mp[MPS_PER_PAGE]; 80 80 }; 81 - #define mp_anchor(page) ((struct meta_anchor *)page_private(page)) 82 81 83 - static inline struct metapage *page_to_mp(struct page *page, int offset) 82 + static inline struct metapage *folio_to_mp(struct folio *folio, int offset) 84 83 { 85 - if (!PagePrivate(page)) 84 + struct meta_anchor *anchor = folio->private; 85 + 86 + if (!anchor) 86 87 return NULL; 87 - return mp_anchor(page)->mp[offset >> L2PSIZE]; 88 + return anchor->mp[offset >> L2PSIZE]; 88 89 } 89 90 90 - static inline int insert_metapage(struct page *page, struct metapage *mp) 91 + static inline int insert_metapage(struct folio *folio, struct metapage *mp) 91 92 { 92 93 struct meta_anchor *a; 93 94 int index; 94 95 int l2mp_blocks; /* log2 blocks per metapage */ 95 96 96 - if (PagePrivate(page)) 97 - a = mp_anchor(page); 98 - else { 97 + a = folio->private; 98 + if (!a) { 99 99 a = kzalloc(sizeof(struct meta_anchor), GFP_NOFS); 100 100 if (!a) 101 101 return -ENOMEM; 102 - set_page_private(page, (unsigned long)a); 103 - SetPagePrivate(page); 104 - kmap(page); 102 + folio_attach_private(folio, a); 103 + kmap(&folio->page); 105 104 } 106 105 107 106 if (mp) { 108 - l2mp_blocks = L2PSIZE - page->mapping->host->i_blkbits; 107 + l2mp_blocks = L2PSIZE - folio->mapping->host->i_blkbits; 109 108 index = (mp->index >> l2mp_blocks) & (MPS_PER_PAGE - 1); 110 109 a->mp_count++; 111 110 a->mp[index] = mp; ··· 114 113 return 0; 115 114 } 116 115 117 - static inline void remove_metapage(struct page *page, struct metapage *mp) 116 + static inline void remove_metapage(struct folio *folio, struct metapage *mp) 118 117 { 119 - struct meta_anchor *a = mp_anchor(page); 120 - int l2mp_blocks = L2PSIZE - page->mapping->host->i_blkbits; 118 + struct meta_anchor *a = folio->private; 119 + int l2mp_blocks = L2PSIZE - folio->mapping->host->i_blkbits; 121 120 int index; 122 121 123 122 index = (mp->index >> l2mp_blocks) & (MPS_PER_PAGE - 1); ··· 127 126 a->mp[index] = NULL; 128 127 if (--a->mp_count == 0) { 129 128 kfree(a); 130 - set_page_private(page, 0); 131 - ClearPagePrivate(page); 132 - kunmap(page); 129 + folio_detach_private(folio); 130 + kunmap(&folio->page); 133 131 } 134 132 } 135 133 136 - static inline void inc_io(struct page *page) 134 + static inline void inc_io(struct folio *folio) 137 135 { 138 - atomic_inc(&mp_anchor(page)->io_count); 136 + struct meta_anchor *anchor = folio->private; 137 + 138 + atomic_inc(&anchor->io_count); 139 139 } 140 140 141 - static inline void dec_io(struct page *page, void (*handler) (struct page *)) 141 + static inline void dec_io(struct folio *folio, blk_status_t status, 142 + void (*handler)(struct folio *, blk_status_t)) 142 143 { 143 - if (atomic_dec_and_test(&mp_anchor(page)->io_count)) 144 - handler(page); 144 + struct meta_anchor *anchor = folio->private; 145 + 146 + if (anchor->status == BLK_STS_OK) 147 + anchor->status = status; 148 + 149 + if (atomic_dec_and_test(&anchor->io_count)) 150 + handler(folio, anchor->status); 145 151 } 146 152 147 153 #else 148 - static inline struct metapage *page_to_mp(struct page *page, int offset) 154 + static inline struct metapage *folio_to_mp(struct folio *folio, int offset) 149 155 { 150 - return PagePrivate(page) ? (struct metapage *)page_private(page) : NULL; 156 + return folio->private; 151 157 } 152 158 153 - static inline int insert_metapage(struct page *page, struct metapage *mp) 159 + static inline int insert_metapage(struct folio *folio, struct metapage *mp) 154 160 { 155 161 if (mp) { 156 - set_page_private(page, (unsigned long)mp); 157 - SetPagePrivate(page); 158 - kmap(page); 162 + folio_attach_private(folio, mp); 163 + kmap(&folio->page); 159 164 } 160 165 return 0; 161 166 } 162 167 163 - static inline void remove_metapage(struct page *page, struct metapage *mp) 168 + static inline void remove_metapage(struct folio *folio, struct metapage *mp) 164 169 { 165 - set_page_private(page, 0); 166 - ClearPagePrivate(page); 167 - kunmap(page); 170 + folio_detach_private(folio); 171 + kunmap(&folio->page); 168 172 } 169 173 170 - #define inc_io(page) do {} while(0) 171 - #define dec_io(page, handler) handler(page) 174 + #define inc_io(folio) do {} while(0) 175 + #define dec_io(folio, status, handler) handler(folio, status) 172 176 173 177 #endif 174 178 ··· 224 218 kmem_cache_destroy(metapage_cache); 225 219 } 226 220 227 - static inline void drop_metapage(struct page *page, struct metapage *mp) 221 + static inline void drop_metapage(struct folio *folio, struct metapage *mp) 228 222 { 229 223 if (mp->count || mp->nohomeok || test_bit(META_dirty, &mp->flag) || 230 224 test_bit(META_io, &mp->flag)) 231 225 return; 232 - remove_metapage(page, mp); 226 + remove_metapage(folio, mp); 233 227 INCREMENT(mpStat.pagefree); 234 228 free_metapage(mp); 235 229 } ··· 263 257 return lblock; 264 258 } 265 259 266 - static void last_read_complete(struct page *page) 260 + static void last_read_complete(struct folio *folio, blk_status_t status) 267 261 { 268 - if (!PageError(page)) 269 - SetPageUptodate(page); 270 - unlock_page(page); 262 + if (status) 263 + printk(KERN_ERR "Read error %d at %#llx\n", status, 264 + folio_pos(folio)); 265 + 266 + folio_end_read(folio, status == 0); 271 267 } 272 268 273 269 static void metapage_read_end_io(struct bio *bio) 274 270 { 275 - struct page *page = bio->bi_private; 271 + struct folio *folio = bio->bi_private; 276 272 277 - if (bio->bi_status) { 278 - printk(KERN_ERR "metapage_read_end_io: I/O error\n"); 279 - SetPageError(page); 280 - } 281 - 282 - dec_io(page, last_read_complete); 273 + dec_io(folio, bio->bi_status, last_read_complete); 283 274 bio_put(bio); 284 275 } 285 276 ··· 302 299 LOGSYNC_UNLOCK(log, flags); 303 300 } 304 301 305 - static void last_write_complete(struct page *page) 302 + static void last_write_complete(struct folio *folio, blk_status_t status) 306 303 { 307 304 struct metapage *mp; 308 305 unsigned int offset; 309 306 307 + if (status) { 308 + int err = blk_status_to_errno(status); 309 + printk(KERN_ERR "metapage_write_end_io: I/O error\n"); 310 + mapping_set_error(folio->mapping, err); 311 + } 312 + 310 313 for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) { 311 - mp = page_to_mp(page, offset); 314 + mp = folio_to_mp(folio, offset); 312 315 if (mp && test_bit(META_io, &mp->flag)) { 313 316 if (mp->lsn) 314 317 remove_from_logsync(mp); ··· 325 316 * safe unless I have the page locked 326 317 */ 327 318 } 328 - end_page_writeback(page); 319 + folio_end_writeback(folio); 329 320 } 330 321 331 322 static void metapage_write_end_io(struct bio *bio) 332 323 { 333 - struct page *page = bio->bi_private; 324 + struct folio *folio = bio->bi_private; 334 325 335 - BUG_ON(!PagePrivate(page)); 326 + BUG_ON(!folio->private); 336 327 337 - if (bio->bi_status) { 338 - printk(KERN_ERR "metapage_write_end_io: I/O error\n"); 339 - SetPageError(page); 340 - } 341 - dec_io(page, last_write_complete); 328 + dec_io(folio, bio->bi_status, last_write_complete); 342 329 bio_put(bio); 343 330 } 344 331 345 - static int metapage_writepage(struct page *page, struct writeback_control *wbc) 332 + static int metapage_write_folio(struct folio *folio, 333 + struct writeback_control *wbc, void *unused) 346 334 { 347 335 struct bio *bio = NULL; 348 336 int block_offset; /* block offset of mp within page */ 349 - struct inode *inode = page->mapping->host; 337 + struct inode *inode = folio->mapping->host; 350 338 int blocks_per_mp = JFS_SBI(inode->i_sb)->nbperpage; 351 339 int len; 352 340 int xlen; ··· 359 353 int offset; 360 354 int bad_blocks = 0; 361 355 362 - page_start = (sector_t)page->index << 363 - (PAGE_SHIFT - inode->i_blkbits); 364 - BUG_ON(!PageLocked(page)); 365 - BUG_ON(PageWriteback(page)); 366 - set_page_writeback(page); 356 + page_start = folio_pos(folio) >> inode->i_blkbits; 357 + BUG_ON(!folio_test_locked(folio)); 358 + BUG_ON(folio_test_writeback(folio)); 359 + folio_start_writeback(folio); 367 360 368 361 for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) { 369 - mp = page_to_mp(page, offset); 362 + mp = folio_to_mp(folio, offset); 370 363 371 364 if (!mp || !test_bit(META_dirty, &mp->flag)) 372 365 continue; ··· 394 389 continue; 395 390 } 396 391 /* Not contiguous */ 397 - if (bio_add_page(bio, page, bio_bytes, bio_offset) < 398 - bio_bytes) 399 - goto add_failed; 392 + bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset); 400 393 /* 401 394 * Increment counter before submitting i/o to keep 402 395 * count from hitting zero before we're through 403 396 */ 404 - inc_io(page); 397 + inc_io(folio); 405 398 if (!bio->bi_iter.bi_size) 406 399 goto dump_bio; 407 400 submit_bio(bio); 408 401 nr_underway++; 409 402 bio = NULL; 410 403 } else 411 - inc_io(page); 412 - xlen = (PAGE_SIZE - offset) >> inode->i_blkbits; 404 + inc_io(folio); 405 + xlen = (folio_size(folio) - offset) >> inode->i_blkbits; 413 406 pblock = metapage_get_blocks(inode, lblock, &xlen); 414 407 if (!pblock) { 415 408 printk(KERN_ERR "JFS: metapage_get_blocks failed\n"); ··· 423 420 bio = bio_alloc(inode->i_sb->s_bdev, 1, REQ_OP_WRITE, GFP_NOFS); 424 421 bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9); 425 422 bio->bi_end_io = metapage_write_end_io; 426 - bio->bi_private = page; 423 + bio->bi_private = folio; 427 424 428 425 /* Don't call bio_add_page yet, we may add to this vec */ 429 426 bio_offset = offset; ··· 433 430 next_block = lblock + len; 434 431 } 435 432 if (bio) { 436 - if (bio_add_page(bio, page, bio_bytes, bio_offset) < bio_bytes) 437 - goto add_failed; 433 + bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset); 438 434 if (!bio->bi_iter.bi_size) 439 435 goto dump_bio; 440 436 ··· 441 439 nr_underway++; 442 440 } 443 441 if (redirty) 444 - redirty_page_for_writepage(wbc, page); 442 + folio_redirty_for_writepage(wbc, folio); 445 443 446 - unlock_page(page); 444 + folio_unlock(folio); 447 445 448 446 if (bad_blocks) 449 447 goto err_out; 450 448 451 449 if (nr_underway == 0) 452 - end_page_writeback(page); 450 + folio_end_writeback(folio); 453 451 454 452 return 0; 455 - add_failed: 456 - /* We should never reach here, since we're only adding one vec */ 457 - printk(KERN_ERR "JFS: bio_add_page failed unexpectedly\n"); 458 - goto skip; 459 453 dump_bio: 460 454 print_hex_dump(KERN_ERR, "JFS: dump of bio: ", DUMP_PREFIX_ADDRESS, 16, 461 455 4, bio, sizeof(*bio), 0); 462 - skip: 463 456 bio_put(bio); 464 - unlock_page(page); 465 - dec_io(page, last_write_complete); 457 + folio_unlock(folio); 458 + dec_io(folio, BLK_STS_OK, last_write_complete); 466 459 err_out: 467 460 while (bad_blocks--) 468 - dec_io(page, last_write_complete); 461 + dec_io(folio, BLK_STS_OK, last_write_complete); 469 462 return -EIO; 463 + } 464 + 465 + static int metapage_writepages(struct address_space *mapping, 466 + struct writeback_control *wbc) 467 + { 468 + struct blk_plug plug; 469 + int err; 470 + 471 + blk_start_plug(&plug); 472 + err = write_cache_pages(mapping, wbc, metapage_write_folio, NULL); 473 + blk_finish_plug(&plug); 474 + 475 + return err; 470 476 } 471 477 472 478 static int metapage_read_folio(struct file *fp, struct folio *folio) 473 479 { 474 - struct page *page = &folio->page; 475 - struct inode *inode = page->mapping->host; 480 + struct inode *inode = folio->mapping->host; 476 481 struct bio *bio = NULL; 477 482 int block_offset; 478 - int blocks_per_page = i_blocks_per_page(inode, page); 483 + int blocks_per_page = i_blocks_per_folio(inode, folio); 479 484 sector_t page_start; /* address of page in fs blocks */ 480 485 sector_t pblock; 481 486 int xlen; 482 487 unsigned int len; 483 488 int offset; 484 489 485 - BUG_ON(!PageLocked(page)); 486 - page_start = (sector_t)page->index << 487 - (PAGE_SHIFT - inode->i_blkbits); 490 + BUG_ON(!folio_test_locked(folio)); 491 + page_start = folio_pos(folio) >> inode->i_blkbits; 488 492 489 493 block_offset = 0; 490 494 while (block_offset < blocks_per_page) { ··· 498 490 pblock = metapage_get_blocks(inode, page_start + block_offset, 499 491 &xlen); 500 492 if (pblock) { 501 - if (!PagePrivate(page)) 502 - insert_metapage(page, NULL); 503 - inc_io(page); 493 + if (!folio->private) 494 + insert_metapage(folio, NULL); 495 + inc_io(folio); 504 496 if (bio) 505 497 submit_bio(bio); 506 498 ··· 509 501 bio->bi_iter.bi_sector = 510 502 pblock << (inode->i_blkbits - 9); 511 503 bio->bi_end_io = metapage_read_end_io; 512 - bio->bi_private = page; 504 + bio->bi_private = folio; 513 505 len = xlen << inode->i_blkbits; 514 506 offset = block_offset << inode->i_blkbits; 515 - if (bio_add_page(bio, page, len, offset) < len) 516 - goto add_failed; 507 + bio_add_folio_nofail(bio, folio, len, offset); 517 508 block_offset += xlen; 518 509 } else 519 510 block_offset++; ··· 520 513 if (bio) 521 514 submit_bio(bio); 522 515 else 523 - unlock_page(page); 516 + folio_unlock(folio); 524 517 525 518 return 0; 526 - 527 - add_failed: 528 - printk(KERN_ERR "JFS: bio_add_page failed unexpectedly\n"); 529 - bio_put(bio); 530 - dec_io(page, last_read_complete); 531 - return -EIO; 532 519 } 533 520 534 521 static bool metapage_release_folio(struct folio *folio, gfp_t gfp_mask) ··· 532 531 int offset; 533 532 534 533 for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) { 535 - mp = page_to_mp(&folio->page, offset); 534 + mp = folio_to_mp(folio, offset); 536 535 537 536 if (!mp) 538 537 continue; ··· 547 546 } 548 547 if (mp->lsn) 549 548 remove_from_logsync(mp); 550 - remove_metapage(&folio->page, mp); 549 + remove_metapage(folio, mp); 551 550 INCREMENT(mpStat.pagefree); 552 551 free_metapage(mp); 553 552 } ··· 566 565 567 566 const struct address_space_operations jfs_metapage_aops = { 568 567 .read_folio = metapage_read_folio, 569 - .writepage = metapage_writepage, 568 + .writepages = metapage_writepages, 570 569 .release_folio = metapage_release_folio, 571 570 .invalidate_folio = metapage_invalidate_folio, 572 571 .dirty_folio = filemap_dirty_folio, ··· 580 579 int l2bsize; 581 580 struct address_space *mapping; 582 581 struct metapage *mp = NULL; 583 - struct page *page; 582 + struct folio *folio; 584 583 unsigned long page_index; 585 584 unsigned long page_offset; 586 585 ··· 611 610 } 612 611 613 612 if (new && (PSIZE == PAGE_SIZE)) { 614 - page = grab_cache_page(mapping, page_index); 615 - if (!page) { 616 - jfs_err("grab_cache_page failed!"); 613 + folio = filemap_grab_folio(mapping, page_index); 614 + if (IS_ERR(folio)) { 615 + jfs_err("filemap_grab_folio failed!"); 617 616 return NULL; 618 617 } 619 - SetPageUptodate(page); 618 + folio_mark_uptodate(folio); 620 619 } else { 621 - page = read_mapping_page(mapping, page_index, NULL); 622 - if (IS_ERR(page)) { 620 + folio = read_mapping_folio(mapping, page_index, NULL); 621 + if (IS_ERR(folio)) { 623 622 jfs_err("read_mapping_page failed!"); 624 623 return NULL; 625 624 } 626 - lock_page(page); 625 + folio_lock(folio); 627 626 } 628 627 629 - mp = page_to_mp(page, page_offset); 628 + mp = folio_to_mp(folio, page_offset); 630 629 if (mp) { 631 630 if (mp->logical_size != size) { 632 631 jfs_error(inode->i_sb, ··· 652 651 mp = alloc_metapage(GFP_NOFS); 653 652 if (!mp) 654 653 goto unlock; 655 - mp->page = page; 654 + mp->folio = folio; 656 655 mp->sb = inode->i_sb; 657 656 mp->flag = 0; 658 657 mp->xflag = COMMIT_PAGE; 659 658 mp->count = 1; 660 659 mp->nohomeok = 0; 661 660 mp->logical_size = size; 662 - mp->data = page_address(page) + page_offset; 661 + mp->data = folio_address(folio) + page_offset; 663 662 mp->index = lblock; 664 - if (unlikely(insert_metapage(page, mp))) { 663 + if (unlikely(insert_metapage(folio, mp))) { 665 664 free_metapage(mp); 666 665 goto unlock; 667 666 } ··· 673 672 memset(mp->data, 0, PSIZE); 674 673 } 675 674 676 - unlock_page(page); 675 + folio_unlock(folio); 677 676 jfs_info("__get_metapage: returning = 0x%p data = 0x%p", mp, mp->data); 678 677 return mp; 679 678 680 679 unlock: 681 - unlock_page(page); 680 + folio_unlock(folio); 682 681 return NULL; 683 682 } 684 683 685 684 void grab_metapage(struct metapage * mp) 686 685 { 687 686 jfs_info("grab_metapage: mp = 0x%p", mp); 688 - get_page(mp->page); 689 - lock_page(mp->page); 687 + folio_get(mp->folio); 688 + folio_lock(mp->folio); 690 689 mp->count++; 691 690 lock_metapage(mp); 692 - unlock_page(mp->page); 691 + folio_unlock(mp->folio); 693 692 } 694 693 695 - static int metapage_write_one(struct page *page) 694 + static int metapage_write_one(struct folio *folio) 696 695 { 697 - struct folio *folio = page_folio(page); 698 696 struct address_space *mapping = folio->mapping; 699 697 struct writeback_control wbc = { 700 698 .sync_mode = WB_SYNC_ALL, ··· 707 707 708 708 if (folio_clear_dirty_for_io(folio)) { 709 709 folio_get(folio); 710 - ret = metapage_writepage(page, &wbc); 710 + ret = metapage_write_folio(folio, &wbc, NULL); 711 711 if (ret == 0) 712 712 folio_wait_writeback(folio); 713 713 folio_put(folio); ··· 722 722 723 723 void force_metapage(struct metapage *mp) 724 724 { 725 - struct page *page = mp->page; 725 + struct folio *folio = mp->folio; 726 726 jfs_info("force_metapage: mp = 0x%p", mp); 727 727 set_bit(META_forcewrite, &mp->flag); 728 728 clear_bit(META_sync, &mp->flag); 729 - get_page(page); 730 - lock_page(page); 731 - set_page_dirty(page); 732 - if (metapage_write_one(page)) 729 + folio_get(folio); 730 + folio_lock(folio); 731 + folio_mark_dirty(folio); 732 + if (metapage_write_one(folio)) 733 733 jfs_error(mp->sb, "metapage_write_one() failed\n"); 734 734 clear_bit(META_forcewrite, &mp->flag); 735 - put_page(page); 735 + folio_put(folio); 736 736 } 737 737 738 738 void hold_metapage(struct metapage *mp) 739 739 { 740 - lock_page(mp->page); 740 + folio_lock(mp->folio); 741 741 } 742 742 743 743 void put_metapage(struct metapage *mp) 744 744 { 745 745 if (mp->count || mp->nohomeok) { 746 746 /* Someone else will release this */ 747 - unlock_page(mp->page); 747 + folio_unlock(mp->folio); 748 748 return; 749 749 } 750 - get_page(mp->page); 750 + folio_get(mp->folio); 751 751 mp->count++; 752 752 lock_metapage(mp); 753 - unlock_page(mp->page); 753 + folio_unlock(mp->folio); 754 754 release_metapage(mp); 755 755 } 756 756 757 757 void release_metapage(struct metapage * mp) 758 758 { 759 - struct page *page = mp->page; 759 + struct folio *folio = mp->folio; 760 760 jfs_info("release_metapage: mp = 0x%p, flag = 0x%lx", mp, mp->flag); 761 761 762 - BUG_ON(!page); 763 - 764 - lock_page(page); 762 + folio_lock(folio); 765 763 unlock_metapage(mp); 766 764 767 765 assert(mp->count); 768 766 if (--mp->count || mp->nohomeok) { 769 - unlock_page(page); 770 - put_page(page); 767 + folio_unlock(folio); 768 + folio_put(folio); 771 769 return; 772 770 } 773 771 774 772 if (test_bit(META_dirty, &mp->flag)) { 775 - set_page_dirty(page); 773 + folio_mark_dirty(folio); 776 774 if (test_bit(META_sync, &mp->flag)) { 777 775 clear_bit(META_sync, &mp->flag); 778 - if (metapage_write_one(page)) 776 + if (metapage_write_one(folio)) 779 777 jfs_error(mp->sb, "metapage_write_one() failed\n"); 780 - lock_page(page); 778 + folio_lock(folio); 781 779 } 782 780 } else if (mp->lsn) /* discard_metapage doesn't remove it */ 783 781 remove_from_logsync(mp); 784 782 785 783 /* Try to keep metapages from using up too much memory */ 786 - drop_metapage(page, mp); 784 + drop_metapage(folio, mp); 787 785 788 - unlock_page(page); 789 - put_page(page); 786 + folio_unlock(folio); 787 + folio_put(folio); 790 788 } 791 789 792 790 void __invalidate_metapages(struct inode *ip, s64 addr, int len) ··· 796 798 struct address_space *mapping = 797 799 JFS_SBI(ip->i_sb)->direct_inode->i_mapping; 798 800 struct metapage *mp; 799 - struct page *page; 800 801 unsigned int offset; 801 802 802 803 /* ··· 804 807 */ 805 808 for (lblock = addr & ~(BlocksPerPage - 1); lblock < addr + len; 806 809 lblock += BlocksPerPage) { 807 - page = find_lock_page(mapping, lblock >> l2BlocksPerPage); 808 - if (!page) 810 + struct folio *folio = filemap_lock_folio(mapping, 811 + lblock >> l2BlocksPerPage); 812 + if (IS_ERR(folio)) 809 813 continue; 810 814 for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) { 811 - mp = page_to_mp(page, offset); 815 + mp = folio_to_mp(folio, offset); 812 816 if (!mp) 813 817 continue; 814 818 if (mp->index < addr) ··· 822 824 if (mp->lsn) 823 825 remove_from_logsync(mp); 824 826 } 825 - unlock_page(page); 826 - put_page(page); 827 + folio_unlock(folio); 828 + folio_put(folio); 827 829 } 828 830 } 829 831

+8 -8

fs/jfs/jfs_metapage.h

··· 24 24 wait_queue_head_t wait; 25 25 26 26 /* implementation */ 27 - struct page *page; 27 + struct folio *folio; 28 28 struct super_block *sb; 29 29 unsigned int logical_size; 30 30 ··· 90 90 91 91 static inline void metapage_nohomeok(struct metapage *mp) 92 92 { 93 - struct page *page = mp->page; 94 - lock_page(page); 93 + struct folio *folio = mp->folio; 94 + folio_lock(folio); 95 95 if (!mp->nohomeok++) { 96 96 mark_metapage_dirty(mp); 97 - get_page(page); 98 - wait_on_page_writeback(page); 97 + folio_get(folio); 98 + folio_wait_writeback(folio); 99 99 } 100 - unlock_page(page); 100 + folio_unlock(folio); 101 101 } 102 102 103 103 /* ··· 107 107 static inline void metapage_wait_for_io(struct metapage *mp) 108 108 { 109 109 if (test_bit(META_io, &mp->flag)) 110 - wait_on_page_writeback(mp->page); 110 + folio_wait_writeback(mp->folio); 111 111 } 112 112 113 113 /* ··· 116 116 static inline void _metapage_homeok(struct metapage *mp) 117 117 { 118 118 if (!--mp->nohomeok) 119 - put_page(mp->page); 119 + folio_put(mp->folio); 120 120 } 121 121 122 122 static inline void metapage_homeok(struct metapage *mp)

+19 -4

fs/jfs/xattr.c

··· 797 797 size_t buf_size) 798 798 { 799 799 struct jfs_ea_list *ealist; 800 - struct jfs_ea *ea; 800 + struct jfs_ea *ea, *ealist_end; 801 801 struct ea_buffer ea_buf; 802 802 int xattr_size; 803 803 ssize_t size; ··· 817 817 goto not_found; 818 818 819 819 ealist = (struct jfs_ea_list *) ea_buf.xattr; 820 + ealist_end = END_EALIST(ealist); 820 821 821 822 /* Find the named attribute */ 822 - for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist); ea = NEXT_EA(ea)) 823 + for (ea = FIRST_EA(ealist); ea < ealist_end; ea = NEXT_EA(ea)) { 824 + if (unlikely(ea + 1 > ealist_end) || 825 + unlikely(NEXT_EA(ea) > ealist_end)) { 826 + size = -EUCLEAN; 827 + goto release; 828 + } 829 + 823 830 if ((namelen == ea->namelen) && 824 831 memcmp(name, ea->name, namelen) == 0) { 825 832 /* Found it */ ··· 841 834 memcpy(data, value, size); 842 835 goto release; 843 836 } 837 + } 844 838 not_found: 845 839 size = -ENODATA; 846 840 release: ··· 869 861 ssize_t size = 0; 870 862 int xattr_size; 871 863 struct jfs_ea_list *ealist; 872 - struct jfs_ea *ea; 864 + struct jfs_ea *ea, *ealist_end; 873 865 struct ea_buffer ea_buf; 874 866 875 867 down_read(&JFS_IP(inode)->xattr_sem); ··· 884 876 goto release; 885 877 886 878 ealist = (struct jfs_ea_list *) ea_buf.xattr; 879 + ealist_end = END_EALIST(ealist); 887 880 888 881 /* compute required size of list */ 889 - for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist); ea = NEXT_EA(ea)) { 882 + for (ea = FIRST_EA(ealist); ea < ealist_end; ea = NEXT_EA(ea)) { 883 + if (unlikely(ea + 1 > ealist_end) || 884 + unlikely(NEXT_EA(ea) > ealist_end)) { 885 + size = -EUCLEAN; 886 + goto release; 887 + } 888 + 890 889 if (can_list(ea)) 891 890 size += name_size(ea) + 1; 892 891 }

-6

include/linux/pagemap.h

··· 1537 1537 { 1538 1538 return folio_size(folio) >> inode->i_blkbits; 1539 1539 } 1540 - 1541 - static inline 1542 - unsigned int i_blocks_per_page(struct inode *inode, struct page *page) 1543 - { 1544 - return i_blocks_per_folio(inode, page_folio(page)); 1545 - } 1546 1540 #endif /* _LINUX_PAGEMAP_H */

Configure Feed

Configure Feed