Formerly sizes.c.~23~

1 files changed, 126 insertions, 55 deletions

diff --git a/ufs/sizes.c b/ufs/sizes.c
index 0f0fd427..8f6174af 100644
--- a/ufs/sizes.c
+++ b/ufs/sizes.c
@@ -28,7 +28,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define MAY_CACHE 1
 #endif
 
-static int free_indir (struct node *np, daddr_t bno, int level);
+static int indir_release (struct node *np, daddr_t bno, int level);
 static void poke_pages (memory_object_t, vm_offset_t, vm_offset_t);
 
 /* Implement the diskfs_truncate callback; sse <hurd/diskfs.h> for the
@@ -38,12 +38,12 @@ diskfs_truncate (struct node *np,
 		 off_t length)
 {
   int offset;
-  daddr_t lastiblock[NIADDR], lastblock, bn;
   struct dinode *di = dino (np->dn->number);
   int blocksfreed = 0;
   error_t err;
-  int level;
   int i;
+  struct iblock_spec indirs[NIADDR + 1];
+  daddr_t lbn;
 
   if (length >= np->dn_stat.st_size)
     return 0;
@@ -104,17 +104,6 @@ diskfs_truncate (struct node *np,
 			np->allocsize - length, 1);
     }
 
-  /* Calculate index into node's block list of direct
-     and indirect blocks which we want to keep.  Lastblock
-     is -1 when the file is truncated to 0. */
-  lastblock = lblkno (sblock, length - 1);
-  lastiblock[INDIR_SINGLE] = lastblock - NDADDR;
-  lastiblock[INDIR_DOUBLE] = lastiblock[INDIR_SINGLE] - NINDIR (sblock);
-  lastiblock[INDIR_TRIPLE] = (lastiblock[INDIR_DOUBLE]
-			      - NINDIR (sblock) * NINDIR (sblock));
-  
-  /* lastiblock will now be negative for elements that we should free. */
-
   /* Update the size on disk; fsck will finish freeing blocks if necessary
      should we crash. */
   np->dn_stat.st_size = length;
