From owner-acpi-jp@jp.freebsd.org  Sun Jun  4 19:05:35 2000
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id TAA24992;
	Sun, 4 Jun 2000 19:05:35 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from tasogare.imasy.or.jp (daemon@tasogare.imasy.or.jp [202.227.24.5])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id TAA24987
	for <acpi-jp@jp.freebsd.org>; Sun, 4 Jun 2000 19:05:34 +0900 (JST)
	(envelope-from iwasaki@jp.FreeBSD.org)
Received: from localhost (isdnb33.imasy.or.jp [202.227.24.161])
	by tasogare.imasy.or.jp (8.10.1+3.3W/3.7W-tasogare/smtpfeed 1.04) with ESMTP id e54A5VP39364
	for <acpi-jp@jp.freebsd.org>; Sun, 4 Jun 2000 19:05:31 +0900 (JST)
	(envelope-from iwasaki@jp.FreeBSD.org)
To: acpi-jp@jp.freebsd.org
X-Mailer: Mew version 1.94.1 on Emacs 19.34 / Mule 2.3 (SUETSUMUHANA)
Mime-Version: 1.0
Content-Type: Text/Plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Message-Id: <20000604190531D.iwasaki@jp.FreeBSD.org>
Date: Sun, 04 Jun 2000 19:05:31 +0900
From: Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
X-Dispatcher: imput version 20000228(IM140)
Lines: 517
Reply-To: acpi-jp@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+000315
X-Sequence: acpi-jp 374
Subject: [acpi-jp 374] style fix: aml_memman.[ch]
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: iwasaki@jp.freebsd.org

Index: aml_memman.c
===================================================================
RCS file: /home/cvs/ACPI/sys/i386/acpi/aml/aml_memman.c,v
retrieving revision 1.6
diff -u -r1.6 aml_memman.c
--- aml_memman.c	2000/06/03 14:32:57	1.6
+++ aml_memman.c	2000/06/04 09:37:32
@@ -31,7 +31,6 @@
  */
 
 #include <sys/param.h>
-#include <sys/types.h>
 
 #include <i386/acpi/aml/aml_memman.h>
 
@@ -39,35 +38,50 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#else
+#else /* _KERNEL */
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 MALLOC_DEFINE(M_MEMMAN, "memman", "Generic and Simple Memory Management");
-#endif
+#endif /* !_KERNEL */
 
 unsigned int	memid_unkown = 255;
 
+static int		 manage_block(struct memman *memman, unsigned int id,
+				      void *block, unsigned static_mem,
+				      unsigned entries);
+static int		 blockman_init(struct memman *memman, unsigned int id);
+static void		 memman_flexsize_add_histogram(struct memman *memman,
+						       size_t size,
+						       int tolerance);
+static int		 memman_comp_histogram_size(const void *a,
+						    const void *b);
+static void		 memman_sort_histogram_by_size(struct memman *memman);
+static unsigned int	 memman_guess_memid(struct memman *memman, void *chunk);
+static void		 memman_statistics_fixedsize(struct memman *memman);
+static void		 memman_statistics_flexsize(struct memman *memman);
+
 static int
