Formerly truncate.c.~5~

1 files changed, 207 insertions, 149 deletions

diff --git a/ext2fs/truncate.c b/ext2fs/truncate.c
index 1aae239a..0ae368e6 100644
--- a/ext2fs/truncate.c
+++ b/ext2fs/truncate.c
@@ -1,3 +1,23 @@
+/* File truncation & growth routines.
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+
+   Converted to work under the hurd by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
 /*
  *  linux/fs/ext2/truncate.c
  *
@@ -37,124 +57,113 @@
     - (addr_per_block * addr_per_block + addr_per_block + EXT2_NDIR_BLOCKS)) \
    / (addr_per_block * addr_per_block))
 
-static int trunc_direct (struct node * node, unsigned long length)
+static void
+trunc_direct (struct node * node, unsigned long length)
 {
-  u32 * p;
-  int i, tmp;
+  u32 block;
+  int i;
   char * bh;
   unsigned long block_to_free = 0;
   unsigned long free_count = 0;
-  int retry = 0;
   int blocks = block_size / 512;
   int direct_block = DIRECT_BLOCK(length);
 
- repeat:
   for (i = direct_block ; i < EXT2_NDIR_BLOCKS ; i++)
     {
-      p = node->dn.info.i_data + i;
-      tmp = *p;
-      if (!tmp)
+      block = node->dn.info.i_data[i];
+      if (!block)
 	continue;
 
-      bh = baddr(tmp);
+      bh = baddr(block);
 
       if (i < direct_block)
 	goto repeat;
 
-      if ((bh && bh->b_count != 1) || tmp != *p)
-	{
-	  retry = 1;
-	  continue;
-	}
+      node->dn.info.i_data[i] = 0;
 
-      *p = 0;
       node->dn_stat.st_blocks -= blocks;
-      node->dirty = 1;
+      node->dn_stat_dirty = 1;
 
       if (free_count == 0) {
-	block_to_free = tmp;
+	block_to_free = block;
 	free_count++;
-      } else if (free_count > 0 && block_to_free == tmp - free_count)
+      } else if (free_count > 0 && block_to_free == block - free_count)
 	free_count++;
       else {
 	ext2_free_blocks (block_to_free, free_count);
-	block_to_free = tmp;
+	block_to_free = block;
 	free_count = 1;
       }
-      /*		ext2f_free_blocks (tmp, 1); */
+
+#if 0
+      ext2f_free_blocks (block, 1);
+#endif
     }
 
   if (free_count > 0)
     ext2_free_blocks (block_to_free, free_count);
-
-  return retry;
 }
 
