Changeset View
Changeset View
Standalone View
Standalone View
sbin/sysctl/sysctl.c
Show First 20 Lines • Show All 729 Lines • ▼ Show 20 Lines | S_efi_map(size_t l2, void *p) | ||||
* Boot Services API. | * Boot Services API. | ||||
*/ | */ | ||||
if (l2 < sizeof(*efihdr)) { | if (l2 < sizeof(*efihdr)) { | ||||
warnx("S_efi_map length less than header"); | warnx("S_efi_map length less than header"); | ||||
return (1); | return (1); | ||||
} | } | ||||
efihdr = p; | efihdr = p; | ||||
efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf; | efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf; | ||||
map = (struct efi_md *)((uint8_t *)efihdr + efisz); | map = (struct efi_md *)(void *)((uint8_t *)efihdr + efisz); | ||||
cem: The second `(struct efi_md *)` cast can be dropped. It is redundant. | |||||
if (efihdr->descriptor_size == 0) | if (efihdr->descriptor_size == 0) | ||||
return (0); | return (0); | ||||
if (l2 != efisz + efihdr->memory_size) { | if (l2 != efisz + efihdr->memory_size) { | ||||
warnx("S_efi_map length mismatch %zu vs %zu", l2, efisz + | warnx("S_efi_map length mismatch %zu vs %zu", l2, efisz + | ||||
efihdr->memory_size); | efihdr->memory_size); | ||||
return (1); | return (1); | ||||
} | } | ||||
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines | name2oid(const char *name, int *oidp) | ||||
j /= sizeof(int); | j /= sizeof(int); | ||||
return (j); | return (j); | ||||
} | } | ||||
static int | static int | ||||
oidfmt(int *oid, int len, char *fmt, u_int *kind) | oidfmt(int *oid, int len, char *fmt, u_int *kind) | ||||
{ | { | ||||
int qoid[CTL_MAXNAME+2]; | int qoid[CTL_MAXNAME+2]; | ||||
u_char buf[BUFSIZ]; | u_int buf[BUFSIZ / sizeof(u_int)]; | ||||
int i; | int i; | ||||
size_t j; | size_t j; | ||||
qoid[0] = 0; | qoid[0] = 0; | ||||
qoid[1] = 4; | qoid[1] = 4; | ||||
memcpy(qoid + 2, oid, len * sizeof(int)); | memcpy(qoid + 2, oid, len * sizeof(int)); | ||||
j = sizeof(buf); | j = sizeof(buf); | ||||
i = sysctl(qoid, len + 2, buf, &j, 0, 0); | i = sysctl(qoid, len + 2, buf, &j, 0, 0); | ||||
if (i) | if (i) | ||||
err(1, "sysctl fmt %d %zu %d", i, j, errno); | err(1, "sysctl fmt %d %zu %d", i, j, errno); | ||||
if (kind) | if (kind) | ||||
*kind = *(u_int *)buf; | *kind = *(u_int *)buf; | ||||
Done Inline ActionsAlternatively, just memcpy(kind, buf, sizeof(*kind)); here and drop the other changes to this function. cem: Alternatively, just `memcpy(kind, buf, sizeof(*kind));` here and drop the other changes to this… | |||||
if (fmt) | if (fmt) | ||||
strcpy(fmt, (char *)(buf + sizeof(u_int))); | strcpy(fmt, (char *)(buf + 1)); | ||||
return (0); | return (0); | ||||
} | } | ||||
/* | /* | ||||
* This formats and outputs the value of one variable | * This formats and outputs the value of one variable | ||||
* | * | ||||
* Returns zero if anything was actually output. | * Returns zero if anything was actually output. | ||||
* Returns one if didn't know what to do with this. | * Returns one if didn't know what to do with this. | ||||
* Return minus one if we had errors. | * Return minus one if we had errors. | ||||
*/ | */ | ||||
static int | static int | ||||
show_var(int *oid, int nlen) | show_var(int *oid, int nlen) | ||||
{ | { | ||||
u_char buf[BUFSIZ], *val, *oval, *p; | u_char buf[BUFSIZ], *p; | ||||
void *val, *oval; | |||||
char name[BUFSIZ], fmt[BUFSIZ]; | char name[BUFSIZ], fmt[BUFSIZ]; | ||||
const char *sep, *sep1, *prntype; | const char *sep, *sep1, *prntype; | ||||
int qoid[CTL_MAXNAME+2]; | int qoid[CTL_MAXNAME+2]; | ||||
uintmax_t umv; | uintmax_t umv; | ||||
intmax_t mv; | intmax_t mv; | ||||
int i, hexlen, sign, ctltype; | int i, hexlen, sign, ctltype; | ||||
size_t intlen; | size_t intlen; | ||||
size_t j, len; | size_t j, len; | ||||
u_int kind; | u_int kind; | ||||
float base; | float base; | ||||
int (*func)(size_t, void *); | int (*func)(size_t, void *); | ||||
int prec; | int prec; | ||||
/* Silence GCC. */ | /* Silence GCC. */ | ||||
umv = mv = intlen = 0; | umv = mv = intlen = 0; | ||||
Not Done Inline ActionsIs this still needed? imp: Is this still needed? | |||||
Done Inline ActionsUnfortunately yes, even with new GCC. trasz: Unfortunately yes, even with new GCC. | |||||
bzero(buf, BUFSIZ); | bzero(buf, BUFSIZ); | ||||
bzero(fmt, BUFSIZ); | bzero(fmt, BUFSIZ); | ||||
bzero(name, BUFSIZ); | bzero(name, BUFSIZ); | ||||
qoid[0] = 0; | qoid[0] = 0; | ||||
memcpy(qoid + 2, oid, nlen * sizeof(int)); | memcpy(qoid + 2, oid, nlen * sizeof(int)); | ||||
qoid[1] = 1; | qoid[1] = 1; | ||||
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines | if (i != 0 || (len == 0 && ctltype != CTLTYPE_STRING)) { | ||||
return (1); | return (1); | ||||
} | } | ||||
if (bflag) { | if (bflag) { | ||||
fwrite(val, 1, len, stdout); | fwrite(val, 1, len, stdout); | ||||
free(oval); | free(oval); | ||||
return (0); | return (0); | ||||
} | } | ||||
val[len] = '\0'; | |||||
p = val; | p = val; | ||||
p[len] = '\0'; | |||||
sign = ctl_sign[ctltype]; | sign = ctl_sign[ctltype]; | ||||
intlen = ctl_size[ctltype]; | intlen = ctl_size[ctltype]; | ||||
switch (ctltype) { | switch (ctltype) { | ||||
case CTLTYPE_STRING: | case CTLTYPE_STRING: | ||||
if (!nflag) | if (!nflag) | ||||
printf("%s%s", name, sep); | printf("%s%s", name, sep); | ||||
printf("%.*s", (int)len, p); | printf("%.*s", (int)len, p); | ||||
Show All 15 Lines | case CTLTYPE_U64: | ||||
if (!nflag) | if (!nflag) | ||||
printf("%s%s", name, sep); | printf("%s%s", name, sep); | ||||
hexlen = 2 + (intlen * CHAR_BIT + 3) / 4; | hexlen = 2 + (intlen * CHAR_BIT + 3) / 4; | ||||
sep1 = ""; | sep1 = ""; | ||||
while (len >= intlen) { | while (len >= intlen) { | ||||
switch (kind & CTLTYPE) { | switch (kind & CTLTYPE) { | ||||
case CTLTYPE_INT: | case CTLTYPE_INT: | ||||
case CTLTYPE_UINT: | case CTLTYPE_UINT: | ||||
umv = *(u_int *)p; | umv = *(u_int *)val; | ||||
mv = *(int *)p; | mv = *(int *)val; | ||||
break; | break; | ||||
case CTLTYPE_LONG: | case CTLTYPE_LONG: | ||||
case CTLTYPE_ULONG: | case CTLTYPE_ULONG: | ||||
umv = *(u_long *)p; | umv = *(u_long *)val; | ||||
mv = *(long *)p; | mv = *(long *)val; | ||||
break; | break; | ||||
case CTLTYPE_S8: | case CTLTYPE_S8: | ||||
case CTLTYPE_U8: | case CTLTYPE_U8: | ||||
umv = *(uint8_t *)p; | umv = *(uint8_t *)val; | ||||
mv = *(int8_t *)p; | mv = *(int8_t *)val; | ||||
break; | break; | ||||
case CTLTYPE_S16: | case CTLTYPE_S16: | ||||
case CTLTYPE_U16: | case CTLTYPE_U16: | ||||
umv = *(uint16_t *)p; | umv = *(uint16_t *)val; | ||||
mv = *(int16_t *)p; | mv = *(int16_t *)val; | ||||
break; | break; | ||||
case CTLTYPE_S32: | case CTLTYPE_S32: | ||||
case CTLTYPE_U32: | case CTLTYPE_U32: | ||||
umv = *(uint32_t *)p; | umv = *(uint32_t *)val; | ||||
mv = *(int32_t *)p; | mv = *(int32_t *)val; | ||||
break; | break; | ||||
case CTLTYPE_S64: | case CTLTYPE_S64: | ||||
case CTLTYPE_U64: | case CTLTYPE_U64: | ||||
umv = *(uint64_t *)p; | umv = *(uint64_t *)val; | ||||
mv = *(int64_t *)p; | mv = *(int64_t *)val; | ||||
break; | break; | ||||
} | } | ||||
fputs(sep1, stdout); | fputs(sep1, stdout); | ||||
if (xflag) | if (xflag) | ||||
printf("%#0*jx", hexlen, umv); | printf("%#0*jx", hexlen, umv); | ||||
else if (!sign) | else if (!sign) | ||||
printf(hflag ? "%'ju" : "%ju", umv); | printf(hflag ? "%'ju" : "%ju", umv); | ||||
else if (fmt[1] == 'K') { | else if (fmt[1] == 'K') { | ||||
if (mv < 0) | if (mv < 0) | ||||
printf("%jd", mv); | printf("%jd", mv); | ||||
else { | else { | ||||
/* | /* | ||||
* See strIKtoi for details on fmt. | * See strIKtoi for details on fmt. | ||||
*/ | */ | ||||
prec = 1; | prec = 1; | ||||
if (fmt[2] != '\0') | if (fmt[2] != '\0') | ||||
prec = fmt[2] - '0'; | prec = fmt[2] - '0'; | ||||
base = 1.0; | base = 1.0; | ||||
for (int i = 0; i < prec; i++) | for (i = 0; i < prec; i++) | ||||
base *= 10.0; | base *= 10.0; | ||||
printf("%.*fC", prec, | printf("%.*fC", prec, | ||||
(float)mv / base - 273.15); | (float)mv / base - 273.15); | ||||
} | } | ||||
} else | } else | ||||
printf(hflag ? "%'jd" : "%jd", mv); | printf(hflag ? "%'jd" : "%jd", mv); | ||||
sep1 = " "; | sep1 = " "; | ||||
len -= intlen; | len -= intlen; | ||||
Show All 15 Lines | #endif | ||||
default: | default: | ||||
if (!oflag && !xflag) { | if (!oflag && !xflag) { | ||||
free(oval); | free(oval); | ||||
return (1); | return (1); | ||||
} | } | ||||
if (!nflag) | if (!nflag) | ||||
printf("%s%s", name, sep); | printf("%s%s", name, sep); | ||||
printf("Format:%s Length:%zu Dump:0x", fmt, len); | printf("Format:%s Length:%zu Dump:0x", fmt, len); | ||||
while (len-- && (xflag || p < val + 16)) | while (len-- && (xflag || p < (u_char *)val + 16)) | ||||
printf("%02x", *p++); | printf("%02x", *p++); | ||||
if (!xflag && len > 16) | if (!xflag && len > 16) | ||||
printf("..."); | printf("..."); | ||||
free(oval); | free(oval); | ||||
return (0); | return (0); | ||||
} | } | ||||
free(oval); | free(oval); | ||||
return (1); | return (1); | ||||
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines |
The second (struct efi_md *) cast can be dropped. It is redundant.