[mirror_ubuntu-jammy-kernel.git] / arch / um / os-Linux / tty_log.c

/*
 * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and
 * geoffrey hing <ghing@net.ohio-state.edu>
 * Licensed under the GPL
 */

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include "init.h"
#include "user.h"
#include "os.h"

#define TTY_LOG_DIR "./"

/* Set early in boot and then unchanged */
static char *tty_log_dir = TTY_LOG_DIR;
static int tty_log_fd = -1;

#define TTY_LOG_OPEN 1
#define TTY_LOG_CLOSE 2
#define TTY_LOG_WRITE 3
#define TTY_LOG_EXEC 4

#define TTY_READ 1
#define TTY_WRITE 2

struct tty_log_buf {
	int what;
	unsigned long tty;
	int len;
	int direction;
	unsigned long sec;
	unsigned long usec;
};

int open_tty_log(void *tty, void *current_tty)
{
	struct timeval tv;
	struct tty_log_buf data;
	char buf[strlen(tty_log_dir) + sizeof("01234567890-01234567\0")];
	int fd;

	gettimeofday(&tv, NULL);
	if(tty_log_fd != -1){
		data = ((struct tty_log_buf) { .what 	= TTY_LOG_OPEN,
					       .tty  = (unsigned long) tty,
					       .len  = sizeof(current_tty),
					       .direction = 0,
					       .sec = tv.tv_sec,
					       .usec = tv.tv_usec } );
		write(tty_log_fd, &data, sizeof(data));
		write(tty_log_fd, &current_tty, data.len);
		return tty_log_fd;
	}

	sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec,
 		(unsigned int) tv.tv_usec);

	fd = os_open_file(buf, of_append(of_create(of_rdwr(OPENFLAGS()))),
			  0644);
	if(fd < 0){
		printk("open_tty_log : couldn't open '%s', errno = %d\n",
		       buf, -fd);
	}
	return fd;
}

void close_tty_log(int fd, void *tty)
{
	struct tty_log_buf data;
	struct timeval tv;

	if(tty_log_fd != -1){
		gettimeofday(&tv, NULL);
		data = ((struct tty_log_buf) { .what 	= TTY_LOG_CLOSE,
					       .tty  = (unsigned long) tty,
					       .len  = 0,
					       .direction = 0,
					       .sec = tv.tv_sec,
					       .usec = tv.tv_usec } );
		write(tty_log_fd, &data, sizeof(data));
		return;
	}
	os_close_file(fd);
}

static int log_chunk(int fd, const char *buf, int len)
{
	int total = 0, try, missed, n;
	char chunk[64];

	while(len > 0){
		try = (len > sizeof(chunk)) ? sizeof(chunk) : len;
		missed = copy_from_user_proc(chunk, (char *) buf, try);
		try -= missed;
		n = write(fd, chunk, try);
		if(n != try) {
			if(n < 0)
				return -errno;
			return -EIO;
		}
		if(missed != 0)
			return -EFAULT;

		len -= try;
		total += try;
		buf += try;
	}

	return total;
}

int write_tty_log(int fd, const char *buf, int len, void *tty, int is_read)
{
	struct timeval tv;
	struct tty_log_buf data;
	int direction;

	if(fd == tty_log_fd){
		gettimeofday(&tv, NULL);
		direction = is_read ? TTY_READ : TTY_WRITE;
		data = ((struct tty_log_buf) { .what 	= TTY_LOG_WRITE,
					       .tty  = (unsigned long) tty,
					       .len  = len,
					       .direction = direction,
					       .sec = tv.tv_sec,
					       .usec = tv.tv_usec } );
		write(tty_log_fd, &data, sizeof(data));
	}

	return log_chunk(fd, buf, len);
}

void log_exec(char **argv, void *tty)
{
	struct timeval tv;
	struct tty_log_buf data;
	char **ptr,*arg;
	int len;

	if(tty_log_fd == -1) return;

	gettimeofday(&tv, NULL);

	len = 0;
	for(ptr = argv; ; ptr++){
		if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
			return;
		if(arg == NULL) break;
		len += strlen_user_proc(arg);
	}

	data = ((struct tty_log_buf) { .what 	= TTY_LOG_EXEC,
				       .tty  = (unsigned long) tty,
				       .len  = len,
				       .direction = 0,
				       .sec = tv.tv_sec,
				       .usec = tv.tv_usec } );
	write(tty_log_fd, &data, sizeof(data));

	for(ptr = argv; ; ptr++){
		if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
			return;
		if(arg == NULL) break;
		log_chunk(tty_log_fd, arg, strlen_user_proc(arg));
	}
}

