コード例 #1
0
ファイル: util.c プロジェクト: 453483289/rekall
// Allocates a pmem_OSBuffer instance of 'size' and 'tag'.
// Returns 0 on failure.
pmem_OSBuffer *pmem_alloc(uint32_t size, OSMallocTag_t tag) {
    pmem_OSBuffer *buffer = (pmem_OSBuffer *)OSMalloc(sizeof(pmem_OSBuffer),
                                                      tag);
    if (!buffer) {
        goto error;
    }

    bzero(buffer, sizeof(pmem_OSBuffer));
    buffer->size = size;
    buffer->tag = tag;
    buffer->buffer = (char *)OSMalloc(size, tag);

    if (!buffer->buffer) {
        goto error;
    }

    bzero(buffer->buffer, buffer->size);

    return buffer;

error:
    if (buffer) {
        OSFree(buffer, sizeof(pmem_OSBuffer), tag);
    }

    return 0;
}
コード例 #2
0
ファイル: ANControlList.c プロジェクト: unixpickle/nethook
__private_extern__ ANPacketInfo * ANControlListEntryGetPacket(OSMallocTag tag, ANControlListEntry * entry) {
    if (entry->bufferLength < 8) return NULL;
    uint32_t length = ((uint32_t *)entry->packetBuffer)[1];
    if (length > entry->bufferLength) return NULL;
    
    // allocate the packet and copy the buffer into it
    ANPacketInfo * info = (ANPacketInfo *)OSMalloc(length, tag);
    if (!info) return NULL;
    memcpy(info, entry->packetBuffer, length);
    
    // move the remaining data back in the buffer
    if (length == entry->bufferLength) {
        // we used up the entire buffer
        OSFree(entry->packetBuffer, entry->bufferLength, tag);
        entry->packetBuffer = NULL;
        entry->bufferLength = 0;
    } else {
        uint32_t newLength = entry->bufferLength - length;
        char * newBuffer = (char *)OSMalloc(newLength, tag);
        if (newBuffer) {
            memcpy(newBuffer, &entry->packetBuffer[length], newLength);            
            OSFree(entry->packetBuffer, entry->bufferLength, tag);
            entry->packetBuffer = newBuffer;
            entry->bufferLength = newLength;
        } else {
            OSFree(entry->packetBuffer, entry->bufferLength, tag);
            entry->packetBuffer = 0;
            entry->bufferLength = 0;
        }
    }
    return info;
}
コード例 #3
0
ファイル: TaskAperio.c プロジェクト: beber007/zottaos
int main(void)
{
  ButtonDescriptorDef *buttonDescriptor;
  TaskParametersDef *taskParameters;
  void *event;

  WDTCTL = WDTPW + WDTHOLD;  // Disable watchdog timer

  /* Set the system clock characteristics */
  OSInitializeSystemClocks();

  // Initialize output I/O ports
  P1OUT = 0x00;   // Initially start at low
  P1DIR = 0x03;   // Set to output
  P4OUT |= 0x3;
  P4REN |= 0x3;
  P4IES |= 0x3;
  P4IFG &= ~0x3;
  P4IE |= 0x3;

  #if defined(ZOTTAOS_VERSION_HARD)
     event = OSCreateEventDescriptor();
     // Register button P4.0 interrupt
     buttonDescriptor = (ButtonDescriptorDef *)OSMalloc(sizeof(ButtonDescriptorDef));
     buttonDescriptor->ButtonInterruptHandler = ButtonISR;
     buttonDescriptor->event = event;
     OSSetISRDescriptor(OS_IO_PORT4_0,buttonDescriptor);
     // Create the first event-driven task
     taskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     taskParameters->Delay = 1000;      // Impulse width to visualize the task execution
     taskParameters->Flag_Pin = BIT0;
     taskParameters->Button_Pin = BIT0;
     taskParameters->event = event;     // Needed to reschedule itself
     OSCreateSynchronousTask(ButtonTask,10000,event,taskParameters);
     // Register button P4.1 interrupt
     event = OSCreateEventDescriptor();
     buttonDescriptor = (ButtonDescriptorDef *)OSMalloc(sizeof(ButtonDescriptorDef));
     buttonDescriptor->ButtonInterruptHandler = ButtonISR;
     buttonDescriptor->event = event;
     OSSetISRDescriptor(OS_IO_PORT4_1,buttonDescriptor);
     // Create the second event-driven task that
     taskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     taskParameters->Delay = 2000;
     taskParameters->Flag_Pin = BIT1;
     taskParameters->Button_Pin = BIT1;
     taskParameters->event = event;
     OSCreateSynchronousTask(ButtonTask,20000,event,taskParameters);
  #elif defined(ZOTTAOS_VERSION_SOFT)
     #error Untested
  #else
     #error Wrong kernel version
  #endif  

  /* Start the OS so that it starts scheduling the user tasks */
  return OSStartMultitasking(NULL,NULL);
} /* end of main */
コード例 #4
0
ファイル: helpers.c プロジェクト: certego/limacharlie
void*
    rpal_memory_alloc
    (
        uint32_t size
    )
{
    void* ptr = NULL;
    unsigned char* realPtr = NULL;
    
    if( 0 == g_mem_tag )
    {
        g_mem_tag = OSMalloc_Tagalloc( "hcp_hbs_acq", 0 );
    }
    
    size += sizeof( uint32_t );
    
    realPtr = OSMalloc( size, g_mem_tag );
    
    if( NULL != realPtr )
    {
        *(uint32_t*)realPtr = size;
        ptr = realPtr + sizeof( uint32_t );
    }
    
    return ptr;
}
コード例 #5
0
ファイル: ANControlList.c プロジェクト: unixpickle/nethook
__private_extern__ ANControlList * ANControlListCreate(OSMallocTag tag) {
    ANControlList * list = (ANControlList *)OSMalloc(sizeof(ANControlList), tag);
    if (!list) return NULL;
    bzero(list, sizeof(ANControlList));
    list->tag = tag;
    return list;
}
コード例 #6
0
ファイル: meta.cpp プロジェクト: 453483289/rekall
// Resize 'meta' to have at least 'min_room' of bytes at the end. This will
// deallocate the old meta struct, so 'metaret' will change to point to the new
// buffer.
//
// Arguments:
//   metaret: The meta struct to resize. Will change to point to new struct.
//   min_room: The new struct will have at least this much room, but probably
//           more.
//
// Returns:
//   KERN_SUCCESS or KERN_FAILURE. On KERN_FAILURE the old struct MAY still be
//   valid; if so, the pointer will not be updated.
static kern_return_t pmem_metaresize(pmem_meta_t **metaret, uint32_t min_room) {
    pmem_meta_t *meta = *metaret;
    uint32_t min_size = meta->size + min_room;

    if (min_size < meta->size || meta->size > UINT32_MAX / 2) {
        pmem_error("32 bit int overflow detected - meta struct is too big.");
        return KERN_FAILURE;
    }

    if (min_size < meta->size * 2) {
        min_size = meta->size * 2;
    }

    pmem_meta_t *newmeta = (pmem_meta_t *)OSMalloc(min_size, pmem_alloc_tag);
    if (!newmeta) {
        return KERN_FAILURE;
    }

    pmem_debug(("Meta struct %p of size %u has been resized and is now %p "
                "of size %u"),
               meta, meta->size, newmeta, min_size);

    memcpy(newmeta, meta, meta->size);
    pmem_metafree(meta);
    newmeta->size = min_size;
    *metaret = newmeta;

    return KERN_SUCCESS;
}
コード例 #7
0
ファイル: GPSWrapper.c プロジェクト: S0043640wipro/RiCRiPInt
/***********************************************************************************************************
*Function Name: GPS_BinInfo()
*Attributes:
*client  IN   Client identifier
*num     IN Number of bininfo[] array. Set the number of output bins obtained by gpsGetSysInfo().
*bininfo OUT Output Bin Information Structure
*bininfo_num OUT Returns the number of bins set to bininfo[] array.
*notify  IN Enable/disable receiving an event whenever there is a change in the information.
*Description: This function obtains output bin information.
************************************************************************************************************/
int GPS_BinInfo()
{
  long binInfo;
  int nTrayIndex;
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  gpsBinInfo = (gps_bininfo_t*) OSMalloc(sysinfo.num_bin * sizeof(gps_bininfo_t), PMS_MemoryPoolPMS);
  g_pstOutputInfo = (PMS_TyOutputInfo*) OSMalloc(sysinfo.num_bin * sizeof(PMS_TyOutputInfo), PMS_MemoryPoolPMS);
#else
  gpsBinInfo = (gps_bininfo_t*) mmalloc(sysinfo.num_bin * sizeof(gps_bininfo_t));
  g_pstOutputInfo = (PMS_TyOutputInfo*) mmalloc(sysinfo.num_bin * sizeof(PMS_TyOutputInfo));
#endif

  if( -1 == gpsGetBinInfo(gps_client, sysinfo.num_bin, gpsBinInfo, &binInfo, GPS_NOTIFY_CHANGE_OFF) )
    return -1;
  
  /* To do - Map SDK str from GPS Specification DB - 01.pdf  : page no 40	*/
  /* gpsGetTrayInfo - page no 200	*/
  
  for(nTrayIndex = 0; nTrayIndex < binInfo; nTrayIndex++)
  {
    /*g_pstOutputInfo[nTrayIndex].eOutputTray = gpsBinInfo[nTrayIndex].id;	*/
	switch (gpsBinInfo[nTrayIndex].id)
	{
	  case 1:
	  case 2:
	  case 3:
	    g_pstOutputInfo[nTrayIndex].eOutputTray = gpsBinInfo[nTrayIndex].id;
	    break;
	  default:
	    g_pstOutputInfo[nTrayIndex].eOutputTray = PMS_OUTPUT_TRAY_AUTO;
	    break;
      /* yet to map  PMS_OUTPUT_TRAY_UPPER, PMS_OUTPUT_TRAY_LOWER, PMS_OUTPUT_TRAY_EXTRA	*/
	}
    g_pstOutputInfo[nTrayIndex].nPriority = nTrayIndex;	/*assumption yet to conform. 	*/
	
  }

  g_nOutputTrays = sysinfo.num_bin;
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  OSFree( gpsBinInfo, PMS_MemoryPoolPMS );
#else
  mfree( gpsBinInfo );
#endif
  gpsBinInfo = NULL;
  
  return 0;
}
コード例 #8
0
ファイル: pmem.cpp プロジェクト: KarlVogel/rekall
// Driver entry point. Initializes globals and registers driver node in /dev.
kern_return_t pmem_start(kmod_info_t * ki, void *d) {
  int error = 0;

  pmem_log("Loading /dev/%s driver", pmem_pmem_devname);
  // Memory allocations are tagged to prevent leaks
  pmem_tag = OSMalloc_Tagalloc(pmem_tagname, OSMT_DEFAULT);
  // Allocate one page for zero padding of illegal read requests
  pmem_zero_page = static_cast<uint8_t *>(OSMalloc(PAGE_SIZE, pmem_tag));
  if (pmem_zero_page == NULL) {
    pmem_error("Failed to allocate memory for page buffer");
    return pmem_cleanup(KERN_FAILURE);
  }
  bzero(pmem_zero_page, PAGE_SIZE);
  // Access the boot arguments through the platform export,
  // and parse the systems physical memory configuration.
  boot_args * ba = reinterpret_cast<boot_args *>(PE_state.bootArgs);
  pmem_physmem_size = ba->PhysicalMemorySize;
  pmem_mmap = reinterpret_cast<EfiMemoryRange *>(ba->MemoryMap +
                                                 pmem_kernel_voffset);
  pmem_mmap_desc_size = ba->MemoryMapDescriptorSize;
  pmem_mmap_size = ba->MemoryMapSize;
  pmem_log("Size of physical memory:%lld", pmem_physmem_size);
  pmem_log("Size of physical pages:%d (PAGE_SHIFT=%d, PAGE_MASK=%#016x)",
           PAGE_SIZE, PAGE_SHIFT, PAGE_MASK);
  pmem_log("Phys. Memory map at:%#016llx (size:%lld desc_size:%d)",
           pmem_mmap, pmem_mmap_size, pmem_mmap_desc_size);
  pmem_log("Number of segments in memory map: %d",
           pmem_mmap_size / pmem_mmap_desc_size);
  // Install switch table
  pmem_devmajor = cdevsw_add(-1, &pmem_cdevsw);
  if (pmem_devmajor == -1) {
    pmem_error("Failed to create character device");
    return pmem_cleanup(KERN_FAILURE);
  }
  // Create physical memory device file
  pmem_log("Adding node /dev/%s", pmem_pmem_devname);
  pmem_devpmemnode = devfs_make_node(makedev(pmem_devmajor,
                                             pmem_dev_pmem_minor),
                                     DEVFS_CHAR,
                                     UID_ROOT,
                                     GID_WHEEL,
                                     0660,
                                     pmem_pmem_devname);
  if (pmem_devpmemnode == NULL) {
    pmem_error("Failed to create /dev/%s node", pmem_pmem_devname);
    return pmem_cleanup(KERN_FAILURE);
  }
  pmem_log("obtaining kernel dtb pointer");
  __asm__ __volatile__("movq %%cr3, %0" :"=r"(pmem_dtb));
  // Only bits 51-12 (inclusive) in cr3 are part of the dtb pointer
  pmem_dtb &= ~PAGE_MASK;
  pmem_log("kernel dtb: %#016llx", pmem_dtb);
  pmem_log("initializing pte_mmap module");
  pmem_log("pmem driver loaded, physical memory available in /dev/%s",
           pmem_pmem_devname);

  return error;
}
コード例 #9
0
ファイル: ANControlList.c プロジェクト: unixpickle/nethook
__private_extern__ ANControlListEntry * ANControlListEntryCreate(OSMallocTag tag, uint32_t unit, kern_ctl_ref ctlref) {
    ANControlListEntry * entry = (ANControlListEntry *)OSMalloc(sizeof(ANControlListEntry), tag);
    if (!entry) return NULL;
    bzero(entry, sizeof(ANControlListEntry));
    entry->unit = unit;
    entry->ctlref = ctlref;
    entry->connected = TRUE;
    return entry;
}
コード例 #10
0
/*! \brief Create a semaphore
 *
 * UNIX/Linux
 *
 * Semaphore is casted to \c void* for platform portability.
 *
 * \param[in] initialValue Initial semaphore value.
 * \return Pointer to semaphore created (casted to \c void*).
*/
void * PMS_CreateSemaphore(int initialValue)
{
#ifdef MACOSX
  mac_sema_desc_t *sem;
  /* Mac OS X returns a failure for sem_init, so we have to use sem_open
     instead. sem_open requires a name, so we will invent one. */
  char name[SEM_NAME_LEN];
  sem_t *ossem;

  if ( (sem = OSMalloc(sizeof(mac_sema_desc_t), PMS_MemoryPoolPMS)) == NULL )
    return NULL;
  do {
    sprintf(name, "pms-%d-%d", getpid(), ++semno) ;
    if ( (ossem = sem_open(name, O_CREAT | O_EXCL, 0777, initialValue))
         == (sem_t *)SEM_FAILED )
      semno += 100; /* try to avoid other semaphores from the same crash */
  } while (ossem == (sem_t *)SEM_FAILED && errno == EEXIST);
  if (ossem == (sem_t *)SEM_FAILED) {
    OSFree(sem, PMS_MemoryPoolPMS);
    return NULL;
  }
  sem->sem = ossem; sem->semno = semno;
  sem_count++;
#else
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  sem_t *sem;

  sem = (sem_t *) OSMalloc(sizeof(sem_t), PMS_MemoryPoolPMS);

  if (sem == NULL)
    return NULL;
#else
  sem_t sem[16];
#endif
  if (sem_init(sem, 0, initialValue)) {
#ifdef PMS_OIL_MERGE_DISABLE_MEM
    OSFree(sem, PMS_MemoryPoolPMS);
#endif
    return NULL;
  }
#endif
  return (void*)sem;
}
コード例 #11
0
/*! \brief Start a new thread.
 *
 * UNIX/Linux
 *
 * \param start_address Funtion pointer to the threads entry point.
 * \param stack_size Size of stack to use, in bytes.
 * \param arglist Pointer to argument list.
 * \return Pointer to thread (casted to void * for platform portability)
 *
*/
void *PMS_BeginThread(void( *start_address )( void * ), unsigned int stack_size, void *arglist )
{
  pthread_attr_t attr;
  unsigned int result;
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  PMS_TyThreadFunction *ptThreadInfo = OSMalloc(sizeof(PMS_TyThreadFunction), PMS_MemoryPoolPMS);
#else
  PMS_TyThreadFunction *ptThreadInfo = mmalloc(sizeof(PMS_TyThreadFunction));
#endif

  if(!ptThreadInfo) {
    return (NULL);
  }

  ptThreadInfo->bCondBroadcasted = 0;

  if ( pthread_mutex_init(&ptThreadInfo->mutexThread, NULL) != 0 ) {
    goto thread_info_destroy;
  }

  if ( pthread_cond_init(&ptThreadInfo->condThread, NULL) != 0 ) {
    goto thread_mutex_destroy;
  }

  if (pthread_attr_init(&attr)) {
    goto thread_cond_destroy;
  }

  ptThreadInfo->start_routine = start_address;
  ptThreadInfo->arg = arglist;
  result = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) ||
           pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) ||
           pthread_create(&ptThreadInfo->tid, &attr, PMSThreadWrapper, (void*)ptThreadInfo);

  (void)pthread_attr_destroy(&attr) ;

  if (result != 0) {
    PMS_SHOW_ERROR("Failed to create thread: \n");
    goto thread_cond_destroy;
  }

  return (void*)ptThreadInfo;

