developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
| 2 | /* |
| 3 | * Copyright (c) 2023 MediaTek Inc. All Rights Reserved. |
| 4 | * |
| 5 | * Author: Alvin Kuo <Alvin.Kuo@mediatek.com> |
| 6 | */ |
| 7 | |
| 8 | #include <limits.h> |
| 9 | #include <stdlib.h> |
| 10 | #include <stdint.h> |
| 11 | #include <string.h> |
| 12 | #include <unistd.h> |
| 13 | #include <stdio.h> |
| 14 | #include <errno.h> |
| 15 | #include <fcntl.h> |
| 16 | #include <time.h> |
| 17 | #include <poll.h> |
| 18 | |
| 19 | #include <sys/types.h> |
| 20 | #include <sys/stat.h> |
| 21 | |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 22 | #include "common.h" |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 23 | #include "dump.h" |
| 24 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 25 | static int save_dump_data(char *dump_root_dir, |
| 26 | struct dump_data_header *dd_hdr, |
| 27 | char *dd) |
| 28 | { |
| 29 | size_t dump_file_size = dd_hdr->info.size + sizeof(struct dump_info); |
| 30 | char dump_time_str[32]; |
| 31 | struct stat st = { 0 }; |
| 32 | char *dump_file = NULL; |
| 33 | char *dump_dir = NULL; |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 34 | size_t path_len; |
| 35 | int ret; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 36 | int fd; |
| 37 | |
| 38 | ret = time_to_str((time_t *)&dd_hdr->info.dump_time_sec, |
| 39 | dump_time_str, sizeof(dump_time_str)); |
| 40 | if (ret < 0) { |
| 41 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 42 | LOG_FMT("time_to_str(%lu) fail(%d)\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 43 | dd_hdr->info.dump_time_sec, ret); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 44 | return ret; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 45 | } |
| 46 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 47 | /* create the dump directory */ |
| 48 | path_len = strlen(dump_root_dir) + 1 + strlen(dump_time_str) + 1; |
| 49 | dump_dir = malloc(path_len); |
| 50 | if (!dump_dir) |
| 51 | return -ENOMEM; |
| 52 | |
| 53 | ret = snprintf(dump_dir, path_len, "%s/%s", dump_root_dir, dump_time_str); |
| 54 | if (ret < 0) |
| 55 | goto free_dump_dir; |
| 56 | |
| 57 | ret = mkdir(dump_dir, 0775); |
| 58 | if (ret && errno != EEXIST) { |
| 59 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 60 | LOG_FMT("mkdir(%s) fail(%s)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 61 | dump_dir, strerror(errno)); |
| 62 | goto free_dump_dir; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 63 | } |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 64 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 65 | /* TODO: only keep latest three dump directories */ |
| 66 | |
| 67 | /* create the dump file */ |
| 68 | path_len = strlen(dump_dir) + 1 + strlen(dd_hdr->info.name) + 1; |
| 69 | dump_file = malloc(path_len); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 70 | if (!dump_file) { |
| 71 | ret = -ENOMEM; |
| 72 | goto free_dump_dir; |
| 73 | } |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 74 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 75 | ret = snprintf(dump_file, path_len, "%s/%s", dump_dir, dd_hdr->info.name); |
| 76 | if (ret < 0) |
| 77 | goto free_dump_file; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 78 | |
developer | 8762a19 | 2023-09-04 09:16:22 +0800 | [diff] [blame] | 79 | fd = open(dump_file, O_WRONLY | O_CREAT, 0664); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 80 | if (fd < 0) { |
| 81 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 82 | LOG_FMT("open(%s) fail(%s)\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 83 | dump_file, strerror(errno)); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 84 | ret = fd; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 85 | goto free_dump_file; |
| 86 | } |
| 87 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 88 | /* write the dump information at the begining of dump file */ |
| 89 | ret = lseek(fd, 0, SEEK_SET); |
| 90 | if (ret < 0) { |
| 91 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 92 | LOG_FMT("lseek fail(%s)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 93 | strerror(errno)); |
| 94 | goto close_dump_file; |
| 95 | } |
| 96 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 97 | write(fd, &dd_hdr->info, sizeof(struct dump_info)); |
| 98 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 99 | /* write the dump data start from dump information plus data offset */ |
| 100 | ret = lseek(fd, dd_hdr->data_offset, SEEK_CUR); |
| 101 | if (ret < 0) { |
| 102 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 103 | LOG_FMT("lseek fail(%s)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 104 | strerror(errno)); |
| 105 | goto close_dump_file; |
| 106 | } |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 107 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 108 | write(fd, dd, dd_hdr->data_len); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 109 | |
| 110 | if (dd_hdr->last_frag) { |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 111 | ret = stat(dump_file, &st); |
| 112 | if (ret < 0) { |
| 113 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 114 | LOG_FMT("stat(%s) fail(%s)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 115 | dump_file, strerror(errno)); |
| 116 | goto close_dump_file; |
| 117 | } |
| 118 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 119 | if ((size_t)st.st_size != dump_file_size) { |
| 120 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 121 | LOG_FMT("file(%s) size %zu != %zu\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 122 | dump_file, st.st_size, dump_file_size); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 123 | ret = -EINVAL; |
| 124 | goto close_dump_file; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 125 | } |
| 126 | } |
| 127 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 128 | ret = 0; |
| 129 | |
| 130 | close_dump_file: |
| 131 | close(fd); |
| 132 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 133 | free_dump_file: |
| 134 | free(dump_file); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 135 | |
| 136 | free_dump_dir: |
| 137 | free(dump_dir); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 138 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 139 | return ret; |
| 140 | } |
| 141 | |
| 142 | static int read_retry(int fd, void *buf, int len) |
| 143 | { |
| 144 | int out_len = 0; |
| 145 | int ret; |
| 146 | |
| 147 | while (len > 0) { |
| 148 | ret = read(fd, buf, len); |
| 149 | if (ret < 0) { |
| 150 | if (errno == EINTR || errno == EAGAIN) |
| 151 | continue; |
| 152 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 153 | return ret; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | if (!ret) |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 157 | break; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 158 | |
| 159 | out_len += ret; |
| 160 | len -= ret; |
| 161 | buf += ret; |
| 162 | } |
| 163 | |
| 164 | return out_len; |
| 165 | } |
| 166 | |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 167 | int tops_tool_save_dump_data(int argc, char *argv[]) |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 168 | { |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 169 | char *dump_root_dir = argv[2]; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 170 | int ret = 0; |
| 171 | int fd; |
| 172 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 173 | if (!dump_root_dir) |
| 174 | return -EINVAL; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 175 | |
| 176 | /* reserve 256 bytes for saving name of dump directory and dump file */ |
| 177 | if (strlen(dump_root_dir) > (PATH_MAX - 256)) { |
| 178 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 179 | LOG_FMT("dump_root_dir(%s) length %zu > %u\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 180 | dump_root_dir, strlen(dump_root_dir), PATH_MAX - 256); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 181 | return -EINVAL; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 182 | } |
| 183 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 184 | ret = mkdir_p(dump_root_dir, 0775); |
| 185 | if (ret < 0) { |
| 186 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 187 | LOG_FMT("mkdir_p(%s) fail(%d)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 188 | dump_root_dir, ret); |
| 189 | return ret; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | fd = open(DUMP_DATA_PATH, O_RDONLY); |
| 193 | if (fd < 0) { |
| 194 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 195 | LOG_FMT("open(%s) fail(%s)\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 196 | DUMP_DATA_PATH, strerror(errno)); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 197 | return fd; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 198 | } |
| 199 | |
| 200 | while (1) { |
| 201 | char dd[RELAY_DUMP_SUBBUF_SIZE - sizeof(struct dump_data_header)]; |
| 202 | struct dump_data_header dd_hdr; |
| 203 | struct pollfd pfd = { |
| 204 | .fd = fd, |
| 205 | .events = POLLIN | POLLHUP | POLLERR, |
| 206 | }; |
| 207 | |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 208 | ret = poll(&pfd, 1, -1); |
| 209 | if (ret < 0) { |
| 210 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 211 | LOG_FMT("poll fail(%s)\n"), |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 212 | strerror(errno)); |
| 213 | break; |
| 214 | } |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 215 | |
| 216 | ret = read_retry(fd, &dd_hdr, sizeof(struct dump_data_header)); |
| 217 | if (ret < 0) { |
| 218 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 219 | LOG_FMT("read dd_hdr fail(%d)\n"), ret); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 220 | break; |
| 221 | } |
| 222 | |
| 223 | if (!ret) |
| 224 | continue; |
| 225 | |
| 226 | if (dd_hdr.data_len == 0) { |
| 227 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 228 | LOG_FMT("read empty data\n")); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 229 | continue; |
| 230 | } |
| 231 | |
| 232 | if (dd_hdr.data_len > sizeof(dd)) { |
| 233 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 234 | LOG_FMT("data length %u > %lu\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 235 | dd_hdr.data_len, sizeof(dd)); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 236 | ret = -ENOMEM; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 237 | break; |
| 238 | } |
| 239 | |
| 240 | ret = read_retry(fd, dd, dd_hdr.data_len); |
| 241 | if (ret < 0) { |
| 242 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 243 | LOG_FMT("read dd fail(%d)\n"), ret); |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 244 | break; |
| 245 | } |
| 246 | |
| 247 | if ((uint32_t)ret != dd_hdr.data_len) { |
| 248 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 249 | LOG_FMT("read dd length %u != %u\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 250 | (uint32_t)ret, dd_hdr.data_len); |
developer | f6c5ced | 2023-10-03 16:23:42 +0800 | [diff] [blame] | 251 | ret = -EAGAIN; |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 252 | break; |
| 253 | } |
| 254 | |
| 255 | ret = save_dump_data(dump_root_dir, &dd_hdr, dd); |
| 256 | if (ret) { |
| 257 | fprintf(stderr, |
developer | 1d31274 | 2023-09-11 11:05:46 +0800 | [diff] [blame] | 258 | LOG_FMT("save_dump_data(%s) fail(%d)\n"), |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 259 | dump_root_dir, ret); |
| 260 | break; |
| 261 | } |
| 262 | } |
| 263 | |
| 264 | close(fd); |
| 265 | |
developer | e5e687d | 2023-08-08 16:05:33 +0800 | [diff] [blame] | 266 | return ret; |
| 267 | } |