ffs_vnops.c revision 1.16.2.6
1 /* $NetBSD: ffs_vnops.c,v 1.16.2.6 1999/06/02 05:05:24 chs Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 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 * @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95 36 */ 37 38 #if defined(_KERNEL) && !defined(_LKM) 39 #include "opt_uvm.h" 40 #include "opt_uvmhist.h" 41 #endif 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/resourcevar.h> 46 #include <sys/kernel.h> 47 #include <sys/file.h> 48 #include <sys/stat.h> 49 #include <sys/buf.h> 50 #include <sys/proc.h> 51 #include <sys/conf.h> 52 #include <sys/mount.h> 53 #include <sys/vnode.h> 54 #include <sys/malloc.h> 55 #include <sys/pool.h> 56 #include <sys/signalvar.h> 57 58 #include <vm/vm.h> 59 60 #if defined(UVM) 61 #include <uvm/uvm_extern.h> 62 #endif 63 64 #include <miscfs/fifofs/fifo.h> 65 #include <miscfs/genfs/genfs.h> 66 #include <miscfs/specfs/specdev.h> 67 68 #include <ufs/ufs/quota.h> 69 #include <ufs/ufs/inode.h> 70 #include <ufs/ufs/dir.h> 71 #include <ufs/ufs/ufs_extern.h> 72 #include <ufs/ufs/ufsmount.h> 73 74 #include <ufs/ffs/fs.h> 75 #include <ufs/ffs/ffs_extern.h> 76 77 /* Global vfs data structures for ufs. */ 78 int (**ffs_vnodeop_p) __P((void *)); 79 struct vnodeopv_entry_desc ffs_vnodeop_entries[] = { 80 { &vop_default_desc, vn_default_error }, 81 { &vop_lookup_desc, ufs_lookup }, /* lookup */ 82 { &vop_create_desc, ufs_create }, /* create */ 83 { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */ 84 { &vop_mknod_desc, ufs_mknod }, /* mknod */ 85 { &vop_open_desc, ufs_open }, /* open */ 86 { &vop_close_desc, ufs_close }, /* close */ 87 { &vop_access_desc, ufs_access }, /* access */ 88 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 89 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 90 { &vop_read_desc, ffs_read }, /* read */ 91 { &vop_write_desc, ffs_write }, /* write */ 92 { &vop_lease_desc, ufs_lease_check }, /* lease */ 93 { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */ 94 { &vop_poll_desc, ufs_poll }, /* poll */ 95 { &vop_revoke_desc, ufs_revoke }, /* revoke */ 96 { &vop_mmap_desc, ufs_mmap }, /* mmap */ 97 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 98 { &vop_seek_desc, ufs_seek }, /* seek */ 99 { &vop_remove_desc, ufs_remove }, /* remove */ 100 { &vop_link_desc, ufs_link }, /* link */ 101 { &vop_rename_desc, ufs_rename }, /* rename */ 102 { &vop_mkdir_desc, ufs_mkdir }, /* mkdir */ 103 { &vop_rmdir_desc, ufs_rmdir }, /* rmdir */ 104 { &vop_symlink_desc, ufs_symlink }, /* symlink */ 105 { &vop_readdir_desc, ufs_readdir }, /* readdir */ 106 { &vop_readlink_desc, ufs_readlink }, /* readlink */ 107 { &vop_abortop_desc, ufs_abortop }, /* abortop */ 108 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 109 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 110 { &vop_lock_desc, ufs_lock }, /* lock */ 111 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 112 { &vop_bmap_desc, ufs_bmap }, /* bmap */ 113 { &vop_strategy_desc, ufs_strategy }, /* strategy */ 114 { &vop_print_desc, ufs_print }, /* print */ 115 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 116 { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */ 117 { &vop_advlock_desc, ufs_advlock }, /* advlock */ 118 { &vop_blkatoff_desc, ffs_blkatoff }, /* blkatoff */ 119 { &vop_valloc_desc, ffs_valloc }, /* valloc */ 120 { &vop_reallocblks_desc, ffs_reallocblks }, /* reallocblks */ 121 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 122 { &vop_truncate_desc, ffs_truncate }, /* truncate */ 123 { &vop_update_desc, ffs_update }, /* update */ 124 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 125 #ifdef UBC 126 { &vop_getpages_desc, ffs_getpages }, /* getpages */ 127 { &vop_putpages_desc, ffs_putpages }, /* putpages */ 128 #endif 129 { NULL, NULL } 130 }; 131 struct vnodeopv_desc ffs_vnodeop_opv_desc = 132 { &ffs_vnodeop_p, ffs_vnodeop_entries }; 133 134 int (**ffs_specop_p) __P((void *)); 135 struct vnodeopv_entry_desc ffs_specop_entries[] = { 136 { &vop_default_desc, vn_default_error }, 137 { &vop_lookup_desc, spec_lookup }, /* lookup */ 138 { &vop_create_desc, spec_create }, /* create */ 139 { &vop_mknod_desc, spec_mknod }, /* mknod */ 140 { &vop_open_desc, spec_open }, /* open */ 141 { &vop_close_desc, ufsspec_close }, /* close */ 142 { &vop_access_desc, ufs_access }, /* access */ 143 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 144 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 145 { &vop_read_desc, ufsspec_read }, /* read */ 146 { &vop_write_desc, ufsspec_write }, /* write */ 147 { &vop_lease_desc, spec_lease_check }, /* lease */ 148 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 149 { &vop_poll_desc, spec_poll }, /* poll */ 150 { &vop_revoke_desc, spec_revoke }, /* revoke */ 151 { &vop_mmap_desc, spec_mmap }, /* mmap */ 152 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 153 { &vop_seek_desc, spec_seek }, /* seek */ 154 { &vop_remove_desc, spec_remove }, /* remove */ 155 { &vop_link_desc, spec_link }, /* link */ 156 { &vop_rename_desc, spec_rename }, /* rename */ 157 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ 158 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ 159 { &vop_symlink_desc, spec_symlink }, /* symlink */ 160 { &vop_readdir_desc, spec_readdir }, /* readdir */ 161 { &vop_readlink_desc, spec_readlink }, /* readlink */ 162 { &vop_abortop_desc, spec_abortop }, /* abortop */ 163 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 164 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 165 { &vop_lock_desc, ufs_lock }, /* lock */ 166 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 167 { &vop_bmap_desc, spec_bmap }, /* bmap */ 168 { &vop_strategy_desc, spec_strategy }, /* strategy */ 169 { &vop_print_desc, ufs_print }, /* print */ 170 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 171 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 172 { &vop_advlock_desc, spec_advlock }, /* advlock */ 173 { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ 174 { &vop_valloc_desc, spec_valloc }, /* valloc */ 175 { &vop_reallocblks_desc, spec_reallocblks }, /* reallocblks */ 176 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 177 { &vop_truncate_desc, spec_truncate }, /* truncate */ 178 { &vop_update_desc, ffs_update }, /* update */ 179 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 180 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 181 }; 182 struct vnodeopv_desc ffs_specop_opv_desc = 183 { &ffs_specop_p, ffs_specop_entries }; 184 185 int (**ffs_fifoop_p) __P((void *)); 186 struct vnodeopv_entry_desc ffs_fifoop_entries[] = { 187 { &vop_default_desc, vn_default_error }, 188 { &vop_lookup_desc, fifo_lookup }, /* lookup */ 189 { &vop_create_desc, fifo_create }, /* create */ 190 { &vop_mknod_desc, fifo_mknod }, /* mknod */ 191 { &vop_open_desc, fifo_open }, /* open */ 192 { &vop_close_desc, ufsfifo_close }, /* close */ 193 { &vop_access_desc, ufs_access }, /* access */ 194 { &vop_getattr_desc, ufs_getattr }, /* getattr */ 195 { &vop_setattr_desc, ufs_setattr }, /* setattr */ 196 { &vop_read_desc, ufsfifo_read }, /* read */ 197 { &vop_write_desc, ufsfifo_write }, /* write */ 198 { &vop_lease_desc, fifo_lease_check }, /* lease */ 199 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ 200 { &vop_poll_desc, fifo_poll }, /* poll */ 201 { &vop_revoke_desc, fifo_revoke }, /* revoke */ 202 { &vop_mmap_desc, fifo_mmap }, /* mmap */ 203 { &vop_fsync_desc, ffs_fsync }, /* fsync */ 204 { &vop_seek_desc, fifo_seek }, /* seek */ 205 { &vop_remove_desc, fifo_remove }, /* remove */ 206 { &vop_link_desc, fifo_link }, /* link */ 207 { &vop_rename_desc, fifo_rename }, /* rename */ 208 { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */ 209 { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */ 210 { &vop_symlink_desc, fifo_symlink }, /* symlink */ 211 { &vop_readdir_desc, fifo_readdir }, /* readdir */ 212 { &vop_readlink_desc, fifo_readlink }, /* readlink */ 213 { &vop_abortop_desc, fifo_abortop }, /* abortop */ 214 { &vop_inactive_desc, ufs_inactive }, /* inactive */ 215 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ 216 { &vop_lock_desc, ufs_lock }, /* lock */ 217 { &vop_unlock_desc, ufs_unlock }, /* unlock */ 218 { &vop_bmap_desc, fifo_bmap }, /* bmap */ 219 { &vop_strategy_desc, fifo_strategy }, /* strategy */ 220 { &vop_print_desc, ufs_print }, /* print */ 221 { &vop_islocked_desc, ufs_islocked }, /* islocked */ 222 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */ 223 { &vop_advlock_desc, fifo_advlock }, /* advlock */ 224 { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */ 225 { &vop_valloc_desc, fifo_valloc }, /* valloc */ 226 { &vop_reallocblks_desc, fifo_reallocblks }, /* reallocblks */ 227 { &vop_vfree_desc, ffs_vfree }, /* vfree */ 228 { &vop_truncate_desc, fifo_truncate }, /* truncate */ 229 { &vop_update_desc, ffs_update }, /* update */ 230 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 231 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 232 }; 233 struct vnodeopv_desc ffs_fifoop_opv_desc = 234 { &ffs_fifoop_p, ffs_fifoop_entries }; 235 236 int doclusterread = 0; 237 int doclusterwrite = 0; 238 239 #include <ufs/ufs/ufs_readwrite.c> 240 241 /* 242 * Reclaim an inode so that it can be used for other purposes. 243 */ 244 int 245 ffs_reclaim(v) 246 void *v; 247 { 248 struct vop_reclaim_args /* { 249 struct vnode *a_vp; 250 struct proc *a_p; 251 } */ *ap = v; 252 register struct vnode *vp = ap->a_vp; 253 int error; 254 255 if ((error = ufs_reclaim(vp, ap->a_p)) != 0) 256 return (error); 257 258 /* 259 * XXX MFS ends up here, too, to free an inode. Should we create 260 * XXX a separate pool for MFS inodes? 261 */ 262 pool_put(&ffs_inode_pool, vp->v_data); 263 vp->v_data = NULL; 264 return (0); 265 } 266 267 #ifdef UBC 268 #include <uvm/uvm.h> 269 270 int 271 ffs_getpages(v) 272 void *v; 273 { 274 struct vop_getpages_args /* { 275 struct vnode *a_vp; 276 vaddr_t a_offset; 277 vm_page_t *a_m; 278 int *a_count; 279 int a_centeridx; 280 vm_prot_t a_access_type; 281 int a_advice; 282 int a_flags; 283 } */ *ap = v; 284 285 int error, npages, cidx, i; 286 struct buf tmpbuf, *bp; 287 struct vnode *vp = ap->a_vp; 288 struct uvm_object *uobj = &vp->v_uvm.u_obj; 289 struct inode *ip = VTOI(vp); 290 struct fs *fs = ip->i_fs; 291 struct vm_page *pg, *pgs[16]; /* XXX 16 */ 292 struct ucred *cred = curproc->p_ucred; 293 off_t offset; 294 UVMHIST_FUNC("ffs_getpages"); UVMHIST_CALLED(ubchist); 295 296 #ifdef DIAGNOSTIC 297 if (ap->a_centeridx < 0 || ap->a_centeridx > *ap->a_count) { 298 panic("ffs_getpages: centeridx %d out of range", 299 ap->a_centeridx); 300 } 301 #endif 302 303 if (ap->a_flags & PGO_LOCKED) { 304 uvn_findpages(uobj, ap->a_offset, ap->a_count, ap->a_m, 305 UFP_NOWAIT|UFP_NOALLOC|UFP_NORDONLY); 306 307 /* XXX PGO_ALLPAGES? */ 308 return ap->a_m[ap->a_centeridx] == NULL ? 309 VM_PAGER_UNLOCK : VM_PAGER_OK; 310 } 311 312 /* vnode is VOP_LOCKed, uobj is locked */ 313 314 315 /* 316 * XXX do the findpages for our 1 page first, 317 * change asyncget to take the one page as an arg and 318 * pretend that its findpages found it. 319 */ 320 321 /* 322 * kick off a big read first to get some readahead, then 323 * get the one page we wanted. 324 */ 325 326 if ((ap->a_flags & PGO_OVERWRITE) == 0 && 327 (ap->a_offset & (MAXBSIZE - 1)) == 0) { 328 /* 329 * XXX pretty sure unlocking here is wrong. 330 */ 331 simple_unlock(&uobj->vmobjlock); 332 uvm_vnp_asyncget(vp, ap->a_offset, MAXBSIZE, fs->fs_bsize); 333 simple_lock(&uobj->vmobjlock); 334 } 335 336 /* 337 * the desired page isn't resident, we'll have to read it. 338 */ 339 340 offset = ap->a_offset + (ap->a_centeridx << PAGE_SHIFT); 341 npages = 1; 342 pg = NULL; 343 uvn_findpages(uobj, offset, &npages, &pg, 0); 344 simple_unlock(&uobj->vmobjlock); 345 346 /* 347 * if the page is already resident, just return it. 348 */ 349 350 if ((pg->flags & PG_FAKE) == 0 && 351 !((ap->a_access_type & VM_PROT_WRITE) && (pg->flags & PG_RDONLY))) { 352 ap->a_m[ap->a_centeridx] = pg; 353 return VM_PAGER_OK; 354 } 355 356 UVMHIST_LOG(ubchist, "pg %p flags 0x%x access_type 0x%x", 357 pg, (int)pg->flags, (int)ap->a_access_type, 0); 358 359 /* 360 * ok, really read the desired page. 361 */ 362 363 bp = &tmpbuf; 364 bzero(bp, sizeof *bp); 365 bp->b_lblkno = lblkno(fs, offset); 366 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL); 367 if (error) { 368 UVMHIST_LOG(ubchist, "VOP_BMAP lbn 0x%x -> %d\n", 369 bp->b_lblkno, error,0,0); 370 goto out; 371 } 372 if (bp->b_blkno == (daddr_t)-1) { 373 UVMHIST_LOG(ubchist, "lbn 0x%x -> HOLE", bp->b_lblkno,0,0,0); 374 375 /* 376 * for read faults, we can skip the block allocation 377 * by marking the page PG_RDONLY and PG_CLEAN. 378 */ 379 380 if ((ap->a_access_type & VM_PROT_WRITE) == 0) { 381 uvm_pagezero(pg); 382 pg->flags |= PG_CLEAN|PG_RDONLY; 383 UVMHIST_LOG(ubchist, "setting PG_RDONLY", 0,0,0,0); 384 goto out; 385 } 386 387 /* 388 * for write faults, we must now allocate the backing store 389 * and make sure the block is zeroed. 390 */ 391 392 error = ffs_balloc(ip, bp->b_lblkno, 393 blksize(fs, ip, bp->b_lblkno), 394 cred, NULL, &bp->b_blkno, 0); 395 if (error) { 396 UVMHIST_LOG(ubchist, "ffs_balloc lbn 0x%x -> %d", 397 bp->b_lblkno, error,0,0); 398 goto out; 399 } 400 401 simple_lock(&uobj->vmobjlock); 402 uvm_pager_dropcluster(uobj, NULL, &pg, &npages, 0, 0); 403 npages = fs->fs_bsize >> PAGE_SHIFT; 404 uvn_findpages(uobj, offset & ~((off_t)fs->fs_bsize - 1), 405 &npages, pgs, 0); 406 for (i = 0; i < npages; i++) { 407 uvm_pagezero(pgs[i]); 408 uvm_pageactivate(pgs[i]); 409 410 /* 411 * don't bother clearing mod/ref, the block is 412 * being modified anyways. 413 */ 414 415 pgs[i]->flags &= ~(PG_FAKE|PG_RDONLY); 416 } 417 cidx = (offset >> PAGE_SHIFT) - (pgs[0]->offset >> PAGE_SHIFT); 418 pg = pgs[cidx]; 419 pgs[cidx] = NULL; 420 uvm_pager_dropcluster(uobj, NULL, pgs, &npages, 0, 0); 421 simple_unlock(&uobj->vmobjlock); 422 UVMHIST_LOG(ubchist, "cleared pages",0,0,0,0); 423 goto out; 424 } 425 426 /* adjust physical blkno for partial blocks */ 427 bp->b_blkno += (offset - lblktosize(fs, bp->b_lblkno)) >> DEV_BSHIFT; 428 UVMHIST_LOG(ubchist, "vp %p bp %p lblkno 0x%x blkno 0x%x", 429 vp, bp, bp->b_lblkno, bp->b_blkno); 430 431 /* 432 * don't bother reading the pages if we're just going to 433 * overwrite them. 434 */ 435 if (ap->a_flags & PGO_OVERWRITE) { 436 UVMHIST_LOG(ubchist, "PGO_OVERWRITE",0,0,0,0); 437 438 /* XXX for now, zero the page */ 439 if (pg->flags & PG_FAKE) { 440 uvm_pagezero(pg); 441 } 442 443 goto out; 444 } 445 446 bp->b_bufsize = PAGE_SIZE; 447 bp->b_data = (void *)uvm_pagermapin(&pg, 1, NULL, M_WAITOK); 448 bp->b_bcount = bp->b_lblkno < 0 ? bp->b_bufsize : 449 min(bp->b_bufsize, fragroundup(fs, vp->v_uvm.u_size - offset)); 450 bp->b_vp = vp; 451 bp->b_flags = B_BUSY|B_READ; 452 VOP_STRATEGY(bp); 453 error = biowait(bp); 454 uvm_pagermapout((vaddr_t)bp->b_data, *ap->a_count); 455 456 out: 457 if (error) { 458 simple_lock(&uobj->vmobjlock); 459 if (pg->flags & PG_WANTED) { 460 wakeup(pg); 461 } 462 UVM_PAGE_OWN(pg, NULL); 463 uvm_lock_pageq(); 464 uvm_pagefree(pg); 465 uvm_unlock_pageq(); 466 simple_unlock(&uobj->vmobjlock); 467 } else { 468 pg->flags &= ~(PG_FAKE); 469 pmap_clear_modify(PMAP_PGARG(pg)); 470 pmap_clear_reference(PMAP_PGARG(pg)); 471 uvm_pageactivate(pg); 472 ap->a_m[ap->a_centeridx] = pg; 473 } 474 UVMHIST_LOG(ubchist, "returning, error %d", error,0,0,0); 475 return error ? VM_PAGER_ERROR : VM_PAGER_OK; 476 } 477 478 /* 479 * Vnode op for VM putpages. 480 */ 481 int 482 ffs_putpages(v) 483 void *v; 484 { 485 struct vop_putpages_args /* { 486 struct vnode *a_vp; 487 struct vm_page **a_m; 488 int a_count; 489 int a_sync; 490 int *a_rtvals; 491 } */ *ap = v; 492 493 int s, error; 494 int bsize; 495 vaddr_t kva, offset; 496 struct vm_page *pg; 497 struct buf tmpbuf, *bp; 498 struct vnode *vp = ap->a_vp; 499 struct inode *ip = VTOI(vp); 500 struct fs *fs = ip->i_fs; 501 UVMHIST_FUNC("ffs_putpages"); UVMHIST_CALLED(ubchist); 502 503 pg = ap->a_m[0]; 504 505 #ifdef DEBUG 506 /* XXX verify that pages given are in fact physically contiguous. */ 507 #endif 508 509 kva = uvm_pagermapin(ap->a_m, ap->a_count, NULL, M_WAITOK); 510 if (kva == 0) { 511 return VM_PAGER_AGAIN; 512 } 513 514 if (ap->a_sync) { 515 bp = &tmpbuf; 516 bzero(bp, sizeof *bp); 517 } 518 else { 519 struct uvm_aiobuf *abp = pool_get(uvm_aiobuf_pool, PR_WAITOK); 520 abp->aio.aiodone = uvm_aio_aiodone; 521 abp->aio.kva = kva; 522 abp->aio.npages = ap->a_count; 523 abp->aio.pd_ptr = abp; 524 /* XXX pagedaemon */ 525 abp->aio.flags = (curproc == uvm.pagedaemon_proc) ? 526 UVM_AIO_PAGEDAEMON : 0; 527 bp = &abp->buf; 528 bzero(bp, sizeof *bp); 529 bp->b_flags = B_CALL|B_ASYNC; 530 bp->b_iodone = uvm_aio_biodone; 531 } 532 533 offset = pg->offset; 534 bp->b_bufsize = ap->a_count << PAGE_SHIFT; 535 bp->b_data = (void *)kva; 536 bp->b_lblkno = lblkno(fs, offset); 537 bp->b_bcount = min(bp->b_bufsize, 538 fragroundup(fs, vp->v_uvm.u_size - offset)); 539 bp->b_flags |= B_BUSY|B_WRITE; 540 bp->b_vp = vp; 541 542 543 bsize = blksize(fs, ip, bp->b_lblkno); 544 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL); 545 if (error) { 546 UVMHIST_LOG(ubchist, "ffs_balloc -> %d", error, 0,0,0); 547 goto out; 548 } 549 550 /* this could be ifdef DIAGNOSTIC, but it's really important */ 551 if (bp->b_blkno == (daddr_t)-1) { 552 panic("ffs_putpages: no backing store vp %p lbn 0x%x", 553 vp, bp->b_lblkno); 554 } 555 556 /* adjust physical blkno for partial blocks */ 557 bp->b_blkno += (offset - lblktosize(fs, bp->b_lblkno)) >> DEV_BSHIFT; 558 UVMHIST_LOG(ubchist, "pg %p vp %p lblkno 0x%x blkno 0x%x", 559 pg, vp, bp->b_lblkno, bp->b_blkno); 560 561 s = splbio(); 562 vp->v_numoutput++; 563 splx(s); 564 VOP_STRATEGY(bp); 565 if (!ap->a_sync) { 566 return VM_PAGER_PEND; 567 } 568 error = biowait(bp); 569 570 out: 571 uvm_pagermapout(kva, ap->a_count); 572 UVMHIST_LOG(ubchist, "returning, error %d", error,0,0,0); 573 574 return error ? VM_PAGER_ERROR : VM_PAGER_OK; 575 } 576 #endif 577
Indexes created Wed Oct 22 13:09:56 GMT 2025