Context Navigation

source: rtems-libbsd/freebsd/sys/sys/buf.h @ 66659ff

4.1155-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 66659ff was 66659ff, checked in by Sebastian Huber <sebastian.huber@…>, on 11/06/13 at 15:20:21
Update to FreeBSD 9.2
Property mode set to `100644`
File size: 19.2 KB

Line
1	/*-
2	* Copyright (c) 1982, 1986, 1989, 1993
3	* The Regents of the University of California. All rights reserved.
4	* (c) UNIX System Laboratories, Inc.
5	* All or some portions of this file are derived from material licensed
6	* to the University of California by American Telephone and Telegraph
7	* Co. or Unix System Laboratories, Inc. and are reproduced herein with
8	* the permission of UNIX System Laboratories, Inc.
9	*
10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions
12	* are met:
13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.
18	* 4. Neither the name of the University nor the names of its contributors
19	* may be used to endorse or promote products derived from this software
20	* without specific prior written permission.
21	*
22	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32	* SUCH DAMAGE.
33	*
34	* @(#)buf.h 8.9 (Berkeley) 3/30/95
35	* $FreeBSD$
36	*/
37
38	#ifndef _SYS_BUF_H_
39	#define _SYS_BUF_H_
40
41	#include <sys/bufobj.h>
42	#include <sys/queue.h>
43	#include <rtems/bsd/sys/lock.h>
44	#include <sys/lockmgr.h>
45
46	struct bio;
47	struct buf;
48	struct bufobj;
49	struct mount;
50	struct vnode;
51	struct uio;
52
53	/*
54	* To avoid including <ufs/ffs/softdep.h>
55	*/
56	LIST_HEAD(workhead, worklist);
57	/*
58	* These are currently used only by the soft dependency code, hence
59	* are stored once in a global variable. If other subsystems wanted
60	* to use these hooks, a pointer to a set of bio_ops could be added
61	* to each buffer.
62	*/
63	extern struct bio_ops {
64	void (io_start)(struct buf );
65	void (io_complete)(struct buf );
66	void (io_deallocate)(struct buf );
67	int (io_countdeps)(struct buf , int);
68	} bioops;
69
70	struct vm_object;
71
72	typedef unsigned char b_xflags_t;
73
74	/*
75	* The buffer header describes an I/O operation in the kernel.
76	*
77	* NOTES:
78	* b_bufsize, b_bcount. b_bufsize is the allocation size of the
79	* buffer, either DEV_BSIZE or PAGE_SIZE aligned. b_bcount is the
80	* originally requested buffer size and can serve as a bounds check
81	* against EOF. For most, but not all uses, b_bcount == b_bufsize.
82	*
83	* b_dirtyoff, b_dirtyend. Buffers support piecemeal, unaligned
84	* ranges of dirty data that need to be written to backing store.
85	* The range is typically clipped at b_bcount ( not b_bufsize ).
86	*
87	* b_resid. Number of bytes remaining in I/O. After an I/O operation
88	* completes, b_resid is usually 0 indicating 100% success.
89	*
90	* All fields are protected by the buffer lock except those marked:
91	* V - Protected by owning bufobj lock
92	* Q - Protected by the buf queue lock
93	* D - Protected by an dependency implementation specific lock
94	*/
95	struct buf {
96	struct bufobj *b_bufobj;
97	long b_bcount;
98	void *b_caller1;
99	caddr_t b_data;
100	int b_error;
101	uint8_t b_iocmd;
102	uint8_t b_ioflags;
103	off_t b_iooffset;
104	long b_resid;
105	void (b_iodone)(struct buf );
106	daddr_t b_blkno; /* Underlying physical block number. */
107	off_t b_offset; /* Offset into file. */
108	TAILQ_ENTRY(buf) b_bobufs; /* (V) Buffer's associated vnode. */
109	struct buf b_left; / (V) splay tree link */
110	struct buf b_right; / (V) splay tree link */
111	uint32_t b_vflags; /* (V) BV_* flags */
112	TAILQ_ENTRY(buf) b_freelist; /* (Q) Free list position inactive. */
113	unsigned short b_qindex; /* (Q) buffer queue index */
114	uint32_t b_flags; /* B_* flags. */
115	b_xflags_t b_xflags; /* extra flags */
116	struct lock b_lock; /* Buffer lock */
117	long b_bufsize; /* Allocated buffer size. */
118	long b_runningbufspace; /* when I/O is running, pipelining */
119	caddr_t b_kvabase; /* base kva for buffer */
120	caddr_t b_kvaalloc; /* allocated kva for B_KVAALLOC */
121	int b_kvasize; /* size of kva for buffer */
122	daddr_t b_lblkno; /* Logical block number. */
123	struct vnode b_vp; / Device vnode. */
124	int b_dirtyoff; /* Offset in buffer of dirty region. */
125	int b_dirtyend; /* Offset of end of dirty region. */
126	struct ucred b_rcred; / Read credentials reference. */
127	struct ucred b_wcred; / Write credentials reference. */
128	void b_saveaddr; / Original b_addr for physio. */
129	union pager_info {
130	int pg_reqpage;
131	} b_pager;
132	union cluster_info {
133	TAILQ_HEAD(cluster_list_head, buf) cluster_head;
134	TAILQ_ENTRY(buf) cluster_entry;
135	} b_cluster;
136	struct vm_page *b_pages[btoc(MAXPHYS)];
137	int b_npages;
138	struct workhead b_dep; /* (D) List of filesystem dependencies. */
139	void *b_fsprivate1;
140	void *b_fsprivate2;
141	void *b_fsprivate3;
142	int b_pin_count;
143	};
144
145	#define b_object b_bufobj->bo_object
146
147	/*
148	* These flags are kept in b_flags.
149	*
150	* Notes:
151	*
152	* B_ASYNC VOP calls on bp's are usually async whether or not
153	* B_ASYNC is set, but some subsystems, such as NFS, like
154	* to know what is best for the caller so they can
155	* optimize the I/O.
156	*
157	* B_PAGING Indicates that bp is being used by the paging system or
158	* some paging system and that the bp is not linked into
159	* the b_vp's clean/dirty linked lists or ref counts.
160	* Buffer vp reassignments are illegal in this case.
161	*
162	* B_CACHE This may only be set if the buffer is entirely valid.
163	* The situation where B_DELWRI is set and B_CACHE is
164	* clear MUST be committed to disk by getblk() so
165	* B_DELWRI can also be cleared. See the comments for
166	* getblk() in kern/vfs_bio.c. If B_CACHE is clear,
167	* the caller is expected to clear BIO_ERROR and B_INVAL,
168	* set BIO_READ, and initiate an I/O.
169	*
170	* The 'entire buffer' is defined to be the range from
171	* 0 through b_bcount.
172	*
173	* B_MALLOC Request that the buffer be allocated from the malloc
174	* pool, DEV_BSIZE aligned instead of PAGE_SIZE aligned.
175	*
176	* B_CLUSTEROK This flag is typically set for B_DELWRI buffers
177	* by filesystems that allow clustering when the buffer
178	* is fully dirty and indicates that it may be clustered
179	* with other adjacent dirty buffers. Note the clustering
180	* may not be used with the stage 1 data write under NFS
181	* but may be used for the commit rpc portion.
182	*
183	* B_VMIO Indicates that the buffer is tied into an VM object.
184	* The buffer's data is always PAGE_SIZE aligned even
185	* if b_bufsize and b_bcount are not. ( b_bufsize is
186	* always at least DEV_BSIZE aligned, though ).
187	*
188	* B_DIRECT Hint that we should attempt to completely free
189	* the pages underlying the buffer. B_DIRECT is
190	* sticky until the buffer is released and typically
191	* only has an effect when B_RELBUF is also set.
192	*
193	*/
194
195	#define B_AGE 0x00000001 /* Move to age queue when I/O done. */
196	#define B_NEEDCOMMIT 0x00000002 /* Append-write in progress. */
197	#define B_ASYNC 0x00000004 /* Start I/O, do not wait. */
198	#define B_DIRECT 0x00000008 /* direct I/O flag (pls free vmio) */
199	#define B_DEFERRED 0x00000010 /* Skipped over for cleaning */
200	#define B_CACHE 0x00000020 /* Bread found us in the cache. */
201	#define B_VALIDSUSPWRT 0x00000040 /* Valid write during suspension. */
202	#define B_DELWRI 0x00000080 /* Delay I/O until buffer reused. */
203	#define B_PERSISTENT 0x00000100 /* Perm. ref'ed while EXT2FS mounted. */
204	#define B_DONE 0x00000200 /* I/O completed. */
205	#define B_EINTR 0x00000400 /* I/O was interrupted */
206	#define B_UNMAPPED 0x00000800 /* KVA is not mapped. */
207	#define B_KVAALLOC 0x00001000 /* But allocated. */
208	#define B_INVAL 0x00002000 /* Does not contain valid info. */
209	#define B_BARRIER 0x00004000 /* Write this and all preceeding first. */
210	#define B_NOCACHE 0x00008000 /* Do not cache block after use. */
211	#define B_MALLOC 0x00010000 /* malloced b_data */
212	#define B_CLUSTEROK 0x00020000 /* Pagein op, so swap() can count it. */
213	#define B_000400000 0x00040000 /* Available flag. */
214	#define B_000800000 0x00080000 /* Available flag. */
215	#define B_00100000 0x00100000 /* Available flag. */
216	#define B_DIRTY 0x00200000 /* Needs writing later (in EXT2FS). */
217	#define B_RELBUF 0x00400000 /* Release VMIO buffer. */
218	#define B_00800000 0x00800000 /* Available flag. */
219	#define B_NOCOPY 0x01000000 /* Don't copy-on-write this buf. */
220	#define B_NEEDSGIANT 0x02000000 /* Buffer's vnode needs giant. */
221	#define B_PAGING 0x04000000 /* volatile paging I/O -- bypass VMIO */
222	#define B_MANAGED 0x08000000 /* Managed by FS. */
223	#define B_RAM 0x10000000 /* Read ahead mark (flag) */
224	#define B_VMIO 0x20000000 /* VMIO flag */
225	#define B_CLUSTER 0x40000000 /* pagein op, so swap() can count it */
226	#define B_REMFREE 0x80000000 /* Delayed bremfree */
227
228	#define PRINT_BUF_FLAGS "\20\40remfree\37cluster\36vmio\35ram\34managed" \
229	"\33paging\32needsgiant\31nocopy\30b23\27relbuf\26dirty\25b20" \
230	"\24b19\23b18\22clusterok\21malloc\20nocache\17b14\16inval" \
231	"\15b12\14b11\13eintr\12done\11persist\10delwri\7validsuspwrt" \
232	"\6cache\5deferred\4direct\3async\2needcommit\1age"
233
234	/*
235	* These flags are kept in b_xflags.
236	*/
237	#define BX_VNDIRTY 0x00000001 /* On vnode dirty list */
238	#define BX_VNCLEAN 0x00000002 /* On vnode clean list */
239	#define BX_BKGRDWRITE 0x00000010 /* Do writes in background */
240	#define BX_BKGRDMARKER 0x00000020 /* Mark buffer for splay tree */
241	#define BX_ALTDATA 0x00000040 /* Holds extended data */
242
243	#define PRINT_BUF_XFLAGS "\20\7altdata\6bkgrdmarker\5bkgrdwrite\2clean\1dirty"
244
245	#define NOOFFSET (-1LL) /* No buffer offset calculated yet */
246
247	/*
248	* These flags are kept in b_vflags.
249	*/
250	#define BV_SCANNED 0x00000001 /* VOP_FSYNC funcs mark written bufs */
251	#define BV_BKGRDINPROG 0x00000002 /* Background write in progress */
252	#define BV_BKGRDWAIT 0x00000004 /* Background write waiting */
253	#define BV_INFREECNT 0x80000000 /* buf is counted in numfreebufs */
254
255	#define PRINT_BUF_VFLAGS "\20\40infreecnt\3bkgrdwait\2bkgrdinprog\1scanned"
256
257	#ifdef _KERNEL
258	/*
259	* Buffer locking
260	*/
261	extern const char buf_wmesg; / Default buffer lock message */
262	#define BUF_WMESG "bufwait"
263	#include <sys/proc.h> /* XXX for curthread */
264	#include <sys/mutex.h>
265
266	/*
267	* Initialize a lock.
268	*/
269	#define BUF_LOCKINIT(bp) \
270	lockinit(&(bp)->b_lock, PRIBIO + 4, buf_wmesg, 0, 0)
271	/*
272	*
273	* Get a lock sleeping non-interruptably until it becomes available.
274	*/
275	#define BUF_LOCK(bp, locktype, interlock) \
276	_lockmgr_args(&(bp)->b_lock, (locktype), (interlock), \
277	LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT, \
278	LOCK_FILE, LOCK_LINE)
279
280	/*
281	* Get a lock sleeping with specified interruptably and timeout.
282	*/
283	#define BUF_TIMELOCK(bp, locktype, interlock, wmesg, catch, timo) \
284	_lockmgr_args(&(bp)->b_lock, (locktype) \| LK_TIMELOCK, \
285	(interlock), (wmesg), (PRIBIO + 4) \| (catch), (timo), \
286	LOCK_FILE, LOCK_LINE)
287
288	/*
289	* Release a lock. Only the acquiring process may free the lock unless
290	* it has been handed off to biodone.
291	*/
292	#define BUF_UNLOCK(bp) do { \
293	KASSERT(((bp)->b_flags & B_REMFREE) == 0, \
294	("BUF_UNLOCK %p while B_REMFREE is still set.", (bp))); \
295	\
296	(void)_lockmgr_args(&(bp)->b_lock, LK_RELEASE, NULL, \
297	LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT, \
298	LOCK_FILE, LOCK_LINE); \
299	} while (0)
300
301	/*
302	* Check if a buffer lock is recursed.
303	*/
304	#define BUF_LOCKRECURSED(bp) \
305	lockmgr_recursed(&(bp)->b_lock)
306
307	/*
308	* Check if a buffer lock is currently held.
309	*/
310	#define BUF_ISLOCKED(bp) \
311	lockstatus(&(bp)->b_lock)
312	/*
313	* Free a buffer lock.
314	*/
315	#define BUF_LOCKFREE(bp) \
316	lockdestroy(&(bp)->b_lock)
317
318	/*
319	* Print informations on a buffer lock.
320	*/
321	#define BUF_LOCKPRINTINFO(bp) \
322	lockmgr_printinfo(&(bp)->b_lock)
323
324	/*
325	* Buffer lock assertions.
326	*/
327	#if defined(INVARIANTS) && defined(INVARIANT_SUPPORT)
328	#define BUF_ASSERT_LOCKED(bp) \
329	_lockmgr_assert(&(bp)->b_lock, KA_LOCKED, LOCK_FILE, LOCK_LINE)
330	#define BUF_ASSERT_SLOCKED(bp) \
331	_lockmgr_assert(&(bp)->b_lock, KA_SLOCKED, LOCK_FILE, LOCK_LINE)
332	#define BUF_ASSERT_XLOCKED(bp) \
333	_lockmgr_assert(&(bp)->b_lock, KA_XLOCKED, LOCK_FILE, LOCK_LINE)
334	#define BUF_ASSERT_UNLOCKED(bp) \
335	_lockmgr_assert(&(bp)->b_lock, KA_UNLOCKED, LOCK_FILE, LOCK_LINE)
336	#define BUF_ASSERT_HELD(bp)
337	#define BUF_ASSERT_UNHELD(bp)
338	#else
339	#define BUF_ASSERT_LOCKED(bp)
340	#define BUF_ASSERT_SLOCKED(bp)
341	#define BUF_ASSERT_XLOCKED(bp)
342	#define BUF_ASSERT_UNLOCKED(bp)
343	#define BUF_ASSERT_HELD(bp)
344	#define BUF_ASSERT_UNHELD(bp)
345	#endif
346
347	#ifdef _SYS_PROC_H_ /* Avoid #include <sys/proc.h> pollution */
348	/*
349	* When initiating asynchronous I/O, change ownership of the lock to the
350	* kernel. Once done, the lock may legally released by biodone. The
351	* original owning process can no longer acquire it recursively, but must
352	* wait until the I/O is completed and the lock has been freed by biodone.
353	*/
354	#define BUF_KERNPROC(bp) \
355	_lockmgr_disown(&(bp)->b_lock, LOCK_FILE, LOCK_LINE)
356	#endif
357
358	/*
359	* Find out if the lock has waiters or not.
360	*/
361	#define BUF_LOCKWAITERS(bp) \
362	lockmgr_waiters(&(bp)->b_lock)
363
364	#endif /* _KERNEL */
365
366	struct buf_queue_head {
367	TAILQ_HEAD(buf_queue, buf) queue;
368	daddr_t last_pblkno;
369	struct buf *insert_point;
370	struct buf *switch_point;
371	};
372
373	/*
374	* This structure describes a clustered I/O. It is stored in the b_saveaddr
375	* field of the buffer on which I/O is done. At I/O completion, cluster
376	* callback uses the structure to parcel I/O's to individual buffers, and
377	* then free's this structure.
378	*/
379	struct cluster_save {
380	long bs_bcount; /* Saved b_bcount. */
381	long bs_bufsize; /* Saved b_bufsize. */
382	void bs_saveaddr; / Saved b_addr. */
383	int bs_nchildren; /* Number of associated buffers. */
384	struct buf *bs_children; / List of associated buffers. */
385	};
386
387	#ifdef _KERNEL
388
389	static __inline int
390	bwrite(struct buf *bp)
391	{
392
393	KASSERT(bp->b_bufobj != NULL, ("bwrite: no bufobj bp=%p", bp));
394	KASSERT(bp->b_bufobj->bo_ops != NULL, ("bwrite: no bo_ops bp=%p", bp));
395	KASSERT(bp->b_bufobj->bo_ops->bop_write != NULL,
396	("bwrite: no bop_write bp=%p", bp));
397	return (BO_WRITE(bp->b_bufobj, bp));
398	}
399
400	static __inline void
401	bstrategy(struct buf *bp)
402	{
403
404	KASSERT(bp->b_bufobj != NULL, ("bstrategy: no bufobj bp=%p", bp));
405	KASSERT(bp->b_bufobj->bo_ops != NULL,
406	("bstrategy: no bo_ops bp=%p", bp));
407	KASSERT(bp->b_bufobj->bo_ops->bop_strategy != NULL,
408	("bstrategy: no bop_strategy bp=%p", bp));
409	BO_STRATEGY(bp->b_bufobj, bp);
410	}
411
412	static __inline void
413	buf_start(struct buf *bp)
414	{
415	if (bioops.io_start)
416	(*bioops.io_start)(bp);
417	}
418
419	static __inline void
420	buf_complete(struct buf *bp)
421	{
422	if (bioops.io_complete)
423	(*bioops.io_complete)(bp);
424	}
425
426	static __inline void
427	buf_deallocate(struct buf *bp)
428	{
429	if (bioops.io_deallocate)
430	(*bioops.io_deallocate)(bp);
431	BUF_LOCKFREE(bp);
432	}
433
434	static __inline int
435	buf_countdeps(struct buf *bp, int i)
436	{
437	if (bioops.io_countdeps)
438	return ((*bioops.io_countdeps)(bp, i));
439	else
440	return (0);
441	}
442
443	#endif /* _KERNEL */
444
445	/*
446	* Zero out the buffer's data area.
447	*/
448	#define clrbuf(bp) { \
449	bzero((bp)->b_data, (u_int)(bp)->b_bcount); \
450	(bp)->b_resid = 0; \
451	}
452
453	/*
454	* Flags for getblk's last parameter.
455	*/
456	#define GB_LOCK_NOWAIT 0x0001 /* Fail if we block on a buf lock. */
457	#define GB_NOCREAT 0x0002 /* Don't create a buf if not found. */
458	#define GB_NOWAIT_BD 0x0004 /* Do not wait for bufdaemon. */
459	#define GB_UNMAPPED 0x0008 /* Do not mmap buffer pages. */
460	#define GB_KVAALLOC 0x0010 /* But allocate KVA. */
461
462	#ifdef _KERNEL
463	extern int nbuf; /* The number of buffer headers */
464	extern long maxswzone; /* Max KVA for swap structures */
465	extern long maxbcache; /* Max KVA for buffer cache */
466	extern long runningbufspace;
467	extern long hibufspace;
468	extern int dirtybufthresh;
469	extern int bdwriteskip;
470	extern int dirtybufferflushes;
471	extern int altbufferflushes;
472	extern int buf_maxio; /* nominal maximum I/O for buffer */
473	extern struct buf buf; / The buffer headers. */
474	extern char buffers; / The buffer contents. */
475	extern int bufpages; /* Number of memory pages in the buffer pool. */
476	extern struct buf swbuf; / Swap I/O buffer headers. */
477	extern int nswbuf; /* Number of swap I/O buffer headers. */
478	extern int cluster_pbuf_freecnt; /* Number of pbufs for clusters */
479	extern int vnode_pbuf_freecnt; /* Number of pbufs for vnode pager */
480	extern caddr_t unmapped_buf;
481
482	void runningbufwakeup(struct buf *);
483	void waitrunningbufspace(void);
484	caddr_t kern_vfs_bio_buffer_alloc(caddr_t v, long physmem_est);
485	void bufinit(void);
486	void bdata2bio(struct buf bp, struct bio bip);
487	void bwillwrite(void);
488	int buf_dirty_count_severe(void);
489	void bremfree(struct buf *);
490	void bremfreef(struct buf ); / XXX Force bremfree, only for nfs. */
491	int bread(struct vnode , daddr_t, int, struct ucred , struct buf **);
492	int bread_gb(struct vnode , daddr_t, int, struct ucred ,
493	int gbflags, struct buf **);
494	void breada(struct vnode , daddr_t , int , int, struct ucred );
495	int breadn(struct vnode , daddr_t, int, daddr_t , int *, int,
496	struct ucred , struct buf *);
497	int breadn_flags(struct vnode , daddr_t, int, daddr_t , int *, int,
498	struct ucred , int, struct buf *);
499	void bdwrite(struct buf *);
500	void bawrite(struct buf *);
501	void babarrierwrite(struct buf *);
502	int bbarrierwrite(struct buf *);
503	void bdirty(struct buf *);
504	void bundirty(struct buf *);
505	void bufstrategy(struct bufobj , struct buf );
506	void brelse(struct buf *);
507	void bqrelse(struct buf *);
508	int vfs_bio_awrite(struct buf *);
509	struct buf * getpbuf(int *);
510	struct buf incore(struct bufobj , daddr_t);
511	struct buf gbincore(struct bufobj , daddr_t);
512	struct buf getblk(struct vnode , daddr_t, int, int, int, int);
513	struct buf *geteblk(int, int);
514	int bufwait(struct buf *);
515	int bufwrite(struct buf *);
516	void bufdone(struct buf *);
517	void bufdone_finish(struct buf *);
518	void bd_speedup(void);
519
520	int cluster_read(struct vnode *, u_quad_t, daddr_t, long,
521	struct ucred , long, int, struct buf *);
522	int cluster_wbuild(struct vnode *, long, daddr_t, int);
523	void cluster_write(struct vnode , struct buf , u_quad_t, int);
524	int cluster_read_gb(struct vnode *, u_quad_t, daddr_t, long,
525	struct ucred , long, int, int, struct buf *);
526	int cluster_wbuild_gb(struct vnode *, long, daddr_t, int, int);
527	void cluster_write_gb(struct vnode , struct buf , u_quad_t, int, int);
528	void vfs_bio_bzero_buf(struct buf *bp, int base, int size);
529	void vfs_bio_set_valid(struct buf *, int base, int size);
530	void vfs_bio_clrbuf(struct buf *);
531	void vfs_busy_pages(struct buf *, int clear_modify);
532	void vfs_unbusy_pages(struct buf *);
533	int vmapbuf(struct buf *, int);
534	void vunmapbuf(struct buf *);
535	void relpbuf(struct buf , int );
536	void brelvp(struct buf *);
537	void bgetvp(struct vnode , struct buf );
538	void pbgetbo(struct bufobj bo, struct buf bp);
539	void pbgetvp(struct vnode , struct buf );
540	void pbrelbo(struct buf *);
541	void pbrelvp(struct buf *);
542	int allocbuf(struct buf *bp, int size);
543	void reassignbuf(struct buf *);
544	struct buf trypbuf(int );
545	void bwait(struct buf , u_char, const char );
546	void bdone(struct buf *);
547	void bpin(struct buf *);
548	void bunpin(struct buf *);
549	void bunpin_wait(struct buf *);
550
551	#endif /* _KERNEL */
552
553	#endif /* !_SYS_BUF_H_ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: