1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000-2003 Tor Egge 5 * 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 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/fcntl.h> 35 #include <sys/file.h> 36 #include <sys/stat.h> 37 #include <sys/proc.h> 38 #include <sys/limits.h> 39 #include <sys/mount.h> 40 #include <sys/namei.h> 41 #include <sys/vnode.h> 42 #include <sys/conf.h> 43 #include <sys/filio.h> 44 #include <sys/ttycom.h> 45 #include <sys/bio.h> 46 #include <sys/buf.h> 47 #include <sys/rwlock.h> 48 #include <ufs/ufs/extattr.h> 49 #include <ufs/ufs/quota.h> 50 #include <ufs/ufs/inode.h> 51 #include <ufs/ufs/ufsmount.h> 52 #include <ufs/ufs/ufs_extern.h> 53 #include <ufs/ffs/fs.h> 54 #include <ufs/ffs/ffs_extern.h> 55 56 #include <vm/vm.h> 57 #include <vm/vm_extern.h> 58 #include <vm/vm_object.h> 59 #include <sys/kernel.h> 60 #include <sys/sysctl.h> 61 62 static int ffs_rawread_readahead(struct vnode *vp, 63 caddr_t udata, 64 off_t offset, 65 size_t len, 66 struct thread *td, 67 struct buf *bp); 68 static int ffs_rawread_main(struct vnode *vp, 69 struct uio *uio); 70 71 static int ffs_rawread_sync(struct vnode *vp); 72 73 int ffs_rawread(struct vnode *vp, struct uio *uio, int *workdone); 74 75 SYSCTL_DECL(_vfs_ffs); 76 77 static uma_zone_t ffsraw_pbuf_zone; 78 79 static int allowrawread = 1; 80 SYSCTL_INT(_vfs_ffs, OID_AUTO, allowrawread, CTLFLAG_RW, &allowrawread, 0, 81 "Flag to enable raw reads"); 82 83 static int rawreadahead = 1; 84 SYSCTL_INT(_vfs_ffs, OID_AUTO, rawreadahead, CTLFLAG_RW, &rawreadahead, 0, 85 "Flag to enable readahead for long raw reads"); 86 87 static void 88 ffs_rawread_setup(void *arg __unused) 89 { 90 91 ffsraw_pbuf_zone = pbuf_zsecond_create("ffsrawpbuf", 92 (nswbuf > 100 ) ? (nswbuf - (nswbuf >> 4)) : nswbuf - 8); 93 } 94 SYSINIT(ffs_raw, SI_SUB_VM_CONF, SI_ORDER_ANY, ffs_rawread_setup, NULL); 95 96 static int 97 ffs_rawread_sync(struct vnode *vp) 98 { 99 int error; 100 int upgraded; 101 struct bufobj *bo; 102 struct mount *mp; 103 vm_object_t obj; 104 105 /* Check for dirty mmap, pending writes and dirty buffers */ 106 bo = &vp->v_bufobj; 107 BO_LOCK(bo); 108 VI_LOCK(vp); 109 if (bo->bo_numoutput > 0 || 110 bo->bo_dirty.bv_cnt > 0 || 111 ((obj = vp->v_object) != NULL && 112 (obj->flags & OBJ_MIGHTBEDIRTY) != 0)) { 113 VI_UNLOCK(vp); 114 BO_UNLOCK(bo); 115 116 if (vn_start_write(vp, &mp, V_NOWAIT) != 0) { 117 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) 118 upgraded = 1; 119 else 120 upgraded = 0; 121 VOP_UNLOCK(vp, 0); 122 (void) vn_start_write(vp, &mp, V_WAIT); 123 VOP_LOCK(vp, LK_EXCLUSIVE); 124 } else if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) { 125 upgraded = 1; 126 /* Upgrade to exclusive lock, this might block */ 127 VOP_LOCK(vp, LK_UPGRADE); 128 } else 129 upgraded = 0; 130 131 132 VI_LOCK(vp); 133 /* Check if vnode was reclaimed while unlocked. */ 134 if ((vp->v_iflag & VI_DOOMED) != 0) { 135 VI_UNLOCK(vp); 136 if (upgraded != 0) 137 VOP_LOCK(vp, LK_DOWNGRADE); 138 vn_finished_write(mp); 139 return (EIO); 140 } 141 /* Attempt to msync mmap() regions to clean dirty mmap */ 142 if ((obj = vp->v_object) != NULL && 143 (obj->flags & OBJ_MIGHTBEDIRTY) != 0) { 144 VI_UNLOCK(vp); 145 VM_OBJECT_WLOCK(obj); 146 vm_object_page_clean(obj, 0, 0, OBJPC_SYNC); 147 VM_OBJECT_WUNLOCK(obj); 148 } else 149 VI_UNLOCK(vp); 150 151 /* Wait for pending writes to complete */ 152 BO_LOCK(bo); 153 error = bufobj_wwait(&vp->v_bufobj, 0, 0); 154 if (error != 0) { 155 /* XXX: can't happen with a zero timeout ??? */ 156 BO_UNLOCK(bo); 157 if (upgraded != 0) 158 VOP_LOCK(vp, LK_DOWNGRADE); 159 vn_finished_write(mp); 160 return (error); 161 } 162 /* Flush dirty buffers */ 163 if (bo->bo_dirty.bv_cnt > 0) { 164 BO_UNLOCK(bo); 165 if ((error = ffs_syncvnode(vp, MNT_WAIT, 0)) != 0) { 166 if (upgraded != 0) 167 VOP_LOCK(vp, LK_DOWNGRADE); 168 vn_finished_write(mp); 169 return (error); 170 } 171 BO_LOCK(bo); 172 if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0) 173 panic("ffs_rawread_sync: dirty bufs"); 174 } 175 BO_UNLOCK(bo); 176 if (upgraded != 0) 177 VOP_LOCK(vp, LK_DOWNGRADE); 178 vn_finished_write(mp); 179 } else { 180 VI_UNLOCK(vp); 181 BO_UNLOCK(bo); 182 } 183 return 0; 184 } 185 186 187 static int 188 ffs_rawread_readahead(struct vnode *vp, 189 caddr_t udata, 190 off_t offset, 191 size_t len, 192 struct thread *td, 193 struct buf *bp) 194 { 195 int error; 196 u_int iolen; 197 off_t blockno; 198 int blockoff; 199 int bsize; 200 struct vnode *dp; 201 int bforwards; 202 struct inode *ip; 203 ufs2_daddr_t blkno; 204 205 bsize = vp->v_mount->mnt_stat.f_iosize; 206 207 ip = VTOI(vp); 208 dp = ITODEVVP(ip); 209 210 iolen = ((vm_offset_t) udata) & PAGE_MASK; 211 bp->b_bcount = len; 212 if (bp->b_bcount + iolen > bp->b_kvasize) { 213 bp->b_bcount = bp->b_kvasize; 214 if (iolen != 0) 215 bp->b_bcount -= PAGE_SIZE; 216 } 217 bp->b_flags = 0; /* XXX necessary ? */ 218 bp->b_iocmd = BIO_READ; 219 bp->b_iodone = bdone; 220 bp->b_data = udata; 221 blockno = offset / bsize; 222 blockoff = (offset % bsize) / DEV_BSIZE; 223 if ((daddr_t) blockno != blockno) { 224 return EINVAL; /* blockno overflow */ 225 } 226 227 bp->b_lblkno = bp->b_blkno = blockno; 228 229 error = ufs_bmaparray(vp, bp->b_lblkno, &blkno, NULL, &bforwards, NULL); 230 if (error != 0) 231 return error; 232 if (blkno == -1) { 233 234 /* Fill holes with NULs to preserve semantics */ 235 236 if (bp->b_bcount + blockoff * DEV_BSIZE > bsize) 237 bp->b_bcount = bsize - blockoff * DEV_BSIZE; 238 bp->b_bufsize = bp->b_bcount; 239 240 if (vmapbuf(bp, 1) < 0) 241 return EFAULT; 242 243 maybe_yield(); 244 bzero(bp->b_data, bp->b_bufsize); 245 246 /* Mark operation completed (similar to bufdone()) */ 247 248 bp->b_resid = 0; 249 bp->b_flags |= B_DONE; 250 return 0; 251 } 252 bp->b_blkno = blkno + blockoff; 253 bp->b_offset = bp->b_iooffset = (blkno + blockoff) * DEV_BSIZE; 254 255 if (bp->b_bcount + blockoff * DEV_BSIZE > bsize * (1 + bforwards)) 256 bp->b_bcount = bsize * (1 + bforwards) - blockoff * DEV_BSIZE; 257 bp->b_bufsize = bp->b_bcount; 258 259 if (vmapbuf(bp, 1) < 0) 260 return EFAULT; 261 262 BO_STRATEGY(&dp->v_bufobj, bp); 263 return 0; 264 } 265 266 267 static int 268 ffs_rawread_main(struct vnode *vp, 269 struct uio *uio) 270 { 271 int error, nerror; 272 struct buf *bp, *nbp, *tbp; 273 u_int iolen; 274 caddr_t udata; 275 long resid; 276 off_t offset; 277 struct thread *td; 278 279 td = uio->uio_td ? uio->uio_td : curthread; 280 udata = uio->uio_iov->iov_base; 281 resid = uio->uio_resid; 282 offset = uio->uio_offset; 283 284 /* 285 * keep the process from being swapped 286 */ 287 PHOLD(td->td_proc); 288 289 error = 0; 290 nerror = 0; 291 292 bp = NULL; 293 nbp = NULL; 294 295 while (resid > 0) { 296 297 if (bp == NULL) { /* Setup first read */ 298 bp = uma_zalloc(ffsraw_pbuf_zone, M_WAITOK); 299 pbgetvp(vp, bp); 300 error = ffs_rawread_readahead(vp, udata, offset, 301 resid, td, bp); 302 if (error != 0) 303 break; 304 305 if (resid > bp->b_bufsize) { /* Setup fist readahead */ 306 if (rawreadahead != 0) 307 nbp = uma_zalloc(ffsraw_pbuf_zone, 308 M_NOWAIT); 309 else 310 nbp = NULL; 311 if (nbp != NULL) { 312 pbgetvp(vp, nbp); 313 314 nerror = ffs_rawread_readahead(vp, 315 udata + 316 bp->b_bufsize, 317 offset + 318 bp->b_bufsize, 319 resid - 320 bp->b_bufsize, 321 td, 322 nbp); 323 if (nerror) { 324 pbrelvp(nbp); 325 uma_zfree(ffsraw_pbuf_zone, 326 nbp); 327 nbp = NULL; 328 } 329 } 330 } 331 } 332 333 bwait(bp, PRIBIO, "rawrd"); 334 vunmapbuf(bp); 335 336 iolen = bp->b_bcount - bp->b_resid; 337 if (iolen == 0 && (bp->b_ioflags & BIO_ERROR) == 0) { 338 nerror = 0; /* Ignore possible beyond EOF error */ 339 break; /* EOF */ 340 } 341 342 if ((bp->b_ioflags & BIO_ERROR) != 0) { 343 error = bp->b_error; 344 break; 345 } 346 resid -= iolen; 347 udata += iolen; 348 offset += iolen; 349 if (iolen < bp->b_bufsize) { 350 /* Incomplete read. Try to read remaining part */ 351 error = ffs_rawread_readahead(vp, 352 udata, 353 offset, 354 bp->b_bufsize - iolen, 355 td, 356 bp); 357 if (error != 0) 358 break; 359 } else if (nbp != NULL) { /* Complete read with readahead */ 360 361 tbp = bp; 362 bp = nbp; 363 nbp = tbp; 364 365 if (resid <= bp->b_bufsize) { /* No more readaheads */ 366 pbrelvp(nbp); 367 uma_zfree(ffsraw_pbuf_zone, nbp); 368 nbp = NULL; 369 } else { /* Setup next readahead */ 370 nerror = ffs_rawread_readahead(vp, 371 udata + 372 bp->b_bufsize, 373 offset + 374 bp->b_bufsize, 375 resid - 376 bp->b_bufsize, 377 td, 378 nbp); 379 if (nerror != 0) { 380 pbrelvp(nbp); 381 uma_zfree(ffsraw_pbuf_zone, nbp); 382 nbp = NULL; 383 } 384 } 385 } else if (nerror != 0) {/* Deferred Readahead error */ 386 break; 387 } else if (resid > 0) { /* More to read, no readahead */ 388 error = ffs_rawread_readahead(vp, udata, offset, 389 resid, td, bp); 390 if (error != 0) 391 break; 392 } 393 } 394 395 if (bp != NULL) { 396 pbrelvp(bp); 397 uma_zfree(ffsraw_pbuf_zone, bp); 398 } 399 if (nbp != NULL) { /* Run down readahead buffer */ 400 bwait(nbp, PRIBIO, "rawrd"); 401 vunmapbuf(nbp); 402 pbrelvp(nbp); 403 uma_zfree(ffsraw_pbuf_zone, nbp); 404 } 405 406 if (error == 0) 407 error = nerror; 408 PRELE(td->td_proc); 409 uio->uio_iov->iov_base = udata; 410 uio->uio_resid = resid; 411 uio->uio_offset = offset; 412 return error; 413 } 414 415 416 int 417 ffs_rawread(struct vnode *vp, 418 struct uio *uio, 419 int *workdone) 420 { 421 if (allowrawread != 0 && 422 uio->uio_iovcnt == 1 && 423 uio->uio_segflg == UIO_USERSPACE && 424 uio->uio_resid == uio->uio_iov->iov_len && 425 (((uio->uio_td != NULL) ? uio->uio_td : curthread)->td_pflags & 426 TDP_DEADLKTREAT) == 0) { 427 int secsize; /* Media sector size */ 428 off_t filebytes; /* Bytes left of file */ 429 int blockbytes; /* Bytes left of file in full blocks */ 430 int partialbytes; /* Bytes in last partial block */ 431 int skipbytes; /* Bytes not to read in ffs_rawread */ 432 struct inode *ip; 433 int error; 434 435 436 /* Only handle sector aligned reads */ 437 ip = VTOI(vp); 438 secsize = ITODEVVP(ip)->v_bufobj.bo_bsize; 439 if ((uio->uio_offset & (secsize - 1)) == 0 && 440 (uio->uio_resid & (secsize - 1)) == 0) { 441 442 /* Sync dirty pages and buffers if needed */ 443 error = ffs_rawread_sync(vp); 444 if (error != 0) 445 return error; 446 447 /* Check for end of file */ 448 if (ip->i_size > uio->uio_offset) { 449 filebytes = ip->i_size - uio->uio_offset; 450 451 /* No special eof handling needed ? */ 452 if (uio->uio_resid <= filebytes) { 453 *workdone = 1; 454 return ffs_rawread_main(vp, uio); 455 } 456 457 partialbytes = ((unsigned int) ip->i_size) % 458 ITOFS(ip)->fs_bsize; 459 blockbytes = (int) filebytes - partialbytes; 460 if (blockbytes > 0) { 461 skipbytes = uio->uio_resid - 462 blockbytes; 463 uio->uio_resid = blockbytes; 464 error = ffs_rawread_main(vp, uio); 465 uio->uio_resid += skipbytes; 466 if (error != 0) 467 return error; 468 /* Read remaining part using buffer */ 469 } 470 } 471 } 472 } 473 *workdone = 0; 474 return 0; 475 } 476