Re: [PATCH] ACPI: Implement overriding of arbitrary ACPI tables via initrd

["H. Peter Anvin" <hpa@kernel.org>]

[-- Attachment #1: Type: text/plain, Size: 622 bytes --]

On 03/24/2012 03:21 PM, H. Peter Anvin wrote:
> The attached cpio-parsing code compiles to 458 bytes on x86-64 and 476
> bytes on i386, and that is without any library dependencies at all.
> Again, it will completely stop at the first compressed data item, so any
> such kernel objects absolutely will have to be first.  In good Linux
> tradition, it is also completely untested.
> 
> However, given that very reasonable size I would think that this is a
> reasonable approach.  Anyone who has a better suggestion for the
> namespace than "kernel/"?
> 

Slightly improved version with actually working memcmp()...

	-hpa


[-- Attachment #2: findcpio.c --]
[-- Type: text/x-csrc, Size: 2814 bytes --]

/*
 * findcpio.c
 *
 * Find a specific cpio member; must precede any compressed content.
 */

#include <stddef.h>
#include <stdbool.h>

struct cpio_data {
	void *data;
	unsigned long size;
};

enum cpio_fields {
	C_INO,
	C_MODE,
	C_UID,
	C_GID,
	C_NLINK,
	C_MTIME,
	C_FILESIZE,
	C_MAJ,
	C_MIN,
	C_RMAJ,
	C_RMIN,
	C_NAMESIZE,
	C_CHKSUM,
	C_NFIELDS
};

/* Return true if this field is composed of valid hex digits */
static bool validhex(const char *ptr, int len)
{
	unsigned char c, x;

	while (len--) {
		c = *ptr++;

		x = c - '0';
		if (x < 10)
			continue;

		x = (c | 0x20) - 'a' + 10;
		if (x < 16)
			continue;

		return false;
	}

	return true;
}

/* Return the value of an already validated field */
static unsigned int hexval(const char *ptr, int len)
{
	unsigned int v = 0;
	unsigned char c, x;

	while (len--) {
		v <<= 4;
		c = *ptr++;

		x = c - '0';
		if (x < 10) {
			v += x;
			continue;
		}

		x = (c | 0x20) - 'a' + 10;
		v += x;
	}

	return v;
}

#if defined(__i386__) || defined(__x86_64__)
static size_t strlen(const char *name)
{
	size_t n = -1;

	asm("repne; scasb"
	    : "+D" (name), "+c" (n)
	    : "a" (0));

	return -2 - n;
}

static int memcmp(const void *p1, const void *p2, size_t n)
{
	unsigned char rv;

	asm("repe; cmpsb; setne %0"
	    : "=r" (rv), "+S" (p1), "+D" (p2), "+c" (n));

	return rv;
}
#else
static size_t strlen(const char *name)
{
	size_t n = 0;

	while (*name++)
		n++;

	return n;
}

static int memcmp(const void *p1, const void *p2, size_t n)
{
	const unsigned char *u1 = p1;
	const unsigned char *u2 = p2;
	int d;

	while (n--) {
		d = *u2++ - *u1++;
		if (d)
			return d;
	}
	return 0;
}
#endif

#define ALIGN4(p) ((void *)(((size_t)p + 3) & ~3))

struct cpio_data find_cpio_data(const char *name, const void *data, size_t len)
{
	const size_t cpio_header_len = 6 + 8*C_NFIELDS;
	struct cpio_data cd = { NULL, 0 };
	const char *p, *dptr, *nptr;
	unsigned int magic, ch[C_NFIELDS], *chp;
	size_t mynamesize = strlen(name) + 1;
	int i;

	p = data;

	while (len > cpio_header_len) {
		if (!*p) {
			/* All cpio headers need to be 4-byte aligned */
			p += 4;
			len -= 4;
			continue;
		}

		if (!validhex(p, cpio_header_len))
			break;	/* Not a valid cpio header */

		magic = hexval(p, 6);
		if ((magic - 0x070701) > 1)
			break;	/* Not a valid cpio magic */

		p += 6;
		chp = ch;
		for (i = 0; i < C_NFIELDS; i++) {
			*chp++ = hexval(p, 8);
			p += 8;

		}

		len -= cpio_header_len;

		dptr = ALIGN4(p + ch[C_NAMESIZE]);
		nptr = ALIGN4(dptr + ch[C_FILESIZE]);

		if (nptr > p + len)
			break;	/* Buffer overrun */

		if ((ch[C_MODE] & 0170000) == 0100000 &&
		    ch[C_NAMESIZE] == mynamesize &&
		    !memcmp(p, name, mynamesize)) {
			cd.data = (void *)dptr;
			cd.size = ch[C_FILESIZE];
			break;
		}

		len -= (nptr - p);
		p = nptr;
	}

	return cd;
}