i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Removed some unused headers.

Browse Source 
* Removed unused pools implementation.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17961 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2006-06-29 15:24:40 +00:00
parent 4e26bc08b8
commit 13e6b02018
5 changed files with 0 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/kernel/cache.h
-50
View File
@@ -1,50 +0,0 @@
/*
Copyright 1999-2001, Be Incorporated. All Rights Reserved.
This file may be used under the terms of the Be Sample Code License.
*/
#ifndef _CACHE_H_
#define _CACHE_H_
#include <OS.h>
#define ALLOW_WRITES 1
#define NO_WRITES 0
#ifdef __cplusplus
extern "C" {
#endif
extern int init_block_cache(int max_blocks, int flags);
extern void shutdown_block_cache(void);
extern void force_cache_flush(int dev, int prefer_log_blocks);
extern int flush_blocks(int dev, off_t bnum, int nblocks);
extern int flush_device(int dev, int warn_locked);
extern int init_cache_for_device(int fd, off_t max_blocks);
extern int remove_cached_device_blocks(int dev, int allow_write);
extern void *get_block(int dev, off_t bnum, int bsize);
extern void *get_empty_block(int dev, off_t bnum, int bsize);
extern int release_block(int dev, off_t bnum);
extern int mark_blocks_dirty(int dev, off_t bnum, int nblocks);
extern int cached_read(int dev, off_t bnum, void *data, off_t num_blocks, int bsize);
extern int cached_write(int dev, off_t bnum, const void *data,
off_t num_blocks, int bsize);
extern int cached_write_locked(int dev, off_t bnum, const void *data,
off_t num_blocks, int bsize);
extern int set_blocks_info(int dev, off_t *blocks, int nblocks,
void (*func)(off_t bnum, size_t nblocks, void *arg),
void *arg);
extern size_t read_phys_blocks(int fd, off_t bnum, void *data, uint num_blocks, int bsize);
extern size_t write_phys_blocks(int fd, off_t bnum, void *data, uint num_blocks, int bsize);
#ifdef __cplusplus
}
#endif
#endif /* _CACHE_H_ */
headers/private/kernel/defines.h
-11
View File
@@ -1,11 +0,0 @@
/*
** Copyright 2001, Travis Geiselbrecht. All rights reserved.
** Distributed under the terms of the NewOS License.
*/
#ifndef _SYS_DEFINES_H
#define _SYS_DEFINES_H
#define SYS_THREAD_ARG_LENGTH_MAX 255
#define SYS_THREAD_STRING_LENGTH_MAX 2048
#endif /* _SYS_DEFINES_H */
headers/private/kernel/faults_priv.h
-23
View File
@@ -1,23 +0,0 @@
/*
** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
** Distributed under the terms of the NewOS License.
*/
#ifndef _KERNEL_FAULTS_PRIV_H
#define _KERNEL_FAULTS_PRIV_H
int general_protection_fault(int errorcode);
enum fpu_faults {
FPU_FAULT_CODE_UNKNOWN = 0,
FPU_FAULT_CODE_DIVBYZERO,
FPU_FAULT_CODE_INVALID_OP,
FPU_FAULT_CODE_OVERFLOW,
FPU_FAULT_CODE_UNDERFLOW,
FPU_FAULT_CODE_INEXACT
};
int fpu_fault(int fpu_fault);
int fpu_disable_fault(void);
#endif
headers/private/kernel/pools.h
-56
View File
@@ -1,56 +0,0 @@
/* pools.h
* simple fixed size block allocator
*/
#ifndef _KERNEL_POOLS_H
#define _KERNEL_POOLS_H
#include <lock.h>
typedef struct pool_ctl pool_ctl;
struct pool_mem {
struct pool_mem *next;
region_id aid;
char *base_addr;
size_t mem_size;
char *ptr;
size_t avail;
benaphore lock;
};
#define FREE_MAGIC 'BORK'
struct free_blk {
uint32 magic;
struct free_blk *next;
uint32 magic_check;
};
#define POOL_USES_BENAPHORES 0
#define POOL_DEBUG_NAME_SZ 32
struct pool_ctl {
struct pool_mem *list;
struct free_blk *freelist;
size_t alloc_size;
size_t block_size;
#if POOL_USES_BENAPHORES
benaphore lock;
#else
rw_lock lock;
#endif
int debug : 1;
char name[POOL_DEBUG_NAME_SZ];
};
int32 pool_init(pool_ctl **p, size_t sz);
void *pool_get(pool_ctl *p);
void pool_put(pool_ctl *p, void *ptr);
void pool_destroy(pool_ctl *p);
void pool_debug(struct pool_ctl *p, char *name);
void pool_debug_walk(pool_ctl *p);
#endif /* _KERNEL_POOLS_H */
src/system/kernel/util/pools.c
-329
View File
@@ -1,329 +0,0 @@
/* pools.c */
/* XXX - add documentation to this file! */
#include <kernel.h>
#include <OS.h>
#include <KernelExport.h>
#include <pools.h>
#include <vm.h>
#include <malloc.h>
#include <atomic.h>
#include <ktypes.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <debug.h>
#include <pools.h>
#define POOL_ALLOC_SZ 4 * 1024
#define ROUND_TO_PAGE_SIZE(x) (((x) + (POOL_ALLOC_SZ) - 1) & ~((POOL_ALLOC_SZ) - 1))
#ifdef WALK_POOL_LIST
void
walk_pool_list(struct pool_ctl *p)
{
struct pool_mem *pb = p->list;
dprintf("Pool: %p\n", p);
dprintf(" -> list = %p\n", pb);
while (pb) {
dprintf(" -> mem_block %p, %p\n", pb, pb->next);
pb = pb->next;
}
}
#endif
void
pool_debug_walk(struct pool_ctl *p)
{
struct free_blk *ptr;
int i = 1;
dprintf("%ld byte blocks allocated, but now free:\n\n", p->alloc_size);
#if POOL_USES_BENAPHORES
ACQUIRE_BENAPHORE(p->lock);
#else
ACQUIRE_READ_LOCK(p->lock);
#endif
ptr = p->freelist;
while (ptr) {
ASSERT(ptr->magic == FREE_MAGIC);
ASSERT(FREE_MAGIC + (uint32)ptr->next == ptr->magic_check);
dprintf(" %02d: %p\n", i++, ptr);
ptr = ptr->next;
}
#if POOL_USES_BENAPHORES
RELEASE_BENAPHORE(p->lock);
#else
RELEASE_READ_LOCK(p->lock);
#endif
}
void
pool_debug(struct pool_ctl *p, char *name)
{
p->debug = 1;
strlcpy(p->name, name, POOL_DEBUG_NAME_SZ);
}
static struct pool_mem *
get_mem_block(struct pool_ctl *pool)
{
struct pool_mem *block;
block = (struct pool_mem *)malloc(sizeof(struct pool_mem));
if (block == NULL)
return NULL;
memset(block, 0, sizeof(*block));
// ToDo: B_CONTIGUOUS for what???
block->aid = create_area("some pool block", (void **)&block->base_addr,
B_ANY_KERNEL_ADDRESS, pool->block_size, B_CONTIGUOUS,
B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
if (block->aid < 0) {
free(block);
return NULL;
}
block->mem_size = block->avail = pool->block_size;
block->ptr = block->base_addr;
INIT_BENAPHORE(block->lock, "pool_mem_lock");
if (CHECK_BENAPHORE(block->lock) >= 0) {
#if POOL_USES_BENAPHORES
ACQUIRE_BENAPHORE(pool->lock);
#else
ACQUIRE_WRITE_LOCK(pool->lock);
#endif
// insert block at the beginning of the pools
block->next = pool->list;
pool->list = block;
#ifdef WALK_POOL_LIST
walk_pool_list(pool);
#endif
#if POOL_USES_BENAPHORES
RELEASE_BENAPHORE(pool->lock);
#else
RELEASE_WRITE_LOCK(pool->lock);
#endif
return block;
}
UNINIT_BENAPHORE(block->lock);
delete_area(block->aid);
free(block);
return NULL;
}
int32
pool_init(struct pool_ctl **_newPool, size_t size)
{
struct pool_ctl *pool = NULL;
/* if the init failes, the new pool will be set to NULL */
*_newPool = NULL;
/* minimum block size is sizeof the free_blk structure */
if (size < sizeof(struct free_blk))
size = sizeof(struct free_blk);
pool = (struct pool_ctl *)malloc(sizeof(struct pool_ctl));
if (pool == NULL)
return ENOMEM;
memset(pool, 0, sizeof(*pool));
#if POOL_USES_BENAPHORES
INIT_BENAPHORE(pool->lock, "pool_lock");
if (CHECK_BENAPHORE(pool->lock) < 0) {
free(pool);
return ENOLCK;
}
#else
INIT_RW_LOCK(pool->lock, "pool_lock");
if (CHECK_RW_LOCK(pool->lock) < 0) {
free(pool);
return ENOLCK;
}
#endif
// 4 puddles will always fit in one pool
pool->block_size = ROUND_TO_PAGE_SIZE(size * 8);
pool->alloc_size = size;
pool->list = NULL;
pool->freelist = NULL;
/* now add a first block */
get_mem_block(pool);
if (!pool->list) {
#if POOL_USES_BENAPHORES
UNINIT_BENAPHORE(pool->lock);
#else
UNINIT_RW_LOCK(pool->lock);
#endif
free(pool);
return ENOMEM;
}
*_newPool = pool;
return 0;
}
void *
pool_get(struct pool_ctl *p)
{
/* ok, so now we look for a suitable block... */
struct pool_mem *mp = p->list;
struct free_blk *rv = NULL;
#if POOL_USES_BENAPHORES
ACQUIRE_BENAPHORE(p->lock);
#else
ACQUIRE_WRITE_LOCK(p->lock);
#endif
if (p->freelist) {
/* woohoo, just grab a block! */
rv = p->freelist;
ASSERT(rv->magic == FREE_MAGIC);
ASSERT(FREE_MAGIC + (uint32)rv->next == rv->magic_check);
if (p->debug)
dprintf("%s: allocating %p, setting freelist to %p\n",
p->name, p->freelist, rv->next);
p->freelist = rv->next;
#if POOL_USES_BENAPHORES
RELEASE_BENAPHORE(p->lock);
#else
RELEASE_WRITE_LOCK(p->lock);
#endif
memset(rv, 0, p->alloc_size);
return rv;
}
#if !POOL_USES_BENAPHORES
RELEASE_WRITE_LOCK(p->lock);
ACQUIRE_READ_LOCK(p->lock);
#endif
/* no free blocks, try to allocate of the top of the memory blocks
** we must hold the global pool lock while iterating through the list!
*/
do {
ACQUIRE_BENAPHORE(mp->lock);
if (mp->avail >= p->alloc_size) {
rv = (struct free_blk *)mp->ptr;
mp->ptr += p->alloc_size;
mp->avail -= p->alloc_size;
RELEASE_BENAPHORE(mp->lock);
break;
}
RELEASE_BENAPHORE(mp->lock);
} while ((mp = mp->next) != NULL);
#if POOL_USES_BENAPHORES
RELEASE_BENAPHORE(p->lock);
#else
RELEASE_READ_LOCK(p->lock);
#endif
if (rv) {
memset(rv, 0, p->alloc_size);
return rv;
}
mp = get_mem_block(p);
if (mp == NULL)
return NULL;
ACQUIRE_BENAPHORE(mp->lock);
if (mp->avail >= p->alloc_size) {
rv = (struct free_blk *)mp->ptr;
mp->ptr += p->alloc_size;
mp->avail -= p->alloc_size;
}
RELEASE_BENAPHORE(mp->lock);
memset(rv, 0, p->alloc_size);
return rv;
}
void
pool_put(struct pool_ctl *p, void *ptr)
{
#if POOL_USES_BENAPHORES
ACQUIRE_BENAPHORE(p->lock);
#else
ACQUIRE_WRITE_LOCK(p->lock);
#endif
memset(ptr, 0, p->alloc_size);
((struct free_blk*)ptr)->next = p->freelist;
((struct free_blk*)ptr)->magic = FREE_MAGIC;
((struct free_blk*)ptr)->magic_check = FREE_MAGIC + (uint32)p->freelist;
if (p->debug) {
dprintf("%s: adding %p, setting next = %p\n",
p->name, ptr, p->freelist);
}
p->freelist = ptr;
if (p->debug)
dprintf("%s: freelist = %p\n", p->name, p->freelist);
#if POOL_USES_BENAPHORES
RELEASE_BENAPHORE(p->lock);
#else
RELEASE_WRITE_LOCK(p->lock);
#endif
}
void
pool_destroy(struct pool_ctl *p)
{
struct pool_mem *mp,*temp;
if (p == NULL)
return;
/* the semaphore will be deleted, so we don't have to unlock */
ACQUIRE_WRITE_LOCK(p->lock);
mp = p->list;
while (mp != NULL) {
delete_area(mp->aid);
temp = mp;
mp = mp->next;
UNINIT_BENAPHORE(mp->lock);
free(temp);
}
#if POOL_USES_BENAPHORES
UNINIT_BENAPHORE(p->lock);
#else
UNINIT_RW_LOCK(p->lock);
#endif
free(p);
}