[linux.git] / arch / um / os-Linux / file.c

/*
 * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <os.h>

static void copy_stat(struct uml_stat *dst, const struct stat64 *src)
{
	*dst = ((struct uml_stat) {
		.ust_dev     = src->st_dev,     /* device */
		.ust_ino     = src->st_ino,     /* inode */
		.ust_mode    = src->st_mode,    /* protection */
		.ust_nlink   = src->st_nlink,   /* number of hard links */
		.ust_uid     = src->st_uid,     /* user ID of owner */
		.ust_gid     = src->st_gid,     /* group ID of owner */
		.ust_size    = src->st_size,    /* total size, in bytes */
		.ust_blksize = src->st_blksize, /* blocksize for filesys I/O */
		.ust_blocks  = src->st_blocks,  /* number of blocks allocated */
		.ust_atime   = src->st_atime,   /* time of last access */
		.ust_mtime   = src->st_mtime,   /* time of last modification */
		.ust_ctime   = src->st_ctime,   /* time of last change */
	});
}

int os_stat_fd(const int fd, struct uml_stat *ubuf)
{
	struct stat64 sbuf;
	int err;

	CATCH_EINTR(err = fstat64(fd, &sbuf));
	if (err < 0)
		return -errno;

	if (ubuf != NULL)
		copy_stat(ubuf, &sbuf);
	return err;
}

int os_stat_file(const char *file_name, struct uml_stat *ubuf)
{
	struct stat64 sbuf;
	int err;

	CATCH_EINTR(err = stat64(file_name, &sbuf));
	if (err < 0)
		return -errno;

	if (ubuf != NULL)
		copy_stat(ubuf, &sbuf);
	return err;
}

int os_access(const char *file, int mode)
{
	int amode, err;

	amode = (mode & OS_ACC_R_OK ? R_OK : 0) |
		(mode & OS_ACC_W_OK ? W_OK : 0) |
		(mode & OS_ACC_X_OK ? X_OK : 0) |
		(mode & OS_ACC_F_OK ? F_OK : 0);

	err = access(file, amode);
	if (err < 0)
		return -errno;

	return 0;
}

/* FIXME? required only by hostaudio (because it passes ioctls verbatim) */
int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
{
	int err;

	err = ioctl(fd, cmd, arg);
	if (err < 0)
		return -errno;

	return err;
}

/* FIXME: ensure namebuf in os_get_if_name is big enough */
int os_get_ifname(int fd, char* namebuf)
{
	if (ioctl(fd, SIOCGIFNAME, namebuf) < 0)
		return -errno;

	return 0;
}

int os_set_slip(int fd)
{
	int disc, sencap;

	disc = N_SLIP;
	if (ioctl(fd, TIOCSETD, &disc) < 0)
		return -errno;

	sencap = 0;
	if (ioctl(fd, SIOCSIFENCAP, &sencap) < 0)
		return -errno;

	return 0;
}

int os_mode_fd(int fd, int mode)
{
	int err;

	CATCH_EINTR(err = fchmod(fd, mode));
	if (err < 0)
		return -errno;

	return 0;
}

int os_file_type(char *file)
{
	struct uml_stat buf;
	int err;

	err = os_stat_file(file, &buf);
	if (err < 0)
		return err;

	if (S_ISDIR(buf.ust_mode))
		return OS_TYPE_DIR;
	else if (S_ISLNK(buf.ust_mode))
		return OS_TYPE_SYMLINK;
	else if (S_ISCHR(buf.ust_mode))
		return OS_TYPE_CHARDEV;
	else if (S_ISBLK(buf.ust_mode))
		return OS_TYPE_BLOCKDEV;
	else if (S_ISFIFO(buf.ust_mode))
		return OS_TYPE_FIFO;
	else if (S_ISSOCK(buf.ust_mode))
		return OS_TYPE_SOCK;
	else return OS_TYPE_FILE;
}

int os_file_mode(const char *file, struct openflags *mode_out)
{
	int err;

	*mode_out = OPENFLAGS();

	err = access(file, W_OK);
	if (err && (errno != EACCES))
		return -errno;
	else if (!err)
		*mode_out = of_write(*mode_out);

	err = access(file, R_OK);
	if (err && (errno != EACCES))
		return -errno;
	else if (!err)
		*mode_out = of_read(*mode_out);

	return err;
}

