[linux-2.6-block.git] / tools / perf / util / data.c

#include <linux/compiler.h>
#include <linux/kernel.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>

#include "data.h"
#include "util.h"

static bool check_pipe(struct perf_data_file *file)
{
	struct stat st;
	bool is_pipe = false;
	int fd = perf_data_file__is_read(file) ?
		 STDIN_FILENO : STDOUT_FILENO;

	if (!file->path) {
		if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
			is_pipe = true;
	} else {
		if (!strcmp(file->path, "-"))
			is_pipe = true;
	}

	if (is_pipe)
		file->fd = fd;

	return file->is_pipe = is_pipe;
}

static int check_backup(struct perf_data_file *file)
{
	struct stat st;

	if (!stat(file->path, &st) && st.st_size) {
		/* TODO check errors properly */
		char oldname[PATH_MAX];
		snprintf(oldname, sizeof(oldname), "%s.old",
			 file->path);
		unlink(oldname);
		rename(file->path, oldname);
	}

	return 0;
}

static int open_file_read(struct perf_data_file *file)
{
	struct stat st;
	int fd;

	fd = open(file->path, O_RDONLY);
	if (fd < 0) {
		int err = errno;

		pr_err("failed to open %s: %s", file->path, strerror(err));
		if (err == ENOENT && !strcmp(file->path, "perf.data"))
			pr_err("  (try 'perf record' first)");
		pr_err("\n");
		return -err;
	}

	if (fstat(fd, &st) < 0)
		goto out_close;

	if (!file->force && st.st_uid && (st.st_uid != geteuid())) {
		pr_err("file %s not owned by current user or root\n",
		       file->path);
		goto out_close;
	}

	if (!st.st_size) {
		pr_info("zero-sized file (%s), nothing to do!\n",
			file->path);
		goto out_close;
	}

	file->size = st.st_size;
	return fd;

 out_close:
	close(fd);
	return -1;
}

static int open_file_write(struct perf_data_file *file)
{
	int fd;

	if (check_backup(file))
		return -1;

	fd = open(file->path, O_CREAT|O_RDWR|O_TRUNC, S_IRUSR|S_IWUSR);

	if (fd < 0)
		pr_err("failed to open %s : %s\n", file->path, strerror(errno));

	return fd;
}

static int open_file(struct perf_data_file *file)
{
	int fd;

	fd = perf_data_file__is_read(file) ?
	     open_file_read(file) : open_file_write(file);

	file->fd = fd;
	return fd < 0 ? -1 : 0;
}

int perf_data_file__open(struct perf_data_file *file)
{
	if (check_pipe(file))
		return 0;

	if (!file->path)
		file->path = "perf.data";

	return open_file(file);
}

void perf_data_file__close(struct perf_data_file *file)
{
	close(file->fd);
}

ssize_t perf_data_file__write(struct perf_data_file *file,
			      void *buf, size_t size)
{
	return writen(file->fd, buf, size);
}
Commit	Line	Data
6a4d98d7 JO	1	#include <linux/compiler.h>
	2	#include <linux/kernel.h>
	3	#include <sys/types.h>
	4	#include <sys/stat.h>
	5	#include <unistd.h>
	6	#include <string.h>
	7
	8	#include "data.h"
	9	#include "util.h"
	10
	11	static bool check_pipe(struct perf_data_file *file)
	12	{
	13	struct stat st;
	14	bool is_pipe = false;
	15	int fd = perf_data_file__is_read(file) ?
	16	STDIN_FILENO : STDOUT_FILENO;
	17
	18	if (!file->path) {
	19	if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
	20	is_pipe = true;
	21	} else {
	22	if (!strcmp(file->path, "-"))
	23	is_pipe = true;
	24	}
	25
	26	if (is_pipe)
	27	file->fd = fd;
	28
	29	return file->is_pipe = is_pipe;
	30	}
	31
	32	static int check_backup(struct perf_data_file *file)
	33	{
	34	struct stat st;
	35
	36	if (!stat(file->path, &st) && st.st_size) {
	37	/* TODO check errors properly */
	38	char oldname[PATH_MAX];
	39	snprintf(oldname, sizeof(oldname), "%s.old",
	40	file->path);
	41	unlink(oldname);
	42	rename(file->path, oldname);
	43	}
	44
	45	return 0;
	46	}
	47
	48	static int open_file_read(struct perf_data_file *file)
	49	{
	50	struct stat st;
	51	int fd;
	52
	53	fd = open(file->path, O_RDONLY);
	54	if (fd < 0) {
	55	int err = errno;
	56
	57	pr_err("failed to open %s: %s", file->path, strerror(err));
	58	if (err == ENOENT && !strcmp(file->path, "perf.data"))
	59	pr_err(" (try 'perf record' first)");
	60	pr_err("\n");
	61	return -err;
	62	}
	63
	64	if (fstat(fd, &st) < 0)
65	goto out_close;
66
67	if (!file->force && st.st_uid && (st.st_uid != geteuid())) {
68	pr_err("file %s not owned by current user or root\n",
69	file->path);
70	goto out_close;
71	}
72
73	if (!st.st_size) {
74	pr_info("zero-sized file (%s), nothing to do!\n",
75	file->path);
76	goto out_close;
77	}
78
79	file->size = st.st_size;
80	return fd;
81
82	out_close:
83	close(fd);
84	return -1;
85	}
86
87	static int open_file_write(struct perf_data_file *file)
88	{
ffa91880 AB	89	int fd;
ffa91880 AB	90
6a4d98d7 JO	91	if (check_backup(file))
	92	return -1;
	93
ffa91880 AB	94	fd = open(file->path, O_CREAT\|O_RDWR\|O_TRUNC, S_IRUSR\|S_IWUSR);
	95
	96	if (fd < 0)
	97	pr_err("failed to open %s : %s\n", file->path, strerror(errno));
	98
	99	return fd;
6a4d98d7 JO	100	}
	101
	102	static int open_file(struct perf_data_file *file)
	103	{
	104	int fd;
	105
	106	fd = perf_data_file__is_read(file) ?
	107	open_file_read(file) : open_file_write(file);
	108
	109	file->fd = fd;
	110	return fd < 0 ? -1 : 0;
	111	}
	112
	113	int perf_data_file__open(struct perf_data_file *file)
	114	{
	115	if (check_pipe(file))
	116	return 0;
	117
	118	if (!file->path)
	119	file->path = "perf.data";
	120
	121	return open_file(file);
	122	}
	123
	124	void perf_data_file__close(struct perf_data_file *file)
	125	{
	126	close(file->fd);
	127	}
6f9a317f JO	128
	129	ssize_t perf_data_file__write(struct perf_data_file *file,
	130	void *buf, size_t size)
	131	{
	132	return writen(file->fd, buf, size);
	133	}