Esempio n. 1
0
/* ////////////////////////////////////////////////////////////////////////// */
static inline int
list_item_construct(mmu_list_item_t **item,
                    const void *payload_base,
                    size_t payload_extent)
{
    int rc = MMU_FAILURE;
    mmu_list_item_t *tmp;
    void *payload;

    if (NULL == item || NULL == payload_base || 0 == payload_extent) {
        return MMU_FAILURE_INVALID_ARG;
    }
    if (NULL == (tmp = calloc(1, sizeof(*tmp)))) {
        MMU_OOR_COMPLAIN();
        return MMU_FAILURE_OOR;
    }
    /* allocate enough space for the payload */
    if (NULL == (payload = calloc(1, payload_extent))) {
        MMU_OOR_COMPLAIN();
        rc = MMU_FAILURE_OOR;
        goto err;
    }
    /* copy the payload */
    (void)memmove(payload, payload_base, payload_extent);
    tmp->datap = payload;
    tmp->size = payload_extent;
    *item = tmp;

    return MMU_SUCCESS;

err:
    list_item_destruct(tmp, false);
    return rc;
}
Esempio n. 2
0
/* ////////////////////////////////////////////////////////////////////////// */
int
mmu_args_construct(mmu_args_t **a)
{
    mmu_args_t *tmp = NULL;

    if (NULL == a) return MMU_FAILURE_INVALID_ARG;

    tmp = (mmu_args_t *)calloc(1, sizeof(*tmp));
    if (NULL == tmp) {
        MMU_OOR_COMPLAIN();
        return MMU_FAILURE_OOR;
    }
    set_arg_defaults(tmp);
    *a = tmp;

    return MMU_SUCCESS;
}
Esempio n. 3
0
/* ////////////////////////////////////////////////////////////////////////// */
int
mmu_list_construct(mmu_list_t **list)
{
    mmu_list_t *tmp;

    if (NULL == list) return MMU_FAILURE_INVALID_ARG;

    if (NULL == (tmp = calloc(1, sizeof(*tmp)))) {
        MMU_OOR_COMPLAIN();
        return MMU_FAILURE_OOR;
    }
    /* start off with nothing */
    tmp->item_ptrs = NULL;
    tmp->size = 0;
    tmp->capacity = 0;
    *list = tmp;

    return MMU_SUCCESS;
}
Esempio n. 4
0
/* ////////////////////////////////////////////////////////////////////////// */
static inline int
list_grow(mmu_list_t *list,
          size_t new_capacity)
{
    if (NULL == list || new_capacity <= 0) return MMU_FAILURE_INVALID_ARG;
    /* this is easy. */
    if (list->capacity >= new_capacity) return MMU_SUCCESS;
    /* if we are here, it is safe to realloc to the given size */
    if (NULL == (list->item_ptrs =
                 realloc(list->item_ptrs,
                         new_capacity * sizeof(mmu_list_item_t *)))) {
        MMU_OOR_COMPLAIN();
        return MMU_FAILURE_OOR;
    }
    /* update list capacity to the new capacity */
    list->capacity = new_capacity;

    return MMU_SUCCESS;
}
Esempio n. 5
0
/* ////////////////////////////////////////////////////////////////////////// */
int
mmu_args_process_user_input(mmu_args_t *a,
                            int argc,
                            char **argv)
{
    int c;
    int rc = MMU_FAILURE;
    char **tmp_argv = NULL;

    if (NULL == (tmp_argv = mmu_args_dup_argv(argc, argv))) {
        MMU_OOR_COMPLAIN();
        return MMU_FAILURE_OOR;
    }
    while (-1 != (c = getopt_long_only(argc, tmp_argv, opt_string, long_opts,
                                       NULL))) {
        switch (c) {
            case 's': /* samples-per-sec */
                if (MMU_SUCCESS != (rc = handle_s(a, c, optarg))) {
                    goto show_usage;
                }
                break;

            case 't': /* sample-time */
                if (MMU_SUCCESS != (rc = handle_t(a, c, optarg))) {
                    goto show_usage;
                }
                break;
            case 'w': /* enable workload */
                if (MMU_SUCCESS != (rc = handle_w(a))) {
                    goto show_usage;
                }
                break;

            case 'h': /* help! */
                mmu_args_usage();
                rc = MMU_SUCCESS_EXIT_SUCCESS;
                goto cleanup;
                break;

            case 'v': /* version, please */
                showver();
                rc = MMU_SUCCESS_EXIT_SUCCESS;
                goto cleanup;
                break;

            default:
                goto show_usage;
        }
    }
    if (optind < argc) {
        fprintf(stderr, MMU_ERR_PREFIX"unrecognized input: \"%s\"\n",
                tmp_argv[optind]);
        goto show_usage;
    }

    /* all is well */
    rc = MMU_SUCCESS;
    goto cleanup;

show_usage:
    mmu_args_usage();
    rc = MMU_FAILURE_INVALID_USER_INPUT;

cleanup:
    if (NULL != tmp_argv) {
        mmu_args_free_dup_argv(tmp_argv);
    }
    return rc;
}