diff options
| -rw-r--r-- | ufs/sizes.c | 719 |
1 files changed, 357 insertions, 362 deletions
diff --git a/ufs/sizes.c b/ufs/sizes.c index 0bc0e547..a349eb40 100644 --- a/ufs/sizes.c +++ b/ufs/sizes.c @@ -30,283 +30,236 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define MAY_CACHE 1 #endif -static void dindir_drop (struct node *); -static void sindir_drop (struct node *, int, int); -static void poke_pages (memory_object_t, vm_offset_t, vm_offset_t); - -/* Truncate node NP to be at most LENGTH bytes. */ -/* The inode must be locked, and we must have the conch. */ -/* This is a pain. Sigh. */ + +/* Implement the diskfs_truncate callback; sse <hurd/diskfs.h> for the + interface description. */ error_t diskfs_truncate (struct node *np, off_t length) { - daddr_t lastblock, olastblock, bn; - off_t osize; - int bsize, idx; - mach_port_t obj; - - osize = np->dn_stat.st_size; - if (length >= osize) + int offset; + daddr_t lastiblock[NIADDR], lastblock, bn; + struct dinode *di = dino (np->dn->number); + int blocksfreed = 0; + + if (length >= np->dn_stat.st_size) return 0; - /* Check to see if this is a kludged symlink. */ + assert (!diskfs_readonly); + + /* First check to see if this is a kludged symlink; if so + this is special. */ if (direct_symlink_extension && S_ISLNK (np->dn_stat.st_mode) - && osize < sblock->fs_maxsymlinklen) + && np->dn_stat.st_size < sblock->fs_maxsymlinklen) { error_t err; - - /* Prune it here */ - err = diskfs_catch_exception (); - if (err) + + if (err = diskfs_catch_exception ()) return err; - - bzero (dinodes[np->dn->number].di_shortlink + length, - osize - length); + bzero (di->di_shortlink + length, np->dn_stat.st_size - length); diskfs_end_catch_exception (); np->dn_stat.st_size = length; - np->dn_set_ctime = 1; - np->dn_set_mtime = 1; + np->dn_set_ctime = np->dn_set_mtime = 1; + return 0; + } + + /* If the file is not being trucated to a block boundary, + the zero the partial bit in the new last block. */ + offset = blkoff (sblock, length); + if (offset) + { + int bsize; /* size of new last block */ + int savesize = np->allocsize; + + np->allocsize = length; /* temporary */ + bsize = blksize (sblock, np, lbkno (sblock, length)); + np->allocsize = savesize; + diskfs_node_rdwr (np, zeroblock, length, bsize - offset, 1, 0, 0); + diskfs_file_update (np, 1); } - /* Calculate block number of last block */ - lastblock = lblkno (sblock, length + sblock->fs_bsize - 1) - 1; - olastblock = lblkno (sblock, osize + sblock->fs_bsize - 1) - 1; - - /* If the prune is not to a block boundary, zero the bit upto the - next block boundary. */ - if (blkoff (sblock, length)) - diskfs_node_rdwr (np, (void *) zeroblock, length, - (blksize (sblock, np, lastblock) - - blkoff (sblock, length)), - 1, 0, 0); - - /* We are going to throw away the block pointers for the blocks - olastblock+1 through lastblock. This will cause the underlying - data to become zeroes, because of the behavior of pager_read_page - (in ufs/pager.c). Consequently, we have to take action to force - the kernel to immediately undertake any delayed copies that - implicitly depend on the data we are flushing. We also have to - prevent any new delayed copies from being undertaken until we - have finished the flush. */ + rwlock_writer_lock (&np->allocptrlock); + + /* Now 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 changing the data implicitly to zeros + and doing it without the kernels immediate knowledge; + this forces us to help out the kernel thusly.) */ if (np->dn->fileinfo) { - pager_change_attributes (np->dn->fileinfo->p, MAY_CACHE, + pager_change_attributes (np->dn->fileinfo->p, MAY_CACHE, MEMORY_OBJECT_COPY_NONE, 1); obj = diskfs_get_filemap (np); - mach_port_insert_right (mach_task_self (), obj, obj, + mach_port_insert_right (mach_task_self (), obj, obj, MACH_MSG_TYPE_MAKE_SEND); - poke_pages (obj, round_page (length), round_page (osize)); + poke_pages (obj, round_page (length), round_page (np->allocsize)); mach_port_deallocate (mach_task_self (), obj); + pager_flush_some (np->fileinfo->p, round_page (length), + 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 + sblock->fs_bsize - 1) - 1; + lastiblock[INDIR_SINGLE] = lastblock - NDADDR; + lastiblock[INDIR_DOUBLE] = lastiblock[INDIR_SINGLE] - NINDIR (sblock); + lastiblock[INDIR_TRIPLE] = (lastiblock[INDIR_DOUBLE] + - NINDIR (sblock) * NINDIR (sblock)); - rwlock_writer_lock (&np->dn->datalock, np->dn); + /* Normalize to -1 indicating that this block will not be needed. */ + for (level = INDIR_TRIPLE; level >= INDIR_SINGLE; level--) + if (lastiblock[level] < 0) + lastiblock[level] = -1; - /* Update the size now. If we crash, fsck can finish freeing the - blocks. */ + /* Update the size on disk; fsck will finish freeing blocks if necessary + should we crash. */ np->dn_stat.st_size = length; - np->dn_stat_dirty = 1; + np->dn_set_mtime = 1; + np->dn_set_ctime = 1; + diskfs_node_update (np, 1); - /* Flush the old data. */ - if (np->dn->fileinfo) - pager_flush_some (np->dn->fileinfo->p, - (lastblock == -1 ? 0 : lastblock) * sblock->fs_bsize, - (olastblock - lastblock) * sblock->fs_bsize, 1); + /* Free the blocks. */ + + err = diskfs_catch_exception (); + if (err) + { + rwlock_writer_unlock (&np->allocptrlock); + return err; + } - /* Drop data blocks mapped by indirect blocks */ - if (olastblock >= NDADDR) + /* Indirect blocks first. */ + for (level = INDIR_TRIPLE; level >= INDIR_SINGLE; level--) + if (lastiblock[level] == -1 && 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--) { - daddr_t first2free; + long bsize; - mutex_lock (&sinmaplock); - if (!np->dn->sinloc) - sin_map (np); + bn = dn->di_db[i]; + if (bn == 0) + continue; - if (lastblock + 1 > NDADDR) - first2free = lastblock + 1; - else - first2free = NDADDR; - - for (idx = first2free; idx <= olastblock; idx ++) - { - assert (idx - NDADDR < np->dn->sinloclen); - if (np->dn->sinloc[idx - NDADDR]) - { - ffs_blkfree (np, np->dn->sinloc[idx - NDADDR], sblock->fs_bsize); - np->dn->sinloc[idx - NDADDR] = 0; - np->dn_stat.st_blocks -= sblock->fs_bsize / DEV_BSIZE; - np->dn_stat_dirty = 1; - } - } + bsize = blksize (sblock, np, i); + ffs_blkfree (sblock, bn, bsize); + blocksfreed += btodb (bsize); - /* Prune the block pointers handled by the sindir pager. This will - free all the indirect blocks and such as necessary. */ - sindir_drop (np, lblkno(sblock, - (first2free - NDADDR) * sizeof (daddr_t)), - lblkno (sblock, (olastblock - NDADDR) * sizeof (daddr_t))); - - if (!np->dn->fileinfo) - sin_unmap (np); - mutex_unlock (&sinmaplock); + dn->di_db[i] = 0; } - /* Prune the blocks mapped directly from the inode */ - for (idx = lastblock + 1; idx < NDADDR; idx++) + /* Finally, check to see if the new last direct block is + changing size; if so release any frags necessary. */ + if (lastblock >= 0 + && dn->di_db[lastblock]) { - bn = dinodes[np->dn->number].di_db[idx]; - if (bn) + bn = dn->di_db[lastblock]; + long oldspace, newspace; + + oldspace = blksize (sblock, np, lastblock); + np->allocsize = length; + newspace = blksize (sblock, np, lastblock); + + assert (newspace); + + if (oldspace - newspace) { - dinodes[np->dn->number].di_db[idx] = 0; - assert (idx <= olastblock); - if (idx == olastblock) - bsize = blksize (sblock, np, idx); - else - bsize = sblock->fs_bsize; - ffs_blkfree (np, bn, bsize); - np->dn_stat.st_blocks -= bsize / DEV_BSIZE; - np->dn_stat_dirty = 1; + bn += numfrags (sblock, newspace); + ffs_blkfree (np, bn, oldspace - newspace); + blocksfreed += btodb (oldspace - newspace) } } + else + np->allocsize = length; - if (lastblock >= 0 && lastblock < NDADDR) - { - /* Look for a change in the size of the last direct block */ - bn = dinodes[np->dn->number].di_db[lastblock]; - if (bn) - { - off_t oldspace, newspace; - - oldspace = blksize (sblock, np, lastblock); - newspace = fragroundup (sblock, blkoff (sblock, length));; - assert (newspace); - if (oldspace - newspace) - { - bn += numfrags (sblock, newspace); - ffs_blkfree (np, bn, oldspace - newspace); - np->dn_stat.st_blocks -= (oldspace - newspace) / DEV_BSIZE; - np->dn_stat_dirty = 1; - } - } - } + diskfs_end_catch_exception (); - if (lastblock < NDADDR) - np->allocsize = fragroundup (sblock, length); - else - np->allocsize = blkroundup (sblock, length); + np->dn_set_ctime = 1; + diskfs_node_update (np, 1); - rwlock_writer_unlock (&np->dn->datalock, np->dn); + rwlock_writer_unlock (&np->allocptrlock); - /* Now we can allow delayed copies again */ + /* 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); - - diskfs_file_update (np, 1); - return 0; -} - -/* Deallocate the double indirect block of the file NP. */ -static void -dindir_drop (struct node *np) -{ - rwlock_writer_lock (&np->dn->dinlock, np->dn); - pager_flush_some (dinpager->p, np->dn->number * sblock->fs_bsize, - sblock->fs_bsize, 1); - - if (dinodes[np->dn->number].di_ib[INDIR_DOUBLE]) - { - ffs_blkfree (np, dinodes[np->dn->number].di_ib[INDIR_DOUBLE], - sblock->fs_bsize); - dinodes[np->dn->number].di_ib[INDIR_DOUBLE] = 0; - np->dn_stat.st_blocks -= sblock->fs_bsize / DEV_BSIZE; - } - - rwlock_writer_unlock (&np->dn->dinlock, np->dn); + return 0; } - -/* Deallocate the single indirect blocks of file IP from - FIRST through LAST inclusive. */ -static void -sindir_drop (struct node *np, - int first, - int last) +/* 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) { - int idx; + int count = 0; + daddr_t *addrs; + int i; + struct indir_dirty *d, *prev, *nxt; - rwlock_writer_lock (&np->dn->sinlock, np->dn); + assert (bno); - pager_flush_some (np->dn->sininfo->p, first * sblock->fs_bsize, - (last - first + 1) * sblock->fs_bsize, 1); + addrs = indir_block (bno); + for (i = 0; i < NINDIR (sblock); i++) + if (addrs[i]) + { + if (level == INDIR_SINGLE) + { + ffs_blkfree (np, addrs[i], sblock->fs_bsize); + count += btodb (sblock->fs_bsize); + } + else + count += free_indir (addrs[i], level - 1); + } - /* Drop indirect blocks found in the double indirect block */ - if (last > 1) + /* Subtlety: this block is no longer necessary; the information + the kernel has cached corresponding to ADDRS is now unimportant. + Consider that if this block is allocated to a file, it will then + be double cached and the kernel might decide to write out + the disk_image version of the block. So we have to flush + the block from the kernel's memory, making sure we do it + synchronously--and BEFORE we attach it to the free list + with ffs_blkfree. */ + pager_flush_some (diskpager->p, fsaddr (bno), sblock->fs_bsize, 1); + + /* We should also take this block off the inode's list of + dirty indirect blocks if it's there. */ + prev = 0; + d = np->dirty; + while (d) { - mutex_lock (&dinmaplock); - if (!np->dn->dinloc) - din_map (np); - for (idx = first; idx = last; idx++) + next = d->next; + if (d->bno == bno) { - assert (idx - 1 < np->dn->dinloclen); - if (np->dn->dinloc[idx - 1]) - { - ffs_blkfree (np, np->dn->dinloc[idx - 1], sblock->fs_bsize); - np->dn->dinloc[idx - 1] = 0; - np->dn_stat.st_blocks -= sblock->fs_bsize / DEV_BSIZE; - } + if (prev) + prev->next = next; + else + np->dirty = next; + free (d); } - - /* If we no longer need the double indirect block, drop it. */ - if (first <= 1) - dindir_drop (np); - - mutex_lock (&dinmaplock); - if (!np->dn->sininfo) - din_unmap (np); - mutex_unlock (&dinmaplock); - } - - /* Drop the block from the inode if we don't need it any more */ - if (first == 0 && dinodes[np->dn->number].di_ib[INDIR_SINGLE]) - { - ffs_blkfree (np, dinodes[np->dn->number].di_ib[INDIR_SINGLE], - sblock->fs_bsize); - dinodes[np->dn->number].di_ib[INDIR_SINGLE] = 0; - np->dn_stat.st_blocks -= sblock->fs_bsize / DEV_BSIZE; - } - rwlock_writer_unlock (&np->dn->sinlock, np->dn); -} - -/* Write something to each page from START to END inclusive of memory - object OBJ, but make sure the data doesns't actually change. */ -static void -poke_pages (memory_object_t obj, - vm_offset_t start, - vm_offset_t end) -{ - vm_address_t addr, poke; - vm_size_t len; - error_t err; - - while (start < end) - { - len = 8 * vm_page_size; - if (len > end - start) - len = end - start; - addr = 0; - err = vm_map (mach_task_self (), &addr, len, 0, 1, obj, start, 0, - VM_PROT_WRITE|VM_PROT_READ, VM_PROT_READ|VM_PROT_WRITE, 0); - if (!err) + else { - for (poke = addr; poke < addr + len; poke += vm_page_size) - *(volatile int *)poke = *(volatile int *)poke; - vm_deallocate (mach_task_self (), addr, len); + prev = d; + next = d->next; } - start += len; + d = next; } + + /* Free designated block */ + ffs_blkfree (np, bno, sblock->fs_bsize); + count += btodb (sblock->fs_bsize); + + return count; } + /* Implement the diskfs_grow callback; see <hurd/diskfs.h> for the interface description. */ @@ -315,197 +268,239 @@ diskfs_grow (struct node *np, off_t end, struct protid *cred) { - daddr_t lbn, pbn, nb; - int osize, size; - int err; - volatile daddr_t dealloc_on_error = 0; - volatile int dealloc_size = 0; - volatile off_t zero_off1 = 0, zero_off2 = 0; - volatile int zero_len1 = 0, zero_len2 = 0; - volatile off_t poke_off1 = 0, poke_off2 = 0; - volatile off_t poke_len1 = 0, poke_len2 = 0; - vm_address_t zerobuf; + daddr_t lbn, olbn; + int size, osize; + error_t err; + struct dinode *di = dino (np->dn->number); + off_t poke_off; + size_t poke_len = 0; + + /* Zero an sblock->fs_bsize piece of disk starting at BNO, + synchronously. We do this on newly allocated indirect + blocks before setting the pointer to them to ensure that an + indirect block absolutely never points to garbage. */ + void zero_disk_block (int bno) + { + bzero (indir_block (bno), sblock->fs_bsize); + sync_disk_blocks (bno, sblock->fs_bsize, 1); + }; + /* Check to see if we don't actually have to do anything */ if (end <= np->allocsize) return 0; - - rwlock_writer_lock (&np->dn->datalock, np->dn); - - /* This deallocation works for the calls to alloc, but not for - realloccg. I'm not sure how to prune the fragment down, especially if - we grew a fragment and then couldn't allocate the piece later. - freeing it all up is a royal pain, largely punted right now... -mib. - */ - if (err = diskfs_catch_exception()) - { - if (dealloc_on_error) - ffs_blkfree (np, dealloc_on_error, dealloc_size); - goto out; - } - /* This is the logical block number of what will be the last block. */ + assert (!diskfs_readonly); + + /* The new last block of the file. */ lbn = lblkno (sblock, end + sblock->fs_bsize - 1) - 1; - /* This is the size to be of that block if it is in the NDADDR array. */ + /* This is the size of that block if it is in the NDADDR array. */ size = fragroundup (sblock, blkoff (sblock, end)); if (size == 0) size = sblock->fs_bsize; - /* if we are writing a new block, then an old one may need to be - reallocated into a full block. */ + rwlock_writer_lock (&np->dn->allocptrlock); - nb = lblkno (sblock, np->allocsize + sblock->fs_bsize - 1) - 1; - if (np->allocsize && nb < NDADDR && nb < lbn) + /* The old last block of the file. */ + olbn = lbkno (sblock, np->allocsize + sblock->fs_bsize - 1) - 1; + + /* This is the size of that block if it is in the NDADDR array. */ + osize = fragroundup (sblock, blkoff (sblock, np->allocsize)); + if (osize == 0) + osize = sblock->fs_bsize; + + /* If this end point is a new block and the file currently + has a fragment, then expand the fragment to a full block. */ + if (np->allocsize && olbn < NDADDR && olbn < lbn) { - osize = blksize (sblock, np, nb); - if (osize < sblock->fs_bsize && osize > 0) + if (osize < sblock->fs_bsize) { - daddr_t old_pbn; + daddr_t olb_pbn, bno; err = ffs_realloccg (np, nb, - ffs_blkpref (np, nb, (int)nb, - dinodes[np->dn->number].di_db), - osize, sblock->fs_bsize, &pbn, cred); + ffs_blkpref (np, lbn, lbn, di->di_db), + osize, sblock->fs_bsize, &bno, cred); if (err) goto out; - np->allocsize = (nb + 1) * sblock->fs_bsize; - old_pbn = dinodes[np->dn->number].di_db[nb]; - dinodes[np->dn->number].di_db[nb] = pbn; - - /* The new disk blocks should be zeros but might not be. - This is a sanity measure that I'm not sure is necessary. */ - zero_off1 = nb * sblock->fs_bsize + osize; - zero_len1 = nb * sblock->fs_bsize + sblock->fs_bsize - zero_off1; + old_pbn = di->di_db + di->di_db[nb] = bno; + np->dn_set_ctime = 1; + + dev_write_sync (fsbtodb (bno) + btodb (osize), + zeroblock, sblock->fs_bsize - osize); if (pbn != old_pbn) { - /* Make sure that the old contents get written out by - poking the pages. */ - poke_off1 = nb * sblock->fs_bsize; - poke_len1 = osize; + /* Make sure the old contents get written out + to the new address by poking the pages. */ + poke_off = nb * sblock->fs_bsize; + poke_len = osize; } } } - - /* allocate this block */ + if (lbn < NDADDR) { - nb = dinodes[np->dn->number].di_db[lbn]; - - if (nb != 0) + daddr_t bno, old_pbn = di->di_db[lbn]; + + if (old_pbn != 0) { - /* consider need to reallocate a fragment. */ - osize = blkoff (sblock, np->allocsize); - if (osize == 0) - osize = sblock->fs_bsize; - if (size > osize) - { - err = ffs_realloccg (np, lbn, - ffs_blkpref (np, lbn, lbn, - dinodes[np->dn->number].di_db), - osize, size, &pbn, cred); - if (err) - goto out; - dinodes[np->dn->number].di_db[lbn] = pbn; - - /* The new disk blocks should be zeros but might not be. - This is a sanity measure that I'm not sure is necessary. */ - zero_off2 = lbn * sblock->fs_bsize + osize; - zero_len2 = lbn * sblock->fs_bsize + size - zero_off2; + /* The last block is already allocated. Therefore we + must be expanding the fragment. Make sure that's really + what we're up to. */ + assert (size > osize); + assert (lbn == olbn); + + err = ffs_realloccg (np, lbn, + ffs_blkpref (np, lbn, lbn, di->di_db), + osize, size, &bno, cred); + if (err) + goto out; + + di->di_db[lbn] = bno; + np->dn_sat_ctime = 1; + + dev_write_sync (fsbtodb (bno) + btodb (osize), + zeroblock, size - osize); - if (pbn != nb) - { - /* Make sure that the old contents get written out by - poking the pages. */ - poke_off2 = lbn * sblock->fs_bsize; - poke_len2 = osize; - } + if (pbn != old_pbn) + { + assert (!poke_len); + + /* Make sure the old contents get written out to + the new address by poking the pages. */ + poke_off = lbn * sblock->fs_bsize; + poke_len = osize; } } else { - err = ffs_alloc (np, lbn, - ffs_blkpref (np, lbn, lbn, - dinodes[np->dn->number].di_db), - size, &pbn, cred); + /* Allocate a new last block. */ + err = ffs_alloc (np, lbn, + ffs_blkpref (np, lbn, lbn, di->di_db), + size, &bno, cred); if (err) goto out; - dealloc_on_error = pbn; - dealloc_size = size; - dinodes[np->dn->number].di_db[lbn] = pbn; + + di->di_db[lbn] = pbn; + np->dn_set_ctime = 1; + + dev_write_sync (fsbtodb (bno), zeroblock, size); } - np->allocsize = fragroundup (sblock, end); } else { - /* Make user the sindir area is mapped at the right size. */ - mutex_lock (&sinmaplock); - if (np->dn->sinloc) - { - sin_remap (np, end); - np->allocsize = blkroundup (sblock, end); - } - else - { - np->allocsize = blkroundup (sblock, end); - sin_map (np); - } + struct iblock_spec indirs[NINDIR + 1]; + int i; + daddr_t *siblock; + + /* Count the number of levels of indirection. */ + err = fetch_indir_spec (np, lbn, indirs); + if (err) + goto out; - lbn -= NDADDR; - assert (lbn < np->dn->sinloclen); - if (!np->dn->sinloc[lbn]) + /* Make sure we didn't miss the NDADDR case + above somehow. */ + assert (indirs[0].offset != -1); + + /* See if we need a triple indirect block; fail if so. */ + assert (indirs[1].offset == -1 || indirs[2].offset == -1); + + /* Check to see if this block is allocated. If it is + that's an error. */ + assert (indirs[0].bno == 0); + + /* We need to set SIBLOCK to the single indirect block + array; see if the single indirect block is allocated. */ + if (indirs[1].bno == 0) { - err = ffs_alloc (np, lbn, ffs_blkpref (np, lbn + NDADDR, lbn, - np->dn->sinloc), - sblock->fs_bsize, &pbn, cred); - if (err) - goto out; - dealloc_on_error = pbn; - dealloc_size = sblock->fs_bsize; - np->dn->sinloc[lbn] = pbn; + /* Allocate it. */ + if (indirs[1].offset == -1) + { + err = ffs_alloc (np, lbn, + ffs_blkpref (np, lbn, INDIR_SINGLE, di->di_ib), + sblock->fs_bsize, &bno, 0); + if (err) + goto out; + zero_disk_block (bno); + indirs[1].bno = di->di_ib[INDIR_SINGLE] = bno; + } + else + { + daddr_t *diblock; + + /* We need to set diblock to the double indirect block + array; see if the double indirect block is allocated. */ + if (indirs[2].bno == 0) + { + /* This assert because triple indirection is not + supported. */ + assert (indirs[2].offset == -1); + err = ffs_alloc (np, lbn + ffs_blkpref (np, lbn, + INDIR_DOUBLE, di->di_ib), + sblock->fs_bsize, &bno, 0); + if (err) + goto out; + zero_disk_block (bno); + indirs[2].bno = di->di_ib[INDIR_DOUBLE] = bno; + } + + diblock = indir_block (indirs[2].bno); + mark_indir_dirty (indirs[2].bno); + + /* Now we can allocate the single indirect block */ + err = ffs_alloc (np, lbn, + ffs_blkpref (np, lbn, + indirs[1].offset, diblock), + sblock->fs_bsize, &bno, 0); + if (err) + goto out; + zero_disk_block (bno); + indirs[1].bno = diblock[indirs[1].offset] = bno; + } } - if (!np->dn->fileinfo) - sin_unmap (np); - mutex_unlock (&sinmaplock); - } + + siblock = indir_block (indirs[1].bno); + mark_indir_dirty (np, indirs[1].bno); - if (np->conch.holder) - ioserver_put_shared_data (np->conch.holder); + /* Now we can allocate the data block. */ + err = ffs_alloc (np, lbn, + ffs_blkpref (np, lbn, indirs[0].offset, siblock), + sblock->fn_bsize, &bno, 0); + if (err) + goto out; + indirs[0].bno = siblock[indirs[0].offset] = bno; + dev_write_sync (fsbtodb (bno), zeroblock, sblock->fs_bsize); + } out: - diskfs_end_catch_exception (); - rwlock_writer_unlock (&np->dn->datalock, np->dn); - - /* Do the pokes and zeros that we requested before; they have to be - done here because we can't cause a page while holding datalock. */ - if (zero_len1 || zero_len2) + if (!err) { - vm_allocate (mach_task_self (), &zerobuf, - zero_len1 > zero_len2 ? zero_len1 : zero_len2, 1); - if (zero_len1) - diskfs_node_rdwr (np, (char *) zerobuf, zero_off1, - zero_len1, 1, cred, 0); - if (zero_len2) - diskfs_node_rdwr (np, (char *) zerobuf, zero_off2, - zero_len2, 1, cred, 0); - vm_deallocate (mach_task_self (), zerobuf, - zero_len1 > zero_len2 ? zero_len1 : zero_len2); + int newallocsize; + if (lbn < NDADDR) + newallocsize = (lbn - 1) * sblock->fs_bsize + size; + else + newallocsize = lbn * sblock->fs_bsize; + assert (newallocsize > np->allocsize); + np->allocsize = newallocsize; } - if (poke_len1 || poke_len2) + + rwlock_writer_unlock (&np->allocptrlock); + + /* If we expanded a fragment, then POKE_LEN will be set. + We need to poke the requested amount of the memory object + so that the kernel will write out the data to the new location + at a suitable time. */ + if (poke_len) { - mach_port_t obj; obj = diskfs_get_filemap (np); - mach_port_insert_right (mach_task_self (), obj, obj, + mach_port_insert_reght (mach_task_self (), obj, obj, MACH_MSG_TYPE_MAKE_SEND); - if (poke_len1) - poke_pages (obj, trunc_page (poke_off1), - round_page (poke_off1 + poke_len1)); - if (poke_len2) - poke_pages (obj, trunc_page (poke_off2), - round_page (poke_off2 + poke_len2)); + poke_pages (obj, trunc_page (poke_off), + round_page (poke_off + poke_len)); mach_port_deallocate (mach_task_self (), obj); } - diskfs_file_update (np, 0); - return err; -} +} + |