ref: 98408d89372fff62722faf0907d9477a529ceb5a
dir: /config/unix/ftsys.c/
/*******************************************************************
*
* ftsys.c
*
* Unix-specific system operations.
*
* Copyright 1996-1998 by
* David Turner, Robert Wilhelm, and Werner Lemberg.
*
* This file is part of the FreeType project, and may only be used
* modified and distributed under the terms of the FreeType project
* license, LICENSE.TXT. By continuing to use, modify, or distribute
* this file you indicate that you have read the license and
* understand and accept it fully.
*
*
* This implementation of the 'ftsys' component uses memory-mapped
* files, as well as the ANSI malloc/free functions..
*
* IMPORTANT NOTE :
*
* Porters, read carefully the comments in ftsys.h before trying
* to port this file to your system. It contains many essential
* remarks, and will ease your work greatly..
*
******************************************************************/
#include "ftsys.h"
#include "ftobjs.h"
#include "ftstream.h"
#include "ftdebug.h"
/* Memory-mapping includes and definitions.. */
/* */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <sys/mman.h>
#ifndef MAP_FILE
#define MAP_FILE 0x00
#endif
/*
* The prototype for munmap() is not provided on SunOS. This needs to
* have a check added later to see if the GNU C library is being used.
* If so, then this prototype is not needed.
*/
#if defined(__sun__) && !defined(SVR4) && !defined(__SVR4)
extern int munmap( caddr_t addr, int len );
#endif
#include <sys/stat.h>
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
/* parameter of the PTRACE and PERROR macros, used to print/log */
/* messages during execution.. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_io
/* To ease porting, we use the macro SYS_STREAM to name the system-specific */
/* stream type. For example, it is a "FILE*" with the ANSI libc, it will be */
/* a file descriptor, i.e. an integer, when using the Unix system api, etc. */
/* we identify each memory-mapped file through its address in memory */
/* hence the following macro definition.. */
#define SYS_STREAM void*
/**************************************************************************/
/* */
/* I/O ACCESS AND MANAGEMENT */
/* */
/* We only define the "ANSI" resource class in this class. It is */
/* disk-based, and provides a MRU cache, in order to only keep the file */
/* descriptors of the 10 most recently used resource files. */
/* */
/* it simply contains two lists. One contains the "cached" resources */
/* with a valid FILE* pointer, the second contains all other "flushed" */
/* resource objects. */
/* */
/* The FT_MMapFile class derives from FT_ResourceRec - description : */
/* */
/* <Struct> FT_AnsiFileRec */
/* */
/* <Fields> */
/* */
/* root :: */
/* the root resource class fields. */
/* */
/* pathname :: */
/* the file's pathname. Needed because we open and close font */
/* resources dynamically in order to limit the number of */
/* concurrently active mappings (this saves kernel resources). */
/* */
/* file_size :: */
/* the size in bytes of the resource. This field should be set to */
/* -1 until the resource is first opened.. */
/* */
#include <stdio.h>
typedef struct FT_MMapFileRec_
{
FT_ResourceRec root;
const char* pathname;
FT_Long file_size; /* file size in bytes */
} FT_MMapFileRec, *FT_MMapFile;
/* We use the macro STREAM_Name as a convenience to return a given */
/* ANSI resource's pathname. Its "stream" argument is a FT_Resource */
/* which is typecasted to the FT_AnsiFile class */
#define STREAM_Name(stream) ((FT_MMapFile)stream->resource)->pathname
/* We use the macro STREAM_File as a convenience to extract the */
/* system-specific stream handle from a given FreeType stream object */
#define STREAM_File(stream) ((void*)stream->stream_id.pointer)
/***************************************************************************/
/* */
/* <Function> MMapFile_Open */
/* */
/* <Description> */
/* This function is used to open a system-stream for a given resource. */
/* */
/* Note that it must update the target FreeType stream object with the */
/* system-stream handle and the resource's size. */
/* */
/* Also, the 'stream->base' field must be set to NULL for disk-based */
/* resource, and to the address in memory of the resource's first byte */
/* for a memory-based one. */
/* */
/* <Input> */
/* resource :: the source resource */
/* stream :: the target stream object */
/* */
/* <Return> */
/* Error code */
/* */
/* <Note> */
/* This function simply opens and maps the resource's file pathname */
/* */
/* The stream object IS NOT CREATED by this function, but by its caller. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Open( FT_MMapFile resource,
FT_Stream stream )
{
int file;
struct stat stat_buf;
/* open the file */
file = open( resource->pathname, O_RDONLY );
if (file < 0)
{
PERROR(( "UnixSys.MMapFile_Open : could not open '%s'\n",
resource->pathname ));
return FT_Err_Cannot_Open_Stream;
}
if (fstat( file, &stat_buf ) < 0)
{
PERROR(( "UnixSys.MMapFile_Open : could not 'fstat' file '%s'\n",
resource->pathname ));
goto Fail_Map;
}
if ( resource->file_size < 0 )
resource->file_size = stat_buf.st_size;
stream->resource = (FT_Resource)resource;
stream->system = resource->root.driver->system;
stream->size = resource->file_size;
stream->stream_id.pointer = mmap( NULL,
resource->file_size,
PROT_READ,
MAP_FILE | MAP_PRIVATE,
file,
0 );
if ( (long)stream->stream_id.pointer == -1 )
{
PERROR(( "UnixSys.MMapFile_Open : Could not map file '%s'\n",
resource->pathname ));
goto Fail_Map;
}
close(file);
stream->base = (FT_Byte*)stream->stream_id.pointer;
stream->cursor = stream->base;
PTRACE1(( "UnixSys.MMapFile_Open: opened '%s' (%d bytes) succesfully\n",
resource->pathname, resource->file_size ));
return FT_Err_Ok;
Fail_Map:
close(file);
stream->resource = NULL;
stream->size = 0;
stream->stream_id.pointer = NULL;
stream->base = NULL;
stream->cursor = NULL;
return FT_Err_Cannot_Open_Stream;
}
/***************************************************************************/
/* */
/* <Function> MMapFile_Close */
/* */
/* <Description> Closes a given stream */
/* */
/* <Input> */
/* stream :: the target stream object */
/* */
/* <Return> */
/* Error code */
/* */
/* <Note> */
/* This function simply unmaps the resource.. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Close( FT_Stream stream )
{
PTRACE1(( "Closing file '%s'\n", STREAM_Name(stream) ));
munmap ( (void*)stream->stream_id.pointer, stream->size );
stream->resource = NULL;
stream->stream_id.pointer = NULL;
stream->size = 0;
stream->base = NULL;
stream->cursor = NULL;
return FT_Err_Ok;
}
/***************************************************************************/
/* */
/* <Function> MMapFile_Seek */
/* */
/* <Description> Seek a stream to a given position */
/* */
/* <Input> */
/* stream :: the target stream object */
/* position :: offset in bytes from start of resource/stream */
/* */
/* <Return> */
/* Error code */
/* */
/* <Note> */
/* This function should never be called for memory-based resources.. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Seek( FT_Stream stream,
FT_Long position )
{
(void)stream;
(void)position;
return FT_Err_Invalid_Stream_Operation;
}
/***************************************************************************/
/* */
/* <Function> MMapFile_Skip */
/* */
/* <Description> Skip a given number of bytes in an MMap stream. */
/* Useful to skip pad bytes, for example. */
/* */
/* <Input> */
/* stream :: the target stream object */
/* count :: number of bytes to skip in the stream */
/* */
/* <Return> */
/* Error code */
/* */
/* <Note> */
/* This function should never be called for memory-based resources.. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Skip( FT_Stream stream,
FT_Long count )
{
(void)stream;
(void)count;
return FT_Err_Invalid_Stream_Operation;
}
/***************************************************************************/
/* */
/* <Function> MMapFile_Pos */
/* */
/* <Description> Returns the current offset within an MMap stream's */
/* resource. */
/* */
/* <Input> */
/* stream :: the target stream object */
/* */
/* <Output> */
/* position :: current offset. -1 in case of error */
/* */
/* <Return> */
/* Error code. */
/* */
/* <Note> */
/* This function should never be called for memory-based resources.. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Pos( FT_Stream stream,
FT_Long* position )
{
(void)stream;
(void)position;
return FT_Err_Invalid_Stream_Operation;
}
/***************************************************************************/
/* */
/* <Function> MMapFile_Read */
/* */
/* <Description> Read a given number of bytes from an MMap stream into */
/* memory. */
/* */
/* <Input> */
/* stream :: the target stream object */
/* buffer :: the target read buffer where data is copied */
/* size :: number of bytes to read from the stream */
/* */
/* <Output> */
/* read_bytes :: the number of bytes effectively read from the stream */
/* used in case of error (i.e. FT_Err_Invalid_Stream_Read) */
/* by some parts of the library.. */
/* <Return> */
/* Error code */
/* */
/* <Note> */
/* This function should never be called for memory-based resources.. */
/* */
/***************************************************************************/
static
FT_Error MMapFile_Read( FT_Stream stream,
FT_Byte* buffer,
FT_Long size,
FT_Long* read_bytes )
{
(void)stream;
(void)buffer;
(void)size;
(void)read_bytes;
return FT_Err_Invalid_Stream_Operation;
}
/* The following table is the "virtual method table" for the 'MMap */
/* resource class', which methods are defined above. Its address is */
/* set in the 'interface' field of all resource objects created by */
/* the function FT_Create_MMapFile (see below) */
static
FTRes_InterfaceRec FT_MMapFile_Interface =
{
(FTRes_Open_Func) MMapFile_Open,
(FTRes_Close_Func) MMapFile_Close,
(FTRes_Seek_Func) MMapFile_Seek,
(FTRes_Skip_Func) MMapFile_Skip,
(FTRes_Pos_Func) MMapFile_Pos,
(FTRes_Read_Func) MMapFile_Read,
};
/************************************************************************/
/* */
/* <Function> FT_Create_Resource */
/* */
/* <Description> */
/* Create a new resource object for a given library. Note that this */
/* function takes an ASCII 'pathname' as an argument. */
/* */
/* <Input> */
/* library :: handle to target library object */
/* pathanme :: ASCII pathname of the font file */
/* */
/* <Output> */
/* resource :: handle to new resource object */
/* */
/* <Return> */
/* Error code. 0 means success */
/* */
/* <Note> */
/* When porting the library to exotic environments, where an */
/* ASCII pathname isn't used to name files, developers should */
/* invoke directly their own resource creation function which */
/* must be placed in their port of the "ftsys" component. */
/* */
/* See the porting guide for more information.. */
/* */
EXPORT_FUNC
FT_Error FT_Create_Resource( FT_Library library,
const char* pathname,
FT_Resource* aresource )
{
FT_Int len;
FT_System system;
FT_MMapFile resource;
FT_Error error;
*aresource = NULL;
if (!library)
{
PERROR(( "Unix.New_Resource : null library handle\n" ));
return FT_Err_Invalid_Library_Handle;
}
system = library->system;
if ( !pathname )
goto Fail_Null;
len = strlen(pathname);
if (len == 0)
goto Fail_Null;
resource = NULL;
if ( ALLOC( resource, sizeof(*resource) ) ||
ALLOC( resource->pathname, len+1 ) )
goto Fail_Memory;
resource->root.library = library;
resource->root.interface = &FT_MMapFile_Interface;
resource->root.flags = FT_RESOURCE_TYPE_MEMORY_BASED;
resource->file_size = -1;
strcpy( (char*)resource->pathname, pathname );
PTRACE1(( "Create_MMapFile : MMap resource created for '%s'\n",
pathname ));
*aresource = (FT_Resource)resource;
return FT_Err_Ok;
Fail_Null:
PERROR(( "Create_MMapFile : null pathname !!\n" ));
return FT_Err_Invalid_Argument;
Fail_Memory:
if (resource)
FREE( resource->pathname );
FREE( resource );
PERROR(( "Create_MMapFile : error when creating resource !\n" ));
return error;
}
/***************************************************************************/
/* */
/* <Function> FT_Destroy_Resource */
/* */
/* <Description> Destroys an MMap resource object. */
/* This function is never called directly by the font */
/* drivers. Only by the higher-level part of FreeType */
/* (called the HLib), or client applications */
/* */
/* <Input> */
/* resource :: the MMap resource object */
/* */
/* <Note> */
/* This functions does not check that runs or streams are opened for */
/* the resource (for now, we assume developer intelligence. We'll most */
/* probably lower our standard later to ease debugging ;-) */
/* */
/***************************************************************************/
EXPORT_FUNC
FT_Error FT_Destroy_Resource( FT_Resource resource )
{
FT_System system = resource->library->system;
FT_MMapFile res = (FT_MMapFile)resource;
if ( !res || res->root.interface != &FT_MMapFile_Interface )
{
PERROR((
"Destroy_MMapFile : Trying to destroy an invalid resource !!\n" ));
return FT_Err_Invalid_Resource_Handle;
}
PTRACE1(( "Destroy_MMapFile : destroying resource for '%s'\n",
res->pathname ));
FREE( res->pathname );
FREE( res );
return FT_Err_Ok;
}
/**************************************************************************/
/* */
/* MEMORY MANAGEMENT */
/* */
/* */
/* This part copies the old FreeType 1.0 and 1.1 memory management */
/* scheme that was defined in the file "ttmemory.h". One can see that */
/* */
/* - a set of macros is defined for the memory operations used */
/* by the engine ( MEM_Copy, MEM_Move, MEM_Set ). This comes from */
/* the fact that many compilers are able to inline these ops directly */
/* within the compiled code, rather than generating a call to the */
/* C library. However, this obliges us to include the <string.h> */
/* header file. */
/* */
/* If you provide your own memory operations routine, you can get */
/* rid of the #include <string.h> below. */
/* */
/* */
/* - the FT_Alloc function has several essential properties that */
/* MUST be retained by each port : */
/* */
/* - it returns an error code, NOT the allocated block's base */
/* address */
/* */
/* - it takes the address of a target pointer, where the block's */
/* base address will be set. if the size is zero, its value */
/* will be NULL and the function returns successfully */
/* */
/* - in case of error, the pointer's value is set to NULL and */
/* an error code is returned.. */
/* */
/* - the new allocated block MUST be zero-filled. This is a strong */
/* convetion the rest of the engine relies on */
/* */
/* */
/* */
/* - the FT_Free function has also its essentials : */
/* */
/* - it takes the address of a pointer which value is the block's */
/* base address. This is UNLIKE a standard "free" which takes the */
/* the block's base directly. */
/* */
/* - it accepts succesfully the address of a pointer which value */
/* is NULL, in which case it simply returns. */
/* */
/* - the pointer is always set to NULL by the function */
/* */
/* */
/* - the MEM_Alloc, ALLOC and ALLOC_ARRAY macros are used by the */
/* library, and should NOT be modified by porters !! */
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
/* parameter of the PTRACE and PERROR macros, used to print/log */
/* messages during execution.. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_memory
#include <stdlib.h>
/**************************************************************************/
/* */
/* <Function> FT_Alloc */
/* */
/* <Description> */
/* Allocates a new bloc of memory. The returned area is always */
/* zero-filled, this is a strong convention in many FreeType parts */
/* */
/* <Input> */
/* system :: handle to a given 'system object' where allocation */
/* occurs.. */
/* */
/* size :: size in bytes of the block to allocate */
/* */
/* <Output> */
/* P :: pointer to the fresh new block. It should be set */
/* to NULL if 'size' is 0, of in case of error.. */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
/**************************************************************************/
BASE_FUNC
FT_Error FT_Alloc( FT_System system,
long size,
void* *P )
{
if (!P)
{
PERROR(( "FT_Alloc : invalid pointer address !!\n" ));
return FT_Err_Invalid_Argument;
}
if ( size > 0 )
{
*P = malloc( size );
if ( !*P )
{
PERROR(( "FT_Alloc : out of memory (%ld bytes requested) !!\n",
size ));
return FT_Err_Out_Of_Memory;
}
system->total_alloc += size;
/* ALWAYS ZERO-FILL THE BLOCK !!!!! */
MEM_Set( *P, 0, size );
}
else
*P = NULL;
PTRACE2(( "FT_Alloc : size = %ld, pointer = 0x%08lx, block = 0x%08lx\n",
size, (long)P, (long)*P ));
return FT_Err_Ok;
}
/**************************************************************************/
/* */
/* <Function> FT_Realloc */
/* */
/* <Description> */
/* Reallocates a block of memory pointed to by '*P' to 'Size' */
/* bytes from the hea^, possibly changing '*P'. */
/* */
/* <Input> */
/* system :: handle to a given 'system object' where allocation */
/* occurs.. */
/* */
/* size :: size in bytes of the block to allocate */
/* */
/* <InOut> */
/* P :: pointer to the fresh new block. It should be set */
/* to NULL if 'size' is 0, of in case of error.. */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
BASE_FUNC
int FT_Realloc( FT_System system,
long size,
void* *P )
{
void* Q;
if (!P)
{
PERROR(( "FT_Realloc : invalid pointer address !!\n" ));
return FT_Err_Invalid_Argument;
}
/* if the original pointer is NULL, call FT_Alloc */
if (!*P)
return FT_Alloc( system, size, P );
/* if the new block if zero-sized, clear the current one */
if (size <= 0)
return FT_Free( system, P );
Q = (void*)realloc( *P, size );
if (!Q)
{
PERROR(( "FT_Realloc : reallocation failed\n" ));
return FT_Err_Out_Of_Memory;
}
*P = Q;
return FT_Err_Ok;
}
/**************************************************************************/
/* */
/* <Function> FT_Free */
/* */
/* <Description> */
/* Releases a given block of memory allocated through FT_Alloc */
/* */
/* <Input> */
/* system :: handle to a given 'system object' where allocation */
/* occured.. */
/* */
/* P :: This is the _address_ of a _pointer_ which points to */
/* the allocated block. It is always set to NULL on exit */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
/* <Note> */
/* If P or *P are NULL, this function should return successfuly. This */
/* is a strong convention within all of FreeType and its drivers.. */
/* */
BASE_FUNC
FT_Error FT_Free( FT_System system,
void* *P )
{
(void)system; /* unused parameter. Gets rid of warnings */
PTRACE2(( "FT_Free : freeing pointer 0x%08lx (block 0x%08lx)\n",
(long)P, (P ? (long)*P : -1) ));
if ( !P || !*P )
return FT_Err_Ok;
free( *P );
*P = NULL;
return FT_Err_Ok;
}
/**************************************************************************/
/* */
/* SYNCHRONIZATION MANAGEMENT */
/* */
/* */
/* This section deals with mutexes. The library can be compiled to */
/* three distinct thread-support levels ( namely single-threaded, */
/* thread-safe and re-entrant modes ). */
/* */
/* It protects its variables through the MUTEX_Lock and MUTEX_Release */
/* macros which are void in single-threaded mode. */
/* */
/* */
/* It defines a type-less mutex reference type, "TMutex", that you're */
/* free to redefine for your system's needs.. */
/* */
/* The default implementation of ftsys.c contains only dummy functions */
/* which always return succesfully. you NEED to specialize them in */
/* order to port ftsys.c in any multi-threaded environment... */
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
/* parameter of the PTRACE and PERROR macros, used to print/log */
/* messages during execution.. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_sync
#ifdef FT_CONFIG_THREADS
BASE_FUNC
FT_Error FT_Mutex_Create ( FT_System system,
TMutex* mutex )
{
(void)system; /* unused parameter. Gets rid of warnings */
mutex = (void*)-1;
system->num_mutexes++;
return FT_Err_Ok;
/* Replace this line with your own mutex creation code */
}
BASE_FUNC
void FT_Mutex_Delete ( FT_System system,
TMutex* mutex )
{
(void)system; /* unused parameter. Gets rid of warnings */
mutex = (void*)0;
system->num_mutexes--;
/* Replace this line with your own mutex destruction code */
}
BASE_FUNC
void FT_Mutex_Lock ( FT_System system,
TMutex* mutex )
{
/* NOTE: It is legal to call this function with a NULL argument */
/* in which case an immediate return is appropriate. */
(void)system; /* unused parameter. Gets rid of warnings */
if ( !mutex )
return;
; /* Insert your own mutex locking code here */
}
void FT_Mutex_Release( FT_System system,
TMutex* mutex )
{
/* NOTE: It is legal to call this function with a NULL argument */
/* in which case an immediate return is appropriate */
(void)system; /* unused parameter. Gets rid of warnings */
if ( !mutex )
return;
; /* Insert your own mutex release code here */
}
#endif /* FT_CONFIG_THREADS */
EXPORT_FUNC
FT_Error FT_New_System( FT_System* system )
{
*system = (FT_System)malloc( sizeof(FT_SystemRec) );
if ( !*system )
return FT_Err_Out_Of_Memory;
/* the ANSI function 'free' is unable to return the number */
/* of released bytes. Hence, the 'current_alloc' field of the */
/* system object cannot be used */
(*system)->system_flags = FT_SYSTEM_FLAG_TOTAL_ALLOC |
FT_SYSTEM_FLAG_MUTEXES;
(*system)->total_alloc = 0;
(*system)->num_mutexes = 0;
/* initialise i/o management (nothing) */
/* initialise synchronisation (nothing) */
/* initialise streams */
return FT_Err_Ok;
}
EXPORT_FUNC
FT_Error FT_Done_System( FT_System system )
{
/* finalise syncrhonisation (nothing) */
/* finalise i/o management (nothing) */
/* finalise memory management */
free( system );
return FT_Err_Ok;
}