1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/compiler.h>
  3#include <linux/kernel.h>
  4#include <linux/string.h>
  5#include <linux/zalloc.h>
  6#include <sys/types.h>
  7#include <sys/stat.h>
  8#include <errno.h>
  9#include <fcntl.h>
 10#include <unistd.h>
 11#include <string.h>
 12#include <asm/bug.h>
 13#include <dirent.h>
 14
 15#include "data.h"
 16#include "util.h" // rm_rf_perf_data()
 17#include "debug.h"
 18#include "header.h"
 19#include <internal/lib.h>
 20
 21static void close_dir(struct perf_data_file *files, int nr)
 22{
 23	while (--nr >= 1) {
 24		close(files[nr].fd);
 25		zfree(&files[nr].path);
 26	}
 27	free(files);
 28}
 29
 30void perf_data__close_dir(struct perf_data *data)
 31{
 32	close_dir(data->dir.files, data->dir.nr);
 33}
 34
 35int perf_data__create_dir(struct perf_data *data, int nr)
 36{
 37	struct perf_data_file *files = NULL;
 38	int i, ret = -1;
 39
 40	if (WARN_ON(!data->is_dir))
 41		return -EINVAL;
 42
 43	files = zalloc(nr * sizeof(*files));
 44	if (!files)
 45		return -ENOMEM;
 46
 47	data->dir.version = PERF_DIR_VERSION;
 48	data->dir.files   = files;
 49	data->dir.nr      = nr;
 50
 51	for (i = 0; i < nr; i++) {
 52		struct perf_data_file *file = &files[i];
 53
 54		if (asprintf(&file->path, "%s/data.%d", data->path, i) < 0)
 55			goto out_err;
 56
 57		ret = open(file->path, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
 58		if (ret < 0)
 59			goto out_err;
 60
 61		file->fd = ret;
 62	}
 63
 64	return 0;
 65
 66out_err:
 67	close_dir(files, i);
 68	return ret;
 69}
 70
 71int perf_data__open_dir(struct perf_data *data)
 72{
 73	struct perf_data_file *files = NULL;
 74	struct dirent *dent;
 75	int ret = -1;
 76	DIR *dir;
 77	int nr = 0;
 78
 
 
 
 
 
 
 
 79	if (WARN_ON(!data->is_dir))
 80		return -EINVAL;
 81
 82	/* The version is provided by DIR_FORMAT feature. */
 83	if (WARN_ON(data->dir.version != PERF_DIR_VERSION))
 84		return -1;
 85
 86	dir = opendir(data->path);
 87	if (!dir)
 88		return -EINVAL;
 89
 90	while ((dent = readdir(dir)) != NULL) {
 91		struct perf_data_file *file;
 92		char path[PATH_MAX];
 93		struct stat st;
 94
 95		snprintf(path, sizeof(path), "%s/%s", data->path, dent->d_name);
 96		if (stat(path, &st))
 97			continue;
 98
 99		if (!S_ISREG(st.st_mode) || strncmp(dent->d_name, "data", 4))
100			continue;
101
102		ret = -ENOMEM;
103
104		file = realloc(files, (nr + 1) * sizeof(*files));
105		if (!file)
106			goto out_err;
107
108		files = file;
109		file = &files[nr++];
110
111		file->path = strdup(path);
112		if (!file->path)
113			goto out_err;
114
115		ret = open(file->path, O_RDONLY);
116		if (ret < 0)
117			goto out_err;
118
119		file->fd = ret;
120		file->size = st.st_size;
121	}
122
123	if (!files)
124		return -EINVAL;
125
126	data->dir.files = files;
127	data->dir.nr    = nr;
128	return 0;
129
130out_err:
131	close_dir(files, nr);
132	return ret;
133}
134
135int perf_data__update_dir(struct perf_data *data)
136{
137	int i;
138
139	if (WARN_ON(!data->is_dir))
140		return -EINVAL;
141
142	for (i = 0; i < data->dir.nr; i++) {
143		struct perf_data_file *file = &data->dir.files[i];
144		struct stat st;
145
146		if (fstat(file->fd, &st))
147			return -1;
148
149		file->size = st.st_size;
150	}
151
152	return 0;
153}
154
155static bool check_pipe(struct perf_data *data)
156{
157	struct stat st;
158	bool is_pipe = false;
159	int fd = perf_data__is_read(data) ?
160		 STDIN_FILENO : STDOUT_FILENO;
161
162	if (!data->path) {
163		if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
164			is_pipe = true;
165	} else {
166		if (!strcmp(data->path, "-"))
167			is_pipe = true;
168	}
169
170	if (is_pipe)
171		data->file.fd = fd;
172
173	return data->is_pipe = is_pipe;
174}
175
176static int check_backup(struct perf_data *data)
177{
178	struct stat st;
179
180	if (perf_data__is_read(data))
181		return 0;
182
183	if (!stat(data->path, &st) && st.st_size) {
184		char oldname[PATH_MAX];
185		int ret;
186
187		snprintf(oldname, sizeof(oldname), "%s.old",
188			 data->path);
189
190		ret = rm_rf_perf_data(oldname);
191		if (ret) {
192			pr_err("Can't remove old data: %s (%s)\n",
193			       ret == -2 ?
194			       "Unknown file found" : strerror(errno),
195			       oldname);
196			return -1;
197		}
198
199		if (rename(data->path, oldname)) {
200			pr_err("Can't move data: %s (%s to %s)\n",
201			       strerror(errno),
202			       data->path, oldname);
203			return -1;
204		}
205	}
206
207	return 0;
208}
209
210static bool is_dir(struct perf_data *data)
211{
212	struct stat st;
213
214	if (stat(data->path, &st))
215		return false;
216
217	return (st.st_mode & S_IFMT) == S_IFDIR;
218}
219
220static int open_file_read(struct perf_data *data)
221{
222	struct stat st;
223	int fd;
224	char sbuf[STRERR_BUFSIZE];
225
226	fd = open(data->file.path, O_RDONLY);
227	if (fd < 0) {
228		int err = errno;
229
230		pr_err("failed to open %s: %s", data->file.path,
231			str_error_r(err, sbuf, sizeof(sbuf)));
232		if (err == ENOENT && !strcmp(data->file.path, "perf.data"))
233			pr_err("  (try 'perf record' first)");
234		pr_err("\n");
235		return -err;
236	}
237
238	if (fstat(fd, &st) < 0)
239		goto out_close;
240
241	if (!data->force && st.st_uid && (st.st_uid != geteuid())) {
242		pr_err("File %s not owned by current user or root (use -f to override)\n",
243		       data->file.path);
244		goto out_close;
245	}
246
247	if (!st.st_size) {
248		pr_info("zero-sized data (%s), nothing to do!\n",
249			data->file.path);
250		goto out_close;
251	}
252
253	data->file.size = st.st_size;
254	return fd;
255
256 out_close:
257	close(fd);
258	return -1;
259}
260
261static int open_file_write(struct perf_data *data)
262{
263	int fd;
264	char sbuf[STRERR_BUFSIZE];
265
266	fd = open(data->file.path, O_CREAT|O_RDWR|O_TRUNC|O_CLOEXEC,
267		  S_IRUSR|S_IWUSR);
268
269	if (fd < 0)
270		pr_err("failed to open %s : %s\n", data->file.path,
271			str_error_r(errno, sbuf, sizeof(sbuf)));
272
273	return fd;
274}
275
276static int open_file(struct perf_data *data)
277{
278	int fd;
279
280	fd = perf_data__is_read(data) ?
281	     open_file_read(data) : open_file_write(data);
282
283	if (fd < 0) {
284		zfree(&data->file.path);
285		return -1;
286	}
287
288	data->file.fd = fd;
289	return 0;
290}
291
292static int open_file_dup(struct perf_data *data)
293{
294	data->file.path = strdup(data->path);
295	if (!data->file.path)
296		return -ENOMEM;
297
298	return open_file(data);
299}
300
301static int open_dir(struct perf_data *data)
302{
303	int ret;
304
305	/*
306	 * So far we open only the header, so we can read the data version and
307	 * layout.
308	 */
309	if (asprintf(&data->file.path, "%s/header", data->path) < 0)
310		return -1;
311
312	if (perf_data__is_write(data) &&
313	    mkdir(data->path, S_IRWXU) < 0)
314		return -1;
315
316	ret = open_file(data);
317
318	/* Cleanup whatever we managed to create so far. */
319	if (ret && perf_data__is_write(data))
320		rm_rf_perf_data(data->path);
321
322	return ret;
323}
324
325int perf_data__open(struct perf_data *data)
326{
327	if (check_pipe(data))
328		return 0;
329
330	if (!data->path)
331		data->path = "perf.data";
332
333	if (check_backup(data))
334		return -1;
335
336	if (perf_data__is_read(data))
337		data->is_dir = is_dir(data);
338
339	return perf_data__is_dir(data) ?
340	       open_dir(data) : open_file_dup(data);
341}
342
343void perf_data__close(struct perf_data *data)
344{
345	if (perf_data__is_dir(data))
346		perf_data__close_dir(data);
347
348	zfree(&data->file.path);
349	close(data->file.fd);
350}
351
352ssize_t perf_data_file__write(struct perf_data_file *file,
353			      void *buf, size_t size)
354{
355	return writen(file->fd, buf, size);
356}
357
358ssize_t perf_data__write(struct perf_data *data,
359			      void *buf, size_t size)
360{
361	return perf_data_file__write(&data->file, buf, size);
362}
363
364int perf_data__switch(struct perf_data *data,
365			   const char *postfix,
366			   size_t pos, bool at_exit,
367			   char **new_filepath)
368{
369	int ret;
370
371	if (check_pipe(data))
372		return -EINVAL;
373	if (perf_data__is_read(data))
374		return -EINVAL;
375
376	if (asprintf(new_filepath, "%s.%s", data->path, postfix) < 0)
377		return -ENOMEM;
378
379	/*
380	 * Only fire a warning, don't return error, continue fill
381	 * original file.
382	 */
383	if (rename(data->path, *new_filepath))
384		pr_warning("Failed to rename %s to %s\n", data->path, *new_filepath);
385
386	if (!at_exit) {
387		close(data->file.fd);
388		ret = perf_data__open(data);
389		if (ret < 0)
390			goto out;
391
392		if (lseek(data->file.fd, pos, SEEK_SET) == (off_t)-1) {
393			ret = -errno;
394			pr_debug("Failed to lseek to %zu: %s",
395				 pos, strerror(errno));
396			goto out;
397		}
398	}
399	ret = data->file.fd;
400out:
401	return ret;
402}
403
404unsigned long perf_data__size(struct perf_data *data)
405{
406	u64 size = data->file.size;
407	int i;
408
409	if (!data->is_dir)
410		return size;
411
412	for (i = 0; i < data->dir.nr; i++) {
413		struct perf_data_file *file = &data->dir.files[i];
414
415		size += file->size;
416	}
417
418	return size;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
419}

  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/compiler.h>
  3#include <linux/kernel.h>
  4#include <linux/string.h>
  5#include <linux/zalloc.h>
  6#include <sys/types.h>
  7#include <sys/stat.h>
  8#include <errno.h>
  9#include <fcntl.h>
 10#include <unistd.h>
 11#include <string.h>
 12#include <asm/bug.h>
 13#include <dirent.h>
 14
 15#include "data.h"
 16#include "util.h" // rm_rf_perf_data()
 17#include "debug.h"
 18#include "header.h"
 19#include <internal/lib.h>
 20
 21static void close_dir(struct perf_data_file *files, int nr)
 22{
 23	while (--nr >= 1) {
 24		close(files[nr].fd);
 25		zfree(&files[nr].path);
 26	}
 27	free(files);
 28}
 29
 30void perf_data__close_dir(struct perf_data *data)
 31{
 32	close_dir(data->dir.files, data->dir.nr);
 33}
 34
 35int perf_data__create_dir(struct perf_data *data, int nr)
 36{
 37	struct perf_data_file *files = NULL;
 38	int i, ret = -1;
 39
 40	if (WARN_ON(!data->is_dir))
 41		return -EINVAL;
 42
 43	files = zalloc(nr * sizeof(*files));
 44	if (!files)
 45		return -ENOMEM;
 46
 47	data->dir.version = PERF_DIR_VERSION;
 48	data->dir.files   = files;
 49	data->dir.nr      = nr;
 50
 51	for (i = 0; i < nr; i++) {
 52		struct perf_data_file *file = &files[i];
 53
 54		if (asprintf(&file->path, "%s/data.%d", data->path, i) < 0)
 55			goto out_err;
 56
 57		ret = open(file->path, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
 58		if (ret < 0)
 59			goto out_err;
 60
 61		file->fd = ret;
 62	}
 63
 64	return 0;
 65
 66out_err:
 67	close_dir(files, i);
 68	return ret;
 69}
 70
 71int perf_data__open_dir(struct perf_data *data)
 72{
 73	struct perf_data_file *files = NULL;
 74	struct dirent *dent;
 75	int ret = -1;
 76	DIR *dir;
 77	int nr = 0;
 78
 79	/*
 80	 * Directory containing a single regular perf data file which is already
 81	 * open, means there is nothing more to do here.
 82	 */
 83	if (perf_data__is_single_file(data))
 84		return 0;
 85
 86	if (WARN_ON(!data->is_dir))
 87		return -EINVAL;
 88
 89	/* The version is provided by DIR_FORMAT feature. */
 90	if (WARN_ON(data->dir.version != PERF_DIR_VERSION))
 91		return -1;
 92
 93	dir = opendir(data->path);
 94	if (!dir)
 95		return -EINVAL;
 96
 97	while ((dent = readdir(dir)) != NULL) {
 98		struct perf_data_file *file;
 99		char path[PATH_MAX];
100		struct stat st;
101
102		snprintf(path, sizeof(path), "%s/%s", data->path, dent->d_name);
103		if (stat(path, &st))
104			continue;
105
106		if (!S_ISREG(st.st_mode) || strncmp(dent->d_name, "data.", 5))
107			continue;
108
109		ret = -ENOMEM;
110
111		file = realloc(files, (nr + 1) * sizeof(*files));
112		if (!file)
113			goto out_err;
114
115		files = file;
116		file = &files[nr++];
117
118		file->path = strdup(path);
119		if (!file->path)
120			goto out_err;
121
122		ret = open(file->path, O_RDONLY);
123		if (ret < 0)
124			goto out_err;
125
126		file->fd = ret;
127		file->size = st.st_size;
128	}
129
130	if (!files)
131		return -EINVAL;
132
133	data->dir.files = files;
134	data->dir.nr    = nr;
135	return 0;
136
137out_err:
138	close_dir(files, nr);
139	return ret;
140}
141
142int perf_data__update_dir(struct perf_data *data)
143{
144	int i;
145
146	if (WARN_ON(!data->is_dir))
147		return -EINVAL;
148
149	for (i = 0; i < data->dir.nr; i++) {
150		struct perf_data_file *file = &data->dir.files[i];
151		struct stat st;
152
153		if (fstat(file->fd, &st))
154			return -1;
155
156		file->size = st.st_size;
157	}
158
159	return 0;
160}
161
162static bool check_pipe(struct perf_data *data)
163{
164	struct stat st;
165	bool is_pipe = false;
166	int fd = perf_data__is_read(data) ?
167		 STDIN_FILENO : STDOUT_FILENO;
168
169	if (!data->path) {
170		if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
171			is_pipe = true;
172	} else {
173		if (!strcmp(data->path, "-"))
174			is_pipe = true;
175	}
176
177	if (is_pipe)
178		data->file.fd = fd;
179
180	return data->is_pipe = is_pipe;
181}
182
183static int check_backup(struct perf_data *data)
184{
185	struct stat st;
186
187	if (perf_data__is_read(data))
188		return 0;
189
190	if (!stat(data->path, &st) && st.st_size) {
191		char oldname[PATH_MAX];
192		int ret;
193
194		snprintf(oldname, sizeof(oldname), "%s.old",
195			 data->path);
196
197		ret = rm_rf_perf_data(oldname);
198		if (ret) {
199			pr_err("Can't remove old data: %s (%s)\n",
200			       ret == -2 ?
201			       "Unknown file found" : strerror(errno),
202			       oldname);
203			return -1;
204		}
205
206		if (rename(data->path, oldname)) {
207			pr_err("Can't move data: %s (%s to %s)\n",
208			       strerror(errno),
209			       data->path, oldname);
210			return -1;
211		}
212	}
213
214	return 0;
215}
216
217static bool is_dir(struct perf_data *data)
218{
219	struct stat st;
220
221	if (stat(data->path, &st))
222		return false;
223
224	return (st.st_mode & S_IFMT) == S_IFDIR;
225}
226
227static int open_file_read(struct perf_data *data)
228{
229	struct stat st;
230	int fd;
231	char sbuf[STRERR_BUFSIZE];
232
233	fd = open(data->file.path, O_RDONLY);
234	if (fd < 0) {
235		int err = errno;
236
237		pr_err("failed to open %s: %s", data->file.path,
238			str_error_r(err, sbuf, sizeof(sbuf)));
239		if (err == ENOENT && !strcmp(data->file.path, "perf.data"))
240			pr_err("  (try 'perf record' first)");
241		pr_err("\n");
242		return -err;
243	}
244
245	if (fstat(fd, &st) < 0)
246		goto out_close;
247
248	if (!data->force && st.st_uid && (st.st_uid != geteuid())) {
249		pr_err("File %s not owned by current user or root (use -f to override)\n",
250		       data->file.path);
251		goto out_close;
252	}
253
254	if (!st.st_size) {
255		pr_info("zero-sized data (%s), nothing to do!\n",
256			data->file.path);
257		goto out_close;
258	}
259
260	data->file.size = st.st_size;
261	return fd;
262
263 out_close:
264	close(fd);
265	return -1;
266}
267
268static int open_file_write(struct perf_data *data)
269{
270	int fd;
271	char sbuf[STRERR_BUFSIZE];
272
273	fd = open(data->file.path, O_CREAT|O_RDWR|O_TRUNC|O_CLOEXEC,
274		  S_IRUSR|S_IWUSR);
275
276	if (fd < 0)
277		pr_err("failed to open %s : %s\n", data->file.path,
278			str_error_r(errno, sbuf, sizeof(sbuf)));
279
280	return fd;
281}
282
283static int open_file(struct perf_data *data)
284{
285	int fd;
286
287	fd = perf_data__is_read(data) ?
288	     open_file_read(data) : open_file_write(data);
289
290	if (fd < 0) {
291		zfree(&data->file.path);
292		return -1;
293	}
294
295	data->file.fd = fd;
296	return 0;
297}
298
299static int open_file_dup(struct perf_data *data)
300{
301	data->file.path = strdup(data->path);
302	if (!data->file.path)
303		return -ENOMEM;
304
305	return open_file(data);
306}
307
308static int open_dir(struct perf_data *data)
309{
310	int ret;
311
312	/*
313	 * So far we open only the header, so we can read the data version and
314	 * layout.
315	 */
316	if (asprintf(&data->file.path, "%s/data", data->path) < 0)
317		return -1;
318
319	if (perf_data__is_write(data) &&
320	    mkdir(data->path, S_IRWXU) < 0)
321		return -1;
322
323	ret = open_file(data);
324
325	/* Cleanup whatever we managed to create so far. */
326	if (ret && perf_data__is_write(data))
327		rm_rf_perf_data(data->path);
328
329	return ret;
330}
331
332int perf_data__open(struct perf_data *data)
333{
334	if (check_pipe(data))
335		return 0;
336
337	if (!data->path)
338		data->path = "perf.data";
339
340	if (check_backup(data))
341		return -1;
342
343	if (perf_data__is_read(data))
344		data->is_dir = is_dir(data);
345
346	return perf_data__is_dir(data) ?
347	       open_dir(data) : open_file_dup(data);
348}
349
350void perf_data__close(struct perf_data *data)
351{
352	if (perf_data__is_dir(data))
353		perf_data__close_dir(data);
354
355	zfree(&data->file.path);
356	close(data->file.fd);
357}
358
359ssize_t perf_data_file__write(struct perf_data_file *file,
360			      void *buf, size_t size)
361{
362	return writen(file->fd, buf, size);
363}
364
365ssize_t perf_data__write(struct perf_data *data,
366			      void *buf, size_t size)
367{
368	return perf_data_file__write(&data->file, buf, size);
369}
370
371int perf_data__switch(struct perf_data *data,
372			   const char *postfix,
373			   size_t pos, bool at_exit,
374			   char **new_filepath)
375{
376	int ret;
377
378	if (check_pipe(data))
379		return -EINVAL;
380	if (perf_data__is_read(data))
381		return -EINVAL;
382
383	if (asprintf(new_filepath, "%s.%s", data->path, postfix) < 0)
384		return -ENOMEM;
385
386	/*
387	 * Only fire a warning, don't return error, continue fill
388	 * original file.
389	 */
390	if (rename(data->path, *new_filepath))
391		pr_warning("Failed to rename %s to %s\n", data->path, *new_filepath);
392
393	if (!at_exit) {
394		close(data->file.fd);
395		ret = perf_data__open(data);
396		if (ret < 0)
397			goto out;
398
399		if (lseek(data->file.fd, pos, SEEK_SET) == (off_t)-1) {
400			ret = -errno;
401			pr_debug("Failed to lseek to %zu: %s",
402				 pos, strerror(errno));
403			goto out;
404		}
405	}
406	ret = data->file.fd;
407out:
408	return ret;
409}
410
411unsigned long perf_data__size(struct perf_data *data)
412{
413	u64 size = data->file.size;
414	int i;
415
416	if (perf_data__is_single_file(data))
417		return size;
418
419	for (i = 0; i < data->dir.nr; i++) {
420		struct perf_data_file *file = &data->dir.files[i];
421
422		size += file->size;
423	}
424
425	return size;
426}
427
428int perf_data__make_kcore_dir(struct perf_data *data, char *buf, size_t buf_sz)
429{
430	int ret;
431
432	if (!data->is_dir)
433		return -1;
434
435	ret = snprintf(buf, buf_sz, "%s/kcore_dir", data->path);
436	if (ret < 0 || (size_t)ret >= buf_sz)
437		return -1;
438
439	return mkdir(buf, S_IRWXU);
440}
441
442char *perf_data__kallsyms_name(struct perf_data *data)
443{
444	char *kallsyms_name;
445	struct stat st;
446
447	if (!data->is_dir)
448		return NULL;
449
450	if (asprintf(&kallsyms_name, "%s/kcore_dir/kallsyms", data->path) < 0)
451		return NULL;
452
453	if (stat(kallsyms_name, &st)) {
454		free(kallsyms_name);
455		return NULL;
456	}
457
458	return kallsyms_name;
459}