xfs_buf.h 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  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. typedef enum {
  42. XBF_READ = (1 << 0), /* buffer intended for reading from device */
  43. XBF_WRITE = (1 << 1), /* buffer intended for writing to device */
  44. XBF_MAPPED = (1 << 2), /* buffer mapped (b_addr valid) */
  45. XBF_ASYNC = (1 << 4), /* initiator will not wait for completion */
  46. XBF_DONE = (1 << 5), /* all pages in the buffer uptodate */
  47. XBF_DELWRI = (1 << 6), /* buffer has dirty pages */
  48. XBF_STALE = (1 << 7), /* buffer has been staled, do not find it */
  49. XBF_FS_MANAGED = (1 << 8), /* filesystem controls freeing memory */
  50. XBF_ORDERED = (1 << 11), /* use ordered writes */
  51. XBF_READ_AHEAD = (1 << 12), /* asynchronous read-ahead */
  52. /* flags used only as arguments to access routines */
  53. XBF_LOCK = (1 << 14), /* lock requested */
  54. XBF_TRYLOCK = (1 << 15), /* lock requested, but do not wait */
  55. XBF_DONT_BLOCK = (1 << 16), /* do not block in current thread */
  56. /* flags used only internally */
  57. _XBF_PAGE_CACHE = (1 << 17),/* backed by pagecache */
  58. _XBF_KMEM_ALLOC = (1 << 18),/* backed by kmem_alloc() */
  59. _XBF_RUN_QUEUES = (1 << 19),/* run block device task queue */
  60. _XBF_DELWRI_Q = (1 << 21), /* buffer on delwri queue */
  61. } xfs_buf_flags_t;
  62. typedef enum {
  63. XBT_FORCE_SLEEP = 0,
  64. XBT_FORCE_FLUSH = 1,
  65. } xfs_buftarg_flags_t;
  66. typedef struct xfs_bufhash {
  67. struct list_head bh_list;
  68. spinlock_t bh_lock;
  69. } xfs_bufhash_t;
  70. typedef struct xfs_buftarg {
  71. dev_t bt_dev;
  72. struct block_device *bt_bdev;
  73. struct address_space *bt_mapping;
  74. unsigned int bt_bsize;
  75. unsigned int bt_sshift;
  76. size_t bt_smask;
  77. /* per device buffer hash table */
  78. uint bt_hashmask;
  79. uint bt_hashshift;
  80. xfs_bufhash_t *bt_hash;
  81. /* per device delwri queue */
  82. struct task_struct *bt_task;
  83. struct list_head bt_list;
  84. struct list_head bt_delwrite_queue;
  85. spinlock_t bt_delwrite_lock;
  86. unsigned long bt_flags;
  87. } xfs_buftarg_t;
  88. /*
  89. * xfs_buf_t: Buffer structure for pagecache-based buffers
  90. *
  91. * This buffer structure is used by the pagecache buffer management routines
  92. * to refer to an assembly of pages forming a logical buffer.
  93. *
  94. * The buffer structure is used on a temporary basis only, and discarded when
  95. * released. The real data storage is recorded in the pagecache. Buffers are
  96. * hashed to the block device on which the file system resides.
  97. */
  98. struct xfs_buf;
  99. typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
  100. typedef void (*xfs_buf_relse_t)(struct xfs_buf *);
  101. typedef int (*xfs_buf_bdstrat_t)(struct xfs_buf *);
  102. #define XB_PAGES 2
  103. typedef struct xfs_buf {
  104. struct semaphore b_sema; /* semaphore for lockables */
  105. unsigned long b_queuetime; /* time buffer was queued */
  106. atomic_t b_pin_count; /* pin count */
  107. wait_queue_head_t b_waiters; /* unpin waiters */
  108. struct list_head b_list;
  109. xfs_buf_flags_t b_flags; /* status flags */
  110. struct list_head b_hash_list; /* hash table list */
  111. xfs_bufhash_t *b_hash; /* hash table list start */
  112. xfs_buftarg_t *b_target; /* buffer target (device) */
  113. atomic_t b_hold; /* reference count */
  114. xfs_daddr_t b_bn; /* block number for I/O */
  115. xfs_off_t b_file_offset; /* offset in file */
  116. size_t b_buffer_length;/* size of buffer in bytes */
  117. size_t b_count_desired;/* desired transfer size */
  118. void *b_addr; /* virtual address of buffer */
  119. struct work_struct b_iodone_work;
  120. atomic_t b_io_remaining; /* #outstanding I/O requests */
  121. xfs_buf_iodone_t b_iodone; /* I/O completion function */
  122. xfs_buf_relse_t b_relse; /* releasing function */
  123. xfs_buf_bdstrat_t b_strat; /* pre-write function */
  124. struct semaphore b_iodonesema; /* Semaphore for I/O waiters */
  125. void *b_fspriv;
  126. void *b_fspriv2;
  127. void *b_fspriv3;
  128. unsigned short b_error; /* error code on I/O */
  129. unsigned short b_locked; /* page array is locked */
  130. unsigned int b_page_count; /* size of page array */
  131. unsigned int b_offset; /* page offset in first page */
  132. struct page **b_pages; /* array of page pointers */
  133. struct page *b_page_array[XB_PAGES]; /* inline pages */
  134. #ifdef XFS_BUF_LOCK_TRACKING
  135. int b_last_holder;
  136. #endif
  137. } xfs_buf_t;
  138. /* Finding and Reading Buffers */
  139. extern xfs_buf_t *_xfs_buf_find(xfs_buftarg_t *, xfs_off_t, size_t,
  140. xfs_buf_flags_t, xfs_buf_t *);
  141. #define xfs_incore(buftarg,blkno,len,lockit) \
  142. _xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
  143. extern xfs_buf_t *xfs_buf_get_flags(xfs_buftarg_t *, xfs_off_t, size_t,
  144. xfs_buf_flags_t);
  145. #define xfs_buf_get(target, blkno, len, flags) \
  146. xfs_buf_get_flags((target), (blkno), (len), XBF_LOCK | XBF_MAPPED)
  147. extern xfs_buf_t *xfs_buf_read_flags(xfs_buftarg_t *, xfs_off_t, size_t,
  148. xfs_buf_flags_t);
  149. #define xfs_buf_read(target, blkno, len, flags) \
  150. xfs_buf_read_flags((target), (blkno), (len), XBF_LOCK | XBF_MAPPED)
  151. extern xfs_buf_t *xfs_buf_get_empty(size_t, xfs_buftarg_t *);
  152. extern xfs_buf_t *xfs_buf_get_noaddr(size_t, xfs_buftarg_t *);
  153. extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t);
  154. extern void xfs_buf_hold(xfs_buf_t *);
  155. extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t,
  156. xfs_buf_flags_t);
  157. /* Releasing Buffers */
  158. extern void xfs_buf_free(xfs_buf_t *);
  159. extern void xfs_buf_rele(xfs_buf_t *);
  160. /* Locking and Unlocking Buffers */
  161. extern int xfs_buf_cond_lock(xfs_buf_t *);
  162. extern int xfs_buf_lock_value(xfs_buf_t *);
  163. extern void xfs_buf_lock(xfs_buf_t *);
  164. extern void xfs_buf_unlock(xfs_buf_t *);
  165. /* Buffer Read and Write Routines */
  166. extern void xfs_buf_ioend(xfs_buf_t *, int);
  167. extern void xfs_buf_ioerror(xfs_buf_t *, int);
  168. extern int xfs_buf_iostart(xfs_buf_t *, xfs_buf_flags_t);
  169. extern int xfs_buf_iorequest(xfs_buf_t *);
  170. extern int xfs_buf_iowait(xfs_buf_t *);
  171. extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, xfs_caddr_t,
  172. xfs_buf_rw_t);
  173. static inline int xfs_buf_iostrategy(xfs_buf_t *bp)
  174. {
  175. return bp->b_strat ? bp->b_strat(bp) : xfs_buf_iorequest(bp);
  176. }
  177. static inline int xfs_buf_geterror(xfs_buf_t *bp)
  178. {
  179. return bp ? bp->b_error : ENOMEM;
  180. }
  181. /* Buffer Utility Routines */
  182. extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
  183. /* Pinning Buffer Storage in Memory */
  184. extern void xfs_buf_pin(xfs_buf_t *);
  185. extern void xfs_buf_unpin(xfs_buf_t *);
  186. extern int xfs_buf_ispin(xfs_buf_t *);
  187. /* Delayed Write Buffer Routines */
  188. extern void xfs_buf_delwri_dequeue(xfs_buf_t *);
  189. /* Buffer Daemon Setup Routines */
  190. extern int xfs_buf_init(void);
  191. extern void xfs_buf_terminate(void);
  192. #ifdef XFS_BUF_TRACE
  193. extern ktrace_t *xfs_buf_trace_buf;
  194. extern void xfs_buf_trace(xfs_buf_t *, char *, void *, void *);
  195. #else
  196. #define xfs_buf_trace(bp,id,ptr,ra) do { } while (0)
  197. #endif
  198. #define xfs_buf_target_name(target) \
  199. ({ char __b[BDEVNAME_SIZE]; bdevname((target)->bt_bdev, __b); __b; })
  200. #define XFS_B_ASYNC XBF_ASYNC
  201. #define XFS_B_DELWRI XBF_DELWRI
  202. #define XFS_B_READ XBF_READ
  203. #define XFS_B_WRITE XBF_WRITE
  204. #define XFS_B_STALE XBF_STALE
  205. #define XFS_BUF_TRYLOCK XBF_TRYLOCK
  206. #define XFS_INCORE_TRYLOCK XBF_TRYLOCK
  207. #define XFS_BUF_LOCK XBF_LOCK
  208. #define XFS_BUF_MAPPED XBF_MAPPED
  209. #define BUF_BUSY XBF_DONT_BLOCK
  210. #define XFS_BUF_BFLAGS(bp) ((bp)->b_flags)
  211. #define XFS_BUF_ZEROFLAGS(bp) ((bp)->b_flags &= \
  212. ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI|XBF_ORDERED))
  213. #define XFS_BUF_STALE(bp) ((bp)->b_flags |= XFS_B_STALE)
  214. #define XFS_BUF_UNSTALE(bp) ((bp)->b_flags &= ~XFS_B_STALE)
  215. #define XFS_BUF_ISSTALE(bp) ((bp)->b_flags & XFS_B_STALE)
  216. #define XFS_BUF_SUPER_STALE(bp) do { \
  217. XFS_BUF_STALE(bp); \
  218. xfs_buf_delwri_dequeue(bp); \
  219. XFS_BUF_DONE(bp); \
  220. } while (0)
  221. #define XFS_BUF_MANAGE XBF_FS_MANAGED
  222. #define XFS_BUF_UNMANAGE(bp) ((bp)->b_flags &= ~XBF_FS_MANAGED)
  223. #define XFS_BUF_DELAYWRITE(bp) ((bp)->b_flags |= XBF_DELWRI)
  224. #define XFS_BUF_UNDELAYWRITE(bp) xfs_buf_delwri_dequeue(bp)
  225. #define XFS_BUF_ISDELAYWRITE(bp) ((bp)->b_flags & XBF_DELWRI)
  226. #define XFS_BUF_ERROR(bp,no) xfs_buf_ioerror(bp,no)
  227. #define XFS_BUF_GETERROR(bp) xfs_buf_geterror(bp)
  228. #define XFS_BUF_ISERROR(bp) (xfs_buf_geterror(bp) ? 1 : 0)
  229. #define XFS_BUF_DONE(bp) ((bp)->b_flags |= XBF_DONE)
  230. #define XFS_BUF_UNDONE(bp) ((bp)->b_flags &= ~XBF_DONE)
  231. #define XFS_BUF_ISDONE(bp) ((bp)->b_flags & XBF_DONE)
  232. #define XFS_BUF_BUSY(bp) do { } while (0)
  233. #define XFS_BUF_UNBUSY(bp) do { } while (0)
  234. #define XFS_BUF_ISBUSY(bp) (1)
  235. #define XFS_BUF_ASYNC(bp) ((bp)->b_flags |= XBF_ASYNC)
  236. #define XFS_BUF_UNASYNC(bp) ((bp)->b_flags &= ~XBF_ASYNC)
  237. #define XFS_BUF_ISASYNC(bp) ((bp)->b_flags & XBF_ASYNC)
  238. #define XFS_BUF_ORDERED(bp) ((bp)->b_flags |= XBF_ORDERED)
  239. #define XFS_BUF_UNORDERED(bp) ((bp)->b_flags &= ~XBF_ORDERED)
  240. #define XFS_BUF_ISORDERED(bp) ((bp)->b_flags & XBF_ORDERED)
  241. #define XFS_BUF_SHUT(bp) do { } while (0)
  242. #define XFS_BUF_UNSHUT(bp) do { } while (0)
  243. #define XFS_BUF_ISSHUT(bp) (0)
  244. #define XFS_BUF_HOLD(bp) xfs_buf_hold(bp)
  245. #define XFS_BUF_READ(bp) ((bp)->b_flags |= XBF_READ)
  246. #define XFS_BUF_UNREAD(bp) ((bp)->b_flags &= ~XBF_READ)
  247. #define XFS_BUF_ISREAD(bp) ((bp)->b_flags & XBF_READ)
  248. #define XFS_BUF_WRITE(bp) ((bp)->b_flags |= XBF_WRITE)
  249. #define XFS_BUF_UNWRITE(bp) ((bp)->b_flags &= ~XBF_WRITE)
  250. #define XFS_BUF_ISWRITE(bp) ((bp)->b_flags & XBF_WRITE)
  251. #define XFS_BUF_IODONE_FUNC(bp) ((bp)->b_iodone)
  252. #define XFS_BUF_SET_IODONE_FUNC(bp, func) ((bp)->b_iodone = (func))
  253. #define XFS_BUF_CLR_IODONE_FUNC(bp) ((bp)->b_iodone = NULL)
  254. #define XFS_BUF_SET_BDSTRAT_FUNC(bp, func) ((bp)->b_strat = (func))
  255. #define XFS_BUF_CLR_BDSTRAT_FUNC(bp) ((bp)->b_strat = NULL)
  256. #define XFS_BUF_FSPRIVATE(bp, type) ((type)(bp)->b_fspriv)
  257. #define XFS_BUF_SET_FSPRIVATE(bp, val) ((bp)->b_fspriv = (void*)(val))
  258. #define XFS_BUF_FSPRIVATE2(bp, type) ((type)(bp)->b_fspriv2)
  259. #define XFS_BUF_SET_FSPRIVATE2(bp, val) ((bp)->b_fspriv2 = (void*)(val))
  260. #define XFS_BUF_FSPRIVATE3(bp, type) ((type)(bp)->b_fspriv3)
  261. #define XFS_BUF_SET_FSPRIVATE3(bp, val) ((bp)->b_fspriv3 = (void*)(val))
  262. #define XFS_BUF_SET_START(bp) do { } while (0)
  263. #define XFS_BUF_SET_BRELSE_FUNC(bp, func) ((bp)->b_relse = (func))
  264. #define XFS_BUF_PTR(bp) (xfs_caddr_t)((bp)->b_addr)
  265. #define XFS_BUF_SET_PTR(bp, val, cnt) xfs_buf_associate_memory(bp, val, cnt)
  266. #define XFS_BUF_ADDR(bp) ((bp)->b_bn)
  267. #define XFS_BUF_SET_ADDR(bp, bno) ((bp)->b_bn = (xfs_daddr_t)(bno))
  268. #define XFS_BUF_OFFSET(bp) ((bp)->b_file_offset)
  269. #define XFS_BUF_SET_OFFSET(bp, off) ((bp)->b_file_offset = (off))
  270. #define XFS_BUF_COUNT(bp) ((bp)->b_count_desired)
  271. #define XFS_BUF_SET_COUNT(bp, cnt) ((bp)->b_count_desired = (cnt))
  272. #define XFS_BUF_SIZE(bp) ((bp)->b_buffer_length)
  273. #define XFS_BUF_SET_SIZE(bp, cnt) ((bp)->b_buffer_length = (cnt))
  274. #define XFS_BUF_SET_VTYPE_REF(bp, type, ref) do { } while (0)
  275. #define XFS_BUF_SET_VTYPE(bp, type) do { } while (0)
  276. #define XFS_BUF_SET_REF(bp, ref) do { } while (0)
  277. #define XFS_BUF_ISPINNED(bp) xfs_buf_ispin(bp)
  278. #define XFS_BUF_VALUSEMA(bp) xfs_buf_lock_value(bp)
  279. #define XFS_BUF_CPSEMA(bp) (xfs_buf_cond_lock(bp) == 0)
  280. #define XFS_BUF_VSEMA(bp) xfs_buf_unlock(bp)
  281. #define XFS_BUF_PSEMA(bp,x) xfs_buf_lock(bp)
  282. #define XFS_BUF_V_IODONESEMA(bp) up(&bp->b_iodonesema);
  283. #define XFS_BUF_SET_TARGET(bp, target) ((bp)->b_target = (target))
  284. #define XFS_BUF_TARGET(bp) ((bp)->b_target)
  285. #define XFS_BUFTARG_NAME(target) xfs_buf_target_name(target)
  286. static inline int xfs_bawrite(void *mp, xfs_buf_t *bp)
  287. {
  288. bp->b_fspriv3 = mp;
  289. bp->b_strat = xfs_bdstrat_cb;
  290. xfs_buf_delwri_dequeue(bp);
  291. return xfs_buf_iostart(bp, XBF_WRITE | XBF_ASYNC | _XBF_RUN_QUEUES);
  292. }
  293. static inline void xfs_buf_relse(xfs_buf_t *bp)
  294. {
  295. if (!bp->b_relse)
  296. xfs_buf_unlock(bp);
  297. xfs_buf_rele(bp);
  298. }
  299. #define xfs_bpin(bp) xfs_buf_pin(bp)
  300. #define xfs_bunpin(bp) xfs_buf_unpin(bp)
  301. #define xfs_buftrace(id, bp) \
  302. xfs_buf_trace(bp, id, NULL, (void *)__builtin_return_address(0))
  303. #define xfs_biodone(bp) xfs_buf_ioend(bp, 0)
  304. #define xfs_biomove(bp, off, len, data, rw) \
  305. xfs_buf_iomove((bp), (off), (len), (data), \
  306. ((rw) == XFS_B_WRITE) ? XBRW_WRITE : XBRW_READ)
  307. #define xfs_biozero(bp, off, len) \
  308. xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
  309. static inline int XFS_bwrite(xfs_buf_t *bp)
  310. {
  311. int iowait = (bp->b_flags & XBF_ASYNC) == 0;
  312. int error = 0;
  313. if (!iowait)
  314. bp->b_flags |= _XBF_RUN_QUEUES;
  315. xfs_buf_delwri_dequeue(bp);
  316. xfs_buf_iostrategy(bp);
  317. if (iowait) {
  318. error = xfs_buf_iowait(bp);
  319. xfs_buf_relse(bp);
  320. }
  321. return error;
  322. }
  323. static inline int xfs_bdwrite(void *mp, xfs_buf_t *bp)
  324. {
  325. bp->b_strat = xfs_bdstrat_cb;
  326. bp->b_fspriv3 = mp;
  327. return xfs_buf_iostart(bp, XBF_DELWRI | XBF_ASYNC);
  328. }
  329. #define XFS_bdstrat(bp) xfs_buf_iorequest(bp)
  330. #define xfs_iowait(bp) xfs_buf_iowait(bp)
  331. #define xfs_baread(target, rablkno, ralen) \
  332. xfs_buf_readahead((target), (rablkno), (ralen), XBF_DONT_BLOCK)
  333. /*
  334. * Handling of buftargs.
  335. */
  336. extern xfs_buftarg_t *xfs_alloc_buftarg(struct block_device *, int);
  337. extern void xfs_free_buftarg(xfs_buftarg_t *, int);
  338. extern void xfs_wait_buftarg(xfs_buftarg_t *);
  339. extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int);
  340. extern int xfs_flush_buftarg(xfs_buftarg_t *, int);
  341. #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
  342. #define xfs_readonly_buftarg(buftarg) bdev_read_only((buftarg)->bt_bdev)
  343. #define xfs_binval(buftarg) xfs_flush_buftarg(buftarg, 1)
  344. #define XFS_bflush(buftarg) xfs_flush_buftarg(buftarg, 1)
  345. #endif /* __XFS_BUF_H__ */