thread_cond_destroy:
  (void)pthread_cond_destroy(&ptThreadInfo->condThread) ;
thread_mutex_destroy:
  (void)pthread_mutex_destroy(&ptThreadInfo->mutexThread) ;
thread_info_destroy:
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  OSFree(ptThreadInfo, PMS_MemoryPoolPMS);
#else
  mfree(ptThreadInfo);
#endif
  return (NULL);
}
コード例 #12
0
static
errno_t ppfilter_attach(void **cookie, socket_t so)
{
    pp_filter_cookie_t cp = OSMalloc(sizeof(*cp), pp_malloc_tag);
    if (cp) {
        cp->pid = proc_selfpid();
        cp->action = COOKIE_NO_ACTION;
    }
    *cookie = (void*)cp;
    return (0);
}
コード例 #13
0
ファイル: if_ipsec.c プロジェクト: Apple-FOSS-Mirror/xnu
/* Prepend length */
static void*
ipsec_alloc(size_t size)
{
	size_t	*mem = OSMalloc(size + sizeof(size_t), ipsec_malloc_tag);
	
	if (mem) {
		*mem = size + sizeof(size_t);
		mem++;
	}
	
	return (void*)mem;
}
コード例 #14
0
ファイル: if_utun.c プロジェクト: Bitesher/xnu
/* Prepend length */
void*
utun_alloc(size_t size)
{
	size_t	*mem = OSMalloc(size + sizeof(size_t), utun_malloc_tag);
	
	if (mem) {
		*mem = size + sizeof(size_t);
		mem++;
	}
	
	return (void*)mem;
}
コード例 #15
0
ファイル: meta.cpp プロジェクト: 453483289/rekall
// Make a new meta struct.
static pmem_meta_t *pmem_metaalloc() {
    uint32_t required_size = (uint32_t)sizeof(pmem_meta_t);
    pmem_meta_t *meta = (pmem_meta_t *)OSMalloc(required_size, pmem_alloc_tag);
    if (!meta) {
        return nullptr;
    }

    bzero(meta, required_size);

    meta->pmem_api_version = PMEM_API_VERSION;
    meta->records_offset = __offsetof(pmem_meta_t, records);
    meta->size = required_size;

    return meta;
}
コード例 #16
0
/**
 * \brief Fill Tray Information.
 *
 * This routine simulates sensing of page attributes from available media sources.  \n
 */
