2 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <diagnostics.h>
27 #include <sys/types.h>
31 #include "diagnostics/diagnostics.h"
32 #include "diagnostics/diagnostics_dump.h"
33 #include "shared/log.h"
34 #include "shared/util.h"
36 enum BUGREPORT_REPORT_TYPE { BR_UNKNOWN, BR_BUGREPORT, BR_CRASHINFO };
41 struct timespec ctime;
44 static bool get_reports_list(const char *path, struct report_file **list, size_t *list_count)
53 _E("Open directory %s error: %m", path);
57 while ((ep = readdir(dp))) {
61 char *file_path = NULL;
62 if (asprintf(&file_path, "%s/%s", path, ep->d_name) == -1) {
63 _E("Memory allocation error: %m");
66 if (stat(file_path, &st) != 0) {
67 _E("Get stats about %s error: %m", path);
71 if (localtime_r(&(st.st_ctim.tv_sec), &t) == NULL) {
72 _E("localtime_r error: %m");
76 *list = realloc(*list, sizeof(struct report_file)*(*list_count + 1));
77 (*list)[*list_count].file_name = strdup(ep->d_name);
78 (*list)[*list_count].file_path = strdup(file_path);
79 (*list)[*list_count].ctime = st.st_ctim;
86 static void free_record(struct report_file *record)
88 free(record->file_name);
89 free(record->file_path);
92 static void filter_time(struct report_file *list, size_t *list_count, long time_from, long time_to)
95 size_t n_list_count = *list_count;
97 struct timespec current_ts;
98 clock_gettime(CLOCK_REALTIME, ¤t_ts);
100 for (int i = 0; i < *list_count; i++) {
101 if (list[i].ctime.tv_sec >= time_from && list[i].ctime.tv_sec < time_to) {
103 list[dest] = list[i];
106 free_record(&list[i]);
110 *list_count = n_list_count;
113 static int ctime_compare(const void *a, const void *b)
115 return ((struct report_file*)a)->ctime.tv_sec - ((struct report_file*)b)->ctime.tv_sec;
118 static struct report_file* get_reports(long time_from, long time_to, size_t *count)
120 struct report_file *list = NULL;
123 const char *dirs[] = {
124 CRASH_ROOT_PATH CRASH_PATH_SUBDIR,
125 CRASH_ROOT_PATH LIVE_PATH_SUBDIR
128 for (int i = 0; i < ARRAY_SIZE(dirs); i++) {
129 if (file_exists(dirs[i]) && !get_reports_list(dirs[i], &list, count)) {
130 _E("Can not read reports from: %s", dirs[i]);
135 filter_time(list, count, time_from, time_to);
137 qsort(list, *count, sizeof(struct report_file), ctime_compare);
141 static void write_bugreport_log_file(int out_fd, const char *report_path)
143 int in_fd = diagnostics_report_get_file(report_path, LOG_FILE);
145 _D("No LOG_FILE report in %s file", report_path);
149 if (dprintf(out_fd, "Begin systemtate-log\n") == -1) {
150 _E("Write error: %m");
154 if (copy_bytes(out_fd, in_fd, NULL) == -1) {
155 _E("Copy data error");
161 if (dprintf(out_fd, "End systemtate-log\n") == -1)
162 _E("Write error: %m");
165 static bool write_bugreport(int fd, long time_from, long time_to)
167 size_t list_count = 0;
170 struct report_file *list = get_reports(time_from, time_to, &list_count);
172 dprintf(fd, "Internal error.\n");
176 for (int i = 0; i < list_count; i++) {
177 if (dprintf(fd, "%sBegin bugreport <%s>\n", (i > 0) ? "\n" : "", list[i].file_path) == -1) {
178 _E("Write error: %m");
183 write_bugreport_log_file(fd, list[i].file_path);
185 if (dprintf(fd, "End bugreport <%s>\n", list[i].file_path) == -1) {
186 _E("Write error: %m");
193 for (int i = 0; i < list_count; i++)
194 free_record(&list[i]);
199 static bool write_crash_info(int fd, long time_from, long time_to)
202 size_t list_count = 0;
204 struct report_file *list = get_reports(time_from, time_to, &list_count);
206 dprintf(fd, "Internal error.\n");
210 for (int i = 0; i < list_count; i++) {
211 int nfd = diagnostics_report_get_file(list[i].file_path, INFO_FILE);
213 _I("No INFO_FILE in %s file", list[i].file_path);
214 dprintf(nfd, "No INFO_FILE in %s\n", list[i].file_path);
218 if (dprintf(fd, "%sBegin crash-info <%s>\n", (i > 0) ? "\n" : "", list[i].file_path) == -1) {
219 _E("Write error: %m");
224 if (copy_bytes(fd, nfd, NULL) == -1) {
225 _E("Copy data error");
233 if (dprintf(fd, "End crash-info <%s>\n", list[i].file_path) == -1) {
234 _E("Write error: %m");
241 for (int i = 0; i < list_count; i++)
242 free_record(&list[i]);
247 struct diagnostics_call_options {
248 enum BUGREPORT_REPORT_TYPE report_type;
250 bool last_set, from_set, to_set;
253 static bool diagnostics_call_parse_options(int out_fd, char **params, int params_size, struct diagnostics_call_options *dco)
255 struct timespec cur_time;
256 clock_gettime(CLOCK_REALTIME, &cur_time);
257 dco->report_type = BR_UNKNOWN;
259 dco->to = cur_time.tv_sec;
260 dco->last_set = false;
261 dco->from_set = false;
264 enum PARAM_NAME { PN_TYPE = 1, PN_LAST, PN_TO, PN_FROM};
266 struct option long_options[] = {
267 {"type", required_argument, NULL, PN_TYPE},
268 {"last", required_argument, NULL, PN_LAST},
269 {"to", required_argument, NULL, PN_TO},
270 {"from", required_argument, NULL, PN_FROM},
276 char **nparams = alloca((params_size+1)*sizeof(char*));
277 memcpy(&nparams[1], params, params_size*sizeof(char*));
279 while ((opt = getopt_long_only(params_size+1, nparams, "", long_options, NULL)) != -1) {
282 if (strcmp(optarg, "bugreport") == 0) {
283 dco->report_type = BR_BUGREPORT;
284 } else if (strcmp(optarg, "crash-info") == 0) {
285 dco->report_type = BR_CRASHINFO;
287 _E("Incorrect report type: %s", optarg);
288 dprintf(out_fd, "Incorrect report type: %s\n", optarg);
293 dco->last_set = true;
294 dco->from = cur_time.tv_sec - strtol(optarg, NULL, 10);
297 dco->from_set = true;
298 dco->from = strtol(optarg, NULL, 10);
302 dco->to = strtol(optarg, NULL, 10);
305 _E("Incorrect option: %s", (optind > 0 && optind + 1 < params_size) ? params[optind-1] : "<unknown>");
306 dprintf(out_fd, "Incorrect option: %s\n", (optind > 0 && optind + 1 < params_size) ? params[optind-1] : "<unknown>");
314 static void diagnostics_callback(diagnostics_data_h data, char **params, int params_size, diagnostics_ctx_h ctx, void *user_data)
317 int ret = diagnostics_data_get_fd(data, &fd);
319 _E("Get data file descriptor error: %d", ret);
322 struct diagnostics_call_options dco;
324 if (!diagnostics_call_parse_options(fd, params, params_size, &dco))
327 if ((dco.last_set && (dco.from_set || dco.from_set)) || (dco.to_set && !dco.from_set)) {
328 _E("Incorrect parameters set");
329 dprintf(fd, "Incorrect parameters set.\n");
333 switch(dco.report_type) {
335 write_crash_info(fd, dco.from, dco.to);
338 write_bugreport(fd, dco.from, dco.to);
341 _E("Unknown report type\n");
345 bool diagnostics_init()
347 diagnostics_set_client_id("org.tizen.bugreport-service");
348 if (diagnostics_set_data_request_cb(&diagnostics_callback, NULL) != DIAGNOSTICS_ERROR_NONE) {
349 _E("Unable to register diagnostics callback");