From patchwork Thu Dec 2 12:27:19 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652485 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2E653C433EF for ; Thu, 2 Dec 2021 12:27:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229561AbhLBMax (ORCPT ); Thu, 2 Dec 2021 07:30:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37090 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233967AbhLBMaw (ORCPT ); Thu, 2 Dec 2021 07:30:52 -0500 Received: from mail-ed1-x536.google.com (mail-ed1-x536.google.com [IPv6:2a00:1450:4864:20::536]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7621CC06174A for ; Thu, 2 Dec 2021 04:27:30 -0800 (PST) Received: by mail-ed1-x536.google.com with SMTP id t5so115475596edd.0 for ; Thu, 02 Dec 2021 04:27:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=tLF41MwcakWVLPdcI4/RUpaIjLs0D7fZ8WxfEM9lAsA=; b=Us+CV4js3paLo2zciHWCI2Q5LmABLnLa/BnLiZgub2O0WSWxizfO9WWiTCgRXR7qoh OQJLTmWx1V7F9+1RxDVaXjEPkijN+CPmaQtDjoFKKHTdM7oqEDs0Q3OljbB+eU6LpVY2 5Nazh3//GMxu9xLuMu5KQsILiRozjBAgGel4b9LOOA//Q1z9Xj3uXONVid+YpA3EwlYi C4fy8yAPJax2P0DRMYL7HVHlGwxuDccVOOeiIri5YfoC2UbSDx5VoUEyFtAAtHT/gw6h K0oEmKipGKgQLlmcqxZvMHY4JdrR8pXxm3gZpXCkKBuJ3fniMNNiDbC6ODHc8jSWpSkz +8bA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=tLF41MwcakWVLPdcI4/RUpaIjLs0D7fZ8WxfEM9lAsA=; b=Bz2GQKds3RFFJmIgF2aJ58hIDhuWo7USAHGkV1sgNBha1A+uzXBvrTM5J3uvMiqoUA Qy7TFkKc0xvRfygfNLnZUOCcd/TkwgQfZtWxU7312MbsNRpZrAIgP/XaTzsSYAJgb3m0 KhFwz+LP9v9WHw8niAUeyfaeMIzE23MIoRS8h4qhOIUgS1w8Ku/fZpu7CDlLkWDHA7Fa AiiQ8/lMQpZNNv8oliBgCvlxwSyTLEuxtJ2Q6mLHQ9cEFt56PxQjKcmxId4xVww+asSw 9Q87JJcHBikrm2OYzXxvfXZqeYYNoTkbNwW06FKQHdkYzvmjW38wAXJj8Q3nBWWd051f yOQg== X-Gm-Message-State: AOAM5307GttglEN0fJ4vMYVWOeH4oGaSyjz5RWU5y/anfzP0qoHkNpkd t4pAmQNpUIbjZfu7yG0yImm9XtztVjeV9w== X-Google-Smtp-Source: ABdhPJzwOm1mDw5jDmByWPn+kDSgRusmvUW4mlIADna9x4US+n8y4jufzUZaw1CKdf9O145mMqiYoQ== X-Received: by 2002:a17:907:7244:: with SMTP id ds4mr15595707ejc.55.1638448049009; Thu, 02 Dec 2021 04:27:29 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:28 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 1/8] trace-cmd library: Use output handler when copying data from input file Date: Thu, 2 Dec 2021 14:27:19 +0200 Message-Id: <20211202122726.43775-2-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org When copying data between two trace files, use input and output handlers, instead of raw file descriptors. Handlers take care of file version and compression context. Signed-off-by: Tzvetomir Stoyanov (VMware) --- .../include/private/trace-cmd-private.h | 3 +- lib/trace-cmd/include/trace-cmd-local.h | 2 + lib/trace-cmd/trace-input.c | 145 +++++++++--------- lib/trace-cmd/trace-output.c | 6 +- 4 files changed, 82 insertions(+), 74 deletions(-) diff --git a/lib/trace-cmd/include/private/trace-cmd-private.h b/lib/trace-cmd/include/private/trace-cmd-private.h index 6cc6ce46..9e2cfcdb 100644 --- a/lib/trace-cmd/include/private/trace-cmd-private.h +++ b/lib/trace-cmd/include/private/trace-cmd-private.h @@ -185,7 +185,8 @@ int tracecmd_get_parsing_failures(struct tracecmd_input *handle); int tracecmd_long_size(struct tracecmd_input *handle); int tracecmd_page_size(struct tracecmd_input *handle); int tracecmd_cpus(struct tracecmd_input *handle); -int tracecmd_copy_headers(struct tracecmd_input *handle, int fd, +int tracecmd_copy_headers(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, enum tracecmd_file_states start_state, enum tracecmd_file_states end_state); void tracecmd_set_flag(struct tracecmd_input *handle, int flag); diff --git a/lib/trace-cmd/include/trace-cmd-local.h b/lib/trace-cmd/include/trace-cmd-local.h index 5f3f1056..b4ed3225 100644 --- a/lib/trace-cmd/include/trace-cmd-local.h +++ b/lib/trace-cmd/include/trace-cmd-local.h @@ -61,6 +61,8 @@ out_write_section_header(struct tracecmd_output *handle, unsigned short header_i char *description, int flags, bool option); int out_update_section_header(struct tracecmd_output *handle, unsigned long long offset); +long long do_write_check(struct tracecmd_output *handle, const void *data, long long size); + struct cpu_data_source { int fd; int size; diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index 69c7c55d..d47d7a94 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -4380,44 +4380,47 @@ void tracecmd_close(struct tracecmd_input *handle) free(handle); } -static int read_copy_size8(struct tracecmd_input *handle, int fd, unsigned long long *size) +static int read_copy_size8(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, unsigned long long *size) { /* read size */ - if (do_read_check(handle, size, 8)) + if (do_read_check(in_handle, size, 8)) return -1; - if (__do_write_check(fd, size, 8)) + if (do_write_check(out_handle, size, 8)) return -1; - *size = tep_read_number(handle->pevent, size, 8); + *size = tep_read_number(in_handle->pevent, size, 8); return 0; } -static int read_copy_size4(struct tracecmd_input *handle, int fd, unsigned int *size) +static int read_copy_size4(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle, + unsigned int *size) { /* read size */ - if (do_read_check(handle, size, 4)) + if (do_read_check(in_handle, size, 4)) return -1; - if (__do_write_check(fd, size, 4)) + if (do_write_check(out_handle, size, 4)) return -1; - *size = tep_read_number(handle->pevent, size, 4); + *size = tep_read_number(in_handle->pevent, size, 4); return 0; } -static int read_copy_data(struct tracecmd_input *handle, - unsigned long long size, int fd) +static int read_copy_data(struct tracecmd_input *in_handle, + unsigned long long size, + struct tracecmd_output *out_handle) { char *buf; buf = malloc(size); if (!buf) return -1; - if (do_read_check(handle, buf, size)) + if (do_read_check(in_handle, buf, size)) goto failed_read; - if (__do_write_check(fd, buf, size)) + if (do_write_check(out_handle, buf, size)) goto failed_read; free(buf); @@ -4429,65 +4432,66 @@ static int read_copy_data(struct tracecmd_input *handle, return -1; } -static int copy_header_files(struct tracecmd_input *handle, int fd) +static int copy_header_files(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) { unsigned long long size; - if (handle->file_state != TRACECMD_FILE_HEADERS - 1) + if (in_handle->file_state != TRACECMD_FILE_HEADERS - 1) return -1; /* "header_page" */ - if (read_copy_data(handle, 12, fd) < 0) + if (read_copy_data(in_handle, 12, out_handle) < 0) return -1; - if (read_copy_size8(handle, fd, &size) < 0) + if (read_copy_size8(in_handle, out_handle, &size) < 0) return -1; - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; /* "header_event" */ - if (read_copy_data(handle, 13, fd) < 0) + if (read_copy_data(in_handle, 13, out_handle) < 0) return -1; - if (read_copy_size8(handle, fd, &size) < 0) + if (read_copy_size8(in_handle, out_handle, &size) < 0) return -1; - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; - handle->file_state = TRACECMD_FILE_HEADERS; + in_handle->file_state = TRACECMD_FILE_HEADERS; return 0; } -static int copy_ftrace_files(struct tracecmd_input *handle, int fd) +static int copy_ftrace_files(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { unsigned long long size; unsigned int count; unsigned int i; - if (handle->file_state != TRACECMD_FILE_FTRACE_EVENTS - 1) + if (in_handle->file_state != TRACECMD_FILE_FTRACE_EVENTS - 1) return -1; - if (read_copy_size4(handle, fd, &count) < 0) + if (read_copy_size4(in_handle, out_handle, &count) < 0) return -1; for (i = 0; i < count; i++) { - if (read_copy_size8(handle, fd, &size) < 0) + if (read_copy_size8(in_handle, out_handle, &size) < 0) return -1; - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; } - handle->file_state = TRACECMD_FILE_FTRACE_EVENTS; + in_handle->file_state = TRACECMD_FILE_FTRACE_EVENTS; return 0; } -static int copy_event_files(struct tracecmd_input *handle, int fd) +static int copy_event_files(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { unsigned long long size; char *system; @@ -4495,103 +4499,103 @@ static int copy_event_files(struct tracecmd_input *handle, int fd) unsigned int count; unsigned int i,x; - if (handle->file_state != TRACECMD_FILE_ALL_EVENTS - 1) + if (in_handle->file_state != TRACECMD_FILE_ALL_EVENTS - 1) return -1; - if (read_copy_size4(handle, fd, &systems) < 0) + if (read_copy_size4(in_handle, out_handle, &systems) < 0) return -1; for (i = 0; i < systems; i++) { - system = read_string(handle); + system = read_string(in_handle); if (!system) return -1; - if (__do_write_check(fd, system, strlen(system) + 1)) { + if (do_write_check(out_handle, system, strlen(system) + 1)) { free(system); return -1; } free(system); - if (read_copy_size4(handle, fd, &count) < 0) + if (read_copy_size4(in_handle, out_handle, &count) < 0) return -1; for (x=0; x < count; x++) { - if (read_copy_size8(handle, fd, &size) < 0) + if (read_copy_size8(in_handle, out_handle, &size) < 0) return -1; - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; } } - handle->file_state = TRACECMD_FILE_ALL_EVENTS; + in_handle->file_state = TRACECMD_FILE_ALL_EVENTS; return 0; } -static int copy_proc_kallsyms(struct tracecmd_input *handle, int fd) +static int copy_proc_kallsyms(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { unsigned int size; - if (handle->file_state != TRACECMD_FILE_KALLSYMS - 1) + if (in_handle->file_state != TRACECMD_FILE_KALLSYMS - 1) return -1; - if (read_copy_size4(handle, fd, &size) < 0) + if (read_copy_size4(in_handle, out_handle, &size) < 0) return -1; if (!size) return 0; /* OK? */ - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; - handle->file_state = TRACECMD_FILE_KALLSYMS; + in_handle->file_state = TRACECMD_FILE_KALLSYMS; return 0; } -static int copy_ftrace_printk(struct tracecmd_input *handle, int fd) +static int copy_ftrace_printk(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { unsigned int size; - if (handle->file_state != TRACECMD_FILE_PRINTK - 1) + if (in_handle->file_state != TRACECMD_FILE_PRINTK - 1) return -1; - if (read_copy_size4(handle, fd, &size) < 0) + if (read_copy_size4(in_handle, out_handle, &size) < 0) return -1; if (!size) return 0; /* OK? */ - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; - handle->file_state = TRACECMD_FILE_PRINTK; + in_handle->file_state = TRACECMD_FILE_PRINTK; return 0; } -static int copy_command_lines(struct tracecmd_input *handle, int fd) +static int copy_command_lines(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { unsigned long long size; - if (handle->file_state != TRACECMD_FILE_CMD_LINES - 1) + if (in_handle->file_state != TRACECMD_FILE_CMD_LINES - 1) return -1; - if (read_copy_size8(handle, fd, &size) < 0) + if (read_copy_size8(in_handle, out_handle, &size) < 0) return -1; if (!size) return 0; /* OK? */ - if (read_copy_data(handle, size, fd) < 0) + if (read_copy_data(in_handle, size, out_handle) < 0) return -1; - handle->file_state = TRACECMD_FILE_CMD_LINES; + in_handle->file_state = TRACECMD_FILE_CMD_LINES; return 0; } /** * tracecmd_copy_headers - Copy headers from a tracecmd_input handle to a file descriptor - * @handle: input handle for the trace.dat file to copy from. - * @fd: The file descriptor to copy to. + * @in_handle: input handle for the trace.dat file to copy from. + * @out_handle: output handle to the trace.dat file to copy to. * @start_state: The file state to start copying from (zero for the beginnig) * @end_state: The file state to stop at (zero for up to cmdlines) * @@ -4602,7 +4606,8 @@ static int copy_command_lines(struct tracecmd_input *handle, int fd) * NOTE: The input handle is also modified, and ends at the end * state as well. */ -int tracecmd_copy_headers(struct tracecmd_input *handle, int fd, +int tracecmd_copy_headers(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, enum tracecmd_file_states start_state, enum tracecmd_file_states end_state) { @@ -4620,71 +4625,71 @@ int tracecmd_copy_headers(struct tracecmd_input *handle, int fd, if (end_state < TRACECMD_FILE_HEADERS) return 0; - if (handle->file_state >= start_state) { + if (in_handle->file_state >= start_state) { /* Set the handle to just before the start state */ - sec = section_open(handle, TRACECMD_OPTION_HEADER_INFO); + sec = section_open(in_handle, TRACECMD_OPTION_HEADER_INFO); if (!sec) return -1; /* Now that the file handle has moved, change its state */ - handle->file_state = TRACECMD_FILE_INIT; + in_handle->file_state = TRACECMD_FILE_INIT; } /* Try to bring the input up to the start state - 1 */ - ret = tracecmd_read_headers(handle, start_state - 1); + ret = tracecmd_read_headers(in_handle, start_state - 1); if (sec) - section_close(handle, sec); + section_close(in_handle, sec); if (ret < 0) goto out; switch (start_state) { case TRACECMD_FILE_HEADERS: - ret = copy_header_files(handle, fd); + ret = copy_header_files(in_handle, out_handle); if (ret < 0) goto out; /* fallthrough */ case TRACECMD_FILE_FTRACE_EVENTS: /* handle's state is now updating with the copies */ - if (end_state <= handle->file_state) + if (end_state <= in_handle->file_state) return 0; - ret = copy_ftrace_files(handle, fd); + ret = copy_ftrace_files(in_handle, out_handle); if (ret < 0) goto out; /* fallthrough */ case TRACECMD_FILE_ALL_EVENTS: - if (end_state <= handle->file_state) + if (end_state <= in_handle->file_state) return 0; - ret = copy_event_files(handle, fd); + ret = copy_event_files(in_handle, out_handle); if (ret < 0) goto out; /* fallthrough */ case TRACECMD_FILE_KALLSYMS: - if (end_state <= handle->file_state) + if (end_state <= in_handle->file_state) return 0; - ret = copy_proc_kallsyms(handle, fd); + ret = copy_proc_kallsyms(in_handle, out_handle); if (ret < 0) goto out; /* fallthrough */ case TRACECMD_FILE_PRINTK: - if (end_state <= handle->file_state) + if (end_state <= in_handle->file_state) return 0; - ret = copy_ftrace_printk(handle, fd); + ret = copy_ftrace_printk(in_handle, out_handle); if (ret < 0) goto out; /* fallthrough */ case TRACECMD_FILE_CMD_LINES: - if (end_state <= handle->file_state) + if (end_state <= in_handle->file_state) return 0; - ret = copy_command_lines(handle, fd); + ret = copy_command_lines(in_handle, out_handle); default: break; } diff --git a/lib/trace-cmd/trace-output.c b/lib/trace-cmd/trace-output.c index bd838d1d..8063e249 100644 --- a/lib/trace-cmd/trace-output.c +++ b/lib/trace-cmd/trace-output.c @@ -89,8 +89,8 @@ struct list_event_system { static int write_options_v7(struct tracecmd_output *handle); -static stsize_t -do_write_check(struct tracecmd_output *handle, const void *data, tsize_t size) +__hidden long long +do_write_check(struct tracecmd_output *handle, const void *data, long long size) { if (handle->do_compress) return tracecmd_compress_write(handle->compress, data, size); @@ -2492,7 +2492,7 @@ struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, goto out_free; output_write_init(handle); - if (tracecmd_copy_headers(ihandle, handle->fd, 0, 0) < 0) + if (tracecmd_copy_headers(ihandle, handle, 0, 0) < 0) goto out_free; handle->file_state = tracecmd_get_file_state(ihandle); From patchwork Thu Dec 2 12:27:20 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652487 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D31C7C433FE for ; Thu, 2 Dec 2021 12:27:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240129AbhLBMay (ORCPT ); Thu, 2 Dec 2021 07:30:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37094 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233967AbhLBMay (ORCPT ); Thu, 2 Dec 2021 07:30:54 -0500 Received: from mail-ed1-x52f.google.com (mail-ed1-x52f.google.com [IPv6:2a00:1450:4864:20::52f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5EF75C06174A for ; Thu, 2 Dec 2021 04:27:31 -0800 (PST) Received: by mail-ed1-x52f.google.com with SMTP id t5so115475741edd.0 for ; Thu, 02 Dec 2021 04:27:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=v45G83vXhejjWAwHMsNZblzs8wASV4H1MfKyvmrVcK4=; b=OcAev1w9mTUFsJ24JR2NWEN8I3961yyuGsEceoEsonTBw3813mEIkc8ssFXdYd+kVN uopiDOsR7XlCTpa8Edl9uNTrNZDEaavlYIjsLtHkV1+nVUSp5r40a2jlqqiVtzJZhLqp qjvgfu1zfUGzH6rOLcsOYCW8+BSJXdo/DxKULQ5cn6nKxcW2gv5eYuIvnioCgyUT/S5j YxKEkLSqBYagOzmvjLC8i88Iv+BvlMKFlLdZdcb0GocMJ47Io1vPux4yC8KfOBTfEyfk RRuJUVzg5moVfgwIsUG27N+npzhJXXbM4oNjD5BN5R8AV7DSkcUUEyaF5K7GfH0Ho1Bu aing== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=v45G83vXhejjWAwHMsNZblzs8wASV4H1MfKyvmrVcK4=; b=VDCS2CdJj92XNkD7d8ciXPrqMWDWV+Q3QurrKAaf81UQh1AEYd2wOm7nk8vFwvW+t5 2fPPhST61L6VfII9sPl9f+89Tut8yHvtXvgTqtudZAhw6HedNmvtQZNoDrq+Y/NPSAu2 MdjKD+3qSXokzKCwQI+rmBIX0m+YavT7uyi3p6COYyZiC8rC7xG8ueSogMCAqUN/ebLf lze8ymFz2L56iuIz6mvR20d/faYJgIFuTgwkpJeQQOktsuPTgGTg8MlOj8FlkKngBkKR CyiyXQ5ucAAYha9y3d5Wwjvw3FMBtuUq4+K/tPTUyqHX8m6nkGrvrcW2pRkPrTs7aXog SFFA== X-Gm-Message-State: AOAM532WNWIeDSI8pqtTKErU7Os60yfaivnhdzeW5wBfrPHWHnQ+hVKl B8OupMWySRw9C51syejz5o+7dNNOKlFl4w== X-Google-Smtp-Source: ABdhPJzWoyDbWcCe5OltoMamAZJFpZvhdQBzZYl6N5yBsH+y119pcqAZ/nc4vQS8HkxgGzpMoGJ/sw== X-Received: by 2002:a17:907:3f07:: with SMTP id hq7mr14979782ejc.420.1638448049791; Thu, 02 Dec 2021 04:27:29 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:29 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 2/8] trace-cmd library: Handle version 7 files when copying headers between files Date: Thu, 2 Dec 2021 14:27:20 +0200 Message-Id: <20211202122726.43775-3-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org When copying header data between trace files, handle the file versions. Internal library functions for copying these headers are fixed to work with trace file version 7: copy_header_files copy_ftrace_files copy_event_files copy_proc_kallsyms copy_command_lines Signed-off-by: Tzvetomir Stoyanov (VMware) --- lib/trace-cmd/include/trace-cmd-local.h | 3 + lib/trace-cmd/trace-input.c | 211 ++++++++++++++++++++---- lib/trace-cmd/trace-output.c | 10 ++ lib/trace-cmd/trace-util.c | 8 +- 4 files changed, 200 insertions(+), 32 deletions(-) diff --git a/lib/trace-cmd/include/trace-cmd-local.h b/lib/trace-cmd/include/trace-cmd-local.h index b4ed3225..b0b70655 100644 --- a/lib/trace-cmd/include/trace-cmd-local.h +++ b/lib/trace-cmd/include/trace-cmd-local.h @@ -50,6 +50,9 @@ int out_uncompress_block(struct tracecmd_output *handle); int out_compression_start(struct tracecmd_output *handle, bool compress); int out_compression_end(struct tracecmd_output *handle, bool compress); void out_compression_reset(struct tracecmd_output *handle, bool compress); +bool out_check_compression(struct tracecmd_output *handle); + +void out_set_file_state(struct tracecmd_output *handle, int new_state); unsigned long long out_copy_fd_compress(struct tracecmd_output *handle, int fd, unsigned long long max, unsigned long long *write_size); diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index d47d7a94..8cd03de0 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -4432,164 +4432,313 @@ static int read_copy_data(struct tracecmd_input *in_handle, return -1; } + +static bool check_in_state(struct tracecmd_input *handle, int new_state) +{ + return check_file_state(handle->file_version, handle->file_state, new_state); +} + static int copy_header_files(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned long long size; - if (in_handle->file_state != TRACECMD_FILE_HEADERS - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_HEADERS) || + !check_out_state(out_handle, TRACECMD_FILE_HEADERS)) return -1; + sec = section_open(in_handle, TRACECMD_OPTION_HEADER_INFO); + if (!sec) + return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_HEADER_INFO, + "headers", TRACECMD_SEC_FL_COMPRESS, true); + out_compression_start(out_handle, compress); + /* "header_page" */ if (read_copy_data(in_handle, 12, out_handle) < 0) - return -1; + goto error; if (read_copy_size8(in_handle, out_handle, &size) < 0) - return -1; + goto error; if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; /* "header_event" */ if (read_copy_data(in_handle, 13, out_handle) < 0) - return -1; + goto error; if (read_copy_size8(in_handle, out_handle, &size) < 0) - return -1; + goto error; if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; in_handle->file_state = TRACECMD_FILE_HEADERS; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } static int copy_ftrace_files(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned long long size; unsigned int count; unsigned int i; - if (in_handle->file_state != TRACECMD_FILE_FTRACE_EVENTS - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_FTRACE_EVENTS) || + !check_out_state(out_handle, TRACECMD_FILE_FTRACE_EVENTS)) return -1; - if (read_copy_size4(in_handle, out_handle, &count) < 0) + sec = section_open(in_handle, TRACECMD_OPTION_FTRACE_EVENTS); + if (!sec) return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_FTRACE_EVENTS, + "ftrace events", TRACECMD_SEC_FL_COMPRESS, true); + + out_compression_start(out_handle, compress); + + if (read_copy_size4(in_handle, out_handle, &count) < 0) + goto error; for (i = 0; i < count; i++) { if (read_copy_size8(in_handle, out_handle, &size) < 0) - return -1; + goto error; if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; } in_handle->file_state = TRACECMD_FILE_FTRACE_EVENTS; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } static int copy_event_files(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned long long size; char *system; unsigned int systems; unsigned int count; unsigned int i,x; - if (in_handle->file_state != TRACECMD_FILE_ALL_EVENTS - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_ALL_EVENTS) || + !check_out_state(out_handle, TRACECMD_FILE_ALL_EVENTS)) return -1; - if (read_copy_size4(in_handle, out_handle, &systems) < 0) + sec = section_open(in_handle, TRACECMD_OPTION_EVENT_FORMATS); + if (!sec) return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_EVENT_FORMATS, + "events format", TRACECMD_SEC_FL_COMPRESS, true); + + out_compression_start(out_handle, compress); + + if (read_copy_size4(in_handle, out_handle, &systems) < 0) + goto error; for (i = 0; i < systems; i++) { system = read_string(in_handle); if (!system) - return -1; + goto error; if (do_write_check(out_handle, system, strlen(system) + 1)) { free(system); - return -1; + goto error; } free(system); if (read_copy_size4(in_handle, out_handle, &count) < 0) - return -1; + goto error; for (x=0; x < count; x++) { if (read_copy_size8(in_handle, out_handle, &size) < 0) - return -1; + goto error; if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; } } in_handle->file_state = TRACECMD_FILE_ALL_EVENTS; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } static int copy_proc_kallsyms(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned int size; - if (in_handle->file_state != TRACECMD_FILE_KALLSYMS - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_KALLSYMS) || + !check_out_state(out_handle, TRACECMD_FILE_KALLSYMS)) return -1; - if (read_copy_size4(in_handle, out_handle, &size) < 0) + sec = section_open(in_handle, TRACECMD_OPTION_KALLSYMS); + if (!sec) return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_KALLSYMS, + "kallsyms", TRACECMD_SEC_FL_COMPRESS, true); + + out_compression_start(out_handle, compress); + if (read_copy_size4(in_handle, out_handle, &size) < 0) + goto error; if (!size) - return 0; /* OK? */ + goto out; /* OK? */ if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; - + goto error; +out: in_handle->file_state = TRACECMD_FILE_KALLSYMS; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } static int copy_ftrace_printk(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned int size; - if (in_handle->file_state != TRACECMD_FILE_PRINTK - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_PRINTK) || + !check_out_state(out_handle, TRACECMD_FILE_PRINTK)) return -1; - if (read_copy_size4(in_handle, out_handle, &size) < 0) + sec = section_open(in_handle, TRACECMD_OPTION_PRINTK); + if (!sec) return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_PRINTK, + "printk", TRACECMD_SEC_FL_COMPRESS, true); + + out_compression_start(out_handle, compress); + + if (read_copy_size4(in_handle, out_handle, &size) < 0) + goto error; if (!size) - return 0; /* OK? */ + goto out; /* OK? */ if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; +out: in_handle->file_state = TRACECMD_FILE_PRINTK; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } static int copy_command_lines(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) { + bool compress = out_check_compression(out_handle); + struct file_section *sec; + unsigned long long offset; unsigned long long size; - if (in_handle->file_state != TRACECMD_FILE_CMD_LINES - 1) + if (!check_in_state(in_handle, TRACECMD_FILE_CMD_LINES) || + !check_out_state(out_handle, TRACECMD_FILE_CMD_LINES)) return -1; - if (read_copy_size8(in_handle, out_handle, &size) < 0) + sec = section_open(in_handle, TRACECMD_OPTION_CMDLINES); + if (!sec) return -1; + offset = out_write_section_header(out_handle, TRACECMD_OPTION_CMDLINES, + "command lines", TRACECMD_SEC_FL_COMPRESS, true); + + out_compression_start(out_handle, compress); + + if (read_copy_size8(in_handle, out_handle, &size) < 0) + goto error; if (!size) - return 0; /* OK? */ + goto out; /* OK? */ if (read_copy_data(in_handle, size, out_handle) < 0) - return -1; + goto error; +out: in_handle->file_state = TRACECMD_FILE_CMD_LINES; + if (out_compression_end(out_handle, compress)) + goto error; + out_set_file_state(out_handle, in_handle->file_state); + + section_close(in_handle, sec); + + if (out_update_section_header(out_handle, offset)) + goto error; return 0; +error: + out_compression_reset(out_handle, compress); + section_close(in_handle, sec); + return -1; } /** diff --git a/lib/trace-cmd/trace-output.c b/lib/trace-cmd/trace-output.c index 8063e249..8ce23fbc 100644 --- a/lib/trace-cmd/trace-output.c +++ b/lib/trace-cmd/trace-output.c @@ -2505,11 +2505,21 @@ out_free: return NULL; } +__hidden void out_set_file_state(struct tracecmd_output *handle, int new_state) +{ + handle->file_state = new_state; +} + __hidden bool check_out_state(struct tracecmd_output *handle, int new_state) { return check_file_state(handle->file_version, handle->file_state, new_state); } +__hidden bool out_check_compression(struct tracecmd_output *handle) +{ + return (handle->compress != NULL); +} + /** * tracecmd_get_out_file_version - return the trace.dat file version * @handle: output handle for the trace.dat file diff --git a/lib/trace-cmd/trace-util.c b/lib/trace-cmd/trace-util.c index 06071f6c..f9014a9a 100644 --- a/lib/trace-cmd/trace-util.c +++ b/lib/trace-cmd/trace-util.c @@ -647,6 +647,12 @@ static void __attribute__((destructor)) tracecmd_lib_free(void) __hidden bool check_file_state(unsigned long file_version, int current_state, int new_state) { + if (file_version >= FILE_VERSION_SECTIONS) { + if (current_state < TRACECMD_FILE_INIT) + return false; + return true; + } + switch (new_state) { case TRACECMD_FILE_HEADERS: case TRACECMD_FILE_FTRACE_EVENTS: @@ -659,7 +665,7 @@ __hidden bool check_file_state(unsigned long file_version, int current_state, in return true; break; case TRACECMD_FILE_OPTIONS: - if (current_state == (new_state - 1)) + if (file_version < FILE_VERSION_SECTIONS && current_state == TRACECMD_FILE_CPU_COUNT) return true; break; case TRACECMD_FILE_CPU_LATENCY: From patchwork Thu Dec 2 12:27:21 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652491 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9FF52C433FE for ; Thu, 2 Dec 2021 12:27:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233967AbhLBMa5 (ORCPT ); Thu, 2 Dec 2021 07:30:57 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37108 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240265AbhLBMaz (ORCPT ); Thu, 2 Dec 2021 07:30:55 -0500 Received: from mail-ed1-x52e.google.com (mail-ed1-x52e.google.com [IPv6:2a00:1450:4864:20::52e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7CA6DC061757 for ; Thu, 2 Dec 2021 04:27:33 -0800 (PST) Received: by mail-ed1-x52e.google.com with SMTP id r25so49185402edq.7 for ; Thu, 02 Dec 2021 04:27:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=lbuXHNZqAeL/Zo3Awo3tYVuoLh3AWEQpHm7l237xiXQ=; b=jlEXGpeUoPUEqlSZh1gJ/qmyDkmNOri9BKb3GPL1X6WSaokJuX2VFb9QLr4aeI5Qjs iBzma2BIy8Lx5aANjMaP8PZRwXf6VX2Bk1DxjXwdaVWNaeG2N+aeZLv6DVwpF0MKw2Er ARrvhsu3n+b01MsP7ulNlyr0yjLsN8zkT2KCxrU5uwxc/VEnAE6qrYEV5eI1t6J1qIit 59QWJMDDb5UF+fOjzMwuKP1SIUH3e8251KrFgrgOmfkAegI+8HUFnb6JeqmpvS+pN/75 inanWNVhwBKgW6Ea4+IkZFD+WZCY3RtP96Sjm+o9SJx9j2tqwB62h1/nSe/RNubGB2Iw cCMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=lbuXHNZqAeL/Zo3Awo3tYVuoLh3AWEQpHm7l237xiXQ=; b=CWju+DWQkQ4p6jdOGpxbj8qlJUaNVFptd+JUeAP7jbjhj5qVgAGPLDHNGE7Q5h59Js twGumfONLf97F1+00EUey35gtTSvDy3znOuhmrUBVBfNgkSLEM5rzQCXAqnWu8LdKGz6 W7QVz3tqQanmpol0f9quBpjrTQrKStdqTO436bvVki5UzuQUxEFC3kAT/zGa5GTvT/W7 cYwOE9jzZwk0ovX1wqjgtu/Yiy+zr+U3zrrvNAXeoA/zc7u1mCRLHu/JY85wXt6hsYYd YU8PlUiwO46Nttt67aGEgMP4VRzGkceiqu1fUW1fT+Hhx48RL6un2JeZVv8BcEr6EwPI w0mg== X-Gm-Message-State: AOAM533c26ukGqgVy1XLVTPGphJhnBVXqAgl+8htI+jvnXIQwfTXfWnb Auq5MCvH2pCmD5WGSlK/YWGuRyiq2+YP+g== X-Google-Smtp-Source: ABdhPJwMwlZHWUNVDrF2YrUHtvTzT2XbBIN3CkSGnFq9dIoQ/BrOoh5JtXuAqjOcFgWXkPsvqaFehA== X-Received: by 2002:a17:906:6a0a:: with SMTP id qw10mr14747084ejc.547.1638448050684; Thu, 02 Dec 2021 04:27:30 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:30 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 3/8] trace-cmd library: Copy CPU count between trace files Date: Thu, 2 Dec 2021 14:27:21 +0200 Message-Id: <20211202122726.43775-4-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org The tracecmd_copy_headers() API should be able to copy CPU count also, as it is part of the headers. Signed-off-by: Tzvetomir Stoyanov (VMware) --- lib/trace-cmd/trace-input.c | 42 +++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index 8cd03de0..4cfe26bc 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -4741,6 +4741,35 @@ error: return -1; } +static int copy_cpu_count(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) +{ + unsigned int cpus; + + if (!check_in_state(in_handle, TRACECMD_FILE_CPU_COUNT) || + !check_out_state(out_handle, TRACECMD_FILE_CPU_COUNT)) + return -1; + + if (!HAS_SECTIONS(in_handle)) { + if (read4(in_handle, &cpus)) + return -1; + } else { + cpus = in_handle->max_cpu; + } + + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) { + cpus = tep_read_number(in_handle->pevent, &cpus, 4); + if (do_write_check(out_handle, &cpus, 4)) + return -1; + } else { + tracecmd_add_option(out_handle, TRACECMD_OPTION_CPUCOUNT, sizeof(int), &cpus); + } + + in_handle->file_state = TRACECMD_FILE_CPU_COUNT; + out_set_file_state(out_handle, in_handle->file_state); + + return 0; +} + /** * tracecmd_copy_headers - Copy headers from a tracecmd_input handle to a file descriptor * @in_handle: input handle for the trace.dat file to copy from. @@ -4839,6 +4868,19 @@ int tracecmd_copy_headers(struct tracecmd_input *in_handle, return 0; ret = copy_command_lines(in_handle, out_handle); + if (ret < 0) + goto out; + + /* fallthrough */ + case TRACECMD_FILE_CPU_COUNT: + if (end_state <= in_handle->file_state) + return 0; + + ret = copy_cpu_count(in_handle, out_handle); + if (ret < 0) + goto out; + + /* fallthrough */ default: break; } From patchwork Thu Dec 2 12:27:22 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652489 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3692BC433F5 for ; Thu, 2 Dec 2021 12:27:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240414AbhLBMa4 (ORCPT ); Thu, 2 Dec 2021 07:30:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37106 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233967AbhLBMaz (ORCPT ); Thu, 2 Dec 2021 07:30:55 -0500 Received: from mail-ed1-x530.google.com (mail-ed1-x530.google.com [IPv6:2a00:1450:4864:20::530]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7808EC06174A for ; Thu, 2 Dec 2021 04:27:33 -0800 (PST) Received: by mail-ed1-x530.google.com with SMTP id y12so115227684eda.12 for ; Thu, 02 Dec 2021 04:27:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=cilZ0IFiLox+aidlI21vhwNnKufJ982VhRU5hNioMJ8=; b=ddyiNW3ahqYVmG6W/kw8/8TvUMJnYk/dEGqQihKES7SfOl59GnUq2X85NXAIAIqcxn NSj4wBmqBU/xEUABqJ+Lmp7quXCGa5LgesipNy2WMAbmBrtgiLyVHZkiQgk3sAXVRaYa ZcNodUaHWdPu63eg0pVeQ1NROziS0hwDi/r0tqeLtV7imnSFZ91ZcEazSTrLYLGSne/2 QKEpv2B40oURr5pz1EfM6i+BPWYrWnMfiYDhBB3eNIkvBs2Gm08cFWSC9Y/zLr6MuRVf BK2r3T3cjNfySjnMdbmF3KSnLKzeuFdwWu3XWNdlheuhQlJgo7ytw66nzHFBJ/dkyPx0 SSqg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=cilZ0IFiLox+aidlI21vhwNnKufJ982VhRU5hNioMJ8=; b=pNn7OzA1v43HzN48oSqRMITsUIW/lJ5wE0XSWq4M+TC6G85b+LYRErzA736bXLTWFN 0DFgXf6N2bkOCFgQohXCreyssqwant5WHOEwwpapvGJfgfJolJUcJNAtzgjrukU0yk8z M4GgVps/jqscy8KdZSis+jQtMc2PXbgRA6EZ1f0pkPgoMVA7vUdnbc2uWfwPhtdpH+jB o2ST8jgRjbXu+tceApnmy8t4Cc8R8Wb8pbi99SHZ5GAFd+BbhKG9FvoReXZi3Bgo/TId QVVUKjsFtB3oFB5LqpgOQevxk7Ih8ca2qScNzRx3qykcGj517d5VXtOX93J8HQugdAtF lbpw== X-Gm-Message-State: AOAM533er+QD0EqQCAnSB1bnLx9HI5vJbK1HsKKOs97hUE8ZDNwx4YZE +tISet6v+T5Iqu3dG2IDYA3Vwb5/SSKVzQ== X-Google-Smtp-Source: ABdhPJz0lJhQDewOEYAXQyUjkmn3Q8uZ0ueZhv0zo1x0NHFyFDaoAGxV4LMzXDTMMhqTV5pRn4WDdw== X-Received: by 2002:a05:6402:1450:: with SMTP id d16mr17565625edx.144.1638448051698; Thu, 02 Dec 2021 04:27:31 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:31 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 4/8] trace-cmd library: New API to copy buffer description between trace files Date: Thu, 2 Dec 2021 14:27:22 +0200 Message-Id: <20211202122726.43775-5-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org A new library API is introduced, to copy buffers description between trace files: tracecmd_copy_buffer_descr() Signed-off-by: Tzvetomir Stoyanov (VMware) --- lib/trace-cmd/include/private/trace-cmd-private.h | 2 ++ lib/trace-cmd/trace-input.c | 13 +++++++++++++ 2 files changed, 15 insertions(+) diff --git a/lib/trace-cmd/include/private/trace-cmd-private.h b/lib/trace-cmd/include/private/trace-cmd-private.h index 9e2cfcdb..58afb455 100644 --- a/lib/trace-cmd/include/private/trace-cmd-private.h +++ b/lib/trace-cmd/include/private/trace-cmd-private.h @@ -189,6 +189,8 @@ int tracecmd_copy_headers(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle, enum tracecmd_file_states start_state, enum tracecmd_file_states end_state); +int tracecmd_copy_buffer_descr(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle); void tracecmd_set_flag(struct tracecmd_input *handle, int flag); void tracecmd_clear_flag(struct tracecmd_input *handle, int flag); unsigned long tracecmd_get_flags(struct tracecmd_input *handle); diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index 4cfe26bc..98c809c6 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -4889,6 +4889,19 @@ int tracecmd_copy_headers(struct tracecmd_input *in_handle, return ret < 0 ? -1 : 0; } +int tracecmd_copy_buffer_descr(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + int i; + + if (tracecmd_get_out_file_version(out_handle) >= FILE_VERSION_SECTIONS) + return 0; + + for (i = 0; i < in_handle->nr_buffers; i++) + tracecmd_add_buffer_info(out_handle, in_handle->buffers[i].name, 0); + return tracecmd_write_buffer_info(out_handle); +} + /** * tracecmd_record_at_buffer_start - return true if record is first on subbuffer * @handle: input handle for the trace.dat file From patchwork Thu Dec 2 12:27:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652493 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 06950C433EF for ; Thu, 2 Dec 2021 12:27:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242157AbhLBMa7 (ORCPT ); Thu, 2 Dec 2021 07:30:59 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37114 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240491AbhLBMa5 (ORCPT ); Thu, 2 Dec 2021 07:30:57 -0500 Received: from mail-ed1-x536.google.com (mail-ed1-x536.google.com [IPv6:2a00:1450:4864:20::536]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3C7D0C061758 for ; Thu, 2 Dec 2021 04:27:34 -0800 (PST) Received: by mail-ed1-x536.google.com with SMTP id l25so115150900eda.11 for ; Thu, 02 Dec 2021 04:27:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=7zySWcoK3GHpKaLkQozyuNevCbYukVomqKaWlAWw0jI=; b=LxH96wnPNJq8zBa20DkPtHvkhuAmbHPpMMFiIhJsFOlZKLQzccKnsYh2ZTNeF2KVZO Iy7+RIWccMya25agn96yRa2VGx1a9Psjw/qGSJsDKuIuMwuyu+B/fhXsv2qn5yJQdoTo QQ/dOa0QxezjgQBBwlSxaiS7/L7eu+lmmMrdQB5K4/AOW8+DD7iQddBnmFDneJxurFG5 f1wa6lErCCiO96bwwlicO0a/jQ1efEs+IlaI1Skb/S/p14Ijqvtryw95EBqou0S6mIwF t2kx6l5Gf6NkRCL+N9jhRKKaXCniXbPd1lOn5qmhb5vw0moSz52kz8mRO4PNXTm7umux uwlA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=7zySWcoK3GHpKaLkQozyuNevCbYukVomqKaWlAWw0jI=; b=0f1KV7MtPgtQqfzRI71BYXAAcJTX8SdayhxZMLkGv8nCHUt7caI2qnx5+b5NIYkuMo TwyAEWx3/+vOJG0ZqC5nKLFjGWLybNhDkYmGuo9MSqE6GkoeA0RYzLgYV0JA8zIS3vTZ cVpCELJ4/yxnVxVA7m+ae0hw1SOh7J9mXiEBHABBwMneLflVHD6/PtmyKsvo8bX8Ertx JyCYzI+r/4XbTZMblCNDSk4wrBfZvl38IhheXKlu31nOWSsjY/cPuwPF8vkT90dz5wFc 916ZUnmHsPGneFTyYBl93CMYZowiVfPUA2I6LXJDQQtKmUBWN7n0jOFfdyelGY7UQdOD A3wg== X-Gm-Message-State: AOAM533e5N0AfhDVHUfuG3C9K5TNCkIVLeJGDmmfumElsmuK2z70MaX0 PqFY26atKYUq3hBv35JkEql+O4+qhi9SlQ== X-Google-Smtp-Source: ABdhPJzAUVJQKudXHXiLRkNIn0JuhvlxOS8KAge1cgX0HDlDXeoccYx2kYCkyhSQBszAIWpntcvo3w== X-Received: by 2002:a17:906:bc46:: with SMTP id s6mr15115946ejv.467.1638448052617; Thu, 02 Dec 2021 04:27:32 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:32 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 5/8] trace-cmd library: New API to copy options between trace files Date: Thu, 2 Dec 2021 14:27:23 +0200 Message-Id: <20211202122726.43775-6-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org A new library API is introduced, to copy options between trace files: tracecmd_copy_options() Signed-off-by: Tzvetomir Stoyanov (VMware) --- .../include/private/trace-cmd-private.h | 3 + lib/trace-cmd/include/trace-cmd-local.h | 2 + lib/trace-cmd/trace-input.c | 140 ++++++++++++++++++ lib/trace-cmd/trace-output.c | 30 ++++ 4 files changed, 175 insertions(+) diff --git a/lib/trace-cmd/include/private/trace-cmd-private.h b/lib/trace-cmd/include/private/trace-cmd-private.h index 58afb455..2c46d885 100644 --- a/lib/trace-cmd/include/private/trace-cmd-private.h +++ b/lib/trace-cmd/include/private/trace-cmd-private.h @@ -191,6 +191,8 @@ int tracecmd_copy_headers(struct tracecmd_input *in_handle, enum tracecmd_file_states end_state); int tracecmd_copy_buffer_descr(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle); +int tracecmd_copy_options(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle); void tracecmd_set_flag(struct tracecmd_input *handle, int flag); void tracecmd_clear_flag(struct tracecmd_input *handle, int flag); unsigned long tracecmd_get_flags(struct tracecmd_input *handle); @@ -335,6 +337,7 @@ int tracecmd_append_buffer_cpu_data(struct tracecmd_output *handle, const char *name, int cpus, char * const *cpu_data_files); struct tracecmd_output *tracecmd_get_output_handle_fd(int fd); unsigned long tracecmd_get_out_file_version(struct tracecmd_output *handle); +unsigned long long tracecmd_get_out_file_offset(struct tracecmd_output *handle); /* --- Reading the Fly Recorder Trace --- */ diff --git a/lib/trace-cmd/include/trace-cmd-local.h b/lib/trace-cmd/include/trace-cmd-local.h index b0b70655..6f14fa03 100644 --- a/lib/trace-cmd/include/trace-cmd-local.h +++ b/lib/trace-cmd/include/trace-cmd-local.h @@ -53,6 +53,8 @@ void out_compression_reset(struct tracecmd_output *handle, bool compress); bool out_check_compression(struct tracecmd_output *handle); void out_set_file_state(struct tracecmd_output *handle, int new_state); +int out_save_options_offset(struct tracecmd_output *handle, + unsigned long long start); unsigned long long out_copy_fd_compress(struct tracecmd_output *handle, int fd, unsigned long long max, unsigned long long *write_size); diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index 98c809c6..72a4907f 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -4902,6 +4902,146 @@ int tracecmd_copy_buffer_descr(struct tracecmd_input *in_handle, return tracecmd_write_buffer_info(out_handle); } +static int copy_options_recursive(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + unsigned short id, flags = 0; + unsigned short option, en2; + unsigned long long next; + unsigned int size, en4; + bool skip; + + for (;;) { + if (do_read_check(in_handle, &option, 2)) + return -1; + en2 = tep_read_number(in_handle->pevent, &option, 2); + + if (en2 == TRACECMD_OPTION_DONE && !HAS_SECTIONS(in_handle)) + return 0; + + /* next 4 bytes is the size of the option */ + if (do_read_check(in_handle, &size, 4)) + return -1; + en4 = tep_read_number(in_handle->pevent, &size, 4); + if (en2 == TRACECMD_OPTION_DONE) { + /* option done v7 */ + if (en4 < 8) + return -1; + if (read8(in_handle, &next)) + return -1; + if (!next) + break; + if (do_lseek(in_handle, next, SEEK_SET) == (off64_t)-1) + return -1; + if (read_section_header(in_handle, &id, &flags, NULL, NULL)) + return -1; + if (id != TRACECMD_OPTION_DONE) + return -1; + if (flags & TRACECMD_SEC_FL_COMPRESS && in_uncompress_block(in_handle)) + return -1; + return copy_options_recursive(in_handle, out_handle); + } + /* Do not copy these, as they have file specific offsets */ + switch (en2) { + case TRACECMD_OPTION_BUFFER: + case TRACECMD_OPTION_BUFFER_TEXT: + case TRACECMD_OPTION_HEADER_INFO: + case TRACECMD_OPTION_FTRACE_EVENTS: + case TRACECMD_OPTION_EVENT_FORMATS: + case TRACECMD_OPTION_KALLSYMS: + case TRACECMD_OPTION_PRINTK: + case TRACECMD_OPTION_CMDLINES: + skip = true; + break; + default: + skip = false; + break; + } + if (skip) { + do_lseek(in_handle, en4, SEEK_CUR); + continue; + } + if (do_write_check(out_handle, &option, 2)) + return -1; + if (do_write_check(out_handle, &size, 4)) + return -1; + if (read_copy_data(in_handle, en4, out_handle)) + return -1; + } + + return 0; +} + +static int copy_options(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle) +{ + unsigned long long offset, start; + unsigned short id, en2, flags = 0; + int tmp; + + if (HAS_SECTIONS(in_handle)) { + if (read_section_header(in_handle, &id, &flags, NULL, NULL)) + return -1; + if (id != TRACECMD_OPTION_DONE) + return -1; + if (flags & TRACECMD_SEC_FL_COMPRESS && in_uncompress_block(in_handle)) + return -1; + } + start = tracecmd_get_out_file_offset(out_handle); + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) { + if (do_write_check(out_handle, "options ", 10)) + return -1; + } + + offset = out_write_section_header(out_handle, TRACECMD_OPTION_DONE, "options", 0, false); + + if (copy_options_recursive(in_handle, out_handle)) + goto error; + + id = TRACECMD_OPTION_DONE; + en2 = tep_read_number(in_handle->pevent, &id, 2); + if (do_write_check(out_handle, &en2, 2)) + goto error; + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) { + out_save_options_offset(out_handle, start); + } else { + tmp = 8; + if (do_write_check(out_handle, &tmp, 4)) + goto error; + out_save_options_offset(out_handle, start); + start = 0; + if (do_write_check(out_handle, &start, 8)) + goto error; + } + out_update_section_header(out_handle, offset); + if (flags & TRACECMD_SEC_FL_COMPRESS) + in_uncompress_reset(in_handle); + in_handle->file_state = TRACECMD_FILE_OPTIONS; + out_set_file_state(out_handle, in_handle->file_state); + /* Append local options */ + return tracecmd_append_options(out_handle); + +error: + if (flags & TRACECMD_SEC_FL_COMPRESS) + in_uncompress_reset(in_handle); + return 0; +} + +int tracecmd_copy_options(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + if (!check_in_state(in_handle, TRACECMD_FILE_OPTIONS) || + !check_out_state(out_handle, TRACECMD_FILE_OPTIONS)) + return -1; + + if (!in_handle->options_start) + return 0; + if (lseek64(in_handle->fd, in_handle->options_start, SEEK_SET) == (off64_t)-1) + return -1; + if (copy_options(in_handle, out_handle) < 0) + return -1; + return 0; +} + /** * tracecmd_record_at_buffer_start - return true if record is first on subbuffer * @handle: input handle for the trace.dat file diff --git a/lib/trace-cmd/trace-output.c b/lib/trace-cmd/trace-output.c index 8ce23fbc..6fbb9073 100644 --- a/lib/trace-cmd/trace-output.c +++ b/lib/trace-cmd/trace-output.c @@ -2520,6 +2520,31 @@ __hidden bool out_check_compression(struct tracecmd_output *handle) return (handle->compress != NULL); } +__hidden int out_save_options_offset(struct tracecmd_output *handle, unsigned long long start) +{ + unsigned long long new, en8; + + if (HAS_SECTIONS(handle)) { + /* Append to the previous options section, if any */ + if (!handle->options_start) + return -1; + new = do_lseek(handle, 0, SEEK_CUR); + if (do_lseek(handle, handle->options_start, SEEK_SET) == (off64_t)-1) + return -1; + + en8 = convert_endian_8(handle, start); + if (do_write_check(handle, &en8, 8)) + return -1; + handle->options_start = new; + if (do_lseek(handle, new, SEEK_SET) == (off64_t)-1) + return -1; + } else { + handle->options_start = start; + } + + return 0; +} + /** * tracecmd_get_out_file_version - return the trace.dat file version * @handle: output handle for the trace.dat file @@ -2528,3 +2553,8 @@ unsigned long tracecmd_get_out_file_version(struct tracecmd_output *handle) { return handle->file_version; } + +unsigned long long tracecmd_get_out_file_offset(struct tracecmd_output *handle) +{ + return do_lseek(handle, 0, SEEK_CUR); +} From patchwork Thu Dec 2 12:27:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652497 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6C61DC43217 for ; Thu, 2 Dec 2021 12:27:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240265AbhLBMbA (ORCPT ); Thu, 2 Dec 2021 07:31:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37124 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241205AbhLBMa7 (ORCPT ); Thu, 2 Dec 2021 07:30:59 -0500 Received: from mail-ed1-x52e.google.com (mail-ed1-x52e.google.com [IPv6:2a00:1450:4864:20::52e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DAE03C06174A for ; Thu, 2 Dec 2021 04:27:34 -0800 (PST) Received: by mail-ed1-x52e.google.com with SMTP id v1so115120282edx.2 for ; Thu, 02 Dec 2021 04:27:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=dv2CJemkAHvLIBNiNZrfuTGPCCCsyn4lFogA60BgNWQ=; b=ZUyifvvgU6gOIGYy5sD8MI5L+DbVECrDNpHt3AlJ6cfkKO62KOat1U+8Tt4/03PUce XF3CnRXl1hDK+6VVSCTc5t6VVkXsAUTQg0/RJ7TSzqUUCE/NpwC7tXwupaGN5UTGA/gT MtwYDgYMyIN8x1tNrxyiM7J5HdSxfbsfLMYvnvyj9jQGfwcWc3sc1Q4DZNIArFi1xMTm skp7Iw//Tkrk8bMl7MJt7tf/z5+LAJ6YhHctuQ8ZlhoqZtCkZRzJgaiLLbKQgNuFpWrv 8KmEd8doPc8HWUhvY6ABnHQydzToF47zi+tw61oo8OhDj7wbonegghLF47h4JwG0QQzo kqQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=dv2CJemkAHvLIBNiNZrfuTGPCCCsyn4lFogA60BgNWQ=; b=2CbXLL7Zzvc7gy9NUyKqWoEsFJROmAqyCLqDVRe7pBMroyDnMKJPRNS3FSIBz81Epa sAw2BiwQvhATIENHluTofloIJaN1H7w4c7jIvStXgmE7GzVpwHtiwWrV7W5IyNEQ+4Sc fd9SWUufYsQRppeWAr2TK9xaPNux/Lc5mTI4Rm3jircsdwrj7jbNsnCESj6lR/kTisWK SghPiN/SGURHcAmrm74hNlPZX5uwa2ThRjXQA6SiXsXn4ioq+79U7CT4V4r5x6O80ykf 2WenikPk1ACsfp8oQxlB80C/W/z1eqCCcqJ2PN5jUgt0r3Ua3+r0Iv0ITon2+IQ1mr45 XtTQ== X-Gm-Message-State: AOAM5333Eivfy/VSIJ5Qmm5NminC+zXXSyZ8Qs7NhxxTHxNc3MUEgGRh Y1cQCDf2848mmjhkJyHpOnm+XLDOR5GDZw== X-Google-Smtp-Source: ABdhPJw9rcE3MhmYr87Sd+urteK5EW36w90brzfXA9QT14FRQOK6/nZyfyPLPSYyaU05RyvnUzxU3Q== X-Received: by 2002:a05:6402:4251:: with SMTP id g17mr17310509edb.89.1638448053402; Thu, 02 Dec 2021 04:27:33 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:33 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 6/8] trace-cmd library: New API to copy trace data between trace files Date: Thu, 2 Dec 2021 14:27:24 +0200 Message-Id: <20211202122726.43775-7-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org A new library API is introduced, to copy trace data between trace files: tracecmd_copy_trace_data() Signed-off-by: Tzvetomir Stoyanov (VMware) --- .../include/private/trace-cmd-private.h | 2 + lib/trace-cmd/include/trace-cmd-local.h | 6 + lib/trace-cmd/trace-input.c | 173 ++++++++++++++++++ lib/trace-cmd/trace-output.c | 38 ++++ 4 files changed, 219 insertions(+) diff --git a/lib/trace-cmd/include/private/trace-cmd-private.h b/lib/trace-cmd/include/private/trace-cmd-private.h index 2c46d885..0e0d631c 100644 --- a/lib/trace-cmd/include/private/trace-cmd-private.h +++ b/lib/trace-cmd/include/private/trace-cmd-private.h @@ -193,6 +193,8 @@ int tracecmd_copy_buffer_descr(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle); int tracecmd_copy_options(struct tracecmd_input *in_handle, struct tracecmd_output *out_handle); +int tracecmd_copy_trace_data(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle); void tracecmd_set_flag(struct tracecmd_input *handle, int flag); void tracecmd_clear_flag(struct tracecmd_input *handle, int flag); unsigned long tracecmd_get_flags(struct tracecmd_input *handle); diff --git a/lib/trace-cmd/include/trace-cmd-local.h b/lib/trace-cmd/include/trace-cmd-local.h index 6f14fa03..57b51a48 100644 --- a/lib/trace-cmd/include/trace-cmd-local.h +++ b/lib/trace-cmd/include/trace-cmd-local.h @@ -68,6 +68,11 @@ int out_update_section_header(struct tracecmd_output *handle, unsigned long long long long do_write_check(struct tracecmd_output *handle, const void *data, long long size); +struct tracecmd_option * +out_add_buffer_option_v7(struct tracecmd_output *handle, const char *name, + unsigned short id, unsigned long long data_offset, + int cpus, struct data_file_write *cpu_data); + struct cpu_data_source { int fd; int size; @@ -76,6 +81,7 @@ struct cpu_data_source { int out_write_cpu_data(struct tracecmd_output *handle, int cpus, struct cpu_data_source *data, const char *buff_name); +int out_write_emty_cpu_data(struct tracecmd_output *handle, int cpus); off64_t msg_lseek(struct tracecmd_msg_handle *msg_handle, off_t offset, int whence); unsigned long long get_last_option_offset(struct tracecmd_input *handle); diff --git a/lib/trace-cmd/trace-input.c b/lib/trace-cmd/trace-input.c index 72a4907f..dd51fd4a 100644 --- a/lib/trace-cmd/trace-input.c +++ b/lib/trace-cmd/trace-input.c @@ -5042,6 +5042,179 @@ int tracecmd_copy_options(struct tracecmd_input *in_handle, return 0; } +static int copy_trace_latency(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, const char *buf_name) +{ + unsigned long long wsize; + unsigned long long offset; + int fd; + + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS && + do_write_check(out_handle, "latency ", 10)) + return -1; + + offset = tracecmd_get_out_file_offset(out_handle); + + if (tracecmd_get_out_file_version(out_handle) >= FILE_VERSION_SECTIONS && + !out_add_buffer_option_v7(out_handle, buf_name, TRACECMD_OPTION_BUFFER_TEXT, offset, 0, NULL)) + return -1; + + offset = out_write_section_header(out_handle, TRACECMD_OPTION_BUFFER_TEXT, + "buffer latency", TRACECMD_SEC_FL_COMPRESS, false); + + if (in_handle->latz.fd >= 0) + fd = in_handle->latz.fd; + else + fd = in_handle->fd; + + if (!out_copy_fd_compress(out_handle, fd, 0, &wsize)) + return -1; + if (out_update_section_header(out_handle, offset)) + return -1; + + out_set_file_state(out_handle, TRACECMD_FILE_CPU_LATENCY); + return 0; +} + +static int copy_trace_flyrecord_data(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, const char *buff_name) +{ + struct cpu_data_source *data; + int total_size = 0; + int cpus; + int ret; + int i, j; + + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) + cpus = in_handle->max_cpu; + else + cpus = in_handle->cpus; + + data = calloc(cpus, sizeof(struct cpu_data_source)); + if (!data) + return -1; + for (i = 0; i < in_handle->cpus; i++) { + j = in_handle->cpu_data[i].cpu; + data[j].size = in_handle->cpu_data[i].file_size; + total_size += data[j].size; + if (in_handle->cpu_data[i].compress.fd >= 0) { + data[j].fd = in_handle->cpu_data[i].compress.fd; + data[j].offset = 0; + } else { + data[j].fd = in_handle->fd; + data[j].offset = in_handle->cpu_data[i].file_offset; + } + } + if (total_size || tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) + ret = out_write_cpu_data(out_handle, cpus, data, buff_name); + else + ret = 0; + free(data); + + return ret; +} + +static int copy_flyrecord_buffer(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle, int index) +{ + struct tracecmd_input *instance; + const char *name; + int ret; + + name = tracecmd_buffer_instance_name(in_handle, index); + if (!name) + return -1; + + instance = tracecmd_buffer_instance_handle(in_handle, index); + if (!instance) + return -1; + if (!tracecmd_get_quiet(out_handle) && *name) + fprintf(stderr, "\nBuffer: %s\n\n", name); + + if (in_handle->buffers[index].latency) + ret = copy_trace_latency(in_handle, out_handle, name); + else + ret = copy_trace_flyrecord_data(instance, out_handle, name); + tracecmd_close(instance); + + return ret; +} + +static int copy_trace_data_from_v6(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + char buf[10]; + int ret; + int i; + + if (do_read_check(in_handle, buf, 10)) + return -1; + + if (strncmp(buf, "latency", 7) == 0) + in_handle->file_state = TRACECMD_FILE_CPU_LATENCY; + else if (strncmp(buf, "flyrecord", 9) == 0) + in_handle->file_state = TRACECMD_FILE_CPU_FLYRECORD; + + tracecmd_init_data(in_handle); + + if (in_handle->file_state == TRACECMD_FILE_CPU_LATENCY) + return copy_trace_latency(in_handle, out_handle, ""); + + /* top instance */ + ret = copy_trace_flyrecord_data(in_handle, out_handle, ""); + if (ret) + return ret; + + for (i = 0; i < in_handle->nr_buffers; i++) + copy_flyrecord_buffer(in_handle, out_handle, i); + return 0; +} + +static int copy_trace_data_from_v7(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + int ret; + int i; + + /* Force using temporary files for trace data decompression */ + in_handle->read_zpage = false; + tracecmd_init_data(in_handle); + + if (tracecmd_get_out_file_version(out_handle) < FILE_VERSION_SECTIONS) { + /* copy top buffer in v6 files */ + if (in_handle->top_buffer.latency) + ret = copy_trace_latency(in_handle, out_handle, in_handle->top_buffer.name); + else if (in_handle->top_buffer.cpus) + ret = copy_trace_flyrecord_data(in_handle, out_handle, + in_handle->top_buffer.name); + else + ret = out_write_emty_cpu_data(out_handle, in_handle->max_cpu); + if (ret) + return ret; + } + + for (i = 0; i < in_handle->nr_buffers; i++) + copy_flyrecord_buffer(in_handle, out_handle, i); + + return 0; +} + +__hidden int tracecmd_copy_trace_data(struct tracecmd_input *in_handle, + struct tracecmd_output *out_handle) +{ + int ret; + + if (!check_in_state(in_handle, TRACECMD_FILE_CPU_FLYRECORD) || + !check_out_state(out_handle, TRACECMD_FILE_CPU_FLYRECORD)) + return -1; + tracecmd_set_out_clock(out_handle, in_handle->trace_clock); + if (in_handle->file_version < FILE_VERSION_SECTIONS) + ret = copy_trace_data_from_v6(in_handle, out_handle); + else + ret = copy_trace_data_from_v7(in_handle, out_handle); + return ret; +} + /** * tracecmd_record_at_buffer_start - return true if record is first on subbuffer * @handle: input handle for the trace.dat file diff --git a/lib/trace-cmd/trace-output.c b/lib/trace-cmd/trace-output.c index 6fbb9073..1e1e16b7 100644 --- a/lib/trace-cmd/trace-output.c +++ b/lib/trace-cmd/trace-output.c @@ -2173,6 +2173,44 @@ static int update_buffer_cpu_offset_v6(struct tracecmd_output *handle, return 0; } +__hidden int out_write_emty_cpu_data(struct tracecmd_output *handle, int cpus) +{ + unsigned long long zero = 0; + char *clock; + int ret; + int i; + + if (HAS_SECTIONS(handle)) + return 0; + + ret = handle->file_state == TRACECMD_FILE_CPU_FLYRECORD ? 0 : + check_file_state(handle->file_version, + handle->file_state, + TRACECMD_FILE_CPU_FLYRECORD); + if (ret < 0) { + tracecmd_warning("Cannot write trace data into the file, unexpected state 0x%X", + handle->file_state); + return ret; + } + + if (do_write_check(handle, "flyrecord", 10)) + return -1; + + for (i = 0; i < cpus; i++) { + /* Write 0 for trace data offset and size */ + if (do_write_check(handle, &zero, 8)) + return -1; + if (do_write_check(handle, &zero, 8)) + return -1; + } + clock = get_clock(handle); + if (clock && save_clock(handle, clock)) + return -1; + handle->file_state = TRACECMD_FILE_CPU_FLYRECORD; + return 0; +} + + __hidden int out_write_cpu_data(struct tracecmd_output *handle, int cpus, struct cpu_data_source *data, const char *buff_name) { From patchwork Thu Dec 2 12:27:25 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652495 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2F567C4332F for ; Thu, 2 Dec 2021 12:27:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240491AbhLBMbA (ORCPT ); Thu, 2 Dec 2021 07:31:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37126 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240265AbhLBMa7 (ORCPT ); Thu, 2 Dec 2021 07:30:59 -0500 Received: from mail-ed1-x531.google.com (mail-ed1-x531.google.com [IPv6:2a00:1450:4864:20::531]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E5560C061757 for ; Thu, 2 Dec 2021 04:27:35 -0800 (PST) Received: by mail-ed1-x531.google.com with SMTP id g14so115293130edb.8 for ; Thu, 02 Dec 2021 04:27:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=4vUfyf6cf5gYXU/cqqxkspOFz8xaw+09/pJe/zuj59c=; b=YFfkD1t0RB10L3O1n0pBdCGFIQ5+k+b9tG8j9wiqAabycGcBLzbckKDNLXzREM6h8x 67I/EF9kGaGyRMmRc1Tlv2DUYpwU9I7FCJ6iNPj952blhPX5A2ZPoOlBaM14zb90UQts 01QirGqxTAEohYsRhbD9L1A9TK0D0E+K5WCv/rwp7cmUUElwUdEAF/usxsQB52OCOlMX VyXTAXNLCmQSipsz21kEgQrJ+nzpkNf4KOB/D/8FPcmxudzCCx946136T0HAs89OXj0u 9WqKgyyvvH+qOjePJEJphh2ncJ9ytyvOtogrlvOyzQIAbNRTxSqZ+x8ihlUOJ3uk2hfF lP/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4vUfyf6cf5gYXU/cqqxkspOFz8xaw+09/pJe/zuj59c=; b=fuuvCd6iMErGKaSrZyNnm3yLW6++blOlwuN60MuXiAXhp/oUQY3GWwkg45XEpIDLMY ZlMQt6+p+SIJfvcAt/4USbA+AYZ5gn9DskmCqmtyrffYKJdwKUPw7kbq/A42gCiNF+56 iGIsUaBe+hTT1NPjcTYuYVWeDWYxAUi519Mg7RB2PUjPbjFSV/hKMkzhKxOk+gTPq4hP kfdYlRFZlG/yfsTFpE1ZmHfBZ3ibVrwzcasw0Ez8R+v7CRIfkvGB2Z26NRZkoKOPUVA8 4B2sfNcDrWahwUSKOLBMH5+dV4Fp3C2029ToSnc4KeqWEyu7lSfsOKOYTV/1+jXoRRxQ cy+w== X-Gm-Message-State: AOAM53341Oz2snqKh/ZiL0MbS2GLDBam2ojbGBbEu/vhRIcjErhB1wMd nfedjyXtJxlBKBfkUNl+lslh9z6NHR7DuA== X-Google-Smtp-Source: ABdhPJzeG+7ZtdQEX7WVRC/nLcghThRWNvxxh9GIodHMzWwGIJh73gdc5s77/bedu5cPnrzfTB7YfA== X-Received: by 2002:a05:6402:1849:: with SMTP id v9mr17636064edy.335.1638448054445; Thu, 02 Dec 2021 04:27:34 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:33 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 7/8] trace-cmd library: Extend tracecmd_copy() API Date: Thu, 2 Dec 2021 14:27:25 +0200 Message-Id: <20211202122726.43775-8-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org The tracecmd_copy() API is used to copy data between trace files. Extended it to support copying data between files from different versions. Added also functionality to copy all sections between the files. Signed-off-by: Tzvetomir Stoyanov (VMware) --- .../include/private/trace-cmd-private.h | 5 ++- lib/trace-cmd/trace-output.c | 39 +++++++++++++++---- tracecmd/trace-restore.c | 2 +- tracecmd/trace-split.c | 2 +- 4 files changed, 36 insertions(+), 12 deletions(-) diff --git a/lib/trace-cmd/include/private/trace-cmd-private.h b/lib/trace-cmd/include/private/trace-cmd-private.h index 0e0d631c..bd09cb48 100644 --- a/lib/trace-cmd/include/private/trace-cmd-private.h +++ b/lib/trace-cmd/include/private/trace-cmd-private.h @@ -328,8 +328,9 @@ int tracecmd_write_options(struct tracecmd_output *handle); int tracecmd_append_options(struct tracecmd_output *handle); void tracecmd_output_close(struct tracecmd_output *handle); void tracecmd_output_free(struct tracecmd_output *handle); -struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, - const char *file); +struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, const char *file, + enum tracecmd_file_states state, int file_version, + const char *compression); int tracecmd_write_cpu_data(struct tracecmd_output *handle, int cpus, char * const *cpu_data_files, const char *buff_name); diff --git a/lib/trace-cmd/trace-output.c b/lib/trace-cmd/trace-output.c index 1e1e16b7..8751e168 100644 --- a/lib/trace-cmd/trace-output.c +++ b/lib/trace-cmd/trace-output.c @@ -2512,14 +2512,23 @@ struct tracecmd_output *tracecmd_output_create(const char *output_file) * tracecmd_copy - copy the headers of one trace.dat file for another * @ihandle: input handle of the trace.dat file to copy * @file: the trace.dat file to create + * @state: what data will be copied from the source handle + * @file_version: version of the output file + * @compression: compression of the output file, can be one of: + * NULL - inherit compression from the input file + * "any" - compress the output file with the best available algorithm + * "none" - do not compress the output file + * algorithm_name - compress the output file with specified algorithm * * Reads the header information and creates a new trace data file * with the same characteristics (events and all) and returns * tracecmd_output handle to this new file. */ -struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, - const char *file) +struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, const char *file, + enum tracecmd_file_states state, int file_version, + const char *compression) { + enum tracecmd_file_states fstate; struct tracecmd_output *handle; handle = tracecmd_output_create(file); @@ -2528,18 +2537,32 @@ struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle, if (tracecmd_output_set_from_input(handle, ihandle)) goto out_free; - output_write_init(handle); - if (tracecmd_copy_headers(ihandle, handle, 0, 0) < 0) + if (file_version >= FILE_VERSION_MIN) + tracecmd_output_set_version(handle, file_version); + if (compression && tracecmd_output_set_compression(handle, compression)) goto out_free; - - handle->file_state = tracecmd_get_file_state(ihandle); - + output_write_init(handle); + fstate = state > TRACECMD_FILE_CPU_COUNT ? TRACECMD_FILE_CPU_COUNT : state; + if (tracecmd_copy_headers(ihandle, handle, 0, fstate) < 0) + goto out_free; + if (tracecmd_copy_buffer_descr(ihandle, handle) < 0) + goto out_free; + if (state >= TRACECMD_FILE_OPTIONS && + tracecmd_copy_options(ihandle, handle) < 0) + goto out_free; + if (state >= TRACECMD_FILE_CPU_LATENCY && + tracecmd_copy_trace_data(ihandle, handle) < 0) + goto out_free; + if (HAS_SECTIONS(handle)) + tracecmd_write_options(handle); /* The file is all ready to have cpu data attached */ return handle; out_free: - tracecmd_output_close(handle); + if (handle) + tracecmd_output_close(handle); + unlink(file); return NULL; } diff --git a/tracecmd/trace-restore.c b/tracecmd/trace-restore.c index 23a7f4af..5bf29c52 100644 --- a/tracecmd/trace-restore.c +++ b/tracecmd/trace-restore.c @@ -147,7 +147,7 @@ void trace_restore (int argc, char **argv) if (tracecmd_read_headers(ihandle, TRACECMD_FILE_CMD_LINES) < 0) die("error reading file %s headers", input); - handle = tracecmd_copy(ihandle, output); + handle = tracecmd_copy(ihandle, output, TRACECMD_FILE_CMD_LINES, 0, NULL); tracecmd_close(ihandle); } else { handle = tracecmd_output_create(output); diff --git a/tracecmd/trace-split.c b/tracecmd/trace-split.c index e4a0c3b3..83c5402c 100644 --- a/tracecmd/trace-split.c +++ b/tracecmd/trace-split.c @@ -348,7 +348,7 @@ static double parse_file(struct tracecmd_input *handle, dir = dirname(output); base = basename(output); - ohandle = tracecmd_copy(handle, output_file); + ohandle = tracecmd_copy(handle, output_file, TRACECMD_FILE_CMD_LINES, 0, NULL); cpus = tracecmd_cpus(handle); cpu_data = malloc(sizeof(*cpu_data) * cpus); From patchwork Thu Dec 2 12:27:26 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12652499 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C6825C433F5 for ; Thu, 2 Dec 2021 12:27:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241205AbhLBMbB (ORCPT ); Thu, 2 Dec 2021 07:31:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37130 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1346749AbhLBMa7 (ORCPT ); Thu, 2 Dec 2021 07:30:59 -0500 Received: from mail-ed1-x535.google.com (mail-ed1-x535.google.com [IPv6:2a00:1450:4864:20::535]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 189FFC061758 for ; Thu, 2 Dec 2021 04:27:36 -0800 (PST) Received: by mail-ed1-x535.google.com with SMTP id x6so114958570edr.5 for ; Thu, 02 Dec 2021 04:27:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Z0N+74W9DmP3ClcW+4Tenz8qOB7sCLlV0uvial0H8Bw=; b=OVkuEgg0fvA9J+asTOb5KZlpFfXDCNB/ga/Y7zmaB9jKRcVsXjClquJd8/dWZRbyRD QaO4A+Z11G22WXO18g3tQxycyUafS7/wKAcV+sbVbkJR+jnGUjuu5akYRraHLVjsOeXx /qY6+6uRiChAAKQMJkOHH66YNxMgyRXENMXy+FvUQoUjnu6UPBgThpVJIW7V/yS2E0nq umM9CrB10BHSDhMPUmrW7tZLeoKn9sr/JLja6Iq2Q/pRfvOiZIlhBMJLSS0cktS1FJjX mau7v5FWUOlM22A6FSODNhPb1pDm1gvN+wE3SvFbrctFOQC6KyCWU7prUHvqh1RBpveh k6QA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Z0N+74W9DmP3ClcW+4Tenz8qOB7sCLlV0uvial0H8Bw=; b=MInIYlbd6f3qpIfyO8ZLrt/WeSilbeGzY0QMqTva4WOR4Ma27YzB75PNaLdB9XG/7z ywpcoJ7Bf8OT5f5QpAxZRyENgRJQVBnXMNQOoDSBPKKDsWAKDfWLVt1G3rcQK1bayRCe 9St5iwitdSmXLxRGykCyEdNqvoOSwOqxZWZFMN58YJKX315KfP+9qz6NyTcRx4iXS5jp tgGcDgu0CSbwgkpbu3Amcy+FVqWG5DL1Rn7ZdxZiPHYEyq2B50uBfznd1+VXbPILsava tU882KRUvVGuhNM4UtTvOJEhWAHYvSoO6PEPCsXeaJnoZjcnOyFnfo5lq80DZosx3b/e YmIw== X-Gm-Message-State: AOAM5322xZmCDG3YsyYJiRkfOdBB7QOKqANTPP3hNL9NBK4KUqFSEivN ko7paz48/fqHjBJQ80b7U+2tQq0F9WTyKA== X-Google-Smtp-Source: ABdhPJwUkgXq478pkSHCdaAAuq9u69FOU++2gkXNAvhHSSO77Jjt6moo4XvD0eMT1xiizXGF9ddBew== X-Received: by 2002:aa7:dd47:: with SMTP id o7mr17331215edw.34.1638448055432; Thu, 02 Dec 2021 04:27:35 -0800 (PST) Received: from oberon.zico.biz.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id u16sm2073403edr.43.2021.12.02.04.27.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 02 Dec 2021 04:27:35 -0800 (PST) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH v5 8/8] trace-cmd: Add new subcommand "convert" Date: Thu, 2 Dec 2021 14:27:26 +0200 Message-Id: <20211202122726.43775-9-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211202122726.43775-1-tz.stoyanov@gmail.com> References: <20211202122726.43775-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org There is a need to convert trace files between different versions. A new "trace-cmd convert" subcommand is introduced, which reads an input trace file and copies to an output trace file. Both files can be from different versions. trace-cmd convert -i -o --file-version --compression Signed-off-by: Tzvetomir Stoyanov (VMware) --- tracecmd/Makefile | 1 + tracecmd/include/trace-local.h | 2 + tracecmd/trace-cmd.c | 1 + tracecmd/trace-convert.c | 106 +++++++++++++++++++++++++++++++++ tracecmd/trace-usage.c | 13 ++++ 5 files changed, 123 insertions(+) create mode 100644 tracecmd/trace-convert.c diff --git a/tracecmd/Makefile b/tracecmd/Makefile index b7a23dc4..56742f0a 100644 --- a/tracecmd/Makefile +++ b/tracecmd/Makefile @@ -36,6 +36,7 @@ TRACE_CMD_OBJS += trace-usage.o TRACE_CMD_OBJS += trace-dump.o TRACE_CMD_OBJS += trace-clear.o TRACE_CMD_OBJS += trace-vm.o +TRACE_CMD_OBJS += trace-convert.o ifeq ($(VSOCK_DEFINED), 1) TRACE_CMD_OBJS += trace-agent.o diff --git a/tracecmd/include/trace-local.h b/tracecmd/include/trace-local.h index e9a0aea8..13dab44c 100644 --- a/tracecmd/include/trace-local.h +++ b/tracecmd/include/trace-local.h @@ -110,6 +110,8 @@ void trace_usage(int argc, char **argv); void trace_dump(int argc, char **argv); +void trace_convert(int argc, char **argv); + int trace_record_agent(struct tracecmd_msg_handle *msg_handle, int cpus, int *fds, int argc, char **argv, bool use_fifos, diff --git a/tracecmd/trace-cmd.c b/tracecmd/trace-cmd.c index 9fc126e4..a83a8d0b 100644 --- a/tracecmd/trace-cmd.c +++ b/tracecmd/trace-cmd.c @@ -133,6 +133,7 @@ struct command commands[] = { {"list", trace_list}, {"help", trace_usage}, {"dump", trace_dump}, + {"convert", trace_convert}, {"-h", trace_usage}, }; diff --git a/tracecmd/trace-convert.c b/tracecmd/trace-convert.c new file mode 100644 index 00000000..fc012af8 --- /dev/null +++ b/tracecmd/trace-convert.c @@ -0,0 +1,106 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2021, VMware, Tzvetomir Stoyanov + */ +#include +#include +#include +#include +#include + +#include "trace-local.h" +#include "trace-cmd.h" +#include "trace-cmd-private.h" + +static void convert_file(const char *in, const char *out, int file_version, char *compr) +{ + struct tracecmd_input *ihandle; + struct tracecmd_output *ohandle; + + ihandle = tracecmd_open_head(in, 0); + if (!ihandle) + die("error reading %s", in); + ohandle = tracecmd_copy(ihandle, out, TRACECMD_FILE_CPU_FLYRECORD, file_version, compr); + if (!ohandle) + die("error writing %s", out); + tracecmd_output_close(ohandle); + tracecmd_close(ihandle); +} + +enum { + OPT_file_version = 254, + OPT_compression = 255, +}; + +void trace_convert(int argc, char **argv) +{ + char *input_file = NULL; + char *output_file = NULL; + char *compression = NULL; + int file_version = tracecmd_default_file_version(); + int c; + + if (argc < 2) + usage(argv); + + if (strcmp(argv[1], "convert") != 0) + usage(argv); + for (;;) { + int option_index = 0; + static struct option long_options[] = { + {"compression", required_argument, NULL, OPT_compression}, + {"file-version", required_argument, NULL, OPT_file_version}, + {"help", no_argument, NULL, '?'}, + {NULL, 0, NULL, 0} + }; + + c = getopt_long (argc-1, argv+1, "+hi:o:", long_options, &option_index); + if (c == -1) + break; + switch (c) { + case 'i': + if (input_file) + die("Only one input file is supported, %s already set", + input_file); + input_file = optarg; + break; + case 'o': + if (output_file) + die("Only one output file is supported, %s already set", + output_file); + output_file = optarg; + break; + case OPT_compression: + if (strcmp(optarg, "any") && strcmp(optarg, "none") && + !tracecmd_compress_is_supported(optarg, NULL)) + die("Compression algorithm %s is not supported", optarg); + compression = optarg; + break; + case OPT_file_version: + file_version = atoi(optarg); + if (file_version < FILE_VERSION_MIN || file_version > FILE_VERSION_MAX) + die("Unsupported file version %d, " + "supported versions are from %d to %d", + file_version, FILE_VERSION_MIN, FILE_VERSION_MAX); + + break; + case 'h': + case '?': + default: + usage(argv); + } + } + + if ((argc - optind) >= 2) { + if (output_file) + usage(argv); + output_file = argv[optind + 1]; + } + + if (!input_file) + input_file = DEFAULT_INPUT_FILE; + if (!output_file) + usage(argv); + + convert_file(input_file, output_file, file_version, compression); +} diff --git a/tracecmd/trace-usage.c b/tracecmd/trace-usage.c index 77898c1c..ec0af46f 100644 --- a/tracecmd/trace-usage.c +++ b/tracecmd/trace-usage.c @@ -412,6 +412,19 @@ static struct usage_help usage_help[] = { " -h, --help show usage information\n" " --verbose 'level' Set the desired log level\n" }, + { + "convert", + "convert trace file to different version", + " %s convert [options]\n" + " -i input file, default is trace.dat\n" + " -o output file, mandatory parameter.\n" + " The output file can be specified also as last argument of the command\n" + " --file-version set the desired trace file version\n" + " --compression compress the trace output file, one of these strings can be passed:\n" + " any - auto select the best available compression algorithm\n" + " none - do not compress the trace file\n" + " name - the name of the desired compression algorithms\n" + " available algorithms can be listed with trace-cmd list -c\n" }, { NULL, NULL, NULL }