int EngineGetTrayInfo(void)
{
  int nTrayIndex;

  /* query engine and fill in information about available attributes 
   * NOTE - maximum of 10 trays
  */
  g_pstTrayInfo = (PMS_TyTrayInfo *) OSMalloc( NUMFIXEDMEDIASOURCES * sizeof(PMS_TyTrayInfo), PMS_MemoryPoolPMS );
  nTrayIndex = 0;

  if( g_pstTrayInfo != NULL )
  {
    g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_MANUALFEED;
    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A4;
    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].eMediaColor = PMS_COLOR_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].uMediaWeight = 0;
    g_pstTrayInfo[nTrayIndex].nPriority = 1;
    g_pstTrayInfo[nTrayIndex].bTrayEmptyFlag = FALSE;
    g_pstTrayInfo[nTrayIndex].nNoOfSheets = 200;
    nTrayIndex++;

    g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_TRAY1;
    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A4_R;
    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].eMediaColor = PMS_COLOR_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].uMediaWeight = 0;
    g_pstTrayInfo[nTrayIndex].nPriority = 2;
    g_pstTrayInfo[nTrayIndex].bTrayEmptyFlag = FALSE;
    g_pstTrayInfo[nTrayIndex].nNoOfSheets = 200;
    nTrayIndex++;

    g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_TRAY2;
    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LETTER;
    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].eMediaColor = PMS_COLOR_DONT_KNOW;
    g_pstTrayInfo[nTrayIndex].uMediaWeight = 0;
    g_pstTrayInfo[nTrayIndex].nPriority = 3;
    g_pstTrayInfo[nTrayIndex].bTrayEmptyFlag = FALSE;
    g_pstTrayInfo[nTrayIndex].nNoOfSheets = 200;
    nTrayIndex++;

    return nTrayIndex;
  }

  return 0;
}
コード例 #17
0
ファイル: ANControlList.c プロジェクト: unixpickle/nethook
__private_extern__ errno_t ANControlListEntryAppend(OSMallocTag tag, ANControlListEntry * entry, mbuf_t packet) {
    uint32_t packSize = (uint32_t)mbuf_len(packet);
    if (packSize == 0) return 0;
    
    uint32_t newSize = packSize + entry->bufferLength;
            
    char * buffer = (char *)OSMalloc(newSize, tag);
    if (!buffer) return ENOMEM;
    
    if (entry->packetBuffer) {
        // copy old data to the buffer
        memcpy(buffer, entry->packetBuffer, entry->bufferLength);
        OSFree(entry->packetBuffer, entry->bufferLength, tag);
    }
    
    mbuf_copydata(packet, 0, packSize, &buffer[entry->bufferLength]);
    entry->packetBuffer = buffer;
    entry->bufferLength = newSize;
    return 0;
}
コード例 #18
0
ファイル: util.c プロジェクト: 453483289/rekall
// Resizes 'buffer' to 'size', preserving old content.
// Size must be larger than current buffer->size.
// Works by allocating a larger buffer and using memcpy. After this call,
// old buffer->buffer will be invalid memory.
// On error, returns 0 and deallocates everything, so buffer will be invalid.
kern_return_t pmem_resize(pmem_OSBuffer *buffer, uint32_t size) {
    char *newbuf = 0;
    if (!buffer) {
        goto error;
    }

    if (size < buffer->size) {
        // We're already bigger. That's fine - nothing to do.
        return KERN_SUCCESS;
    }

    newbuf = (char *)OSMalloc(size, buffer->tag);
    if (!newbuf) {
        goto error;
    }
    bzero(newbuf, size);

    memcpy(newbuf, buffer->buffer, buffer->size);
    OSFree(buffer->buffer, buffer->size, buffer->tag);
    buffer->buffer = newbuf;
    buffer->size = size;

    return KERN_SUCCESS;

error:
    if (newbuf) {
        OSFree(newbuf, size, buffer->tag);
    }

    if (buffer) {
        if (buffer->buffer) {
            OSFree(buffer->buffer, buffer->size, buffer->tag);
        }
        OSFree(buffer, sizeof(pmem_OSBuffer), buffer->tag);
    }

    return KERN_FAILURE;
}
コード例 #19
0
ファイル: chipsec.cpp プロジェクト: abazhaniuk/chipsec
// Driver entry point. Initializes globals and registers driver node in /dev.
kern_return_t chipsec_start(kmod_info_t * ki, void *d) {
    int error = 0;

    pmem_log("Loading /dev/%s driver", chipsec_devname);
    // Memory allocations are tagged to prevent leaks
    pmem_tag = OSMalloc_Tagalloc(pmem_tagname, OSMT_DEFAULT);
    // Allocate one page for zero padding of illegal read requests
    pmem_zero_page = static_cast<uint8_t *>(OSMalloc(PAGE_SIZE, pmem_tag));
    if (pmem_zero_page == NULL) {
        pmem_error("Failed to allocate memory for page buffer");
        return pmem_cleanup(KERN_FAILURE);
    }
    bzero(pmem_zero_page, PAGE_SIZE);

    // Install the character device
    chipsec_dev_major = cdevsw_add(-1, &pmem_cdevsw);
    if (chipsec_dev_major == -1) {
        pmem_error("Failed to create character device");
        return pmem_cleanup(KERN_FAILURE);
    }
    // Create physical memory device file
    pmem_log("Adding node /dev/%s", chipsec_devname);
    pmem_devpmemnode = devfs_make_node(makedev(chipsec_dev_major,
                                               chipsec_dev_minor),
                                       DEVFS_CHAR,
                                       UID_ROOT,
                                       GID_WHEEL,
                                       0660,
                                       chipsec_devname);
    if (pmem_devpmemnode == NULL) {
        pmem_error("Failed to create /dev/%s node", chipsec_devname);
        return pmem_cleanup(KERN_FAILURE);
    }
    pmem_log("pmem driver loaded, physical memory available in /dev/%s",
             chipsec_devname);
    return error;
}
コード例 #20
0
/**
 * \brief Add an input module node to the linked list of input modules.
 *
 */
