Paths

Table of Contentst

-
sys/dev/uart/
-
dev/
-
uart/
-
uart_subr.c

uart: uart_getenv: check for NULL class last, not first
ClosedPublic
Actions

Authored by imp on Oct 11 2024, 9:54 PM.

Details

Reviewers

markj
andrew
adrian
jhb
jrtc27
bz
marius
oh
manu
kevans
cperciva
mhorne
mw
mmel

Commits

rGc87b3f0006be: uart: uart_getenv: check for NULL class last, not first

Summary

This allows one to specify dt:XXXX when the default class isn't compiled
into the kernel. It's not an error to not have a class until we're done
parsing the spec, so defer checking until then.

Diff Detail

Repository

rG FreeBSD src repository

Lint

Lint Skipped

Unit

Tests Skipped

Build Status

Buildable 59988
Build 56873: arc lint + arc unit

Event Timeline

imp requested review of this revision.Oct 11 2024, 9:54 PM

imp created this revision.

Harbormaster completed remote builds in B59925: Diff 144682.Oct 11 2024, 9:54 PM

imp added a parent revision: D47077: uart/pl011: Add support for computing rclk.Oct 11 2024, 9:54 PM

imp added a child revision: D47079: acpidump: Move to acpi.rsdp.

markj added inline comments.Oct 12 2024, 2:54 PM

sys/dev/uart/uart_subr.c
293	This is missing a `freeenv(cp)` in the cleanup path.

Check a little later for NULL class... Doesn't really matter and this fixes the leak markj noticed.

Harbormaster completed remote builds in B59962: Diff 144790.Oct 13 2024, 10:23 PM

adrian accepted this revision.Oct 13 2024, 10:46 PM

adrian added inline comments.

sys/dev/uart/uart_subr.c
293	is it? inval: has freeenv(cp); in it.

This revision is now accepted and ready to land.Oct 13 2024, 10:46 PM

markj accepted this revision.Oct 13 2024, 11:03 PM

markj added inline comments.

sys/dev/uart/uart_subr.c
293	My comment applied to an older version of the diff. Its location is misleading now, which is a bug/quirk of phabricator.

andrew accepted this revision.Oct 14 2024, 11:56 AM

andrew added inline comments.

sys/dev/uart/uart_subr.c
297–298	We should update this comment while here. Most uart classes are static. Only a few are weak, e.g. the default.

Update the comment too, per Andrew

This revision now requires review to proceed.Oct 14 2024, 9:11 PM

Harbormaster completed remote builds in B59988: Diff 144852.Oct 14 2024, 9:11 PM

imp marked 4 inline comments as done.Oct 14 2024, 9:12 PM

imp added inline comments.

sys/dev/uart/uart_subr.c
297–298	Good idea. Tweaked it a bit.

This revision was not accepted when it landed; it landed in state Needs Review.Oct 14 2024, 10:18 PM

Closed by commit rGc87b3f0006be: uart: uart_getenv: check for NULL class last, not first (authored by imp). · Explain Why

This revision was automatically updated to reflect the committed changes.

imp marked an inline comment as done.

imp added a commit: rGc87b3f0006be: uart: uart_getenv: check for NULL class last, not first.

Revision Contents
Changeset List

Path

Size

sys/

dev/

uart/

uart_subr.c

14 lines

Diff 144852

View Options

sys/dev/uart/uart_subr.c

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines

#define SMBIOS_GET8(base, off) ((uint8_t )((base) + (off)))		#define SMBIOS_GET8(base, off) ((uint8_t )((base) + (off)))
#define SMBIOS_GET16(base, off) ((uint16_t )((base) + (off)))		#define SMBIOS_GET16(base, off) ((uint16_t )((base) + (off)))
#define SMBIOS_GET32(base, off) ((uint32_t )((base) + (off)))		#define SMBIOS_GET32(base, off) ((uint32_t )((base) + (off)))

#define SMBIOS_GETLEN(base) SMBIOS_GET8(base, 0x01)		#define SMBIOS_GETLEN(base) SMBIOS_GET8(base, 0x01)
#define SMBIOS_GETSTR(base) ((base) + SMBIOS_GETLEN(base))		#define SMBIOS_GETSTR(base) ((base) + SMBIOS_GETLEN(base))