extern void register_tty_logger(int (*opener)(void *, void *),
				int (*writer)(int, const char *, int,
					      void *, int),
				void (*closer)(int, void *));

static int register_logger(void)
{
	register_tty_logger(open_tty_log, write_tty_log, close_tty_log);
	return 0;
}

__uml_initcall(register_logger);

static int __init set_tty_log_dir(char *name, int *add)
{
	tty_log_dir = name;
	return 0;
}

__uml_setup("tty_log_dir=", set_tty_log_dir,
"tty_log_dir=<directory>\n"
"    This is used to specify the directory where the logs of all pty\n"
"    data from this UML machine will be written.\n\n"
);

static int __init set_tty_log_fd(char *name, int *add)
{
	char *end;

	tty_log_fd = strtoul(name, &end, 0);
	if((*end != '\0') || (end == name)){
		printf("set_tty_log_fd - strtoul failed on '%s'\n", name);
		tty_log_fd = -1;
	}

	*add = 0;
	return 0;
}

__uml_setup("tty_log_fd=", set_tty_log_fd,
"tty_log_fd=<fd>\n"
"    This is used to specify a preconfigured file descriptor to which all\n"
"    tty data will be written.  Preconfigure the descriptor with something\n"
"    like '10>tty_log tty_log_fd=10'.\n\n"
);
Commit	Line	Data
c554f899 JD	1	/*
c554f899 JD	2	* Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and
1da177e4 LT	3	* geoffrey hing <ghing@net.ohio-state.edu>
	4	* Licensed under the GPL
	5	*/
	6
	7	#include <errno.h>
	8	#include <string.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <unistd.h>
	12	#include <sys/time.h>
	13	#include "init.h"
	14	#include "user.h"
1da177e4 LT	15	#include "os.h"
	16
	17	#define TTY_LOG_DIR "./"
	18
	19	/* Set early in boot and then unchanged */
	20	static char *tty_log_dir = TTY_LOG_DIR;
	21	static int tty_log_fd = -1;
	22
	23	#define TTY_LOG_OPEN 1
	24	#define TTY_LOG_CLOSE 2
	25	#define TTY_LOG_WRITE 3
	26	#define TTY_LOG_EXEC 4
	27
	28	#define TTY_READ 1
	29	#define TTY_WRITE 2
	30
	31	struct tty_log_buf {
	32	int what;
	33	unsigned long tty;
	34	int len;
	35	int direction;
	36	unsigned long sec;
	37	unsigned long usec;
	38	};
	39
	40	int open_tty_log(void tty, void current_tty)
	41	{
	42	struct timeval tv;
	43	struct tty_log_buf data;
	44	char buf[strlen(tty_log_dir) + sizeof("01234567890-01234567\0")];
	45	int fd;
	46
	47	gettimeofday(&tv, NULL);
	48	if(tty_log_fd != -1){
	49	data = ((struct tty_log_buf) { .what = TTY_LOG_OPEN,
	50	.tty = (unsigned long) tty,
	51	.len = sizeof(current_tty),
	52	.direction = 0,
	53	.sec = tv.tv_sec,
	54	.usec = tv.tv_usec } );
a61f334f JD	55	write(tty_log_fd, &data, sizeof(data));
a61f334f JD	56	write(tty_log_fd, &current_tty, data.len);
ef0470c0	57	return tty_log_fd;
1da177e4 LT	58	}
1da177e4 LT	59
c554f899	60	sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec,
1da177e4 LT	61	(unsigned int) tv.tv_usec);
	62
	63	fd = os_open_file(buf, of_append(of_create(of_rdwr(OPENFLAGS()))),
	64	0644);
	65	if(fd < 0){
	66	printk("open_tty_log : couldn't open '%s', errno = %d\n",
	67	buf, -fd);
	68	}