int os_open_file(const char *file, struct openflags flags, int mode)
{
	int fd, err, f = 0;

	if (flags.r && flags.w)
		f = O_RDWR;
	else if (flags.r)
		f = O_RDONLY;
	else if (flags.w)
		f = O_WRONLY;
	else f = 0;

	if (flags.s)
		f |= O_SYNC;
	if (flags.c)
		f |= O_CREAT;
	if (flags.t)
		f |= O_TRUNC;
	if (flags.e)
		f |= O_EXCL;
	if (flags.a)
		f |= O_APPEND;

	fd = open64(file, f, mode);
	if (fd < 0)
		return -errno;

	if (flags.cl && fcntl(fd, F_SETFD, 1)) {
		err = -errno;
		close(fd);
		return err;
	}

	return fd;
}

int os_connect_socket(const char *name)
{
	struct sockaddr_un sock;
	int fd, err;

	sock.sun_family = AF_UNIX;
	snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);

	fd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (fd < 0) {
		err = -errno;
		goto out;
	}

	err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
	if (err) {
		err = -errno;
		goto out_close;
	}

	return fd;

out_close:
	close(fd);
out:
	return err;
}

void os_close_file(int fd)
{
	close(fd);
}
int os_fsync_file(int fd)
{
	if (fsync(fd) < 0)
	    return -errno;
	return 0;
}

int os_seek_file(int fd, unsigned long long offset)
{
	unsigned long long actual;

	actual = lseek64(fd, offset, SEEK_SET);
	if (actual != offset)
		return -errno;
	return 0;
}

int os_read_file(int fd, void *buf, int len)
{
	int n = read(fd, buf, len);

	if (n < 0)
		return -errno;
	return n;
}

int os_write_file(int fd, const void *buf, int len)
{
	int n = write(fd, (void *) buf, len);

	if (n < 0)
		return -errno;
	return n;
}

int os_sync_file(int fd)
{
	int n = fsync(fd);

	if (n < 0)
		return -errno;
	return n;
}

int os_file_size(const char *file, unsigned long long *size_out)
{
	struct uml_stat buf;
	int err;

	err = os_stat_file(file, &buf);
	if (err < 0) {
		printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
		       -err);
		return err;
	}

	if (S_ISBLK(buf.ust_mode)) {
		int fd;
		long blocks;

		fd = open(file, O_RDONLY, 0);
		if (fd < 0) {
			err = -errno;
			printk(UM_KERN_ERR "Couldn't open \"%s\", "
			       "errno = %d\n", file, errno);
			return err;
		}
		if (ioctl(fd, BLKGETSIZE, &blocks) < 0) {
			err = -errno;
			printk(UM_KERN_ERR "Couldn't get the block size of "
			       "\"%s\", errno = %d\n", file, errno);
			close(fd);
			return err;
		}
		*size_out = ((long long) blocks) * 512;
		close(fd);
	}
	else *size_out = buf.ust_size;

	return 0;
}

int os_file_modtime(const char *file, unsigned long *modtime)
{
	struct uml_stat buf;
	int err;

	err = os_stat_file(file, &buf);
	if (err < 0) {
		printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
		       -err);
		return err;
	}

	*modtime = buf.ust_mtime;
	return 0;
}

int os_set_exec_close(int fd)
{
	int err;

	CATCH_EINTR(err = fcntl(fd, F_SETFD, FD_CLOEXEC));

	if (err < 0)
		return -errno;
	return err;
}

int os_pipe(int *fds, int stream, int close_on_exec)
{
	int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;

	err = socketpair(AF_UNIX, type, 0, fds);
	if (err < 0)
		return -errno;

	if (!close_on_exec)
		return 0;

	err = os_set_exec_close(fds[0]);
	if (err < 0)
		goto error;

	err = os_set_exec_close(fds[1]);
	if (err < 0)
		goto error;

	return 0;

 error:
	printk(UM_KERN_ERR "os_pipe : Setting FD_CLOEXEC failed, err = %d\n",
	       -err);
	close(fds[1]);
	close(fds[0]);
	return err;
}

