lfs_segment.c revision 1.53
1 /* $NetBSD: lfs_segment.c,v 1.53 2000/07/03 01:45:52 perseant Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant (at) hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 /* 39 * Copyright (c) 1991, 1993 40 * The Regents of the University of California. All rights reserved. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. All advertising materials mentioning features or use of this software 51 * must display the following acknowledgement: 52 * This product includes software developed by the University of 53 * California, Berkeley and its contributors. 54 * 4. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 * 70 * @(#)lfs_segment.c 8.10 (Berkeley) 6/10/95 71 */ 72 73 #define ivndebug(vp,str) printf("ino %d: %s\n",VTOI(vp)->i_number,(str)) 74 75 #include "opt_ddb.h" 76 #include <sys/param.h> 77 #include <sys/systm.h> 78 #include <sys/namei.h> 79 #include <sys/kernel.h> 80 #include <sys/resourcevar.h> 81 #include <sys/file.h> 82 #include <sys/stat.h> 83 #include <sys/buf.h> 84 #include <sys/proc.h> 85 #include <sys/conf.h> 86 #include <sys/vnode.h> 87 #include <sys/malloc.h> 88 #include <sys/mount.h> 89 90 #include <miscfs/specfs/specdev.h> 91 #include <miscfs/fifofs/fifo.h> 92 93 #include <ufs/ufs/quota.h> 94 #include <ufs/ufs/inode.h> 95 #include <ufs/ufs/dir.h> 96 #include <ufs/ufs/ufsmount.h> 97 #include <ufs/ufs/ufs_extern.h> 98 99 #include <ufs/lfs/lfs.h> 100 #include <ufs/lfs/lfs_extern.h> 101 102 extern int count_lock_queue __P((void)); 103 extern struct simplelock vnode_free_list_slock; /* XXX */ 104 105 /* 106 * Determine if it's OK to start a partial in this segment, or if we need 107 * to go on to a new segment. 108 */ 109 #define LFS_PARTIAL_FITS(fs) \ 110 ((fs)->lfs_dbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \ 111 1 << (fs)->lfs_fsbtodb) 112 113 void lfs_callback __P((struct buf *)); 114 int lfs_gather __P((struct lfs *, struct segment *, 115 struct vnode *, int (*) __P((struct lfs *, struct buf *)))); 116 int lfs_gatherblock __P((struct segment *, struct buf *, int *)); 117 void lfs_iset __P((struct inode *, ufs_daddr_t, time_t)); 118 int lfs_match_fake __P((struct lfs *, struct buf *)); 119 int lfs_match_data __P((struct lfs *, struct buf *)); 120 int lfs_match_dindir __P((struct lfs *, struct buf *)); 121 int lfs_match_indir __P((struct lfs *, struct buf *)); 122 int lfs_match_tindir __P((struct lfs *, struct buf *)); 123 void lfs_newseg __P((struct lfs *)); 124 void lfs_shellsort __P((struct buf **, ufs_daddr_t *, int)); 125 void lfs_supercallback __P((struct buf *)); 126 void lfs_updatemeta __P((struct segment *)); 127 int lfs_vref __P((struct vnode *)); 128 void lfs_vunref __P((struct vnode *)); 129 void lfs_writefile __P((struct lfs *, struct segment *, struct vnode *)); 130 int lfs_writeinode __P((struct lfs *, struct segment *, struct inode *)); 131 int lfs_writeseg __P((struct lfs *, struct segment *)); 132 void lfs_writesuper __P((struct lfs *, daddr_t)); 133 int lfs_writevnodes __P((struct lfs *fs, struct mount *mp, 134 struct segment *sp, int dirops)); 135 136 int lfs_allclean_wakeup; /* Cleaner wakeup address. */ 137 int lfs_writeindir = 1; /* whether to flush indir on non-ckp */ 138 int lfs_clean_vnhead = 0; /* Allow freeing to head of vn list */ 139 int lfs_dirvcount = 0; /* # active dirops */ 140 141 /* Statistics Counters */ 142 int lfs_dostats = 1; 143 struct lfs_stats lfs_stats; 144 145 /* op values to lfs_writevnodes */ 146 #define VN_REG 0 147 #define VN_DIROP 1 148 #define VN_EMPTY 2 149 #define VN_CLEAN 3 150 151 #define LFS_MAX_ACTIVE 10 152 153 /* 154 * XXX KS - Set modification time on the Ifile, so the cleaner can 155 * read the fs mod time off of it. We don't set IN_UPDATE here, 156 * since we don't really need this to be flushed to disk (and in any 157 * case that wouldn't happen to the Ifile until we checkpoint). 158 */ 159 void 160 lfs_imtime(fs) 161 struct lfs *fs; 162 { 163 struct timespec ts; 164 struct inode *ip; 165 166 TIMEVAL_TO_TIMESPEC(&time, &ts); 167 ip = VTOI(fs->lfs_ivnode); 168 ip->i_ffs_mtime = ts.tv_sec; 169 ip->i_ffs_mtimensec = ts.tv_nsec; 170 } 171 172 /* 173 * Ifile and meta data blocks are not marked busy, so segment writes MUST be 174 * single threaded. Currently, there are two paths into lfs_segwrite, sync() 175 * and getnewbuf(). They both mark the file system busy. Lfs_vflush() 176 * explicitly marks the file system busy. So lfs_segwrite is safe. I think. 177 */ 178 179 #define SET_FLUSHING(fs,vp) (fs)->lfs_flushvp = (vp) 180 #define IS_FLUSHING(fs,vp) ((fs)->lfs_flushvp == (vp)) 181 #define CLR_FLUSHING(fs,vp) (fs)->lfs_flushvp = NULL 182 183 int 184 lfs_vflush(vp) 185 struct vnode *vp; 186 { 187 struct inode *ip; 188 struct lfs *fs; 189 struct segment *sp; 190 struct buf *bp, *nbp, *tbp, *tnbp; 191 int error, s; 192 193 ip = VTOI(vp); 194 fs = VFSTOUFS(vp->v_mount)->um_lfs; 195 196 if(ip->i_flag & IN_CLEANING) { 197 #ifdef DEBUG_LFS 198 ivndebug(vp,"vflush/in_cleaning"); 199 #endif 200 ip->i_flag &= ~IN_CLEANING; 201 if(ip->i_flag & (IN_MODIFIED | IN_ACCESSED)) { 202 fs->lfs_uinodes--; 203 } else 204 ip->i_flag |= IN_MODIFIED; 205 /* 206 * Toss any cleaning buffers that have real counterparts 207 * to avoid losing new data 208 */ 209 s = splbio(); 210 for(bp=vp->v_dirtyblkhd.lh_first; bp; bp=nbp) { 211 nbp = bp->b_vnbufs.le_next; 212 if(bp->b_flags & B_CALL) { 213 for(tbp=vp->v_dirtyblkhd.lh_first; tbp; 214 tbp=tnbp) 215 { 216 tnbp = tbp->b_vnbufs.le_next; 217 if(tbp->b_vp == bp->b_vp 218 && tbp->b_lblkno == bp->b_lblkno 219 && tbp != bp) 220 { 221 lfs_freebuf(bp); 222 } 223 } 224 } 225 } 226 splx(s); 227 } 228 229 /* If the node is being written, wait until that is done */ 230 if(WRITEINPROG(vp)) { 231 #ifdef DEBUG_LFS 232 ivndebug(vp,"vflush/writeinprog"); 233 #endif 234 tsleep(vp, PRIBIO+1, "lfs_vw", 0); 235 } 236 237 /* Protect against VXLOCK deadlock in vinvalbuf() */ 238 lfs_seglock(fs, SEGM_SYNC); 239 240 /* If we're supposed to flush a freed inode, just toss it */ 241 /* XXX - seglock, so these buffers can't be gathered, right? */ 242 if(ip->i_ffs_mode == 0) { 243 printf("lfs_vflush: ino %d is freed, not flushing\n", 244 ip->i_number); 245 s = splbio(); 246 for(bp=vp->v_dirtyblkhd.lh_first; bp; bp=nbp) { 247 nbp = bp->b_vnbufs.le_next; 248 /* Copied from lfs_writeseg */ 249 if (bp->b_flags & B_CALL) { 250 /* if B_CALL, it was created with newbuf */ 251 lfs_freebuf(bp); 252 } else { 253 bremfree(bp); 254 bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | 255 B_LOCKED | B_GATHERED); 256 bp->b_flags |= B_DONE; 257 reassignbuf(bp, vp); 258 brelse(bp); 259 } 260 } 261 splx(s); 262 if(ip->i_flag & IN_CLEANING) 263 fs->lfs_uinodes--; 264 if(ip->i_flag & (IN_MODIFIED | IN_ACCESSED)) 265 fs->lfs_uinodes--; 266 ip->i_flag &= ~IN_ALLMOD; 267 printf("lfs_vflush: done not flushing ino %d\n", 268 ip->i_number); 269 lfs_segunlock(fs); 270 return 0; 271 } 272 273 SET_FLUSHING(fs,vp); 274 if (fs->lfs_nactive > LFS_MAX_ACTIVE) { 275 error = lfs_segwrite(vp->v_mount, SEGM_SYNC|SEGM_CKP); 276 CLR_FLUSHING(fs,vp); 277 lfs_segunlock(fs); 278 return error; 279 } 280 sp = fs->lfs_sp; 281 282 if (vp->v_dirtyblkhd.lh_first == NULL) { 283 lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY); 284 } else if((ip->i_flag & IN_CLEANING) && (fs->lfs_sp->seg_flags & SEGM_CLEAN)) { 285 #ifdef DEBUG_LFS 286 ivndebug(vp,"vflush/clean"); 287 #endif 288 lfs_writevnodes(fs, vp->v_mount, sp, VN_CLEAN); 289 } 290 else if(lfs_dostats) { 291 if(vp->v_dirtyblkhd.lh_first || (VTOI(vp)->i_flag & IN_ALLMOD)) 292 ++lfs_stats.vflush_invoked; 293 #ifdef DEBUG_LFS 294 ivndebug(vp,"vflush"); 295 #endif 296 } 297 298 #ifdef DIAGNOSTIC 299 /* XXX KS This actually can happen right now, though it shouldn't(?) */ 300 if(vp->v_flag & VDIROP) { 301 printf("lfs_vflush: flushing VDIROP, this shouldn\'t be\n"); 302 /* panic("VDIROP being flushed...this can\'t happen"); */ 303 } 304 if(vp->v_usecount<0) { 305 printf("usecount=%ld\n",vp->v_usecount); 306 panic("lfs_vflush: usecount<0"); 307 } 308 #endif 309 310 do { 311 do { 312 if (vp->v_dirtyblkhd.lh_first != NULL) 313 lfs_writefile(fs, sp, vp); 314 } while (lfs_writeinode(fs, sp, ip)); 315 } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM); 316 317 if(lfs_dostats) { 318 ++lfs_stats.nwrites; 319 if (sp->seg_flags & SEGM_SYNC) 320 ++lfs_stats.nsync_writes; 321 if (sp->seg_flags & SEGM_CKP) 322 ++lfs_stats.ncheckpoints; 323 } 324 lfs_segunlock(fs); 325 326 CLR_FLUSHING(fs,vp); 327 return (0); 328 } 329 330 #ifdef DEBUG_LFS_VERBOSE 331 # define vndebug(vp,str) if(VTOI(vp)->i_flag & IN_CLEANING) printf("not writing ino %d because %s (op %d)\n",VTOI(vp)->i_number,(str),op) 332 #else 333 # define vndebug(vp,str) 334 #endif 335 336 int 337 lfs_writevnodes(fs, mp, sp, op) 338 struct lfs *fs; 339 struct mount *mp; 340 struct segment *sp; 341 int op; 342 { 343 struct inode *ip; 344 struct vnode *vp; 345 int inodes_written=0, only_cleaning; 346 int needs_unlock; 347 348 #ifndef LFS_NO_BACKVP_HACK 349 /* BEGIN HACK */ 350 #define VN_OFFSET (((caddr_t)&vp->v_mntvnodes.le_next) - (caddr_t)vp) 351 #define BACK_VP(VP) ((struct vnode *)(((caddr_t)VP->v_mntvnodes.le_prev) - VN_OFFSET)) 352 #define BEG_OF_VLIST ((struct vnode *)(((caddr_t)&mp->mnt_vnodelist.lh_first) - VN_OFFSET)) 353 354 /* Find last vnode. */ 355 loop: for (vp = mp->mnt_vnodelist.lh_first; 356 vp && vp->v_mntvnodes.le_next != NULL; 357 vp = vp->v_mntvnodes.le_next); 358 for (; vp && vp != BEG_OF_VLIST; vp = BACK_VP(vp)) { 359 #else 360 loop: 361 for (vp = mp->mnt_vnodelist.lh_first; 362 vp != NULL; 363 vp = vp->v_mntvnodes.le_next) { 364 #endif 365 /* 366 * If the vnode that we are about to sync is no longer 367 * associated with this mount point, start over. 368 */ 369 if (vp->v_mount != mp) 370 goto loop; 371 372 ip = VTOI(vp); 373 if ((op == VN_DIROP && !(vp->v_flag & VDIROP)) || 374 (op != VN_DIROP && op != VN_CLEAN && (vp->v_flag & VDIROP))) { 375 vndebug(vp,"dirop"); 376 continue; 377 } 378 379 if (op == VN_EMPTY && vp->v_dirtyblkhd.lh_first) { 380 vndebug(vp,"empty"); 381 continue; 382 } 383 384 if (vp->v_type == VNON) { 385 continue; 386 } 387 388 if(op == VN_CLEAN && ip->i_number != LFS_IFILE_INUM 389 && vp != fs->lfs_flushvp 390 && !(ip->i_flag & IN_CLEANING)) { 391 vndebug(vp,"cleaning"); 392 continue; 393 } 394 395 if (lfs_vref(vp)) { 396 vndebug(vp,"vref"); 397 continue; 398 } 399 400 #if 0 /* XXX KS - if we skip the ifile, things could go badly for us. */ 401 if(WRITEINPROG(vp)) { 402 lfs_vunref(vp); 403 #ifdef DEBUG_LFS 404 ivndebug(vp,"writevnodes/writeinprog"); 405 #endif 406 continue; 407 } 408 #endif 409 410 needs_unlock = 0; 411 if (VOP_ISLOCKED(vp)) { 412 if (vp != fs->lfs_ivnode && 413 vp->v_lock.lk_lockholder != curproc->p_pid) { 414 #ifdef DEBUG_LFS 415 printf("lfs_writevnodes: not writing ino %d, locked by pid %d\n", 416 VTOI(vp)->i_number, 417 vp->v_lock.lk_lockholder); 418 #endif 419 lfs_vunref(vp); 420 continue; 421 } 422 } else if (vp != fs->lfs_ivnode) { 423 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 424 needs_unlock = 1; 425 } 426 427 only_cleaning = 0; 428 /* 429 * Write the inode/file if dirty and it's not the 430 * the IFILE. 431 */ 432 if ((ip->i_flag & IN_ALLMOD) || 433 (vp->v_dirtyblkhd.lh_first != NULL)) 434 { 435 only_cleaning = ((ip->i_flag & IN_ALLMOD)==IN_CLEANING); 436 437 if(ip->i_number != LFS_IFILE_INUM 438 && vp->v_dirtyblkhd.lh_first != NULL) 439 { 440 lfs_writefile(fs, sp, vp); 441 } 442 if(vp->v_dirtyblkhd.lh_first != NULL) { 443 if(WRITEINPROG(vp)) { 444 #ifdef DEBUG_LFS 445 ivndebug(vp,"writevnodes/write2"); 446 #endif 447 } else if(!(ip->i_flag & IN_ALLMOD)) { 448 #ifdef DEBUG_LFS 449 printf("<%d>",ip->i_number); 450 #endif 451 ip->i_flag |= IN_MODIFIED; 452 ++fs->lfs_uinodes; 453 } 454 } 455 (void) lfs_writeinode(fs, sp, ip); 456 inodes_written++; 457 } 458 459 if (needs_unlock) 460 VOP_UNLOCK(vp, 0); 461 462 if (lfs_clean_vnhead && only_cleaning) 463 lfs_vunref_head(vp); 464 else 465 lfs_vunref(vp); 466 } 467 return inodes_written; 468 } 469 470 int 471 lfs_segwrite(mp, flags) 472 struct mount *mp; 473 int flags; /* Do a checkpoint. */ 474 { 475 struct buf *bp; 476 struct inode *ip; 477 struct lfs *fs; 478 struct segment *sp; 479 struct vnode *vp; 480 SEGUSE *segusep; 481 ufs_daddr_t ibno; 482 int do_ckp, error, i; 483 int writer_set = 0; 484 int need_unlock = 0; 485 486 fs = VFSTOUFS(mp)->um_lfs; 487 488 if (fs->lfs_ronly) 489 return EROFS; 490 491 lfs_imtime(fs); 492 493 /* 494 * If we are not the cleaner, and we have fewer than lfs_minfreeseg 495 * clean segments, wait until cleaner writes. 496 */ 497 if(!(flags & SEGM_CLEAN) 498 && (!fs->lfs_seglock || !(fs->lfs_sp->seg_flags & SEGM_CLEAN))) 499 { 500 do { 501 if (fs->lfs_nclean <= fs->lfs_minfreeseg || 502 fs->lfs_avail <= 0) 503 { 504 wakeup(&lfs_allclean_wakeup); 505 wakeup(&fs->lfs_nextseg); 506 error = tsleep(&fs->lfs_avail, PRIBIO + 1, 507 "lfs_avail", 0); 508 if (error) { 509 return (error); 510 } 511 } 512 } while (fs->lfs_nclean <= fs->lfs_minfreeseg || 513 fs->lfs_avail <= 0); 514 } 515 516 /* 517 * Allocate a segment structure and enough space to hold pointers to 518 * the maximum possible number of buffers which can be described in a 519 * single summary block. 520 */ 521 do_ckp = (flags & SEGM_CKP) || fs->lfs_nactive > LFS_MAX_ACTIVE; 522 lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0)); 523 sp = fs->lfs_sp; 524 525 /* 526 * If lfs_flushvp is non-NULL, we are called from lfs_vflush, 527 * in which case we have to flush *all* buffers off of this vnode. 528 * We don't care about other nodes, but write any non-dirop nodes 529 * anyway in anticipation of another getnewvnode(). 530 * 531 * If we're cleaning we only write cleaning and ifile blocks, and 532 * no dirops, since otherwise we'd risk corruption in a crash. 533 */ 534 if(sp->seg_flags & SEGM_CLEAN) 535 lfs_writevnodes(fs, mp, sp, VN_CLEAN); 536 else { 537 lfs_writevnodes(fs, mp, sp, VN_REG); 538 if(!fs->lfs_dirops || !fs->lfs_flushvp) { 539 while(fs->lfs_dirops) 540 if((error = tsleep(&fs->lfs_writer, PRIBIO + 1, 541 "lfs writer", 0))) 542 { 543 free(sp->bpp, M_SEGMENT); 544 free(sp, M_SEGMENT); 545 return (error); 546 } 547 fs->lfs_writer++; 548 writer_set=1; 549 lfs_writevnodes(fs, mp, sp, VN_DIROP); 550 ((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT); 551 } 552 } 553 554 /* 555 * If we are doing a checkpoint, mark everything since the 556 * last checkpoint as no longer ACTIVE. 557 */ 558 if (do_ckp) { 559 for (ibno = fs->lfs_cleansz + fs->lfs_segtabsz; 560 --ibno >= fs->lfs_cleansz; ) { 561 if (bread(fs->lfs_ivnode, ibno, fs->lfs_bsize, NOCRED, &bp)) 562 563 panic("lfs_segwrite: ifile read"); 564 segusep = (SEGUSE *)bp->b_data; 565 for (i = fs->lfs_sepb; i--; segusep++) 566 segusep->su_flags &= ~SEGUSE_ACTIVE; 567 568 /* But the current segment is still ACTIVE */ 569 segusep = (SEGUSE *)bp->b_data; 570 if (datosn(fs, fs->lfs_curseg) / fs->lfs_sepb == 571 (ibno-fs->lfs_cleansz)) 572 segusep[datosn(fs, fs->lfs_curseg) % 573 fs->lfs_sepb].su_flags |= SEGUSE_ACTIVE; 574 error = VOP_BWRITE(bp); 575 } 576 } 577 578 if (do_ckp || fs->lfs_doifile) { 579 redo: 580 vp = fs->lfs_ivnode; 581 /* 582 * Depending on the circumstances of our calling, the ifile 583 * inode might be locked. If it is, and if it is locked by 584 * us, we should VREF instead of vget here. 585 */ 586 need_unlock = 0; 587 if(VOP_ISLOCKED(vp) 588 && vp->v_lock.lk_lockholder == curproc->p_pid) { 589 VREF(vp); 590 } else { 591 while (vget(vp, LK_EXCLUSIVE)) 592 continue; 593 need_unlock = 1; 594 } 595 ip = VTOI(vp); 596 if (vp->v_dirtyblkhd.lh_first != NULL) 597 lfs_writefile(fs, sp, vp); 598 (void)lfs_writeinode(fs, sp, ip); 599 600 /* Only vput if we used vget() above. */ 601 if(need_unlock) 602 vput(vp); 603 else 604 vrele(vp); 605 606 if (lfs_writeseg(fs, sp) && do_ckp) 607 goto redo; 608 } else { 609 (void) lfs_writeseg(fs, sp); 610 } 611 612 /* 613 * If the I/O count is non-zero, sleep until it reaches zero. 614 * At the moment, the user's process hangs around so we can 615 * sleep. 616 */ 617 fs->lfs_doifile = 0; 618 if(writer_set && --fs->lfs_writer==0) 619 wakeup(&fs->lfs_dirops); 620 621 if(lfs_dostats) { 622 ++lfs_stats.nwrites; 623 if (sp->seg_flags & SEGM_SYNC) 624 ++lfs_stats.nsync_writes; 625 if (sp->seg_flags & SEGM_CKP) 626 ++lfs_stats.ncheckpoints; 627 } 628 lfs_segunlock(fs); 629 return (0); 630 } 631 632 /* 633 * Write the dirty blocks associated with a vnode. 634 */ 635 void 636 lfs_writefile(fs, sp, vp) 637 struct lfs *fs; 638 struct segment *sp; 639 struct vnode *vp; 640 { 641 struct buf *bp; 642 struct finfo *fip; 643 IFILE *ifp; 644 645 646 if (sp->seg_bytes_left < fs->lfs_bsize || 647 sp->sum_bytes_left < sizeof(struct finfo)) 648 (void) lfs_writeseg(fs, sp); 649 650 sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(ufs_daddr_t); 651 ++((SEGSUM *)(sp->segsum))->ss_nfinfo; 652 653 if(vp->v_flag & VDIROP) 654 ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT); 655 656 fip = sp->fip; 657 fip->fi_nblocks = 0; 658 fip->fi_ino = VTOI(vp)->i_number; 659 LFS_IENTRY(ifp, fs, fip->fi_ino, bp); 660 fip->fi_version = ifp->if_version; 661 brelse(bp); 662 663 if(sp->seg_flags & SEGM_CLEAN) 664 { 665 lfs_gather(fs, sp, vp, lfs_match_fake); 666 /* 667 * For a file being flushed, we need to write *all* blocks. 668 * This means writing the cleaning blocks first, and then 669 * immediately following with any non-cleaning blocks. 670 * The same is true of the Ifile since checkpoints assume 671 * that all valid Ifile blocks are written. 672 */ 673 if(IS_FLUSHING(fs,vp) || VTOI(vp)->i_number == LFS_IFILE_INUM) 674 lfs_gather(fs, sp, vp, lfs_match_data); 675 } else 676 lfs_gather(fs, sp, vp, lfs_match_data); 677 678 /* 679 * It may not be necessary to write the meta-data blocks at this point, 680 * as the roll-forward recovery code should be able to reconstruct the 681 * list. 682 * 683 * We have to write them anyway, though, under two conditions: (1) the 684 * vnode is being flushed (for reuse by vinvalbuf); or (2) we are 685 * checkpointing. 686 */ 687 if(lfs_writeindir 688 || IS_FLUSHING(fs,vp) 689 || (sp->seg_flags & SEGM_CKP)) 690 { 691 lfs_gather(fs, sp, vp, lfs_match_indir); 692 lfs_gather(fs, sp, vp, lfs_match_dindir); 693 lfs_gather(fs, sp, vp, lfs_match_tindir); 694 } 695 fip = sp->fip; 696 if (fip->fi_nblocks != 0) { 697 sp->fip = (FINFO*)((caddr_t)fip + sizeof(struct finfo) + 698 sizeof(ufs_daddr_t) * (fip->fi_nblocks-1)); 699 sp->start_lbp = &sp->fip->fi_blocks[0]; 700 } else { 701 sp->sum_bytes_left += sizeof(FINFO) - sizeof(ufs_daddr_t); 702 --((SEGSUM *)(sp->segsum))->ss_nfinfo; 703 } 704 } 705 706 int 707 lfs_writeinode(fs, sp, ip) 708 struct lfs *fs; 709 struct segment *sp; 710 struct inode *ip; 711 { 712 struct buf *bp, *ibp; 713 struct dinode *cdp; 714 IFILE *ifp; 715 SEGUSE *sup; 716 ufs_daddr_t daddr; 717 daddr_t *daddrp; 718 ino_t ino; 719 int error, i, ndx; 720 int redo_ifile = 0; 721 struct timespec ts; 722 int gotblk=0; 723 724 if (!(ip->i_flag & IN_ALLMOD)) 725 return(0); 726 727 /* Allocate a new inode block if necessary. */ 728 if ((ip->i_number != LFS_IFILE_INUM || sp->idp==NULL) && sp->ibp == NULL) { 729 /* Allocate a new segment if necessary. */ 730 if (sp->seg_bytes_left < fs->lfs_bsize || 731 sp->sum_bytes_left < sizeof(ufs_daddr_t)) 732 (void) lfs_writeseg(fs, sp); 733 734 /* Get next inode block. */ 735 daddr = fs->lfs_offset; 736 fs->lfs_offset += fsbtodb(fs, 1); 737 sp->ibp = *sp->cbpp++ = 738 getblk(VTOI(fs->lfs_ivnode)->i_devvp, daddr, fs->lfs_bsize, 0, 0); 739 gotblk++; 740 741 /* Zero out inode numbers */ 742 for (i = 0; i < INOPB(fs); ++i) 743 ((struct dinode *)sp->ibp->b_data)[i].di_inumber = 0; 744 745 ++sp->start_bpp; 746 fs->lfs_avail -= fsbtodb(fs, 1); 747 /* Set remaining space counters. */ 748 sp->seg_bytes_left -= fs->lfs_bsize; 749 sp->sum_bytes_left -= sizeof(ufs_daddr_t); 750 ndx = LFS_SUMMARY_SIZE / sizeof(ufs_daddr_t) - 751 sp->ninodes / INOPB(fs) - 1; 752 ((ufs_daddr_t *)(sp->segsum))[ndx] = daddr; 753 } 754 755 /* Update the inode times and copy the inode onto the inode page. */ 756 if (ip->i_flag & (IN_CLEANING | IN_MODIFIED | IN_ACCESSED)) 757 --fs->lfs_uinodes; 758 TIMEVAL_TO_TIMESPEC(&time, &ts); 759 LFS_ITIMES(ip, &ts, &ts, &ts); 760 761 /* XXX IN_ALLMOD */ 762 if(ip->i_flag & IN_CLEANING) 763 ip->i_flag &= ~IN_CLEANING; 764 else 765 ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | 766 IN_UPDATE | IN_ACCESSED); 767 768 /* 769 * If this is the Ifile, and we've already written the Ifile in this 770 * partial segment, just overwrite it (it's not on disk yet) and 771 * continue. 772 * 773 * XXX we know that the bp that we get the second time around has 774 * already been gathered. 775 */ 776 if(ip->i_number == LFS_IFILE_INUM && sp->idp) { 777 *(sp->idp) = ip->i_din.ffs_din; 778 return 0; 779 } 780 781 bp = sp->ibp; 782 cdp = ((struct dinode *)bp->b_data) + (sp->ninodes % INOPB(fs)); 783 *cdp = ip->i_din.ffs_din; 784 785 /* 786 * If we are cleaning, ensure that we don't write UNWRITTEN disk 787 * addresses to disk. 788 */ 789 if (ip->i_lfs_effnblks != ip->i_ffs_blocks) { 790 printf("lfs_writeinode: cleansing ino %d (%d != %d)\n", 791 ip->i_number, ip->i_lfs_effnblks, ip->i_ffs_blocks); 792 for (daddrp = cdp->di_db; daddrp < cdp->di_ib + NIADDR; 793 daddrp++) { 794 if (*daddrp == UNWRITTEN) { 795 #ifdef DEBUG 796 printf("lfs_writeinode: wiping UNWRITTEN\n"); 797 #endif 798 *daddrp = 0; 799 } 800 } 801 } 802 803 if(ip->i_number == LFS_IFILE_INUM) /* We know sp->idp == NULL */ 804 sp->idp = ((struct dinode *)bp->b_data) + 805 (sp->ninodes % INOPB(fs)); 806 if(gotblk) { 807 bp->b_flags |= B_LOCKED; 808 brelse(bp); 809 } 810 811 /* Increment inode count in segment summary block. */ 812 ++((SEGSUM *)(sp->segsum))->ss_ninos; 813 814 /* If this page is full, set flag to allocate a new page. */ 815 if (++sp->ninodes % INOPB(fs) == 0) 816 sp->ibp = NULL; 817 818 /* 819 * If updating the ifile, update the super-block. Update the disk 820 * address and access times for this inode in the ifile. 821 */ 822 ino = ip->i_number; 823 if (ino == LFS_IFILE_INUM) { 824 daddr = fs->lfs_idaddr; 825 fs->lfs_idaddr = bp->b_blkno; 826 } else { 827 LFS_IENTRY(ifp, fs, ino, ibp); 828 daddr = ifp->if_daddr; 829 ifp->if_daddr = bp->b_blkno; 830 #ifdef LFS_DEBUG_NEXTFREE 831 if(ino > 3 && ifp->if_nextfree) { 832 vprint("lfs_writeinode",ITOV(ip)); 833 printf("lfs_writeinode: updating free ino %d\n", 834 ip->i_number); 835 } 836 #endif 837 error = VOP_BWRITE(ibp); 838 } 839 840 /* 841 * No need to update segment usage if there was no former inode 842 * address or if the last inode address is in the current 843 * partial segment. 844 */ 845 if (daddr >= fs->lfs_lastpseg && daddr <= bp->b_blkno) 846 printf("lfs_writeinode: last inode addr in current pseg " 847 "(ino %d daddr 0x%x)\n", ino, daddr); 848 if (daddr != LFS_UNUSED_DADDR) { 849 LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); 850 #ifdef DIAGNOSTIC 851 if (sup->su_nbytes < DINODE_SIZE) { 852 printf("lfs_writeinode: negative bytes " 853 "(segment %d short by %d)\n", 854 datosn(fs, daddr), 855 (int)DINODE_SIZE - sup->su_nbytes); 856 panic("lfs_writeinode: negative bytes"); 857 sup->su_nbytes = DINODE_SIZE; 858 } 859 #endif 860 sup->su_nbytes -= DINODE_SIZE; 861 redo_ifile = 862 (ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED)); 863 error = VOP_BWRITE(bp); 864 } 865 return (redo_ifile); 866 } 867 868 int 869 lfs_gatherblock(sp, bp, sptr) 870 struct segment *sp; 871 struct buf *bp; 872 int *sptr; 873 { 874 struct lfs *fs; 875 int version; 876 877 /* 878 * If full, finish this segment. We may be doing I/O, so 879 * release and reacquire the splbio(). 880 */ 881 #ifdef DIAGNOSTIC 882 if (sp->vp == NULL) 883 panic ("lfs_gatherblock: Null vp in segment"); 884 #endif 885 fs = sp->fs; 886 if (sp->sum_bytes_left < sizeof(ufs_daddr_t) || 887 sp->seg_bytes_left < bp->b_bcount) { 888 if (sptr) 889 splx(*sptr); 890 lfs_updatemeta(sp); 891 892 version = sp->fip->fi_version; 893 (void) lfs_writeseg(fs, sp); 894 895 sp->fip->fi_version = version; 896 sp->fip->fi_ino = VTOI(sp->vp)->i_number; 897 /* Add the current file to the segment summary. */ 898 ++((SEGSUM *)(sp->segsum))->ss_nfinfo; 899 sp->sum_bytes_left -= 900 sizeof(struct finfo) - sizeof(ufs_daddr_t); 901 902 if (sptr) 903 *sptr = splbio(); 904 return(1); 905 } 906 907 #ifdef DEBUG 908 if(bp->b_flags & B_GATHERED) { 909 printf("lfs_gatherblock: already gathered! Ino %d, lbn %d\n", 910 sp->fip->fi_ino, bp->b_lblkno); 911 return(0); 912 } 913 #endif 914 /* Insert into the buffer list, update the FINFO block. */ 915 bp->b_flags |= B_GATHERED; 916 *sp->cbpp++ = bp; 917 sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno; 918 919 sp->sum_bytes_left -= sizeof(ufs_daddr_t); 920 sp->seg_bytes_left -= bp->b_bcount; 921 return(0); 922 } 923 924 int 925 lfs_gather(fs, sp, vp, match) 926 struct lfs *fs; 927 struct segment *sp; 928 struct vnode *vp; 929 int (*match) __P((struct lfs *, struct buf *)); 930 { 931 struct buf *bp; 932 int s, count=0; 933 934 sp->vp = vp; 935 s = splbio(); 936 937 #ifndef LFS_NO_BACKBUF_HACK 938 loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) { 939 #else /* LFS_NO_BACKBUF_HACK */ 940 /* This is a hack to see if ordering the blocks in LFS makes a difference. */ 941 # define BUF_OFFSET (((void *)&bp->b_vnbufs.le_next) - (void *)bp) 942 # define BACK_BUF(BP) ((struct buf *)(((void *)BP->b_vnbufs.le_prev) - BUF_OFFSET)) 943 # define BEG_OF_LIST ((struct buf *)(((void *)&vp->v_dirtyblkhd.lh_first) - BUF_OFFSET)) 944 /* Find last buffer. */ 945 loop: for (bp = vp->v_dirtyblkhd.lh_first; bp && bp->b_vnbufs.le_next != NULL; 946 bp = bp->b_vnbufs.le_next); 947 for (; bp && bp != BEG_OF_LIST; bp = BACK_BUF(bp)) { 948 #endif /* LFS_NO_BACKBUF_HACK */ 949 if ((bp->b_flags & (B_BUSY|B_GATHERED)) || !match(fs, bp)) 950 continue; 951 if(vp->v_type == VBLK) { 952 /* For block devices, just write the blocks. */ 953 /* XXX Do we really need to even do this? */ 954 #ifdef DEBUG_LFS 955 if(count==0) 956 printf("BLK("); 957 printf("."); 958 #endif 959 /* Get the block before bwrite, so we don't corrupt the free list */ 960 bp->b_flags |= B_BUSY; 961 bremfree(bp); 962 bwrite(bp); 963 } else { 964 #ifdef DIAGNOSTIC 965 if ((bp->b_flags & (B_CALL|B_INVAL))==B_INVAL) { 966 printf("lfs_gather: lbn %d is B_INVAL\n", 967 bp->b_lblkno); 968 VOP_PRINT(bp->b_vp); 969 } 970 if (!(bp->b_flags & B_DELWRI)) 971 panic("lfs_gather: bp not B_DELWRI"); 972 if (!(bp->b_flags & B_LOCKED)) { 973 printf("lfs_gather: lbn %d blk %d not B_LOCKED\n", bp->b_lblkno, bp->b_blkno); 974 VOP_PRINT(bp->b_vp); 975 panic("lfs_gather: bp not B_LOCKED"); 976 } 977 #endif 978 if (lfs_gatherblock(sp, bp, &s)) { 979 goto loop; 980 } 981 } 982 count++; 983 } 984 splx(s); 985 #ifdef DEBUG_LFS 986 if(vp->v_type == VBLK && count) 987 printf(")\n"); 988 #endif 989 lfs_updatemeta(sp); 990 sp->vp = NULL; 991 return count; 992 } 993 994 /* 995 * Update the metadata that points to the blocks listed in the FINFO 996 * array. 997 */ 998 void 999 lfs_updatemeta(sp) 1000 struct segment *sp; 1001 { 1002 SEGUSE *sup; 1003 struct buf *bp, *ibp; 1004 struct lfs *fs; 1005 struct vnode *vp; 1006 struct indir a[NIADDR + 2], *ap; 1007 struct inode *ip; 1008 ufs_daddr_t daddr, lbn, off; 1009 daddr_t ooff; 1010 int error, i, nblocks, num; 1011 int bb; 1012 1013 vp = sp->vp; 1014 nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp; 1015 if (nblocks < 0) 1016 panic("This is a bad thing\n"); 1017 if (vp == NULL || nblocks == 0) 1018 return; 1019 1020 /* Sort the blocks. */ 1021 /* 1022 * XXX KS - We have to sort even if the blocks come from the 1023 * cleaner, because there might be other pending blocks on the 1024 * same inode...and if we don't sort, and there are fragments 1025 * present, blocks may be written in the wrong place. 1026 */ 1027 /* if (!(sp->seg_flags & SEGM_CLEAN)) */ 1028 lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks); 1029 1030 /* 1031 * Record the length of the last block in case it's a fragment. 1032 * If there are indirect blocks present, they sort last. An 1033 * indirect block will be lfs_bsize and its presence indicates 1034 * that you cannot have fragments. 1035 */ 1036 sp->fip->fi_lastlength = sp->start_bpp[nblocks - 1]->b_bcount; 1037 1038 /* 1039 * Assign disk addresses, and update references to the logical 1040 * block and the segment usage information. 1041 */ 1042 fs = sp->fs; 1043 for (i = nblocks; i--; ++sp->start_bpp) { 1044 lbn = *sp->start_lbp++; 1045 1046 (*sp->start_bpp)->b_blkno = off = fs->lfs_offset; 1047 if((*sp->start_bpp)->b_blkno == (*sp->start_bpp)->b_lblkno) { 1048 printf("lfs_updatemeta: ino %d blk %d has same lbn and daddr\n", VTOI(vp)->i_number, off); 1049 } 1050 bb = fragstodb(fs, numfrags(fs, (*sp->start_bpp)->b_bcount)); 1051 fs->lfs_offset += bb; 1052 error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL); 1053 if (error) 1054 panic("lfs_updatemeta: ufs_bmaparray %d", error); 1055 ip = VTOI(vp); 1056 switch (num) { 1057 case 0: 1058 ooff = ip->i_ffs_db[lbn]; 1059 if(vp != fs->lfs_ivnode && ooff == 0) { 1060 #ifdef DEBUG_LFS 1061 printf("lfs_updatemeta[1]: warning: writing " 1062 "ino %d lbn %d at 0x%x, was 0x%x\n", 1063 ip->i_number, lbn, off, ooff); 1064 #endif 1065 } else { 1066 if (ooff == UNWRITTEN) 1067 ip->i_ffs_blocks += bb; 1068 ip->i_ffs_db[lbn] = off; 1069 } 1070 break; 1071 case 1: 1072 ooff = ip->i_ffs_ib[a[0].in_off]; 1073 if(vp != fs->lfs_ivnode && ooff == 0) { 1074 #ifdef DEBUG_LFS 1075 printf("lfs_updatemeta[2]: warning: writing " 1076 "ino %d lbn %d at 0x%x, was 0x%x\n", 1077 ip->i_number, lbn, off, ooff); 1078 #endif 1079 } else { 1080 if (ooff == UNWRITTEN) 1081 ip->i_ffs_blocks += bb; 1082 ip->i_ffs_ib[a[0].in_off] = off; 1083 } 1084 break; 1085 default: 1086 ap = &a[num - 1]; 1087 if (bread(vp, ap->in_lbn, fs->lfs_bsize, NOCRED, &bp)) 1088 panic("lfs_updatemeta: bread bno %d", 1089 ap->in_lbn); 1090 /* 1091 * Bread may create a new (indirect) block which needs 1092 * to get counted for the inode. 1093 * 1094 * XXX - why would it ever do this (except possibly 1095 * for the Ifile)? lfs_balloc is supposed to take 1096 * care of this. 1097 */ 1098 if (bp->b_blkno == UNASSIGNED) { 1099 printf("lfs_updatemeta: creating lbn %d for " 1100 "ino %d", ap->in_lbn, ip->i_number); 1101 ip->i_lfs_effnblks += fsbtodb(fs, 1); 1102 fs->lfs_bfree -= fsbtodb(fs, 1); 1103 1104 /* Note the new address */ 1105 bp->b_blkno = UNWRITTEN; 1106 1107 if(num == 2) { 1108 ip->i_ffs_ib[a[0].in_off] = UNWRITTEN; 1109 } else { 1110 ap = &a[num - 2]; 1111 if (bread(vp, ap->in_lbn, 1112 fs->lfs_bsize, NOCRED, &ibp)) 1113 panic("lfs_updatemeta: bread bno %d", 1114 ap->in_lbn); 1115 ((ufs_daddr_t *)ibp->b_data)[ap->in_off] = UNWRITTEN; 1116 VOP_BWRITE(ibp); 1117 } 1118 } 1119 ooff = ((ufs_daddr_t *)bp->b_data)[ap->in_off]; 1120 if(vp != fs->lfs_ivnode && ooff == 0) { 1121 #ifdef DEBUG_LFS 1122 printf("lfs_updatemeta[3]: warning: writing " 1123 "ino %d lbn %d at 0x%x, was 0x%x\n", 1124 ip->i_number, lbn, off, ooff); 1125 #endif 1126 brelse(bp); 1127 } else { 1128 if (ooff == UNWRITTEN) 1129 ip->i_ffs_blocks += bb; 1130 ((ufs_daddr_t *)bp->b_data)[ap->in_off] = off; 1131 VOP_BWRITE(bp); 1132 } 1133 } 1134 /* Update segment usage information. */ 1135 if (daddr >= fs->lfs_lastpseg && daddr <= off) { 1136 printf("lfs_updatemeta: ino %d, lbn %d, addr = %x " 1137 "in same pseg\n", VTOI(sp->vp)->i_number, 1138 (*sp->start_bpp)->b_lblkno, daddr); 1139 } 1140 if (daddr > 0) { 1141 LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); 1142 #ifdef DIAGNOSTIC 1143 if (sup->su_nbytes < (*sp->start_bpp)->b_bcount) { 1144 /* XXX -- Change to a panic. */ 1145 printf("lfs_updatemeta: negative bytes (segment %d short by %ld)\n", 1146 datosn(fs, daddr), (*sp->start_bpp)->b_bcount - sup->su_nbytes); 1147 printf("lfs_updatemeta: ino %d, lbn %d, addr = %x\n", 1148 VTOI(sp->vp)->i_number, (*sp->start_bpp)->b_lblkno, daddr); 1149 panic("lfs_updatemeta: negative bytes"); 1150 sup->su_nbytes = (*sp->start_bpp)->b_bcount; 1151 } 1152 #endif 1153 sup->su_nbytes -= (*sp->start_bpp)->b_bcount; 1154 error = VOP_BWRITE(bp); 1155 } 1156 } 1157 } 1158 1159 /* 1160 * Start a new segment. 1161 */ 1162 int 1163 lfs_initseg(fs) 1164 struct lfs *fs; 1165 { 1166 struct segment *sp; 1167 SEGUSE *sup; 1168 SEGSUM *ssp; 1169 struct buf *bp; 1170 int repeat; 1171 1172 sp = fs->lfs_sp; 1173 1174 repeat = 0; 1175 /* Advance to the next segment. */ 1176 if (!LFS_PARTIAL_FITS(fs)) { 1177 /* Wake up any cleaning procs waiting on this file system. */ 1178 wakeup(&lfs_allclean_wakeup); 1179 wakeup(&fs->lfs_nextseg); 1180 lfs_newseg(fs); 1181 repeat = 1; 1182 fs->lfs_offset = fs->lfs_curseg; 1183 sp->seg_number = datosn(fs, fs->lfs_curseg); 1184 sp->seg_bytes_left = fs->lfs_dbpseg * DEV_BSIZE; 1185 /* 1186 * If the segment contains a superblock, update the offset 1187 * and summary address to skip over it. 1188 */ 1189 LFS_SEGENTRY(sup, fs, sp->seg_number, bp); 1190 if (sup->su_flags & SEGUSE_SUPERBLOCK) { 1191 fs->lfs_offset += LFS_SBPAD / DEV_BSIZE; 1192 sp->seg_bytes_left -= LFS_SBPAD; 1193 } 1194 brelse(bp); 1195 } else { 1196 sp->seg_number = datosn(fs, fs->lfs_curseg); 1197 sp->seg_bytes_left = (fs->lfs_dbpseg - 1198 (fs->lfs_offset - fs->lfs_curseg)) * DEV_BSIZE; 1199 } 1200 fs->lfs_lastpseg = fs->lfs_offset; 1201 1202 sp->fs = fs; 1203 sp->ibp = NULL; 1204 sp->idp = NULL; 1205 sp->ninodes = 0; 1206 1207 /* Get a new buffer for SEGSUM and enter it into the buffer list. */ 1208 sp->cbpp = sp->bpp; 1209 *sp->cbpp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, 1210 fs->lfs_offset, LFS_SUMMARY_SIZE); 1211 sp->segsum = (*sp->cbpp)->b_data; 1212 bzero(sp->segsum, LFS_SUMMARY_SIZE); 1213 sp->start_bpp = ++sp->cbpp; 1214 fs->lfs_offset += LFS_SUMMARY_SIZE / DEV_BSIZE; 1215 1216 /* Set point to SEGSUM, initialize it. */ 1217 ssp = sp->segsum; 1218 ssp->ss_next = fs->lfs_nextseg; 1219 ssp->ss_nfinfo = ssp->ss_ninos = 0; 1220 ssp->ss_magic = SS_MAGIC; 1221 1222 /* Set pointer to first FINFO, initialize it. */ 1223 sp->fip = (struct finfo *)((caddr_t)sp->segsum + sizeof(SEGSUM)); 1224 sp->fip->fi_nblocks = 0; 1225 sp->start_lbp = &sp->fip->fi_blocks[0]; 1226 sp->fip->fi_lastlength = 0; 1227 1228 sp->seg_bytes_left -= LFS_SUMMARY_SIZE; 1229 sp->sum_bytes_left = LFS_SUMMARY_SIZE - sizeof(SEGSUM); 1230 1231 return(repeat); 1232 } 1233 1234 /* 1235 * Return the next segment to write. 1236 */ 1237 void 1238 lfs_newseg(fs) 1239 struct lfs *fs; 1240 { 1241 CLEANERINFO *cip; 1242 SEGUSE *sup; 1243 struct buf *bp; 1244 int curseg, isdirty, sn; 1245 1246 LFS_SEGENTRY(sup, fs, datosn(fs, fs->lfs_nextseg), bp); 1247 sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE; 1248 sup->su_nbytes = 0; 1249 sup->su_nsums = 0; 1250 sup->su_ninos = 0; 1251 (void) VOP_BWRITE(bp); 1252 1253 LFS_CLEANERINFO(cip, fs, bp); 1254 --cip->clean; 1255 ++cip->dirty; 1256 fs->lfs_nclean = cip->clean; 1257 (void) VOP_BWRITE(bp); 1258 1259 fs->lfs_lastseg = fs->lfs_curseg; 1260 fs->lfs_curseg = fs->lfs_nextseg; 1261 for (sn = curseg = datosn(fs, fs->lfs_curseg);;) { 1262 sn = (sn + 1) % fs->lfs_nseg; 1263 if (sn == curseg) 1264 panic("lfs_nextseg: no clean segments"); 1265 LFS_SEGENTRY(sup, fs, sn, bp); 1266 isdirty = sup->su_flags & SEGUSE_DIRTY; 1267 brelse(bp); 1268 if (!isdirty) 1269 break; 1270 } 1271 1272 ++fs->lfs_nactive; 1273 fs->lfs_nextseg = sntoda(fs, sn); 1274 if(lfs_dostats) { 1275 ++lfs_stats.segsused; 1276 } 1277 } 1278 1279 int 1280 lfs_writeseg(fs, sp) 1281 struct lfs *fs; 1282 struct segment *sp; 1283 { 1284 extern int locked_queue_count; 1285 extern long locked_queue_bytes; 1286 struct buf **bpp, *bp, *cbp, *newbp; 1287 SEGUSE *sup; 1288 SEGSUM *ssp; 1289 dev_t i_dev; 1290 u_long *datap, *dp; 1291 int do_again, i, nblocks, s; 1292 #ifdef LFS_TRACK_IOS 1293 int j; 1294 #endif 1295 int (*strategy)__P((void *)); 1296 struct vop_strategy_args vop_strategy_a; 1297 u_short ninos; 1298 struct vnode *devvp; 1299 char *p; 1300 struct vnode *vn; 1301 struct inode *ip; 1302 daddr_t *daddrp; 1303 #if defined(DEBUG) && defined(LFS_PROPELLER) 1304 static int propeller; 1305 char propstring[4] = "-\\|/"; 1306 1307 printf("%c\b",propstring[propeller++]); 1308 if(propeller==4) 1309 propeller = 0; 1310 #endif 1311 1312 /* 1313 * If there are no buffers other than the segment summary to write 1314 * and it is not a checkpoint, don't do anything. On a checkpoint, 1315 * even if there aren't any buffers, you need to write the superblock. 1316 */ 1317 if ((nblocks = sp->cbpp - sp->bpp) == 1) 1318 return (0); 1319 1320 i_dev = VTOI(fs->lfs_ivnode)->i_dev; 1321 devvp = VTOI(fs->lfs_ivnode)->i_devvp; 1322 1323 /* Update the segment usage information. */ 1324 LFS_SEGENTRY(sup, fs, sp->seg_number, bp); 1325 1326 /* Loop through all blocks, except the segment summary. */ 1327 for (bpp = sp->bpp; ++bpp < sp->cbpp; ) { 1328 if((*bpp)->b_vp != devvp) 1329 sup->su_nbytes += (*bpp)->b_bcount; 1330 } 1331 1332 ssp = (SEGSUM *)sp->segsum; 1333 1334 ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs); 1335 sup->su_nbytes += ssp->ss_ninos * DINODE_SIZE; 1336 /* sup->su_nbytes += LFS_SUMMARY_SIZE; */ 1337 sup->su_lastmod = time.tv_sec; 1338 sup->su_ninos += ninos; 1339 ++sup->su_nsums; 1340 fs->lfs_dmeta += (LFS_SUMMARY_SIZE / DEV_BSIZE + fsbtodb(fs, ninos)); 1341 1342 do_again = !(bp->b_flags & B_GATHERED); 1343 (void)VOP_BWRITE(bp); 1344 /* 1345 * Mark blocks B_BUSY, to prevent then from being changed between 1346 * the checksum computation and the actual write. 1347 * 1348 * If we are cleaning, check indirect blocks for UNWRITTEN, and if 1349 * there are any, replace them with copies that have UNASSIGNED 1350 * instead. 1351 */ 1352 for (bpp = sp->bpp, i = nblocks - 1; i--;) { 1353 ++bpp; 1354 if((*bpp)->b_flags & B_CALL) 1355 continue; 1356 bp = *bpp; 1357 again: 1358 s = splbio(); 1359 if(bp->b_flags & B_BUSY) { 1360 #ifdef DEBUG 1361 printf("lfs_writeseg: avoiding potential data " 1362 "summary corruption for ino %d, lbn %d\n", 1363 VTOI(bp->b_vp)->i_number, bp->b_lblkno); 1364 #endif 1365 bp->b_flags |= B_WANTED; 1366 tsleep(bp, (PRIBIO + 1), "lfs_writeseg", 0); 1367 splx(s); 1368 goto again; 1369 } 1370 bp->b_flags |= B_BUSY; 1371 splx(s); 1372 /* Check and replace indirect block UNWRITTEN bogosity */ 1373 if(bp->b_lblkno < 0 && bp->b_vp != devvp && bp->b_vp && 1374 VTOI(bp->b_vp)->i_ffs_blocks != 1375 VTOI(bp->b_vp)->i_lfs_effnblks) { 1376 printf("lfs_writeseg: cleansing ino %d (%d != %d)\n", 1377 VTOI(bp->b_vp)->i_number, 1378 VTOI(bp->b_vp)->i_lfs_effnblks, 1379 VTOI(bp->b_vp)->i_ffs_blocks); 1380 /* Make a copy we'll make changes to */ 1381 newbp = lfs_newbuf(bp->b_vp, bp->b_lblkno, 1382 bp->b_bcount); 1383 newbp->b_blkno = bp->b_blkno; 1384 memcpy(newbp->b_data, bp->b_data, 1385 newbp->b_bcount); 1386 *bpp = newbp; 1387 1388 /* Get rid of the old buffer */ 1389 bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | 1390 B_LOCKED | B_GATHERED); 1391 if (bp->b_flags & B_CALL) 1392 lfs_freebuf(bp); 1393 else { 1394 bremfree(bp); 1395 bp->b_flags |= B_DONE; 1396 if(bp->b_vp) 1397 reassignbuf(bp, bp->b_vp); 1398 brelse(bp); 1399 } 1400 1401 for (daddrp = (daddr_t *)(newbp->b_data); 1402 daddrp < (daddr_t *)(newbp->b_data + 1403 newbp->b_bcount); daddrp++) { 1404 if (*daddrp == UNWRITTEN) { 1405 #ifdef DEBUG 1406 printf("lfs_segwrite: replacing UNWRITTEN\n"); 1407 #endif 1408 *daddrp = 0; 1409 } 1410 } 1411 } 1412 } 1413 /* 1414 * Compute checksum across data and then across summary; the first 1415 * block (the summary block) is skipped. Set the create time here 1416 * so that it's guaranteed to be later than the inode mod times. 1417 * 1418 * XXX 1419 * Fix this to do it inline, instead of malloc/copy. 1420 */ 1421 datap = dp = malloc(nblocks * sizeof(u_long), M_SEGMENT, M_WAITOK); 1422 for (bpp = sp->bpp, i = nblocks - 1; i--;) { 1423 if (((*++bpp)->b_flags & (B_CALL|B_INVAL)) == (B_CALL|B_INVAL)) { 1424 if (copyin((*bpp)->b_saveaddr, dp++, sizeof(u_long))) 1425 panic("lfs_writeseg: copyin failed [1]: " 1426 "ino %d blk %d", 1427 VTOI((*bpp)->b_vp)->i_number, 1428 (*bpp)->b_lblkno); 1429 } else 1430 *dp++ = ((u_long *)(*bpp)->b_data)[0]; 1431 } 1432 ssp->ss_create = time.tv_sec; 1433 ssp->ss_datasum = cksum(datap, (nblocks - 1) * sizeof(u_long)); 1434 ssp->ss_sumsum = 1435 cksum(&ssp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(ssp->ss_sumsum)); 1436 free(datap, M_SEGMENT); 1437 1438 fs->lfs_bfree -= (fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE); 1439 1440 strategy = devvp->v_op[VOFFSET(vop_strategy)]; 1441 1442 /* 1443 * When we simply write the blocks we lose a rotation for every block 1444 * written. To avoid this problem, we allocate memory in chunks, copy 1445 * the buffers into the chunk and write the chunk. CHUNKSIZE is the 1446 * largest size I/O devices can handle. 1447 * When the data is copied to the chunk, turn off the B_LOCKED bit 1448 * and brelse the buffer (which will move them to the LRU list). Add 1449 * the B_CALL flag to the buffer header so we can count I/O's for the 1450 * checkpoints and so we can release the allocated memory. 1451 * 1452 * XXX 1453 * This should be removed if the new virtual memory system allows us to 1454 * easily make the buffers contiguous in kernel memory and if that's 1455 * fast enough. 1456 */ 1457 1458 #define CHUNKSIZE MAXPHYS 1459 1460 if(devvp==NULL) 1461 panic("devvp is NULL"); 1462 for (bpp = sp->bpp,i = nblocks; i;) { 1463 cbp = lfs_newbuf(devvp, (*bpp)->b_blkno, CHUNKSIZE); 1464 cbp->b_dev = i_dev; 1465 cbp->b_flags |= B_ASYNC | B_BUSY; 1466 cbp->b_bcount = 0; 1467 1468 #ifdef DIAGNOSTIC 1469 if(datosn(fs,(*bpp)->b_blkno + ((*bpp)->b_bcount - 1)/DEV_BSIZE) != datosn(fs,cbp->b_blkno)) { 1470 panic("lfs_writeseg: Segment overwrite"); 1471 } 1472 #endif 1473 1474 s = splbio(); 1475 if(fs->lfs_iocount >= LFS_THROTTLE) { 1476 tsleep(&fs->lfs_iocount, PRIBIO+1, "lfs throttle", 0); 1477 } 1478 ++fs->lfs_iocount; 1479 #ifdef LFS_TRACK_IOS 1480 for(j=0;j<LFS_THROTTLE;j++) { 1481 if(fs->lfs_pending[j]==LFS_UNUSED_DADDR) { 1482 fs->lfs_pending[j] = cbp->b_blkno; 1483 break; 1484 } 1485 } 1486 #endif /* LFS_TRACK_IOS */ 1487 for (p = cbp->b_data; i && cbp->b_bcount < CHUNKSIZE; i--) { 1488 bp = *bpp; 1489 1490 if (bp->b_bcount > (CHUNKSIZE - cbp->b_bcount)) 1491 break; 1492 1493 /* 1494 * Fake buffers from the cleaner are marked as B_INVAL. 1495 * We need to copy the data from user space rather than 1496 * from the buffer indicated. 1497 * XXX == what do I do on an error? 1498 */ 1499 if ((bp->b_flags & (B_CALL|B_INVAL)) == (B_CALL|B_INVAL)) { 1500 if (copyin(bp->b_saveaddr, p, bp->b_bcount)) 1501 panic("lfs_writeseg: copyin failed [2]"); 1502 } else 1503 bcopy(bp->b_data, p, bp->b_bcount); 1504 p += bp->b_bcount; 1505 cbp->b_bcount += bp->b_bcount; 1506 if (bp->b_flags & B_LOCKED) { 1507 --locked_queue_count; 1508 locked_queue_bytes -= bp->b_bufsize; 1509 } 1510 bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | 1511 B_LOCKED | B_GATHERED); 1512 vn = bp->b_vp; 1513 if (bp->b_flags & B_CALL) { 1514 /* if B_CALL, it was created with newbuf */ 1515 lfs_freebuf(bp); 1516 } else { 1517 bremfree(bp); 1518 bp->b_flags |= B_DONE; 1519 if(vn) 1520 reassignbuf(bp, vn); 1521 brelse(bp); 1522 } 1523 if(bp->b_flags & B_NEEDCOMMIT) { /* XXX */ 1524 bp->b_flags &= ~B_NEEDCOMMIT; 1525 wakeup(bp); 1526 } 1527 1528 bpp++; 1529 1530 /* 1531 * If this is the last block for this vnode, but 1532 * there are other blocks on its dirty list, 1533 * set IN_MODIFIED/IN_CLEANING depending on what 1534 * sort of block. Only do this for our mount point, 1535 * not for, e.g., inode blocks that are attached to 1536 * the devvp. 1537 */ 1538 if(i>1 && vn && *bpp && (*bpp)->b_vp != vn 1539 && (*bpp)->b_vp && (bp=vn->v_dirtyblkhd.lh_first)!=NULL && 1540 vn->v_mount == fs->lfs_ivnode->v_mount) 1541 { 1542 ip = VTOI(vn); 1543 #ifdef DEBUG_LFS 1544 printf("lfs_writeseg: marking ino %d\n",ip->i_number); 1545 #endif 1546 if(!(ip->i_flag & (IN_CLEANING | IN_MODIFIED | 1547 IN_ACCESSED))) { 1548 fs->lfs_uinodes++; 1549 if(bp->b_flags & B_CALL) 1550 ip->i_flag |= IN_CLEANING; 1551 else 1552 ip->i_flag |= IN_MODIFIED; 1553 } 1554 } 1555 /* if(vn->v_dirtyblkhd.lh_first == NULL) */ 1556 wakeup(vn); 1557 } 1558 ++cbp->b_vp->v_numoutput; 1559 splx(s); 1560 /* 1561 * XXXX This is a gross and disgusting hack. Since these 1562 * buffers are physically addressed, they hang off the 1563 * device vnode (devvp). As a result, they have no way 1564 * of getting to the LFS superblock or lfs structure to 1565 * keep track of the number of I/O's pending. So, I am 1566 * going to stuff the fs into the saveaddr field of 1567 * the buffer (yuk). 1568 */ 1569 cbp->b_saveaddr = (caddr_t)fs; 1570 vop_strategy_a.a_desc = VDESC(vop_strategy); 1571 vop_strategy_a.a_bp = cbp; 1572 (strategy)(&vop_strategy_a); 1573 } 1574 /* 1575 * XXX 1576 * Vinvalbuf can move locked buffers off the locked queue 1577 * and we have no way of knowing about this. So, after 1578 * doing a big write, we recalculate how many buffers are 1579 * really still left on the locked queue. 1580 */ 1581 lfs_countlocked(&locked_queue_count,&locked_queue_bytes); 1582 wakeup(&locked_queue_count); 1583 if(lfs_dostats) { 1584 ++lfs_stats.psegwrites; 1585 lfs_stats.blocktot += nblocks - 1; 1586 if (fs->lfs_sp->seg_flags & SEGM_SYNC) 1587 ++lfs_stats.psyncwrites; 1588 if (fs->lfs_sp->seg_flags & SEGM_CLEAN) { 1589 ++lfs_stats.pcleanwrites; 1590 lfs_stats.cleanblocks += nblocks - 1; 1591 } 1592 } 1593 return (lfs_initseg(fs) || do_again); 1594 } 1595 1596 void 1597 lfs_writesuper(fs, daddr) 1598 struct lfs *fs; 1599 daddr_t daddr; 1600 { 1601 struct buf *bp; 1602 dev_t i_dev; 1603 int (*strategy) __P((void *)); 1604 int s; 1605 struct vop_strategy_args vop_strategy_a; 1606 1607 #ifdef LFS_CANNOT_ROLLFW 1608 /* 1609 * If we can write one superblock while another is in 1610 * progress, we risk not having a complete checkpoint if we crash. 1611 * So, block here if a superblock write is in progress. 1612 */ 1613 s = splbio(); 1614 while(fs->lfs_sbactive) { 1615 tsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0); 1616 } 1617 fs->lfs_sbactive = daddr; 1618 splx(s); 1619 #endif 1620 i_dev = VTOI(fs->lfs_ivnode)->i_dev; 1621 strategy = VTOI(fs->lfs_ivnode)->i_devvp->v_op[VOFFSET(vop_strategy)]; 1622 1623 /* Set timestamp of this version of the superblock */ 1624 fs->lfs_tstamp = time.tv_sec; 1625 1626 /* Checksum the superblock and copy it into a buffer. */ 1627 fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs)); 1628 bp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, daddr, LFS_SBPAD); 1629 *(struct dlfs *)bp->b_data = fs->lfs_dlfs; 1630 1631 bp->b_dev = i_dev; 1632 bp->b_flags |= B_BUSY | B_CALL | B_ASYNC; 1633 bp->b_flags &= ~(B_DONE | B_ERROR | B_READ | B_DELWRI); 1634 bp->b_iodone = lfs_supercallback; 1635 /* XXX KS - same nasty hack as above */ 1636 bp->b_saveaddr = (caddr_t)fs; 1637 1638 vop_strategy_a.a_desc = VDESC(vop_strategy); 1639 vop_strategy_a.a_bp = bp; 1640 s = splbio(); 1641 ++bp->b_vp->v_numoutput; 1642 ++fs->lfs_iocount; 1643 splx(s); 1644 (strategy)(&vop_strategy_a); 1645 } 1646 1647 /* 1648 * Logical block number match routines used when traversing the dirty block 1649 * chain. 1650 */ 1651 int 1652 lfs_match_fake(fs, bp) 1653 struct lfs *fs; 1654 struct buf *bp; 1655 { 1656 return (bp->b_flags & B_CALL); 1657 } 1658 1659 int 1660 lfs_match_data(fs, bp) 1661 struct lfs *fs; 1662 struct buf *bp; 1663 { 1664 return (bp->b_lblkno >= 0); 1665 } 1666 1667 int 1668 lfs_match_indir(fs, bp) 1669 struct lfs *fs; 1670 struct buf *bp; 1671 { 1672 int lbn; 1673 1674 lbn = bp->b_lblkno; 1675 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 0); 1676 } 1677 1678 int 1679 lfs_match_dindir(fs, bp) 1680 struct lfs *fs; 1681 struct buf *bp; 1682 { 1683 int lbn; 1684 1685 lbn = bp->b_lblkno; 1686 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 1); 1687 } 1688 1689 int 1690 lfs_match_tindir(fs, bp) 1691 struct lfs *fs; 1692 struct buf *bp; 1693 { 1694 int lbn; 1695 1696 lbn = bp->b_lblkno; 1697 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 2); 1698 } 1699 1700 /* 1701 * XXX - The only buffers that are going to hit these functions are the 1702 * segment write blocks, or the segment summaries, or the superblocks. 1703 * 1704 * All of the above are created by lfs_newbuf, and so do not need to be 1705 * released via brelse. 1706 */ 1707 void 1708 lfs_callback(bp) 1709 struct buf *bp; 1710 { 1711 struct lfs *fs; 1712 #ifdef LFS_TRACK_IOS 1713 int j; 1714 #endif 1715 1716 fs = (struct lfs *)bp->b_saveaddr; 1717 #ifdef DIAGNOSTIC 1718 if (fs->lfs_iocount == 0) 1719 panic("lfs_callback: zero iocount\n"); 1720 #endif 1721 if (--fs->lfs_iocount < LFS_THROTTLE) 1722 wakeup(&fs->lfs_iocount); 1723 #ifdef LFS_TRACK_IOS 1724 for(j=0;j<LFS_THROTTLE;j++) { 1725 if(fs->lfs_pending[j]==bp->b_blkno) { 1726 fs->lfs_pending[j] = LFS_UNUSED_DADDR; 1727 wakeup(&(fs->lfs_pending[j])); 1728 break; 1729 } 1730 } 1731 #endif /* LFS_TRACK_IOS */ 1732 1733 lfs_freebuf(bp); 1734 } 1735 1736 void 1737 lfs_supercallback(bp) 1738 struct buf *bp; 1739 { 1740 struct lfs *fs; 1741 1742 fs = (struct lfs *)bp->b_saveaddr; 1743 #ifdef LFS_CANNOT_ROLLFW 1744 fs->lfs_sbactive = 0; 1745 wakeup(&fs->lfs_sbactive); 1746 #endif 1747 if (--fs->lfs_iocount < LFS_THROTTLE) 1748 wakeup(&fs->lfs_iocount); 1749 lfs_freebuf(bp); 1750 } 1751 1752 /* 1753 * Shellsort (diminishing increment sort) from Data Structures and 1754 * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290; 1755 * see also Knuth Vol. 3, page 84. The increments are selected from 1756 * formula (8), page 95. Roughly O(N^3/2). 1757 */ 1758 /* 1759 * This is our own private copy of shellsort because we want to sort 1760 * two parallel arrays (the array of buffer pointers and the array of 1761 * logical block numbers) simultaneously. Note that we cast the array 1762 * of logical block numbers to a unsigned in this routine so that the 1763 * negative block numbers (meta data blocks) sort AFTER the data blocks. 1764 */ 1765 1766 void 1767 lfs_shellsort(bp_array, lb_array, nmemb) 1768 struct buf **bp_array; 1769 ufs_daddr_t *lb_array; 1770 int nmemb; 1771 { 1772 static int __rsshell_increments[] = { 4, 1, 0 }; 1773 int incr, *incrp, t1, t2; 1774 struct buf *bp_temp; 1775 u_long lb_temp; 1776 1777 for (incrp = __rsshell_increments; (incr = *incrp++) != 0;) 1778 for (t1 = incr; t1 < nmemb; ++t1) 1779 for (t2 = t1 - incr; t2 >= 0;) 1780 if (lb_array[t2] > lb_array[t2 + incr]) { 1781 lb_temp = lb_array[t2]; 1782 lb_array[t2] = lb_array[t2 + incr]; 1783 lb_array[t2 + incr] = lb_temp; 1784 bp_temp = bp_array[t2]; 1785 bp_array[t2] = bp_array[t2 + incr]; 1786 bp_array[t2 + incr] = bp_temp; 1787 t2 -= incr; 1788 } else 1789 break; 1790 } 1791 1792 /* 1793 * Check VXLOCK. Return 1 if the vnode is locked. Otherwise, vget it. 1794 */ 1795 int 1796 lfs_vref(vp) 1797 struct vnode *vp; 1798 { 1799 /* 1800 * If we return 1 here during a flush, we risk vinvalbuf() not 1801 * being able to flush all of the pages from this vnode, which 1802 * will cause it to panic. So, return 0 if a flush is in progress. 1803 */ 1804 if (vp->v_flag & VXLOCK) { 1805 if(IS_FLUSHING(VTOI(vp)->i_lfs,vp)) { 1806 return 0; 1807 } 1808 return(1); 1809 } 1810 return (vget(vp, 0)); 1811 } 1812 1813 /* 1814 * This is vrele except that we do not want to VOP_INACTIVE this vnode. We 1815 * inline vrele here to avoid the vn_lock and VOP_INACTIVE call at the end. 1816 */ 1817 void 1818 lfs_vunref(vp) 1819 struct vnode *vp; 1820 { 1821 /* 1822 * Analogous to lfs_vref, if the node is flushing, fake it. 1823 */ 1824 if((vp->v_flag & VXLOCK) && IS_FLUSHING(VTOI(vp)->i_lfs,vp)) { 1825 return; 1826 } 1827 1828 simple_lock(&vp->v_interlock); 1829 #ifdef DIAGNOSTIC 1830 if(vp->v_usecount<=0) { 1831 printf("lfs_vunref: inum is %d\n", VTOI(vp)->i_number); 1832 printf("lfs_vunref: flags are 0x%lx\n", vp->v_flag); 1833 printf("lfs_vunref: usecount = %ld\n", vp->v_usecount); 1834 panic("lfs_vunref: v_usecount<0"); 1835 } 1836 #endif 1837 vp->v_usecount--; 1838 if (vp->v_usecount > 0) { 1839 simple_unlock(&vp->v_interlock); 1840 return; 1841 } 1842 /* 1843 * insert at tail of LRU list 1844 */ 1845 simple_lock(&vnode_free_list_slock); 1846 if (vp->v_holdcnt > 0) 1847 TAILQ_INSERT_TAIL(&vnode_hold_list, vp, v_freelist); 1848 else 1849 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 1850 simple_unlock(&vnode_free_list_slock); 1851 simple_unlock(&vp->v_interlock); 1852 } 1853 1854 /* 1855 * We use this when we have vnodes that were loaded in solely for cleaning. 1856 * There is no reason to believe that these vnodes will be referenced again 1857 * soon, since the cleaning process is unrelated to normal filesystem 1858 * activity. Putting cleaned vnodes at the tail of the list has the effect 1859 * of flushing the vnode LRU. So, put vnodes that were loaded only for 1860 * cleaning at the head of the list, instead. 1861 */ 1862 void 1863 lfs_vunref_head(vp) 1864 struct vnode *vp; 1865 { 1866 simple_lock(&vp->v_interlock); 1867 #ifdef DIAGNOSTIC 1868 if(vp->v_usecount==0) { 1869 panic("lfs_vunref: v_usecount<0"); 1870 } 1871 #endif 1872 vp->v_usecount--; 1873 if (vp->v_usecount > 0) { 1874 simple_unlock(&vp->v_interlock); 1875 return; 1876 } 1877 #ifdef DIAGNOSTIC 1878 if(VOP_ISLOCKED(vp)) 1879 panic("lfs_vunref_head: vnode locked"); 1880 #endif 1881 /* 1882 * insert at head of LRU list 1883 */ 1884 simple_lock(&vnode_free_list_slock); 1885 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 1886 simple_unlock(&vnode_free_list_slock); 1887 simple_unlock(&vp->v_interlock); 1888 } 1889 1890
Indexes created Tue Sep 23 14:10:03 GMT 2025