1 /* 2 * Copyright (c) 1982, 1986, 1989 Regents of the University of California. 3 * All rights reserved. 4 * 5 * %sccs.include.redist.c% 6 * 7 * @(#)ffs_vnops.c 7.75 (Berkeley) 05/04/92 8 */ 9 10 #include <sys/param.h> 11 #include <sys/systm.h> 12 #include <sys/resourcevar.h> 13 #include <sys/kernel.h> 14 #include <sys/file.h> 15 #include <sys/stat.h> 16 #include <sys/buf.h> 17 #include <sys/proc.h> 18 #include <sys/conf.h> 19 #include <sys/mount.h> 20 #include <sys/vnode.h> 21 #include <sys/specdev.h> 22 #include <sys/fifo.h> 23 #include <sys/malloc.h> 24 25 #include <vm/vm.h> 26 27 #include <ufs/ufs/lockf.h> 28 #include <ufs/ufs/quota.h> 29 #include <ufs/ufs/inode.h> 30 #include <ufs/ufs/dir.h> 31 #include <ufs/ufs/ufs_extern.h> 32 33 #include <ufs/ffs/fs.h> 34 #include <ufs/ffs/ffs_extern.h> 35 36 /* Global vfs data structures for ufs. */ 37 struct vnodeops ffs_vnodeops = { 38 ufs_lookup, /* lookup */ 39 ufs_create, /* create */ 40 ufs_mknod, /* mknod */ 41 ufs_open, /* open */ 42 ufs_close, /* close */ 43 ufs_access, /* access */ 44 ufs_getattr, /* getattr */ 45 ufs_setattr, /* setattr */ 46 ffs_read, /* read */ 47 ffs_write, /* write */ 48 ufs_ioctl, /* ioctl */ 49 ufs_select, /* select */ 50 ufs_mmap, /* mmap */ 51 ffs_fsync, /* fsync */ 52 ufs_seek, /* seek */ 53 ufs_remove, /* remove */ 54 ufs_link, /* link */ 55 ufs_rename, /* rename */ 56 ufs_mkdir, /* mkdir */ 57 ufs_rmdir, /* rmdir */ 58 ufs_symlink, /* symlink */ 59 ufs_readdir, /* readdir */ 60 ufs_readlink, /* readlink */ 61 ufs_abortop, /* abortop */ 62 ffs_inactive, /* inactive */ 63 ufs_reclaim, /* reclaim */ 64 ufs_lock, /* lock */ 65 ufs_unlock, /* unlock */ 66 ffs_bmap, /* bmap */ 67 ufs_strategy, /* strategy */ 68 ufs_print, /* print */ 69 ufs_islocked, /* islocked */ 70 ufs_advlock, /* advlock */ 71 ffs_blkatoff, /* blkatoff */ 72 ffs_vget, /* vget */ 73 ffs_valloc, /* valloc */ 74 ffs_vfree, /* vfree */ 75 ffs_truncate, /* truncate */ 76 ffs_update, /* update */ 77 bwrite, /* bwrite */ 78 }; 79 80 struct vnodeops ffs_specops = { 81 spec_lookup, /* lookup */ 82 spec_create, /* create */ 83 spec_mknod, /* mknod */ 84 spec_open, /* open */ 85 ufsspec_close, /* close */ 86 ufs_access, /* access */ 87 ufs_getattr, /* getattr */ 88 ufs_setattr, /* setattr */ 89 ufsspec_read, /* read */ 90 ufsspec_write, /* write */ 91 spec_ioctl, /* ioctl */ 92 spec_select, /* select */ 93 spec_mmap, /* mmap */ 94 spec_fsync, /* fsync */ 95 spec_seek, /* seek */ 96 spec_remove, /* remove */ 97 spec_link, /* link */ 98 spec_rename, /* rename */ 99 spec_mkdir, /* mkdir */ 100 spec_rmdir, /* rmdir */ 101 spec_symlink, /* symlink */ 102 spec_readdir, /* readdir */ 103 spec_readlink, /* readlink */ 104 spec_abortop, /* abortop */ 105 ffs_inactive, /* inactive */ 106 ufs_reclaim, /* reclaim */ 107 ufs_lock, /* lock */ 108 ufs_unlock, /* unlock */ 109 spec_bmap, /* bmap */ 110 spec_strategy, /* strategy */ 111 ufs_print, /* print */ 112 ufs_islocked, /* islocked */ 113 spec_advlock, /* advlock */ 114 spec_blkatoff, /* blkatoff */ 115 spec_vget, /* vget */ 116 spec_valloc, /* valloc */ 117 spec_vfree, /* vfree */ 118 spec_truncate, /* truncate */ 119 ffs_update, /* update */ 120 bwrite, /* bwrite */ 121 }; 122 123 #ifdef FIFO 124 struct vnodeops ffs_fifoops = { 125 fifo_lookup, /* lookup */ 126 fifo_create, /* create */ 127 fifo_mknod, /* mknod */ 128 fifo_open, /* open */ 129 ufsfifo_close, /* close */ 130 ufs_access, /* access */ 131 ufs_getattr, /* getattr */ 132 ufs_setattr, /* setattr */ 133 ufsfifo_read, /* read */ 134 ufsfifo_write, /* write */ 135 fifo_ioctl, /* ioctl */ 136 fifo_select, /* select */ 137 fifo_mmap, /* mmap */ 138 fifo_fsync, /* fsync */ 139 fifo_seek, /* seek */ 140 fifo_remove, /* remove */ 141 fifo_link, /* link */ 142 fifo_rename, /* rename */ 143 fifo_mkdir, /* mkdir */ 144 fifo_rmdir, /* rmdir */ 145 fifo_symlink, /* symlink */ 146 fifo_readdir, /* readdir */ 147 fifo_readlink, /* readlink */ 148 fifo_abortop, /* abortop */ 149 ffs_inactive, /* inactive */ 150 ufs_reclaim, /* reclaim */ 151 ufs_lock, /* lock */ 152 ufs_unlock, /* unlock */ 153 fifo_bmap, /* bmap */ 154 fifo_strategy, /* strategy */ 155 ufs_print, /* print */ 156 ufs_islocked, /* islocked */ 157 fifo_advlock, /* advlock */ 158 fifo_blkatoff, /* blkatoff */ 159 fifo_vget, /* vget */ 160 fifo_valloc, /* valloc */ 161 fifo_vfree, /* vfree */ 162 fifo_truncate, /* truncate */ 163 ffs_update, /* update */ 164 bwrite, /* bwrite */ 165 }; 166 #endif /* FIFO */ 167 168 169 /* 170 * Vnode op for reading. 171 */ 172 /* ARGSUSED */ 173 ffs_read(vp, uio, ioflag, cred) 174 struct vnode *vp; 175 register struct uio *uio; 176 int ioflag; 177 struct ucred *cred; 178 { 179 register struct inode *ip = VTOI(vp); 180 register struct fs *fs; 181 struct buf *bp; 182 daddr_t lbn, bn, rablock; 183 off_t diff; 184 int rasize, error = 0; 185 long size, n, on; 186 187 #ifdef DIAGNOSTIC 188 int type; 189 if (uio->uio_rw != UIO_READ) 190 panic("ffs_read mode"); 191 type = ip->i_mode & IFMT; 192 if (type != IFDIR && type != IFREG && type != IFLNK) 193 panic("ffs_read type"); 194 #endif 195 if (uio->uio_resid == 0) 196 return (0); 197 if (uio->uio_offset < 0) 198 return (EINVAL); 199 ip->i_flag |= IACC; 200 fs = ip->i_fs; 201 do { 202 lbn = lblkno(fs, uio->uio_offset); 203 on = blkoff(fs, uio->uio_offset); 204 n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid); 205 diff = ip->i_size - uio->uio_offset; 206 if (diff <= 0) 207 return (0); 208 if (diff < n) 209 n = diff; 210 size = blksize(fs, ip, lbn); 211 rablock = lbn + 1; 212 if (vp->v_lastr + 1 == lbn && 213 lblktosize(fs, rablock) < ip->i_size) { 214 rasize = blksize(fs, ip, rablock); 215 error = breadn(vp, lbn, size, &rablock, 216 &rasize, 1, NOCRED, &bp); 217 } else 218 error = bread(vp, lbn, size, NOCRED, &bp); 219 vp->v_lastr = lbn; 220 n = MIN(n, size - bp->b_resid); 221 if (error) { 222 brelse(bp); 223 return (error); 224 } 225 error = uiomove(bp->b_un.b_addr + on, (int)n, uio); 226 if (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size) 227 bp->b_flags |= B_AGE; 228 brelse(bp); 229 } while (error == 0 && uio->uio_resid > 0 && n != 0); 230 return (error); 231 } 232 233 /* 234 * Vnode op for writing. 235 */ 236 ffs_write(vp, uio, ioflag, cred) 237 register struct vnode *vp; 238 struct uio *uio; 239 int ioflag; 240 struct ucred *cred; 241 { 242 struct proc *p = uio->uio_procp; 243 register struct inode *ip = VTOI(vp); 244 register struct fs *fs; 245 struct buf *bp; 246 daddr_t lbn, bn; 247 off_t osize; 248 int n, on, flags; 249 int size, resid, error = 0; 250 251 #ifdef DIAGNOSTIC 252 if (uio->uio_rw != UIO_WRITE) 253 panic("ffs_write mode"); 254 #endif 255 switch (vp->v_type) { 256 case VREG: 257 if (ioflag & IO_APPEND) 258 uio->uio_offset = ip->i_size; 259 /* fall through */ 260 case VLNK: 261 break; 262 263 case VDIR: 264 if ((ioflag & IO_SYNC) == 0) 265 panic("ffs_write nonsync dir write"); 266 break; 267 268 default: 269 panic("ffs_write type"); 270 } 271 if (uio->uio_offset < 0) 272 return (EINVAL); 273 if (uio->uio_resid == 0) 274 return (0); 275 /* 276 * Maybe this should be above the vnode op call, but so long as 277 * file servers have no limits, i don't think it matters 278 */ 279 if (vp->v_type == VREG && p && 280 uio->uio_offset + uio->uio_resid > 281 p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { 282 psignal(p, SIGXFSZ); 283 return (EFBIG); 284 } 285 resid = uio->uio_resid; 286 osize = ip->i_size; 287 fs = ip->i_fs; 288 flags = 0; 289 if (ioflag & IO_SYNC) 290 flags = B_SYNC; 291 do { 292 lbn = lblkno(fs, uio->uio_offset); 293 on = blkoff(fs, uio->uio_offset); 294 n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid); 295 if (n < fs->fs_bsize) 296 flags |= B_CLRBUF; 297 else 298 flags &= ~B_CLRBUF; 299 if (error = ffs_balloc(ip, lbn, on + n, cred, &bp, flags)) 300 break; 301 bn = bp->b_blkno; 302 if (uio->uio_offset + n > ip->i_size) { 303 ip->i_size = uio->uio_offset + n; 304 vnode_pager_setsize(vp, (u_long)ip->i_size); 305 } 306 size = blksize(fs, ip, lbn); 307 (void) vnode_pager_uncache(vp); 308 n = MIN(n, size - bp->b_resid); 309 error = uiomove(bp->b_un.b_addr + on, n, uio); 310 if (ioflag & IO_SYNC) 311 (void) bwrite(bp); 312 else if (n + on == fs->fs_bsize) { 313 bp->b_flags |= B_AGE; 314 bawrite(bp); 315 } else 316 bdwrite(bp); 317 ip->i_flag |= IUPD|ICHG; 318 if (cred->cr_uid != 0) 319 ip->i_mode &= ~(ISUID|ISGID); 320 } while (error == 0 && uio->uio_resid > 0 && n != 0); 321 if (error && (ioflag & IO_UNIT)) { 322 (void)ffs_truncate(vp, osize, ioflag & IO_SYNC, cred); 323 uio->uio_offset -= resid - uio->uio_resid; 324 uio->uio_resid = resid; 325 } 326 if (!error && (ioflag & IO_SYNC)) 327 error = ffs_update(vp, &time, &time, 1); 328 return (error); 329 } 330 331 /* 332 * Synch an open file. 333 */ 334 /* ARGSUSED */ 335 int 336 ffs_fsync(vp, fflags, cred, waitfor, p) 337 struct vnode *vp; 338 int fflags; 339 struct ucred *cred; 340 int waitfor; 341 struct proc *p; 342 { 343 struct inode *ip = VTOI(vp); 344 345 if (fflags & FWRITE) 346 ip->i_flag |= ICHG; 347 vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0); 348 return (ffs_update(vp, &time, &time, waitfor == MNT_WAIT)); 349 } 350 351 /* 352 * Last reference to an inode, write the inode out and if necessary, 353 * truncate and deallocate the file. 354 */ 355 int 356 ffs_inactive(vp, p) 357 struct vnode *vp; 358 struct proc *p; 359 { 360 register struct inode *ip; 361 int mode, error; 362 extern int prtactive; 363 364 if (prtactive && vp->v_usecount != 0) 365 vprint("ffs_inactive: pushing active", vp); 366 367 /* Get rid of inodes related to stale file handles. */ 368 ip = VTOI(vp); 369 if (ip->i_mode == 0) { 370 if ((vp->v_flag & VXLOCK) == 0) 371 vgone(vp); 372 return (0); 373 } 374 375 error = 0; 376 ILOCK(ip); 377 if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 378 #ifdef QUOTA 379 if (!getinoquota(ip)) 380 (void)chkiq(ip, -1, NOCRED, 0); 381 #endif 382 error = ffs_truncate(vp, (off_t)0, 0, NOCRED); 383 mode = ip->i_mode; 384 ip->i_mode = 0; 385 ip->i_rdev = 0; 386 ip->i_flag |= IUPD|ICHG; 387 ffs_vfree(vp, ip->i_number, mode); 388 } 389 if (ip->i_flag&(IUPD|IACC|ICHG|IMOD)) 390 ffs_update(vp, &time, &time, 0); 391 IUNLOCK(ip); 392 ip->i_flag = 0; 393 /* 394 * If we are done with the inode, reclaim it 395 * so that it can be reused immediately. 396 */ 397 if (vp->v_usecount == 0 && ip->i_mode == 0) 398 vgone(vp); 399 return (error); 400 } 401