int os_set_fd_async(int fd)
{
	int err, flags;

	flags = fcntl(fd, F_GETFL);
	if (flags < 0)
		return -errno;

	flags |= O_ASYNC | O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) {
		err = -errno;
		printk(UM_KERN_ERR "os_set_fd_async : failed to set O_ASYNC "
		       "and O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
		return err;
	}

	if ((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
	    (fcntl(fd, F_SETOWN, os_getpid()) < 0)) {
		err = -errno;
		printk(UM_KERN_ERR "os_set_fd_async : Failed to fcntl F_SETOWN "
		       "(or F_SETSIG) fd %d, errno = %d\n", fd, errno);
		return err;
	}

	return 0;
}

int os_clear_fd_async(int fd)
{
	int flags;

	flags = fcntl(fd, F_GETFL);
	if (flags < 0)
		return -errno;

	flags &= ~(O_ASYNC | O_NONBLOCK);
	if (fcntl(fd, F_SETFL, flags) < 0)
		return -errno;
	return 0;
}

int os_set_fd_block(int fd, int blocking)
{
	int flags;

	flags = fcntl(fd, F_GETFL);
	if (flags < 0)
		return -errno;

	if (blocking)
		flags &= ~O_NONBLOCK;
	else
		flags |= O_NONBLOCK;

	if (fcntl(fd, F_SETFL, flags) < 0)
		return -errno;

	return 0;
}

int os_accept_connection(int fd)
{
	int new;

	new = accept(fd, NULL, 0);
	if (new < 0)
		return -errno;
	return new;
}

#ifndef SHUT_RD
#define SHUT_RD 0
#endif

#ifndef SHUT_WR
#define SHUT_WR 1
#endif

#ifndef SHUT_RDWR
#define SHUT_RDWR 2
#endif

int os_shutdown_socket(int fd, int r, int w)
{
	int what, err;

	if (r && w)
		what = SHUT_RDWR;
	else if (r)
		what = SHUT_RD;
	else if (w)
		what = SHUT_WR;
	else
		return -EINVAL;

	err = shutdown(fd, what);
	if (err < 0)
		return -errno;
	return 0;
}

int os_rcv_fd(int fd, int *helper_pid_out)
{
	int new, n;
	char buf[CMSG_SPACE(sizeof(new))];
	struct msghdr msg;
	struct cmsghdr *cmsg;
	struct iovec iov;

	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	iov = ((struct iovec) { .iov_base  = helper_pid_out,
				.iov_len   = sizeof(*helper_pid_out) });
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = buf;
	msg.msg_controllen = sizeof(buf);
	msg.msg_flags = 0;

	n = recvmsg(fd, &msg, 0);
	if (n < 0)
		return -errno;
	else if (n != iov.iov_len)
		*helper_pid_out = -1;

	cmsg = CMSG_FIRSTHDR(&msg);
	if (cmsg == NULL) {
		printk(UM_KERN_ERR "rcv_fd didn't receive anything, "
		       "error = %d\n", errno);
		return -1;
	}
	if ((cmsg->cmsg_level != SOL_SOCKET) ||
	    (cmsg->cmsg_type != SCM_RIGHTS)) {
		printk(UM_KERN_ERR "rcv_fd didn't receive a descriptor\n");
		return -1;
	}

	new = ((int *) CMSG_DATA(cmsg))[0];
	return new;
}

int os_create_unix_socket(const char *file, int len, int close_on_exec)
{
	struct sockaddr_un addr;
	int sock, err;

	sock = socket(PF_UNIX, SOCK_DGRAM, 0);
	if (sock < 0)
		return -errno;

	if (close_on_exec) {
		err = os_set_exec_close(sock);
		if (err < 0)
			printk(UM_KERN_ERR "create_unix_socket : "
			       "close_on_exec failed, err = %d", -err);
	}

	addr.sun_family = AF_UNIX;

	snprintf(addr.sun_path, len, "%s", file);

	err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
	if (err < 0)
		return -errno;

	return sock;
}

void os_flush_stdout(void)
{
	fflush(stdout);
}

int os_lock_file(int fd, int excl)
{
	int type = excl ? F_WRLCK : F_RDLCK;
	struct flock lock = ((struct flock) { .l_type	= type,
					      .l_whence	= SEEK_SET,
					      .l_start	= 0,
					      .l_len	= 0 } );
	int err, save;

	err = fcntl(fd, F_SETLK, &lock);
	if (!err)
		goto out;

	save = -errno;
	err = fcntl(fd, F_GETLK, &lock);
	if (err) {
		err = -errno;
		goto out;
	}

	printk(UM_KERN_ERR "F_SETLK failed, file already locked by pid %d\n",
	       lock.l_pid);
	err = save;
 out:
	return err;
}

unsigned os_major(unsigned long long dev)
{
	return major(dev);
}

unsigned os_minor(unsigned long long dev)
{
	return minor(dev);
}

unsigned long long os_makedev(unsigned major, unsigned minor)
{
	return makedev(major, minor);
}
Commit	Line	Data
108ffa8c	1	/*
1adfd609	2	* Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1da177e4 LT	3	* Licensed under the GPL
	4	*/
	5
	6	#include <stdio.h>
	7	#include <unistd.h>
	8	#include <errno.h>
	9	#include <fcntl.h>
	10	#include <signal.h>
1da177e4 LT	11	#include <sys/ioctl.h>
1da177e4 LT	12	#include <sys/mount.h>
1adfd609 JD	13	#include <sys/socket.h>
	14	#include <sys/stat.h>
	15	#include <sys/un.h>
37185b33	16	#include <os.h>
1da177e4	17
c9a3072d	18	static void copy_stat(struct uml_stat dst, const struct stat64 src)
1da177e4 LT	19	{
	20	*dst = ((struct uml_stat) {
	21	.ust_dev = src->st_dev, /* device */
	22	.ust_ino = src->st_ino, /* inode */
	23	.ust_mode = src->st_mode, /* protection */
	24	.ust_nlink = src->st_nlink, /* number of hard links */
	25	.ust_uid = src->st_uid, /* user ID of owner */
	26	.ust_gid = src->st_gid, /* group ID of owner */
	27	.ust_size = src->st_size, /* total size, in bytes */
	28	.ust_blksize = src->st_blksize, /* blocksize for filesys I/O */
	29	.ust_blocks = src->st_blocks, /* number of blocks allocated */
	30	.ust_atime = src->st_atime, /* time of last access */
	31	.ust_mtime = src->st_mtime, /* time of last modification */
	32	.ust_ctime = src->st_ctime, /* time of last change */
	33	});
	34	}
	35
	36	int os_stat_fd(const int fd, struct uml_stat *ubuf)
	37	{
	38	struct stat64 sbuf;
	39	int err;
	40
9ead6fee	41	CATCH_EINTR(err = fstat64(fd, &sbuf));
1adfd609	42	if (err < 0)
108ffa8c	43	return -errno;
1da177e4	44
1adfd609	45	if (ubuf != NULL)
1da177e4	46	copy_stat(ubuf, &sbuf);
108ffa8c	47	return err;
1da177e4 LT	48	}
	49
	50	int os_stat_file(const char file_name, struct uml_stat ubuf)
	51	{
	52	struct stat64 sbuf;
	53	int err;
	54
1adfd609 JD	55	CATCH_EINTR(err = stat64(file_name, &sbuf));
1adfd609 JD	56	if (err < 0)
108ffa8c	57	return -errno;
1da177e4	58
1adfd609	59	if (ubuf != NULL)
1da177e4	60	copy_stat(ubuf, &sbuf);
108ffa8c	61	return err;
1da177e4 LT	62	}
1da177e4 LT	63
1adfd609	64	int os_access(const char *file, int mode)
1da177e4 LT	65	{
	66	int amode, err;
	67
1adfd609 JD	68	amode = (mode & OS_ACC_R_OK ? R_OK : 0) \|
	69	(mode & OS_ACC_W_OK ? W_OK : 0) \|
	70	(mode & OS_ACC_X_OK ? X_OK : 0) \|
	71	(mode & OS_ACC_F_OK ? F_OK : 0);
1da177e4 LT	72
1da177e4 LT	73	err = access(file, amode);
1adfd609	74	if (err < 0)
108ffa8c	75	return -errno;
1da177e4	76
108ffa8c	77	return 0;
1da177e4 LT	78	}
1da177e4 LT	79
1da177e4 LT	80	/* FIXME? required only by hostaudio (because it passes ioctls verbatim) */
	81	int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
	82	{
	83	int err;
	84
	85	err = ioctl(fd, cmd, arg);
1adfd609	86	if (err < 0)
108ffa8c	87	return -errno;
1da177e4	88
108ffa8c	89	return err;
1da177e4 LT	90	}
1da177e4 LT	91
1da177e4 LT	92	/* FIXME: ensure namebuf in os_get_if_name is big enough */
	93	int os_get_ifname(int fd, char* namebuf)
	94	{
1adfd609	95	if (ioctl(fd, SIOCGIFNAME, namebuf) < 0)
108ffa8c	96	return -errno;
1da177e4	97
108ffa8c	98	return 0;
1da177e4 LT	99	}
	100
	101	int os_set_slip(int fd)
	102	{
	103	int disc, sencap;
	104
	105	disc = N_SLIP;
1adfd609	106	if (ioctl(fd, TIOCSETD, &disc) < 0)
b4fd310e	107	return -errno;
1da177e4 LT	108
1da177e4 LT	109	sencap = 0;
1adfd609	110	if (ioctl(fd, SIOCSIFENCAP, &sencap) < 0)
b4fd310e	111	return -errno;
1da177e4	112
108ffa8c	113	return 0;
1da177e4 LT	114	}
1da177e4 LT	115
1da177e4 LT	116	int os_mode_fd(int fd, int mode)
	117	{
	118	int err;
	119
1adfd609 JD	120	CATCH_EINTR(err = fchmod(fd, mode));
1adfd609 JD	121	if (err < 0)
108ffa8c	122	return -errno;
1da177e4	123
108ffa8c	124	return 0;
1da177e4 LT	125	}
	126
	127	int os_file_type(char *file)
	128	{
	129	struct uml_stat buf;
	130	int err;
	131
	132	err = os_stat_file(file, &buf);
1adfd609	133	if (err < 0)
108ffa8c	134	return err;
1da177e4	135
1adfd609	136	if (S_ISDIR(buf.ust_mode))
108ffa8c	137	return OS_TYPE_DIR;
1adfd609	138	else if (S_ISLNK(buf.ust_mode))
108ffa8c	139	return OS_TYPE_SYMLINK;
1adfd609	140	else if (S_ISCHR(buf.ust_mode))
108ffa8c	141	return OS_TYPE_CHARDEV;
1adfd609	142	else if (S_ISBLK(buf.ust_mode))
108ffa8c	143	return OS_TYPE_BLOCKDEV;
1adfd609	144	else if (S_ISFIFO(buf.ust_mode))
108ffa8c	145	return OS_TYPE_FIFO;
1adfd609	146	else if (S_ISSOCK(buf.ust_mode))
108ffa8c JD	147	return OS_TYPE_SOCK;
108ffa8c JD	148	else return OS_TYPE_FILE;
1da177e4 LT	149	}
1da177e4 LT	150
c9a3072d	151	int os_file_mode(const char file, struct openflags mode_out)
1da177e4 LT	152	{
	153	int err;
	154
	155	*mode_out = OPENFLAGS();
	156
512b6fb1	157	err = access(file, W_OK);
1adfd609	158	if (err && (errno != EACCES))
512b6fb1	159	return -errno;
1adfd609	160	else if (!err)
512b6fb1	161	mode_out = of_write(mode_out);
1da177e4	162
512b6fb1	163	err = access(file, R_OK);
1adfd609	164	if (err && (errno != EACCES))
512b6fb1	165	return -errno;
1adfd609	166	else if (!err)
512b6fb1	167	mode_out = of_read(mode_out);
1da177e4	168
512b6fb1	169	return err;
1da177e4 LT	170	}
1da177e4 LT	171
c9a3072d	172	int os_open_file(const char *file, struct openflags flags, int mode)
1da177e4	173	{
b4fd310e	174	int fd, err, f = 0;
1da177e4	175
1adfd609 JD	176	if (flags.r && flags.w)
	177	f = O_RDWR;
	178	else if (flags.r)
	179	f = O_RDONLY;
	180	else if (flags.w)
	181	f = O_WRONLY;
1da177e4 LT	182	else f = 0;
1da177e4 LT	183
1adfd609 JD	184	if (flags.s)
	185	f \|= O_SYNC;
	186	if (flags.c)
	187	f \|= O_CREAT;
	188	if (flags.t)
	189	f \|= O_TRUNC;
	190	if (flags.e)
	191	f \|= O_EXCL;
bf53d85e JD	192	if (flags.a)
bf53d85e JD	193	f \|= O_APPEND;
1da177e4 LT	194
1da177e4 LT	195	fd = open64(file, f, mode);
1adfd609	196	if (fd < 0)
512b6fb1	197	return -errno;
1da177e4	198
1adfd609	199	if (flags.cl && fcntl(fd, F_SETFD, 1)) {
b4fd310e	200	err = -errno;
512b6fb1	201	close(fd);
b4fd310e	202	return err;
1da177e4 LT	203	}
1da177e4 LT	204
512b6fb1	205	return fd;
1da177e4 LT	206	}
1da177e4 LT	207
c9a3072d	208	int os_connect_socket(const char *name)
1da177e4 LT	209	{
	210	struct sockaddr_un sock;
	211	int fd, err;
	212
	213	sock.sun_family = AF_UNIX;
	214	snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
	215
	216	fd = socket(AF_UNIX, SOCK_STREAM, 0);
1adfd609	217	if (fd < 0) {
dc1561ac PBG	218	err = -errno;
	219	goto out;
	220	}
1da177e4 LT	221
1da177e4 LT	222	err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
1adfd609	223	if (err) {
dc1561ac PBG	224	err = -errno;
	225	goto out_close;
	226	}
1da177e4	227
dc1561ac PBG	228	return fd;
	229
	230	out_close:
	231	close(fd);
	232	out:
	233	return err;
1da177e4 LT	234	}
	235
	236	void os_close_file(int fd)
	237	{
	238	close(fd);
	239	}
0565103d AI	240	int os_fsync_file(int fd)
	241	{
	242	if (fsync(fd) < 0)
	243	return -errno;
	244	return 0;
	245	}
1da177e4	246
ba180fd4	247	int os_seek_file(int fd, unsigned long long offset)
1da177e4	248	{
ba180fd4	249	unsigned long long actual;
1da177e4 LT	250
1da177e4 LT	251	actual = lseek64(fd, offset, SEEK_SET);
1adfd609	252	if (actual != offset)
108ffa8c JD	253	return -errno;
108ffa8c JD	254	return 0;
1da177e4 LT	255	}
1da177e4 LT	256
1da177e4	257	int os_read_file(int fd, void *buf, int len)
3d564047 JD	258	{
	259	int n = read(fd, buf, len);
	260
1adfd609	261	if (n < 0)
3d564047 JD	262	return -errno;
	263	return n;
	264	}
	265
1da177e4	266	int os_write_file(int fd, const void *buf, int len)
3d564047 JD	267	{
	268	int n = write(fd, (void *) buf, len);
	269
1adfd609	270	if (n < 0)
3d564047 JD	271	return -errno;
	272	return n;
	273	}
	274
805f11a0 RW	275	int os_sync_file(int fd)
	276	{
	277	int n = fsync(fd);
	278
	279	if (n < 0)
	280	return -errno;
	281	return n;
	282	}
	283
c9a3072d	284	int os_file_size(const char file, unsigned long long size_out)
1da177e4 LT	285	{
	286	struct uml_stat buf;
	287	int err;
	288
	289	err = os_stat_file(file, &buf);
1adfd609 JD	290	if (err < 0) {
	291	printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
	292	-err);
512b6fb1	293	return err;
1da177e4 LT	294	}
1da177e4 LT	295
1adfd609	296	if (S_ISBLK(buf.ust_mode)) {
2c392a4f NG	297	int fd;
2c392a4f NG	298	long blocks;
1da177e4	299
512b6fb1	300	fd = open(file, O_RDONLY, 0);
1adfd609	301	if (fd < 0) {
512b6fb1	302	err = -errno;
1adfd609 JD	303	printk(UM_KERN_ERR "Couldn't open \"%s\", "
1adfd609 JD	304	"errno = %d\n", file, errno);
512b6fb1	305	return err;
1da177e4	306	}
1adfd609	307	if (ioctl(fd, BLKGETSIZE, &blocks) < 0) {
b4fd310e	308	err = -errno;
1adfd609 JD	309	printk(UM_KERN_ERR "Couldn't get the block size of "
1adfd609 JD	310	"\"%s\", errno = %d\n", file, errno);
512b6fb1 JD	311	close(fd);
512b6fb1 JD	312	return err;
1da177e4 LT	313	}
1da177e4 LT	314	size_out = ((long long) blocks) 512;
512b6fb1	315	close(fd);
1da177e4	316	}
512b6fb1 JD	317	else *size_out = buf.ust_size;
	318
	319	return 0;
1da177e4 LT	320	}
1da177e4 LT	321
c9a3072d	322	int os_file_modtime(const char file, unsigned long modtime)
1da177e4 LT	323	{
	324	struct uml_stat buf;
	325	int err;
	326
	327	err = os_stat_file(file, &buf);
1adfd609 JD	328	if (err < 0) {
	329	printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
	330	-err);
108ffa8c	331	return err;
1da177e4 LT	332	}
	333
	334	*modtime = buf.ust_mtime;