static uint32_t smbios_enabled_memory = 0;		struct smbios_attr {
static uint32_t smbios_old_enabled_memory = 0;		int probed;
static uint8_t smbios_enabled_sockets = 0;		caddr_t addr;
static uint8_t smbios_populated_sockets = 0;		size_t length;
		size_t count;
		int major;
		int minor;
		int ver;
		const char* bios_vendor;
		const char* maker;
		const char* product;
		uint32_t enabled_memory;
		uint32_t old_enabled_memory;
		uint8_t enabled_sockets;
		uint8_t populated_sockets;
		};

		static struct smbios_attr smbios;

static uint8_t		static uint8_t
smbios_checksum(const caddr_t addr, const uint8_t len)		smbios_checksum(const caddr_t addr, const uint8_t len)
{		{
uint8_t sum;		uint8_t sum;
int i;		int i;

for (sum = 0, i = 0; i < len; i++)		for (sum = 0, i = 0; i < len; i++)
sum += SMBIOS_GET8(addr, i);		sum += SMBIOS_GET8(addr, i);
Show All 10 Lines	for (cp = addr; cp < addr + len; cp += SMBIOS_STEP)
if (strncmp(cp, SMBIOS_SIG, 4) == 0 &&		if (strncmp(cp, SMBIOS_SIG, 4) == 0 &&
smbios_checksum(cp, SMBIOS_GET8(cp, 0x05)) == 0 &&		smbios_checksum(cp, SMBIOS_GET8(cp, 0x05)) == 0 &&
strncmp(cp + 0x10, SMBIOS_DMI_SIG, 5) == 0 &&		strncmp(cp + 0x10, SMBIOS_DMI_SIG, 5) == 0 &&
smbios_checksum(cp + 0x10, 0x0f) == 0)		smbios_checksum(cp + 0x10, 0x0f) == 0)
return (cp);		return (cp);
return (NULL);		return (NULL);
}		}

static void		static const char*
smbios_setenv(const char *name, caddr_t addr, const int offset)		smbios_getstring(caddr_t addr, const int offset)
{		{
caddr_t cp;		caddr_t cp;
int i, idx;		int i, idx;

idx = SMBIOS_GET8(addr, offset);		idx = SMBIOS_GET8(addr, offset);
if (idx != 0) {		if (idx != 0) {
cp = SMBIOS_GETSTR(addr);		cp = SMBIOS_GETSTR(addr);
for (i = 1; i < idx; i++)		for (i = 1; i < idx; i++)
cp += strlen(cp) + 1;		cp += strlen(cp) + 1;
setenv(name, cp, 1);		return cp;
}		}
		return (NULL);
}		}

		static void
		smbios_setenv(const char *name, caddr_t addr, const int offset)
		{
		const char* val;

		val = smbios_getstring(addr, offset);
		if (val != NULL)
		setenv(name, val, 1);
		}

#ifdef SMBIOS_SERIAL_NUMBERS		#ifdef SMBIOS_SERIAL_NUMBERS

#define UUID_SIZE 16		#define UUID_SIZE 16
#define UUID_TYPE uint32_t		#define UUID_TYPE uint32_t
#define UUID_STEP sizeof(UUID_TYPE)		#define UUID_STEP sizeof(UUID_TYPE)
#define UUID_ALL_BITS (UUID_SIZE / UUID_STEP)		#define UUID_ALL_BITS (UUID_SIZE / UUID_STEP)
#define UUID_GET(base, off) ((UUID_TYPE )((base) + (off)))		#define UUID_GET(base, off) ((UUID_TYPE )((base) + (off)))

▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
#undef UUID_TYPE		#undef UUID_TYPE
#undef UUID_STEP		#undef UUID_STEP
#undef UUID_ALL_BITS		#undef UUID_ALL_BITS
#undef UUID_GET		#undef UUID_GET

#endif		#endif

