[warm.git] / warm.c

/*
 * wARM - exporting ARM processor specific privileged services to userspace
 * userspace part
 *
 * Copyright (c) Gražvydas "notaz" Ignotas, 2009
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the organization nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <sys/syscall.h>
#include <errno.h>

#define WARM_CODE
#include "warm.h"

#define PFX "wARM: "

/* provided by glibc */
extern long init_module(void *, unsigned long, const char *);
extern long delete_module(const char *, unsigned int);

static int warm_fd = -1;
static int kernel_version;
static int module_inserted;

static void sys_cacheflush(void *start, void *end)
{
#ifdef __ARM_EABI__
	/* EABI version */
	int num = __ARM_NR_cacheflush;
	__asm__("mov  r0, %0 ;"
		"mov  r1, %1 ;"
		"mov  r2, #0 ;"
		"mov  r7, %2 ;"
		"swi  0" : : "r" (start), "r" (end), "r" (num)
			: "r0", "r1", "r2", "r3", "r7");
#else
	/* OABI */
	__asm__("mov  r0, %0 ;"
		"mov  r1, %1 ;"
		"mov  r2, #0 ;"
		"swi  %2" : : "r" (start), "r" (end), "i" __ARM_NR_cacheflush
			: "r0", "r1", "r2", "r3");
#endif
}

/* Those are here because system() occasionaly fails on Wiz
 * with errno 12 for some unknown reason */
static int manual_insmod_26(const char *fname, const char *opts)
{
	unsigned long len, read_len;
	int ret = -1;
	void *buff;
	FILE *f;

	f = fopen(fname, "rb");
	if (f == NULL)
		return -1;

	fseek(f, 0, SEEK_END);
	len = ftell(f);
	fseek(f, 0, SEEK_SET);

	buff = malloc(len);
	if (buff == NULL)
		goto fail0;

	read_len = fread(buff, 1, len, f);
	if (read_len != len) {
		fprintf(stderr, PFX "failed to read module\n");
		goto fail1;
	}

	ret = init_module(buff, len, opts);

fail1:
	free(buff);
fail0:
	fclose(f);
	return ret;
}

static int manual_rmmod(const char *name)
{
	return delete_module(name, O_NONBLOCK|O_EXCL);
}

int warm_init(void)
{
	struct utsname unm;
	char buff1[32], buff2[128];
	int ret;

	memset(&unm, 0, sizeof(unm));
	uname(&unm);

	if (strlen(unm.release) < 3 || unm.release[1] != '.') {
		fprintf(stderr, PFX "unexpected version string: %s\n", unm.release);
		goto fail;
	}
	kernel_version = ((unm.release[0] - '0') << 4) | (unm.release[2] - '0');

	warm_fd = open("/proc/warm", O_RDWR);
	if (warm_fd >= 0)
		return 0;

	snprintf(buff1, sizeof(buff1), "warm_%s.%s", unm.release, kernel_version >= 0x26 ? "ko" : "o");
	snprintf(buff2, sizeof(buff2), "/sbin/insmod %s verbose=1", buff1);

	/* try to insmod */
	ret = system(buff2);
	if (ret != 0) {
		fprintf(stderr, PFX "system/insmod failed: %d %d\n", ret, errno);
		if (kernel_version >= 0x26) {
			ret = manual_insmod_26(buff1, "verbose=1");
			if (ret != 0)
				fprintf(stderr, PFX "manual insmod also failed: %d\n", ret);
		}
	}
	if (ret == 0)
		module_inserted = 1;

	warm_fd = open("/proc/warm", O_RDWR);
	if (warm_fd >= 0)
		return 0;

fail:
	fprintf(stderr, PFX "can't init, acting as sys_cacheflush wrapper\n");
	return -1;
}

void warm_finish(void)
{
	char name[32], cmd[64];
	int ret;

	if (warm_fd < 0)
		return;

	close(warm_fd);
	warm_fd = -1;

	if (module_inserted) {
		if (kernel_version < 0x26) {
			struct utsname unm;
			memset(&unm, 0, sizeof(unm));
			uname(&unm);
			snprintf(name, sizeof(name), "warm_%s", unm.release);
		}
		else
			strcpy(name, "warm");

		snprintf(cmd, sizeof(cmd), "/sbin/rmmod %s", name);
		ret = system(cmd);
		if (ret != 0) {
			fprintf(stderr, PFX "system/rmmod failed: %d %d\n", ret, errno);
			manual_rmmod(name);
		}
	}
}

int warm_cache_op_range(int op, void *addr, unsigned long size)
{
	struct warm_cache_op wop;
	int ret;

	if (warm_fd < 0) {
		/* note that this won't work for warm_cache_op_all */
		sys_cacheflush(addr, (char *)addr + size);
		return -1;
	}

	wop.ops = op;
	wop.addr = (unsigned long)addr;
	wop.size = size;

	ret = ioctl(warm_fd, WARMC_CACHE_OP, &wop);
	if (ret != 0) {
		perror("WARMC_CACHE_OP failed");
		return -1;
	}

	return 0;
}

