xfs_buf.h 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397
  1. /*
  2. * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #ifndef __XFS_BUF_H__
  19. #define __XFS_BUF_H__
  20. #include <linux/list.h>
  21. #include <linux/types.h>
  22. #include <linux/spinlock.h>
  23. #include <asm/system.h>
  24. #include <linux/mm.h>
  25. #include <linux/fs.h>
  26. #include <linux/buffer_head.h>
  27. #include <linux/uio.h>
  28. /*
  29. * Base types
  30. */
  31. #define XFS_BUF_DADDR_NULL ((xfs_daddr_t) (-1LL))
  32. #define xfs_buf_ctob(pp) ((pp) * PAGE_CACHE_SIZE)
  33. #define xfs_buf_btoc(dd) (((dd) + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT)
  34. #define xfs_buf_btoct(dd) ((dd) >> PAGE_CACHE_SHIFT)
  35. #define xfs_buf_poff(aa) ((aa) & ~PAGE_CACHE_MASK)
  36. typedef enum {
  37. XBRW_READ = 1, /* transfer into target memory */
  38. XBRW_WRITE = 2, /* transfer from target memory */
  39. XBRW_ZERO = 3, /* Zero target memory */
  40. } xfs_buf_rw_t;
  41. #define XBF_READ (1 << 0) /* buffer intended for reading from device */
  42. #define XBF_WRITE (1 << 1) /* buffer intended for writing to device */
  43. #define XBF_MAPPED (1 << 2) /* buffer mapped (b_addr valid) */
  44. #define XBF_ASYNC (1 << 4) /* initiator will not wait for completion */
  45. #define XBF_DONE (1 << 5) /* all pages in the buffer uptodate */
  46. #define XBF_DELWRI (1 << 6) /* buffer has dirty pages */
  47. #define XBF_STALE (1 << 7) /* buffer has been staled, do not find it */
  48. #define XBF_ORDERED (1 << 11)/* use ordered writes */
  49. #define XBF_READ_AHEAD (1 << 12)/* asynchronous read-ahead */
  50. #define XBF_LOG_BUFFER (1 << 13)/* this is a buffer used for the log */
  51. /* flags used only as arguments to access routines */
  52. #define XBF_LOCK (1 << 14)/* lock requested */
  53. #define XBF_TRYLOCK (1 << 15)/* lock requested, but do not wait */
  54. #define XBF_DONT_BLOCK (1 << 16)/* do not block in current thread */
  55. /* flags used only internally */
  56. #define _XBF_PAGE_CACHE (1 << 17)/* backed by pagecache */
  57. #define _XBF_PAGES (1 << 18)/* backed by refcounted pages */
  58. #define _XBF_RUN_QUEUES (1 << 19)/* run block device task queue */
  59. #define _XBF_DELWRI_Q (1 << 21)/* buffer on delwri queue */
  60. /*
  61. * Special flag for supporting metadata blocks smaller than a FSB.
  62. *
  63. * In this case we can have multiple xfs_buf_t on a single page and
  64. * need to lock out concurrent xfs_buf_t readers as they only
  65. * serialise access to the buffer.
  66. *
  67. * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
  68. * between reads of the page. Hence we can have one thread read the
  69. * page and modify it, but then race with another thread that thinks
  70. * the page is not up-to-date and hence reads it again.
  71. *
  72. * The result is that the first modifcation to the page is lost.
  73. * This sort of AGF/AGI reading race can happen when unlinking inodes
  74. * that require truncation and results in the AGI unlinked list
  75. * modifications being lost.
  76. */
  77. #define _XBF_PAGE_LOCKED (1 << 22)
  78. /*
  79. * If we try a barrier write, but it fails we have to communicate
  80. * this to the upper layers. Unfortunately b_error gets overwritten
  81. * when the buffer is re-issued so we have to add another flag to
  82. * keep this information.
  83. */
  84. #define _XFS_BARRIER_FAILED (1 << 23)
  85. typedef unsigned int xfs_buf_flags_t;
  86. #define XFS_BUF_FLAGS \
  87. { XBF_READ, "READ" }, \
  88. { XBF_WRITE, "WRITE" }, \
  89. { XBF_MAPPED, "MAPPED" }, \
  90. { XBF_ASYNC, "ASYNC" }, \
  91. { XBF_DONE, "DONE" }, \
  92. { XBF_DELWRI, "DELWRI" }, \
  93. { XBF_STALE, "STALE" }, \
  94. { XBF_ORDERED, "ORDERED" }, \
  95. { XBF_READ_AHEAD, "READ_AHEAD" }, \
  96. { XBF_LOCK, "LOCK" }, /* should never be set */\
  97. { XBF_TRYLOCK, "TRYLOCK" }, /* ditto */\
  98. { XBF_DONT_BLOCK, "DONT_BLOCK" }, /* ditto */\
  99. { _XBF_PAGE_CACHE, "PAGE_CACHE" }, \
  100. { _XBF_PAGES, "PAGES" }, \
  101. { _XBF_RUN_QUEUES, "RUN_QUEUES" }, \
  102. { _XBF_DELWRI_Q, "DELWRI_Q" }, \
  103. { _XBF_PAGE_LOCKED, "PAGE_LOCKED" }, \
  104. { _XFS_BARRIER_FAILED, "BARRIER_FAILED" }
  105. typedef enum {
  106. XBT_FORCE_SLEEP = 0,
  107. XBT_FORCE_FLUSH = 1,
  108. } xfs_buftarg_flags_t;
  109. typedef struct xfs_bufhash {
  110. struct list_head bh_list;
  111. spinlock_t bh_lock;
  112. } xfs_bufhash_t;
  113. typedef struct xfs_buftarg {
  114. dev_t bt_dev;
  115. struct block_device *bt_bdev;
  116. struct address_space *bt_mapping;
  117. struct xfs_mount *bt_mount;
  118. unsigned int bt_bsize;
  119. unsigned int bt_sshift;
  120. size_t bt_smask;
  121. /* per device delwri queue */
  122. struct task_struct *bt_task;
  123. struct list_head bt_list;
  124. struct list_head bt_delwrite_queue;
  125. spinlock_t bt_delwrite_lock;
  126. unsigned long bt_flags;
  127. } xfs_buftarg_t;
  128. /*
  129. * xfs_buf_t: Buffer structure for pagecache-based buffers
  130. *
  131. * This buffer structure is used by the pagecache buffer management routines
  132. * to refer to an assembly of pages forming a logical buffer.
  133. *
  134. * The buffer structure is used on a temporary basis only, and discarded when
  135. * released. The real data storage is recorded in the pagecache. Buffers are
  136. * hashed to the block device on which the file system resides.
  137. */
  138. struct xfs_buf;
  139. typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
  140. typedef void (*xfs_buf_relse_t)(struct xfs_buf *);
  141. typedef int (*xfs_buf_bdstrat_t)(struct xfs_buf *);
  142. #define XB_PAGES 2
  143. typedef struct xfs_buf {
  144. /*
  145. * first cacheline holds all the fields needed for an uncontended cache
  146. * hit to be fully processed. The semaphore straddles the cacheline
  147. * boundary, but the counter and lock sits on the first cacheline,
  148. * which is the only bit that is touched if we hit the semaphore
  149. * fast-path on locking.
  150. */
  151. struct rb_node b_rbnode; /* rbtree node */
  152. xfs_off_t b_file_offset; /* offset in file */
  153. size_t b_buffer_length;/* size of buffer in bytes */
  154. atomic_t b_hold; /* reference count */
  155. xfs_buf_flags_t b_flags; /* status flags */
  156. struct semaphore b_sema; /* semaphore for lockables */
  157. wait_queue_head_t b_waiters; /* unpin waiters */
  158. struct list_head b_list;
  159. struct xfs_perag *b_pag; /* contains rbtree root */
  160. xfs_buftarg_t *b_target; /* buffer target (device) */
  161. xfs_daddr_t b_bn; /* block number for I/O */
  162. size_t b_count_desired;/* desired transfer size */
  163. void *b_addr; /* virtual address of buffer */
  164. struct work_struct b_iodone_work;
  165. xfs_buf_iodone_t b_iodone; /* I/O completion function */
  166. xfs_buf_relse_t b_relse; /* releasing function */
  167. struct completion b_iowait; /* queue for I/O waiters */
  168. void *b_fspriv;
  169. void *b_fspriv2;
  170. struct page **b_pages; /* array of page pointers */
  171. struct page *b_page_array[XB_PAGES]; /* inline pages */
  172. unsigned long b_queuetime; /* time buffer was queued */
  173. atomic_t b_pin_count; /* pin count */
  174. atomic_t b_io_remaining; /* #outstanding I/O requests */
  175. unsigned int b_page_count; /* size of page array */
  176. unsigned int b_offset; /* page offset in first page */
  177. unsigned short b_error; /* error code on I/O */
  178. #ifdef XFS_BUF_LOCK_TRACKING
  179. int b_last_holder;
  180. #endif
  181. } xfs_buf_t;
  182. /* Finding and Reading Buffers */
  183. extern xfs_buf_t *_xfs_buf_find(xfs_buftarg_t *, xfs_off_t, size_t,
  184. xfs_buf_flags_t, xfs_buf_t *);
  185. #define xfs_incore(buftarg,blkno,len,lockit) \
  186. _xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
  187. extern xfs_buf_t *xfs_buf_get(xfs_buftarg_t *, xfs_off_t, size_t,
  188. xfs_buf_flags_t);
  189. extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t,
  190. xfs_buf_flags_t);
  191. extern xfs_buf_t *xfs_buf_get_empty(size_t, xfs_buftarg_t *);
  192. extern xfs_buf_t *xfs_buf_get_uncached(struct xfs_buftarg *, size_t, int);
  193. extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t);
  194. extern void xfs_buf_hold(xfs_buf_t *);
  195. extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t,
  196. xfs_buf_flags_t);
  197. struct xfs_buf *xfs_buf_read_uncached(struct xfs_mount *mp,
  198. struct xfs_buftarg *target,
  199. xfs_daddr_t daddr, size_t length, int flags);
  200. /* Releasing Buffers */
  201. extern void xfs_buf_free(xfs_buf_t *);
  202. extern void xfs_buf_rele(xfs_buf_t *);
  203. /* Locking and Unlocking Buffers */
  204. extern int xfs_buf_cond_lock(xfs_buf_t *);
  205. extern int xfs_buf_lock_value(xfs_buf_t *);
  206. extern void xfs_buf_lock(xfs_buf_t *);
  207. extern void xfs_buf_unlock(xfs_buf_t *);
  208. /* Buffer Read and Write Routines */
  209. extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp);
  210. extern void xfs_bdwrite(void *mp, xfs_buf_t *bp);
  211. extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
  212. extern int xfs_bdstrat_cb(struct xfs_buf *);
  213. extern void xfs_buf_ioend(xfs_buf_t *, int);
  214. extern void xfs_buf_ioerror(xfs_buf_t *, int);
  215. extern int xfs_buf_iorequest(xfs_buf_t *);
  216. extern int xfs_buf_iowait(xfs_buf_t *);
  217. extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
  218. xfs_buf_rw_t);
  219. static inline int xfs_buf_geterror(xfs_buf_t *bp)
  220. {
  221. return bp ? bp->b_error : ENOMEM;
  222. }
  223. /* Buffer Utility Routines */
  224. extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
  225. /* Delayed Write Buffer Routines */
  226. extern void xfs_buf_delwri_dequeue(xfs_buf_t *);
  227. extern void xfs_buf_delwri_promote(xfs_buf_t *);
  228. /* Buffer Daemon Setup Routines */
  229. extern int xfs_buf_init(void);
  230. extern void xfs_buf_terminate(void);
  231. #define xfs_buf_target_name(target) \
  232. ({ char __b[BDEVNAME_SIZE]; bdevname((target)->bt_bdev, __b); __b; })
  233. #define XFS_BUF_BFLAGS(bp) ((bp)->b_flags)
  234. #define XFS_BUF_ZEROFLAGS(bp) ((bp)->b_flags &= \
  235. ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI|XBF_ORDERED))
  236. #define XFS_BUF_STALE(bp) ((bp)->b_flags |= XBF_STALE)
  237. #define XFS_BUF_UNSTALE(bp) ((bp)->b_flags &= ~XBF_STALE)
  238. #define XFS_BUF_ISSTALE(bp) ((bp)->b_flags & XBF_STALE)
  239. #define XFS_BUF_SUPER_STALE(bp) do { \
  240. XFS_BUF_STALE(bp); \
  241. xfs_buf_delwri_dequeue(bp); \
  242. XFS_BUF_DONE(bp); \
  243. } while (0)
  244. #define XFS_BUF_DELAYWRITE(bp) ((bp)->b_flags |= XBF_DELWRI)
  245. #define XFS_BUF_UNDELAYWRITE(bp) xfs_buf_delwri_dequeue(bp)
  246. #define XFS_BUF_ISDELAYWRITE(bp) ((bp)->b_flags & XBF_DELWRI)
  247. #define XFS_BUF_ERROR(bp,no) xfs_buf_ioerror(bp,no)
  248. #define XFS_BUF_GETERROR(bp) xfs_buf_geterror(bp)
  249. #define XFS_BUF_ISERROR(bp) (xfs_buf_geterror(bp) ? 1 : 0)
  250. #define XFS_BUF_DONE(bp) ((bp)->b_flags |= XBF_DONE)
  251. #define XFS_BUF_UNDONE(bp) ((bp)->b_flags &= ~XBF_DONE)
  252. #define XFS_BUF_ISDONE(bp) ((bp)->b_flags & XBF_DONE)
  253. #define XFS_BUF_BUSY(bp) do { } while (0)
  254. #define XFS_BUF_UNBUSY(bp) do { } while (0)
  255. #define XFS_BUF_ISBUSY(bp) (1)
  256. #define XFS_BUF_ASYNC(bp) ((bp)->b_flags |= XBF_ASYNC)
  257. #define XFS_BUF_UNASYNC(bp) ((bp)->b_flags &= ~XBF_ASYNC)
  258. #define XFS_BUF_ISASYNC(bp) ((bp)->b_flags & XBF_ASYNC)
  259. #define XFS_BUF_ORDERED(bp) ((bp)->b_flags |= XBF_ORDERED)
  260. #define XFS_BUF_UNORDERED(bp) ((bp)->b_flags &= ~XBF_ORDERED)
  261. #define XFS_BUF_ISORDERED(bp) ((bp)->b_flags & XBF_ORDERED)
  262. #define XFS_BUF_HOLD(bp) xfs_buf_hold(bp)
  263. #define XFS_BUF_READ(bp) ((bp)->b_flags |= XBF_READ)
  264. #define XFS_BUF_UNREAD(bp) ((bp)->b_flags &= ~XBF_READ)
  265. #define XFS_BUF_ISREAD(bp) ((bp)->b_flags & XBF_READ)
  266. #define XFS_BUF_WRITE(bp) ((bp)->b_flags |= XBF_WRITE)
  267. #define XFS_BUF_UNWRITE(bp) ((bp)->b_flags &= ~XBF_WRITE)
  268. #define XFS_BUF_ISWRITE(bp) ((bp)->b_flags & XBF_WRITE)
  269. #define XFS_BUF_IODONE_FUNC(bp) ((bp)->b_iodone)
  270. #define XFS_BUF_SET_IODONE_FUNC(bp, func) ((bp)->b_iodone = (func))
  271. #define XFS_BUF_CLR_IODONE_FUNC(bp) ((bp)->b_iodone = NULL)
  272. #define XFS_BUF_FSPRIVATE(bp, type) ((type)(bp)->b_fspriv)
  273. #define XFS_BUF_SET_FSPRIVATE(bp, val) ((bp)->b_fspriv = (void*)(val))
  274. #define XFS_BUF_FSPRIVATE2(bp, type) ((type)(bp)->b_fspriv2)
  275. #define XFS_BUF_SET_FSPRIVATE2(bp, val) ((bp)->b_fspriv2 = (void*)(val))
  276. #define XFS_BUF_SET_START(bp) do { } while (0)
  277. #define XFS_BUF_SET_BRELSE_FUNC(bp, func) ((bp)->b_relse = (func))
  278. #define XFS_BUF_PTR(bp) (xfs_caddr_t)((bp)->b_addr)
  279. #define XFS_BUF_SET_PTR(bp, val, cnt) xfs_buf_associate_memory(bp, val, cnt)
  280. #define XFS_BUF_ADDR(bp) ((bp)->b_bn)
  281. #define XFS_BUF_SET_ADDR(bp, bno) ((bp)->b_bn = (xfs_daddr_t)(bno))
  282. #define XFS_BUF_OFFSET(bp) ((bp)->b_file_offset)
  283. #define XFS_BUF_SET_OFFSET(bp, off) ((bp)->b_file_offset = (off))
  284. #define XFS_BUF_COUNT(bp) ((bp)->b_count_desired)
  285. #define XFS_BUF_SET_COUNT(bp, cnt) ((bp)->b_count_desired = (cnt))
  286. #define XFS_BUF_SIZE(bp) ((bp)->b_buffer_length)
  287. #define XFS_BUF_SET_SIZE(bp, cnt) ((bp)->b_buffer_length = (cnt))
  288. #define XFS_BUF_SET_VTYPE_REF(bp, type, ref) do { } while (0)
  289. #define XFS_BUF_SET_VTYPE(bp, type) do { } while (0)
  290. #define XFS_BUF_SET_REF(bp, ref) do { } while (0)
  291. #define XFS_BUF_ISPINNED(bp) atomic_read(&((bp)->b_pin_count))
  292. #define XFS_BUF_VALUSEMA(bp) xfs_buf_lock_value(bp)
  293. #define XFS_BUF_CPSEMA(bp) (xfs_buf_cond_lock(bp) == 0)
  294. #define XFS_BUF_VSEMA(bp) xfs_buf_unlock(bp)
  295. #define XFS_BUF_PSEMA(bp,x) xfs_buf_lock(bp)
  296. #define XFS_BUF_FINISH_IOWAIT(bp) complete(&bp->b_iowait);
  297. #define XFS_BUF_SET_TARGET(bp, target) ((bp)->b_target = (target))
  298. #define XFS_BUF_TARGET(bp) ((bp)->b_target)
  299. #define XFS_BUFTARG_NAME(target) xfs_buf_target_name(target)
  300. static inline void xfs_buf_relse(xfs_buf_t *bp)
  301. {
  302. if (!bp->b_relse)
  303. xfs_buf_unlock(bp);
  304. xfs_buf_rele(bp);
  305. }
  306. #define xfs_biodone(bp) xfs_buf_ioend(bp, 0)
  307. #define xfs_biomove(bp, off, len, data, rw) \
  308. xfs_buf_iomove((bp), (off), (len), (data), \
  309. ((rw) == XBF_WRITE) ? XBRW_WRITE : XBRW_READ)
  310. #define xfs_biozero(bp, off, len) \
  311. xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
  312. #define xfs_iowait(bp) xfs_buf_iowait(bp)
  313. #define xfs_baread(target, rablkno, ralen) \
  314. xfs_buf_readahead((target), (rablkno), (ralen), XBF_DONT_BLOCK)
  315. /*
  316. * Handling of buftargs.
  317. */
  318. extern xfs_buftarg_t *xfs_alloc_buftarg(struct xfs_mount *,
  319. struct block_device *, int, const char *);
  320. extern void xfs_free_buftarg(struct xfs_mount *, struct xfs_buftarg *);
  321. extern void xfs_wait_buftarg(xfs_buftarg_t *);
  322. extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int);
  323. extern int xfs_flush_buftarg(xfs_buftarg_t *, int);
  324. #ifdef CONFIG_KDB_MODULES
  325. extern struct list_head *xfs_get_buftarg_list(void);
  326. #endif
  327. #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
  328. #define xfs_readonly_buftarg(buftarg) bdev_read_only((buftarg)->bt_bdev)
  329. #define xfs_binval(buftarg) xfs_flush_buftarg(buftarg, 1)
  330. #define XFS_bflush(buftarg) xfs_flush_buftarg(buftarg, 1)
  331. #endif /* __XFS_BUF_H__ */