1/* 2 * Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of version 2 of the GNU General Public License as 6 * published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it would be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 11 * 12 * Further, this software is distributed without any warranty that it is 13 * free of the rightful claim of any third person regarding infringement 14 * or the like. Any license provided herein, whether implied or 15 * otherwise, applies only to this software file. Patent licenses, if 16 * any, provided herein do not apply to combinations of this program with 17 * other software, or any other product whatsoever. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write the Free Software Foundation, Inc., 59 21 * Temple Place - Suite 330, Boston MA 02111-1307, USA. 22 * 23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, 24 * Mountain View, CA 94043, or: 25 * 26 * http://www.sgi.com 27 * 28 * For further information regarding this notice, see: 29 * 30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ 31 */ 32#ifndef __XFS_BUF_H__ 33#define __XFS_BUF_H__ 34 35#include <sys/bio.h> 36#include <sys/buf.h> 37 38struct xfs_buf; 39struct xfs_mount; 40struct vnode; 41typedef struct buf xfs_buf_t; 42typedef uint32_t xfs_buf_flags_t; 43#define xfs_buf buf 44 45extern struct buf_ops xfs_bo_ops; 46 47typedef enum { 48 XBRW_READ = 1, /* transfer into target memory */ 49 XBRW_WRITE = 2, /* transfer from target memory */ 50 XBRW_ZERO = 3, /* Zero target memory */ 51} xfs_buf_rw_t; 52 53/* Buffer Read and Write Routines */ 54extern void xfs_buf_ioend(xfs_buf_t *, int); 55extern void xfs_buf_ioerror(xfs_buf_t *, int); 56extern int xfs_buf_iostart(xfs_buf_t *, xfs_buf_flags_t); 57extern int xfs_buf_iorequest(xfs_buf_t *); 58extern int xfs_buf_iowait(xfs_buf_t *); 59extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, xfs_caddr_t, xfs_buf_rw_t); 60 61/* Pinning Buffer Storage in Memory */ 62extern void xfs_buf_pin(xfs_buf_t *); 63extern void xfs_buf_unpin(xfs_buf_t *); 64extern int xfs_buf_ispin(xfs_buf_t *); 65 66 67typedef void (*xfs_buf_iodone_t)(struct xfs_buf *); /* call-back function on I/O completion */ 68typedef void (*xfs_buf_relse_t)(struct xfs_buf *); /* call-back function on I/O completion */ 69typedef int (*xfs_buf_bdstrat_t)(struct xfs_buf *); 70 71typedef struct xfs_buftarg { 72 /* this probaby redundant info, but stick with linux conventions for now */ 73 unsigned int bt_bsize; 74 unsigned int bt_sshift; 75 size_t bt_smask; 76 struct cdev *dev; 77 struct vnode *specvp; 78} xfs_buftarg_t; 79 80 81/* Finding and Reading Buffers */ 82extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t, xfs_buf_flags_t); 83/* Misc buffer rountines */ 84extern int xfs_readonly_buftarg(xfs_buftarg_t *); 85 86/* These are just for xfs_syncsub... it sets an internal variable 87 * then passes it to VOP_FLUSH_PAGES or adds the flags to a newly gotten buf_t 88 */ 89#define XBF_DONT_BLOCK 0 90 91#define XFS_B_ASYNC B_ASYNC 92#define XFS_B_DELWRI B_DELWRI 93#define XFS_B_READ BIO_READ 94#define XFS_B_WRITE BIO_WRITE 95 96#define XFS_B_STALE B_INVAL 97#define XFS_BUF_LOCK 0 98#define XFS_BUF_TRYLOCK 0 99#define XFS_BUF_MAPPED 0 100#define BUF_BUSY 0 101 102#define XBF_ORDERED 0 103 104 /* debugging routines might need this */ 105#define XFS_BUF_BFLAGS(x) ((x)->b_flags) 106#define XFS_BUF_ZEROFLAGS(x) ((x)->b_flags = 0) 107#define XFS_BUF_STALE(x) ((x)->b_flags |= (XFS_B_STALE|B_NOCACHE)) 108#define XFS_BUF_UNSTALE(x) ((x)->b_flags &= ~(XFS_B_STALE|B_NOCACHE)) 109#define XFS_BUF_ISSTALE(x) ((x)->b_flags & (XFS_B_STALE|B_NOCACHE)) 110#define XFS_BUF_SUPER_STALE(x) {(x)->b_flags |= (XFS_B_STALE|B_NOCACHE); \ 111 (x)->b_flags &= ~(XFS_B_DELWRI|B_CACHE);} 112 113#define XFS_BUF_MANAGE B_MANAGED 114#define XFS_BUF_UNMANAGE(x) ((x)->b_flags &= ~B_MANAGED) 115 116#define XFS_BUF_DELAYWRITE(x) ((x)->b_flags |= XFS_B_DELWRI) 117#define XFS_BUF_UNDELAYWRITE(x) ((x)->b_flags &= ~XFS_B_DELWRI) 118#define XFS_BUF_ISDELAYWRITE(x) ((x)->b_flags & XFS_B_DELWRI) 119 120#define XFS_BUF_ERROR(x,no) xfs_buf_set_error((x), (no)) 121#define XFS_BUF_GETERROR(x) xfs_buf_get_error(x) 122#define XFS_BUF_ISERROR(x) (((x)->b_ioflags & BIO_ERROR) != 0) 123 124void static __inline__ 125xfs_buf_set_error(struct buf *bp, int err) 126{ 127 bp->b_ioflags |= BIO_ERROR; 128 bp->b_error = err; 129} 130 131int static __inline__ 132xfs_buf_get_error(struct buf *bp) 133{ 134 return XFS_BUF_ISERROR(bp) ? (bp->b_error ? bp->b_error : EIO) : 0; 135} 136 137#define XFS_BUF_DONE(x) ((x)->b_flags |= B_CACHE) 138#define XFS_BUF_UNDONE(x) ((x)->b_flags &= ~B_CACHE) 139#define XFS_BUF_ISDONE(x) ((x)->b_flags & B_CACHE) 140 141#define XFS_BUF_BUSY(x) ((x)->b_flags |= BUF_BUSY) 142#define XFS_BUF_UNBUSY(x) ((x)->b_flags &= ~BUF_BUSY) 143#define XFS_BUF_ISBUSY(x) (1) 144 145#define XFS_BUF_ASYNC(x) ((x)->b_flags |= B_ASYNC) 146#define XFS_BUF_UNASYNC(x) ((x)->b_flags &= ~B_ASYNC) 147#define XFS_BUF_ISASYNC(x) ((x)->b_flags & B_ASYNC) 148 149#define XFS_BUF_ORDERED(bp) ((bp)->b_flags |= XBF_ORDERED) 150#define XFS_BUF_UNORDERED(bp) ((bp)->b_flags &= ~XBF_ORDERED) 151#define XFS_BUF_ISORDERED(bp) ((bp)->b_flags & XBF_ORDERED) 152 153#define XFS_BUF_FLUSH(x) ((x)->b_flags |= B_00800000) 154#define XFS_BUF_UNFLUSH(x) ((x)->b_flags &= ~B_00800000) 155#define XFS_BUF_ISFLUSH(x) ((x)->b_flags & B_00800000) 156 157#define XFS_BUF_SHUT(x) printf("XFS_BUF_SHUT not implemented yet\n") 158#define XFS_BUF_UNSHUT(x) printf("XFS_BUF_UNSHUT not implemented yet\n") 159#define XFS_BUF_ISSHUT(x) (0) 160 161#define XFS_BUF_HOLD(x) ((void)0) 162#define XFS_BUF_UNHOLD(x) ((void)0) 163 164#define XFS_BUF_READ(x) ((x)->b_iocmd = BIO_READ) 165#define XFS_BUF_UNREAD(x) ((x)->b_iocmd = 0) 166#define XFS_BUF_ISREAD(x) ((x)->b_iocmd == BIO_READ) 167 168#define XFS_BUF_WRITE(x) ((x)->b_iocmd = BIO_WRITE) 169#define XFS_BUF_UNWRITE(x) ((x)->b_iocmd = 0) 170#define XFS_BUF_ISWRITE(x) ((x)->b_iocmd == BIO_WRITE) 171 172#define XFS_BUF_ISUNINITIAL(x) (0) 173#define XFS_BUF_UNUNINITIAL(x) (0) 174 175#define XFS_BUF_IODONE_FUNC(x) (x)->b_iodone 176#define XFS_BUF_SET_IODONE_FUNC(x, f) (x)->b_iodone = (f) 177#define XFS_BUF_CLR_IODONE_FUNC(x) (x)->b_iodone = NULL 178 179#define XFS_BUF_SET_BDSTRAT_FUNC(x, f) do { if(f != NULL) {} } while(0) 180#define XFS_BUF_CLR_BDSTRAT_FUNC(x) ((void)0) 181 182#define XFS_BUF_BP_ISMAPPED(bp) (1) 183 184#define XFS_BUF_FSPRIVATE(buf, type) \ 185 ((type)(buf)->b_fsprivate1) 186#define XFS_BUF_SET_FSPRIVATE(buf, value) \ 187 (buf)->b_fsprivate1 = (void *)(value) 188#define XFS_BUF_FSPRIVATE2(buf, type) \ 189 ((type)(buf)->b_fsprivate2) 190#define XFS_BUF_SET_FSPRIVATE2(buf, value) \ 191 (buf)->b_fsprivate2 = (void *)(value) 192#define XFS_BUF_FSPRIVATE3(buf, type) \ 193 ((type)(buf)->b_fsprivate3) 194#define XFS_BUF_SET_FSPRIVATE3(buf, value) \ 195 (buf)->b_fsprivate3 = (void *)(value) 196#define XFS_BUF_SET_START(buf) \ 197 printf("XFS_BUF_SET_START: %s:%d\n", __FILE__, __LINE__) 198 199#define XFS_BUF_SET_BRELSE_FUNC(buf, value) \ 200 do { \ 201 printf("XFS_BUF_SET_BRELSE_FUNC: %s:%d\n", \ 202 __FILE__, __LINE__); \ 203 if (value != NULL ) {} \ 204 } while(0) 205 206#define XFS_BUF_PTR(bp) (xfs_caddr_t)((bp)->b_data) 207 208static __inline xfs_caddr_t 209xfs_buf_offset(xfs_buf_t *bp, size_t offset) 210{ 211 return XFS_BUF_PTR(bp) + offset; 212} 213 214#define XFS_BUF_SET_PTR(bp, val, count) \ 215 do { \ 216 (bp)->b_data = (val); \ 217 (bp)->b_bcount = (count); \ 218 } while(0) 219 220#define XFS_BUF_ADDR(bp) ((bp)->b_blkno) 221#define XFS_BUF_SET_ADDR(bp, blk) \ 222 ((bp)->b_blkno = blk) 223#define XFS_BUF_OFFSET(bp) ((bp)->b_offset) 224#define XFS_BUF_SET_OFFSET(bp, off) \ 225 ((bp)->b_offset = off) 226#define XFS_BUF_COUNT(bp) ((bp)->b_bcount) 227#define XFS_BUF_SET_COUNT(bp, cnt) \ 228 ((bp)->b_bcount = cnt) 229#define XFS_BUF_SIZE(bp) ((bp)->b_bufsize) 230#define XFS_BUF_SET_SIZE(bp, cnt) \ 231 ((bp)->b_bufsize = cnt) 232#define XFS_BUF_SET_VTYPE_REF(bp, type, ref) 233#define XFS_BUF_SET_VTYPE(bp, type) 234#define XFS_BUF_SET_REF(bp, ref) 235 236#define XFS_BUF_VALUSEMA(bp) (BUF_ISLOCKED(bp) ? 0 : 1) 237#define XFS_BUF_CPSEMA(bp) \ 238 (BUF_LOCK(bp, LK_EXCLUSIVE|LK_CANRECURSE | LK_SLEEPFAIL, NULL) == 0) 239 240#define XFS_BUF_PSEMA(bp,x) BUF_LOCK(bp, LK_EXCLUSIVE|LK_CANRECURSE, NULL) 241#define XFS_BUF_VSEMA(bp) BUF_UNLOCK(bp) 242 243#define XFS_BUF_V_IODONESEMA(bp) bdone(bp) 244 245/* setup the buffer target from a buftarg structure */ 246#define XFS_BUF_SET_TARGET(bp, target) \ 247 xfs_buf_set_target(bp, target) 248 249void xfs_buf_set_target(xfs_buf_t *, xfs_buftarg_t *); 250xfs_buftarg_t *xfs_buf_get_target(xfs_buf_t *); 251 252/* return the dev_t being used */ 253#define XFS_BUF_TARGET(bp) xfs_buf_get_target(bp) 254#define XFS_BUFTARG_NAME(targp) devtoname((targp)->dev) 255 256#define XFS_BUF_SET_VTYPE_REF(bp, type, ref) 257#define XFS_BUF_SET_VTYPE(bp, type) 258#define XFS_BUF_SET_REF(bp, ref) 259 260#define XFS_BUF_ISPINNED(bp) xfs_buf_ispin(bp) 261 262xfs_buf_t * 263xfs_buf_read_flags(xfs_buftarg_t *, xfs_daddr_t, size_t, int); 264 265#define xfs_buf_read(target, blkno, len, flags) \ 266 xfs_buf_read_flags(target, blkno, len, \ 267 XFS_BUF_LOCK | XFS_BUF_MAPPED) 268 269xfs_buf_t * 270xfs_buf_get_flags(xfs_buftarg_t *, xfs_daddr_t, size_t, int); 271 272#define xfs_buf_get(target, blkno, len, flags) \ 273 xfs_buf_get_flags(target, blkno, len, \ 274 XFS_BUF_LOCK | XFS_BUF_MAPPED) 275 276/* the return value is never used ... why does linux define this functions this way? */ 277static inline int xfs_bawrite(void *mp, xfs_buf_t *bp) 278{ 279 /* Ditto for xfs_bawrite 280 bp->b_fspriv3 = mp; 281 bp->b_strat = xfs_bdstrat_cb; 282 xfs_buf_delwri_dequeue(bp); 283 return xfs_buf_iostart(bp, XBF_WRITE | XBF_ASYNC | _XBF_RUN_QUEUES); 284 */ 285 bawrite(bp); 286 return 0; 287} 288 289static inline int xfs_bdwrite(void *mp, xfs_buf_t *bp) 290{ 291 /* this is for io shutdown checking need to do this at some point RMC */ 292 /* probably should just change xfs to call a buf write function */ 293#if 0 /* RMC */ 294 bp->b_strat = xfs_bdstrat_cb; 295 bp->b_fspriv3 = mp; 296 return xfs_buf_iostart(bp, XBF_DELWRI | XBF_ASYNC); 297#endif 298 bdwrite(bp); 299 return 0; 300} 301 302#define xfs_bpin(bp) xfs_buf_pin(bp) 303#define xfs_bunpin(bp) xfs_buf_unpin(bp) 304 305#define xfs_buf_relse(bp) brelse(bp) 306#define xfs_bp_mapin(bp) bp_mapin(bp) 307#define xfs_xfsd_list_evict(x) _xfs_xfsd_list_evict(x) 308#define xfs_buftrace(x,y) CTR2(KTR_BUF, "%s bp %p flags %X", bp, bp->b_flags) 309#define xfs_biodone(bp) bufdone_finish(bp) 310 311#define xfs_incore(xfs_buftarg,blkno,len,lockit) \ 312 incore(&xfs_buftarg->specvp->v_bufobj, blkno); 313 314#define xfs_biomove(bp, off, len, data, rw) \ 315 xfs_buf_iomove((bp), (off), (len), (data), \ 316 ((rw) == XFS_B_WRITE) ? XBRW_WRITE : XBRW_READ) 317 318#define xfs_biozero(bp, off, len) \ 319 xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO) 320 321/* already a function xfs_bwrite... fix this */ 322#define XFS_bdwrite(bp) bdwrite(bp) 323#define xfs_iowait(bp) bufwait(bp) 324 325#define XFS_bdstrat(bp) xfs_buf_iorequest(bp) 326 327#define xfs_baread(target, rablkno, ralen) \ 328 xfs_buf_readahead((target), (rablkno), (ralen), XBF_DONT_BLOCK) 329 330struct xfs_mount; 331 332int XFS_bwrite(xfs_buf_t *bp); 333xfs_buf_t* xfs_buf_get_empty(size_t, xfs_buftarg_t *targ); 334xfs_buf_t* xfs_buf_get_noaddr(size_t, xfs_buftarg_t *targ); 335void xfs_buf_free(xfs_buf_t *); 336 337extern void xfs_bwait_unpin(xfs_buf_t *bp); 338extern xfs_buftarg_t *xfs_alloc_buftarg(struct vnode *, int); 339extern void xfs_free_buftarg(xfs_buftarg_t *, int); 340extern void xfs_wait_buftarg(xfs_buftarg_t *); 341extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int); 342extern unsigned int xfs_getsize_buftarg(struct xfs_buftarg *); 343extern int xfs_flush_buftarg(xfs_buftarg_t *, int); 344 345#define xfs_binval(buftarg) xfs_flush_buftarg(buftarg, 1) 346#define XFS_bflush(buftarg) xfs_flush_buftarg(buftarg, 1) 347 348#endif 349