int warm_cache_op_all(int op)
{
	return warm_cache_op_range(op, NULL, (unsigned long)-1);
}

int warm_change_cb_range(int cb, int is_set, void *addr, unsigned long size)
{
	struct warm_change_cb ccb;
	int ret;

	if (warm_fd < 0)
		return -1;
	
	ccb.addr = (unsigned long)addr;
	ccb.size = size;
	ccb.cb = cb;
	ccb.is_set = is_set;

	ret = ioctl(warm_fd, WARMC_CHANGE_CB, &ccb);
	if (ret != 0) {
		perror("WARMC_CHANGE_CB failed");
		return -1;
	}

	return 0;
}

int warm_change_cb_upper(int cb, int is_set)
{
	return warm_change_cb_range(cb, is_set, 0, 0);
}

unsigned long warm_virt2phys(const void *ptr)
{
	unsigned long ptrio;
	int ret;

	ptrio = (unsigned long)ptr;
	ret = ioctl(warm_fd, WARMC_VIRT2PHYS, &ptrio);
	if (ret != 0) {
		perror("WARMC_VIRT2PHYS failed");
		return (unsigned long)-1;
	}

	return ptrio;
}
Commit	Line	Data
198a1649	1	/*
	2	* wARM - exporting ARM processor specific privileged services to userspace
	3	* userspace part
	4	*
	5	* Copyright (c) Gražvydas "notaz" Ignotas, 2009
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions are met:
	9	* * Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* * Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* * Neither the name of the organization nor the
	15	* names of its contributors may be used to endorse or promote products
	16	* derived from this software without specific prior written permission.
	17	*
	18	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	19	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	20	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	21	* ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	22	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	24	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	25	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	26	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	27	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	28	*/
	29
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33	#include <sys/types.h>
	34	#include <sys/stat.h>
	35	#include <unistd.h>
	36	#include <fcntl.h>
	37	#include <sys/ioctl.h>
	38	#include <sys/utsname.h>
cc951732	39	#include <sys/syscall.h>
198a1649	40	#include <errno.h>
	41
	42	#define WARM_CODE
	43	#include "warm.h"
cc951732	44
bee2f7fb	45	#define PFX "wARM: "
bee2f7fb	46
f43e9610	47	/* provided by glibc */
	48	extern long init_module(void , unsigned long, const char );
	49	extern long delete_module(const char *, unsigned int);
198a1649	50
198a1649	51	static int warm_fd = -1;
cc951732	52	static int kernel_version;
c682a397	53	static int module_inserted;
cc951732	54
	55	static void sys_cacheflush(void start, void end)
	56	{
	57	#ifdef __ARM_EABI__
	58	/* EABI version */
	59	int num = __ARM_NR_cacheflush;
	60	__asm__("mov r0, %0 ;"
	61	"mov r1, %1 ;"
	62	"mov r2, #0 ;"
	63	"mov r7, %2 ;"
	64	"swi 0" : : "r" (start), "r" (end), "r" (num)
	65	: "r0", "r1", "r2", "r3", "r7");
	66	#else
	67	/* OABI */
	68	__asm__("mov r0, %0 ;"
	69	"mov r1, %1 ;"
	70	"mov r2, #0 ;"
	71	"swi %2" : : "r" (start), "r" (end), "i" __ARM_NR_cacheflush
	72	: "r0", "r1", "r2", "r3");
	73	#endif
	74	}
	75
f43e9610	76	/* Those are here because system() occasionaly fails on Wiz
f43e9610	77	* with errno 12 for some unknown reason */
cc951732	78	static int manual_insmod_26(const char fname, const char opts)
	79	{
	80	unsigned long len, read_len;
	81	int ret = -1;
	82	void *buff;
	83	FILE *f;
	84
	85	f = fopen(fname, "rb");
	86	if (f == NULL)
	87	return -1;
	88
	89	fseek(f, 0, SEEK_END);
	90	len = ftell(f);
	91	fseek(f, 0, SEEK_SET);
	92
	93	buff = malloc(len);
	94	if (buff == NULL)
	95	goto fail0;
	96
	97	read_len = fread(buff, 1, len, f);
	98	if (read_len != len) {
bee2f7fb	99	fprintf(stderr, PFX "failed to read module\n");
cc951732	100	goto fail1;
	101	}
	102
	103	ret = init_module(buff, len, opts);
	104
	105	fail1:
	106	free(buff);
	107	fail0:
	108	fclose(f);
	109	return ret;
	110	}
198a1649	111
f43e9610	112	static int manual_rmmod(const char *name)
	113	{
	114	return delete_module(name, O_NONBLOCK\|O_EXCL);
	115	}
	116
