dead_vnops.c revision 1.22
1 /* $NetBSD: dead_vnops.c,v 1.22 1998/03/01 02:21:24 fvdl Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)dead_vnops.c 8.2 (Berkeley) 11/21/94 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/time.h> 41 #include <sys/vnode.h> 42 #include <sys/errno.h> 43 #include <sys/namei.h> 44 #include <sys/buf.h> 45 #include <sys/proc.h> 46 47 #include <miscfs/genfs/genfs.h> 48 49 /* 50 * Prototypes for dead operations on vnodes. 51 */ 52 int dead_lookup __P((void *)); 53 #define dead_create genfs_badop 54 #define dead_mknod genfs_badop 55 int dead_open __P((void *)); 56 #define dead_close genfs_nullop 57 #define dead_access genfs_ebadf 58 #define dead_getattr genfs_ebadf 59 #define dead_setattr genfs_ebadf 60 int dead_read __P((void *)); 61 int dead_write __P((void *)); 62 int dead_ioctl __P((void *)); 63 int dead_poll __P((void *)); 64 #define dead_mmap genfs_badop 65 #define dead_fsync genfs_nullop 66 #define dead_seek genfs_nullop 67 #define dead_remove genfs_badop 68 #define dead_link genfs_badop 69 #define dead_rename genfs_badop 70 #define dead_mkdir genfs_badop 71 #define dead_rmdir genfs_badop 72 #define dead_symlink genfs_badop 73 #define dead_readdir genfs_ebadf 74 #define dead_readlink genfs_ebadf 75 #define dead_abortop genfs_badop 76 #define dead_inactive genfs_nullop 77 #define dead_reclaim genfs_nullop 78 int dead_lock __P((void *)); 79 #define dead_unlock genfs_nullop 80 int dead_bmap __P((void *)); 81 int dead_strategy __P((void *)); 82 int dead_print __P((void *)); 83 #define dead_islocked genfs_nullop 84 #define dead_pathconf genfs_ebadf 85 #define dead_advlock genfs_ebadf 86 #define dead_blkatoff genfs_badop 87 #define dead_valloc genfs_badop 88 #define dead_vfree genfs_badop 89 #define dead_truncate genfs_nullop 90 #define dead_update genfs_nullop 91 #define dead_bwrite genfs_nullop 92 #define dead_revoke genfs_nullop 93 94 int chkvnlock __P((struct vnode *)); 95 96 int (**dead_vnodeop_p) __P((void *)); 97 98 struct vnodeopv_entry_desc dead_vnodeop_entries[] = { 99 { &vop_default_desc, vn_default_error }, 100 { &vop_lookup_desc, dead_lookup }, /* lookup */ 101 { &vop_create_desc, dead_create }, /* create */ 102 { &vop_mknod_desc, dead_mknod }, /* mknod */ 103 { &vop_open_desc, dead_open }, /* open */ 104 { &vop_close_desc, dead_close }, /* close */ 105 { &vop_access_desc, dead_access }, /* access */ 106 { &vop_getattr_desc, dead_getattr }, /* getattr */ 107 { &vop_setattr_desc, dead_setattr }, /* setattr */ 108 { &vop_read_desc, dead_read }, /* read */ 109 { &vop_write_desc, dead_write }, /* write */ 110 { &vop_ioctl_desc, dead_ioctl }, /* ioctl */ 111 { &vop_poll_desc, dead_poll }, /* poll */ 112 { &vop_revoke_desc, dead_revoke }, /* revoke */ 113 { &vop_mmap_desc, dead_mmap }, /* mmap */ 114 { &vop_fsync_desc, dead_fsync }, /* fsync */ 115 { &vop_seek_desc, dead_seek }, /* seek */ 116 { &vop_remove_desc, dead_remove }, /* remove */ 117 { &vop_link_desc, dead_link }, /* link */ 118 { &vop_rename_desc, dead_rename }, /* rename */ 119 { &vop_mkdir_desc, dead_mkdir }, /* mkdir */ 120 { &vop_rmdir_desc, dead_rmdir }, /* rmdir */ 121 { &vop_symlink_desc, dead_symlink }, /* symlink */ 122 { &vop_readdir_desc, dead_readdir }, /* readdir */ 123 { &vop_readlink_desc, dead_readlink }, /* readlink */ 124 { &vop_abortop_desc, dead_abortop }, /* abortop */ 125 { &vop_inactive_desc, dead_inactive }, /* inactive */ 126 { &vop_reclaim_desc, dead_reclaim }, /* reclaim */ 127 { &vop_lock_desc, dead_lock }, /* lock */ 128 { &vop_unlock_desc, dead_unlock }, /* unlock */ 129 { &vop_bmap_desc, dead_bmap }, /* bmap */ 130 { &vop_strategy_desc, dead_strategy }, /* strategy */ 131 { &vop_print_desc, dead_print }, /* print */ 132 { &vop_islocked_desc, dead_islocked }, /* islocked */ 133 { &vop_pathconf_desc, dead_pathconf }, /* pathconf */ 134 { &vop_advlock_desc, dead_advlock }, /* advlock */ 135 { &vop_blkatoff_desc, dead_blkatoff }, /* blkatoff */ 136 { &vop_valloc_desc, dead_valloc }, /* valloc */ 137 { &vop_vfree_desc, dead_vfree }, /* vfree */ 138 { &vop_truncate_desc, dead_truncate }, /* truncate */ 139 { &vop_update_desc, dead_update }, /* update */ 140 { &vop_bwrite_desc, dead_bwrite }, /* bwrite */ 141 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 142 }; 143 struct vnodeopv_desc dead_vnodeop_opv_desc = 144 { &dead_vnodeop_p, dead_vnodeop_entries }; 145 146 /* 147 * Trivial lookup routine that always fails. 148 */ 149 /* ARGSUSED */ 150 int 151 dead_lookup(v) 152 void *v; 153 { 154 struct vop_lookup_args /* { 155 struct vnode * a_dvp; 156 struct vnode ** a_vpp; 157 struct componentname * a_cnp; 158 } */ *ap = v; 159 160 *ap->a_vpp = NULL; 161 return (ENOTDIR); 162 } 163 164 /* 165 * Open always fails as if device did not exist. 166 */ 167 /* ARGSUSED */ 168 int 169 dead_open(v) 170 void *v; 171 { 172 173 return (ENXIO); 174 } 175 176 /* 177 * Vnode op for read 178 */ 179 /* ARGSUSED */ 180 int 181 dead_read(v) 182 void *v; 183 { 184 struct vop_read_args /* { 185 struct vnode *a_vp; 186 struct uio *a_uio; 187 int a_ioflag; 188 struct ucred *a_cred; 189 } */ *ap = v; 190 191 if (chkvnlock(ap->a_vp)) 192 panic("dead_read: lock"); 193 /* 194 * Return EOF for tty devices, EIO for others 195 */ 196 if ((ap->a_vp->v_flag & VISTTY) == 0) 197 return (EIO); 198 return (0); 199 } 200 201 /* 202 * Vnode op for write 203 */ 204 /* ARGSUSED */ 205 int 206 dead_write(v) 207 void *v; 208 { 209 struct vop_write_args /* { 210 struct vnode *a_vp; 211 struct uio *a_uio; 212 int a_ioflag; 213 struct ucred *a_cred; 214 } */ *ap = v; 215 216 if (chkvnlock(ap->a_vp)) 217 panic("dead_write: lock"); 218 return (EIO); 219 } 220 221 /* 222 * Device ioctl operation. 223 */ 224 /* ARGSUSED */ 225 int 226 dead_ioctl(v) 227 void *v; 228 { 229 struct vop_ioctl_args /* { 230 struct vnode *a_vp; 231 u_long a_command; 232 caddr_t a_data; 233 int a_fflag; 234 struct ucred *a_cred; 235 struct proc *a_p; 236 } */ *ap = v; 237 238 if (!chkvnlock(ap->a_vp)) 239 return (EBADF); 240 return (VCALL(ap->a_vp, VOFFSET(vop_ioctl), ap)); 241 } 242 243 /* ARGSUSED */ 244 int 245 dead_poll(v) 246 void *v; 247 { 248 struct vop_poll_args /* { 249 struct vnode *a_vp; 250 int a_events; 251 struct proc *a_p; 252 } */ *ap = v; 253 254 /* 255 * Let the user find out that the descriptor is gone. 256 */ 257 return (ap->a_events); 258 } 259 260 /* 261 * Just call the device strategy routine 262 */ 263 int 264 dead_strategy(v) 265 void *v; 266 { 267 268 struct vop_strategy_args /* { 269 struct buf *a_bp; 270 } */ *ap = v; 271 if (ap->a_bp->b_vp == NULL || !chkvnlock(ap->a_bp->b_vp)) { 272 ap->a_bp->b_flags |= B_ERROR; 273 biodone(ap->a_bp); 274 return (EIO); 275 } 276 return (VOP_STRATEGY(ap->a_bp)); 277 } 278 279 /* 280 * Wait until the vnode has finished changing state. 281 */ 282 int 283 dead_lock(v) 284 void *v; 285 { 286 struct vop_lock_args /* { 287 struct vnode *a_vp; 288 } */ *ap = v; 289 290 if (!chkvnlock(ap->a_vp)) 291 return (0); 292 return (VCALL(ap->a_vp, VOFFSET(vop_lock), ap)); 293 } 294 295 /* 296 * Wait until the vnode has finished changing state. 297 */ 298 int 299 dead_bmap(v) 300 void *v; 301 { 302 struct vop_bmap_args /* { 303 struct vnode *a_vp; 304 daddr_t a_bn; 305 struct vnode **a_vpp; 306 daddr_t *a_bnp; 307 int *a_runp; 308 } */ *ap = v; 309 310 if (!chkvnlock(ap->a_vp)) 311 return (EIO); 312 return (VOP_BMAP(ap->a_vp, ap->a_bn, ap->a_vpp, ap->a_bnp, ap->a_runp)); 313 } 314 315 /* 316 * Print out the contents of a dead vnode. 317 */ 318 /* ARGSUSED */ 319 int 320 dead_print(v) 321 void *v; 322 { 323 printf("tag VT_NON, dead vnode\n"); 324 return 0; 325 } 326 327 /* 328 * We have to wait during times when the vnode is 329 * in a state of change. 330 */ 331 int 332 chkvnlock(vp) 333 register struct vnode *vp; 334 { 335 int locked = 0; 336 337 while (vp->v_flag & VXLOCK) { 338 vp->v_flag |= VXWANT; 339 sleep((caddr_t)vp, PINOD); 340 locked = 1; 341 } 342 return (locked); 343 } 344
Indexes created Mon Sep 22 13:09:51 GMT 2025