-manage_block(struct memman *memman, unsigned int id, void *block, unsigned static_mem, unsigned entries)
+manage_block(struct memman *memman, unsigned int id, void *block,
+    unsigned static_mem, unsigned entries)
 {
-	unsigned int		i;
-	size_t			alloc_size;
-	void			*tmp, *realblock;
-	struct memman_blockman	*bmp;
-	struct memman_block	*memblock;
-	struct memman_node	*memnodes;
+	unsigned int	i;
+	size_t	alloc_size;
+	void	*tmp, *realblock;
+	struct	memman_blockman	*bmp;
+	struct	memman_block *memblock;
+	struct	memman_node *memnodes;
 
 	bmp = &memman->blockman[id];
 	alloc_size = MEMMAN_BLOCKNODE_SIZE(entries);
 
 	if (static_mem) {
-		tmp = (void *)block;
-		realblock = (char *)block + alloc_size;
+		tmp = (void *) block;
+		realblock = (char *) block + alloc_size;
 	} else {
 		tmp = MEMMAN_SYSMALLOC(alloc_size);
 		if (!tmp) {
-			return -1;
+			return (-1);
 		}
 		realblock = block;
 
@@ -75,8 +89,8 @@
 		memman->salloc_called++;
 	}
 
-	memblock = (struct memman_block *) tmp;
-	memnodes = (struct memman_node *) ((char *)tmp + sizeof(struct memman_block));
+	memblock = (struct memman_block *)tmp;
+	memnodes = (struct memman_node *)((char *)tmp + sizeof(struct memman_block));
 
 	memblock->block = realblock;
 	memblock->static_mem = static_mem;
@@ -95,46 +109,48 @@
 	}
 	bmp->available = entries;
 
-	return 0;
+	return (0);
 }
 
 static int
 blockman_init(struct memman *memman, unsigned int id)
 {
-	struct memman_blockman	*bmp;
+	int	status;
+	struct	memman_blockman *bmp;
 
 	bmp = &memman->blockman[id];
 	bmp->initialized = 1;
 	LIST_INIT(&bmp->block_list);
 	LIST_INIT(&bmp->free_node_list);
 	LIST_INIT(&bmp->occupied_node_list);
-	return manage_block(memman, id, bmp->initial_block, 1, MEMMAN_INITIAL_SIZE);
+	status = manage_block(memman, id, bmp->initial_block,
+	    1, MEMMAN_INITIAL_SIZE);
+	return (status);
 }
 
 void *
 memman_alloc(struct memman *memman, unsigned int id)
 {
-	size_t			alloc_size;
-	void			*chunk, *block;
-	struct memman_blockman	*bmp;
-	struct memman_node	*memnode;
+	size_t	alloc_size;
+	void	*chunk, *block;
+	struct	memman_blockman *bmp;
+	struct	memman_node *memnode;
 
 	if (memman->max_memid <= id) {
 		printf("memman_alloc: invalid memory type id\n");
-		return NULL;
+		return (NULL);
 	}
-
 	bmp = &memman->blockman[id];
 	if (!bmp->initialized) {
 		if (blockman_init(memman, id)) {
 			goto malloc_fail;
 		}
 	}
-
 	memman->alloc_called++;
 
 	if (bmp->available == 0) {
-		alloc_size = roundup(bmp->size * MEMMAN_INCR_SIZE, ROUNDUP_UNIT);
+		alloc_size = roundup(bmp->size * MEMMAN_INCR_SIZE,
+		    ROUNDUP_UNIT);
 		block = MEMMAN_SYSMALLOC(alloc_size);
 		if (!block) {
 			goto malloc_fail;
@@ -147,7 +163,6 @@
 			goto malloc_fail;
 		}
 	}
-
 	memnode = LIST_FIRST(&bmp->free_node_list);
 	LIST_REMOVE(memnode, links);
 	chunk = memnode->node;
@@ -155,15 +170,16 @@
 	memnode->memblock->available--;
 	bmp->available--;
 
-	return chunk;
+	return (chunk);
 
 malloc_fail:
 	printf("memman_alloc: could not allocate memory\n");
-	return NULL;
+	return (NULL);
 }
 
 static void
