Mechanical whitespace cleanup.

1 files changed, 41 insertions, 41 deletions

diff --git a/sys/vm/uma_core.c b/sys/vm/uma_core.c
index b1d0008..85327b0 100644
--- a/sys/vm/uma_core.c
+++ b/sys/vm/uma_core.c
@@ -30,7 +30,7 @@
  * This allocator is intended to replace the multitude of similar object caches
  * in the standard FreeBSD kernel.  The intent is to be flexible as well as
  * effecient.  A primary design goal is to return unused memory to the rest of
- * the system.  This will make the system as a whole more flexible due to the 
+ * the system.  This will make the system as a whole more flexible due to the
  * ability to move memory to subsystems which most need it instead of leaving
  * pools of reserved memory unused.
  *
@@ -84,7 +84,7 @@ __FBSDID("$FreeBSD$");
 #include <machine/vmparam.h>
 
 /*
- * This is the zone from which all zones are spawned.  The idea is that even 
+ * This is the zone from which all zones are spawned.  The idea is that even
  * the zone heads are allocated from the allocator, so we use the bss section
  * to bootstrap us.
  */
@@ -108,7 +108,7 @@ static MALLOC_DEFINE(M_UMAHASH, "UMAHash", "UMA Hash Buckets");
 static int bucketdisable = 1;
 
 /* Linked list of all zones in the system */
-static LIST_HEAD(,uma_zone) uma_zones = LIST_HEAD_INITIALIZER(&uma_zones); 
+static LIST_HEAD(,uma_zone) uma_zones = LIST_HEAD_INITIALIZER(&uma_zones);
 
 /* This mutex protects the zone list */
 static struct mtx uma_mtx;
@@ -237,7 +237,7 @@ bucket_init(void)
 		size = roundup(sizeof(struct uma_bucket), sizeof(void *));
 		size += sizeof(void *) * ubz->ubz_entries;
 		ubz->ubz_zone = uma_zcreate(ubz->ubz_name, size,
-	    	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZFLAG_INTERNAL);
+		    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZFLAG_INTERNAL);
 		for (; i <= ubz->ubz_entries; i += (1 << BUCKET_SHIFT))
 			bucket_size[i >> BUCKET_SHIFT] = j;
 	}
@@ -300,7 +300,7 @@ bucket_zone_drain(void)
  *
  * Arguments:
  *	arg   Unused
- * 
+ *
  * Returns:
  *	Nothing
  */