108ffa8c	335	return 0;
1da177e4 LT	336	}
1da177e4 LT	337
512b6fb1	338	int os_set_exec_close(int fd)
1da177e4	339	{
512b6fb1	340	int err;
1da177e4	341
512b6fb1	342	CATCH_EINTR(err = fcntl(fd, F_SETFD, FD_CLOEXEC));
1da177e4	343
1adfd609	344	if (err < 0)
512b6fb1 JD	345	return -errno;
512b6fb1 JD	346	return err;
1da177e4 LT	347	}
	348
	349	int os_pipe(int *fds, int stream, int close_on_exec)
	350	{
	351	int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;
	352
	353	err = socketpair(AF_UNIX, type, 0, fds);
1adfd609	354	if (err < 0)
512b6fb1	355	return -errno;
1da177e4	356
1adfd609	357	if (!close_on_exec)
512b6fb1	358	return 0;
1da177e4	359
512b6fb1	360	err = os_set_exec_close(fds[0]);
1adfd609	361	if (err < 0)
1da177e4 LT	362	goto error;
1da177e4 LT	363
512b6fb1	364	err = os_set_exec_close(fds[1]);
1adfd609	365	if (err < 0)
1da177e4 LT	366	goto error;
1da177e4 LT	367
108ffa8c	368	return 0;
1da177e4 LT	369
1da177e4 LT	370	error:
1adfd609 JD	371	printk(UM_KERN_ERR "os_pipe : Setting FD_CLOEXEC failed, err = %d\n",
1adfd609 JD	372	-err);
512b6fb1 JD	373	close(fds[1]);
	374	close(fds[0]);
	375	return err;
1da177e4 LT	376	}
1da177e4 LT	377
bf8fde78	378	int os_set_fd_async(int fd)
1da177e4	379	{
bf8fde78 JD	380	int err, flags;
	381
	382	flags = fcntl(fd, F_GETFL);
	383	if (flags < 0)
	384	return -errno;
b4fd310e	385
bf8fde78 JD	386	flags \|= O_ASYNC \| O_NONBLOCK;
bf8fde78 JD	387	if (fcntl(fd, F_SETFL, flags) < 0) {
b4fd310e	388	err = -errno;
1adfd609 JD	389	printk(UM_KERN_ERR "os_set_fd_async : failed to set O_ASYNC "
1adfd609 JD	390	"and O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
b4fd310e	391	return err;
1da177e4	392	}
1da177e4	393
bf8fde78 JD	394	if ((fcntl(fd, F_SETSIG, SIGIO) < 0) \|\|
bf8fde78 JD	395	(fcntl(fd, F_SETOWN, os_getpid()) < 0)) {
b4fd310e	396	err = -errno;
1adfd609	397	printk(UM_KERN_ERR "os_set_fd_async : Failed to fcntl F_SETOWN "
bf8fde78	398	"(or F_SETSIG) fd %d, errno = %d\n", fd, errno);
b4fd310e	399	return err;
1da177e4 LT	400	}
1da177e4 LT	401
108ffa8c	402	return 0;
1da177e4 LT	403	}
	404
	405	int os_clear_fd_async(int fd)
	406	{
1adfd609 JD	407	int flags;
	408
	409	flags = fcntl(fd, F_GETFL);
	410	if (flags < 0)
	411	return -errno;
1da177e4 LT	412
1da177e4 LT	413	flags &= ~(O_ASYNC \| O_NONBLOCK);
1adfd609	414	if (fcntl(fd, F_SETFL, flags) < 0)
108ffa8c JD	415	return -errno;
108ffa8c JD	416	return 0;
1da177e4 LT	417	}
	418
	419	int os_set_fd_block(int fd, int blocking)
	420	{
	421	int flags;
	422
	423	flags = fcntl(fd, F_GETFL);
1adfd609 JD	424	if (flags < 0)
1adfd609 JD	425	return -errno;
1da177e4	426
1adfd609 JD	427	if (blocking)
	428	flags &= ~O_NONBLOCK;
	429	else
	430	flags \|= O_NONBLOCK;
1da177e4	431
1adfd609	432	if (fcntl(fd, F_SETFL, flags) < 0)
b4fd310e JD	433	return -errno;
b4fd310e JD	434
108ffa8c	435	return 0;
1da177e4 LT	436	}
	437
	438	int os_accept_connection(int fd)
	439	{
	440	int new;
	441
	442	new = accept(fd, NULL, 0);
1adfd609	443	if (new < 0)
108ffa8c JD	444	return -errno;
108ffa8c JD	445	return new;
1da177e4 LT	446	}
	447
	448	#ifndef SHUT_RD
	449	#define SHUT_RD 0
	450	#endif
	451
	452	#ifndef SHUT_WR
	453	#define SHUT_WR 1
	454	#endif
	455
	456	#ifndef SHUT_RDWR
	457	#define SHUT_RDWR 2
	458	#endif
	459
	460	int os_shutdown_socket(int fd, int r, int w)
	461	{
	462	int what, err;
	463
1adfd609 JD	464	if (r && w)
	465	what = SHUT_RDWR;
	466	else if (r)
	467	what = SHUT_RD;
	468	else if (w)
	469	what = SHUT_WR;
	470	else
108ffa8c	471	return -EINVAL;
1adfd609	472
1da177e4	473	err = shutdown(fd, what);
1adfd609	474	if (err < 0)
108ffa8c JD	475	return -errno;
108ffa8c JD	476	return 0;
1da177e4 LT	477	}
	478
	479	int os_rcv_fd(int fd, int *helper_pid_out)
	480	{
	481	int new, n;
	482	char buf[CMSG_SPACE(sizeof(new))];
	483	struct msghdr msg;
	484	struct cmsghdr *cmsg;
	485	struct iovec iov;
	486
	487	msg.msg_name = NULL;
	488	msg.msg_namelen = 0;
	489	iov = ((struct iovec) { .iov_base = helper_pid_out,
	490	.iov_len = sizeof(*helper_pid_out) });
	491	msg.msg_iov = &iov;
	492	msg.msg_iovlen = 1;
	493	msg.msg_control = buf;
	494	msg.msg_controllen = sizeof(buf);
	495	msg.msg_flags = 0;
	496
	497	n = recvmsg(fd, &msg, 0);
1adfd609	498	if (n < 0)
108ffa8c	499	return -errno;
1adfd609	500	else if (n != iov.iov_len)
1da177e4 LT	501	*helper_pid_out = -1;
	502
	503	cmsg = CMSG_FIRSTHDR(&msg);
1adfd609 JD	504	if (cmsg == NULL) {
	505	printk(UM_KERN_ERR "rcv_fd didn't receive anything, "
	506	"error = %d\n", errno);
108ffa8c	507	return -1;
1da177e4	508	}
1adfd609 JD	509	if ((cmsg->cmsg_level != SOL_SOCKET) \|\|
	510	(cmsg->cmsg_type != SCM_RIGHTS)) {
	511	printk(UM_KERN_ERR "rcv_fd didn't receive a descriptor\n");
108ffa8c	512	return -1;
1da177e4 LT	513	}
	514
	515	new = ((int *) CMSG_DATA(cmsg))[0];
108ffa8c	516	return new;
1da177e4 LT	517	}
1da177e4 LT	518
c9a3072d	519	int os_create_unix_socket(const char *file, int len, int close_on_exec)
1da177e4 LT	520	{
	521	struct sockaddr_un addr;
	522	int sock, err;
	523
	524	sock = socket(PF_UNIX, SOCK_DGRAM, 0);
1adfd609	525	if (sock < 0)
b4fd310e	526	return -errno;
1da177e4	527
1adfd609	528	if (close_on_exec) {
512b6fb1	529	err = os_set_exec_close(sock);
1adfd609 JD	530	if (err < 0)
	531	printk(UM_KERN_ERR "create_unix_socket : "
	532	"close_on_exec failed, err = %d", -err);
1da177e4 LT	533	}
	534
	535	addr.sun_family = AF_UNIX;
	536
1da177e4 LT	537	snprintf(addr.sun_path, len, "%s", file);
	538
	539	err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
1adfd609	540	if (err < 0)
b4fd310e	541	return -errno;
1da177e4	542
108ffa8c	543	return sock;
1da177e4 LT	544	}
	545
	546	void os_flush_stdout(void)
	547	{
	548	fflush(stdout);
	549	}
	550
	551	int os_lock_file(int fd, int excl)
	552	{
	553	int type = excl ? F_WRLCK : F_RDLCK;
	554	struct flock lock = ((struct flock) { .l_type = type,
	555	.l_whence = SEEK_SET,
	556	.l_start = 0,
	557	.l_len = 0 } );
	558	int err, save;
	559
	560	err = fcntl(fd, F_SETLK, &lock);
1adfd609	561	if (!err)
1da177e4 LT	562	goto out;
	563
	564	save = -errno;
	565	err = fcntl(fd, F_GETLK, &lock);
1adfd609	566	if (err) {
1da177e4 LT	567	err = -errno;
	568	goto out;
	569	}
	570
1adfd609 JD	571	printk(UM_KERN_ERR "F_SETLK failed, file already locked by pid %d\n",
1adfd609 JD	572	lock.l_pid);
1da177e4 LT	573	err = save;
1da177e4 LT	574	out:
108ffa8c	575	return err;
1da177e4	576	}
005a59ec AV	577
	578	unsigned os_major(unsigned long long dev)
	579	{
	580	return major(dev);
	581	}
	582
	583	unsigned os_minor(unsigned long long dev)
	584	{
	585	return minor(dev);
	586	}
	587
	588	unsigned long long os_makedev(unsigned major, unsigned minor)
	589	{
	590	return makedev(major, minor);
	591	}