sys/sys/bio.h

   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  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  *      @(#)buf.h       8.9 (Berkeley) 3/30/95
  39  * $FreeBSD$
  40  */
  41
  42 #ifndef _SYS_BIO_H_
  43 #define _SYS_BIO_H_
  44
  45 #include <sys/queue.h>
  46
  47 struct bio;
  48 struct buf;
  49 struct g_consumer;
  50 struct g_provider;
  51
  52 struct iodone_chain {
  53         long    ic_prev_flags;
  54         void    (*ic_prev_iodone) __P((struct bio *));
  55         void    *ic_prev_iodone_chain;
  56         struct {
  57                 long    ia_long;
  58                 void    *ia_ptr;
  59         }       ic_args[5];
  60 };
  61
  62 /*
  63  * The bio structure describes an I/O operation in the kernel.
  64  */
  65 struct bio {
  66         u_int   bio_cmd;                /* I/O operation. */
  67         dev_t   bio_dev;                /* Device to do I/O on. */
  68         daddr64_t bio_blkno;            /* Underlying physical block number. */
  69         off_t   bio_offset;             /* Offset into file. */
  70         long    bio_bcount;             /* Valid bytes in buffer. */
  71         caddr_t bio_data;               /* Memory, superblocks, indirect etc. */
  72         u_int   bio_flags;              /* BIO_ flags. */
  73         struct buf      *_bio_buf;      /* Parent buffer. */
  74         int     bio_error;              /* Errno for BIO_ERROR. */
  75         long    bio_resid;              /* Remaining I/0 in bytes. */
  76         void    (*bio_done) __P((struct bio *));
  77         void    *bio_driver1;           /* Private use by the callee. */
  78         void    *bio_driver2;           /* Private use by the callee. */
  79         void    *bio_caller1;           /* Private use by the caller. */
  80         void    *bio_caller2;           /* Private use by the caller. */
  81         TAILQ_ENTRY(bio) bio_queue;     /* Disksort queue. */
  82
  83         /* XXX: these go away when bio chaining is introduced */
  84         daddr64_t bio_pblkno;               /* physical block number */
  85         struct  iodone_chain *bio_done_chain;
  86         struct bio *bio_linkage;
  87         off_t   bio_length;
  88         char    *bio_attribute;
  89         off_t   bio_completed;
  90         struct g_consumer *bio_from;
  91         struct g_provider *bio_to;
  92 };
  93
  94 /* bio_cmd */
  95 #define BIO_READ        0x00000001
  96 #define BIO_WRITE       0x00000002
  97 #define BIO_DELETE      0x00000004
  98 #define BIO_FORMAT      0x00000008
  99 #define BIO_GETATTR     0x00000010
 100 #define BIO_SETATTR     0x00000020
 101 #define BIO_CMD1        0x40000000      /* Available for local hacks */
 102 #define BIO_CMD2        0x80000000      /* Available for local hacks */
 103
 104 /* bio_flags */
 105 #define BIO_ERROR       0x00000001
 106 #define BIO_DONE        0x00000004
 107 #define BIO_FLAG2       0x40000000      /* Available for local hacks */
 108 #define BIO_FLAG1       0x80000000      /* Available for local hacks */
 109
 110 #ifdef _KERNEL
 111
 112 static __inline__ void
 113 biodone(struct bio *bp)
 114 {
 115         bp->bio_flags |= BIO_DONE;
 116         bp->bio_done(bp);
 117 }
 118
 119 #ifndef _DEVICESTAT_H
 120 struct devstat;
 121 void devstat_end_transaction_bio(struct devstat *, struct bio *);
 122 #endif
 123
 124 static __inline__ void
 125 biofinish(struct bio *bp, struct devstat *stat, int error)
 126 {
 127
 128         if (error) {
 129                 bp->bio_error = error;
 130                 bp->bio_flags |= BIO_ERROR;
 131         }
 132         if (stat != NULL)
 133                 devstat_end_transaction_bio(stat, bp);
 134         biodone(bp);
 135 }
 136
 137 struct bio_queue_head {
 138         TAILQ_HEAD(bio_queue, bio) queue;
 139         daddr64_t last_pblkno;
 140         struct  bio *insert_point;
 141         struct  bio *switch_point;
 142         int busy;
 143 };
 144
 145 static __inline void bioq_init __P((struct bio_queue_head *head));
 146 static __inline void bioq_insert_tail __P((struct bio_queue_head *head,
 147                                            struct bio *bp));
 148 static __inline void bioq_remove __P((struct bio_queue_head *head,
 149                                       struct bio *bp));
 150 static __inline struct bio *bioq_first __P((struct bio_queue_head *head));
 151
 152 static __inline void
 153 bioq_init(struct bio_queue_head *head)
 154 {
 155         TAILQ_INIT(&head->queue);
 156         head->last_pblkno = 0;
 157         head->insert_point = NULL;
 158         head->switch_point = NULL;
 159 }
 160
 161 static __inline void
 162 bioq_insert_tail(struct bio_queue_head *head, struct bio *bp)
 163 {
 164
 165         TAILQ_INSERT_TAIL(&head->queue, bp, bio_queue);
 166 }
 167
 168 static __inline void
 169 bioq_remove(struct bio_queue_head *head, struct bio *bp)
 170 {
 171         if (bp == head->switch_point)
 172                 head->switch_point = TAILQ_NEXT(bp, bio_queue);
 173         if (bp == head->insert_point) {
 174                 head->insert_point = TAILQ_PREV(bp, bio_queue, bio_queue);
 175                 if (head->insert_point == NULL)
 176                         head->last_pblkno = 0;
 177         } else if (bp == TAILQ_FIRST(&head->queue))
 178                 head->last_pblkno = bp->bio_pblkno;
 179         TAILQ_REMOVE(&head->queue, bp, bio_queue);
 180         if (TAILQ_FIRST(&head->queue) == head->switch_point)
 181                 head->switch_point = NULL;
 182 }
 183
 184 static __inline struct bio *
 185 bioq_first(struct bio_queue_head *head)
 186 {
 187         return (TAILQ_FIRST(&head->queue));
 188 }
 189
 190 /*
 191  * Zero out the bio's data area.
 192  */
 193 #define clrbio(bp) {                                                    \
 194         bzero((bp)->bio_data, (u_int)(bp)->bio_bcount);                 \
 195         (bp)->bio_resid = 0;                                            \
 196 }
 197
 198 int     physio __P((dev_t dev, struct uio *uio, int ioflag));
 199 #define physread physio
 200 #define physwrite physio
 201
 202 #endif /* _KERNEL */
 203
 204 #endif /* !_SYS_BIO_H_ */