Diff for /src/sys/kern/vfs_bio.c between versions 1.24 and 1.25

version 1.24, 2004/05/10 10:51:31 version 1.25, 2004/05/13 17:40:15
Line 1125  brelse(struct buf * bp) Line 1125  brelse(struct buf * bp)
                         vm_page_flag_clear(m, PG_ZERO);                          vm_page_flag_clear(m, PG_ZERO);
                         /*                          /*
                          * If we hit a bogus page, fixup *all* of them                           * If we hit a bogus page, fixup *all* of them
                         * now.                         * now.  Note that we left these pages wired
                          * when we removed them so they had better exist,
                          * and they cannot be ripped out from under us so
                          * no splvm() protection is necessary.
                          */                           */
                         if (m == bogus_page) {                          if (m == bogus_page) {
                                 VOP_GETVOBJECT(vp, &obj);                                  VOP_GETVOBJECT(vp, &obj);
Line 1704  restart: Line 1707  restart:
                 LIST_REMOVE(bp, b_hash);                  LIST_REMOVE(bp, b_hash);
                 LIST_INSERT_HEAD(&invalhash, bp, b_hash);                  LIST_INSERT_HEAD(&invalhash, bp, b_hash);
   
                   /*
                    * spl protection not required when scrapping a buffer's
                    * contents because it is already wired.
                    */
                 if (bp->b_bufsize)                  if (bp->b_bufsize)
                         allocbuf(bp, 0);                          allocbuf(bp, 0);
   
Line 1974  incore(struct vnode * vp, daddr_t blkno) Line 1981  incore(struct vnode * vp, daddr_t blkno)
 }  }
   
 /*  /*
 * Returns true if no I/O is needed to access the * Returns true if no I/O is needed to access the associated VM object.
 * associated VM object.  This is like incore except * This is like incore except it also hunts around in the VM system for
 * it also hunts around in the VM system for the data. * the data.
  *
  * Note that we ignore vm_page_free() races from interrupts against our
  * lookup, since if the caller is not protected our return value will not
  * be any more valid then otherwise once we splx().
  */   */
   
 int  int
 inmem(struct vnode * vp, daddr_t blkno)  inmem(struct vnode * vp, daddr_t blkno)
 {  {
Line 2357  loop: Line 2367  loop:
 /*  /*
  * Get an empty, disassociated buffer of given size.  The buffer is initially   * Get an empty, disassociated buffer of given size.  The buffer is initially
  * set to B_INVAL.   * set to B_INVAL.
    *
    * spl protection is not required for the allocbuf() call because races are
    * impossible here.
  */   */
 struct buf *  struct buf *
 geteblk(int size)  geteblk(int size)
Line 2389  geteblk(int size) Line 2402  geteblk(int size)
  *   *
  * allocbuf() only adjusts B_CACHE for VMIO buffers.  getblk() deals with   * allocbuf() only adjusts B_CACHE for VMIO buffers.  getblk() deals with
  * B_CACHE for the non-VMIO case.   * B_CACHE for the non-VMIO case.
    *
    * This routine does not need to be called at splbio() but you must own the
    * buffer.
  */   */
   
 int  int
 allocbuf(struct buf *bp, int size)  allocbuf(struct buf *bp, int size)
 {  {
Line 2548  allocbuf(struct buf *bp, int size) Line 2563  allocbuf(struct buf *bp, int size)
                         vm_object_t obj;                          vm_object_t obj;
                         vm_offset_t toff;                          vm_offset_t toff;
                         vm_offset_t tinc;                          vm_offset_t tinc;
                           int s;
   
                         /*                          /*
                          * Step 1, bring in the VM pages from the object,                            * Step 1, bring in the VM pages from the object, 
                          * allocating them if necessary.  We must clear                           * allocating them if necessary.  We must clear
                          * B_CACHE if these pages are not valid for the                            * B_CACHE if these pages are not valid for the 
                          * range covered by the buffer.                           * range covered by the buffer.
                            *
                            * spl protection is required to protect against
                            * interrupts unbusying and freeing pages between
                            * our vm_page_lookup() and our busycheck/wiring
                            * call.
                          */                           */
   
                         vp = bp->b_vp;                          vp = bp->b_vp;
                         VOP_GETVOBJECT(vp, &obj);                          VOP_GETVOBJECT(vp, &obj);
   
                           s = splbio();
                         while (bp->b_npages < desiredpages) {                          while (bp->b_npages < desiredpages) {
                                 vm_page_t m;                                  vm_page_t m;
                                 vm_pindex_t pi;                                  vm_pindex_t pi;
Line 2615  allocbuf(struct buf *bp, int size) Line 2636  allocbuf(struct buf *bp, int size)
                                 bp->b_pages[bp->b_npages] = m;                                  bp->b_pages[bp->b_npages] = m;
                                 ++bp->b_npages;                                  ++bp->b_npages;
                         }                          }
                           splx(s);
   
                         /*                          /*
                          * Step 2.  We've loaded the pages into the buffer,                           * Step 2.  We've loaded the pages into the buffer,
Line 2822  biodone(struct buf * bp) Line 2844  biodone(struct buf * bp)
                                 resid = iosize;                                  resid = iosize;
   
                         /*                          /*
                         * cleanup bogus pages, restoring the originals                         * cleanup bogus pages, restoring the originals.  Since
                          * the originals should still be wired, we don't have
                          * to worry about interrupt/freeing races destroying
                          * the VM object association.
                          */                           */
                         m = bp->b_pages[i];                          m = bp->b_pages[i];
                         if (m == bogus_page) {                          if (m == bogus_page) {
Line 2921  vfs_unbusy_pages(struct buf * bp) Line 2946  vfs_unbusy_pages(struct buf * bp)
                 for (i = 0; i < bp->b_npages; i++) {                  for (i = 0; i < bp->b_npages; i++) {
                         vm_page_t m = bp->b_pages[i];                          vm_page_t m = bp->b_pages[i];
   
                           /*
                            * When restoring bogus changes the original pages
                            * should still be wired, so we are in no danger of
                            * losing the object association and do not need
                            * spl protection particularly.
                            */
                         if (m == bogus_page) {                          if (m == bogus_page) {
                                 m = vm_page_lookup(obj, OFF_TO_IDX(bp->b_offset) + i);                                  m = vm_page_lookup(obj, OFF_TO_IDX(bp->b_offset) + i);
                                 if (!m) {                                  if (!m) {

Removed from v.1.24  
changed lines
  Added in v.1.25