@@ -345,7 +345,7 @@ zone_timeout(uma_zone_t zone)
 		for (cpu = 0; cpu <= mp_maxid; cpu++) {
 			if (CPU_ABSENT(cpu))
 				continue;
-			CPU_LOCK(cpu); 
+			CPU_LOCK(cpu);
 			cache = &zone->uz_cpu[cpu];
 			/* Add them up, and reset */
 			alloc += cache->uc_allocs;
@@ -360,7 +360,7 @@ zone_timeout(uma_zone_t zone)
 
 	/*
 	 * Expand the zone hash table.
-	 * 
+	 *
 	 * This is done if the number of slabs is larger than the hash size.
 	 * What I'm trying to do here is completely reduce collisions.  This
 	 * may be a little aggressive.  Should I allow for two collisions max?
@@ -373,7 +373,7 @@ zone_timeout(uma_zone_t zone)
 		int ret;
 
 		/*
-		 * This is so involved because allocating and freeing 
+		 * This is so involved because allocating and freeing
 		 * while the zone lock is held will lead to deadlock.
 		 * I have to do everything in stages and check for
 		 * races.
@@ -442,11 +442,11 @@ hash_alloc(struct uma_hash *hash)
  * path, otherwise, we can recurse on the vm while allocating pages.
  *
  * Arguments:
- *	oldhash  The hash you want to expand 
+ *	oldhash  The hash you want to expand
  *	newhash  The hash structure for the new table
  *
  * Returns:
- * 	Nothing
+ *	Nothing
  *
  * Discussion:
  */
@@ -538,7 +538,7 @@ bucket_drain(uma_zone_t zone, uma_bucket_t bucket)
 		KASSERT(item != NULL,
 		    ("bucket_drain: botched ptr, item is NULL"));
 #endif
-		/* 
+		/*
 		 * This is extremely inefficient.  The slab pointer was passed
 		 * to uma_zfree_arg, but we lost it because the buckets don't
 		 * hold them.  This will go away when free() gets a size passed
@@ -712,7 +712,7 @@ finished:
  *	The slab that was allocated or NULL if there is no memory and the
  *	caller specified M_NOWAIT.
  */
-static uma_slab_t 
+static uma_slab_t
 slab_zalloc(uma_zone_t zone, int wait)
 {
 	uma_slab_t slab;	/* Starting slab */
@@ -830,7 +830,7 @@ startup_alloc(uma_zone_t zone, int bytes, u_int8_t *pflag, int wait)
  *	wait  Shall we wait?
  *
  * Returns:
- *	A pointer to the alloced memory or possibly 
+ *	A pointer to the alloced memory or possibly
  *	NULL if M_NOWAIT is set.
  */
 static void *
@@ -840,7 +840,7 @@ page_alloc(uma_zone_t zone, int bytes, u_int8_t *pflag, int wait)
 
 	*pflag = UMA_SLAB_KMEM;
 	p = (void *) kmem_malloc(kmem_map, bytes, wait);
-  
+
 	return (p);
 }
 
@@ -853,7 +853,7 @@ page_alloc(uma_zone_t zone, int bytes, u_int8_t *pflag, int wait)
  *	wait   Shall we wait?
  *
  * Returns:
- *	A pointer to the alloced memory or possibly 
+ *	A pointer to the alloced memory or possibly
  *	NULL if M_NOWAIT is set.
  */
 static void *
@@ -867,7 +867,7 @@ obj_alloc(uma_zone_t zone, int bytes, u_int8_t *flags, int wait)
 	object = zone->uz_obj;
 	retkva = 0;
 
-	/* 
+	/*
 	 * This looks a little weird since we're getting one page at a time.
 	 */
 	VM_OBJECT_LOCK(object);
@@ -907,7 +907,7 @@ done:
 
 /*
  * Frees a number of pages to the system
- * 
+ *
  * Arguments:
  *	mem   A pointer to the memory to be freed
  *	size  The size of the memory being freed
@@ -996,7 +996,7 @@ zone_small_init(uma_zone_t zone)
 }
 
 /*
- * Finish creating a large (> UMA_SLAB_SIZE) uma zone.  Just give in and do 
+ * Finish creating a large (> UMA_SLAB_SIZE) uma zone.  Just give in and do
  * OFFPAGE for now.  When I can allow for more dynamic slab sizes this will be
  * more complicated.
  *
@@ -1008,7 +1008,7 @@ zone_small_init(uma_zone_t zone)
  */
 static void
 zone_large_init(uma_zone_t zone)
-{	
+{
 	int pages;
 
 	KASSERT((zone->uz_flags & UMA_ZFLAG_CACHEONLY) == 0,
@@ -1030,7 +1030,7 @@ zone_large_init(uma_zone_t zone)
 	zone->uz_rsize = zone->uz_size;
 }
 
-/* 
+/*
  * Zone header ctor.  This initializes all fields, locks, etc.  And inserts
  * the zone onto the global zone list.
  *
@@ -1095,7 +1095,7 @@ zone_ctor(void *mem, int size, void *udata)
 
 	/*
 	 * If we're putting the slab header in the actual page we need to
-	 * figure out where in each page it goes.  This calculates a right 
+	 * figure out where in each page it goes.  This calculates a right
 	 * justified offset into the memory on an ALIGN_PTR boundary.
 	 */
 	if (!(zone->uz_flags & UMA_ZONE_OFFPAGE)) {
@@ -1146,7 +1146,7 @@ zone_ctor(void *mem, int size, void *udata)
 		zone->uz_count = BUCKET_MAX;
 }
 
-/* 
+/*
  * Zone header dtor.  This frees all data, destroys locks, frees the hash table
  * and removes the zone from the global list.
  *
@@ -1188,11 +1188,11 @@ zone_dtor(void *arg, int size, void *udata)
  * Arguments:
  *	zfunc  A pointer to a function which accepts a zone
  *		as an argument.
- * 
+ *
  * Returns:
  *	Nothing
  */
-static void 
+static void
 zone_foreach(void (*zfunc)(uma_zone_t))
 {
 	uma_zone_t zone;
@@ -1309,10 +1309,10 @@ uma_startup3(void)
 }
 
 /* See uma.h */
-uma_zone_t  
+uma_zone_t
 uma_zcreate(char *name, size_t size, uma_ctor ctor, uma_dtor dtor,
 		uma_init uminit, uma_fini fini, int align, u_int16_t flags)
-		     
+
 {
 	struct uma_zctor_args args;
 
@@ -1445,7 +1445,7 @@ zalloc_start:
 		cache->uc_allocbucket = bucket;
 		ZONE_UNLOCK(zone);
 		goto zalloc_start;
-	} 
+	}
 	/* We are no longer associated with this cpu!!! */
 	CPU_UNLOCK(cpu);
 
@@ -1476,15 +1476,15 @@ uma_zone_slab(uma_zone_t zone, int flags)
 {
 	uma_slab_t slab;
 
-	/* 
+	/*
 	 * This is to prevent us from recursively trying to allocate
 	 * buckets.  The problem is that if an allocation forces us to
 	 * grab a new bucket we will call page_alloc, which will go off
 	 * and cause the vm to allocate vm_map_entries.  If we need new
-	 * buckets there too we will recurse in kmem_alloc and bad 
+	 * buckets there too we will recurse in kmem_alloc and bad
 	 * things happen.  So instead we return a NULL bucket, and make
 	 * the code that allocates buckets smart enough to deal with it
-	 */ 
+	 */
 	if (zone->uz_flags & UMA_ZFLAG_INTERNAL && zone->uz_recurse != 0)
 		return (NULL);
 
@@ -1520,7 +1520,7 @@ uma_zone_slab(uma_zone_t zone, int flags)
 
 			if (flags & M_NOWAIT)
 				break;
-			else 
+			else
 				msleep(zone, &zone->uz_lock, PVM,
 				    "zonelimit", 0);
 			continue;
@@ -1528,7 +1528,7 @@ uma_zone_slab(uma_zone_t zone, int flags)
 		zone->uz_recurse++;
 		slab = slab_zalloc(zone, flags);
 		zone->uz_recurse--;
-		/* 
+		/*
 		 * If we got a slab here it's safe to mark it partially used
 		 * and return.  We assume that the caller is going to remove
 		 * at least one item.
@@ -1537,7 +1537,7 @@ uma_zone_slab(uma_zone_t zone, int flags)
 			LIST_INSERT_HEAD(&zone->uz_part_slab, slab, us_link);
 			return (slab);
 		}
-		/* 
+		/*
 		 * We might not have been able to get a slab but another cpu
 		 * could have while we were unlocked.  Check again before we
 		 * fail.
@@ -1553,7 +1553,7 @@ uma_slab_alloc(uma_zone_t zone, uma_slab_t slab)
 {
 	void *item;
 	u_int8_t freei;
-	
+
 	freei = slab->us_firstfree;
 	slab->us_firstfree = slab->us_freelist[freei];
 	item = slab->us_data + (zone->uz_rsize * freei);
@@ -1748,7 +1748,7 @@ zfree_start:
 			 * We have run out of space in our freebucket.
 			 * See if we can switch with our alloc bucket.
 			 */
-			if (cache->uc_allocbucket->ub_cnt < 
+			if (cache->uc_allocbucket->ub_cnt <
 			    cache->uc_freebucket->ub_cnt) {
 				bucket = cache->uc_freebucket;
 				cache->uc_freebucket = cache->uc_allocbucket;
@@ -1756,7 +1756,7 @@ zfree_start:
 				goto zfree_start;
 			}
 		}
-	} 
+	}
 	/*
 	 * We can get here for two reasons:
 	 *
@@ -1878,7 +1878,7 @@ uma_zfree_internal(uma_zone_t zone, void *item, void *udata, int skip)
 		LIST_INSERT_HEAD(&zone->uz_part_slab, slab, us_link);
 	}
 
-	/* Slab management stuff */	
+	/* Slab management stuff */
 	freei = ((unsigned long)item - (unsigned long)slab->us_data)
 		/ zone->uz_rsize;
 
@@ -1912,7 +1912,7 @@ uma_zone_set_max(uma_zone_t zone, int nitems)
 	ZONE_LOCK(zone);
 	if (zone->uz_ppera > 1)
 		zone->uz_maxpages = nitems * zone->uz_ppera;
-	else 
+	else
 		zone->uz_maxpages = nitems / zone->uz_ipers;
 
 	if (zone->uz_maxpages * zone->uz_ipers < nitems)
@@ -2039,7 +2039,7 @@ void
 uma_large_free(uma_slab_t slab)
 {
 	vsetobj((vm_offset_t)slab->us_data, kmem_object);
-	/* 
+	/*
 	 * XXX: We get a lock order reversal if we don't have Giant:
 	 * vm_map_remove (locks system map) -> vm_map_delete ->
 	 *    vm_map_entry_unwire -> vm_fault_unwire -> mtx_lock(&Giant)
@@ -2070,7 +2070,7 @@ slab_print(uma_slab_t slab)
 static void
 cache_print(uma_cache_t cache)
 {
-	printf("alloc: %p(%d), free: %p(%d)\n", 
+	printf("alloc: %p(%d), free: %p(%d)\n",
 		cache->uc_allocbucket,
 		cache->uc_allocbucket?cache->uc_allocbucket->ub_cnt:0,
 		cache->uc_freebucket,
@@ -2107,7 +2107,7 @@ uma_print_zone(uma_zone_t zone)
 }
 
 /*
- * Sysctl handler for vm.zone 
+ * Sysctl handler for vm.zone
  *
  * stolen from vm_zone.c
  */