Return to vfs_bio.c CVS log

Up to [Net/2] / Net2 / kern

Annotation of Net2/kern/vfs_bio.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     from: @(#)vfs_bio.c     7.40 (Berkeley) 5/8/91
        !            34:  */
        !            35: 
        !            36: #include "param.h"
        !            37: #include "proc.h"
        !            38: #include "buf.h"
        !            39: #include "vnode.h"
        !            40: #include "specdev.h"
        !            41: #include "mount.h"
        !            42: #include "trace.h"
        !            43: #include "resourcevar.h"
        !            44: 
        !            45: /*
        !            46:  * Initialize buffers and hash links for buffers.
        !            47:  */
        !            48: bufinit()
        !            49: {
        !            50: 
        !            51:        /*
        !            52:         * Body deleted.
        !            53:         */
        !            54:        return;
        !            55: }
        !            56: 
        !            57: /*
        !            58:  * Find the block in the buffer pool.
        !            59:  * If the buffer is not present, allocate a new buffer and load
        !            60:  * its contents according to the filesystem fill routine.
        !            61:  */
        !            62: bread(vp, blkno, size, cred, bpp)
        !            63:        struct vnode *vp;
        !            64:        daddr_t blkno;
        !            65:        int size;
        !            66:        struct ucred *cred;
        !            67:        struct buf **bpp;
        !            68: {
        !            69: 
        !            70:        /*
        !            71:         * Body deleted.
        !            72:         */
        !            73:        return (EIO);
        !            74: }
        !            75: 
        !            76: /*
        !            77:  * Operates like bread, but also starts I/O on the specified
        !            78:  * read-ahead block.
        !            79:  */
        !            80: breada(vp, blkno, size, rablkno, rabsize, cred, bpp)
        !            81:        struct vnode *vp;
        !            82:        daddr_t blkno; int size;
        !            83:        daddr_t rablkno; int rabsize;
        !            84:        struct ucred *cred;
        !            85:        struct buf **bpp;
        !            86: {
        !            87: 
        !            88:        /*
        !            89:         * Body deleted.
        !            90:         */
        !            91:        return (EIO);
        !            92: }
        !            93: 
        !            94: /*
        !            95:  * Synchronous write.
        !            96:  * Release buffer on completion.
        !            97:  */
        !            98: bwrite(bp)
        !            99:        register struct buf *bp;
        !           100: {
        !           101: 
        !           102:        /*
        !           103:         * Body deleted.
        !           104:         */
        !           105:        return (EIO);
        !           106: }
        !           107: 
        !           108: /*
        !           109:  * Delayed write.
        !           110:  *
        !           111:  * The buffer is marked dirty, but is not queued for I/O.
        !           112:  * This routine should be used when the buffer is expected
        !           113:  * to be modified again soon, typically a small write that
        !           114:  * partially fills a buffer.
        !           115:  *
        !           116:  * NB: magnetic tapes cannot be delayed; they must be
        !           117:  * written in the order that the writes are requested.
        !           118:  */
        !           119: bdwrite(bp)
        !           120:        register struct buf *bp;
        !           121: {
        !           122: 
        !           123:        /*
        !           124:         * Body deleted.
        !           125:         */
        !           126:        return;
        !           127: }
        !           128: 
        !           129: /*
        !           130:  * Asynchronous write.
        !           131:  * Start I/O on a buffer, but do not wait for it to complete.
        !           132:  * The buffer is released when the I/O completes.
        !           133:  */
        !           134: bawrite(bp)
        !           135:        register struct buf *bp;
        !           136: {
        !           137: 
        !           138:        /*
        !           139:         * Body deleted.
        !           140:         */
        !           141:        return;
        !           142: }
        !           143: 
        !           144: /*
        !           145:  * Release a buffer.
        !           146:  * Even if the buffer is dirty, no I/O is started.
        !           147:  */
        !           148: brelse(bp)
        !           149:        register struct buf *bp;
        !           150: {
        !           151: 
        !           152:        /*
        !           153:         * Body deleted.
        !           154:         */
        !           155:        return;
        !           156: }
        !           157: 
        !           158: /*
        !           159:  * Check to see if a block is currently memory resident.
        !           160:  */
        !           161: incore(vp, blkno)
        !           162:        struct vnode *vp;
        !           163:        daddr_t blkno;
        !           164: {
        !           165: 
        !           166:        /*
        !           167:         * Body deleted.
        !           168:         */
        !           169:        return (0);
        !           170: }
        !           171: 
        !           172: /*
        !           173:  * Check to see if a block is currently memory resident.
        !           174:  * If it is resident, return it. If it is not resident,
        !           175:  * allocate a new buffer and assign it to the block.
        !           176:  */
        !           177: struct buf *
        !           178: getblk(vp, blkno, size)
        !           179:        register struct vnode *vp;
        !           180:        daddr_t blkno;
        !           181:        int size;
        !           182: {
        !           183: 
        !           184:        /*
        !           185:         * Body deleted.
        !           186:         */
        !           187:        return (0);
        !           188: }
        !           189: 
        !           190: /*
        !           191:  * Allocate a buffer.
        !           192:  * The caller will assign it to a block.
        !           193:  */
        !           194: struct buf *
        !           195: geteblk(size)
        !           196:        int size;
        !           197: {
        !           198: 
        !           199:        /*
        !           200:         * Body deleted.
        !           201:         */
        !           202:        return (0);
        !           203: }
        !           204: 
        !           205: /*
        !           206:  * Expand or contract the actual memory allocated to a buffer.
        !           207:  * If no memory is available, release buffer and take error exit.
        !           208:  */
        !           209: allocbuf(tp, size)
        !           210:        register struct buf *tp;
        !           211:        int size;
        !           212: {
        !           213: 
        !           214:        /*
        !           215:         * Body deleted.
        !           216:         */
        !           217:        return (0);
        !           218: }
        !           219: 
        !           220: /*
        !           221:  * Find a buffer which is available for use.
        !           222:  * Select something from a free list.
        !           223:  * Preference is to AGE list, then LRU list.
        !           224:  */
        !           225: struct buf *
        !           226: getnewbuf()
        !           227: {
        !           228: 
        !           229:        /*
        !           230:         * Body deleted.
        !           231:         */
        !           232:        return (0);
        !           233: }
        !           234: 
        !           235: /*
        !           236:  * Wait for I/O to complete.
        !           237:  *
        !           238:  * Extract and return any errors associated with the I/O.
        !           239:  * If the error flag is set, but no specific error is
        !           240:  * given, return EIO.
        !           241:  */
        !           242: biowait(bp)
        !           243:        register struct buf *bp;
        !           244: {
        !           245: 
        !           246:        /*
        !           247:         * Body deleted.
        !           248:         */
        !           249:        return (EIO);
        !           250: }
        !           251: 
        !           252: /*
        !           253:  * Mark I/O complete on a buffer.
        !           254:  *
        !           255:  * If a callback has been requested, e.g. the pageout
        !           256:  * daemon, do so. Otherwise, awaken waiting processes.
        !           257:  */
        !           258: biodone(bp)
        !           259:        register struct buf *bp;
        !           260: {
        !           261: 
        !           262:        /*
        !           263:         * Body deleted.
        !           264:         */
        !           265:         return;
        !           266: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.