static caddr_t		static caddr_t
smbios_parse_table(const caddr_t addr, const int ver)		smbios_parse_table(const caddr_t addr)
{		{
caddr_t cp;		caddr_t cp;
int proc, size, osize, type;		int proc, size, osize, type;

type = SMBIOS_GET8(addr, 0); /* 3.1.2 Structure Header Format */		type = SMBIOS_GET8(addr, 0); /* 3.1.2 Structure Header Format */
switch(type) {		switch(type) {
case 0: /* 3.3.1 BIOS Information (Type 0) */		case 0: /* 3.3.1 BIOS Information (Type 0) */
smbios_setenv("smbios.bios.vendor", addr, 0x04);		smbios_setenv("smbios.bios.vendor", addr, 0x04);
smbios_setenv("smbios.bios.version", addr, 0x05);		smbios_setenv("smbios.bios.version", addr, 0x05);
smbios_setenv("smbios.bios.reldate", addr, 0x08);		smbios_setenv("smbios.bios.reldate", addr, 0x08);
break;		break;

case 1: /* 3.3.2 System Information (Type 1) */		case 1: /* 3.3.2 System Information (Type 1) */
smbios_setenv("smbios.system.maker", addr, 0x04);		smbios_setenv("smbios.system.maker", addr, 0x04);
smbios_setenv("smbios.system.product", addr, 0x05);		smbios_setenv("smbios.system.product", addr, 0x05);
smbios_setenv("smbios.system.version", addr, 0x06);		smbios_setenv("smbios.system.version", addr, 0x06);
#ifdef SMBIOS_SERIAL_NUMBERS		#ifdef SMBIOS_SERIAL_NUMBERS
smbios_setenv("smbios.system.serial", addr, 0x07);		smbios_setenv("smbios.system.serial", addr, 0x07);
smbios_setuuid("smbios.system.uuid", addr + 0x08, ver);		smbios_setuuid("smbios.system.uuid", addr + 0x08, smbios.ver);
#endif		#endif
break;		break;

case 2: /* 3.3.3 Base Board (or Module) Information (Type 2) */		case 2: /* 3.3.3 Base Board (or Module) Information (Type 2) */
smbios_setenv("smbios.planar.maker", addr, 0x04);		smbios_setenv("smbios.planar.maker", addr, 0x04);
smbios_setenv("smbios.planar.product", addr, 0x05);		smbios_setenv("smbios.planar.product", addr, 0x05);
smbios_setenv("smbios.planar.version", addr, 0x06);		smbios_setenv("smbios.planar.version", addr, 0x06);
#ifdef SMBIOS_SERIAL_NUMBERS		#ifdef SMBIOS_SERIAL_NUMBERS
Show All 25 Lines	case 4: /* 3.3.5 Processor Information (Type 4) */
* 2h - CPU Disabled by User via BIOS Setup		* 2h - CPU Disabled by User via BIOS Setup
* 3h - CPU Disabled by BIOS (POST Error)		* 3h - CPU Disabled by BIOS (POST Error)
* 4h - CPU is Idle, waiting to be enabled		* 4h - CPU is Idle, waiting to be enabled
* 5-6h - Reserved		* 5-6h - Reserved
* 7h - Other		* 7h - Other
*/		*/
proc = SMBIOS_GET8(addr, 0x18);		proc = SMBIOS_GET8(addr, 0x18);
if ((proc & 0x07) == 1)		if ((proc & 0x07) == 1)
smbios_enabled_sockets++;		smbios.enabled_sockets++;
if ((proc & 0x40) != 0)		if ((proc & 0x40) != 0)
smbios_populated_sockets++;		smbios.populated_sockets++;
break;		break;

case 6: /* 3.3.7 Memory Module Information (Type 6, Obsolete) */		case 6: /* 3.3.7 Memory Module Information (Type 6, Obsolete) */
/*		/*
* Offset 0Ah: Enabled Size		* Offset 0Ah: Enabled Size
*		*
* Bit 7 Bank connection		* Bit 7 Bank connection
* 1 - Double-bank connection		* 1 - Double-bank connection
* 0 - Single-bank connection		* 0 - Single-bank connection
* Bit 6:0 Size (n), where 2**n is the size in MB		* Bit 6:0 Size (n), where 2**n is the size in MB
* 7Dh - Not determinable (Installed Size only)		* 7Dh - Not determinable (Installed Size only)
* 7Eh - Module is installed, but no memory		* 7Eh - Module is installed, but no memory
* has been enabled		* has been enabled
* 7Fh - Not installed		* 7Fh - Not installed
*/		*/
osize = SMBIOS_GET8(addr, 0x0a) & 0x7f;		osize = SMBIOS_GET8(addr, 0x0a) & 0x7f;
if (osize > 0 && osize < 22)		if (osize > 0 && osize < 22)
smbios_old_enabled_memory += 1 << (osize + 10);		smbios.old_enabled_memory += 1 << (osize + 10);
break;		break;

case 17: /* 3.3.18 Memory Device (Type 17) */		case 17: /* 3.3.18 Memory Device (Type 17) */
/*		/*
* Offset 0Ch: Size		* Offset 0Ch: Size
*		*
* Bit 15 Granularity		* Bit 15 Granularity
* 1 - Value is in kilobytes units		* 1 - Value is in kilobytes units
* 0 - Value is in megabytes units		* 0 - Value is in megabytes units
* Bit 14:0 Size		* Bit 14:0 Size
*/		*/
size = SMBIOS_GET16(addr, 0x0c);		size = SMBIOS_GET16(addr, 0x0c);
if (size != 0 && size != 0xffff)		if (size != 0 && size != 0xffff)
smbios_enabled_memory += (size & 0x8000) != 0 ?		smbios.enabled_memory += (size & 0x8000) != 0 ?
(size & 0x7fff) : (size << 10);		(size & 0x7fff) : (size << 10);
break;		break;

default: /* skip other types */		default: /* skip other types */
break;		break;
}		}

/* Find structure terminator. */		/* Find structure terminator. */
cp = SMBIOS_GETSTR(addr);		cp = SMBIOS_GETSTR(addr);
while (SMBIOS_GET16(cp, 0) != 0)		while (SMBIOS_GET16(cp, 0) != 0)
cp++;		cp++;

return (cp + 2);		return (cp + 2);
}		}

