void* kzalloc(size_t size, gfp_t flags)
{
void *mem = kern_os_malloc(size);
if (mem)
bzero(mem, size);
return(mem);
}
struct pci_pool* pci_pool_create(const char *name, void *pdev, size_t size, size_t align, int flags)
{
// big fake out here, we alloc a page and hand out from that page.
uint32_t pool_size = PAGE_SIZE;
struct pci_pool *page_block;
page_block = (pci_pool*)kern_os_malloc(sizeof(struct pci_pool));
page_block->chunk_size = size;
page_block->chunk_align = align * 2;
page_block->memory = IOBufferMemoryDescriptor::withOptions(
kIOMemoryPhysicallyContiguous, pool_size, PAGE_SIZE);
if (page_block->memory == 0) {
return false;
}
if (page_block->memory->prepare() != kIOReturnSuccess) {
SAFE_RELEASE(page_block->memory);
return false;
}
page_block->freeStart = page_block->memory->getBytesNoCopy();
page_block->freeBytes = page_block->memory->getCapacity();
bzero(page_block->freeStart, page_block->freeBytes);
return page_block;
}
__END_DECLS
void * operator new( size_t size)
{
void * result;
result = (void *) kern_os_malloc( size);
if( result)
bzero( result, size);
return( result);
}
void *
kern_os_realloc(
void * addr,
size_t nsize)
{
struct _mhead * ohdr;
struct _mhead * nmem;
size_t nmemsize, osize;
if (!addr) {
return (kern_os_malloc(nsize));
}
ohdr = (struct _mhead *)addr;
ohdr--;
osize = ohdr->mlen - sizeof(*ohdr);
if (nsize == osize) {
return (addr);
}
if (nsize == 0) {
kern_os_free(addr);
return (0);
}
nmemsize = sizeof (*nmem) + nsize ;
nmem = (struct _mhead *) kalloc(nmemsize);
if (!nmem) {
kern_os_free(addr);
return (0);
}
#if OSALLOCDEBUG
debug_iomalloc_size += (nmemsize - ohdr->mlen);
#endif
nmem->mlen = nmemsize;
if (nsize > osize) {
(void) memset(&nmem->dat[osize], 0, nsize - osize);
}
(void)memcpy(nmem->dat, ohdr->dat, (nsize > osize) ? osize : nsize);
kfree(ohdr, ohdr->mlen);
return (nmem->dat);
}
void *
kern_os_realloc(
void * addr,
size_t nsize)
{
void *nmem;
size_t osize;
if (!addr) {
return (kern_os_malloc(nsize));
}
osize = kalloc_size(addr);
if (nsize == osize) {
return (addr);
}
if (nsize == 0) {
kfree_addr(addr);
return (0);
}
nmem = kallocp_tag_bt((vm_size_t *)&nsize, VM_KERN_MEMORY_LIBKERN);
if (!nmem){
kfree_addr(addr);
return (0);
}
#if OSALLOCDEBUG
OSAddAtomic((nsize - osize), &debug_iomalloc_size);
#endif
if (nsize > osize) {
(void)memset((char *)nmem + osize, 0, nsize - osize);
}
(void)memcpy(nmem, addr, (nsize > osize) ? osize : nsize);
kfree_addr(addr);
return (nmem);
}
void* vmalloc(size_t size)
{
return( kern_os_malloc(size) );
}
void* kalloc(size_t size, gfp_t flags)
{
return( kern_os_malloc(size) );
}
static void* cs_kern_os_calloc(size_t num, size_t size)
{
return kern_os_malloc(num * size); // malloc bzeroes the buffer
}
inline T *create(size_t size) {
size_t s = sizeof(T) * size;
if (s > BufferMax) return nullptr;
return static_cast<T *>(kern_os_malloc(s));
}