@@ -122,52 +111,98 @@ diskfs_truncate (struct node *np,
   np->dn_set_ctime = 1;
   diskfs_node_update (np, 1);
 
-  /* Free the blocks. */
+  /* Find out the location information for the last block to
+     be retained */
+  lbn = lblkno (sblock, length - 1);
+  err = fetch_indir_spec (np, lbn, indirs);
+  /* err XXX */
+  
+  /* We don't support triple indirs */
+  assert (indirs[0].offset == -1 
+	  || indirs[1].offset == -1
+	  || indirs[2].offset == -1);
+
+  /* BSD carefully finds out how far to clear; it's vastly simpler
+     to just clear everything after the new last block. */
   
-  err = diskfs_catch_exception ();
-  if (err)
+  /* Free direct blocks */
+  if (indirs[0].offset < 0)
     {
-      rwlock_writer_unlock (&np->dn->allocptrlock);
-      return err;
+      /* ...mapped from the inode. */
+      for (i = lbn + 1; i < NDADDR; i++)
+	if (di->di_db[i])
+	  {
+	    long bsize = blksize (sblock, np, i);
+	    ffs_blkfree (np, di->di_db[i], bsize);
+	    di->di_db[i] = 0;
+	    blocksfreed += btodb (bsize);
+	  }
     }
-
-  /* Indirect blocks first. */
-  for (level = INDIR_TRIPLE; level >= INDIR_SINGLE; level--)
-    if (lastiblock[level] < 0 && di->di_ib[level])
-      {
-	int count;
-	count = free_indir (np, di->di_ib[level], level);
-	blocksfreed += count;
-	di->di_ib[level] = 0;
-      }
-
-  /* Whole direct blocks or frags */
-  for (i = NDADDR - 1; i > lastblock; i--)
+  else
     {
-      long bsize;
-
-      bn = di->di_db[i];
-      if (bn == 0)
-	continue;
-
-      bsize = blksize (sblock, np, i);
-      ffs_blkfree (np, bn, bsize);
-      blocksfreed += btodb (bsize);
-
-      di->di_db[i] = 0;
+      /* ... or mapped from sindir */
+      if (indirs[1].bno)
+	{
+	  daddr_t *sindir = indir_block (indirs[1].bno);
+	  for (i = indirs[0].offset + 1; i < NINDIR (sblock); i++)
+	    {
+	      ffs_blkfree (np, sindir[i], sblock->fs_bsize);
+	      sindir[i] = 0;
+	      blocksfreed += btodb (sblock->fs_bsize);
+	    }
+	  record_poke (sindir, sblock->fs_bsize);
+	}
     }
-
+  
+  /* Free single indirect blocks */
+  if (indirs[1].offset < 0)
+    {
+      /* ...mapped from the inode */
+      if (di->di_ib[INDIR_SINGLE] && indirs[1].offset == -2)
+	{
+	  blocksfreed += indir_release (np, di->di_ib[INDIR_SINGLE], 
+					INDIR_SINGLE);
+	  di->di_ib[INDIR_SINGLE] = 0;
+	}
+    }
+  else
+    {
+      /* ...or mapped from dindir */
+      if (indirs[2].bno)
+	{
+	  daddr_t *dindir = indir_block (indirs[2].bno);
+	  for (i = indirs[1].offset + 1; i < NINDIR (sblock); i++)
+	    {
+	      blocksfreed += indir_release (np, dindir[i], INDIR_SINGLE);
+	      dindir[i] = 0;
+	    }
+	  record_poke (dindir, sblock->fs_bsize);
+	}
+    }
+  
+  /* Free double indirect block */
+  assert (indirs[2].offset < 0); /* which must be mapped from the inode */
+  if (indirs[2].offset == -2)
+    {
+      if (di->di_ib[INDIR_DOUBLE])
+	{
+	  blocksfreed += indir_release (np, di->di_ib[INDIR_DOUBLE], 
+					INDIR_DOUBLE);
+	  di->di_ib[INDIR_DOUBLE] = 0;
+	}
+    }
+  
   /* Finally, check to see if the new last direct block is 
      changing size; if so release any frags necessary. */
-  if (lastblock >= 0
-      && di->di_db[lastblock])
+  if (lbn >= 0 && lbn < NDADDR && di->di_db[lbn])
     {
       long oldspace, newspace;
+      daddr_t bn;
       
-      bn = di->di_db[lastblock];
-      oldspace = blksize (sblock, np, lastblock);
+      bn = di->di_db[lbn];
+      oldspace = blksize (sblock, np, lbn);
       np->allocsize = fragroundup (sblock, length);
-      newspace = blksize (sblock, np, lastblock);
+      newspace = blksize (sblock, np, lbn);
       
       assert (newspace);
       
@@ -179,28 +214,56 @@ diskfs_truncate (struct node *np,
 	}
     }
   else
-    np->allocsize = fragroundup (sblock, length);
-  
-  diskfs_end_catch_exception ();
+    {
+      if (lbn > NDADDR)
+	np->allocsize = blkroundup (sblock, length);
+      else
+	np->allocsize = fragroundup (sblock, length);
+    }
+
+  record_poke (di, sizeof (struct dinode));
 
+  np->dn_stat.st_blocks -= blocksfreed;
   np->dn_set_ctime = 1;
   diskfs_node_update (np, 1);
 
   rwlock_writer_unlock (&np->dn->allocptrlock);
 
+  /* At this point the last block (as defined by np->allocsize)
+     might not be allocated.  We need to allocate it to maintain
+     the rule that the last block of a file is always allocated. */
+
+  if (np->allocsize && indirs[0].bno == 0)
+    {
+      /* The strategy is to reduce LBN until we get one that's allocated;
+	 then reduce allocsize accordingly, then call diskfs_grow. */
+      
+      do
+	err = fetch_indir_spec (np, --lbn, indirs);
+      /* err XXX */
+      while (indirs[0].bno == 0 && lbn >= 0);
+      
+      assert ((lbn + 1) * sblock->fs_bsize < np->allocsize);
+      np->allocsize = (lbn + 1) * sblock->fs_bsize;
+
+      diskfs_grow (np, length, 0);
+    }
+  
+  diskfs_end_catch_exception ();
+
   /* Now we can permit delayed copies again. */
   if (np->dn->fileinfo)
     pager_change_attributes (np->dn->fileinfo->p, MAY_CACHE,
 			     MEMORY_OBJECT_COPY_DELAY, 0);
   
-  return 0;
+  return err;
 }
 
 /* Free indirect block BNO of level LEVEL; recursing if necessary
    to free other indirect blocks.  Return the number of disk
    blocks freed. */
 static int
