[linux-2.6-block.git] / tools / testing / selftests / ia64 / aliasing-test.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Exercise /dev/mem mmap cases that have been troublesome in the past
 *
 * (c) Copyright 2007 Hewlett-Packard Development Company, L.P.
 *	Bjorn Helgaas <bjorn.helgaas@hp.com>
 */

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/pci.h>

int sum;

static int map_mem(char *path, off_t offset, size_t length, int touch)
{
	int fd, rc;
	void *addr;
	int *c;

	fd = open(path, O_RDWR);
	if (fd == -1) {
		perror(path);
		return -1;
	}

	if (fnmatch("/proc/bus/pci/*", path, 0) == 0) {
		rc = ioctl(fd, PCIIOC_MMAP_IS_MEM);
		if (rc == -1)
			perror("PCIIOC_MMAP_IS_MEM ioctl");
	}

	addr = mmap(NULL, length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset);
	if (addr == MAP_FAILED)
		return 1;

	if (touch) {
		c = (int *) addr;
		while (c < (int *) (addr + length))
			sum += *c++;
	}

	rc = munmap(addr, length);
	if (rc == -1) {
		perror("munmap");
		return -1;
	}

	close(fd);
	return 0;
}

static int scan_tree(char *path, char *file, off_t offset, size_t length, int touch)
{
	struct dirent **namelist;
	char *name, *path2;
	int i, n, r, rc = 0, result = 0;
	struct stat buf;

	n = scandir(path, &namelist, 0, alphasort);
	if (n < 0) {
		perror("scandir");
		return -1;
	}

	for (i = 0; i < n; i++) {
		name = namelist[i]->d_name;

		if (fnmatch(".", name, 0) == 0)
			goto skip;
		if (fnmatch("..", name, 0) == 0)
			goto skip;

		path2 = malloc(strlen(path) + strlen(name) + 3);
		strcpy(path2, path);
		strcat(path2, "/");
		strcat(path2, name);

		if (fnmatch(file, name, 0) == 0) {
			rc = map_mem(path2, offset, length, touch);
			if (rc == 0)
				fprintf(stderr, "PASS: %s 0x%lx-0x%lx is %s\n", path2, offset, offset + length, touch ? "readable" : "mappable");
			else if (rc > 0)
				fprintf(stderr, "PASS: %s 0x%lx-0x%lx not mappable\n", path2, offset, offset + length);
			else {
				fprintf(stderr, "FAIL: %s 0x%lx-0x%lx not accessible\n", path2, offset, offset + length);
				return rc;
			}
		} else {
			r = lstat(path2, &buf);
			if (r == 0 && S_ISDIR(buf.st_mode)) {
				rc = scan_tree(path2, file, offset, length, touch);
				if (rc < 0)
					return rc;
			}
		}

		result |= rc;
		free(path2);

skip:
		free(namelist[i]);
	}
	free(namelist);
	return result;
}

char buf[1024];

static int read_rom(char *path)
{
	int fd, rc;
	size_t size = 0;

	fd = open(path, O_RDWR);
	if (fd == -1) {
		perror(path);
		return -1;
	}

	rc = write(fd, "1", 2);
	if (rc <= 0) {
		close(fd);
		perror("write");
		return -1;
	}

	do {
		rc = read(fd, buf, sizeof(buf));
		if (rc > 0)
			size += rc;
	} while (rc > 0);

	close(fd);
	return size;
}

static int scan_rom(char *path, char *file)
{
	struct dirent **namelist;
	char *name, *path2;
	int i, n, r, rc = 0, result = 0;
	struct stat buf;

	n = scandir(path, &namelist, 0, alphasort);
	if (n < 0) {
		perror("scandir");
		return -1;
	}

	for (i = 0; i < n; i++) {
		name = namelist[i]->d_name;

		if (fnmatch(".", name, 0) == 0)
			goto skip;
		if (fnmatch("..", name, 0) == 0)
			goto skip;

		path2 = malloc(strlen(path) + strlen(name) + 3);
		strcpy(path2, path);
		strcat(path2, "/");
		strcat(path2, name);

		if (fnmatch(file, name, 0) == 0) {
			rc = read_rom(path2);

			/*
			 * It's OK if the ROM is unreadable.  Maybe there
			 * is no ROM, or some other error occurred.  The
			 * important thing is that no MCA happened.
			 */
			if (rc > 0)
				fprintf(stderr, "PASS: %s read %d bytes\n", path2, rc);
			else {
				fprintf(stderr, "PASS: %s not readable\n", path2);
				return rc;
			}
		} else {
			r = lstat(path2, &buf);
			if (r == 0 && S_ISDIR(buf.st_mode)) {
				rc = scan_rom(path2, file);
				if (rc < 0)
					return rc;
			}
		}

		result |= rc;
		free(path2);

skip:
		free(namelist[i]);
	}
	free(namelist);
	return result;
}