198a1649	117	int warm_init(void)
	118	{
	119	struct utsname unm;
cc951732	120	char buff1[32], buff2[128];
cc951732	121	int ret;
198a1649	122
198a1649	123	memset(&unm, 0, sizeof(unm));
198a1649	124	uname(&unm);
cc951732	125
cc951732	126	if (strlen(unm.release) < 3 \|\| unm.release[1] != '.') {
bee2f7fb	127	fprintf(stderr, PFX "unexpected version string: %s\n", unm.release);
cc951732	128	goto fail;
	129	}
	130	kernel_version = ((unm.release[0] - '0') << 4) \| (unm.release[2] - '0');
	131
f43e9610	132	warm_fd = open("/proc/warm", O_RDWR);
	133	if (warm_fd >= 0)
	134	return 0;
	135
cc951732	136	snprintf(buff1, sizeof(buff1), "warm_%s.%s", unm.release, kernel_version >= 0x26 ? "ko" : "o");
cc951732	137	snprintf(buff2, sizeof(buff2), "/sbin/insmod %s verbose=1", buff1);
198a1649	138
198a1649	139	/* try to insmod */
cc951732	140	ret = system(buff2);
cc951732	141	if (ret != 0) {
bee2f7fb	142	fprintf(stderr, PFX "system/insmod failed: %d %d\n", ret, errno);
cc951732	143	if (kernel_version >= 0x26) {
	144	ret = manual_insmod_26(buff1, "verbose=1");
	145	if (ret != 0)
bee2f7fb	146	fprintf(stderr, PFX "manual insmod also failed: %d\n", ret);
cc951732	147	}
cc951732	148	}
c682a397	149	if (ret == 0)
c682a397	150	module_inserted = 1;
cc951732	151
198a1649	152	warm_fd = open("/proc/warm", O_RDWR);
	153	if (warm_fd >= 0)
	154	return 0;
	155
cc951732	156	fail:
bee2f7fb	157	fprintf(stderr, PFX "can't init, acting as sys_cacheflush wrapper\n");
198a1649	158	return -1;
	159	}
	160
	161	void warm_finish(void)
	162	{
f43e9610	163	char name[32], cmd[64];
f43e9610	164	int ret;
cc951732	165
	166	if (warm_fd < 0)
	167	return;
	168
	169	close(warm_fd);
	170	warm_fd = -1;
	171
c682a397	172	if (module_inserted) {
	173	if (kernel_version < 0x26) {
	174	struct utsname unm;
	175	memset(&unm, 0, sizeof(unm));
	176	uname(&unm);
	177	snprintf(name, sizeof(name), "warm_%s", unm.release);
	178	}
	179	else
	180	strcpy(name, "warm");
	181
	182	snprintf(cmd, sizeof(cmd), "/sbin/rmmod %s", name);
	183	ret = system(cmd);
	184	if (ret != 0) {
	185	fprintf(stderr, PFX "system/rmmod failed: %d %d\n", ret, errno);
	186	manual_rmmod(name);
	187	}
f43e9610	188	}
198a1649	189	}
	190
	191	int warm_cache_op_range(int op, void *addr, unsigned long size)
	192	{
	193	struct warm_cache_op wop;
	194	int ret;
	195
	196	if (warm_fd < 0) {
cc951732	197	/* note that this won't work for warm_cache_op_all */
198a1649	198	sys_cacheflush(addr, (char *)addr + size);
	199	return -1;
	200	}
	201
	202	wop.ops = op;
	203	wop.addr = (unsigned long)addr;
	204	wop.size = size;
	205
	206	ret = ioctl(warm_fd, WARMC_CACHE_OP, &wop);
	207	if (ret != 0) {
	208	perror("WARMC_CACHE_OP failed");
	209	return -1;
	210	}
	211
	212	return 0;
	213	}
	214
	215	int warm_cache_op_all(int op)
	216	{
cc951732	217	return warm_cache_op_range(op, NULL, (unsigned long)-1);
198a1649	218	}
	219
	220	int warm_change_cb_range(int cb, int is_set, void *addr, unsigned long size)
	221	{
	222	struct warm_change_cb ccb;
	223	int ret;
	224
	225	if (warm_fd < 0)
	226	return -1;
	227
	228	ccb.addr = (unsigned long)addr;
	229	ccb.size = size;
	230	ccb.cb = cb;
	231	ccb.is_set = is_set;
	232
	233	ret = ioctl(warm_fd, WARMC_CHANGE_CB, &ccb);
	234	if (ret != 0) {
	235	perror("WARMC_CHANGE_CB failed");
	236	return -1;
	237	}
	238
	239	return 0;
	240	}
	241
	242	int warm_change_cb_upper(int cb, int is_set)
	243	{
	244	return warm_change_cb_range(cb, is_set, 0, 0);
	245	}
	246
	247	unsigned long warm_virt2phys(const void *ptr)
	248	{
	249	unsigned long ptrio;
	250	int ret;
	251
	252	ptrio = (unsigned long)ptr;
	253	ret = ioctl(warm_fd, WARMC_VIRT2PHYS, &ptrio);
	254	if (ret != 0) {
	255	perror("WARMC_VIRT2PHYS failed");
	256	return (unsigned long)-1;
	257	}
	258
	259	return ptrio;
	260	}
	261