int Add_Input_Module( int (*pfnInitDataStream)(void),
		int (*pfnOpenDataStream)(void),
		int (*pfnCloseDataStream)(void),
		int (*pfnPeekDataStream)(unsigned char * buffer, int nBytesToRead),
		int (*pfnConsumeDataStream)(int nBytesToConsume),
		int (*pfnWriteDataStream)(unsigned char * pBuffer, int nBytesToWrite, int * pnBytesWritten)
		) 
{
	struct input_modules *pModuleNode;

	PMS_ASSERT(pfnOpenDataStream, ("Add_Input_Module: pfnOpenDataStream must be defined for all modules\n"));

#ifdef PMS_OIL_MERGE_DISABLE_MEM
	pModuleNode = OSMalloc(sizeof(struct input_modules), PMS_MemoryPoolPMS);
#else
	pModuleNode = mmalloc(sizeof(struct input_modules));
#endif
	if(!pModuleNode) {
		return FALSE;
	}
	pModuleNode->pNext = NULL;
	pModuleNode->tInput.pfnInitDataStream = pfnInitDataStream;
	pModuleNode->tInput.pfnOpenDataStream = pfnOpenDataStream;
	pModuleNode->tInput.pfnCloseDataStream = pfnCloseDataStream;
	pModuleNode->tInput.pfnPeekDataStream = pfnPeekDataStream;
	pModuleNode->tInput.pfnConsumeDataStream = pfnConsumeDataStream;
	pModuleNode->tInput.pfnWriteDataStream = pfnWriteDataStream;

	if(l_ptModulesTail == NULL) {
		l_ptModules = pModuleNode;
		l_ptModulesTail = pModuleNode;
	} else {
		l_ptModulesTail->pNext = pModuleNode;
		l_ptModulesTail = pModuleNode;
	}
	return TRUE;
}
コード例 #21
0
/**
 * \brief Fill Output Tray Information.
 *
 * This routine simulates sensing of page attributes from available media destinations.  \n
 */
int EngineGetOutputInfo(void)
{
  int nTrayIndex;

  /* query engine and fill in information about available attributes 
   * NOTE - maximum of 10 trays
  */
  g_pstOutputInfo = (PMS_TyOutputInfo *) OSMalloc( NUMFIXEDMEDIADESTS * sizeof(PMS_TyOutputInfo), PMS_MemoryPoolPMS );
  nTrayIndex = 0;

  if( g_pstOutputInfo != NULL )
  {
    g_pstOutputInfo[nTrayIndex].eOutputTray = PMS_OUTPUT_TRAY_UPPER;
    g_pstOutputInfo[nTrayIndex].nPriority = 1;
    nTrayIndex++;

    g_pstOutputInfo[nTrayIndex].eOutputTray = PMS_OUTPUT_TRAY_LOWER;
    g_pstOutputInfo[nTrayIndex].nPriority = 2;
    nTrayIndex++;
    return nTrayIndex;
  }

  return 0;
}
コード例 #22
0
ファイル: socketEvents.cpp プロジェクト: Delostik/LuLu
//called for new socket
// ->find rule, and attach entry (so know to allow/deny for later actions)
//   if no rule is found, that's ok (new proc), request user input in connect_out or sf_data_out, etc
static kern_return_t attach(void **cookie, socket_t so)
{
    //result
    kern_return_t result = kIOReturnError;
    
    //unset
    *cookie = NULL;
    
    //dbg msg
    IOLog("LULU: in %s\n", __FUNCTION__);
    
    //set cookie
    *cookie = (void*)OSMalloc(sizeof(struct cookieStruct), allocTag);
    if(NULL == *cookie)
    {
        //no memory
        result = ENOMEM;
        
        //bail
        goto bail;
    }
    
    //set rule action
    // not found, block, allow, etc
    ((struct cookieStruct*)(*cookie))->ruleAction = queryRule(proc_selfpid());
    
    //dbg msg
    IOLog("LULU: rule action for %d: %d\n", proc_selfpid(), ((struct cookieStruct*)(*cookie))->ruleAction);
    
    //happy
    result = kIOReturnSuccess;
    
bail:
    
    return result;
}
コード例 #23
0
ファイル: procfsnode.c プロジェクト: kimtopley/ProcFS
/*
 * Finds the procfsnode_t for a node with a given id and referencing a given structure node
 * on a given instance of the file system. If the node does not already exist, it is created, 
 * entered into the node has table and a vnode is created and attached to it. If the node already 
 * exists, it is returned along with its vnode. In both cases, the vnode has an additional iocount,
 * which the caller must remove at some point by calling vnode_put().
 *
 * Creation of a vnode cannot be performed by this function because the information required 
 * to initialize it is known only to the caller. The caller must supply a pointer to a function
 * that will create the vnode when required, along with an opaque context pointer that is passed
 * to the creation function, along with a pointer to the corresponding procfsnode_t. The creation
 * function must either create the vnode and link it to the procfsnode_t or return an error.
 *
 * The allocation of the procfsnode_t that is done here is reversed in the procfs_reclaim() function,
 * which is called when the node's associated vnode is being reclaimed.
 */
