jfs_metapage.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) International Business Machines Corp., 2000-2005
  4. * Portions Copyright (C) Christoph Hellwig, 2001-2002
  5. */
  6. #include <linux/fs.h>
  7. #include <linux/mm.h>
  8. #include <linux/module.h>
  9. #include <linux/bio.h>
  10. #include <linux/slab.h>
  11. #include <linux/init.h>
  12. #include <linux/buffer_head.h>
  13. #include <linux/mempool.h>
  14. #include <linux/seq_file.h>
  15. #include "jfs_incore.h"
  16. #include "jfs_superblock.h"
  17. #include "jfs_filsys.h"
  18. #include "jfs_metapage.h"
  19. #include "jfs_txnmgr.h"
  20. #include "jfs_debug.h"
  21. #ifdef CONFIG_JFS_STATISTICS
  22. static struct {
  23. uint pagealloc; /* # of page allocations */
  24. uint pagefree; /* # of page frees */
  25. uint lockwait; /* # of sleeping lock_metapage() calls */
  26. } mpStat;
  27. #endif
  28. #define metapage_locked(mp) test_bit(META_locked, &(mp)->flag)
  29. #define trylock_metapage(mp) test_and_set_bit_lock(META_locked, &(mp)->flag)
  30. static inline void unlock_metapage(struct metapage *mp)
  31. {
  32. clear_bit_unlock(META_locked, &mp->flag);
  33. wake_up(&mp->wait);
  34. }
  35. static inline void __lock_metapage(struct metapage *mp)
  36. {
  37. DECLARE_WAITQUEUE(wait, current);
  38. INCREMENT(mpStat.lockwait);
  39. add_wait_queue_exclusive(&mp->wait, &wait);
  40. do {
  41. set_current_state(TASK_UNINTERRUPTIBLE);
  42. if (metapage_locked(mp)) {
  43. unlock_page(mp->page);
  44. io_schedule();
  45. lock_page(mp->page);
  46. }
  47. } while (trylock_metapage(mp));
  48. __set_current_state(TASK_RUNNING);
  49. remove_wait_queue(&mp->wait, &wait);
  50. }
  51. /*
  52. * Must have mp->page locked
  53. */
  54. static inline void lock_metapage(struct metapage *mp)
  55. {
  56. if (trylock_metapage(mp))
  57. __lock_metapage(mp);
  58. }
  59. #define METAPOOL_MIN_PAGES 32
  60. static struct kmem_cache *metapage_cache;
  61. static mempool_t *metapage_mempool;
  62. #define MPS_PER_PAGE (PAGE_SIZE >> L2PSIZE)
  63. #if MPS_PER_PAGE > 1
  64. struct meta_anchor {
  65. int mp_count;
  66. atomic_t io_count;
  67. struct metapage *mp[MPS_PER_PAGE];
  68. };
  69. #define mp_anchor(page) ((struct meta_anchor *)page_private(page))
  70. static inline struct metapage *page_to_mp(struct page *page, int offset)
  71. {
  72. if (!PagePrivate(page))
  73. return NULL;
  74. return mp_anchor(page)->mp[offset >> L2PSIZE];
  75. }
  76. static inline int insert_metapage(struct page *page, struct metapage *mp)
  77. {
  78. struct meta_anchor *a;
  79. int index;
  80. int l2mp_blocks; /* log2 blocks per metapage */
  81. if (PagePrivate(page))
  82. a = mp_anchor(page);
  83. else {
  84. a = kzalloc(sizeof(struct meta_anchor), GFP_NOFS);
  85. if (!a)
  86. return -ENOMEM;
  87. set_page_private(page, (unsigned long)a);
  88. SetPagePrivate(page);
  89. kmap(page);
  90. }
  91. if (mp) {
  92. l2mp_blocks = L2PSIZE - page->mapping->host->i_blkbits;
  93. index = (mp->index >> l2mp_blocks) & (MPS_PER_PAGE - 1);
  94. a->mp_count++;
  95. a->mp[index] = mp;
  96. }
  97. return 0;
  98. }
  99. static inline void remove_metapage(struct page *page, struct metapage *mp)
  100. {
  101. struct meta_anchor *a = mp_anchor(page);
  102. int l2mp_blocks = L2PSIZE - page->mapping->host->i_blkbits;
  103. int index;
  104. index = (mp->index >> l2mp_blocks) & (MPS_PER_PAGE - 1);
  105. BUG_ON(a->mp[index] != mp);
  106. a->mp[index] = NULL;
  107. if (--a->mp_count == 0) {
  108. kfree(a);
  109. set_page_private(page, 0);
  110. ClearPagePrivate(page);
  111. kunmap(page);
  112. }
  113. }
  114. static inline void inc_io(struct page *page)
  115. {
  116. atomic_inc(&mp_anchor(page)->io_count);
  117. }
  118. static inline void dec_io(struct page *page, void (*handler) (struct page *))
  119. {
  120. if (atomic_dec_and_test(&mp_anchor(page)->io_count))
  121. handler(page);
  122. }
  123. #else
  124. static inline struct metapage *page_to_mp(struct page *page, int offset)
  125. {
  126. return PagePrivate(page) ? (struct metapage *)page_private(page) : NULL;
  127. }
  128. static inline int insert_metapage(struct page *page, struct metapage *mp)
  129. {
  130. if (mp) {
  131. set_page_private(page, (unsigned long)mp);
  132. SetPagePrivate(page);
  133. kmap(page);
  134. }
  135. return 0;
  136. }
  137. static inline void remove_metapage(struct page *page, struct metapage *mp)
  138. {
  139. set_page_private(page, 0);
  140. ClearPagePrivate(page);
  141. kunmap(page);
  142. }
  143. #define inc_io(page) do {} while(0)
  144. #define dec_io(page, handler) handler(page)
  145. #endif
  146. static inline struct metapage *alloc_metapage(gfp_t gfp_mask)
  147. {
  148. struct metapage *mp = mempool_alloc(metapage_mempool, gfp_mask);
  149. if (mp) {
  150. mp->lid = 0;
  151. mp->lsn = 0;
  152. mp->data = NULL;
  153. mp->clsn = 0;
  154. mp->log = NULL;
  155. init_waitqueue_head(&mp->wait);
  156. }
  157. return mp;
  158. }
  159. static inline void free_metapage(struct metapage *mp)
  160. {
  161. mempool_free(mp, metapage_mempool);
  162. }
  163. int __init metapage_init(void)
  164. {
  165. /*
  166. * Allocate the metapage structures
  167. */
  168. metapage_cache = kmem_cache_create("jfs_mp", sizeof(struct metapage),
  169. 0, 0, NULL);
  170. if (metapage_cache == NULL)
  171. return -ENOMEM;
  172. metapage_mempool = mempool_create_slab_pool(METAPOOL_MIN_PAGES,
  173. metapage_cache);
  174. if (metapage_mempool == NULL) {
  175. kmem_cache_destroy(metapage_cache);
  176. return -ENOMEM;
  177. }
  178. return 0;
  179. }
  180. void metapage_exit(void)
  181. {
  182. mempool_destroy(metapage_mempool);
  183. kmem_cache_destroy(metapage_cache);
  184. }
  185. static inline void drop_metapage(struct page *page, struct metapage *mp)
  186. {
  187. if (mp->count || mp->nohomeok || test_bit(META_dirty, &mp->flag) ||
  188. test_bit(META_io, &mp->flag))
  189. return;
  190. remove_metapage(page, mp);
  191. INCREMENT(mpStat.pagefree);
  192. free_metapage(mp);
  193. }
  194. /*
  195. * Metapage address space operations
  196. */
  197. static sector_t metapage_get_blocks(struct inode *inode, sector_t lblock,
  198. int *len)
  199. {
  200. int rc = 0;
  201. int xflag;
  202. s64 xaddr;
  203. sector_t file_blocks = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
  204. inode->i_blkbits;
  205. if (lblock >= file_blocks)
  206. return 0;
  207. if (lblock + *len > file_blocks)
  208. *len = file_blocks - lblock;
  209. if (inode->i_ino) {
  210. rc = xtLookup(inode, (s64)lblock, *len, &xflag, &xaddr, len, 0);
  211. if ((rc == 0) && *len)
  212. lblock = (sector_t)xaddr;
  213. else
  214. lblock = 0;
  215. } /* else no mapping */
  216. return lblock;
  217. }
  218. static void last_read_complete(struct page *page)
  219. {
  220. if (!PageError(page))
  221. SetPageUptodate(page);
  222. unlock_page(page);
  223. }
  224. static void metapage_read_end_io(struct bio *bio)
  225. {
  226. struct page *page = bio->bi_private;
  227. if (bio->bi_status) {
  228. printk(KERN_ERR "metapage_read_end_io: I/O error\n");
  229. SetPageError(page);
  230. }
  231. dec_io(page, last_read_complete);
  232. bio_put(bio);
  233. }
  234. static void remove_from_logsync(struct metapage *mp)
  235. {
  236. struct jfs_log *log = mp->log;
  237. unsigned long flags;
  238. /*
  239. * This can race. Recheck that log hasn't been set to null, and after
  240. * acquiring logsync lock, recheck lsn
  241. */
  242. if (!log)
  243. return;
  244. LOGSYNC_LOCK(log, flags);
  245. if (mp->lsn) {
  246. mp->log = NULL;
  247. mp->lsn = 0;
  248. mp->clsn = 0;
  249. log->count--;
  250. list_del(&mp->synclist);
  251. }
  252. LOGSYNC_UNLOCK(log, flags);
  253. }
  254. static void last_write_complete(struct page *page)
  255. {
  256. struct metapage *mp;
  257. unsigned int offset;
  258. for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) {
  259. mp = page_to_mp(page, offset);
  260. if (mp && test_bit(META_io, &mp->flag)) {
  261. if (mp->lsn)
  262. remove_from_logsync(mp);
  263. clear_bit(META_io, &mp->flag);
  264. }
  265. /*
  266. * I'd like to call drop_metapage here, but I don't think it's
  267. * safe unless I have the page locked
  268. */
  269. }
  270. end_page_writeback(page);
  271. }
  272. static void metapage_write_end_io(struct bio *bio)
  273. {
  274. struct page *page = bio->bi_private;
  275. BUG_ON(!PagePrivate(page));
  276. if (bio->bi_status) {
  277. printk(KERN_ERR "metapage_write_end_io: I/O error\n");
  278. SetPageError(page);
  279. }
  280. dec_io(page, last_write_complete);
  281. bio_put(bio);
  282. }
  283. static int metapage_writepage(struct page *page, struct writeback_control *wbc)
  284. {
  285. struct bio *bio = NULL;
  286. int block_offset; /* block offset of mp within page */
  287. struct inode *inode = page->mapping->host;
  288. int blocks_per_mp = JFS_SBI(inode->i_sb)->nbperpage;
  289. int len;
  290. int xlen;
  291. struct metapage *mp;
  292. int redirty = 0;
  293. sector_t lblock;
  294. int nr_underway = 0;
  295. sector_t pblock;
  296. sector_t next_block = 0;
  297. sector_t page_start;
  298. unsigned long bio_bytes = 0;
  299. unsigned long bio_offset = 0;
  300. int offset;
  301. int bad_blocks = 0;
  302. page_start = (sector_t)page->index <<
  303. (PAGE_SHIFT - inode->i_blkbits);
  304. BUG_ON(!PageLocked(page));
  305. BUG_ON(PageWriteback(page));
  306. set_page_writeback(page);
  307. for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) {
  308. mp = page_to_mp(page, offset);
  309. if (!mp || !test_bit(META_dirty, &mp->flag))
  310. continue;
  311. if (mp->nohomeok && !test_bit(META_forcewrite, &mp->flag)) {
  312. redirty = 1;
  313. /*
  314. * Make sure this page isn't blocked indefinitely.
  315. * If the journal isn't undergoing I/O, push it
  316. */
  317. if (mp->log && !(mp->log->cflag & logGC_PAGEOUT))
  318. jfs_flush_journal(mp->log, 0);
  319. continue;
  320. }
  321. clear_bit(META_dirty, &mp->flag);
  322. set_bit(META_io, &mp->flag);
  323. block_offset = offset >> inode->i_blkbits;
  324. lblock = page_start + block_offset;
  325. if (bio) {
  326. if (xlen && lblock == next_block) {
  327. /* Contiguous, in memory & on disk */
  328. len = min(xlen, blocks_per_mp);
  329. xlen -= len;
  330. bio_bytes += len << inode->i_blkbits;
  331. continue;
  332. }
  333. /* Not contiguous */
  334. if (bio_add_page(bio, page, bio_bytes, bio_offset) <
  335. bio_bytes)
  336. goto add_failed;
  337. /*
  338. * Increment counter before submitting i/o to keep
  339. * count from hitting zero before we're through
  340. */
  341. inc_io(page);
  342. if (!bio->bi_iter.bi_size)
  343. goto dump_bio;
  344. submit_bio(bio);
  345. nr_underway++;
  346. bio = NULL;
  347. } else
  348. inc_io(page);
  349. xlen = (PAGE_SIZE - offset) >> inode->i_blkbits;
  350. pblock = metapage_get_blocks(inode, lblock, &xlen);
  351. if (!pblock) {
  352. printk(KERN_ERR "JFS: metapage_get_blocks failed\n");
  353. /*
  354. * We already called inc_io(), but can't cancel it
  355. * with dec_io() until we're done with the page
  356. */
  357. bad_blocks++;
  358. continue;
  359. }
  360. len = min(xlen, (int)JFS_SBI(inode->i_sb)->nbperpage);
  361. bio = bio_alloc(GFP_NOFS, 1);
  362. bio_set_dev(bio, inode->i_sb->s_bdev);
  363. bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9);
  364. bio->bi_end_io = metapage_write_end_io;
  365. bio->bi_private = page;
  366. bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
  367. /* Don't call bio_add_page yet, we may add to this vec */
  368. bio_offset = offset;
  369. bio_bytes = len << inode->i_blkbits;
  370. xlen -= len;
  371. next_block = lblock + len;
  372. }
  373. if (bio) {
  374. if (bio_add_page(bio, page, bio_bytes, bio_offset) < bio_bytes)
  375. goto add_failed;
  376. if (!bio->bi_iter.bi_size)
  377. goto dump_bio;
  378. submit_bio(bio);
  379. nr_underway++;
  380. }
  381. if (redirty)
  382. redirty_page_for_writepage(wbc, page);
  383. unlock_page(page);
  384. if (bad_blocks)
  385. goto err_out;
  386. if (nr_underway == 0)
  387. end_page_writeback(page);
  388. return 0;
  389. add_failed:
  390. /* We should never reach here, since we're only adding one vec */
  391. printk(KERN_ERR "JFS: bio_add_page failed unexpectedly\n");
  392. goto skip;
  393. dump_bio:
  394. print_hex_dump(KERN_ERR, "JFS: dump of bio: ", DUMP_PREFIX_ADDRESS, 16,
  395. 4, bio, sizeof(*bio), 0);
  396. skip:
  397. bio_put(bio);
  398. unlock_page(page);
  399. dec_io(page, last_write_complete);
  400. err_out:
  401. while (bad_blocks--)
  402. dec_io(page, last_write_complete);
  403. return -EIO;
  404. }
  405. static int metapage_readpage(struct file *fp, struct page *page)
  406. {
  407. struct inode *inode = page->mapping->host;
  408. struct bio *bio = NULL;
  409. int block_offset;
  410. int blocks_per_page = i_blocks_per_page(inode, page);
  411. sector_t page_start; /* address of page in fs blocks */
  412. sector_t pblock;
  413. int xlen;
  414. unsigned int len;
  415. int offset;
  416. BUG_ON(!PageLocked(page));
  417. page_start = (sector_t)page->index <<
  418. (PAGE_SHIFT - inode->i_blkbits);
  419. block_offset = 0;
  420. while (block_offset < blocks_per_page) {
  421. xlen = blocks_per_page - block_offset;
  422. pblock = metapage_get_blocks(inode, page_start + block_offset,
  423. &xlen);
  424. if (pblock) {
  425. if (!PagePrivate(page))
  426. insert_metapage(page, NULL);
  427. inc_io(page);
  428. if (bio)
  429. submit_bio(bio);
  430. bio = bio_alloc(GFP_NOFS, 1);
  431. bio_set_dev(bio, inode->i_sb->s_bdev);
  432. bio->bi_iter.bi_sector =
  433. pblock << (inode->i_blkbits - 9);
  434. bio->bi_end_io = metapage_read_end_io;
  435. bio->bi_private = page;
  436. bio_set_op_attrs(bio, REQ_OP_READ, 0);
  437. len = xlen << inode->i_blkbits;
  438. offset = block_offset << inode->i_blkbits;
  439. if (bio_add_page(bio, page, len, offset) < len)
  440. goto add_failed;
  441. block_offset += xlen;
  442. } else
  443. block_offset++;
  444. }
  445. if (bio)
  446. submit_bio(bio);
  447. else
  448. unlock_page(page);
  449. return 0;
  450. add_failed:
  451. printk(KERN_ERR "JFS: bio_add_page failed unexpectedly\n");
  452. bio_put(bio);
  453. dec_io(page, last_read_complete);
  454. return -EIO;
  455. }
  456. static int metapage_releasepage(struct page *page, gfp_t gfp_mask)
  457. {
  458. struct metapage *mp;
  459. int ret = 1;
  460. int offset;
  461. for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) {
  462. mp = page_to_mp(page, offset);
  463. if (!mp)
  464. continue;
  465. jfs_info("metapage_releasepage: mp = 0x%p", mp);
  466. if (mp->count || mp->nohomeok ||
  467. test_bit(META_dirty, &mp->flag)) {
  468. jfs_info("count = %ld, nohomeok = %d", mp->count,
  469. mp->nohomeok);
  470. ret = 0;
  471. continue;
  472. }
  473. if (mp->lsn)
  474. remove_from_logsync(mp);
  475. remove_metapage(page, mp);
  476. INCREMENT(mpStat.pagefree);
  477. free_metapage(mp);
  478. }
  479. return ret;
  480. }
  481. static void metapage_invalidatepage(struct page *page, unsigned int offset,
  482. unsigned int length)
  483. {
  484. BUG_ON(offset || length < PAGE_SIZE);
  485. BUG_ON(PageWriteback(page));
  486. metapage_releasepage(page, 0);
  487. }
  488. const struct address_space_operations jfs_metapage_aops = {
  489. .readpage = metapage_readpage,
  490. .writepage = metapage_writepage,
  491. .releasepage = metapage_releasepage,
  492. .invalidatepage = metapage_invalidatepage,
  493. .set_page_dirty = __set_page_dirty_nobuffers,
  494. };
  495. struct metapage *__get_metapage(struct inode *inode, unsigned long lblock,
  496. unsigned int size, int absolute,
  497. unsigned long new)
  498. {
  499. int l2BlocksPerPage;
  500. int l2bsize;
  501. struct address_space *mapping;
  502. struct metapage *mp = NULL;
  503. struct page *page;
  504. unsigned long page_index;
  505. unsigned long page_offset;
  506. jfs_info("__get_metapage: ino = %ld, lblock = 0x%lx, abs=%d",
  507. inode->i_ino, lblock, absolute);
  508. l2bsize = inode->i_blkbits;
  509. l2BlocksPerPage = PAGE_SHIFT - l2bsize;
  510. page_index = lblock >> l2BlocksPerPage;
  511. page_offset = (lblock - (page_index << l2BlocksPerPage)) << l2bsize;
  512. if ((page_offset + size) > PAGE_SIZE) {
  513. jfs_err("MetaData crosses page boundary!!");
  514. jfs_err("lblock = %lx, size = %d", lblock, size);
  515. dump_stack();
  516. return NULL;
  517. }
  518. if (absolute)
  519. mapping = JFS_SBI(inode->i_sb)->direct_inode->i_mapping;
  520. else {
  521. /*
  522. * If an nfs client tries to read an inode that is larger
  523. * than any existing inodes, we may try to read past the
  524. * end of the inode map
  525. */
  526. if ((lblock << inode->i_blkbits) >= inode->i_size)
  527. return NULL;
  528. mapping = inode->i_mapping;
  529. }
  530. if (new && (PSIZE == PAGE_SIZE)) {
  531. page = grab_cache_page(mapping, page_index);
  532. if (!page) {
  533. jfs_err("grab_cache_page failed!");
  534. return NULL;
  535. }
  536. SetPageUptodate(page);
  537. } else {
  538. page = read_mapping_page(mapping, page_index, NULL);
  539. if (IS_ERR(page) || !PageUptodate(page)) {
  540. jfs_err("read_mapping_page failed!");
  541. return NULL;
  542. }
  543. lock_page(page);
  544. }
  545. mp = page_to_mp(page, page_offset);
  546. if (mp) {
  547. if (mp->logical_size != size) {
  548. jfs_error(inode->i_sb,
  549. "get_mp->logical_size != size\n");
  550. jfs_err("logical_size = %d, size = %d",
  551. mp->logical_size, size);
  552. dump_stack();
  553. goto unlock;
  554. }
  555. mp->count++;
  556. lock_metapage(mp);
  557. if (test_bit(META_discard, &mp->flag)) {
  558. if (!new) {
  559. jfs_error(inode->i_sb,
  560. "using a discarded metapage\n");
  561. discard_metapage(mp);
  562. goto unlock;
  563. }
  564. clear_bit(META_discard, &mp->flag);
  565. }
  566. } else {
  567. INCREMENT(mpStat.pagealloc);
  568. mp = alloc_metapage(GFP_NOFS);
  569. if (!mp)
  570. goto unlock;
  571. mp->page = page;
  572. mp->sb = inode->i_sb;
  573. mp->flag = 0;
  574. mp->xflag = COMMIT_PAGE;
  575. mp->count = 1;
  576. mp->nohomeok = 0;
  577. mp->logical_size = size;
  578. mp->data = page_address(page) + page_offset;
  579. mp->index = lblock;
  580. if (unlikely(insert_metapage(page, mp))) {
  581. free_metapage(mp);
  582. goto unlock;
  583. }
  584. lock_metapage(mp);
  585. }
  586. if (new) {
  587. jfs_info("zeroing mp = 0x%p", mp);
  588. memset(mp->data, 0, PSIZE);
  589. }
  590. unlock_page(page);
  591. jfs_info("__get_metapage: returning = 0x%p data = 0x%p", mp, mp->data);
  592. return mp;
  593. unlock:
  594. unlock_page(page);
  595. return NULL;
  596. }
  597. void grab_metapage(struct metapage * mp)
  598. {
  599. jfs_info("grab_metapage: mp = 0x%p", mp);
  600. get_page(mp->page);
  601. lock_page(mp->page);
  602. mp->count++;
  603. lock_metapage(mp);
  604. unlock_page(mp->page);
  605. }
  606. void force_metapage(struct metapage *mp)
  607. {
  608. struct page *page = mp->page;
  609. jfs_info("force_metapage: mp = 0x%p", mp);
  610. set_bit(META_forcewrite, &mp->flag);
  611. clear_bit(META_sync, &mp->flag);
  612. get_page(page);
  613. lock_page(page);
  614. set_page_dirty(page);
  615. if (write_one_page(page))
  616. jfs_error(mp->sb, "write_one_page() failed\n");
  617. clear_bit(META_forcewrite, &mp->flag);
  618. put_page(page);
  619. }
  620. void hold_metapage(struct metapage *mp)
  621. {
  622. lock_page(mp->page);
  623. }
  624. void put_metapage(struct metapage *mp)
  625. {
  626. if (mp->count || mp->nohomeok) {
  627. /* Someone else will release this */
  628. unlock_page(mp->page);
  629. return;
  630. }
  631. get_page(mp->page);
  632. mp->count++;
  633. lock_metapage(mp);
  634. unlock_page(mp->page);
  635. release_metapage(mp);
  636. }
  637. void release_metapage(struct metapage * mp)
  638. {
  639. struct page *page = mp->page;
  640. jfs_info("release_metapage: mp = 0x%p, flag = 0x%lx", mp, mp->flag);
  641. BUG_ON(!page);
  642. lock_page(page);
  643. unlock_metapage(mp);
  644. assert(mp->count);
  645. if (--mp->count || mp->nohomeok) {
  646. unlock_page(page);
  647. put_page(page);
  648. return;
  649. }
  650. if (test_bit(META_dirty, &mp->flag)) {
  651. set_page_dirty(page);
  652. if (test_bit(META_sync, &mp->flag)) {
  653. clear_bit(META_sync, &mp->flag);
  654. if (write_one_page(page))
  655. jfs_error(mp->sb, "write_one_page() failed\n");
  656. lock_page(page); /* write_one_page unlocks the page */
  657. }
  658. } else if (mp->lsn) /* discard_metapage doesn't remove it */
  659. remove_from_logsync(mp);
  660. /* Try to keep metapages from using up too much memory */
  661. drop_metapage(page, mp);
  662. unlock_page(page);
  663. put_page(page);
  664. }
  665. void __invalidate_metapages(struct inode *ip, s64 addr, int len)
  666. {
  667. sector_t lblock;
  668. int l2BlocksPerPage = PAGE_SHIFT - ip->i_blkbits;
  669. int BlocksPerPage = 1 << l2BlocksPerPage;
  670. /* All callers are interested in block device's mapping */
  671. struct address_space *mapping =
  672. JFS_SBI(ip->i_sb)->direct_inode->i_mapping;
  673. struct metapage *mp;
  674. struct page *page;
  675. unsigned int offset;
  676. /*
  677. * Mark metapages to discard. They will eventually be
  678. * released, but should not be written.
  679. */
  680. for (lblock = addr & ~(BlocksPerPage - 1); lblock < addr + len;
  681. lblock += BlocksPerPage) {
  682. page = find_lock_page(mapping, lblock >> l2BlocksPerPage);
  683. if (!page)
  684. continue;
  685. for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) {
  686. mp = page_to_mp(page, offset);
  687. if (!mp)
  688. continue;
  689. if (mp->index < addr)
  690. continue;
  691. if (mp->index >= addr + len)
  692. break;
  693. clear_bit(META_dirty, &mp->flag);
  694. set_bit(META_discard, &mp->flag);
  695. if (mp->lsn)
  696. remove_from_logsync(mp);
  697. }
  698. unlock_page(page);
  699. put_page(page);
  700. }
  701. }
  702. #ifdef CONFIG_JFS_STATISTICS
  703. int jfs_mpstat_proc_show(struct seq_file *m, void *v)
  704. {
  705. seq_printf(m,
  706. "JFS Metapage statistics\n"
  707. "=======================\n"
  708. "page allocations = %d\n"
  709. "page frees = %d\n"
  710. "lock waits = %d\n",
  711. mpStat.pagealloc,
  712. mpStat.pagefree,
  713. mpStat.lockwait);
  714. return 0;
  715. }
  716. #endif