自学教程：C++ D_INFO函数代码示例

static DFBResult driver_open_device(CoreInputDevice *device,                                    unsigned int number,                                    InputDeviceInfo *info,                                    void **driver_data){     int fd;     MuTData *data;     /* open device */     fd = MuTOpenDevice (dfb_config->mut_device);     D_INFO("MuTouch:driver_open_device %s fd %d/n", dfb_config->mut_device,fd);     if (fd < 0) {          return DFB_INIT;     }     data = D_CALLOC (1, sizeof(MuTData));     if (!data) {          close (fd);          return D_OOM ();     }     data->fd     = fd;     data->device = device;     /* Must define the correct resolution of screen */     data->screen_width  = MuT_SCREENWIDTH;     data->screen_height = MuT_SCREENHEIGHT;     /* The following variable are defined to adjust the orientation of      * the touchscreen. Variables are either max screen height/width or 0.      */     data->min_x = MuT_MINX;     data->min_y = MuT_MINY;     /* fill device info structure */     snprintf(info->desc.name, DFB_INPUT_DEVICE_DESC_NAME_LENGTH,              "MuTouch");     snprintf(info->desc.vendor, DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH,              "Microtouch");     info->prefered_id     = DIDID_MOUSE;     info->desc.type        = DIDTF_MOUSE;     info->desc.caps        = DICAPS_AXES | DICAPS_BUTTONS;     info->desc.max_axis   = DIAI_Y;     info->desc.max_button = DIBI_LEFT;     /* start input thread */     data->thread = direct_thread_create (DTT_INPUT, MuTouchEventThread, data, "MuTouch Input");     /* set private data pointer */     *driver_data = data;     return DFB_OK;}

static interror_handler_shm( Display *display, XErrorEvent *event ){     if (use_shm) {          D_INFO( "X11/Display: Error! Disabling XShm./n" );          use_shm = false;     }     return 0;}

int __initlibdirect_init(void){     DirectResult__ctor();     D_DEBUG_AT( Direct_Module, "%s()/n", __FUNCTION__ );     D_INFO( "Direct/Module: Initializing module.../n" );     return 0;}

voidgGetDriverInfo( GraphicsDriverInfo *info ){     D_INFO( "DirectFB/Genefx: No software fallbacks supported/n" );     snprintf( info->name, DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH, "Software Driver" );     snprintf( info->vendor, DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH, "directfb.org" );     info->version.major = 0;     info->version.minor = 0;}

static DFBResultTest_RenderElements( IWater *water, IDirectFBSurface *surface ){     D_INFO( "Tests/Water: Testing RenderElements( %d ).../n", D_ARRAY_SIZE(m_test_elements) );     /*      * Render elements      */     _T( water->RenderElements( water, surface, m_test_elements, D_ARRAY_SIZE(m_test_elements) ) );     return DFB_OK;}

static DirectEnumerationResultplayer_callback( void                    *ctx,                 const VoodooPlayInfo    *info,                 const VoodooPlayVersion *version,                 const char              *address,                 unsigned int             ms_since_last_seen ){     D_INFO( "Voodoo/Play: <%4ums> [ %-30s ]   %s%s   (vendor: %s, model: %s)/n",             ms_since_last_seen, info->name, address, (info->flags & VPIF_LEVEL2) ? " *" : "",             info->vendor, info->model );     return DENUM_OK;}