-free_indir (struct node *np, daddr_t bno, int level)
+indir_release (struct node *np, daddr_t bno, int level)
 {
   int count = 0;
   daddr_t *addrs;
@@ -219,7 +282,7 @@ free_indir (struct node *np, daddr_t bno, int level)
 	    count += btodb (sblock->fs_bsize);
 	  }
 	else
-	  count += free_indir (np, addrs[i], level - 1);
+	  count += indir_release (np, addrs[i], level - 1);
       }
   
   /* Subtlety: this block is no longer necessary; the information
@@ -263,6 +326,7 @@ free_indir (struct node *np, daddr_t bno, int level)
 }
 
 
+
 
 /* Implement the diskfs_grow callback; see <hurd/diskfs.h> for the 
    interface description. */
@@ -326,6 +390,7 @@ diskfs_grow (struct node *np,
 	    goto out;
 	  old_pbn = di->di_db[olbn];
 	  di->di_db[olbn] = bno;
+	  record_poke (di, sizeof (struct dinode));
 	  np->dn_set_ctime = 1;
 	  
 	  dev_write_sync (fsbtodb (sblock, bno) + btodb (osize),
@@ -360,6 +425,7 @@ diskfs_grow (struct node *np,
 	    goto out;
 	  
 	  di->di_db[lbn] = bno;
+	  record_poke (di, sizeof (struct dinode)); 
 	  np->dn_set_ctime = 1;
 	  
 	  dev_write_sync (fsbtodb (sblock, bno) + btodb (osize),
@@ -385,6 +451,7 @@ diskfs_grow (struct node *np,
 	    goto out;
 	  
 	  di->di_db[lbn] = bno;
+	  record_poke (di, sizeof (struct dinode));
 	  np->dn_set_ctime = 1;
 
 	  dev_write_sync (fsbtodb (sblock, bno), zeroblock, size);
@@ -426,6 +493,7 @@ diskfs_grow (struct node *np,
 		goto out;
 	      zero_disk_block (bno);
 	      indirs[1].bno = di->di_ib[INDIR_SINGLE] = bno;
+	      record_poke (di, sizeof (struct dinode));
 	    }
 	  else
 	    {
@@ -446,6 +514,7 @@ diskfs_grow (struct node *np,
 		    goto out;
 		  zero_disk_block (bno);
 		  indirs[2].bno = di->di_ib[INDIR_DOUBLE] = bno;
+		  record_poke (di, sizeof (struct dinode));
 		}
 	      
 	      diblock = indir_block (indirs[2].bno);
@@ -460,6 +529,7 @@ diskfs_grow (struct node *np,
 		goto out;
 	      zero_disk_block (bno);
 	      indirs[1].bno = diblock[indirs[1].offset] = bno;
+	      record_poke (diblock, sblock->fs_bsize);
 	    }
 	}
       
@@ -473,6 +543,7 @@ diskfs_grow (struct node *np,
       if (err)
 	goto out;
       indirs[0].bno = siblock[indirs[0].offset] = bno;
+      record_poke (siblock, sblock->fs_bsize);
       dev_write_sync (fsbtodb (sblock, bno), zeroblock, sblock->fs_bsize);
     }