void page_aligned_allocator::free(char* const block)
{
#ifdef TORRENT_DEBUG_BUFFERS
int page = page_size();
// make the two surrounding pages non-readable and -writable
mprotect(block - page, page, PROT_READ | PROT_WRITE);
alloc_header* h = (alloc_header*)(block - page);
int num_pages = (h->size + (page-1)) / page + 2;
TORRENT_ASSERT(h->magic == 0x1337);
mprotect(block + (num_pages-2) * page, page, PROT_READ | PROT_WRITE);
// fprintf(stderr, "free: %p head: %p tail: %p size: %d\n", block, block - page, block + h->size, int(h->size));
h->magic = 0;
#if defined __linux__ || (defined __APPLE__ && MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
print_backtrace(h->stack, sizeof(h->stack));
#endif
::free(block - page);
return;
#endif
#ifdef TORRENT_WINDOWS
_aligned_free(block);
#elif defined TORRENT_BEOS
area_id id = area_for(block);
if (id < B_OK) return;
delete_area(id);
#else
::free(block);
#endif
}
BufferManager::BufferManager()
: fSharedBufferList(_shared_buffer_list::Clone()),
fSharedBufferListId(-1),
fNextBufferId(1),
fLocker(new BLocker("buffer manager locker")),
fBufferInfoMap(new Map<media_buffer_id, buffer_info>)
{
fSharedBufferListId = area_for(fSharedBufferList);
}
static void
init_after_fork()
{
// The memory has actually been copied (or is in a copy on write state) but
// but the area ids have changed.
for (guarded_heap_area* area = sGuardedHeap.areas; area != NULL;
area = area->next) {
area->area = area_for(area);
if (area->area < 0)
panic("failed to find area for heap area %p after fork", area);
}
}
void
bus_release_resource(device_t dev, int type, int reg, struct resource *res)
{
switch (type) {
case SYS_RES_IOPORT:
case SYS_RES_IRQ:
return;
case SYS_RES_MEMORY:
delete_area(area_for(res));
return;
default:
INIT_DEBUGOUT("bus_release_resource default!\n");
return;
}
}
void page_aligned_allocator::free(char* block)
{
if (block == 0) return;
#ifdef TORRENT_DEBUG_BUFFERS
#ifdef TORRENT_WINDOWS
#define mprotect(buf, size, prot) VirtualProtect(buf, size, prot, NULL)
#define PROT_READ PAGE_READONLY
#define PROT_WRITE PAGE_READWRITE
#endif
const int page = page_size();
// make the two surrounding pages non-readable and -writable
mprotect(block - page, page, PROT_READ | PROT_WRITE);
alloc_header* h = reinterpret_cast<alloc_header*>(block - page);
const int num_pages = (h->size + (page-1)) / page + 2;
TORRENT_ASSERT(h->magic == 0x1337);
mprotect(block + (num_pages-2) * page, page, PROT_READ | PROT_WRITE);
// fprintf(stderr, "free: %p head: %p tail: %p size: %d\n", block, block - page, block + h->size, int(h->size));
h->magic = 0;
block -= page;
#ifdef TORRENT_WINDOWS
#undef mprotect
#undef PROT_READ
#undef PROT_WRITE
#endif
print_backtrace(h->stack, sizeof(h->stack));
#endif // TORRENT_DEBUG_BUFFERS
#ifdef TORRENT_WINDOWS
_aligned_free(block);
#elif defined TORRENT_BEOS
area_id id = area_for(block);
if (id < B_OK) return;
delete_area(id);
#else
::free(block);
#endif // TORRENT_WINDOWS
}
void
CThreadSlm::free()
{
if (m_Levels) {
delete [] m_Levels;
}
if (m_buf) {
if (m_bMMap) {
#ifdef HAVE_SYS_MMAN_H
munmap(m_buf, m_bufSize);
#elif defined(BEOS_OS)
delete_area(area_for(m_buf));
#else // Other OS
#error "No implementation for munmap()"
#endif // HAVE_SYS_MMAN_H
} else {
delete [] m_buf;
}
}
m_buf = NULL;
m_Levels = NULL;
}
static guarded_heap_page*
guarded_heap_area_allocation_for(void* address, area_id& allocationArea)
{
allocationArea = area_for(address);
if (allocationArea < 0)
return NULL;
area_info areaInfo;
if (get_area_info(allocationArea, &areaInfo) != B_OK)
return NULL;
guarded_heap_page* page = (guarded_heap_page*)areaInfo.address;
if (page->flags != (GUARDED_HEAP_PAGE_FLAG_USED
| GUARDED_HEAP_PAGE_FLAG_FIRST | GUARDED_HEAP_PAGE_FLAG_AREA)) {
return NULL;
}
if (page->allocation_base != address)
return NULL;
if (page->allocation_size >= areaInfo.size)
return NULL;
return page;
}
status_t
VideoConsumer::CreateBuffers(const media_format& format)
{
FUNCTION("VideoConsumer::CreateBuffers\n");
// delete any old buffers
DeleteBuffers();
status_t status = B_OK;
// create a buffer group
uint32 width = format.u.raw_video.display.line_width;
uint32 height = format.u.raw_video.display.line_count;
color_space colorSpace = format.u.raw_video.display.format;
PROGRESS("VideoConsumer::CreateBuffers - Width = %ld - Height = %ld - "
"Colorspace = %d\n", width, height, colorSpace);
fBuffers = new BBufferGroup();
status = fBuffers->InitCheck();
if (B_OK != status) {
ERROR("VideoConsumer::CreateBuffers - ERROR CREATING BUFFER GROUP\n");
return status;
}
// and attach the bitmaps to the buffer group
BRect bounds(0, 0, width - 1, height - 1);
for (uint32 i = 0; i < kBufferCount; i++) {
// figure out the bitmap creation flags
uint32 bitmapFlags = 0;
if (fTryOverlay) {
// try to use hardware overlay
bitmapFlags |= B_BITMAP_WILL_OVERLAY;
if (i == 0)
bitmapFlags |= B_BITMAP_RESERVE_OVERLAY_CHANNEL;
} else
bitmapFlags = B_BITMAP_IS_LOCKED;
fBitmap[i] = new BBitmap(bounds, bitmapFlags, colorSpace);
status = fBitmap[i]->InitCheck();
if (status >= B_OK) {
buffer_clone_info info;
uint8* bits = (uint8*)fBitmap[i]->Bits();
info.area = area_for(bits);
area_info bitmapAreaInfo;
status = get_area_info(info.area, &bitmapAreaInfo);
if (status != B_OK) {
fprintf(stderr, "VideoConsumer::CreateBuffers() - "
"get_area_info(): %s\n", strerror(status));
return status;
}
//printf("area info for bitmap %ld (%p):\n", i, fBitmap[i]->Bits());
//printf(" area: %ld\n", bitmapAreaInfo.area);
//printf(" size: %ld\n", bitmapAreaInfo.size);
//printf(" lock: %ld\n", bitmapAreaInfo.lock);
//printf(" protection: %ld\n", bitmapAreaInfo.protection);
//printf(" ram size: %ld\n", bitmapAreaInfo.ram_size);
//printf(" copy_count: %ld\n", bitmapAreaInfo.copy_count);
//printf(" out_count: %ld\n", bitmapAreaInfo.out_count);
//printf(" address: %p\n", bitmapAreaInfo.address);
info.offset = bits - (uint8*)bitmapAreaInfo.address;
info.size = (size_t)fBitmap[i]->BitsLength();
info.flags = 0;
info.buffer = 0;
// the media buffer id
BBuffer* buffer = NULL;
if ((status = fBuffers->AddBuffer(info, &buffer)) != B_OK) {
ERROR("VideoConsumer::CreateBuffers - ERROR ADDING BUFFER "
"TO GROUP (%ld): %s\n", i, strerror(status));
return status;
} else {
PROGRESS("VideoConsumer::CreateBuffers - SUCCESSFUL ADD "
"BUFFER TO GROUP\n");
}
fBufferMap[i] = buffer;
} else {
ERROR("VideoConsumer::CreateBuffers - ERROR CREATING VIDEO RING "
"BUFFER (Index %ld Width %ld Height %ld Colorspace %d: %s\n",
i, width, height, colorSpace, strerror(status));
return status;
}
}
FUNCTION("VideoConsumer::CreateBuffers - EXIT\n");
return status;
}
void
area_free(void *p)
{
delete_area(area_for(p));
}
void
contigfree(void *p, int p1, int p2)
{
delete_area(area_for(p));
}
image_id
beos_dl_open(char *filename)
{
image_id im;
/* If a port doesn't exist, lauch support server */
if ((beos_dl_port_in <= 0) || (beos_dl_port_out <= 0))
{
/* Create communication port */
beos_dl_port_in = create_port(50, "beos_support_in");
beos_dl_port_out = create_port(50, "beos_support_in");
if ((beos_dl_port_in <= 0) || (beos_dl_port_out <= 0))
{
elog(WARNING, "error loading BeOS support server: could not create communication ports");
return B_ERROR;
}
else
{
char Cmd[4000];
/* Build arg list */
sprintf(Cmd, "%s -beossupportserver %d %d &", my_exec_path, (int) beos_dl_port_in, (int) beos_dl_port_out);
/* Lauch process */
system(Cmd);
}
}
/* Add-on loading */
/* Send command '1' (load) to the support server */
write_port(beos_dl_port_in, 1, filename, strlen(filename) + 1);
/* Read Object Id */
read_port(beos_dl_port_out, &im, NULL, 0);
/* Checking integrity */
if (im < 0)
{
elog(WARNING, "could not load this add-on");
return B_ERROR;
}
else
{
/* Map text and data segment in our address space */
char datas[4000];
int32 area;
int32 resu;
void *add;
/* read text segment id and address */
read_port(beos_dl_port_out, &area, datas, 4000);
read_port(beos_dl_port_out, (void *) &add, datas, 4000);
/* map text segment in our address space */
resu = clone_area(datas, &add, B_EXACT_ADDRESS, B_READ_AREA | B_WRITE_AREA, area);
if (resu < 0)
{
/* If we can't map, we are in reload case */
/* delete the mapping */
resu = delete_area(area_for(add));
/* Remap */
resu = clone_area(datas, &add, B_EXACT_ADDRESS, B_READ_AREA | B_WRITE_AREA, area);
if (resu < 0)
elog(WARNING, "could not load this add-on: map text error");
}
/* read text segment id and address */
read_port(beos_dl_port_out, &area, datas, 4000);
read_port(beos_dl_port_out, (void *) &add, datas, 4000);
/* map text segment in our address space */
resu = clone_area(datas, &add, B_EXACT_ADDRESS, B_READ_AREA | B_WRITE_AREA, area);
if (resu < 0)
{
/* If we can't map, we are in reload case */
/* delete the mapping */
resu = delete_area(area_for(add));
/* Remap */
resu = clone_area(datas, &add, B_EXACT_ADDRESS, B_READ_AREA | B_WRITE_AREA, area);
if (resu < 0)
elog(WARNING, "could not load this add-on: map data error");
}
return im;
}
}
void
beos_startup(int argc, char **argv)
{
if (strlen(argv[0]) >= 10 && !strcmp(argv[0] + strlen(argv[0]) - 10, "postmaster"))
{
/*
* We are in the postmaster, create the protection semaphore for
* shared mem remapping
*/
beos_shm_sem = create_sem(1, "beos_shm_sem");
}
if (argc > 1 && strcmp(argv[1], "-beossupportserver") == 0)
{
/* We are in the support server, run it ... */
port_id port_in;
port_id port_out;
/* Get back port ids from arglist */
sscanf(argv[2], "%d", (int *) (&port_in));
sscanf(argv[3], "%d", (int *) (&port_out));
/* Main server loop */
for (;;)
{
int32 opcode = 0;
char datas[4000];
/*
* Wait for a message from the backend : 1 : load a shared object
* 2 : unload a shared object any other : exit support server
*/
read_port(port_in, &opcode, datas, 4000);
switch (opcode)
{
image_id addon;
image_info info_im;
area_info info_ar;
void *fpt;
/* Load Add-On */
case 1:
/* Load shared object */
addon = load_add_on(datas);
/* send back the shared object Id */
write_port(port_out, addon, NULL, 0);
/* Get Shared Object infos */
get_image_info(addon, &info_im);
/* get text segment info */
get_area_info(area_for(info_im.text), &info_ar);
/* Send back area_id of text segment */
write_port(port_out, info_ar.area, info_ar.name, strlen(info_ar.name) + 1);
/* Send back real address of text segment */
write_port(port_out, (int) info_ar.address, info_ar.name, strlen(info_ar.name) + 1);
/* get data segment info */
get_area_info(area_for(info_im.data), &info_ar);
/* Send back area_id of data segment */
write_port(port_out, info_ar.area, info_ar.name, strlen(info_ar.name) + 1);
/* Send back real address of data segment */
write_port(port_out, (int) info_ar.address, info_ar.name, strlen(info_ar.name) + 1);
break;
/* UnLoad Add-On */
case 2:
/*
* Unload shared object and send back the result of the
* operation
*/
write_port(port_out, unload_add_on(*((int *) (datas))), NULL, 0);
break;
/* Cleanup and exit */
case 3:
/* read image Id on the input port */
read_port(port_in, &addon, NULL, 0);
/* Loading symbol */
fpt = NULL;
if (get_image_symbol(addon, datas, B_SYMBOL_TYPE_TEXT, &fpt) == B_OK);
{
/*
* Sometime the loader return B_OK for an inexistant
* function with an invalid address !!! Check that the
* return address is in the image range
*/
get_image_info(addon, &info_im);
if ((fpt < info_im.text) ||(fpt >= (info_im.text +info_im.text_size)))
fpt = NULL;
}
/* Send back fptr of data segment */
write_port(port_out, (int32) (fpt), NULL, 0);
break;
default:
/* Free system resources */
delete_port(port_in);
delete_port(port_out);
/* Exit */
exit(0);
break;
}
}
/* Never be there */
exit(1);
}
}