static DFBResultsystem_initialize( CoreDFB *core, void **data ){     char       *driver;     CoreScreen *screen;     D_ASSERT( dfb_sdl == NULL );     dfb_sdl = (DFBSDL*) SHCALLOC( dfb_core_shmpool(core), 1, sizeof(DFBSDL) );     if (!dfb_sdl) {          D_ERROR( "DirectFB/SDL: Couldn't allocate shared memory!/n" );          return D_OOSHM();     }     dfb_sdl_core = core;     dfb_fbdev_read_modes();  /* use same mode list as a fake */     driver = getenv( "SDL_VIDEODRIVER" );     if (driver && !strcasecmp( driver, "directfb" )) {          D_INFO( "DirectFB/SDL: SDL_VIDEODRIVER is 'directfb', unsetting it./n" );          unsetenv( "SDL_VIDEODRIVER" );     }     /* Initialize SDL */     if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {          D_ERROR( "DirectFB/SDL: Couldn't initialize SDL: %s/n", SDL_GetError() );          SHFREE( dfb_core_shmpool(core), dfb_sdl );          dfb_sdl = NULL;          return DFB_INIT;     }     fusion_skirmish_init( &dfb_sdl->lock, "SDL System", dfb_core_world(core) );     fusion_call_init( &dfb_sdl->call, dfb_sdl_call_handler, NULL, dfb_core_world(core) );     screen = dfb_screens_register( NULL, NULL, sdlPrimaryScreenFuncs );     dfb_layers_register( screen, NULL, sdlPrimaryLayerFuncs );     fusion_arena_add_shared_field( dfb_core_arena( core ), "sdl", dfb_sdl );     dfb_surface_pool_initialize( core, &sdlSurfacePoolFuncs, &dfb_sdl->sdl_pool );     *data = dfb_sdl;     return DFB_OK;}

