levels
char *type, char *basetype, int levels)
name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
int levels)
name, line, file, PRIMITIVE, type, basetype, levels,
char *type, char *basetype, int levels)
name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
char *basetype, int levels)
name, line, file, PRIMITIVE, type, basetype, levels, "", -1, -1);
int kind, char *type, char *basetype, int levels, char *attribute,
return (set_entry(e, name, line, file, kind, type, basetype, levels,
int kind, char *type, char *basetype, int levels, char *attribute,
e->e_levels = levels;
int kind, char *type, char *basetype, int levels, char *attribute,
name, line, file, kind, type, basetype, levels,
int levels = 0;
levels++;
return (levels);
int levels, a_levels;
levels = to_basetype(f_basetype);
symtab_set_function(f_name, line, file, f_type, f_basetype, levels);
dsdt_indent(int levels)
dsdt_indent_level += levels;
dsdt_unindent(int levels)
assert(dsdt_indent_level >= levels);
dsdt_indent_level -= levels;
void dsdt_indent(int levels);
void dsdt_unindent(int levels);
} levels[] = {
struct levels *p;
for (p = levels; (p != NULL) && (p->p_level != level); p++)
struct levels *p;
for (p = levels; p->p_name; p++) {
for (p = levels; (p != NULL) && (p->p_name); p++)
struct levels *p;
for (p = levels; p->p_name; p++) {
for (p = levels; p->p_name; p++)
unsigned int levels = 0; /* levels seen so far */
levels++;
if (levels == level) {
if (levels == level) {
int levels, i;
levels = 1;
roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {
levels = 1;
if (levels > ctx->argc) {
ln, pos, "%d, but max is %d", levels, ctx->argc);
levels = ctx->argc;
if (levels == 0)
for (i = 0; i < levels; i++)
ctx->argc -= levels;
ctx->argv[i] = ctx->argv[i + levels];
fs_dprintf(("<8> levels = %d\n", levels));
levels++;
return (levels);
int levels;
if ((levels = crawl(win, kbase, ktop, ubase, 1, fsip)) > 1) {
mdb_printf(" %p (%d)\n", fp, levels);
} else if (levels == CRAWL_FOUNDALL) {
int levels = 0;
int levels;
for (i = P_ROOT, levels = 0 ;; ++levels) {
if (levels == 0)
levels = 1;
levels, levels == 1 ? "" : "s", nkeys);
uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg);
for (i = 0; i <= levels + 1; i++)
uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i;
for (i = 0; i < levels; base += step, i++)
return (total + (long double)lquanta[levels + 1] *
uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i;
for (i = 0; i < levels; base += step, i++) {
return (lquanta[levels + 1]);
levels = (int)size / sizeof (uint64_t);
last_bin = levels - 1;
while (first_bin < levels && data[first_bin] == 0)
if (first_bin == levels) {
if (last_bin < levels - 1)
uint16_t step, levels;
levels = DTRACE_LQUANTIZE_LEVELS(arg);
last_bin = levels + 1;
if (size != sizeof (uint64_t) * (levels + 2))
while (first_bin <= levels + 1 && data[first_bin] == 0)
if (first_bin > levels + 1) {
if (last_bin < levels + 1)
} else if (i == levels + 1) {
base + (levels * step));
uint16_t step, levels;
levels = DTRACE_LQUANTIZE_LEVELS(arg);
if (size != sizeof (uint64_t) * (levels + 2))
max = levels + 1;
(void) snprintf(c, sizeof (c), ">= %d", base + (levels * step));
int i, first_bin, last_bin, bin = 1, order, levels;
int levels;
levels = DTRACE_LQUANTIZE_LEVELS(value);
n = levels + 2;
levels = size / sizeof (int64_t);
n = levels;
levels = n - 1; /* levels excludes base */
int levels = ep->dom_levels;
struct piggy *bank = bank_init(levels);
bank_free(bank, levels);
static struct piggy *bank_init(unsigned levels)
bank = calloc(1, sizeof(*bank) + levels * sizeof(bank->lists[0]));
bank->max = levels - 1;
static void bank_free(struct piggy *bank, unsigned int levels)
for (; levels-- ;)
free_ptr_list(&bank->lists[levels]);
int levels, level;
levels = 0;
cpu_cmt_hier[levels++] = pg;
group_expand(cmt_pgs, levels);
pg_cmt_hier_sort(cpu_cmt_hier, levels);
lineage_status = pg_cmt_lineage_validate(cpu_cmt_hier, &levels, pgdata);
for (level = levels - 1; level >= 0; ) {
level = levels - 1;
for (level = 0; level < levels; level++) {
err = group_add_at(cmt_pgs, pg, levels - level - 1);
if ((level + 1) == levels) {
uint16_t levels = DTRACE_LQUANTIZE_LEVELS(desc->dtad_arg);
if (step == 0 || levels == 0)
size = levels * sizeof (uint64_t) + 3 * sizeof (uint64_t);
uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg);
ASSERT(levels != 0);
if (level < levels) {
lquanta[levels + 1] += incr;
dmu_objset_type_t type, int levels, int blksz, int ibs, dmu_tx_t *tx)
if (levels == 0) {
levels = 1;
(mdn->dn_datablkshift - DNODE_SHIFT + (levels - 1) *
levels++;
mdn->dn_nlevels = levels;
blkptr_t *bp, dmu_objset_type_t type, int levels, int blksz, int ibs,
lpl_topo_flatten(int levels)
if (levels != 2)
return (levels);
lgrp_topo_flatten(int levels, lgrp_t **lgrps, int lgrp_count,
if (levels != 2)
vidbp->cur_level = vidbp->levels[vidbp->cur_level_index];
if (vidbp->levels[i] == vidbp->cur_level) {
if (acpi_drv_set_int(vidbp->dev.hdl, "_BCM", vidbp->levels[level])
vidbp->cur_level = vidbp->levels[level];
vidbp->levels = kmem_zalloc(nlev * sizeof (uint32_t), KM_SLEEP);
vidbp->levels[i] = lev;
if (vidbp->levels[k] > vidbp->levels[k+1]) {
tmp = vidbp->levels[k+1];
vidbp->levels[k+1] = vidbp->levels[k];
vidbp->levels[k] = tmp;
if (vidbp->levels[l] == vidbp->levels[l+1]) {
vidbp->levels[m] = vidbp->levels[m+1];
int *levels;
if (copyout(vidbp->levels, (void *)arg,
sizeof (*vidbp->levels) * vidbp->nlevel)) {
if (vidbp->levels[i] == vidbp->cur_level) {
enum levels warning_level, level;
enum levels warning_level = green;