1 /* $NetBSD: lfs_segment.c,v 1.37 1999/12/03 21:47:44 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@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 *, register 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; 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) { 202 fs->lfs_uinodes--; 203 } else 204 ip->i_flag |= IN_MODIFIED; 205 } 206 207 /* If the node is being written, wait until that is done */ 208 if(WRITEINPROG(vp)) { 209 #ifdef DEBUG_LFS 210 ivndebug(vp,"vflush/writeinprog"); 211 #endif 212 tsleep(vp, PRIBIO+1, "lfs_vw", 0); 213 } 214 215 /* Protect against VXLOCK deadlock in vinvalbuf() */ 216 lfs_seglock(fs, SEGM_SYNC); 217 218 /* If we're supposed to flush a freed inode, just toss it */ 219 /* XXX - seglock, so these buffers can't be gathered, right? */ 220 if(ip->i_ffs_mode == 0) { 221 printf("lfs_vflush: ino %d is freed, not flushing\n", 222 ip->i_number); 223 s = splbio(); 224 for(bp=vp->v_dirtyblkhd.lh_first; bp; bp=nbp) { 225 nbp = bp->b_vnbufs.le_next; 226 /* Copied from lfs_writeseg */ 227 if (bp->b_flags & B_CALL) { 228 /* if B_CALL, it was created with newbuf */ 229 lfs_freebuf(bp); 230 } else { 231 bremfree(bp); 232 bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | 233 B_LOCKED | B_GATHERED); 234 bp->b_flags |= B_DONE; 235 reassignbuf(bp, vp); 236 brelse(bp); 237 } 238 } 239 splx(s); 240 if(ip->i_flag & IN_CLEANING) 241 fs->lfs_uinodes--; 242 if(ip->i_flag & IN_MODIFIED) 243 fs->lfs_uinodes--; 244 ip->i_flag &= ~(IN_MODIFIED|IN_UPDATE|IN_ACCESS|IN_CHANGE|IN_CLEANING); 245 printf("lfs_vflush: done not flushing ino %d\n", 246 ip->i_number); 247 lfs_segunlock(fs); 248 return 0; 249 } 250 251 SET_FLUSHING(fs,vp); 252 if (fs->lfs_nactive > LFS_MAX_ACTIVE) { 253 error = lfs_segwrite(vp->v_mount, SEGM_SYNC|SEGM_CKP); 254 CLR_FLUSHING(fs,vp); 255 lfs_segunlock(fs); 256 return error; 257 } 258 sp = fs->lfs_sp; 259 260 if (vp->v_dirtyblkhd.lh_first == NULL) { 261 lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY); 262 } else if((ip->i_flag & IN_CLEANING) && (fs->lfs_sp->seg_flags & SEGM_CLEAN)) { 263 #ifdef DEBUG_LFS 264 ivndebug(vp,"vflush/clean"); 265 #endif 266 lfs_writevnodes(fs, vp->v_mount, sp, VN_CLEAN); 267 } 268 else if(lfs_dostats) { 269 if(vp->v_dirtyblkhd.lh_first || (VTOI(vp)->i_flag & (IN_MODIFIED|IN_UPDATE|IN_ACCESS|IN_CHANGE|IN_CLEANING))) 270 ++lfs_stats.vflush_invoked; 271 #ifdef DEBUG_LFS 272 ivndebug(vp,"vflush"); 273 #endif 274 } 275 276 #ifdef DIAGNOSTIC 277 /* XXX KS This actually can happen right now, though it shouldn't(?) */ 278 if(vp->v_flag & VDIROP) { 279 printf("lfs_vflush: flushing VDIROP, this shouldn\'t be\n"); 280 /* panic("VDIROP being flushed...this can\'t happen"); */ 281 } 282 if(vp->v_usecount<0) { 283 printf("usecount=%ld\n",vp->v_usecount); 284 panic("lfs_vflush: usecount<0"); 285 } 286 #endif 287 288 do { 289 do { 290 if (vp->v_dirtyblkhd.lh_first != NULL) 291 lfs_writefile(fs, sp, vp); 292 } while (lfs_writeinode(fs, sp, ip)); 293 } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM); 294 295 if(lfs_dostats) { 296 ++lfs_stats.nwrites; 297 if (sp->seg_flags & SEGM_SYNC) 298 ++lfs_stats.nsync_writes; 299 if (sp->seg_flags & SEGM_CKP) 300 ++lfs_stats.ncheckpoints; 301 } 302 lfs_segunlock(fs); 303 304 CLR_FLUSHING(fs,vp); 305 return (0); 306 } 307 308 #ifdef DEBUG_LFS_VERBOSE 309 # 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) 310 #else 311 # define vndebug(vp,str) 312 #endif 313 314 int 315 lfs_writevnodes(fs, mp, sp, op) 316 struct lfs *fs; 317 struct mount *mp; 318 struct segment *sp; 319 int op; 320 { 321 struct inode *ip; 322 struct vnode *vp; 323 int inodes_written=0, only_cleaning; 324 325 #ifndef LFS_NO_BACKVP_HACK 326 /* BEGIN HACK */ 327 #define VN_OFFSET (((caddr_t)&vp->v_mntvnodes.le_next) - (caddr_t)vp) 328 #define BACK_VP(VP) ((struct vnode *)(((caddr_t)VP->v_mntvnodes.le_prev) - VN_OFFSET)) 329 #define BEG_OF_VLIST ((struct vnode *)(((caddr_t)&mp->mnt_vnodelist.lh_first) - VN_OFFSET)) 330 331 /* Find last vnode. */ 332 loop: for (vp = mp->mnt_vnodelist.lh_first; 333 vp && vp->v_mntvnodes.le_next != NULL; 334 vp = vp->v_mntvnodes.le_next); 335 for (; vp && vp != BEG_OF_VLIST; vp = BACK_VP(vp)) { 336 #else 337 loop: 338 for (vp = mp->mnt_vnodelist.lh_first; 339 vp != NULL; 340 vp = vp->v_mntvnodes.le_next) { 341 #endif 342 /* 343 * If the vnode that we are about to sync is no longer 344 * associated with this mount point, start over. 345 */ 346 if (vp->v_mount != mp) 347 goto loop; 348 349 ip = VTOI(vp); 350 if ((op == VN_DIROP && !(vp->v_flag & VDIROP)) || 351 (op != VN_DIROP && op != VN_CLEAN && (vp->v_flag & VDIROP))) { 352 vndebug(vp,"dirop"); 353 continue; 354 } 355 356 if (op == VN_EMPTY && vp->v_dirtyblkhd.lh_first) { 357 vndebug(vp,"empty"); 358 continue; 359 } 360 361 if (vp->v_type == VNON) { 362 continue; 363 } 364 365 if(op == VN_CLEAN && ip->i_number != LFS_IFILE_INUM 366 && !(ip->i_flag & IN_CLEANING)) { 367 vndebug(vp,"cleaning"); 368 continue; 369 } 370 371 if (lfs_vref(vp)) { 372 vndebug(vp,"vref"); 373 continue; 374 } 375 376 #if 0 /* XXX KS - if we skip the ifile, things could go badly for us. */ 377 if(WRITEINPROG(vp)) { 378 lfs_vunref(vp); 379 #ifdef DEBUG_LFS 380 ivndebug(vp,"writevnodes/writeinprog"); 381 #endif 382 continue; 383 } 384 #endif 385 only_cleaning = 0; 386 /* 387 * Write the inode/file if dirty and it's not the 388 * the IFILE. 389 */ 390 if ((ip->i_flag & 391 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE | IN_CLEANING) || 392 vp->v_dirtyblkhd.lh_first != NULL)) 393 { 394 only_cleaning = ((ip->i_flag & (IN_ACCESS|IN_CHANGE|IN_MODIFIED|IN_UPDATE|IN_CLEANING))==IN_CLEANING); 395 396 if(ip->i_number != LFS_IFILE_INUM 397 && vp->v_dirtyblkhd.lh_first != NULL) 398 { 399 lfs_writefile(fs, sp, vp); 400 } 401 if(vp->v_dirtyblkhd.lh_first != NULL) { 402 if(WRITEINPROG(vp)) { 403 #ifdef DEBUG_LFS 404 ivndebug(vp,"writevnodes/write2"); 405 #endif 406 } else if(!(ip->i_flag & (IN_ACCESS|IN_CHANGE|IN_MODIFIED|IN_UPDATE|IN_CLEANING))) { 407 #ifdef DEBUG_LFS 408 printf("<%d>",ip->i_number); 409 #endif 410 ip->i_flag |= IN_MODIFIED; 411 ++fs->lfs_uinodes; 412 } 413 } 414 (void) lfs_writeinode(fs, sp, ip); 415 inodes_written++; 416 } 417 418 if(vp->v_flag & VDIROP) { 419 --lfs_dirvcount; 420 vp->v_flag &= ~VDIROP; 421 wakeup(&lfs_dirvcount); 422 lfs_vunref(vp); 423 } 424 425 if(lfs_clean_vnhead && only_cleaning) 426 lfs_vunref_head(vp); 427 else 428 lfs_vunref(vp); 429 } 430 return inodes_written; 431 } 432 433 int 434 lfs_segwrite(mp, flags) 435 struct mount *mp; 436 int flags; /* Do a checkpoint. */ 437 { 438 struct buf *bp; 439 struct inode *ip; 440 struct lfs *fs; 441 struct segment *sp; 442 struct vnode *vp; 443 SEGUSE *segusep; 444 ufs_daddr_t ibno; 445 int do_ckp, error, i; 446 int writer_set = 0; 447 int need_unlock = 0; 448 449 fs = VFSTOUFS(mp)->um_lfs; 450 451 lfs_imtime(fs); 452 453 /* 454 * If we are not the cleaner, and we have fewer than MIN_FREE_SEGS 455 * clean segments, wait until cleaner writes. 456 */ 457 if(!(flags & SEGM_CLEAN) 458 && (!fs->lfs_seglock || !(fs->lfs_sp->seg_flags & SEGM_CLEAN))) 459 { 460 do { 461 if (fs->lfs_nclean <= MIN_FREE_SEGS 462 || fs->lfs_avail <= 0) 463 { 464 wakeup(&lfs_allclean_wakeup); 465 wakeup(&fs->lfs_nextseg); 466 error = tsleep(&fs->lfs_avail, PRIBIO + 1, 467 "lfs_avail", 0); 468 if (error) { 469 return (error); 470 } 471 } 472 } while (fs->lfs_nclean <= MIN_FREE_SEGS || fs->lfs_avail <= 0); 473 } 474 475 /* 476 * Allocate a segment structure and enough space to hold pointers to 477 * the maximum possible number of buffers which can be described in a 478 * single summary block. 479 */ 480 do_ckp = (flags & SEGM_CKP) || fs->lfs_nactive > LFS_MAX_ACTIVE; 481 lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0)); 482 sp = fs->lfs_sp; 483 484 /* 485 * If lfs_flushvp is non-NULL, we are called from lfs_vflush, 486 * in which case we have to flush *all* buffers off of this vnode. 487 * We don't care about other nodes, but write any non-dirop nodes 488 * anyway in anticipation of another getnewvnode(). 489 * 490 * If we're cleaning we only write cleaning and ifile blocks, and 491 * no dirops, since otherwise we'd risk corruption in a crash. 492 */ 493 if(fs->lfs_flushvp) 494 lfs_writevnodes(fs, mp, sp, VN_REG); 495 else if(sp->seg_flags & SEGM_CLEAN) 496 lfs_writevnodes(fs, mp, sp, VN_CLEAN); 497 else { 498 lfs_writevnodes(fs, mp, sp, VN_REG); 499 while(fs->lfs_dirops) 500 if((error = tsleep(&fs->lfs_writer, PRIBIO + 1, 501 "lfs writer", 0))) 502 { 503 free(sp->bpp, M_SEGMENT); 504 free(sp, M_SEGMENT); 505 return (error); 506 } 507 fs->lfs_writer++; 508 writer_set=1; 509 lfs_writevnodes(fs, mp, sp, VN_DIROP); 510 ((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT); 511 } 512 513 /* 514 * If we are doing a checkpoint, mark everything since the 515 * last checkpoint as no longer ACTIVE. 516 */ 517 if (do_ckp) { 518 for (ibno = fs->lfs_cleansz + fs->lfs_segtabsz; 519 --ibno >= fs->lfs_cleansz; ) { 520 if (bread(fs->lfs_ivnode, ibno, fs->lfs_bsize, NOCRED, &bp)) 521 522 panic("lfs_segwrite: ifile read"); 523 segusep = (SEGUSE *)bp->b_data; 524 for (i = fs->lfs_sepb; i--; segusep++) 525 segusep->su_flags &= ~SEGUSE_ACTIVE; 526 527 /* But the current segment is still ACTIVE */ 528 if (fs->lfs_curseg/fs->lfs_sepb==(ibno-fs->lfs_cleansz)) 529 ((SEGUSE *)(bp->b_data))[fs->lfs_curseg%fs->lfs_sepb].su_flags |= SEGUSE_ACTIVE; 530 error = VOP_BWRITE(bp); 531 } 532 } 533 534 if (do_ckp || fs->lfs_doifile) { 535 redo: 536 vp = fs->lfs_ivnode; 537 /* 538 * Depending on the circumstances of our calling, the ifile 539 * inode might be locked. If it is, and if it is locked by 540 * us, we should VREF instead of vget here. 541 */ 542 need_unlock = 0; 543 if(VOP_ISLOCKED(vp) 544 && vp->v_lock.lk_lockholder == curproc->p_pid) { 545 VREF(vp); 546 } else { 547 while (vget(vp, LK_EXCLUSIVE)) 548 continue; 549 need_unlock = 1; 550 } 551 ip = VTOI(vp); 552 if (vp->v_dirtyblkhd.lh_first != NULL) 553 lfs_writefile(fs, sp, vp); 554 (void)lfs_writeinode(fs, sp, ip); 555 556 /* Only vput if we used vget() above. */ 557 if(need_unlock) 558 vput(vp); 559 else 560 vrele(vp); 561 562 if (lfs_writeseg(fs, sp) && do_ckp) 563 goto redo; 564 } else { 565 (void) lfs_writeseg(fs, sp); 566 } 567 568 /* 569 * If the I/O count is non-zero, sleep until it reaches zero. 570 * At the moment, the user's process hangs around so we can 571 * sleep. 572 */ 573 fs->lfs_doifile = 0; 574 if(writer_set && --fs->lfs_writer==0) 575 wakeup(&fs->lfs_dirops); 576 577 if(lfs_dostats) { 578 ++lfs_stats.nwrites; 579 if (sp->seg_flags & SEGM_SYNC) 580 ++lfs_stats.nsync_writes; 581 if (sp->seg_flags & SEGM_CKP) 582 ++lfs_stats.ncheckpoints; 583 } 584 lfs_segunlock(fs); 585 return (0); 586 } 587 588 /* 589 * Write the dirty blocks associated with a vnode. 590 */ 591 void 592 lfs_writefile(fs, sp, vp) 593 struct lfs *fs; 594 struct segment *sp; 595 struct vnode *vp; 596 { 597 struct buf *bp; 598 struct finfo *fip; 599 IFILE *ifp; 600 601 602 if (sp->seg_bytes_left < fs->lfs_bsize || 603 sp->sum_bytes_left < sizeof(struct finfo)) 604 (void) lfs_writeseg(fs, sp); 605 606 sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(ufs_daddr_t); 607 ++((SEGSUM *)(sp->segsum))->ss_nfinfo; 608 609 if(vp->v_flag & VDIROP) 610 ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT); 611 612 fip = sp->fip; 613 fip->fi_nblocks = 0; 614 fip->fi_ino = VTOI(vp)->i_number; 615 LFS_IENTRY(ifp, fs, fip->fi_ino, bp); 616 fip->fi_version = ifp->if_version; 617 brelse(bp); 618 619 /* 620 * It may not be necessary to write the meta-data blocks at this point, 621 * as the roll-forward recovery code should be able to reconstruct the 622 * list. 623 * 624 * We have to write them anyway, though, under two conditions: (1) the 625 * vnode is being flushed (for reuse by vinvalbuf); or (2) we are 626 * checkpointing. 627 */ 628 if((sp->seg_flags & SEGM_CLEAN) 629 && VTOI(vp)->i_number != LFS_IFILE_INUM 630 && !IS_FLUSHING(fs,vp)) 631 { 632 lfs_gather(fs, sp, vp, lfs_match_fake); 633 } else 634 lfs_gather(fs, sp, vp, lfs_match_data); 635 636 if(lfs_writeindir 637 || IS_FLUSHING(fs,vp) 638 || (sp->seg_flags & SEGM_CKP)) 639 { 640 lfs_gather(fs, sp, vp, lfs_match_indir); 641 lfs_gather(fs, sp, vp, lfs_match_dindir); 642 /* XXX KS - when is TRIPLE not true? */ /* #ifdef TRIPLE */ 643 lfs_gather(fs, sp, vp, lfs_match_tindir); 644 /* #endif */ 645 } 646 fip = sp->fip; 647 if (fip->fi_nblocks != 0) { 648 sp->fip = (FINFO*)((caddr_t)fip + sizeof(struct finfo) + 649 sizeof(ufs_daddr_t) * (fip->fi_nblocks-1)); 650 sp->start_lbp = &sp->fip->fi_blocks[0]; 651 } else { 652 sp->sum_bytes_left += sizeof(FINFO) - sizeof(ufs_daddr_t); 653 --((SEGSUM *)(sp->segsum))->ss_nfinfo; 654 } 655 } 656 657 int 658 lfs_writeinode(fs, sp, ip) 659 struct lfs *fs; 660 struct segment *sp; 661 struct inode *ip; 662 { 663 struct buf *bp, *ibp; 664 IFILE *ifp; 665 SEGUSE *sup; 666 ufs_daddr_t daddr; 667 ino_t ino; 668 int error, i, ndx; 669 int redo_ifile = 0; 670 struct timespec ts; 671 int gotblk=0; 672 673 if (!(ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE | IN_CLEANING))) 674 return(0); 675 676 /* Allocate a new inode block if necessary. */ 677 if ((ip->i_number != LFS_IFILE_INUM || sp->idp==NULL) && sp->ibp == NULL) { 678 /* Allocate a new segment if necessary. */ 679 if (sp->seg_bytes_left < fs->lfs_bsize || 680 sp->sum_bytes_left < sizeof(ufs_daddr_t)) 681 (void) lfs_writeseg(fs, sp); 682 683 /* Get next inode block. */ 684 daddr = fs->lfs_offset; 685 fs->lfs_offset += fsbtodb(fs, 1); 686 sp->ibp = *sp->cbpp++ = 687 getblk(VTOI(fs->lfs_ivnode)->i_devvp, daddr, fs->lfs_bsize, 0, 0); 688 gotblk++; 689 690 /* Zero out inode numbers */ 691 for (i = 0; i < INOPB(fs); ++i) 692 ((struct dinode *)sp->ibp->b_data)[i].di_inumber = 0; 693 694 ++sp->start_bpp; 695 fs->lfs_avail -= fsbtodb(fs, 1); 696 /* Set remaining space counters. */ 697 sp->seg_bytes_left -= fs->lfs_bsize; 698 sp->sum_bytes_left -= sizeof(ufs_daddr_t); 699 ndx = LFS_SUMMARY_SIZE / sizeof(ufs_daddr_t) - 700 sp->ninodes / INOPB(fs) - 1; 701 ((ufs_daddr_t *)(sp->segsum))[ndx] = daddr; 702 } 703 704 /* Update the inode times and copy the inode onto the inode page. */ 705 if (ip->i_flag & (IN_CLEANING|IN_MODIFIED)) 706 --fs->lfs_uinodes; 707 TIMEVAL_TO_TIMESPEC(&time, &ts); 708 LFS_ITIMES(ip, &ts, &ts, &ts); 709 710 if(ip->i_flag & IN_CLEANING) 711 ip->i_flag &= ~IN_CLEANING; 712 else 713 ip->i_flag &= ~(IN_ACCESS|IN_CHANGE|IN_MODIFIED|IN_UPDATE); 714 715 /* 716 * If this is the Ifile, and we've already written the Ifile in this 717 * partial segment, just overwrite it (it's not on disk yet) and 718 * continue. 719 * 720 * XXX we know that the bp that we get the second time around has 721 * already been gathered. 722 */ 723 if(ip->i_number == LFS_IFILE_INUM && sp->idp) { 724 *(sp->idp) = ip->i_din.ffs_din; 725 return 0; 726 } 727 728 bp = sp->ibp; 729 ((struct dinode *)bp->b_data)[sp->ninodes % INOPB(fs)] = 730 ip->i_din.ffs_din; 731 732 if(ip->i_number == LFS_IFILE_INUM) /* We know sp->idp == NULL */ 733 sp->idp = ((struct dinode *)bp->b_data)+(sp->ninodes % INOPB(fs)); 734 if(gotblk) { 735 bp->b_flags |= B_LOCKED; 736 brelse(bp); 737 } 738 739 /* Increment inode count in segment summary block. */ 740 ++((SEGSUM *)(sp->segsum))->ss_ninos; 741 742 /* If this page is full, set flag to allocate a new page. */ 743 if (++sp->ninodes % INOPB(fs) == 0) 744 sp->ibp = NULL; 745 746 /* 747 * If updating the ifile, update the super-block. Update the disk 748 * address and access times for this inode in the ifile. 749 */ 750 ino = ip->i_number; 751 if (ino == LFS_IFILE_INUM) { 752 daddr = fs->lfs_idaddr; 753 fs->lfs_idaddr = bp->b_blkno; 754 } else { 755 LFS_IENTRY(ifp, fs, ino, ibp); 756 daddr = ifp->if_daddr; 757 ifp->if_daddr = bp->b_blkno; 758 #ifdef LFS_DEBUG_NEXTFREE 759 if(ino > 3 && ifp->if_nextfree) { 760 vprint("lfs_writeinode",ITOV(ip)); 761 printf("lfs_writeinode: updating free ino %d\n", 762 ip->i_number); 763 } 764 #endif 765 error = VOP_BWRITE(ibp); 766 } 767 768 /* 769 * No need to update segment usage if there was no former inode address 770 * or if the last inode address is in the current partial segment. 771 */ 772 if (daddr != LFS_UNUSED_DADDR && 773 !(daddr >= fs->lfs_lastpseg && daddr <= bp->b_blkno)) { 774 LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); 775 #ifdef DIAGNOSTIC 776 if (sup->su_nbytes < DINODE_SIZE) { 777 /* XXX -- Change to a panic. */ 778 printf("lfs_writeinode: negative bytes (segment %d short by %d)\n", 779 datosn(fs, daddr), (int)DINODE_SIZE - sup->su_nbytes); 780 panic("lfs_writeinode: negative bytes"); 781 sup->su_nbytes = DINODE_SIZE; 782 } 783 #endif 784 sup->su_nbytes -= DINODE_SIZE; 785 redo_ifile = 786 (ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED)); 787 error = VOP_BWRITE(bp); 788 } 789 return (redo_ifile); 790 } 791 792 int 793 lfs_gatherblock(sp, bp, sptr) 794 struct segment *sp; 795 struct buf *bp; 796 int *sptr; 797 { 798 struct lfs *fs; 799 int version; 800 801 /* 802 * If full, finish this segment. We may be doing I/O, so 803 * release and reacquire the splbio(). 804 */ 805 #ifdef DIAGNOSTIC 806 if (sp->vp == NULL) 807 panic ("lfs_gatherblock: Null vp in segment"); 808 #endif 809 fs = sp->fs; 810 if (sp->sum_bytes_left < sizeof(ufs_daddr_t) || 811 sp->seg_bytes_left < bp->b_bcount) { 812 if (sptr) 813 splx(*sptr); 814 lfs_updatemeta(sp); 815 816 version = sp->fip->fi_version; 817 (void) lfs_writeseg(fs, sp); 818 819 sp->fip->fi_version = version; 820 sp->fip->fi_ino = VTOI(sp->vp)->i_number; 821 /* Add the current file to the segment summary. */ 822 ++((SEGSUM *)(sp->segsum))->ss_nfinfo; 823 sp->sum_bytes_left -= 824 sizeof(struct finfo) - sizeof(ufs_daddr_t); 825 826 if (sptr) 827 *sptr = splbio(); 828 return(1); 829 } 830 831 #ifdef DEBUG 832 if(bp->b_flags & B_GATHERED) { 833 printf("lfs_gatherblock: already gathered! Ino %d, lbn %d\n", 834 sp->fip->fi_ino, bp->b_lblkno); 835 return(0); 836 } 837 #endif 838 /* Insert into the buffer list, update the FINFO block. */ 839 bp->b_flags |= B_GATHERED; 840 *sp->cbpp++ = bp; 841 sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno; 842 843 sp->sum_bytes_left -= sizeof(ufs_daddr_t); 844 sp->seg_bytes_left -= bp->b_bcount; 845 return(0); 846 } 847 848 int 849 lfs_gather(fs, sp, vp, match) 850 struct lfs *fs; 851 struct segment *sp; 852 struct vnode *vp; 853 int (*match) __P((struct lfs *, struct buf *)); 854 { 855 struct buf *bp; 856 int s, count=0; 857 858 sp->vp = vp; 859 s = splbio(); 860 861 #ifndef LFS_NO_BACKBUF_HACK 862 loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) { 863 #else /* LFS_NO_BACKBUF_HACK */ 864 /* This is a hack to see if ordering the blocks in LFS makes a difference. */ 865 # define BUF_OFFSET (((void *)&bp->b_vnbufs.le_next) - (void *)bp) 866 # define BACK_BUF(BP) ((struct buf *)(((void *)BP->b_vnbufs.le_prev) - BUF_OFFSET)) 867 # define BEG_OF_LIST ((struct buf *)(((void *)&vp->v_dirtyblkhd.lh_first) - BUF_OFFSET)) 868 /* Find last buffer. */ 869 loop: for (bp = vp->v_dirtyblkhd.lh_first; bp && bp->b_vnbufs.le_next != NULL; 870 bp = bp->b_vnbufs.le_next); 871 for (; bp && bp != BEG_OF_LIST; bp = BACK_BUF(bp)) { 872 #endif /* LFS_NO_BACKBUF_HACK */ 873 if ((bp->b_flags & (B_BUSY|B_GATHERED)) || !match(fs, bp)) 874 continue; 875 if(vp->v_type == VBLK) { 876 /* For block devices, just write the blocks. */ 877 /* XXX Do we really need to even do this? */ 878 #ifdef DEBUG_LFS 879 if(count==0) 880 printf("BLK("); 881 printf("."); 882 #endif 883 /* Get the block before bwrite, so we don't corrupt the free list */ 884 bp->b_flags |= B_BUSY; 885 bremfree(bp); 886 bwrite(bp); 887 } else { 888 #ifdef DIAGNOSTIC 889 if (!(bp->b_flags & B_DELWRI)) 890 panic("lfs_gather: bp not B_DELWRI"); 891 if (!(bp->b_flags & B_LOCKED)) { 892 printf("lfs_gather: lbn %d blk %d not B_LOCKED\n", bp->b_lblkno, bp->b_blkno); 893 VOP_PRINT(bp->b_vp); 894 panic("lfs_gather: bp not B_LOCKED"); 895 } 896 #endif 897 if (lfs_gatherblock(sp, bp, &s)) { 898 goto loop; 899 } 900 } 901 count++; 902 } 903 splx(s); 904 #ifdef DEBUG_LFS 905 if(vp->v_type == VBLK && count) 906 printf(")\n"); 907 #endif 908 lfs_updatemeta(sp); 909 sp->vp = NULL; 910 return count; 911 } 912 913 /* 914 * Update the metadata that points to the blocks listed in the FINFO 915 * array. 916 */ 917 void 918 lfs_updatemeta(sp) 919 struct segment *sp; 920 { 921 SEGUSE *sup; 922 struct buf *bp; 923 struct lfs *fs; 924 struct vnode *vp; 925 struct indir a[NIADDR + 2], *ap; 926 struct inode *ip; 927 ufs_daddr_t daddr, lbn, off; 928 int error, i, nblocks, num; 929 930 vp = sp->vp; 931 nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp; 932 if (nblocks < 0) 933 panic("This is a bad thing\n"); 934 if (vp == NULL || nblocks == 0) 935 return; 936 937 /* Sort the blocks. */ 938 /* 939 * XXX KS - We have to sort even if the blocks come from the 940 * cleaner, because there might be other pending blocks on the 941 * same inode...and if we don't sort, and there are fragments 942 * present, blocks may be written in the wrong place. 943 */ 944 /* if (!(sp->seg_flags & SEGM_CLEAN)) */ 945 lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks); 946 947 /* 948 * Record the length of the last block in case it's a fragment. 949 * If there are indirect blocks present, they sort last. An 950 * indirect block will be lfs_bsize and its presence indicates 951 * that you cannot have fragments. 952 */ 953 sp->fip->fi_lastlength = sp->start_bpp[nblocks - 1]->b_bcount; 954 955 /* 956 * Assign disk addresses, and update references to the logical 957 * block and the segment usage information. 958 */ 959 fs = sp->fs; 960 for (i = nblocks; i--; ++sp->start_bpp) { 961 lbn = *sp->start_lbp++; 962 963 (*sp->start_bpp)->b_blkno = off = fs->lfs_offset; 964 if((*sp->start_bpp)->b_blkno == (*sp->start_bpp)->b_lblkno) { 965 printf("lfs_updatemeta: ino %d blk %d has same lbn and daddr\n", VTOI(vp)->i_number, off); 966 } 967 fs->lfs_offset += 968 fragstodb(fs, numfrags(fs, (*sp->start_bpp)->b_bcount)); 969 error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL); 970 if (error) 971 panic("lfs_updatemeta: ufs_bmaparray %d", error); 972 ip = VTOI(vp); 973 switch (num) { 974 case 0: 975 ip->i_ffs_db[lbn] = off; 976 break; 977 case 1: 978 ip->i_ffs_ib[a[0].in_off] = off; 979 break; 980 default: 981 ap = &a[num - 1]; 982 if (bread(vp, ap->in_lbn, fs->lfs_bsize, NOCRED, &bp)) 983 panic("lfs_updatemeta: bread bno %d", 984 ap->in_lbn); 985 /* 986 * Bread may create a new (indirect) block which needs 987 * to get counted for the inode. 988 */ 989 if (/* bp->b_blkno == -1 && */ 990 !(bp->b_flags & (B_DELWRI|B_DONE))) { 991 ip->i_ffs_blocks += fsbtodb(fs, 1); 992 fs->lfs_bfree -= fragstodb(fs, fs->lfs_frag); 993 } 994 ((ufs_daddr_t *)bp->b_data)[ap->in_off] = off; 995 VOP_BWRITE(bp); 996 } 997 /* Update segment usage information. */ 998 if (daddr != UNASSIGNED && !(daddr >= fs->lfs_lastpseg && daddr <= off)) { 999 LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); 1000 #ifdef DIAGNOSTIC 1001 if (sup->su_nbytes < (*sp->start_bpp)->b_bcount) { 1002 /* XXX -- Change to a panic. */ 1003 printf("lfs_updatemeta: negative bytes (segment %d short by %ld)\n", 1004 datosn(fs, daddr), (*sp->start_bpp)->b_bcount - sup->su_nbytes); 1005 printf("lfs_updatemeta: ino %d, lbn %d, addr = %x\n", 1006 VTOI(sp->vp)->i_number, (*sp->start_bpp)->b_lblkno, daddr); 1007 panic("lfs_updatemeta: negative bytes"); 1008 sup->su_nbytes = (*sp->start_bpp)->b_bcount; 1009 } 1010 #endif 1011 sup->su_nbytes -= (*sp->start_bpp)->b_bcount; 1012 error = VOP_BWRITE(bp); 1013 } 1014 } 1015 } 1016 1017 /* 1018 * Start a new segment. 1019 */ 1020 int 1021 lfs_initseg(fs) 1022 struct lfs *fs; 1023 { 1024 struct segment *sp; 1025 SEGUSE *sup; 1026 SEGSUM *ssp; 1027 struct buf *bp; 1028 int repeat; 1029 1030 sp = fs->lfs_sp; 1031 1032 repeat = 0; 1033 /* Advance to the next segment. */ 1034 if (!LFS_PARTIAL_FITS(fs)) { 1035 /* Wake up any cleaning procs waiting on this file system. */ 1036 wakeup(&lfs_allclean_wakeup); 1037 wakeup(&fs->lfs_nextseg); 1038 lfs_newseg(fs); 1039 repeat = 1; 1040 fs->lfs_offset = fs->lfs_curseg; 1041 sp->seg_number = datosn(fs, fs->lfs_curseg); 1042 sp->seg_bytes_left = fs->lfs_dbpseg * DEV_BSIZE; 1043 /* 1044 * If the segment contains a superblock, update the offset 1045 * and summary address to skip over it. 1046 */ 1047 LFS_SEGENTRY(sup, fs, sp->seg_number, bp); 1048 if (sup->su_flags & SEGUSE_SUPERBLOCK) { 1049 fs->lfs_offset += LFS_SBPAD / DEV_BSIZE; 1050 sp->seg_bytes_left -= LFS_SBPAD; 1051 } 1052 brelse(bp); 1053 } else { 1054 sp->seg_number = datosn(fs, fs->lfs_curseg); 1055 sp->seg_bytes_left = (fs->lfs_dbpseg - 1056 (fs->lfs_offset - fs->lfs_curseg)) * DEV_BSIZE; 1057 } 1058 fs->lfs_lastpseg = fs->lfs_offset; 1059 1060 sp->fs = fs; 1061 sp->ibp = NULL; 1062 sp->idp = NULL; 1063 sp->ninodes = 0; 1064 1065 /* Get a new buffer for SEGSUM and enter it into the buffer list. */ 1066 sp->cbpp = sp->bpp; 1067 *sp->cbpp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, 1068 fs->lfs_offset, LFS_SUMMARY_SIZE); 1069 sp->segsum = (*sp->cbpp)->b_data; 1070 bzero(sp->segsum, LFS_SUMMARY_SIZE); 1071 sp->start_bpp = ++sp->cbpp; 1072 fs->lfs_offset += LFS_SUMMARY_SIZE / DEV_BSIZE; 1073 1074 /* Set point to SEGSUM, initialize it. */ 1075 ssp = sp->segsum; 1076 ssp->ss_next = fs->lfs_nextseg; 1077 ssp->ss_nfinfo = ssp->ss_ninos = 0; 1078 ssp->ss_magic = SS_MAGIC; 1079 1080 /* Set pointer to first FINFO, initialize it. */ 1081 sp->fip = (struct finfo *)((caddr_t)sp->segsum + sizeof(SEGSUM)); 1082 sp->fip->fi_nblocks = 0; 1083 sp->start_lbp = &sp->fip->fi_blocks[0]; 1084 sp->fip->fi_lastlength = 0; 1085 1086 sp->seg_bytes_left -= LFS_SUMMARY_SIZE; 1087 sp->sum_bytes_left = LFS_SUMMARY_SIZE - sizeof(SEGSUM); 1088 1089 return(repeat); 1090 } 1091 1092 /* 1093 * Return the next segment to write. 1094 */ 1095 void 1096 lfs_newseg(fs) 1097 struct lfs *fs; 1098 { 1099 CLEANERINFO *cip; 1100 SEGUSE *sup; 1101 struct buf *bp; 1102 int curseg, isdirty, sn; 1103 1104 LFS_SEGENTRY(sup, fs, datosn(fs, fs->lfs_nextseg), bp); 1105 sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE; 1106 sup->su_nbytes = 0; 1107 sup->su_nsums = 0; 1108 sup->su_ninos = 0; 1109 (void) VOP_BWRITE(bp); 1110 1111 LFS_CLEANERINFO(cip, fs, bp); 1112 --cip->clean; 1113 ++cip->dirty; 1114 fs->lfs_nclean = cip->clean; 1115 (void) VOP_BWRITE(bp); 1116 1117 fs->lfs_lastseg = fs->lfs_curseg; 1118 fs->lfs_curseg = fs->lfs_nextseg; 1119 for (sn = curseg = datosn(fs, fs->lfs_curseg);;) { 1120 sn = (sn + 1) % fs->lfs_nseg; 1121 if (sn == curseg) 1122 panic("lfs_nextseg: no clean segments"); 1123 LFS_SEGENTRY(sup, fs, sn, bp); 1124 isdirty = sup->su_flags & SEGUSE_DIRTY; 1125 brelse(bp); 1126 if (!isdirty) 1127 break; 1128 } 1129 1130 ++fs->lfs_nactive; 1131 fs->lfs_nextseg = sntoda(fs, sn); 1132 if(lfs_dostats) { 1133 ++lfs_stats.segsused; 1134 } 1135 } 1136 1137 int 1138 lfs_writeseg(fs, sp) 1139 struct lfs *fs; 1140 struct segment *sp; 1141 { 1142 extern int locked_queue_count; 1143 extern long locked_queue_bytes; 1144 struct buf **bpp, *bp, *cbp; 1145 SEGUSE *sup; 1146 SEGSUM *ssp; 1147 dev_t i_dev; 1148 u_long *datap, *dp; 1149 int do_again, i, nblocks, s; 1150 #ifdef LFS_TRACK_IOS 1151 int j; 1152 #endif 1153 int (*strategy)__P((void *)); 1154 struct vop_strategy_args vop_strategy_a; 1155 u_short ninos; 1156 struct vnode *devvp; 1157 char *p; 1158 struct vnode *vn; 1159 struct inode *ip; 1160 #if defined(DEBUG) && defined(LFS_PROPELLER) 1161 static int propeller; 1162 char propstring[4] = "-\\|/"; 1163 1164 printf("%c\b",propstring[propeller++]); 1165 if(propeller==4) 1166 propeller = 0; 1167 #endif 1168 1169 /* 1170 * If there are no buffers other than the segment summary to write 1171 * and it is not a checkpoint, don't do anything. On a checkpoint, 1172 * even if there aren't any buffers, you need to write the superblock. 1173 */ 1174 if ((nblocks = sp->cbpp - sp->bpp) == 1) 1175 return (0); 1176 1177 #ifdef DEBUG_LFS 1178 lfs_check_bpp(fs,sp,__FILE__,__LINE__); 1179 #endif 1180 i_dev = VTOI(fs->lfs_ivnode)->i_dev; 1181 devvp = VTOI(fs->lfs_ivnode)->i_devvp; 1182 1183 /* Update the segment usage information. */ 1184 LFS_SEGENTRY(sup, fs, sp->seg_number, bp); 1185 1186 /* Loop through all blocks, except the segment summary. */ 1187 for (bpp = sp->bpp; ++bpp < sp->cbpp; ) { 1188 if((*bpp)->b_vp != devvp) 1189 sup->su_nbytes += (*bpp)->b_bcount; 1190 } 1191 1192 ssp = (SEGSUM *)sp->segsum; 1193 1194 ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs); 1195 sup->su_nbytes += ssp->ss_ninos * DINODE_SIZE; 1196 /* sup->su_nbytes += LFS_SUMMARY_SIZE; */ 1197 sup->su_lastmod = time.tv_sec; 1198 sup->su_ninos += ninos; 1199 ++sup->su_nsums; 1200 1201 do_again = !(bp->b_flags & B_GATHERED); 1202 (void)VOP_BWRITE(bp); 1203 /* 1204 * Compute checksum across data and then across summary; the first 1205 * block (the summary block) is skipped. Set the create time here 1206 * so that it's guaranteed to be later than the inode mod times. 1207 * 1208 * XXX 1209 * Fix this to do it inline, instead of malloc/copy. 1210 */ 1211 datap = dp = malloc(nblocks * sizeof(u_long), M_SEGMENT, M_WAITOK); 1212 for (bpp = sp->bpp, i = nblocks - 1; i--;) { 1213 if (((*++bpp)->b_flags & (B_CALL|B_INVAL)) == (B_CALL|B_INVAL)) { 1214 if (copyin((*bpp)->b_saveaddr, dp++, sizeof(u_long))) 1215 panic("lfs_writeseg: copyin failed [1]: ino %d blk %d", VTOI((*bpp)->b_vp)->i_number, (*bpp)->b_lblkno); 1216 } else { 1217 if( !((*bpp)->b_flags & B_CALL) ) { 1218 /* 1219 * Before we record data for a checksm, 1220 * make sure the data won't change in between 1221 * the checksum calculation and the write, 1222 * by marking the buffer B_BUSY. It will 1223 * be freed later by brelse(). 1224 */ 1225 again: 1226 s = splbio(); 1227 if((*bpp)->b_flags & B_BUSY) { 1228 #ifdef DEBUG 1229 printf("lfs_writeseg: avoiding potential data summary corruption for ino %d, lbn %d\n", 1230 VTOI((*bpp)->b_vp)->i_number, 1231 bp->b_lblkno); 1232 #endif 1233 (*bpp)->b_flags |= B_WANTED; 1234 tsleep((*bpp), (PRIBIO + 1), 1235 "lfs_writeseg", 0); 1236 splx(s); 1237 goto again; 1238 } 1239 (*bpp)->b_flags |= B_BUSY; 1240 splx(s); 1241 } 1242 *dp++ = ((u_long *)(*bpp)->b_data)[0]; 1243 } 1244 } 1245 ssp->ss_create = time.tv_sec; 1246 ssp->ss_datasum = cksum(datap, (nblocks - 1) * sizeof(u_long)); 1247 ssp->ss_sumsum = 1248 cksum(&ssp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(ssp->ss_sumsum)); 1249 free(datap, M_SEGMENT); 1250 #ifdef DIAGNOSTIC 1251 if (fs->lfs_bfree < fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE) 1252 panic("lfs_writeseg: No diskspace for summary"); 1253 #endif 1254 fs->lfs_bfree -= (fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE); 1255 1256 strategy = devvp->v_op[VOFFSET(vop_strategy)]; 1257 1258 /* 1259 * When we simply write the blocks we lose a rotation for every block 1260 * written. To avoid this problem, we allocate memory in chunks, copy 1261 * the buffers into the chunk and write the chunk. CHUNKSIZE is the 1262 * largest size I/O devices can handle. 1263 * When the data is copied to the chunk, turn off the the B_LOCKED bit 1264 * and brelse the buffer (which will move them to the LRU list). Add 1265 * the B_CALL flag to the buffer header so we can count I/O's for the 1266 * checkpoints and so we can release the allocated memory. 1267 * 1268 * XXX 1269 * This should be removed if the new virtual memory system allows us to 1270 * easily make the buffers contiguous in kernel memory and if that's 1271 * fast enough. 1272 */ 1273 1274 #define CHUNKSIZE MAXPHYS 1275 1276 if(devvp==NULL) 1277 panic("devvp is NULL"); 1278 for (bpp = sp->bpp,i = nblocks; i;) { 1279 cbp = lfs_newbuf(devvp, (*bpp)->b_blkno, CHUNKSIZE); 1280 cbp->b_dev = i_dev; 1281 cbp->b_flags |= B_ASYNC | B_BUSY; 1282 cbp->b_bcount = 0; 1283 1284 #ifdef DIAGNOSTIC 1285 if(datosn(fs,(*bpp)->b_blkno + ((*bpp)->b_bcount - 1)/DEV_BSIZE) != datosn(fs,cbp->b_blkno)) { 1286 panic("lfs_writeseg: Segment overwrite"); 1287 } 1288 #endif 1289 1290 s = splbio(); 1291 if(fs->lfs_iocount >= LFS_THROTTLE) { 1292 tsleep(&fs->lfs_iocount, PRIBIO+1, "lfs throttle", 0); 1293 } 1294 ++fs->lfs_iocount; 1295 #ifdef LFS_TRACK_IOS 1296 for(j=0;j<LFS_THROTTLE;j++) { 1297 if(fs->lfs_pending[j]==LFS_UNUSED_DADDR) { 1298 fs->lfs_pending[j] = cbp->b_blkno; 1299 break; 1300 } 1301 } 1302 #endif /* LFS_TRACK_IOS */ 1303 for (p = cbp->b_data; i && cbp->b_bcount < CHUNKSIZE; i--) { 1304 bp = *bpp; 1305 1306 if (bp->b_bcount > (CHUNKSIZE - cbp->b_bcount)) 1307 break; 1308 1309 /* 1310 * Fake buffers from the cleaner are marked as B_INVAL. 1311 * We need to copy the data from user space rather than 1312 * from the buffer indicated. 1313 * XXX == what do I do on an error? 1314 */ 1315 if ((bp->b_flags & (B_CALL|B_INVAL)) == (B_CALL|B_INVAL)) { 1316 if (copyin(bp->b_saveaddr, p, bp->b_bcount)) 1317 panic("lfs_writeseg: copyin failed [2]"); 1318 } else 1319 bcopy(bp->b_data, p, bp->b_bcount); 1320 p += bp->b_bcount; 1321 cbp->b_bcount += bp->b_bcount; 1322 if (bp->b_flags & B_LOCKED) { 1323 --locked_queue_count; 1324 locked_queue_bytes -= bp->b_bufsize; 1325 } 1326 bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | 1327 B_LOCKED | B_GATHERED); 1328 vn = bp->b_vp; 1329 if (bp->b_flags & B_CALL) { 1330 /* if B_CALL, it was created with newbuf */ 1331 lfs_freebuf(bp); 1332 } else { 1333 bremfree(bp); 1334 bp->b_flags |= B_DONE; 1335 if(vn) 1336 reassignbuf(bp, vn); 1337 brelse(bp); 1338 } 1339 if(bp->b_flags & B_NEEDCOMMIT) { /* XXX */ 1340 bp->b_flags &= ~B_NEEDCOMMIT; 1341 wakeup(bp); 1342 } 1343 1344 bpp++; 1345 1346 /* 1347 * If this is the last block for this vnode, but 1348 * there are other blocks on its dirty list, 1349 * set IN_MODIFIED/IN_CLEANING depending on what 1350 * sort of block. Only do this for our mount point, 1351 * not for, e.g., inode blocks that are attached to 1352 * the devvp. 1353 */ 1354 if(i>1 && vn && *bpp && (*bpp)->b_vp != vn 1355 && (*bpp)->b_vp && (bp=vn->v_dirtyblkhd.lh_first)!=NULL && 1356 vn->v_mount == fs->lfs_ivnode->v_mount) 1357 { 1358 ip = VTOI(vn); 1359 #ifdef DEBUG_LFS 1360 printf("lfs_writeseg: marking ino %d\n",ip->i_number); 1361 #endif 1362 if(!(ip->i_flag & (IN_CLEANING|IN_MODIFIED))) { 1363 fs->lfs_uinodes++; 1364 if(bp->b_flags & B_CALL) 1365 ip->i_flag |= IN_CLEANING; 1366 else 1367 ip->i_flag |= IN_MODIFIED; 1368 } 1369 } 1370 /* if(vn->v_dirtyblkhd.lh_first == NULL) */ 1371 wakeup(vn); 1372 } 1373 ++cbp->b_vp->v_numoutput; 1374 splx(s); 1375 /* 1376 * XXXX This is a gross and disgusting hack. Since these 1377 * buffers are physically addressed, they hang off the 1378 * device vnode (devvp). As a result, they have no way 1379 * of getting to the LFS superblock or lfs structure to 1380 * keep track of the number of I/O's pending. So, I am 1381 * going to stuff the fs into the saveaddr field of 1382 * the buffer (yuk). 1383 */ 1384 cbp->b_saveaddr = (caddr_t)fs; 1385 vop_strategy_a.a_desc = VDESC(vop_strategy); 1386 vop_strategy_a.a_bp = cbp; 1387 (strategy)(&vop_strategy_a); 1388 } 1389 /* 1390 * XXX 1391 * Vinvalbuf can move locked buffers off the locked queue 1392 * and we have no way of knowing about this. So, after 1393 * doing a big write, we recalculate how many buffers are 1394 * really still left on the locked queue. 1395 */ 1396 lfs_countlocked(&locked_queue_count,&locked_queue_bytes); 1397 wakeup(&locked_queue_count); 1398 if(lfs_dostats) { 1399 ++lfs_stats.psegwrites; 1400 lfs_stats.blocktot += nblocks - 1; 1401 if (fs->lfs_sp->seg_flags & SEGM_SYNC) 1402 ++lfs_stats.psyncwrites; 1403 if (fs->lfs_sp->seg_flags & SEGM_CLEAN) { 1404 ++lfs_stats.pcleanwrites; 1405 lfs_stats.cleanblocks += nblocks - 1; 1406 } 1407 } 1408 return (lfs_initseg(fs) || do_again); 1409 } 1410 1411 void 1412 lfs_writesuper(fs, daddr) 1413 struct lfs *fs; 1414 daddr_t daddr; 1415 { 1416 struct buf *bp; 1417 dev_t i_dev; 1418 int (*strategy) __P((void *)); 1419 int s; 1420 struct vop_strategy_args vop_strategy_a; 1421 1422 #ifdef LFS_CANNOT_ROLLFW 1423 /* 1424 * If we can write one superblock while another is in 1425 * progress, we risk not having a complete checkpoint if we crash. 1426 * So, block here if a superblock write is in progress. 1427 */ 1428 s = splbio(); 1429 while(fs->lfs_sbactive) { 1430 tsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0); 1431 } 1432 fs->lfs_sbactive = daddr; 1433 splx(s); 1434 #endif 1435 i_dev = VTOI(fs->lfs_ivnode)->i_dev; 1436 strategy = VTOI(fs->lfs_ivnode)->i_devvp->v_op[VOFFSET(vop_strategy)]; 1437 1438 /* Set timestamp of this version of the superblock */ 1439 fs->lfs_tstamp = time.tv_sec; 1440 1441 /* Checksum the superblock and copy it into a buffer. */ 1442 fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs)); 1443 bp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, daddr, LFS_SBPAD); 1444 *(struct dlfs *)bp->b_data = fs->lfs_dlfs; 1445 1446 bp->b_dev = i_dev; 1447 bp->b_flags |= B_BUSY | B_CALL | B_ASYNC; 1448 bp->b_flags &= ~(B_DONE | B_ERROR | B_READ | B_DELWRI); 1449 bp->b_iodone = lfs_supercallback; 1450 /* XXX KS - same nasty hack as above */ 1451 bp->b_saveaddr = (caddr_t)fs; 1452 1453 vop_strategy_a.a_desc = VDESC(vop_strategy); 1454 vop_strategy_a.a_bp = bp; 1455 s = splbio(); 1456 ++bp->b_vp->v_numoutput; 1457 splx(s); 1458 (strategy)(&vop_strategy_a); 1459 } 1460 1461 /* 1462 * Logical block number match routines used when traversing the dirty block 1463 * chain. 1464 */ 1465 int 1466 lfs_match_fake(fs, bp) 1467 struct lfs *fs; 1468 struct buf *bp; 1469 { 1470 return (bp->b_flags & B_CALL); 1471 } 1472 1473 int 1474 lfs_match_data(fs, bp) 1475 struct lfs *fs; 1476 struct buf *bp; 1477 { 1478 return (bp->b_lblkno >= 0); 1479 } 1480 1481 int 1482 lfs_match_indir(fs, bp) 1483 struct lfs *fs; 1484 struct buf *bp; 1485 { 1486 int lbn; 1487 1488 lbn = bp->b_lblkno; 1489 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 0); 1490 } 1491 1492 int 1493 lfs_match_dindir(fs, bp) 1494 struct lfs *fs; 1495 struct buf *bp; 1496 { 1497 int lbn; 1498 1499 lbn = bp->b_lblkno; 1500 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 1); 1501 } 1502 1503 int 1504 lfs_match_tindir(fs, bp) 1505 struct lfs *fs; 1506 struct buf *bp; 1507 { 1508 int lbn; 1509 1510 lbn = bp->b_lblkno; 1511 return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 2); 1512 } 1513 1514 /* 1515 * XXX - The only buffers that are going to hit these functions are the 1516 * segment write blocks, or the segment summaries, or the superblocks. 1517 * 1518 * All of the above are created by lfs_newbuf, and so do not need to be 1519 * released via brelse. 1520 */ 1521 void 1522 lfs_callback(bp) 1523 struct buf *bp; 1524 { 1525 struct lfs *fs; 1526 #ifdef LFS_TRACK_IOS 1527 int j; 1528 #endif 1529 1530 fs = (struct lfs *)bp->b_saveaddr; 1531 #ifdef DIAGNOSTIC 1532 if (fs->lfs_iocount == 0) 1533 panic("lfs_callback: zero iocount\n"); 1534 #endif 1535 if (--fs->lfs_iocount < LFS_THROTTLE) 1536 wakeup(&fs->lfs_iocount); 1537 #ifdef LFS_TRACK_IOS 1538 for(j=0;j<LFS_THROTTLE;j++) { 1539 if(fs->lfs_pending[j]==bp->b_blkno) { 1540 fs->lfs_pending[j] = LFS_UNUSED_DADDR; 1541 wakeup(&(fs->lfs_pending[j])); 1542 break; 1543 } 1544 } 1545 #endif /* LFS_TRACK_IOS */ 1546 1547 lfs_freebuf(bp); 1548 } 1549 1550 void 1551 lfs_supercallback(bp) 1552 struct buf *bp; 1553 { 1554 #ifdef LFS_CANNOT_ROLLFW 1555 struct lfs *fs; 1556 1557 fs = (struct lfs *)bp->b_saveaddr; 1558 fs->lfs_sbactive=NULL; 1559 wakeup(&fs->lfs_sbactive); 1560 #endif 1561 lfs_freebuf(bp); 1562 } 1563 1564 /* 1565 * Shellsort (diminishing increment sort) from Data Structures and 1566 * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290; 1567 * see also Knuth Vol. 3, page 84. The increments are selected from 1568 * formula (8), page 95. Roughly O(N^3/2). 1569 */ 1570 /* 1571 * This is our own private copy of shellsort because we want to sort 1572 * two parallel arrays (the array of buffer pointers and the array of 1573 * logical block numbers) simultaneously. Note that we cast the array 1574 * of logical block numbers to a unsigned in this routine so that the 1575 * negative block numbers (meta data blocks) sort AFTER the data blocks. 1576 */ 1577 1578 void 1579 lfs_shellsort(bp_array, lb_array, nmemb) 1580 struct buf **bp_array; 1581 ufs_daddr_t *lb_array; 1582 register int nmemb; 1583 { 1584 static int __rsshell_increments[] = { 4, 1, 0 }; 1585 register int incr, *incrp, t1, t2; 1586 struct buf *bp_temp; 1587 u_long lb_temp; 1588 1589 for (incrp = __rsshell_increments; (incr = *incrp++) != 0;) 1590 for (t1 = incr; t1 < nmemb; ++t1) 1591 for (t2 = t1 - incr; t2 >= 0;) 1592 if (lb_array[t2] > lb_array[t2 + incr]) { 1593 lb_temp = lb_array[t2]; 1594 lb_array[t2] = lb_array[t2 + incr]; 1595 lb_array[t2 + incr] = lb_temp; 1596 bp_temp = bp_array[t2]; 1597 bp_array[t2] = bp_array[t2 + incr]; 1598 bp_array[t2 + incr] = bp_temp; 1599 t2 -= incr; 1600 } else 1601 break; 1602 } 1603 1604 /* 1605 * Check VXLOCK. Return 1 if the vnode is locked. Otherwise, vget it. 1606 */ 1607 int 1608 lfs_vref(vp) 1609 register struct vnode *vp; 1610 { 1611 /* 1612 * If we return 1 here during a flush, we risk vinvalbuf() not 1613 * being able to flush all of the pages from this vnode, which 1614 * will cause it to panic. So, return 0 if a flush is in progress. 1615 */ 1616 if (vp->v_flag & VXLOCK) { 1617 if(IS_FLUSHING(VTOI(vp)->i_lfs,vp)) { 1618 return 0; 1619 } 1620 return(1); 1621 } 1622 return (vget(vp, 0)); 1623 } 1624 1625 /* 1626 * This is vrele except that we do not want to VOP_INACTIVE this vnode. We 1627 * inline vrele here to avoid the vn_lock and VOP_INACTIVE call at the end. 1628 */ 1629 void 1630 lfs_vunref(vp) 1631 register struct vnode *vp; 1632 { 1633 /* 1634 * Analogous to lfs_vref, if the node is flushing, fake it. 1635 */ 1636 if((vp->v_flag & VXLOCK) && IS_FLUSHING(VTOI(vp)->i_lfs,vp)) { 1637 return; 1638 } 1639 1640 simple_lock(&vp->v_interlock); 1641 #ifdef DIAGNOSTIC 1642 if(vp->v_usecount<=0) { 1643 printf("lfs_vunref: flags are 0x%lx\n", vp->v_flag); 1644 printf("lfs_vunref: usecount = %ld\n", vp->v_usecount); 1645 panic("lfs_vunref: v_usecount<0"); 1646 } 1647 #endif 1648 vp->v_usecount--; 1649 if (vp->v_usecount > 0) { 1650 simple_unlock(&vp->v_interlock); 1651 return; 1652 } 1653 #ifdef DIAGNOSTIC 1654 if(VOP_ISLOCKED(vp)) 1655 panic("lfs_vunref: vnode locked"); 1656 #endif 1657 /* 1658 * insert at tail of LRU list 1659 */ 1660 simple_lock(&vnode_free_list_slock); 1661 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 1662 simple_unlock(&vnode_free_list_slock); 1663 simple_unlock(&vp->v_interlock); 1664 } 1665 1666 /* 1667 * We use this when we have vnodes that were loaded in solely for cleaning. 1668 * There is no reason to believe that these vnodes will be referenced again 1669 * soon, since the cleaning process is unrelated to normal filesystem 1670 * activity. Putting cleaned vnodes at the tail of the list has the effect 1671 * of flushing the vnode LRU. So, put vnodes that were loaded only for 1672 * cleaning at the head of the list, instead. 1673 */ 1674 void 1675 lfs_vunref_head(vp) 1676 register struct vnode *vp; 1677 { 1678 simple_lock(&vp->v_interlock); 1679 #ifdef DIAGNOSTIC 1680 if(vp->v_usecount==0) { 1681 panic("lfs_vunref: v_usecount<0"); 1682 } 1683 #endif 1684 vp->v_usecount--; 1685 if (vp->v_usecount > 0) { 1686 simple_unlock(&vp->v_interlock); 1687 return; 1688 } 1689 #ifdef DIAGNOSTIC 1690 if(VOP_ISLOCKED(vp)) 1691 panic("lfs_vunref_head: vnode locked"); 1692 #endif 1693 /* 1694 * insert at head of LRU list 1695 */ 1696 simple_lock(&vnode_free_list_slock); 1697 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 1698 simple_unlock(&vnode_free_list_slock); 1699 simple_unlock(&vp->v_interlock); 1700 } 1701 1702