int main(void)
{
	int rc;

	if (map_mem("/dev/mem", 0, 0xA0000, 1) == 0)
		fprintf(stderr, "PASS: /dev/mem 0x0-0xa0000 is readable\n");
	else
		fprintf(stderr, "FAIL: /dev/mem 0x0-0xa0000 not accessible\n");

	/*
	 * It's not safe to blindly read the VGA frame buffer.  If you know
	 * how to poke the card the right way, it should respond, but it's
	 * not safe in general.  Many machines, e.g., Intel chipsets, cover
	 * up a non-responding card by just returning -1, but others will
	 * report the failure as a machine check.
	 */
	if (map_mem("/dev/mem", 0xA0000, 0x20000, 0) == 0)
		fprintf(stderr, "PASS: /dev/mem 0xa0000-0xc0000 is mappable\n");
	else
		fprintf(stderr, "FAIL: /dev/mem 0xa0000-0xc0000 not accessible\n");

	if (map_mem("/dev/mem", 0xC0000, 0x40000, 1) == 0)
		fprintf(stderr, "PASS: /dev/mem 0xc0000-0x100000 is readable\n");
	else
		fprintf(stderr, "FAIL: /dev/mem 0xc0000-0x100000 not accessible\n");

	/*
	 * Often you can map all the individual pieces above (0-0xA0000,
	 * 0xA0000-0xC0000, and 0xC0000-0x100000), but can't map the whole
	 * thing at once.  This is because the individual pieces use different
	 * attributes, and there's no single attribute supported over the
	 * whole region.
	 */
	rc = map_mem("/dev/mem", 0, 1024*1024, 0);
	if (rc == 0)
		fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 is mappable\n");
	else if (rc > 0)
		fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 not mappable\n");
	else
		fprintf(stderr, "FAIL: /dev/mem 0x0-0x100000 not accessible\n");

	scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 0xA0000, 1);
	scan_tree("/sys/class/pci_bus", "legacy_mem", 0xA0000, 0x20000, 0);
	scan_tree("/sys/class/pci_bus", "legacy_mem", 0xC0000, 0x40000, 1);
	scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 1024*1024, 0);

	scan_rom("/sys/devices", "rom");

	scan_tree("/proc/bus/pci", "??.?", 0, 0xA0000, 1);
	scan_tree("/proc/bus/pci", "??.?", 0xA0000, 0x20000, 0);
	scan_tree("/proc/bus/pci", "??.?", 0xC0000, 0x40000, 1);
	scan_tree("/proc/bus/pci", "??.?", 0, 1024*1024, 0);

	return rc;
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
ddd83eff BH	2	/*
	3	* Exercise /dev/mem mmap cases that have been troublesome in the past
	4	*
	5	* (c) Copyright 2007 Hewlett-Packard Development Company, L.P.
	6	* Bjorn Helgaas <bjorn.helgaas@hp.com>
ddd83eff BH	7	*/
	8
	9	#include <stdlib.h>
	10	#include <stdio.h>
	11	#include <sys/types.h>
	12	#include <dirent.h>
	13	#include <fcntl.h>
	14	#include <fnmatch.h>
	15	#include <string.h>
cdef24c9	16	#include <sys/ioctl.h>
ddd83eff BH	17	#include <sys/mman.h>
	18	#include <sys/stat.h>
	19	#include <unistd.h>
012b7105	20	#include <linux/pci.h>
ddd83eff BH	21
	22	int sum;
	23
