示例#1
0
文件: types.c 项目: bawerd/kitten
/* Create a boxed integer. */
Boxed integer_new(Integer value) {
  Boxed reference = boxed_new(integer_alloc(value));
  if (!reference)
    goto memory_error;
  return reference;
 memory_error:
  return NULL;
}
示例#2
0
文件: fileset.c 项目: alhazred/onarm
/*
 * Allocates a fileset instance, initializes fs_dirgamma and
 * fs_sizegamma default values, and sets the fileset name to the
 * supplied name string. Puts the allocated fileset on the
 * master fileset list and returns a pointer to it.
 */
fileset_t *
fileset_define(char *name)
{
	fileset_t *fileset;

	if (name == NULL)
		return (NULL);

	if ((fileset = (fileset_t *)ipc_malloc(FILEBENCH_FILESET)) == NULL) {
		filebench_log(LOG_ERROR,
		    "fileset_define: Can't malloc fileset");
		return (NULL);
	}

	filebench_log(LOG_DEBUG_IMPL, "Defining file %s", name);

	(void) ipc_mutex_lock(&filebench_shm->fileset_lock);

	fileset->fs_dirgamma = integer_alloc(1500);
	fileset->fs_sizegamma = integer_alloc(1500);

	/* Add fileset to global list */
	if (filebench_shm->filesetlist == NULL) {
		filebench_shm->filesetlist = fileset;
		fileset->fs_next = NULL;
	} else {
		fileset->fs_next = filebench_shm->filesetlist;
		filebench_shm->filesetlist = fileset;
	}

	(void) ipc_mutex_unlock(&filebench_shm->fileset_lock);

	(void) strcpy(fileset->fs_name, name);

	return (fileset);
}
示例#3
0
/*
 * Allocates a flowop entity and initializes it with inherited
 * contents from the "inherit" flowop, if it is supplied, or
 * with zeros otherwise. In either case the file descriptor
 * (fo_fd) is set to -1, and the fo_next and fo_threadnext
 * pointers are set to NULL, and fo_thread is set to point to
 * the owning threadflow. The initialized flowop is placed at
 * the head of the global flowop list, and also placed on the
 * tail of thethreadflow's tf_ops list. The routine locks the
 * flowop's fo_lock and leaves it held on return. If successful,
 * it returns a pointer to the allocated and initialized flowop,
 * otherwise NULL.
 *
 * filebench_shm->flowop_lock must be held by caller.
 */
static flowop_t *
flowop_define_common(threadflow_t *threadflow, char *name, flowop_t *inherit,
    int instance, int type)
{
	flowop_t *flowop;

	if (name == NULL)
		return (NULL);

	if ((flowop = (flowop_t *)ipc_malloc(FILEBENCH_FLOWOP)) == NULL) {
		filebench_log(LOG_ERROR,
		    "flowop_define: Can't malloc flowop");
		return (NULL);
	}

	filebench_log(LOG_DEBUG_IMPL, "defining flowops %s-%d, addr %zx",
	    name, instance, flowop);

	if (flowop == NULL)
		return (NULL);

	if (inherit) {
		(void) memcpy(flowop, inherit, sizeof (flowop_t));
		(void) pthread_mutex_init(&flowop->fo_lock, ipc_mutexattr());
		(void) ipc_mutex_lock(&flowop->fo_lock);
		flowop->fo_next = NULL;
		flowop->fo_threadnext = NULL;
		flowop->fo_fd = -1;
		filebench_log(LOG_DEBUG_IMPL,
		    "flowop %s-%d calling init", name, instance);
	} else {
		(void) memset(flowop, 0, sizeof (flowop_t));
		flowop->fo_fd = -1;
		flowop->fo_iters = integer_alloc(1);
		flowop->fo_type = type;
		(void) pthread_mutex_init(&flowop->fo_lock, ipc_mutexattr());
		(void) ipc_mutex_lock(&flowop->fo_lock);
	}

	/* Create backpointer to thread */
	flowop->fo_thread = threadflow;

	/* Add flowop to global list */
	if (filebench_shm->flowoplist == NULL) {
		filebench_shm->flowoplist = flowop;
		flowop->fo_next = NULL;
	} else {
		flowop->fo_next = filebench_shm->flowoplist;
		filebench_shm->flowoplist = flowop;
	}

	(void) strcpy(flowop->fo_name, name);
	flowop->fo_instance = instance;

	if (threadflow == NULL)
		return (flowop);

	/* Add flowop to thread op list */
	if (threadflow->tf_ops == NULL) {
		threadflow->tf_ops = flowop;
		flowop->fo_threadnext = NULL;
	} else {
		flowop_t *flowend;

		/* Find the end of the thread list */
		flowend = threadflow->tf_ops;
		while (flowend->fo_threadnext != NULL)
			flowend = flowend->fo_threadnext;
		flowend->fo_threadnext = flowop;
		flowop->fo_threadnext = NULL;
	}

	return (flowop);
}