-static int trunc_indirect (struct node * node, unsigned long length,
-			   int offset, u32 * p)
+static void
+trunc_indirect (struct node * node, unsigned long length,
+		int offset, u32 * p)
 {
-  int i, tmp;
+  int i, block;
   char * bh;
   char * ind_bh;
   u32 * ind;
   unsigned long block_to_free = 0;
   unsigned long free_count = 0;
-  int retry = 0;
   int blocks = block_size / 512;
   int indirect_block = INDIRECT_BLOCK (length, offset);
 
-  tmp = *p;
-  if (!tmp)
+  block = *p;
+  if (!block)
     return 0;
-  ind_bh = baddr (tmp);
-  if (tmp != *p)
-    return 1;
+
+  ind_bh = baddr (block);
   if (!ind_bh) {
     *p = 0;
     return 0;
   }
 
- repeat:
   for (i = indirect_block ; i < addr_per_block ; i++)
     {
       if (i < 0)
 	i = 0;
-      if (i < indirect_block)
-	goto repeat;
 
-      ind = i + (u32 *) ind_bh;
-      tmp = *ind;
-      if (!tmp)
+      ind = (u32 *)ind_bh + i;
+      block = *ind;
+      if (!block)
 	continue;
 
-      bh = baddr (tmp);
+      bh = baddr (block);
       if (i < indirect_block)
 	goto repeat;
-      if ((bh && bh->b_count != 1) || tmp != *ind)
-	{
-	  retry = 1;
-	  continue;
-	}
 
       *ind = 0;
-      poke_loc (ind, sizeof *ind);
+      pokel_add (&node->dn.pokel, ind, sizeof *ind);
 
       if (free_count == 0)
 	{
-	  block_to_free = tmp;
+	  block_to_free = block;
 	  free_count++;
 	}
-      else if (free_count > 0 && block_to_free == tmp - free_count)
+      else if (free_count > 0 && block_to_free == block - free_count)
 	free_count++;
       else
 	{
 	  ext2_free_blocks (block_to_free, free_count);
-	  block_to_free = tmp;
+	  block_to_free = block;
 	  free_count = 1;
 	}
-      /*		ext2_free_blocks (tmp, 1); */
+
+#if 0
+      ext2_free_blocks (block, 1);
+#endif
+
       node->dn_stat.st_blocks -= blocks;
-      node->dirty = 1;
+      node->dn_stat_dirty = 1;
     }
 
   if (free_count > 0)
@@ -165,59 +174,50 @@ static int trunc_indirect (struct node * node, unsigned long length,
     if (*(ind++))
       break;
   if (i >= addr_per_block)
-    if (ind_bh->b_count != 1)
-      retry = 1;
-    else
-      {
-	tmp = *p;
-	*p = 0;
-	node->dn_stat.st_blocks -= blocks;
-	node->dirty = 1;
-	ext2_free_blocks (tmp, 1);
-      }
+    {
+      block = *p;
+      *p = 0;
+      node->dn_stat.st_blocks -= blocks;
+      node->dn_stat_dirty = 1;
+      ext2_free_blocks (block, 1);
+    }
 
   return retry;
 }
 
-static int trunc_dindirect (struct node * node, unsigned long length,
-			    int offset, u32 * p)
+static void
+trunc_dindirect (struct node * node, unsigned long length,
+		 int offset, u32 * p)
 {
-  int i, tmp;
+  int i, block;
   char * dind_bh;
   u32 * dind;
-  int retry = 0;
   int blocks = block_size / 512;
   int dindirect_block = DINDIRECT_BLOCK (length, offset);
 
-  tmp = *p;
-  if (!tmp)
+  block = *p;
+  if (!block)
     return 0;
 
-  dind_bh = baddr (tmp);
-  if (tmp != *p)
-    return 1;
-
+  dind_bh = baddr (block);
   if (!dind_bh)
     {
       *p = 0;
       return 0;
     }
 
- repeat:
   for (i = dindirect_block ; i < addr_per_block ; i++) {
     if (i < 0)
       i = 0;
-    if (i < dindirect_block)
-      goto repeat;
 
     dind = i + (u32 *) dind_bh;
-    tmp = *dind;
-    if (!tmp)
+    block = *dind;
+    if (!block)
       continue;
 
-    retry |= trunc_indirect (node, offset + (i * addr_per_block), dind);
+    trunc_indirect (node, offset + (i * addr_per_block), dind);
 
-    poke_loc (dind_bh, block_size);
+    pokel_add (&node->dn.pokel, dindh_bh, block_size);
   }
 
   dind = (u32 *) dind_bh;
@@ -226,23 +226,21 @@ static int trunc_dindirect (struct node * node, unsigned long length,
       break;
 
   if (i >= addr_per_block)
-    if (dind_bh->b_count != 1)
-      retry = 1;
-    else
-      {
-	tmp = *p;
-	*p = 0;
-	node->dn_stat.st_blocks -= blocks;
-	node->dirty = 1;
-	ext2_free_blocks (tmp, 1);
-      }
+    {
+      block = *p;
+      *p = 0;
+      node->dn_stat.st_blocks -= blocks;
+      node->dn_stat_dirty = 1;
+      ext2_free_blocks (block, 1);
+    }
 
   return retry;
 }
 
-static int trunc_tindirect (struct node * node, unsigned long length)
+static void
+trunc_tindirect (struct node * node, unsigned long length)
 {
-  int i, tmp;
+  int i, block;
   char * tind_bh;
   u32 * tind, * p;
   int retry = 0;
@@ -250,35 +248,28 @@ static int trunc_tindirect (struct node * node, unsigned long length)
   int tindirect_block = TINDIRECT_BLOCK (length);
 
   p = node->dn.info.i_data + EXT2_TIND_BLOCK;
-  if (!(tmp = *p))
+  if (!(block = *p))
     return 0;
 
-  tind_bh = baddr (tmp);
-  if (tmp != *p)
-    return 1;
-
+  tind_bh = baddr (block);
   if (!tind_bh)
     {
       *p = 0;
       return 0;
     }
 
-repeat:
   for (i = tindirect_block ; i < addr_per_block ; i++)
     {
       if (i < 0)
 	i = 0;
-      if (i < tindirect_block)
-	goto repeat;
 
       tind = i + (u32 *) tind_bh;
-      retry |=
-	trunc_dindirect(node,
-			(EXT2_NDIR_BLOCKS
-			 + addr_per_block
-			 + (i + 1) * addr_per_block * addr_per_block),
-			tind);
-      poke_loc (tind_bh, block_size);
+      trunc_dindirect(node,
+		      (EXT2_NDIR_BLOCKS
+		       + addr_per_block
+		       + (i + 1) * addr_per_block * addr_per_block),
+		      tind);
+      pokel_add (&node->dn.pokel, tindh_bh, block_size);
     }
 
   tind = (u32 *) tind_bh;
@@ -287,55 +278,82 @@ repeat:
       break;
 
   if (i >= addr_per_block)
-    if (tind_bh->b_count != 1)
-      retry = 1;
-    else
-      {
-	tmp = *p;
-	*p = 0;
-	node->dn_stat.st_blocks -= blocks;
-	node->dirty = 1;
-	ext2_free_blocks (tmp, 1);
-      }
+    {
+      block = *p;
+      *p = 0;
+      node->dn_stat.st_blocks -= blocks;
+      node->dn_stat_dirty = 1;
+      ext2_free_blocks (block, 1);
+    }
+}
+
+/* ---------------------------------------------------------------- */
+
+/* Flush all the data past the new size from the kernel.  Also force any
+   delayed copies of this data to take place immediately.  (We are implicitly
+   changing the data to zeros and doing it without the kernel's immediate
+   knowledge; accordingl we must help out the kernel thusly.) */
+static void
+force_delayed_copies (struct node *node, off_t length)
+{
+  spin_lock (&node2pagelock);
+  upi = np->dn->fileinfo;
+  if (upi)
+    pager_reference (upi->p);
+  spin_unlock (&node2pagelock);
+ 
+  if (upi)
+    {
+      mach_port_t obj;
+      
+      pager_change_attributes (upi->p, MAY_CACHE, MEMORY_OBJECT_COPY_NONE, 1);
+      obj = diskfs_get_filemap (np);
+      poke_pages (obj, round_page (length), round_page (np->allocsize));
+      mach_port_deallocate (mach_task_self (), obj);
+      pager_flush_some (upi->p, round_page(length), np->allocsize - length, 1);
+      pager_unreference (upi->p);
+    }
+}
 
-  return retry;
+static void
+enable_delayed_copies (struct node *node)
+{
+  spin_lock (&node2pagelock);
+  upi = np->dn->fileinfo;
+  if (upi)
+    pager_reference (upi->p);
+  spin_unlock (&node2pagelock);
+  if (upi)
+    {
+      pager_change_attributes (upi->p, MAY_CACHE, MEMORY_OBJECT_COPY_DELAY, 0);
+      pager_unreference (upi->p);
+    }
 }
-		
-void ext2_truncate (struct node * node)
+
+/* ---------------------------------------------------------------- */
+
+/* The user must define this function.  Truncate locked node NP to be SIZE
+   bytes long.  (If NP is already less than or equal to SIZE bytes
+   long, do nothing.)  If this is a symlink (and diskfs_shortcut_symlink
+   is set) then this should clear the symlink, even if 
+   diskfs_create_symlink_hook stores the link target elsewhere.  */
+error_t
+diskfs_truncate (struct node *np, off_t length)
 {
-  int retry;
   int offset;
   mode_t mode = node->dn_state.st_mode;
 
-  if (!(S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
-    return;
+  if (S_ISDIR(mode))
+    return EISDIR;
+  if (!S_ISREG(mode))
+    return EINVAL;
   if (IS_APPEND(node) || IS_IMMUTABLE(node))
-    return;
+    return EINVAL;
 
-  ext2_discard_prealloc(node);
+  if (length >= np->dn_stat.st_size)
+    return 0;
 
-  while (1)
-    {
-      down(&node->i_sem);
-      retry = trunc_direct(node, length);
-      retry |=
-	trunc_indirect (node, length, EXT2_IND_BLOCK,
-			(u32 *) &node->dn.info.i_data[EXT2_IND_BLOCK]);
-      retry |=
-	trunc_dindirect (node, length, EXT2_IND_BLOCK +
-			 EXT2_ADDR_PER_BLOCK(sblock),
-			 (u32 *) &node->dn.info.i_data[EXT2_DIND_BLOCK]);
-      retry |= trunc_tindirect (node, length);
-      up(&node->i_sem);
-
-      if (!retry)
-	break;
-
-      if (IS_SYNC(node) && node->dirty)
-	ext2_sync_inode (node);
-      current->counter = 0;
-      schedule ();
-    }
+  assert (!diskfs_readonly);
 
   /*
    * If the file is not being truncated to a block boundary, the
@@ -343,15 +361,55 @@ void ext2_truncate (struct node * node)
    * zeroed in case it ever becomes accessible again because of
    * subsequent file growth.
    */
-  offset = node->allocsize % block_size;
-  if (offset)
+  offset = length % block_size;
+  if (offset > 0)
+    {
+      diskfs_node_rdwr (np, (void *)zeroblock, length, block_size - offset,
+			1, 0, 0);
+      diskfs_file_update (np, 1);
+    }
+
+  ext2_discard_prealloc(node);
+
+  force_delayed_copies (np, length);
+
+  rwlock_writer_lock (&np->dn->allocptrlock);
+
+  /* Update the size on disk; fsck will finish freeing blocks if necessary
+     should we crash. */
+  np->dn_stat.st_size = length;
+  np->dn_set_mtime = 1;
+  np->dn_set_ctime = 1;
+  diskfs_node_update (np, 1);
+
+  err = diskfs_catch_exception();
+  if (!err)
     {
-      char * bh = baddr (node->allocsize / block_size);
-      memset (bh + offset, 0, block_size - offset);
-      poke_loc (bh + offset, block_size - offset);
+      trunc_direct(node, length);
+      trunc_indirect (node, length, EXT2_IND_BLOCK,
+		      (u32 *) &node->dn.info.i_data[EXT2_IND_BLOCK]);
+      trunc_dindirect (node, length, EXT2_IND_BLOCK +
+		       EXT2_ADDR_PER_BLOCK(sblock),
+		       (u32 *) &node->dn.info.i_data[EXT2_DIND_BLOCK]);
+      trunc_tindirect (node, length);
     }
 
   node->dn_set_mtime = 1;
   node->dn_set_ctime = 1;
-  node->dirty = 1;
+  node->dn_stat_dirty = 1;
+
+  /* Now we can permit delayed copies again. */
+  enable_delayed_copies (np);
+}
+
+/* The user must define this function.  Grow the disk allocated to locked node
+   NP to be at least SIZE bytes, and set NP->allocsize to the actual
+   allocated size.  (If the allocated size is already SIZE bytes, do
+   nothing.)  CRED identifies the user responsible for the call.  */
+error_t
+diskfs_grow (struct node *np, off_t size, struct protid *cred)
+{
+  if (size > np->allocsize)
+    np->allocsize = size;
+  return 0;
 }