ef0470c0	69	return fd;
1da177e4 LT	70	}
	71
	72	void close_tty_log(int fd, void *tty)
	73	{
	74	struct tty_log_buf data;
	75	struct timeval tv;
	76
	77	if(tty_log_fd != -1){
	78	gettimeofday(&tv, NULL);
	79	data = ((struct tty_log_buf) { .what = TTY_LOG_CLOSE,
	80	.tty = (unsigned long) tty,
	81	.len = 0,
	82	.direction = 0,
	83	.sec = tv.tv_sec,
	84	.usec = tv.tv_usec } );
a61f334f	85	write(tty_log_fd, &data, sizeof(data));
1da177e4 LT	86	return;
	87	}
	88	os_close_file(fd);
	89	}
	90
	91	static int log_chunk(int fd, const char *buf, int len)
	92	{
	93	int total = 0, try, missed, n;
	94	char chunk[64];
	95
	96	while(len > 0){
	97	try = (len > sizeof(chunk)) ? sizeof(chunk) : len;
	98	missed = copy_from_user_proc(chunk, (char *) buf, try);
	99	try -= missed;
a61f334f	100	n = write(fd, chunk, try);
1da177e4 LT	101	if(n != try) {
1da177e4 LT	102	if(n < 0)
a61f334f	103	return -errno;
ef0470c0	104	return -EIO;
1da177e4 LT	105	}
1da177e4 LT	106	if(missed != 0)
ef0470c0	107	return -EFAULT;
1da177e4 LT	108
	109	len -= try;
	110	total += try;
	111	buf += try;
	112	}
	113
ef0470c0	114	return total;
1da177e4 LT	115	}
	116
	117	int write_tty_log(int fd, const char buf, int len, void tty, int is_read)
	118	{
	119	struct timeval tv;
	120	struct tty_log_buf data;
	121	int direction;
	122
	123	if(fd == tty_log_fd){
	124	gettimeofday(&tv, NULL);
	125	direction = is_read ? TTY_READ : TTY_WRITE;
	126	data = ((struct tty_log_buf) { .what = TTY_LOG_WRITE,
	127	.tty = (unsigned long) tty,
	128	.len = len,
	129	.direction = direction,
	130	.sec = tv.tv_sec,
	131	.usec = tv.tv_usec } );
a61f334f	132	write(tty_log_fd, &data, sizeof(data));
1da177e4 LT	133	}
1da177e4 LT	134
ef0470c0	135	return log_chunk(fd, buf, len);
1da177e4 LT	136	}
	137
	138	void log_exec(char *argv, void tty)
	139	{
	140	struct timeval tv;
	141	struct tty_log_buf data;
	142	char *ptr,arg;
	143	int len;
	144
	145	if(tty_log_fd == -1) return;
	146
	147	gettimeofday(&tv, NULL);
	148
	149	len = 0;
	150	for(ptr = argv; ; ptr++){
	151	if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
	152	return;
	153	if(arg == NULL) break;
	154	len += strlen_user_proc(arg);
	155	}
	156
	157	data = ((struct tty_log_buf) { .what = TTY_LOG_EXEC,
	158	.tty = (unsigned long) tty,
	159	.len = len,
	160	.direction = 0,
	161	.sec = tv.tv_sec,
	162	.usec = tv.tv_usec } );
a61f334f	163	write(tty_log_fd, &data, sizeof(data));
1da177e4 LT	164
	165	for(ptr = argv; ; ptr++){
	166	if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
	167	return;
	168	if(arg == NULL) break;
	169	log_chunk(tty_log_fd, arg, strlen_user_proc(arg));
	170	}
	171	}
	172
	173	extern void register_tty_logger(int (opener)(void , void *),
	174	int (writer)(int, const char , int,
	175	void *, int),
	176	void (closer)(int, void ));
	177
	178	static int register_logger(void)
	179	{
	180	register_tty_logger(open_tty_log, write_tty_log, close_tty_log);
ef0470c0	181	return 0;
1da177e4 LT	182	}
	183
	184	__uml_initcall(register_logger);
	185
	186	static int __init set_tty_log_dir(char name, int add)
	187	{
	188	tty_log_dir = name;
	189	return 0;
	190	}
	191
	192	__uml_setup("tty_log_dir=", set_tty_log_dir,
	193	"tty_log_dir=<directory>\n"
	194	" This is used to specify the directory where the logs of all pty\n"
	195	" data from this UML machine will be written.\n\n"
	196	);
	197
	198	static int __init set_tty_log_fd(char name, int add)
	199	{
	200	char *end;
	201
	202	tty_log_fd = strtoul(name, &end, 0);
	203	if((*end != '\0') \|\| (end == name)){
	204	printf("set_tty_log_fd - strtoul failed on '%s'\n", name);
	205	tty_log_fd = -1;
	206	}
	207
	208	*add = 0;
	209	return 0;
	210	}
	211
	212	__uml_setup("tty_log_fd=", set_tty_log_fd,
	213	"tty_log_fd=<fd>\n"
	214	" This is used to specify a preconfigured file descriptor to which all\n"
	215	" tty data will be written. Preconfigure the descriptor with something\n"
	216	" like '10>tty_log tty_log_fd=10'.\n\n"
	217	);