From d913b97b8b118e0dd081c1d780bdf7cf67429575 Mon Sep 17 00:00:00 2001 From: "Michael I. Bushnell" Date: Fri, 3 May 1996 17:49:14 +0000 Subject: (block_extended): Rewrite code that moves pages to be more efficient, and not deadlock too, using unlocked pagein permission feature (read "hack"). Return value now indicates whether we expect a sync. (diskfs_grow): If a call to block_extended returns nonzero, then sync the file before returning. --- ufs/sizes.c | 92 ++++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 55 insertions(+), 37 deletions(-) (limited to 'ufs') diff --git a/ufs/sizes.c b/ufs/sizes.c index 4237ea56..ad14f5cc 100644 --- a/ufs/sizes.c +++ b/ufs/sizes.c @@ -373,8 +373,9 @@ offer_data (struct node *np, /* Logical block LBN of node NP has been extended with ffs_realloccg. It used to be allocated at OLD_PBN and is now at NEW_PBN. The old size was OLD_SIZE; it is now NEW_SIZE bytes long. Arrange for the data - on disk to be kept consistent, and free the old block if it has moved. */ -void + on disk to be kept consistent, and free the old block if it has moved. + Return one iff we've actually moved data around on disk. */ +int block_extended (struct node *np, daddr_t lbn, daddr_t old_pbn, @@ -393,42 +394,54 @@ block_extended (struct node *np, if (old_pbn != new_pbn) { - /* Fetch the old data for the part that has moved and offer it - to the kernel, to make sure it's paged in before - we deallocate the old block. */ - for (off = 0; off < round_page (old_size); off += vm_page_size) - { - - /* There's *got* to be a better way to do this... */ - - /* Force it out to disk */ - assert (np->dn->fileinfo); - pager_sync_some (np->dn->fileinfo->p, lbn * sblock->fs_bsize + off, - vm_page_size, 1); - - /* Read it back in */ - diskfs_device_read_sync (fsbtodb (sblock, old_pbn) + off / DEV_BSIZE, - (void *) &buf, vm_page_size); - /* If this page is the last one, then zero the excess first */ - if (off + vm_page_size > old_size) - bzero ((void *)(buf + old_size - off), - vm_page_size - (old_size - off)); - - /* And make sure it's in core. */ - offer_data (np, lbn * sblock->fs_bsize + off, vm_page_size, buf); - - /* And now, make sure it's on disk. (Why? Because a previous - write of this file, maybe even one from before we started - running may have been fsynced. We can't cause data already - on disk to be lossy at any time in the future while we move it. */ - pager_sync_some (np->dn->fileinfo->p, lbn * sblock->fs_bsize + off, - vm_page_size, 1); - } + vm_object_t mapobj; + error_t err; + vm_address_t mapaddr; + volatile int *pokeaddr; + + /* Map in this part of the file */ + mapobj = diskfs_get_filemap (np, VM_PROT_WRITE | VM_PROT_READ); + err = vm_map (mach_task_self (), &mapaddr, round_page (old_size), 0, 1, + mapobj, lbn * sblock->fs_bsize, 0, + VM_PROT_READ|VM_PROT_WRITE, VM_PROT_READ|VM_PROT_WRITE, 0); + assert_perror (err); - /* And deallocate the old block */ + /* Allow these pageins to occur even though we're holding the lock */ + spin_lock (&unlocked_pagein_lock); + np->dn->fileinfo->allow_unlocked_pagein = lbn * sblock->fs_bsize; + np->dn->fileinfo->unlocked_pagein_length = round_page (old_size); + spin_unlock (&unlocked_pagein_lock); + + /* Make sure all waiting pageins see this change. */ + mutex_lock (&np->allocptrlock->master); + condition_broadcast (&np->allocptrlock->wakeup); + mutex_unlock (&np->allocptrlock->master); + + /* Force the pages in core and make sure they are dirty */ + for (pokeaddr = (char *)mapaddr; + pokeaddr < mapaddr + round_page (old_size); + pokeaddr += vm_page_size / sizeof (*pokeaddr)) + *pokeaddr = *pokeaddr; + + /* Turn off the special pagein permission */ + spin_lock (&unlocked_pagein_lock); + np->dn->fileinfo->allow_unlocked_pagein = 0; + np->dn->fileinfo->unlocked_pagein_length = 0; + spin_unlock (&unlocked_pagein_lock); + + /* Undo mapping */ + mach_port_deallocate (mach_task_self (), mapobj); + vm_deallocate (mach_task_self (), mapaddr, round_page (old_size); + + /* Now it's OK to free the old block */ ffs_blkfree (np, old_pbn, old_size); + + /* Tell caller that we've moved data */ + return 1; } -} + else + return 0; +} /* Implement the diskfs_grow callback; see for the @@ -443,6 +456,7 @@ diskfs_grow (struct node *np, error_t err; struct dinode *di = dino (np->dn->number); mach_port_t pagerpt; + int needsync = 0; /* Zero an sblock->fs_bsize piece of disk starting at BNO, synchronously. We do this on newly allocated indirect @@ -496,7 +510,8 @@ diskfs_grow (struct node *np, old_pbn = read_disk_entry (di->di_db[olbn]); - block_extended (np, olbn, old_pbn, bno, osize, sblock->fs_bsize); + need_sync = block_extended (np, olbn, old_pbn, bno, + osize, sblock->fs_bsize); write_disk_entry (di->di_db[olbn], bno); record_poke (di, sizeof (struct dinode)); @@ -522,7 +537,7 @@ diskfs_grow (struct node *np, if (err) goto out; - block_extended (np, lbn, old_pbn, bno, osize, size); + need_sync = block_extended (np, lbn, old_pbn, bno, osize, size); write_disk_entry (di->di_db[lbn], bno); record_poke (di, sizeof (struct dinode)); @@ -653,6 +668,9 @@ diskfs_grow (struct node *np, rwlock_writer_unlock (&np->dn->allocptrlock); + if (need_sync) + diskfs_file_update (np, 1); + return err; } -- cgit v1.2.3