[BACK]Return to vfs_default.c CVS log [TXT][DIR] Up to [local] / sys / kern

Annotation of sys/kern/vfs_default.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: vfs_default.c,v 1.34 2007/06/01 23:47:56 deraadt Exp $  */
                      2:
                      3: /*
                      4:  * Portions of this code are:
                      5:  *
                      6:  * Copyright (c) 1989, 1993
                      7:  *     The Regents of the University of California.  All rights reserved.
                      8:  * (c) UNIX System Laboratories, Inc.
                      9:  * All or some portions of this file are derived from material licensed
                     10:  * to the University of California by American Telephone and Telegraph
                     11:  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
                     12:  * the permission of UNIX System Laboratories, Inc.
                     13:  *
                     14:  * Redistribution and use in source and binary forms, with or without
                     15:  * modification, are permitted provided that the following conditions
                     16:  * are met:
                     17:  * 1. Redistributions of source code must retain the above copyright
                     18:  *    notice, this list of conditions and the following disclaimer.
                     19:  * 2. Redistributions in binary form must reproduce the above copyright
                     20:  *    notice, this list of conditions and the following disclaimer in the
                     21:  *    documentation and/or other materials provided with the distribution.
                     22:  * 3. 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:
                     39: #include <sys/param.h>
                     40: #include <sys/systm.h>
                     41: #include <sys/proc.h>
                     42: #include <sys/mount.h>
                     43: #include <sys/vnode.h>
                     44: #include <sys/namei.h>
                     45: #include <sys/malloc.h>
                     46: #include <sys/pool.h>
                     47: #include <sys/event.h>
                     48: #include <miscfs/specfs/specdev.h>
                     49:
                     50: int filt_generic_readwrite(struct knote *, long);
                     51: void filt_generic_detach(struct knote *);
                     52:
                     53: /*
                     54:  * Eliminate all activity associated with the requested vnode
                     55:  * and with all vnodes aliased to the requested vnode.
                     56:  */
                     57: int
                     58: vop_generic_revoke(void *v)
                     59: {
                     60:        struct vop_revoke_args *ap = v;
                     61:        struct vnode *vp, *vq;
                     62:        struct proc *p = curproc;
                     63:
                     64: #ifdef DIAGNOSTIC
                     65:        if ((ap->a_flags & REVOKEALL) == 0)
                     66:                panic("vop_generic_revoke");
                     67: #endif
                     68:
                     69:        vp = ap->a_vp;
                     70:
                     71:        if (vp->v_flag & VALIASED) {
                     72:                /*
                     73:                 * If a vgone (or vclean) is already in progress,
                     74:                 * wait until it is done and return.
                     75:                 */
                     76:                if (vp->v_flag & VXLOCK) {
                     77:                        vp->v_flag |= VXWANT;
                     78:                        tsleep(vp, PINOD, "vop_generic_revokeall", 0);
                     79:
                     80:                        return(0);
                     81:                }
                     82:
                     83:                /*
                     84:                 * Ensure that vp will not be vgone'd while we
                     85:                 * are eliminating its aliases.
                     86:                 */
                     87:                vp->v_flag |= VXLOCK;
                     88:                while (vp->v_flag & VALIASED) {
                     89:                        for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
                     90:                                if (vq->v_rdev != vp->v_rdev ||
                     91:                                    vq->v_type != vp->v_type || vp == vq)
                     92:                                        continue;
                     93:                                vgone(vq);
                     94:                                break;
                     95:                        }
                     96:                }
                     97:
                     98:                /*
                     99:                 * Remove the lock so that vgone below will
                    100:                 * really eliminate the vnode after which time
                    101:                 * vgone will awaken any sleepers.
                    102:                 */
                    103:                vp->v_flag &= ~VXLOCK;
                    104:        }
                    105:
                    106:        vgonel(vp, p);
                    107:
                    108:        return (0);
                    109: }
                    110:
                    111: int
                    112: vop_generic_bwrite(void *v)
                    113: {
                    114:        struct vop_bwrite_args *ap = v;
                    115:
                    116:        return (bwrite(ap->a_bp));
                    117: }
                    118:
                    119: int
                    120: vop_generic_abortop(void *v)
                    121: {
                    122:        struct vop_abortop_args *ap = v;
                    123:
                    124:        if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF)
                    125:                pool_put(&namei_pool, ap->a_cnp->cn_pnbuf);
                    126:
                    127:        return (0);
                    128: }
                    129:
                    130: /*
                    131:  * Stubs to use when there is no locking to be done on the underlying object.
                    132:  * A minimal shared lock is necessary to ensure that the underlying object
                    133:  * is not revoked while an operation is in progress. So, an active shared
                    134:  * count should be maintained in an auxiliary vnode lock structure. However,
                    135:  * that's not done now.
                    136:  */
                    137: int
                    138: vop_generic_lock(void *v)
                    139: {
                    140:        return (0);
                    141: }
                    142:
                    143: /*
                    144:  * Decrement the active use count. (Not done currently)
                    145:  */
                    146: int
                    147: vop_generic_unlock(void *v)
                    148: {
                    149:        return (0);
                    150: }
                    151:
                    152: /*
                    153:  * Return whether or not the node is in use. (Not done currently)
                    154:  */
                    155: int
                    156: vop_generic_islocked(void *v)
                    157: {
                    158:        return (0);
                    159: }
                    160:
                    161: struct filterops generic_filtops =
                    162:        { 1, NULL, filt_generic_detach, filt_generic_readwrite };
                    163:
                    164: int
                    165: vop_generic_kqfilter(void *v)
                    166: {
                    167:        struct vop_kqfilter_args *ap = v;
                    168:        struct knote *kn = ap->a_kn;
                    169:
                    170:        switch (kn->kn_filter) {
                    171:        case EVFILT_READ:
                    172:        case EVFILT_WRITE:
                    173:                kn->kn_fop = &generic_filtops;
                    174:                break;
                    175:        default:
                    176:                return (1);
                    177:        }
                    178:
                    179:        return (0);
                    180: }
                    181:
                    182: void
                    183: filt_generic_detach(struct knote *kn)
                    184: {
                    185: }
                    186:
                    187: int
                    188: filt_generic_readwrite(struct knote *kn, long hint)
                    189: {
                    190:        /*
                    191:         * filesystem is gone, so set the EOF flag and schedule
                    192:         * the knote for deletion.
                    193:         */
                    194:        if (hint == NOTE_REVOKE) {
                    195:                kn->kn_flags |= (EV_EOF | EV_ONESHOT);
                    196:                return (1);
                    197:        }
                    198:
                    199:         kn->kn_data = 0;
                    200:
                    201:         return (1);
                    202: }

CVSweb