b7ed698c	24	static int map_mem(char *path, off_t offset, size_t length, int touch)
ddd83eff BH	25	{
	26	int fd, rc;
	27	void *addr;
	28	int *c;
	29
	30	fd = open(path, O_RDWR);
	31	if (fd == -1) {
	32	perror(path);
	33	return -1;
	34	}
	35
012b7105 AC	36	if (fnmatch("/proc/bus/pci/*", path, 0) == 0) {
	37	rc = ioctl(fd, PCIIOC_MMAP_IS_MEM);
	38	if (rc == -1)
	39	perror("PCIIOC_MMAP_IS_MEM ioctl");
	40	}
	41
ddd83eff BH	42	addr = mmap(NULL, length, PROT_READ\|PROT_WRITE, MAP_SHARED, fd, offset);
	43	if (addr == MAP_FAILED)
	44	return 1;
	45
	46	if (touch) {
	47	c = (int *) addr;
012b7105	48	while (c < (int *) (addr + length))
ddd83eff BH	49	sum += *c++;
	50	}
	51
	52	rc = munmap(addr, length);
	53	if (rc == -1) {
	54	perror("munmap");
	55	return -1;
	56	}
	57
	58	close(fd);
	59	return 0;
	60	}
	61
b7ed698c	62	static int scan_tree(char path, char file, off_t offset, size_t length, int touch)
ddd83eff BH	63	{
	64	struct dirent **namelist;
	65	char name, path2;
cdef24c9	66	int i, n, r, rc = 0, result = 0;
ddd83eff BH	67	struct stat buf;
	68
	69	n = scandir(path, &namelist, 0, alphasort);
	70	if (n < 0) {
	71	perror("scandir");
	72	return -1;
	73	}
	74
	75	for (i = 0; i < n; i++) {
	76	name = namelist[i]->d_name;
	77
	78	if (fnmatch(".", name, 0) == 0)
	79	goto skip;
	80	if (fnmatch("..", name, 0) == 0)
	81	goto skip;
	82
	83	path2 = malloc(strlen(path) + strlen(name) + 3);
	84	strcpy(path2, path);
	85	strcat(path2, "/");
	86	strcat(path2, name);
	87
	88	if (fnmatch(file, name, 0) == 0) {
	89	rc = map_mem(path2, offset, length, touch);
	90	if (rc == 0)
	91	fprintf(stderr, "PASS: %s 0x%lx-0x%lx is %s\n", path2, offset, offset + length, touch ? "readable" : "mappable");
	92	else if (rc > 0)
	93	fprintf(stderr, "PASS: %s 0x%lx-0x%lx not mappable\n", path2, offset, offset + length);
	94	else {
	95	fprintf(stderr, "FAIL: %s 0x%lx-0x%lx not accessible\n", path2, offset, offset + length);
	96	return rc;
	97	}
	98	} else {
	99	r = lstat(path2, &buf);
	100	if (r == 0 && S_ISDIR(buf.st_mode)) {
012b7105	101	rc = scan_tree(path2, file, offset, length, touch);
ddd83eff BH	102	if (rc < 0)
	103	return rc;
	104	}
	105	}
	106
	107	result \|= rc;
	108	free(path2);
	109
	110	skip:
	111	free(namelist[i]);
	112	}
	113	free(namelist);
cdef24c9	114	return result;
ddd83eff BH	115	}
	116
	117	char buf[1024];
	118
b7ed698c	119	static int read_rom(char *path)
ddd83eff BH	120	{
	121	int fd, rc;
	122	size_t size = 0;
	123
	124	fd = open(path, O_RDWR);
	125	if (fd == -1) {
	126	perror(path);
	127	return -1;
	128	}
	129
	130	rc = write(fd, "1", 2);
	131	if (rc <= 0) {
5ffd27fa	132	close(fd);
ddd83eff BH	133	perror("write");
	134	return -1;
	135	}
	136
	137	do {
	138	rc = read(fd, buf, sizeof(buf));
	139	if (rc > 0)
	140	size += rc;
	141	} while (rc > 0);
	142
	143	close(fd);
	144	return size;
	145	}
	146