static int check_mnt_point(const char *mpoint){	printf("/n/033[34m<<<<check_mnt_point/033[0m/n");	FILE *fp;	struct mntent *ment;		fp = setmntent("/etc/mtab", "r");	if (fp == NULL)	{		D_ERROR("check_mnt_point: Failed to open /etc/mtab/n");		return -1;	}	while (!feof(fp))	{		ment = getmntent(fp);				if (ment != NULL && !strcmp(ment->mnt_dir, mpoint))		{			D_INFO("ment->mnt_opts:%s/n", ment->mnt_opts);			D_INFO("ment->mnt_opts:[%c%c]/n", ment->mnt_opts[0], ment->mnt_opts[1]);			if((ment->mnt_opts[0] == 'r') && (ment->mnt_opts[1] == 'w')) //rw: writable			{				D_INFO("%s/n", ment->mnt_dir);				return 0;			}			else			{				D_INFO("/033[31mRead-only device/033[0m/n");				return -1;			}		}	}		return -1;}

static voidClose( VoodooLink *link ){     Link *l = link->priv;     D_INFO( "Voodoo/Link: Closing connection./n" );     // FIXME: how to close socket?     direct_mutex_deinit( &l->lock );     WSACloseEvent( l->event );     D_FREE( l );}

intmain( int argc, char** argv ){     IDirectFB *dfb = NULL;      ISaWMan   *saw = NULL;      pid_t      pid;     D_INFO( "SaWMan/TestRun: Initializing.../n" );     CHECK( DirectFBInit( &argc, &argv ) );     CHECK( DirectFBCreate( &dfb ) );     CHECK( SaWManCreate( &saw ) );     CHECK( saw->Start( saw, ((argc > 1) && argv[1]) ? argv[1] : "Test Application", &pid ) );          D_INFO( "SaWMan/TestRun: New process has pid %d./n", pid );//     sleep( 2 );//     CHECK( saw->Stop( saw, pid ) );out:     D_INFO( "SaWMan/TestRun: Shutting down.../n" );     if (saw)          saw->Release( saw );     if (dfb)          dfb->Release( dfb );     return 0;}

DirectResultDirectGetInterface( DirectInterfaceFuncs     **funcs,                    const char                *type,                    const char                *implementation,                    DirectInterfaceProbeFunc   probe,                    void                      *probe_ctx ){#ifdef DYNAMIC_LINKING     int                         len;     DIR                        *dir;     char                       *interface_dir;     struct dirent              *entry = NULL;     struct dirent               tmp;#endif     DirectLink *link;     pthread_mutex_lock( &implementations_mutex );     /*      * Check existing implementations first.      */     direct_list_foreach( link, implementations ) {          DirectInterfaceImplementation *impl = (DirectInterfaceImplementation*) link;          if (type && strcmp( type, impl->type ))               continue;          if (implementation && strcmp( implementation, impl->implementation ))               continue;          if (probe && !probe( impl->funcs, probe_ctx ))               continue;          else {               if (!impl->references) {                    D_INFO( "Direct/Interface: Using '%s' implementation of '%s'./n",                            impl->implementation, impl->type );               }               *funcs = impl->funcs;               impl->references++;               pthread_mutex_unlock( &implementations_mutex );               return DFB_OK;          }     }

     Surface( EGL                  &egl,              IDirectFB             dfb,              int                   width,              int                   height,              IDirectFBEventBuffer  events )          :          egl( egl )     {          DFBSurfaceDescription desc;          /* Fill description for a shared offscreen surface. */          desc.flags  = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);          desc.caps   = (DFBSurfaceCapabilities)(DSCAPS_SHARED | DSCAPS_TRIPLE);          desc.width  = width;          desc.height = height;          /* Create a primary surface. */          surface = dfb.CreateSurface( desc );          surface.MakeClient();          /* Create event buffer */          surface.AttachEventBuffer( events );          surface_id = surface.GetID();          surface.AllowAccess( "*" );          surface.Clear( 0xff, 0xff, 0xff, 0xff );          D_INFO( "DFBTest/EGLCompositor: Created new surface with ID %u/n", surface_id );          image = egl.CreateImage( EGL_NO_CONTEXT, EGL_IMAGE_IDIRECTFBSURFACE_DIRECTFB, (EGLClientBuffer) surface.iface, NULL );          glGenTextures( 1, &tex );          glBindTexture( GL_TEXTURE_2D, tex );          egl.EGLImageTargetTexture2D( GL_TEXTURE_2D, image );          glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );          glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );          glDisable( GL_CULL_FACE );          glDisable( GL_DEPTH_TEST );     }

DirectResultfusion_ref_down (FusionRef *ref, bool global){     D_ASSERT( ref != NULL );     D_DEBUG_AT( Fusion_Ref, "fusion_ref_down( %p [%d]%s )/n", ref, ref->multi.id, global ? " GLOBAL" : "" );     if (ref->multi.id == fusion_config->trace_ref) {          D_INFO( "Fusion/Ref: 0x%08x down (%s)/n", ref->multi.id, global ? "global" : "local" );          direct_trace_print_stack( NULL );     }     fusion_world_flush_calls( _fusion_world( ref->multi.shared ), 1 );     while (ioctl (_fusion_fd( ref->multi.shared ), global ?                   FUSION_REF_DOWN_GLOBAL : FUSION_REF_DOWN, &ref->multi.id))     {          switch (errno) {               case EINTR:                    continue;               case EINVAL:                    D_ERROR ("Fusion/Reference: invalid reference/n");                    return DR_DESTROYED;               default:                    break;          }          if (global)               D_PERROR ("FUSION_REF_DOWN_GLOBAL");          else               D_PERROR ("FUSION_REF_DOWN");          return DR_FAILURE;     }// FIMXE: the following had to be commented out as the ref down may cause a ref watcher to free the memory of 'ref' (via ioctl)#if 0     if (ref->multi.shared)          D_DEBUG_AT( Fusion_Ref, "  -> %d references now/n",                      ioctl( _fusion_fd( ref->multi.shared ), FUSION_REF_STAT, &ref->multi.id ) );     else          D_DEBUG_AT( Fusion_Ref, "  -> destroyed/n" );#endif     return DR_OK;}

static int driver_get_available( void ){  int fd;   /* we will only use the ELO device if it has been configured */  if(!dfb_config->elo_device) {    return 0;  }  fd = eloOpenDevice (dfb_config->elo_device);  if (fd < 0) {    D_INFO("Elo:driver_get_available NON OK/n");    return 0;  }  close(fd);  return 1;}

static voidClose( VoodooLink *link ){     Link *l = link->priv;     D_INFO( "Voodoo/Link: Closing connection./n" );     close( l->fd[0] );     if (l->fd[1] != l->fd[0])          close( l->fd[1] );     close( l->wakeup_fds[0] );     close( l->wakeup_fds[1] );     D_FREE( link->priv );     link->priv = NULL;}

static intset_abt_max_num_xstreams(int n){	char   *name = "ABT_MAX_NUM_XSTREAMS";	char   *value;	int	rc;	D_ASSERTF(n > 0, "%d/n", n);	D_ASPRINTF(value, "%d", n);	if (value == NULL)		return -DER_NOMEM;	D_INFO("Setting %s to %s/n", name, value);	rc = setenv(name, value, 1 /* overwrite */);	D_FREE(value);	if (rc != 0)		return daos_errno2der(errno);	return 0;}

static voidserver_fini(bool force){	D_INFO("Service is shutting down/n");	dss_module_cleanup_all();	drpc_fini();	if (dss_mod_facs & DSS_FAC_LOAD_CLI)		daos_fini();	else		daos_hhash_fini();	dss_srv_fini(force);	dss_module_unload_all();	ds_iv_fini();	crt_finalize();	dss_module_fini(force);	abt_fini();	daos_debug_fini();}

static DirectResult fs_config_read( const char *filename ){     DirectResult  ret = DR_OK;     char       line[400];     FILE      *f;     f = fopen( filename, "r" );     if (!f) {          D_DEBUG( "FusionSound/Config: "                   "Unable to open config file `%s'!/n", filename );          return DR_IO;     } else {          D_INFO( "FusionSound/Config: "                  "Parsing config file '%s'./n", filename );     }     while (fgets( line, 400, f )) {          char *name  = line;          char *value = strchr( line, '=' );          if (value) {               *value++ = 0;               direct_trim( &value );          }          direct_trim( &name );          if (!*name || *name == '#')               continue;          ret = fs_config_set( name, value );          if (ret) {               if (ret == DR_UNSUPPORTED)                    D_ERROR( "FusionSound/Config: In config file `%s': "                             "Invalid option `%s'!/n", filename, name );               break;          }     }     fclose( f );     return ret;}

// "ouvre" le device et commnce à le préparer :static DFBResult driver_open_device(CoreInputDevice *device,          unsigned int number,          InputDeviceInfo *info,          void **driver_data){     int fd;     ZytData *data;     /* open device */     fd = ZytOpenDevice (dfb_config->zytronic_device);     D_INFO("ZYT, driver_open_device %s fd %d/n", dfb_config->zytronic_device,fd);     if (fd < 0) {          return DFB_INIT;     }     ZytActivateDevice(fd); //on configure le controleur pour fonctionner en mode normal     data = D_CALLOC (1, sizeof(ZytData));     data->fd     = fd;     data->device = device;     /* fill device info structure */     snprintf(info->desc.name, DFB_INPUT_DEVICE_DESC_NAME_LENGTH,               "Zypos");     snprintf(info->desc.vendor, DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH,               "Zytronic");     info->prefered_id     = DIDID_MOUSE;     info->desc.type       = DIDTF_MOUSE;     info->desc.caps       = DICAPS_AXES | DICAPS_BUTTONS;     info->desc.max_axis   = DIAI_Y;     info->desc.max_button = DIBI_LEFT;     /* start input thread */     data->thread = direct_thread_create (DTT_INPUT, ZytronicEventThread, data, "Zytronic Input");     /* set private data pointer */     *driver_data = data;     return DFB_OK;}

static voidhandle_disconnect( VoodooManager *manager ){     D_MAGIC_ASSERT( manager, VoodooManager );     if (0) {          int       num;          long long millis = direct_clock_get_millis();          long long diff   = millis - manager->millis;          num = manager->msg_count * 1000LL / diff;          D_INFO( "Voodoo/Manager: Average number of messages: %d.%03d k/sec/n", num / 1000, num % 1000 );     }     D_DEBUG( "Voodoo/Manager: Remote site disconnected from manager at %p!/n", manager );     voodoo_manager_quit( manager );}

voidVoodooConnection::SetupTime(){     DirectResult           ret;     VoodooResponseMessage *response;     long long              t1, t2;     D_DEBUG_AT( Voodoo_Connection, "VoodooConnection::%s( %p )/n", __func__, this );     D_MAGIC_ASSERT( this, VoodooConnection );     t1 = direct_clock_get_time( DIRECT_CLOCK_MONOTONIC );     ret = manager->do_request( manager->remote_time_service_id, 0, VREQ_RESPOND, &response );     if (ret) {          D_DERROR( ret, "Voodoo/Connection: Failed to call TimeService!/n" );          return;     }     t2 = direct_clock_get_time( DIRECT_CLOCK_MONOTONIC );     VoodooMessageParser parser;     unsigned int        high, low;     long long           micros;     VOODOO_PARSER_BEGIN( parser, response );     VOODOO_PARSER_GET_UINT( parser, high );     VOODOO_PARSER_GET_UINT( parser, low );     VOODOO_PARSER_END( parser );     micros = (long long) (((unsigned long long) high << 32) | low);     delay     = t2 - t1;     time_diff = micros - t1 - delay / 2;     D_INFO( "Voodoo/Connection: Delay %lld us, time difference to remote is %lld us/n", delay, time_diff );     manager->finish_request( response );}

DirectResultfusion_ref_up (FusionRef *ref, bool global){     D_ASSERT( ref != NULL );     D_DEBUG_AT( Fusion_Ref, "fusion_ref_up( %p [%d]%s )/n", ref, ref->multi.id, global ? " GLOBAL" : "" );     if (ref->multi.id == fusion_config->trace_ref) {          D_INFO( "Fusion/Ref: 0x%08x up (%s)/n", ref->multi.id, global ? "global" : "local" );          direct_trace_print_stack( NULL );     }     while (ioctl (_fusion_fd( ref->multi.shared ), global ?                   FUSION_REF_UP_GLOBAL : FUSION_REF_UP, &ref->multi.id))     {          switch (errno) {               case EINTR:                    continue;               case EAGAIN:                    return DR_LOCKED;               case EINVAL:                    D_ERROR ("Fusion/Reference: invalid reference/n");                    return DR_DESTROYED;               default:                    break;          }          if (global)               D_PERROR ("FUSION_REF_UP_GLOBAL");          else               D_PERROR ("FUSION_REF_UP");          return DR_FAILURE;     }     D_DEBUG_AT( Fusion_Ref, "  -> %d references now/n",                 ioctl( _fusion_fd( ref->multi.shared ), FUSION_REF_STAT, &ref->multi.id ) );     return DR_OK;}

DirectResultvoodoo_client_destroy( VoodooClient *client ){     D_ASSERT( client != NULL );     D_DEBUG_AT( Voodoo_Client, "%s( %p )/n", __FUNCTION__, client );     D_INFO( "Voodoo/Client: Decreasing ref count of connection.../n" );     if (! --(client->refs)) {          voodoo_manager_destroy( client->manager );          //client->vl.Close( &client->vl );          direct_list_remove( &m_clients, &client->link );          D_FREE( client->host );          D_FREE( client );     }     return DR_OK;}

static DFBResultTest_Simple( IWater *water, IDirectFBSurface *surface ){     WaterScalar test_rect[4] = {{ 130 },{ 190 },{ 400 },{ 200 }};     D_INFO( "Tests/Water: Testing SetAttribute( COLOR ) and RenderElement( RECTANGLE ).../n" );     WaterAttributeHeader attribute;     WaterElementHeader   element;     WaterColor           fill_color = { 0xff, 0x20, 0x80, 0xff };     WaterColor           draw_color = { 0xff, 0xf8, 0xf4, 0xd8 };     /*      * Set the fill color via SetAttribute()      */     attribute.type  = WAT_FILL_COLOR;     attribute.flags = WAF_NONE;     _T( water->SetAttribute( water, &attribute, &fill_color ) );     /*      * Set the draw color via SetAttribute()      */     attribute.type  = WAT_DRAW_COLOR;     attribute.flags = WAF_NONE;     _T( water->SetAttribute( water, &attribute, &draw_color ) );     /*      * Render a rectangle via RenderElement()      */     element.type   = WET_RECTANGLE;     element.flags  = WEF_FILL | WEF_DRAW;     element.scalar = WST_INTEGER;     _T( water->RenderElement( water, surface, &element, test_rect, 4 ) );     return DFB_OK;}

intmain( int argc, char *argv[] ){     DirectResult     ret;     VoodooTestServer test = {0};     ret = voodoo_server_create( "127.0.0.1", 23456, false, &test.server );     if (ret) {          D_DERROR( ret, "voodoo_server_create() failed!/n" );          return ret;     }     voodoo_server_register( test.server, "VoodooTest", VoodooTestConstruct, &test /* context pointer */ );     D_INFO( "Voodoo/Test: Running server.../n" );     voodoo_server_run( test.server );     voodoo_server_destroy( test.server );     return 0;}

static DFBResultInitPVR2D( PVR2DData *pvr2d ){     PVR2DERROR       ePVR2DStatus;     PVR2DDataShared *shared = pvr2d->shared;     pvr2d->nDevices = PVR2DEnumerateDevices(0);     pvr2d->pDevInfo = (PVR2DDEVICEINFO *) malloc(pvr2d->nDevices * sizeof(PVR2DDEVICEINFO));     PVR2DEnumerateDevices(pvr2d->pDevInfo);     pvr2d->nDeviceNum = pvr2d->pDevInfo[0].ulDevID;     ePVR2DStatus = PVR2DCreateDeviceContext (pvr2d->nDeviceNum, &pvr2d->hPVR2DContext, 0);     if (ePVR2DStatus) {          D_ERROR( "DirectFB/PVR2D: PVR2DCreateDeviceContext() failed! (status %d)/n", ePVR2DStatus );          return DFB_INIT;     }     ePVR2DStatus = PVR2DGetFrameBuffer( pvr2d->hPVR2DContext, PVR2D_FB_PRIMARY_SURFACE, &pvr2d->pFBMemInfo);     if (ePVR2DStatus) {          D_ERROR( "DirectFB/PVR2D: PVR2DGetFrameBuffer() failed! (status %d)/n", ePVR2DStatus );          return DFB_INIT;     }     ePVR2DStatus = PVR2DGetScreenMode(pvr2d->hPVR2DContext, &pvr2d->eDisplayFormat, &pvr2d->lDisplayWidth, &pvr2d->lDisplayHeight, &pvr2d->lStride, &pvr2d->RefreshRate);     if (ePVR2DStatus) {          D_ERROR( "DirectFB/PVR2D: PVR2DGetScreenMode() failed! (status %d)/n", ePVR2DStatus );          return DFB_INIT;     }     D_INFO( "DirectFB/PVR2D: Display %ldx%ld, format %d, stride %ld, refresh %d/n",             pvr2d->lDisplayWidth, pvr2d->lDisplayHeight, pvr2d->eDisplayFormat, pvr2d->lStride, pvr2d->RefreshRate );     shared->screen_size.w = pvr2d->lDisplayWidth;     shared->screen_size.h = pvr2d->lDisplayHeight;     return DFB_OK;}

void shjpeg_veu_set_dst_jpu(shjpeg_internal_t *data){#ifdef SHJPEG_DEBUG    u32 vdayr = shjpeg_veu_getreg32(data, VEU_VDAYR);    u32 vdacr = shjpeg_veu_getreg32(data, VEU_VDACR);#endif			        shjpeg_veu_setreg32(data, VEU_VDAYR,			(data->veu_linebuf) ?			shjpeg_jpu_getreg32(data, JPU_JIFESYA2) :			shjpeg_jpu_getreg32(data, JPU_JIFESYA1));    shjpeg_veu_setreg32(data, VEU_VDACR,			(data->veu_linebuf) ?			shjpeg_jpu_getreg32(data, JPU_JIFESCA2) :			shjpeg_jpu_getreg32(data, JPU_JIFESCA1));    #ifdef SHJPEG_DEBUG    D_INFO("		-> SWAP, "	   "VEU_VSAYR = %08x (%08x->%08x, %08x->%08x)",	   shjpeg_veu_getreg32(data, VEU_VSAYR), vdayr,	   shjpeg_veu_getreg32(data, VEU_VDAYR), vdacr,	   shjpeg_veu_getreg32(data, VEU_VDACR));#endif}

// Remove all input translations over tty serial controller.//// set=1:  Saves current settings then turns rawmode on.// set=0:  Restores controller to previous saved value.//static void tty_rawmode(int fd, int set){  static struct termio tbuf, termio_save;  int ret;  if(set) {    ioctl(fd, TCGETA, &termio_save);    tbuf=termio_save;    /* For complete explanation of the flags set/unset below, see termios(3)       unix programmers reference manual. */    tbuf.c_iflag = 0; /* No input processing */    tbuf.c_oflag = 0; /* No output processing */    tbuf.c_lflag = 0; /* Disable erase/kill, signals, and echo */    tbuf.c_cflag = B9600|CS8|CLOCAL|CREAD;  /* Set baud & 1-char read mode */    ret = ioctl(fd, TCSETAF, &tbuf);    D_INFO("Elo:tty_rawmode ioctl= %d/n",ret);  } else    ioctl(fd, TCSETAF, &termio_save);}

int init_hotplug(){	printf("/n/033[34m<<<<init_hotplug/033[0m/n");	/* check if the internal, i.e. non-removable storage was mounted */	if ((check_mnt_point(INT_STOR) == 0) && (read_dev_properties(INT_STOR, &prop_i_stor) == 0))		s_status |= ISTORAGE_PRESENT;	/* check if an external, i.e. removable storage was already mounted */	if ((check_mnt_point(EXT_STOR) == 0) && (read_dev_properties(EXT_STOR, &prop_e_stor) == 0))		s_status |= ESTORAGE_ADDED;	if (s_status == STORAGE_NONE)		D_WARN("init_hotplug: No internal OR external storage mounted./n");		if (open_fifo() == -1)	{		D_WARN("init_hotplug: open_fifo() failed. Hotplug messages will not be received./n");		return -1;	}	D_INFO("Hotplug handler initialized./n");	return 0;}

intmain( int argc, char *argv[] ){     DirectClock clock;     int         counter = 0;     int         res;     (void)res;     /* Initialize libdirect. */     direct_initialize();//     direct_config->log_level = DIRECT_LOG_ALL;     direct_log_domain_config_level( "Voodoo/Input", DIRECT_LOG_DEBUG_9 );     direct_log_domain_config_level( "Voodoo/Output", DIRECT_LOG_DEBUG_9 );     direct_log_domain_config_level( "Voodoo/Dispatch", DIRECT_LOG_DEBUG_9 );     direct_log_domain_config_level( "Voodoo/Manager", DIRECT_LOG_DEBUG_9 );     int               pipe_1[2];     int               pipe_2[2];//     int               socket[2];     int               fds_server[2];     int               fds_client[2];     VoodooLink        voodoo_link_server;     VoodooLink        voodoo_link_client;     VoodooManager    *manager_server;     VoodooManager    *manager_client;     VoodooInstanceID  instance;//     socketpair( PF_LOCAL, SOCK_STREAM, 0, fd );     res = pipe( pipe_1 );     res = pipe( pipe_2 );     fds_server[0] = pipe_1[0];     fds_server[1] = pipe_2[1];     fds_client[0] = pipe_2[0];     fds_client[1] = pipe_1[1];     voodoo_link_init_fd( &voodoo_link_server, fds_server );     voodoo_manager_create( &voodoo_link_server, NULL, NULL, &manager_server );     voodoo_manager_register_local( manager_server, VOODOO_INSTANCE_NONE, NULL, NULL, Dispatch, &instance );     voodoo_link_init_fd( &voodoo_link_client, fds_client );     voodoo_manager_create( &voodoo_link_client, NULL, NULL, &manager_client );     direct_clock_start( &clock );#if !BENCH_SYNC     do {          voodoo_manager_request( manager_client, instance,                                  VOODOOTEST_METHOD_ID_Push, VREQ_NONE, NULL,                                  VMBT_INT, counter++,                                  VMBT_NONE );     } while (counter < NUM_ITEMS);#else     do {          VoodooResponseMessage *response;          voodoo_manager_request( manager_client, instance,                                  VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,                                  VMBT_NONE );          voodoo_manager_finish_request( manager_client, response );          counter++;     } while (counter < NUM_ITEMS);#endif     {          VoodooResponseMessage *response;          voodoo_manager_request( manager_client, instance,                                  VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,                                  VMBT_NONE );          voodoo_manager_finish_request( manager_client, response );     }     direct_clock_stop( &clock );     D_INFO( "Voodoo/Test: Stopped after %lld.%03lld seconds... (%lld items/sec)/n",             DIRECT_CLOCK_DIFF_SEC_MS( &clock ), NUM_ITEMS * 1000000ULL / direct_clock_diff( &clock ) );     /* Shutdown libdirect. */     direct_shutdown();     return 0;}