jfs_metapage.c 20 KB

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