meta_io.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403
  1. /*
  2. * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
  3. * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
  4. *
  5. * This copyrighted material is made available to anyone wishing to use,
  6. * modify, copy, or redistribute it subject to the terms and conditions
  7. * of the GNU General Public License version 2.
  8. */
  9. #include <linux/sched.h>
  10. #include <linux/slab.h>
  11. #include <linux/spinlock.h>
  12. #include <linux/completion.h>
  13. #include <linux/buffer_head.h>
  14. #include <linux/mm.h>
  15. #include <linux/pagemap.h>
  16. #include <linux/writeback.h>
  17. #include <linux/swap.h>
  18. #include <linux/delay.h>
  19. #include <linux/bio.h>
  20. #include <linux/gfs2_ondisk.h>
  21. #include "gfs2.h"
  22. #include "incore.h"
  23. #include "glock.h"
  24. #include "glops.h"
  25. #include "inode.h"
  26. #include "log.h"
  27. #include "lops.h"
  28. #include "meta_io.h"
  29. #include "rgrp.h"
  30. #include "trans.h"
  31. #include "util.h"
  32. #include "trace_gfs2.h"
  33. static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
  34. {
  35. struct buffer_head *bh, *head;
  36. int nr_underway = 0;
  37. int write_op = REQ_META | REQ_PRIO |
  38. (wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE);
  39. BUG_ON(!PageLocked(page));
  40. BUG_ON(!page_has_buffers(page));
  41. head = page_buffers(page);
  42. bh = head;
  43. do {
  44. if (!buffer_mapped(bh))
  45. continue;
  46. /*
  47. * If it's a fully non-blocking write attempt and we cannot
  48. * lock the buffer then redirty the page. Note that this can
  49. * potentially cause a busy-wait loop from flusher thread and kswapd
  50. * activity, but those code paths have their own higher-level
  51. * throttling.
  52. */
  53. if (wbc->sync_mode != WB_SYNC_NONE) {
  54. lock_buffer(bh);
  55. } else if (!trylock_buffer(bh)) {
  56. redirty_page_for_writepage(wbc, page);
  57. continue;
  58. }
  59. if (test_clear_buffer_dirty(bh)) {
  60. mark_buffer_async_write(bh);
  61. } else {
  62. unlock_buffer(bh);
  63. }
  64. } while ((bh = bh->b_this_page) != head);
  65. /*
  66. * The page and its buffers are protected by PageWriteback(), so we can
  67. * drop the bh refcounts early.
  68. */
  69. BUG_ON(PageWriteback(page));
  70. set_page_writeback(page);
  71. do {
  72. struct buffer_head *next = bh->b_this_page;
  73. if (buffer_async_write(bh)) {
  74. submit_bh(write_op, bh);
  75. nr_underway++;
  76. }
  77. bh = next;
  78. } while (bh != head);
  79. unlock_page(page);
  80. if (nr_underway == 0)
  81. end_page_writeback(page);
  82. return 0;
  83. }
  84. const struct address_space_operations gfs2_meta_aops = {
  85. .writepage = gfs2_aspace_writepage,
  86. .releasepage = gfs2_releasepage,
  87. };
  88. const struct address_space_operations gfs2_rgrp_aops = {
  89. .writepage = gfs2_aspace_writepage,
  90. .releasepage = gfs2_releasepage,
  91. };
  92. /**
  93. * gfs2_getbuf - Get a buffer with a given address space
  94. * @gl: the glock
  95. * @blkno: the block number (filesystem scope)
  96. * @create: 1 if the buffer should be created
  97. *
  98. * Returns: the buffer
  99. */
  100. struct buffer_head *gfs2_getbuf(struct gfs2_glock *gl, u64 blkno, int create)
  101. {
  102. struct address_space *mapping = gfs2_glock2aspace(gl);
  103. struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
  104. struct page *page;
  105. struct buffer_head *bh;
  106. unsigned int shift;
  107. unsigned long index;
  108. unsigned int bufnum;
  109. if (mapping == NULL)
  110. mapping = &sdp->sd_aspace;
  111. shift = PAGE_CACHE_SHIFT - sdp->sd_sb.sb_bsize_shift;
  112. index = blkno >> shift; /* convert block to page */
  113. bufnum = blkno - (index << shift); /* block buf index within page */
  114. if (create) {
  115. for (;;) {
  116. page = grab_cache_page(mapping, index);
  117. if (page)
  118. break;
  119. yield();
  120. }
  121. } else {
  122. page = find_get_page_flags(mapping, index,
  123. FGP_LOCK|FGP_ACCESSED);
  124. if (!page)
  125. return NULL;
  126. }
  127. if (!page_has_buffers(page))
  128. create_empty_buffers(page, sdp->sd_sb.sb_bsize, 0);
  129. /* Locate header for our buffer within our page */
  130. for (bh = page_buffers(page); bufnum--; bh = bh->b_this_page)
  131. /* Do nothing */;
  132. get_bh(bh);
  133. if (!buffer_mapped(bh))
  134. map_bh(bh, sdp->sd_vfs, blkno);
  135. unlock_page(page);
  136. page_cache_release(page);
  137. return bh;
  138. }
  139. static void meta_prep_new(struct buffer_head *bh)
  140. {
  141. struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
  142. lock_buffer(bh);
  143. clear_buffer_dirty(bh);
  144. set_buffer_uptodate(bh);
  145. unlock_buffer(bh);
  146. mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
  147. }
  148. /**
  149. * gfs2_meta_new - Get a block
  150. * @gl: The glock associated with this block
  151. * @blkno: The block number
  152. *
  153. * Returns: The buffer
  154. */
  155. struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
  156. {
  157. struct buffer_head *bh;
  158. bh = gfs2_getbuf(gl, blkno, CREATE);
  159. meta_prep_new(bh);
  160. return bh;
  161. }
  162. /**
  163. * gfs2_meta_read - Read a block from disk
  164. * @gl: The glock covering the block
  165. * @blkno: The block number
  166. * @flags: flags
  167. * @bhp: the place where the buffer is returned (NULL on failure)
  168. *
  169. * Returns: errno
  170. */
  171. int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
  172. struct buffer_head **bhp)
  173. {
  174. struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
  175. struct buffer_head *bh;
  176. if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
  177. *bhp = NULL;
  178. return -EIO;
  179. }
  180. *bhp = bh = gfs2_getbuf(gl, blkno, CREATE);
  181. lock_buffer(bh);
  182. if (buffer_uptodate(bh)) {
  183. unlock_buffer(bh);
  184. return 0;
  185. }
  186. bh->b_end_io = end_buffer_read_sync;
  187. get_bh(bh);
  188. submit_bh(READ_SYNC | REQ_META | REQ_PRIO, bh);
  189. if (!(flags & DIO_WAIT))
  190. return 0;
  191. wait_on_buffer(bh);
  192. if (unlikely(!buffer_uptodate(bh))) {
  193. struct gfs2_trans *tr = current->journal_info;
  194. if (tr && tr->tr_touched)
  195. gfs2_io_error_bh(sdp, bh);
  196. brelse(bh);
  197. *bhp = NULL;
  198. return -EIO;
  199. }
  200. return 0;
  201. }
  202. /**
  203. * gfs2_meta_wait - Reread a block from disk
  204. * @sdp: the filesystem
  205. * @bh: The block to wait for
  206. *
  207. * Returns: errno
  208. */
  209. int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
  210. {
  211. if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
  212. return -EIO;
  213. wait_on_buffer(bh);
  214. if (!buffer_uptodate(bh)) {
  215. struct gfs2_trans *tr = current->journal_info;
  216. if (tr && tr->tr_touched)
  217. gfs2_io_error_bh(sdp, bh);
  218. return -EIO;
  219. }
  220. if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
  221. return -EIO;
  222. return 0;
  223. }
  224. void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
  225. {
  226. struct address_space *mapping = bh->b_page->mapping;
  227. struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
  228. struct gfs2_bufdata *bd = bh->b_private;
  229. int was_pinned = 0;
  230. if (test_clear_buffer_pinned(bh)) {
  231. trace_gfs2_pin(bd, 0);
  232. atomic_dec(&sdp->sd_log_pinned);
  233. list_del_init(&bd->bd_list);
  234. if (meta)
  235. tr->tr_num_buf_rm++;
  236. else
  237. tr->tr_num_databuf_rm++;
  238. tr->tr_touched = 1;
  239. was_pinned = 1;
  240. brelse(bh);
  241. }
  242. if (bd) {
  243. spin_lock(&sdp->sd_ail_lock);
  244. if (bd->bd_tr) {
  245. gfs2_trans_add_revoke(sdp, bd);
  246. } else if (was_pinned) {
  247. bh->b_private = NULL;
  248. kmem_cache_free(gfs2_bufdata_cachep, bd);
  249. }
  250. spin_unlock(&sdp->sd_ail_lock);
  251. }
  252. clear_buffer_dirty(bh);
  253. clear_buffer_uptodate(bh);
  254. }
  255. /**
  256. * gfs2_meta_wipe - make inode's buffers so they aren't dirty/pinned anymore
  257. * @ip: the inode who owns the buffers
  258. * @bstart: the first buffer in the run
  259. * @blen: the number of buffers in the run
  260. *
  261. */
  262. void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
  263. {
  264. struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
  265. struct buffer_head *bh;
  266. while (blen) {
  267. bh = gfs2_getbuf(ip->i_gl, bstart, NO_CREATE);
  268. if (bh) {
  269. lock_buffer(bh);
  270. gfs2_log_lock(sdp);
  271. gfs2_remove_from_journal(bh, current->journal_info, 1);
  272. gfs2_log_unlock(sdp);
  273. unlock_buffer(bh);
  274. brelse(bh);
  275. }
  276. bstart++;
  277. blen--;
  278. }
  279. }
  280. /**
  281. * gfs2_meta_indirect_buffer - Get a metadata buffer
  282. * @ip: The GFS2 inode
  283. * @height: The level of this buf in the metadata (indir addr) tree (if any)
  284. * @num: The block number (device relative) of the buffer
  285. * @bhp: the buffer is returned here
  286. *
  287. * Returns: errno
  288. */
  289. int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
  290. struct buffer_head **bhp)
  291. {
  292. struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
  293. struct gfs2_glock *gl = ip->i_gl;
  294. struct buffer_head *bh;
  295. int ret = 0;
  296. u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
  297. ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
  298. if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
  299. brelse(bh);
  300. ret = -EIO;
  301. }
  302. *bhp = bh;
  303. return ret;
  304. }
  305. /**
  306. * gfs2_meta_ra - start readahead on an extent of a file
  307. * @gl: the glock the blocks belong to
  308. * @dblock: the starting disk block
  309. * @extlen: the number of blocks in the extent
  310. *
  311. * returns: the first buffer in the extent
  312. */
  313. struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
  314. {
  315. struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
  316. struct buffer_head *first_bh, *bh;
  317. u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
  318. sdp->sd_sb.sb_bsize_shift;
  319. BUG_ON(!extlen);
  320. if (max_ra < 1)
  321. max_ra = 1;
  322. if (extlen > max_ra)
  323. extlen = max_ra;
  324. first_bh = gfs2_getbuf(gl, dblock, CREATE);
  325. if (buffer_uptodate(first_bh))
  326. goto out;
  327. if (!buffer_locked(first_bh))
  328. ll_rw_block(READ_SYNC | REQ_META, 1, &first_bh);
  329. dblock++;
  330. extlen--;
  331. while (extlen) {
  332. bh = gfs2_getbuf(gl, dblock, CREATE);
  333. if (!buffer_uptodate(bh) && !buffer_locked(bh))
  334. ll_rw_block(READA | REQ_META, 1, &bh);
  335. brelse(bh);
  336. dblock++;
  337. extlen--;
  338. if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
  339. goto out;
  340. }
  341. wait_on_buffer(first_bh);
  342. out:
  343. return first_bh;
  344. }