void		static void
smbios_detect(void)		smbios_probe(void)
{		{
char buf[16];		caddr_t saddr, info;
caddr_t addr, dmi, smbios;		u_int32_t paddr;
size_t count, length;
uint32_t paddr;
int i, major, minor, ver;

		if (smbios.probed)
		return;
		smbios.probed = 1;

/* Search signatures and validate checksums. */		/* Search signatures and validate checksums. */
smbios = smbios_sigsearch(PTOV(SMBIOS_START), SMBIOS_LENGTH);		saddr = smbios_sigsearch(PTOV(SMBIOS_START), SMBIOS_LENGTH);
if (smbios == NULL)		if (saddr == NULL)
return;		return;

length = SMBIOS_GET16(smbios, 0x16); /* Structure Table Length */		smbios.length = SMBIOS_GET16(saddr, 0x16); /* Structure Table Length */
paddr = SMBIOS_GET32(smbios, 0x18); /* Structure Table Address */		paddr = SMBIOS_GET32(saddr, 0x18); /* Structure Table Address */
count = SMBIOS_GET16(smbios, 0x1c); /* No of SMBIOS Structures */		smbios.count = SMBIOS_GET16(saddr, 0x1c); /* No of SMBIOS Structures */
ver = SMBIOS_GET8(smbios, 0x1e); /* SMBIOS BCD Revision */		smbios.ver = SMBIOS_GET8(saddr, 0x1e); /* SMBIOS BCD Revision */

if (ver != 0) {		if (smbios.ver != 0) {
major = ver >> 4;		smbios.major = smbios.ver >> 4;
minor = ver & 0x0f;		smbios.minor = smbios.ver & 0x0f;
if (major > 9 \|\| minor > 9)		if (smbios.major > 9 \|\| smbios.minor > 9)
ver = 0;		smbios.ver = 0;
}		}
if (ver == 0) {		if (smbios.ver == 0) {
major = SMBIOS_GET8(smbios, 0x06); /* SMBIOS Major Version */		smbios.major = SMBIOS_GET8(saddr, 0x06);/* SMBIOS Major Version */
minor = SMBIOS_GET8(smbios, 0x07); /* SMBIOS Minor Version */		smbios.minor = SMBIOS_GET8(saddr, 0x07);/* SMBIOS Minor Version */
}		}
ver = (major << 8) \| minor;		smbios.ver = (smbios.major << 8) \| smbios.minor;
		smbios.addr = PTOV(paddr);

addr = PTOV(paddr);		/* Get system information from SMBIOS */
for (dmi = addr, i = 0; dmi < addr + length && i < count; i++)		info = smbios_find_struct(0x00);
dmi = smbios_parse_table(dmi, ver);		if (info != NULL) {
		smbios.bios_vendor = smbios_getstring(info, 0x04);
		}
		info = smbios_find_struct(0x01);
		if (info != NULL) {
		smbios.maker = smbios_getstring(info, 0x04);
		smbios.product = smbios_getstring(info, 0x05);
		}
		}

sprintf(buf, "%d.%d", major, minor);		static caddr_t
		smbios_find_struct(int type)
		{
		caddr_t dmi;
		int i;

		if (smbios.addr == NULL)
		return (NULL);

		for (dmi = smbios.addr, i = 0;
		dmi < smbios.addr + smbios.length && i < smbios.count; i++) {
		if (SMBIOS_GET8(dmi, 0) == type)
		return dmi;
		/* Find structure terminator. */
		dmi = SMBIOS_GETSTR(dmi);
		while (SMBIOS_GET16(dmi, 0) != 0)
		dmi++;
		dmi += 2;
		}

		return (NULL);
		}

		void
		smbios_detect(void)
		{
		char buf[16];
		caddr_t dmi;
		int i;

		smbios_probe();
		if (smbios.addr == NULL)
		return;

		for (dmi = smbios.addr, i = 0;
		dmi < smbios.addr + smbios.length && i < smbios.count; i++)
		dmi = smbios_parse_table(dmi);

		sprintf(buf, "%d.%d", smbios.major, smbios.minor);
setenv("smbios.version", buf, 1);		setenv("smbios.version", buf, 1);
if (smbios_enabled_memory > 0 \|\| smbios_old_enabled_memory > 0) {		if (smbios.enabled_memory > 0 \|\| smbios.old_enabled_memory > 0) {
sprintf(buf, "%u", smbios_enabled_memory > 0 ?		sprintf(buf, "%u", smbios.enabled_memory > 0 ?
smbios_enabled_memory : smbios_old_enabled_memory);		smbios.enabled_memory : smbios.old_enabled_memory);
setenv("smbios.memory.enabled", buf, 1);		setenv("smbios.memory.enabled", buf, 1);
}		}
if (smbios_enabled_sockets > 0) {		if (smbios.enabled_sockets > 0) {
sprintf(buf, "%u", smbios_enabled_sockets);		sprintf(buf, "%u", smbios.enabled_sockets);
setenv("smbios.socket.enabled", buf, 1);		setenv("smbios.socket.enabled", buf, 1);
}		}
if (smbios_populated_sockets > 0) {		if (smbios.populated_sockets > 0) {
sprintf(buf, "%u", smbios_populated_sockets);		sprintf(buf, "%u", smbios.populated_sockets);
setenv("smbios.socket.populated", buf, 1);		setenv("smbios.socket.populated", buf, 1);
}		}
		}

		static int
		smbios_match_str(const char* s1, const char* s2)
		{
		return (s1 == NULL \|\| (s2 != NULL && !strcmp(s1, s2)));
		}

		int
		smbios_match(const char* bios_vendor, const char* maker,
		const char* product)
		{
		smbios_probe();
		return (smbios_match_str(bios_vendor, smbios.bios_vendor) &&
		smbios_match_str(maker, smbios.maker) &&
		smbios_match_str(product, smbios.product));
}		}

uart: uart_getenv: check for NULL class last, not firstClosedPublicActions