-memman_flexsize_add_histogram(struct memman *memman, size_t size, int tolerance)
+memman_flexsize_add_histogram(struct memman *memman, size_t size,
+    int tolerance)
 {
 	int	i;
 	int	gap;
@@ -171,7 +187,6 @@
 	if (size == 0) {
 		return;
 	}
-
 	for (i = 0; i < memman->flex_mem_histogram_ptr; i++) {
 		gap = memman->flex_mem_histogram[i].mem_size - size;
 		if (gap >= (tolerance * -1) && gap <= tolerance) {
@@ -187,7 +202,6 @@
 		memman_flexsize_add_histogram(memman, size, tolerance + 1);
 		return;
 	}
-
 	i = memman->flex_mem_histogram_ptr;
 	memman->flex_mem_histogram[i].mem_size = size;
 	memman->flex_mem_histogram[i].count = 1;
@@ -197,27 +211,29 @@
 static int
 memman_comp_histogram_size(const void *a, const void *b)
 {
-	return ((const struct memman_histogram *)a)->mem_size -
-	       ((const struct memman_histogram *)b)->mem_size;
+	int	delta;
+
+	delta = ((const struct memman_histogram *)a)->mem_size -
+	    ((const struct memman_histogram *)b)->mem_size;
+	return (delta);
 }
 
 static void
 memman_sort_histogram_by_size(struct memman *memman)
 {
 	qsort(memman->flex_mem_histogram, memman->flex_mem_histogram_ptr,
-	      sizeof(struct memman_histogram), memman_comp_histogram_size);
+	    sizeof(struct memman_histogram), memman_comp_histogram_size);
 }
 
 void *
 memman_alloc_flexsize(struct memman *memman, size_t size)
 {
 	void	*mem;
-	struct memman_flexmem_info *info;
+	struct	memman_flexmem_info *info;
 
 	if (size == 0) {
-		return NULL;
+		return (NULL);
 	}
-
 	if ((mem = MEMMAN_SYSMALLOC(size)) != NULL) {	/* XXX */
 
 		info = MEMMAN_SYSMALLOC(sizeof(struct memman_flexmem_info));
@@ -243,24 +259,23 @@
 		if (memman->flex_mem_size_max < size) {
 			memman->flex_mem_size_max = size;
 		}
-		if (memman->flex_peak_mem_usage < 
+		if (memman->flex_peak_mem_usage <
 		    (memman->flex_allocated_mem - memman->flex_reclaimed_mem)) {
-			memman->flex_peak_mem_usage = 
+			memman->flex_peak_mem_usage =
 			    (memman->flex_allocated_mem - memman->flex_reclaimed_mem);
 		}
 		memman_flexsize_add_histogram(memman, size,
 		    memman->flex_mem_histogram_initial_tolerance);
 	}
-
-	return mem;
+	return (mem);
 }
 
 static unsigned int
 memman_guess_memid(struct memman *memman, void *chunk)
 {
-	unsigned int		id;
-	struct memman_blockman	*bmp;
-	struct memman_node	*memnode;
+	unsigned int	id;
+	struct	memman_blockman *bmp;
+	struct	memman_node *memnode;
 
 	for (id = 0; id < memman->max_memid; id++) {
 		bmp = &memman->blockman[id];
@@ -269,43 +284,40 @@
 				printf("memman_free: could not initialized\n");
 			}
 		}
-
 		LIST_FOREACH(memnode, &bmp->occupied_node_list, links) {
 			if (memnode->node == chunk) {
-				return id;	/* got it! */
+				return (id);	/* got it! */
 			}
 		}
 	}
-	return memid_unkown;		/* gave up */
+	return (memid_unkown);	/* gave up */
 }
 
 void
 memman_free(struct memman *memman, unsigned int memid, void *chunk)
 {
-	unsigned int		id = memid;
-	unsigned		found;
-	void			*block;
-	struct memman_blockman	*bmp;
-	struct memman_block	*memblock;
-	struct memman_node	*memnode;
+	unsigned int	id;
+	unsigned	found;
+	void	*block;
+	struct	memman_blockman *bmp;
+	struct	memman_block *memblock;
+	struct	memman_node *memnode;
 
+	id = memid;
 	if (memid == memid_unkown) {
 		id = memman_guess_memid(memman, chunk);
 	}
-	
 	if (memman->max_memid <= id) {
 		printf("memman_free: invalid memory type id\n");
 		MEMMAN_SYSABORT();
 		return;
 	}
-
 	bmp = &memman->blockman[id];
 	if (!bmp->initialized) {
 		if (blockman_init(memman, id)) {
 			printf("memman_free: could not initialized\n");
 		}
 	}
-
 	found = 0;
 	LIST_FOREACH(memnode, &bmp->occupied_node_list, links) {
 		if (memnode->node == chunk) {
@@ -317,7 +329,6 @@
 		printf("memman_free: invalid address\n");
 		return;
 	}
-
 	memman->free_called++;
 
 	LIST_REMOVE(memnode, links);
@@ -349,7 +360,7 @@
 void
 memman_free_flexsize(struct memman *memman, void *chunk)
 {
-	struct memman_flexmem_info *info;
+	struct	memman_flexmem_info *info;
 
 	LIST_FOREACH(info, &memman->flexmem_info_list, links) {
 		if (info->addr == chunk) {
@@ -368,12 +379,12 @@
 void
 memman_freeall(struct memman *memman)
 {
-	int			id;
-	void			*chunk;
-	struct memman_blockman	*bmp;
-	struct memman_node	*memnode;
-	struct memman_block	*memblock;
-	struct memman_flexmem_info *info;
+	int	id;
+	void	*chunk;
+	struct	memman_blockman *bmp;
+	struct	memman_node *memnode;
+	struct	memman_block *memblock;
+	struct	memman_flexmem_info *info;
 
 	for (id = 0; id < memman->max_memid; id++) {
 		bmp = &memman->blockman[id];
@@ -458,10 +469,7 @@
 {
 	if (memman->max_memid <= id) {
 		printf("memman_alloc: invalid memory type id\n");
-		return 0;
+		return (0);
 	}
-
-	return memman->blockman[id].size;
+	return (memman->blockman[id].size);
 }
-
-
Index: aml_memman.h
===================================================================
RCS file: /home/cvs/ACPI/sys/i386/acpi/aml/aml_memman.h,v
retrieving revision 1.6
diff -u -r1.6 aml_memman.h
--- aml_memman.h	2000/06/03 14:32:57	1.6
+++ aml_memman.h	2000/06/04 09:16:13
@@ -26,34 +26,34 @@
  *	$Id: aml_memman.h,v 1.6 2000/06/03 14:32:57 iwasaki Exp $
  */
 
+#ifndef _MEMMAN_H_
+#define _MEMMAN_H_
+
 /*
  * Generic Memory Management
  */
 
-#ifndef _MEMMAN_H_
-#define _MEMMAN_H_
-
 #include <sys/param.h>
 #include <sys/queue.h>
 
 /* memory block */
-struct memman_block {
+struct	memman_block {
 	LIST_ENTRY(memman_block) links;
-	void			*block;
-	unsigned		static_mem;	/* static memory or not */
-	unsigned int		allocated;	/* number of allocated chunks */
-	unsigned int		available;	/* number of available chunks */
-	unsigned int		allocated_mem;	/* block + misc (in bytes) */
+	void		*block;
+	unsigned	static_mem;	/* static memory or not */
+	unsigned int	allocated;	/* number of allocated chunks */
+	unsigned int	available;	/* number of available chunks */
+	unsigned int	allocated_mem;	/* block + misc (in bytes) */
 
 }__attribute__((packed));
 
 LIST_HEAD(memman_block_list, memman_block);
 
 /* memory node in block */
-struct memman_node {
+struct	memman_node {
 	LIST_ENTRY(memman_node)	links;
-	void			*node;
-	struct memman_block	*memblock;
+	void	*node;
+	struct	memman_block *memblock;
 }__attribute__((packed));
 
 LIST_HEAD(memman_node_list, memman_node);
@@ -62,36 +62,36 @@
 extern unsigned int	memid_unkown;
 
 /* memory block manager */
-struct memman_blockman {
+struct	memman_blockman {
 	unsigned int	size;		/* size of chunk */
-	unsigned int	available;	/* total number of available chunks */
+	unsigned	int available;	/* total # of available chunks */
 	void		*initial_block;	/* initial memory storage */
 	unsigned	initialized;	/* initialized or not */
 
-	struct memman_block_list	block_list;
-	struct memman_node_list		free_node_list;
-	struct memman_node_list		occupied_node_list;
+	struct	memman_block_list block_list;
+	struct	memman_node_list free_node_list;
+	struct	memman_node_list occupied_node_list;
 };
 
 /* memory size histogram */
 #define MEMMAN_HISTOGRAM_SIZE	20
-struct memman_histogram {
+struct	memman_histogram {
 	int	mem_size;
 	int	count;
 };
 
 /* flex size memory allocation info */
-struct memman_flexmem_info {
+struct	memman_flexmem_info {
 	LIST_ENTRY(memman_flexmem_info) links;
-	void 	*addr;
+	void	*addr;
 	size_t	mem_size;
 }__attribute__((packed));
 
 LIST_HEAD(memman_flexmem_info_list, memman_flexmem_info);
 
 /* memory manager */
-struct memman {
-	struct memman_blockman	*blockman;
+struct	memman {
+	struct	memman_blockman	*blockman;
 	unsigned int	max_memid;	/* max number of valid memid */
 
 	/* fixed size memory blocks */
@@ -115,15 +115,15 @@
 	size_t		flex_peak_mem_usage;/* memory usage at a peak period */
 
 	/* stuff for more detailed statistical information */
-	struct memman_histogram	*flex_mem_histogram;
+	struct	memman_histogram *flex_mem_histogram;
 	unsigned int	flex_mem_histogram_ptr;
 	int		flex_mem_histogram_initial_tolerance;
 	unsigned	flex_mem_initialized;
-	struct memman_flexmem_info_list	flexmem_info_list;
+	struct	memman_flexmem_info_list flexmem_info_list;
 };
 
 #define MEMMAN_BLOCKNODE_SIZE(entries) sizeof(struct memman_block) + \
-			    sizeof(struct memman_node) * entries
+    sizeof(struct memman_node) * entries
 
 #ifndef ROUNDUP_UNIT
 #define ROUNDUP_UNIT	4
@@ -152,24 +152,20 @@
 
 void	*memman_alloc(struct memman *, unsigned int);
 void	*memman_alloc_flexsize(struct memman *, size_t);
-void	memman_free(struct memman *, unsigned int, void *);
-void	memman_free_flexsize(struct memman *, void *);
-void	memman_freeall(struct memman *);
-void	memman_statistics(struct memman *);
-size_t	memman_memid2size(struct memman *, unsigned int);
+void	 memman_free(struct memman *, unsigned int, void *);
+void	 memman_free_flexsize(struct memman *, void *);
+void	 memman_freeall(struct memman *);
+void	 memman_statistics(struct memman *);
+size_t	 memman_memid2size(struct memman *, unsigned int);
 
 #ifdef _KERNEL
-#define MEMMAN_SYSMALLOC(size)	malloc(size, M_MEMMAN, M_WAITOK) 
+#define MEMMAN_SYSMALLOC(size)	malloc(size, M_MEMMAN, M_WAITOK)
 #define MEMMAN_SYSFREE(ptr)	free(ptr, M_MEMMAN)
-#define MEMMAN_SYSABORT()
- 
-#else 
- 
+#define MEMMAN_SYSABORT()	/* no abort in kernel */
+#else /* !_KERNEL */
 #define MEMMAN_SYSMALLOC(size)	malloc(size)
 #define MEMMAN_SYSFREE(ptr)	free(ptr)
 #define MEMMAN_SYSABORT()	abort()
- 
-#endif  /* _KERNEL */
-
-#endif
+#endif /* _KERNEL */
 
+#endif /* !_MEMMAN_H_ */