int
procfsnode_find(procfs_mount_t *pmp, procfsnode_id_t node_id, procfs_structure_node_t *snode,
                procfsnode_t **pnpp, vnode_t *vnpp,
                create_vnode_func create_vnode_func,
                void *create_vnode_params) {
    int error = 0;
    boolean_t locked = TRUE;
    procfsnode_t *target_procfsnode = NULL;     // This is the node that we will return.
    procfsnode_t *new_procfsnode = NULL;        // Newly allocated node. Will be freed if not used.
    vnode_t target_vnode = NULL;                // Start by assuming we will not get a vnode.
    int32_t mount_id = pmp->pmnt_id;            // File system id.
    
    // Lock the hash table. We'll keep this locked until we are done,
    // unless we need to allocate memory. In that case, we'll drop the
    // lock, but we'll have to revisit all of our assumptions when we
    // reacquire it, because another thread may have created the node
    // we are looking for.
    lck_mtx_lock(procfsnode_hash_mutex);
    
    boolean_t done = FALSE;
    while (!done) {
        assert(locked);
        error = 0;
        
        // Select the correct hash bucket and walk along it, looking for an existing
        // node with the correct attributes.
        int nodehash = HASH_FOR_MOUNT_AND_ID(mount_id, node_id);
        procfs_hash_head *hash_bucket = PROCFS_NODE_HASH_TO_BUCKET_HEADER(nodehash);
        LIST_FOREACH(target_procfsnode, hash_bucket, node_hash) {
            if (target_procfsnode->node_mnt_id == mount_id
                    && target_procfsnode->node_id.nodeid_pid == node_id.nodeid_pid
                    &&target_procfsnode->node_id.nodeid_objectid == node_id.nodeid_objectid
                    && target_procfsnode->node_id.nodeid_base_id == node_id.nodeid_base_id) {
                // Matched.
                break;
            }
        }
        
        // We got a match if target_procfsnode is not NULL.
        if (target_procfsnode == NULL) {
            // We did not find a match, so either allocate a new node or use the
            // one we created last time around this loop.
            if (new_procfsnode == NULL) {
                // We need to allocate a new node. Before doing that, unlock
                // the node hash, because the memory allocation may block.
                lck_mtx_unlock(procfsnode_hash_mutex);
                locked = FALSE;
                
                new_procfsnode = (procfsnode_t *)OSMalloc(sizeof(procfsnode_t), procfs_osmalloc_tag);
                if (new_procfsnode == NULL) {
                    // Allocation failure - bail. Nothing to clean up and
                    // we don't hold the lock.
                    error = ENOMEM;
                    break;
                }
                
                // We got a new procfsnode. Relock the node hash, then go around the
                // loop again. This is necessary because someone else may have created
                // the same node after we dropped the lock. If that's the case, we'll
                // find that node next time around and we'll use it. The one we just
                // allocated will remain in target_procfsnode and will be freed before we return.
                lck_mtx_lock(procfsnode_hash_mutex);
                locked = TRUE;
                continue;
            } else {
                // If we get here, we know that we need to use the node that we
                // allocated last time around the loop, so promote it to target_procfsnode
                assert(locked);
                assert(new_procfsnode != NULL);
                
                target_procfsnode = new_procfsnode;
                
                // Initialize the new node.
                memset(target_procfsnode, 0, sizeof(procfsnode_t));
                target_procfsnode->node_mnt_id = mount_id;
                target_procfsnode->node_id = node_id;
                target_procfsnode->node_structure_node = snode;
                
                // Add the node to the node hash. We already know which bucket
                // it belongs to.
                LIST_INSERT_HEAD(hash_bucket, target_procfsnode, node_hash);
            }
        }
        
        // At this point, we have a procfsnode_t, which either already existed
        // or was just created. We also have the lock for the node hash table.
        assert(target_procfsnode != NULL);
        assert(locked);
        
        // Check whether another thread is already in the process of creating a
        // vnode for this procfsnode_t. If it is, wait until it's done and go
        // around the loop again.
        if (target_procfsnode->node_attaching_vnode) {
            // Indicate that a wakeup is needed when the attaching thread
            // is done.
            target_procfsnode->node_thread_waiting_attach = TRUE;
            
            // Sleeping will drop and relock the mutex.
            msleep(target_procfsnode, procfsnode_hash_mutex, PINOD, "procfsnode_find", NULL);
            
            // Since anything can have changed while we were away, go around
            // the loop again.
            continue;
        }
        
        target_vnode = target_procfsnode->node_vnode;
        if (target_vnode != NULL) {
            // We already have a vnode. We need to check if it has been reassigned.
            // To do that, unlock and check the vnode id.
            uint32_t vid = vnode_vid(target_vnode);
            lck_mtx_unlock(procfsnode_hash_mutex);
            locked = FALSE;
            
            error = vnode_getwithvid(target_vnode, vid);
            if (error != 0) {
                // Vnode changed identity, so we need to redo everything. Relock
                // because we are expected to hold the lock at the top of the loop.
                // Getting here means that the vnode was reclaimed and the procfsnode
                // was removed from the hash and freed, so we will be restarting from scratch.
                lck_mtx_lock(procfsnode_hash_mutex);
                target_procfsnode = NULL;
                new_procfsnode = NULL;
                locked = TRUE;
                continue;
            }
            
            // The vnode was still present and has not changed id. All we need to do
            // is terminate the loop. We don't hold the lock, "locked" is FALSE and
            // we don't need to relock (and indeed doing so would introduce yet more
            // race conditions). vnode_getwithvid() added an iocount reference for us,
            // which the caller is expected to eventually release with vnode_put().
            assert(error == 0);
            break;
        }
        
        // At this point, we have procfsnode_t in the node hash, but we don't have a
        // vnode. To create the vnode, we have to release the node hash lock and invoke
        // the caller's create_vnode_func callback. Before doing that, we need to set
        // node_attaching_vnode to force any other threads that come in here to wait for
        // this thread to create the vnode (or fail).
        target_procfsnode->node_attaching_vnode = TRUE;
        lck_mtx_unlock(procfsnode_hash_mutex);
        locked = FALSE;
        
        error = (*create_vnode_func)(create_vnode_params, target_procfsnode, &target_vnode);
        assert(error != 0 || target_vnode != NULL);
        
        // Relock the hash table and clear node_attaching_vnode now that we are
        // safely back from the caller's callback.
        lck_mtx_lock(procfsnode_hash_mutex);
        locked = TRUE;
        target_procfsnode->node_attaching_vnode = FALSE;
        
        // If there are threads waiting for the vnode attach to complete,
        // wake them up.
        if (target_procfsnode->node_thread_waiting_attach) {
            target_procfsnode->node_thread_waiting_attach = FALSE;
            wakeup(target_procfsnode);
        }
        
        // Now check whether we succeeded.
        if (error != 0) {
            // Failed to create the vnode -- this is fatal.
            // Remove the procfsnode_t from the hash table and
            // release it.
            procfsnode_free_node(target_procfsnode);
            new_procfsnode = NULL; // To avoid double free.
            break;
        }
        
        // We got the new vnode and it's already linked to the procfsnode_t.
        // Link the procfsnode_t to it. Also add a file system reference to
        // the vnode itself.
        target_procfsnode->node_vnode = target_vnode;
        vnode_addfsref(target_vnode);
        
        break;
    }
    
    // Unlock the hash table, if it is still locked.
    if (locked) {
        lck_mtx_unlock(procfsnode_hash_mutex);
    }
    
    // Free the node we allocated, if we didn't use it. We do this
    // *after* releasing the hash lock just in case it might block.
    if (new_procfsnode != NULL && new_procfsnode != target_procfsnode) {
        OSFree(new_procfsnode, sizeof(procfsnode_t), procfs_osmalloc_tag);
    }
    
    // Set the return value, or NULL if we failed.
    *pnpp = error == 0 ? target_procfsnode : NULL;
    *vnpp = error == 0 ? target_vnode : NULL;
    
    return error;
}
コード例 #24
0
ファイル: TaskLEDF1.c プロジェクト: beber007/zottaos
int main(void)
{
  TaskParametersDef *TaskParameters;
  /* Stop timer during debugger connection */
  #if ZOTTAOS_TIMER == OS_IO_TIM17
     DBGMCU_Config(DBGMCU_TIM17_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM16
     DBGMCU_Config(DBGMCU_TIM16_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM15
     DBGMCU_Config(DBGMCU_TIM15_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM14
     DBGMCU_Config(DBGMCU_TIM14_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM13
     DBGMCU_Config(DBGMCU_TIM13_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM12
     DBGMCU_Config(DBGMCU_TIM12_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM11
     DBGMCU_Config(DBGMCU_TIM11_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM10
     DBGMCU_Config(DBGMCU_TIM10_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM9
     DBGMCU_Config(DBGMCU_TIM9_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM8
     DBGMCU_Config(DBGMCU_TIM8_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM5
     DBGMCU_Config(DBGMCU_TIM5_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM4
     DBGMCU_Config(DBGMCU_TIM4_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM3
     DBGMCU_Config(DBGMCU_TIM3_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM2
     DBGMCU_Config(DBGMCU_TIM2_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM1
     DBGMCU_Config(DBGMCU_TIM1_STOP,ENABLE);
  #endif
  /* Keep debugger connection during sleep mode */
  DBGMCU_Config(DBGMCU_SLEEP,ENABLE);
  /* Initialize Hardware */
  SystemInit();
  InitializeFlags(FLAG1_PIN | FLAG2_PIN | FLAG3_PIN);
  /* Create the 3 tasks. Notice that each particular task receives a private set of para-
  ** meters that it inherits from the main program and that it is the only task that can
  ** later access. */
  #if defined(ZOTTAOS_VERSION_HARD)
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG1_PIN;
     TaskParameters->Delay = 150;
     OSCreateTask(FixedDelayTask,0,700,699,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG2_PIN;
     TaskParameters->Delay = 150;
     OSCreateTask(FixedDelayTask,0,700,700,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG3_PIN;
     TaskParameters->Delay = 7000;
     OSCreateTask(VariableDelayTask,0,2100,2100,TaskParameters);
  #elif defined(ZOTTAOS_VERSION_SOFT)
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG1_PIN;
     TaskParameters->Delay = 600;
     OSCreateTask(FixedDelayTask,200,0,700,250,1,3,0,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG2_PIN;
     TaskParameters->Delay = 600;
     OSCreateTask(FixedDelayTask,200,0,700,700,1,3,0,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG3_PIN;
     TaskParameters->Delay = 7000;
     OSCreateTask(VariableDelayTask,1600,0,2100,2100,1,1,0,TaskParameters);
  #endif
  /* Start the OS so that it starts scheduling the user tasks */
  return OSStartMultitasking();
} /* end of main */
コード例 #25
0
ファイル: GPSWrapper.c プロジェクト: S0043640wipro/RiCRiPInt
/***********************************************************************************************************
*Function Name: GPS_TrayInfo()
*Attributes:
*client  IN   Client identifier
*num     IN   Number of the trayinfo[] arrays. Set the number of trays indicated in the information obtained
*                by gpsGetSysInfo() function.
*trayinfo OUT Input Tray Information Structure
*trayinfo_num OUT Returns the number of trays set to trayinfo[] array.
*notify IN Set to receive / not receive event whenever there is a change in the information.
*Description: This function obtains input tray information.
************************************************************************************************************/
int GPS_TrayInfo()
{
  long trayNum;
  int nTrayIndex;

#define YET_TO_FIND_0 200
#define YET_TO_FIND_1 201
#define YET_TO_FIND_2 202
#define YET_TO_FIND_3 203
#define YET_TO_FIND_4 204
#define YET_TO_FIND_5 205
#define YET_TO_FIND_6 206
#define YET_TO_FIND_7 207

#ifdef PMS_OIL_MERGE_DISABLE_MEM
  gpsTrayInfo = (gps_trayinfo_t*) OSMalloc(sysinfo.num_tray * sizeof(gps_trayinfo_t), PMS_MemoryPoolPMS);
  g_pstTrayInfo = (PMS_TyTrayInfo*) OSMalloc(sysinfo.num_tray * sizeof(PMS_TyTrayInfo), PMS_MemoryPoolPMS);
#else
  gpsTrayInfo = (gps_trayinfo_t*) mmalloc(sysinfo.num_tray * sizeof(gps_trayinfo_t));
  g_pstTrayInfo = (PMS_TyTrayInfo*) mmalloc(sysinfo.num_tray * sizeof(PMS_TyTrayInfo));
#endif

  if( -1 == gpsGetTrayInfo(gps_client, sysinfo.num_tray, gpsTrayInfo, &trayNum, GPS_NOTIFY_CHANGE_OFF) )
    return -1;
  /* To do - Map SDK str from GPS Specification DB - 01.pdf  : page no 37	*/
  /* gpsGetTrayInfo - page no 197	*/

  for(nTrayIndex = 0; nTrayIndex < trayNum; nTrayIndex++)
  {
    switch(gpsTrayInfo[nTrayIndex].id)
	{
	  case 0:
        g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_MANUALFEED;
		break;
      case 1:
        g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_TRAY1;
		break;
      case 2:
        g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_TRAY2;
		break;
      case 3:
        g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_TRAY3;
		break;
      default:
        g_pstTrayInfo[nTrayIndex].eMediaSource = PMS_TRAY_AUTO; 
		break;
		
		//Yet to map PMS_TRAY_BYPASS, PMS_TRAY_ENVELOPE
	}
	
	
	//Guess!!!!!!  the paper size.
	/*
	GPS_CODE_NO_PAPER = 0,
	GPS_CODE_A0,		GPS_CODE_A1,		GPS_CODE_A2,		GPS_CODE_A3,
	GPS_CODE_A4,		GPS_CODE_A5,		GPS_CODE_A6,		GPS_CODE_A7,
	GPS_CODE_B0,		GPS_CODE_B1,		GPS_CODE_B2,		GPS_CODE_B3,
	GPS_CODE_B4,		GPS_CODE_B5,		GPS_CODE_B6,		GPS_CODE_B7,
	GPS_CODE_WMAIL,		GPS_CODE_MAIL,		GPS_CODE_LINE1,		GPS_CODE_LINE2,
	GPS_CODE_LIB6,		GPS_CODE_LIB8,		GPS_CODE_210x170,	GPS_CODE_210x182,
	GPS_CODE_267x388,

	GPS_CODE_FREEmm = 31,
	GPS_CODE_11x17,
	GPS_CODE_11x14,		GPS_CODE_10x15,		GPS_CODE_10x14,		GPS_CODE_8Hx14,
	GPS_CODE_8Hx13,		GPS_CODE_8Hx11,		GPS_CODE_8Qx14,		GPS_CODE_8Qx13,
	GPS_CODE_8x13,		GPS_CODE_8x10H,		GPS_CODE_8x10,		GPS_CODE_5Hx8H,
	GPS_CODE_7Qx10H,

	GPS_CODE_12x18 = 47,
	GPS_CODE_12x14H,
	GPS_CODE_11x15,		GPS_CODE_9Hx11,		 GPS_CODE_8Hx12,	GPS_CODE_13x19,

	GPS_CODE_8KAI = 66,
	GPS_CODE_16KAI,

	GPS_CODE_NO_10 = 80,
	GPS_CODE_NO_7,

	GPS_CODE_C5 = 83,
	GPS_CODE_C6,		GPS_CODE_DL,

	GPS_CODE_NO_SIZE = 128,
	GPS_CODE_A0T,		GPS_CODE_A1T,		GPS_CODE_A2T,		GPS_CODE_A3T,
	GPS_CODE_A4T,		GPS_CODE_A5T,		GPS_CODE_A6T,		GPS_CODE_A7T,
	GPS_CODE_B0T,		GPS_CODE_B1T,		GPS_CODE_B2T,		GPS_CODE_B3T,
	GPS_CODE_B4T,		GPS_CODE_B5T,		GPS_CODE_B6T,		GPS_CODE_B7T,
	GPS_CODE_WMAILT,	GPS_CODE_MAILT,		GPS_CODE_LINE1T,	GPS_CODE_LINE2T,
	GPS_CODE_LIB6T,		GPS_CODE_LIB8T,		GPS_CODE_210x170T,	GPS_CODE_210x182T,
	GPS_CODE_267x388T,

	GPS_CODE_FREEmmT = 159,
	GPS_CODE_11x17T,
	GPS_CODE_11x14T,	GPS_CODE_10x15T,	GPS_CODE_10x14T,	GPS_CODE_8Hx14T,
	GPS_CODE_8Hx13T,	GPS_CODE_8Hx11T,	GPS_CODE_8Qx14T,	GPS_CODE_8Qx13T,
	GPS_CODE_8x13T,		GPS_CODE_8x10HT,	GPS_CODE_8x10T,		GPS_CODE_5Hx8HT,
	GPS_CODE_7Qx10HT,

	GPS_CODE_12x18T = 175,
	GPS_CODE_12x14HT,
	GPS_CODE_11x15T,	GPS_CODE_9Hx11T,	 GPS_CODE_8Hx12T,	GPS_CODE_13x19T,

	GPS_CODE_8KAIT = 194,
	GPS_CODE_16KAIT,

	GPS_CODE_NO_10T = 208,
	GPS_CODE_NO_7T,

	GPS_CODE_C5T = 211,
	GPS_CODE_C6T,		GPS_CODE_DL_T
	*/
	
	switch(gpsTrayInfo[nTrayIndex].p_size)
	{
	  case GPS_CODE_8Hx11:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LETTER;
	    break;
	  case GPS_CODE_A4:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A4;
	    break;
	  case GPS_CODE_8Hx14:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LEGAL;
	    break;
	  case GPS_CODE_7Qx10H:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_EXE;
	    break;
	  case GPS_CODE_A3:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A3;
	    break;
	  case GPS_CODE_11x17:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_TABLOID;
	    break;
	  case GPS_CODE_A5:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A5;
	    break;
	  case GPS_CODE_A6:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A6;
	    break;
	  case GPS_CODE_C5:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_C5_ENV;
	    break;
	  case GPS_CODE_DL:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_DL_ENV;
	    break;
	  case YET_TO_FIND_0:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LEDGER;
	    break;
	  case YET_TO_FIND_2:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_OFUKU;
	    break;
	  case GPS_CODE_10x14:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_JISB4;
	    break;
	  case YET_TO_FIND_3:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_JISB5;
	    break;
	  case GPS_CODE_8Hx11T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LETTER_R;
	    break;
	  case GPS_CODE_A4T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A4_R;
	    break;
	  case GPS_CODE_8Hx14T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LEGAL_R;
	    break;
	  case GPS_CODE_7Qx10HT:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_EXE_R;
	    break;
	  case GPS_CODE_A3T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A3_R;
	    break;
	  case GPS_CODE_11x17T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_TABLOID_R;
	    break;
	  case GPS_CODE_A5T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A5_R;
	    break;
	  case GPS_CODE_A6T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_A6_R;
	    break;
	  case GPS_CODE_C5T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_C5_ENV_R;
	    break;
	  case GPS_CODE_DL_T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_DL_ENV_R;
	    break;
	  case YET_TO_FIND_4:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_LEDGER_R;
	    break;
	  case YET_TO_FIND_5:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_OFUKU_R;
	    break;
	  case GPS_CODE_10x14T:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_JISB4_R;
	    break;
	  case YET_TO_FIND_6:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_JISB5_R;
	    break;
	  case YET_TO_FIND_7:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_CUSTOM;
	    break;
	  default:
	    g_pstTrayInfo[nTrayIndex].ePaperSize = PMS_SIZE_DONT_KNOW;
	    break;
	}
	
	switch(gpsTrayInfo[nTrayIndex].p_kind)
	{
	  case DI_PAPER_NORMAL:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_PLAIN;
	    break;
	  case DI_PAPER_BOND:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_BOND;
	    break;
	  case DI_PAPER_SPECIAL:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_SPECIAL;
	    break;
	  case DI_PAPER_GLOSSY:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_GLOSSY;
	    break;
	  case DI_PAPER_OHP:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_TRANSPARENCY;
	    break;
	  case DI_PAPER_RECYCLE:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_RECYCLED;
	    break;
	  case DI_PAPER_MIDDLETHICK:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_THICK;
	    break;
	  case DI_PAPER_ENVELOPE:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_ENVELOPE;
	    break;
	  case DI_PAPER_POSTCARD:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_POSTCARD;
	    break;
	  case DI_PAPER_THIN:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_THIN;
	    break;
	  case DI_PAPER_LABEL:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_LABEL;
	    break;
	  case DI_PAPER_PREPRINT:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_PREPRINTED;
	    break;
	  case DI_PAPER_LETTER_HEAD:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_LETTERHEAD;
	    break;
	  default:
	    g_pstTrayInfo[nTrayIndex].eMediaType = PMS_TYPE_DONT_KNOW;
	    break;
	}
	
	g_pstTrayInfo[nTrayIndex].eMediaColor = PMS_COLOR_DONT_KNOW; /* yet to map	*/
    g_pstTrayInfo[nTrayIndex].uMediaWeight = 0; /* yet to map	*/
    g_pstTrayInfo[nTrayIndex].nPriority = nTrayIndex; /* assumption yet to conform. 	*/
	
	g_pstTrayInfo[nTrayIndex].bTrayEmptyFlag = (GPS_TRAY_PAPEREND == gpsTrayInfo[nTrayIndex].status);
    g_pstTrayInfo[nTrayIndex].nNoOfSheets = gpsTrayInfo[nTrayIndex].remain;

  }
  
  g_nInputTrays = sysinfo.num_tray;
#ifdef PMS_OIL_MERGE_DISABLE_MEM
  OSFree( gpsTrayInfo, PMS_MemoryPoolPMS );
#else
  mfree( gpsTrayInfo );
#endif
  gpsTrayInfo = NULL;
    
  return 0;
}
コード例 #26
0
ファイル: pms_file_in.c プロジェクト: SH297614Wipro/RiCRiPInt
/**
 * \brief Open the next file.
 *
 * Opens the file contaning next job data.\n
 */
int File_OpenDataStream(void)
{
  /* PMS_SHOW("File_OpenDataStream()\n"); */

  if(!GetNextFilename(szJobFilename))
    return -1; /* -1 means don't try opening this module again */

  if ( (l_fileCurrent = fopen((char *)szJobFilename, "rb") ) == NULL )
  {
    PMS_SHOW_ERROR(" ***ASSERT*** File_OpenDataStream: Failed to open file %s \n", szJobFilename);
    return 0; /* 0 means you may try this module again to try the next job */
  }

  if(g_tSystemInfo.nStoreJobBeforeRip)
  {
    int nRead;
    int nChunk = 16 * 1024;
    PMS_SHOW("Storing job before passing to rip...\n");
    l_pStoreBuffer = OSMalloc(g_tSystemInfo.cbReceiveBuffer,PMS_MemoryPoolMisc);
    if(!l_pStoreBuffer) {
      PMS_SHOW_ERROR(" ***ASSERT*** File_OpenDataStream: Failed to allocate buffer for storing job\n");
      fclose(l_fileCurrent);
      l_fileCurrent = NULL;
      return 0; /* 0 means you may try this module again to try the next job */
    }
    fseek(l_fileCurrent,0,SEEK_END);
    l_nStoreBufferUsed = ftell(l_fileCurrent);
    fseek(l_fileCurrent,0,SEEK_SET);

    if(l_nStoreBufferUsed > g_tSystemInfo.cbReceiveBuffer)
    {
      PMS_SHOW_ERROR(" ***ASSERT*** File_OpenDataStream: Failed to store job. Job size is larger than the memory buffer.\n");
      fclose(l_fileCurrent);
      l_fileCurrent = NULL;
      OSFree(l_pStoreBuffer, PMS_MemoryPoolMisc);
      l_pStoreBuffer = NULL;
      return 0; /* 0 means you may try this module again to try the next job */
    }

    l_nStoreBufferUsed = 0;
    l_nStoreBufferPos = 0;
    do
    {
      if((l_nStoreBufferUsed + nChunk) < g_tSystemInfo.cbReceiveBuffer)
      {
        nRead = (int)fread(l_pStoreBuffer + l_nStoreBufferUsed, 1, nChunk, l_fileCurrent);
      }
      else if(l_nStoreBufferUsed < g_tSystemInfo.cbReceiveBuffer)
      {
        nRead = (int)fread(l_pStoreBuffer + l_nStoreBufferUsed, 1, g_tSystemInfo.cbReceiveBuffer - l_nStoreBufferUsed, l_fileCurrent);
      }
      else
      {
        nRead = 0;
      }
      l_nStoreBufferUsed += nRead;
    } while (nRead>0);

    fclose(l_fileCurrent);
    l_fileCurrent = NULL;
    PMS_SHOW("Stored %d bytes.\n", l_nStoreBufferUsed);
  }

  return 1; /* 1 means we have a job ready to rip */
}
コード例 #27
0
ファイル: TaskPerio.c プロジェクト: beber007/zottaos
int main(void)
{
  TaskParametersDef *TaskParameters;

  WDTCTL = WDTPW + WDTHOLD;  // Disable watchdog timer

  // Initialize output I/O ports
  P1OUT = 0x00;   // Initially start at low
  P1DIR = 0x07;   // Set to output

  /* Set the system clock characteristics */
  OSInitializeSystemClocks();

  /* Create the 3 tasks. Notice that each particular task receives a private set of para-
  ** meters that it inherits from the main program and that it is the only task that can
  ** later access. */
  #if defined(ZOTTAOS_VERSION_HARD)
     /* Calculation of the total load:
     ** 1250  / 5000  -> 25%
     ** 2500  / 10000 -> 25%
     ** 12000 / 30000 -> 40%
     ** Total:           90% */
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x1;
     TaskParameters->Delay = 600;   // wcet 1250
     OSCreateTask(FixedDelayTask,0,5000,5000,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x2;
     TaskParameters->Delay = 1200;  // wcet 2500
     OSCreateTask(FixedDelayTask,0,10000,10000,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x4;
     TaskParameters->Delay = 7000;  // wcet 12000
     OSCreateTask(VariableDelayTask,0,30000,30000,TaskParameters);
  #elif defined(ZOTTAOS_VERSION_SOFT)
     /* Calculation of the total load:
     ** Without ZottaOS-Soft capabilities:
     **    1250  / 5000  ->  25%
     **    2500  / 10000 ->  25%
     **    24000 / 30000 ->  80%
     **    Total:           130% (Task set is NOT schedulable)
     ** With ZottaOS-Soft capabilities:
     **    1250  / 5000  / 3 ->   8%
     **    2500  / 10000 / 3 ->   8%
     **    24000 / 30000 / 1 ->  80%
     **    Total:                96% (Task set is schedulable) */
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x1;
     TaskParameters->Delay = 600;   // wcet 1250
     OSCreateTask(FixedDelayTask,1250,0,5000,5000,1,3,2,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x2;
     TaskParameters->Delay = 1200;  // wcet 2500
     OSCreateTask(FixedDelayTask,2500,0,10000,10000,1,3,0,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIO_Pin = 0x4;
     TaskParameters->Delay = 13500; // wcet 2400
     OSCreateTask(VariableDelayTask,2400,0,30000,30000,1,1,0,TaskParameters);
  #else
     #error Wrong kernel version
  #endif

  /* Start the OS so that it starts scheduling the user tasks */
  return OSStartMultitasking(NULL,NULL);
} /* end of main */
コード例 #28
0
ファイル: TaskLEDF0.c プロジェクト: beber007/zottaos
int main(void)
{
  TaskParametersDef *TaskParameters;
  // Enable debug module clock
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_DBGMCU, ENABLE);
  /* Stop timer during debugger connection */
  #if ZOTTAOS_TIMER == OS_IO_TIM17
     DBGMCU_APB2PeriphConfig(DBGMCU_TIM17_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM16
     DBGMCU_APB2PeriphConfig(DBGMCU_TIM16_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM15
     DBGMCU_APB2PeriphConfig(DBGMCU_TIM15_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM14
     DBGMCU_APB1PeriphConfig(DBGMCU_TIM14_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM3
     DBGMCU_APB1PeriphConfig(DBGMCU_TIM3_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM2
     DBGMCU_APB1PeriphConfig(DBGMCU_TIM2_STOP,ENABLE);
  #elif ZOTTAOS_TIMER == OS_IO_TIM1
     DBGMCU_APB2PeriphConfig(DBGMCU_TIM1_STOP,ENABLE);
  #endif
  /* Initialize Hardware */
  SystemInit();
  InitializeFlags(FLAG1_PIN | FLAG2_PIN | FLAG3_PIN);
  /* Create the 3 tasks. Notice that each particular task receives a private set of para-
  ** meters that it inherits from the main program and that it is the only task that can
  ** later access. */
  #if defined(ZOTTAOS_VERSION_HARD)
     /* Calculation of the total load:
     ** 1250  / 5000  -> 25%
     ** 2500  / 10000 -> 25%
     ** 12000 / 30000 -> 40%
     ** Total:           90% */
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG1_PIN;
     TaskParameters->Delay = 350;
     OSCreateTask(FixedDelayTask,0,500,500,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG2_PIN;
     TaskParameters->Delay = 700;
     OSCreateTask(FixedDelayTask,0,1000,1000,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG3_PIN;
     TaskParameters->Delay = 3000;
     OSCreateTask(VariableDelayTask,0,3000,3000,TaskParameters);
  #elif defined(ZOTTAOS_VERSION_SOFT)
     /* Calculation of the total load:
     ** Without ZottaOS-Soft capabilities:
     **    1250  / 5000  ->  25%
     **    2500  / 10000 ->  25%
     **    24000 / 30000 ->  80%
     **    Total:           130% (Task set is NOT schedulable)
     ** With ZottaOS-Soft capabilities:
     **    1250  / 5000  / 3 ->   8%
     **    2500  / 10000 / 3 ->   8%
     **    24000 / 30000 / 1 ->  80%
     **    Total:                96% (Task set is schedulable) */
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG1_PIN;
     TaskParameters->Delay = 300;
     OSCreateTask(FixedDelayTask,125,0,500,500,1,2,0,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG2_PIN;
     TaskParameters->Delay = 600;
     OSCreateTask(FixedDelayTask,250,0,1000,1000,1,3,0,TaskParameters);
     TaskParameters = (TaskParametersDef *)OSMalloc(sizeof(TaskParametersDef));
     TaskParameters->GPIOx = FLAG_PORT;
     TaskParameters->GPIO_Pin = FLAG3_PIN;
     TaskParameters->Delay = 5000;
     OSCreateTask(VariableDelayTask,2400,0,3000,3000,1,1,0,TaskParameters);
  #endif
  /* Start the OS so that it starts scheduling the user tasks */
  return OSStartMultitasking(NULL,NULL);
} /* end of main */