1 /* $OpenBSD: ffs_vnops.c,v 1.10 1999/12/05 08:30:38 art Exp $ */ 2 /* $NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $ */ 3 4 /* 5 * Copyright (c) 1982, 1986, 1989, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)ffs_vnops.c 8.10 (Berkeley) 8/10/94 37 */ 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/resourcevar.h> 42 #include <sys/kernel.h> 43 #include <sys/file.h> 44 #include <sys/stat.h> 45 #include <sys/buf.h> 46 #include <sys/proc.h> 47 #include <sys/conf.h> 48 #include <sys/mount.h> 49 #include <sys/vnode.h> 50 #include <sys/malloc.h> 51 #include <sys/signalvar.h> 52 53 #include <vm/vm.h> 54 55 #if defined(UVM) 56 #include <uvm/uvm_extern.h> 57 #endif 58 59 #include <miscfs/specfs/specdev.h> 60 #include <miscfs/fifofs/fifo.h> 61 62 #include <ufs/ufs/quota.h> 63 #include <ufs/ufs/inode.h> 64 #include <ufs/ufs/dir.h> 65 #include <ufs/ufs/ufs_extern.h> 66 #include <ufs/ufs/ufsmount.h> 67 68 #include <ufs/ffs/fs.h> 69 #include <ufs/ffs/ffs_extern.h> 70 71 /* Global vfs data structures for ufs. */ 72 int (**ffs_vnodeop_p) __P((void *)); 73 struct vnodeopv_entry_desc ffs_vnodeop_entries[] = { 74 { &vop_default_desc, vn_default_error }, 75 { &vop_lookup_desc, ufs_lookup }, /* lookup */ 76 { &vop_create_desc, ufs_create }, /* create */ 77 { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */ 78 { &vop_mknod_desc, ufs_mknod }, /* mknod */ 79 { &vop_open_desc, ufs_open }, /* open */ 80 { &vop_close_desc, ufs_close }, /* close */ 81 { &vop_access_desc, ufs_access }, /* access */ 82 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 83 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 84 { &vop_read_desc, ffs_read }, /* read */ 85 { &vop_write_desc, ffs_write }, /* write */ 86 { &vop_lease_desc, ufs_lease_check }, /* lease */ 87 { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */ 88 { &vop_select_desc, ufs_select }, /* select */ 89 { &vop_revoke_desc, ufs_revoke }, /* revoke */ 90 { &vop_mmap_desc, ufs_mmap }, /* mmap */ 91 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 92 { &vop_seek_desc, ufs_seek }, /* seek */ 93 { &vop_remove_desc, ufs_remove }, /* remove */ 94 { &vop_link_desc, ufs_link }, /* link */ 95 { &vop_rename_desc, ufs_rename }, /* rename */ 96 { &vop_mkdir_desc, ufs_mkdir }, /* mkdir */ 97 { &vop_rmdir_desc, ufs_rmdir }, /* rmdir */ 98 { &vop_symlink_desc, ufs_symlink }, /* symlink */ 99 { &vop_readdir_desc, ufs_readdir }, /* readdir */ 100 { &vop_readlink_desc, ufs_readlink }, /* readlink */ 101 { &vop_abortop_desc, vop_generic_abortop }, /* abortop */ 102 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 103 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 104 { &vop_lock_desc, ufs_lock }, /* lock */ 105 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 106 { &vop_bmap_desc, ufs_bmap }, /* bmap */ 107 { &vop_strategy_desc, ufs_strategy }, /* strategy */ 108 { &vop_print_desc, ufs_print }, /* print */ 109 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 110 { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */ 111 { &vop_advlock_desc, ufs_advlock }, /* advlock */ 112 { &vop_blkatoff_desc, ffs_blkatoff }, /* blkatoff */ 113 { &vop_valloc_desc, ffs_valloc }, /* valloc */ 114 { &vop_balloc_desc, ffs_balloc }, /* balloc */ 115 { &vop_reallocblks_desc, ffs_reallocblks }, /* reallocblks */ 116 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 117 { &vop_truncate_desc, ffs_truncate }, /* truncate */ 118 { &vop_update_desc, ffs_update }, /* update */ 119 { &vop_bwrite_desc, vop_generic_bwrite }, 120 { (struct vnodeop_desc*)NULL, (int(*) __P((void*)))NULL } 121 }; 122 struct vnodeopv_desc ffs_vnodeop_opv_desc = 123 { &ffs_vnodeop_p, ffs_vnodeop_entries }; 124 125 int (**ffs_specop_p) __P((void *)); 126 struct vnodeopv_entry_desc ffs_specop_entries[] = { 127 { &vop_default_desc, vn_default_error }, 128 { &vop_lookup_desc, spec_lookup }, /* lookup */ 129 { &vop_create_desc, spec_create }, /* create */ 130 { &vop_mknod_desc, spec_mknod }, /* mknod */ 131 { &vop_open_desc, spec_open }, /* open */ 132 { &vop_close_desc, ufsspec_close }, /* close */ 133 { &vop_access_desc, ufs_access }, /* access */ 134 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 135 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 136 { &vop_read_desc, ufsspec_read }, /* read */ 137 { &vop_write_desc, ufsspec_write }, /* write */ 138 { &vop_lease_desc, spec_lease_check }, /* lease */ 139 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 140 { &vop_select_desc, spec_select }, /* select */ 141 { &vop_revoke_desc, spec_revoke }, /* revoke */ 142 { &vop_mmap_desc, spec_mmap }, /* mmap */ 143 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 144 { &vop_seek_desc, spec_seek }, /* seek */ 145 { &vop_remove_desc, spec_remove }, /* remove */ 146 { &vop_link_desc, spec_link }, /* link */ 147 { &vop_rename_desc, spec_rename }, /* rename */ 148 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ 149 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ 150 { &vop_symlink_desc, spec_symlink }, /* symlink */ 151 { &vop_readdir_desc, spec_readdir }, /* readdir */ 152 { &vop_readlink_desc, spec_readlink }, /* readlink */ 153 { &vop_abortop_desc, spec_abortop }, /* abortop */ 154 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 155 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 156 { &vop_lock_desc, ufs_lock }, /* lock */ 157 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 158 { &vop_bmap_desc, spec_bmap }, /* bmap */ 159 { &vop_strategy_desc, spec_strategy }, /* strategy */ 160 { &vop_print_desc, ufs_print }, /* print */ 161 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 162 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 163 { &vop_advlock_desc, spec_advlock }, /* advlock */ 164 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 165 { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ 166 { &vop_valloc_desc, spec_valloc }, /* valloc */ 167 { &vop_reallocblks_desc, spec_reallocblks }, /* reallocblks */ 168 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 169 { &vop_truncate_desc, spec_truncate }, /* truncate */ 170 { &vop_update_desc, ffs_update }, /* update */ 171 { &vop_bwrite_desc, vop_generic_bwrite }, 172 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 173 }; 174 struct vnodeopv_desc ffs_specop_opv_desc = 175 { &ffs_specop_p, ffs_specop_entries }; 176 177 #ifdef FIFO 178 int (**ffs_fifoop_p) __P((void *)); 179 struct vnodeopv_entry_desc ffs_fifoop_entries[] = { 180 { &vop_default_desc, vn_default_error }, 181 { &vop_lookup_desc, fifo_lookup }, /* lookup */ 182 { &vop_create_desc, fifo_create }, /* create */ 183 { &vop_mknod_desc, fifo_mknod }, /* mknod */ 184 { &vop_open_desc, fifo_open }, /* open */ 185 { &vop_close_desc, ufsfifo_close }, /* close */ 186 { &vop_access_desc, ufs_access }, /* access */ 187 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 188 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 189 { &vop_read_desc, ufsfifo_read }, /* read */ 190 { &vop_write_desc, ufsfifo_write }, /* write */ 191 { &vop_lease_desc, fifo_lease_check }, /* lease */ 192 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ 193 { &vop_select_desc, fifo_select }, /* select */ 194 { &vop_revoke_desc, fifo_revoke }, /* revoke */ 195 { &vop_mmap_desc, fifo_mmap }, /* mmap */ 196 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 197 { &vop_seek_desc, fifo_seek }, /* seek */ 198 { &vop_remove_desc, fifo_remove }, /* remove */ 199 { &vop_link_desc, fifo_link }, /* link */ 200 { &vop_rename_desc, fifo_rename }, /* rename */ 201 { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */ 202 { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */ 203 { &vop_symlink_desc, fifo_symlink }, /* symlink */ 204 { &vop_readdir_desc, fifo_readdir }, /* readdir */ 205 { &vop_readlink_desc, fifo_readlink }, /* readlink */ 206 { &vop_abortop_desc, fifo_abortop }, /* abortop */ 207 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 208 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 209 { &vop_lock_desc, ufs_lock }, /* lock */ 210 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 211 { &vop_bmap_desc, fifo_bmap }, /* bmap */ 212 { &vop_strategy_desc, fifo_strategy }, /* strategy */ 213 { &vop_print_desc, ufs_print }, /* print */ 214 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 215 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */ 216 { &vop_advlock_desc, fifo_advlock }, /* advlock */ 217 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 218 { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */ 219 { &vop_valloc_desc, fifo_valloc }, /* valloc */ 220 { &vop_reallocblks_desc, fifo_reallocblks }, /* reallocblks */ 221 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 222 { &vop_truncate_desc, fifo_truncate }, /* truncate */ 223 { &vop_update_desc, ffs_update }, /* update */ 224 { &vop_bwrite_desc, vop_generic_bwrite }, 225 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 226 }; 227 struct vnodeopv_desc ffs_fifoop_opv_desc = 228 { &ffs_fifoop_p, ffs_fifoop_entries }; 229 #endif /* FIFO */ 230 231 /* 232 * Enabling cluster read/write operations. 233 */ 234 int doclusterread = 1; 235 int doclusterwrite = 1; 236 237 #include <ufs/ufs/ufs_readwrite.c> 238 239 /* 240 * Synch an open file. 241 */ 242 /* ARGSUSED */ 243 int 244 ffs_fsync(v) 245 void *v; 246 { 247 struct vop_fsync_args /* { 248 struct vnode *a_vp; 249 struct ucred *a_cred; 250 int a_waitfor; 251 struct proc *a_p; 252 } */ *ap = v; 253 struct vnode *vp = ap->a_vp; 254 struct buf *bp, *nbp; 255 struct timespec ts; 256 int s, error, passes, skipmeta; 257 258 if (vp->v_type == VBLK && 259 vp->v_specmountpoint != NULL && 260 (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP)) 261 softdep_fsync_mountdev(vp); 262 263 /* 264 * Flush all dirty buffers associated with a vnode 265 */ 266 passes = NIADDR; 267 skipmeta = 0; 268 if (ap->a_waitfor == MNT_WAIT) 269 skipmeta = 1; 270 loop: 271 s = splbio(); 272 loop2: 273 for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) { 274 nbp = bp->b_vnbufs.le_next; 275 if ((bp->b_flags & B_BUSY)) 276 continue; 277 if ((bp->b_flags & B_DELWRI) == 0) 278 panic("ffs_fsync: not dirty"); 279 if (skipmeta && bp->b_lblkno < 0) 280 continue; 281 bremfree(bp); 282 bp->b_flags |= B_BUSY; 283 splx(s); 284 /* 285 * Wait for I/O associated with indirect blocks to complete, 286 * since there is no way to quickly wait for them below. 287 */ 288 if (bp->b_vp == vp || ap->a_waitfor != MNT_WAIT) 289 (void) bawrite(bp); 290 else if ((error = bwrite(bp)) != 0) 291 return (error); 292 goto loop; 293 } 294 if (skipmeta) { 295 skipmeta = 0; 296 goto loop2; 297 } 298 if (ap->a_waitfor == MNT_WAIT) { 299 while (vp->v_numoutput) { 300 vp->v_flag |= VBWAIT; 301 sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1); 302 } 303 /* 304 * Ensure that any filesystem metatdata associated 305 * with the vnode has been written. 306 */ 307 splx(s); 308 if ((error = softdep_sync_metadata(ap)) != 0) 309 return (error); 310 s = splbio(); 311 if (vp->v_dirtyblkhd.lh_first) { 312 /* 313 * Block devices associated with filesystems may 314 * have new I/O requests posted for them even if 315 * the vnode is locked, so no amount of trying will 316 * get them clean. Thus we give block devices a 317 * good effort, then just give up. For all other file 318 * types, go around and try again until it is clean. 319 */ 320 if (passes > 0) { 321 passes -= 1; 322 goto loop2; 323 } 324 #ifdef DIAGNOSTIC 325 if (vp->v_type != VBLK) 326 vprint("ffs_fsync: dirty", vp); 327 #endif 328 } 329 } 330 splx(s); 331 TIMEVAL_TO_TIMESPEC(&time, &ts); 332 return (VOP_UPDATE(vp, &ts, &ts, ap->a_waitfor == MNT_WAIT)); 333 } 334 335 /* 336 * Reclaim an inode so that it can be used for other purposes. 337 */ 338 int 339 ffs_reclaim(v) 340 void *v; 341 { 342 struct vop_reclaim_args /* { 343 struct vnode *a_vp; 344 sturct proc *a_p; 345 } */ *ap = v; 346 register struct vnode *vp = ap->a_vp; 347 int error; 348 349 if ((error = ufs_reclaim(vp, ap->a_p)) != 0) 350 return (error); 351 FREE(vp->v_data, VFSTOUFS(vp->v_mount)->um_devvp->v_tag == VT_MFS ? 352 M_MFSNODE : M_FFSNODE); 353 vp->v_data = NULL; 354 return (0); 355 } 356