b7ed698c	147	static int scan_rom(char path, char file)
ddd83eff BH	148	{
	149	struct dirent **namelist;
	150	char name, path2;
cdef24c9	151	int i, n, r, rc = 0, result = 0;
ddd83eff BH	152	struct stat buf;
	153
	154	n = scandir(path, &namelist, 0, alphasort);
	155	if (n < 0) {
	156	perror("scandir");
	157	return -1;
	158	}
	159
	160	for (i = 0; i < n; i++) {
	161	name = namelist[i]->d_name;
	162
	163	if (fnmatch(".", name, 0) == 0)
	164	goto skip;
	165	if (fnmatch("..", name, 0) == 0)
	166	goto skip;
	167
	168	path2 = malloc(strlen(path) + strlen(name) + 3);
	169	strcpy(path2, path);
	170	strcat(path2, "/");
	171	strcat(path2, name);
	172
	173	if (fnmatch(file, name, 0) == 0) {
	174	rc = read_rom(path2);
	175
	176	/*
	177	* It's OK if the ROM is unreadable. Maybe there
25985edc	178	* is no ROM, or some other error occurred. The
ddd83eff BH	179	* important thing is that no MCA happened.
	180	*/
	181	if (rc > 0)
cdef24c9	182	fprintf(stderr, "PASS: %s read %d bytes\n", path2, rc);
ddd83eff BH	183	else {
	184	fprintf(stderr, "PASS: %s not readable\n", path2);
	185	return rc;
	186	}
	187	} else {
	188	r = lstat(path2, &buf);
	189	if (r == 0 && S_ISDIR(buf.st_mode)) {
	190	rc = scan_rom(path2, file);
	191	if (rc < 0)
	192	return rc;
	193	}
	194	}
	195
	196	result \|= rc;
	197	free(path2);
	198
	199	skip:
	200	free(namelist[i]);
	201	}
	202	free(namelist);
cdef24c9	203	return result;
ddd83eff BH	204	}
ddd83eff BH	205
cdef24c9	206	int main(void)
ddd83eff BH	207	{
	208	int rc;
	209
	210	if (map_mem("/dev/mem", 0, 0xA0000, 1) == 0)
	211	fprintf(stderr, "PASS: /dev/mem 0x0-0xa0000 is readable\n");
	212	else
	213	fprintf(stderr, "FAIL: /dev/mem 0x0-0xa0000 not accessible\n");
	214
	215	/*
	216	* It's not safe to blindly read the VGA frame buffer. If you know
	217	* how to poke the card the right way, it should respond, but it's
	218	* not safe in general. Many machines, e.g., Intel chipsets, cover
	219	* up a non-responding card by just returning -1, but others will
	220	* report the failure as a machine check.
	221	*/
	222	if (map_mem("/dev/mem", 0xA0000, 0x20000, 0) == 0)
	223	fprintf(stderr, "PASS: /dev/mem 0xa0000-0xc0000 is mappable\n");
	224	else
	225	fprintf(stderr, "FAIL: /dev/mem 0xa0000-0xc0000 not accessible\n");
	226
	227	if (map_mem("/dev/mem", 0xC0000, 0x40000, 1) == 0)
	228	fprintf(stderr, "PASS: /dev/mem 0xc0000-0x100000 is readable\n");
	229	else
	230	fprintf(stderr, "FAIL: /dev/mem 0xc0000-0x100000 not accessible\n");
	231
	232	/*
	233	* Often you can map all the individual pieces above (0-0xA0000,
	234	* 0xA0000-0xC0000, and 0xC0000-0x100000), but can't map the whole
	235	* thing at once. This is because the individual pieces use different
	236	* attributes, and there's no single attribute supported over the
	237	* whole region.
	238	*/
	239	rc = map_mem("/dev/mem", 0, 1024*1024, 0);
	240	if (rc == 0)
	241	fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 is mappable\n");
	242	else if (rc > 0)
	243	fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 not mappable\n");
	244	else
	245	fprintf(stderr, "FAIL: /dev/mem 0x0-0x100000 not accessible\n");
	246
012b7105 AC	247	scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 0xA0000, 1);
	248	scan_tree("/sys/class/pci_bus", "legacy_mem", 0xA0000, 0x20000, 0);
	249	scan_tree("/sys/class/pci_bus", "legacy_mem", 0xC0000, 0x40000, 1);
	250	scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 1024*1024, 0);
ddd83eff BH	251
ddd83eff BH	252	scan_rom("/sys/devices", "rom");
012b7105 AC	253
	254	scan_tree("/proc/bus/pci", "??.?", 0, 0xA0000, 1);
	255	scan_tree("/proc/bus/pci", "??.?", 0xA0000, 0x20000, 0);
	256	scan_tree("/proc/bus/pci", "??.?", 0xC0000, 0x40000, 1);
	257	scan_tree("/proc/bus/pci", "??.?", 0, 1024*1024, 0);
cdef24c9 RD	258
cdef24c9 RD	259	return rc;
ddd83eff	260	}