| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Copyright (c) 2020 MediaTek Inc. | |
| */ | |
| #include <linux/module.h> | |
| #include <linux/moduleparam.h> | |
| #include <linux/proc_fs.h> | |
| #include <linux/printk.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/sched/clock.h> | |
| #include <linux/of.h> | |
| #include <linux/slab.h> | |
| #include <linux/uaccess.h> | |
| #include <linux/seq_file.h> | |
| #include <linux/tracepoint.h> | |
| #include <trace/events/initcall.h> | |
| /* Define */ | |
| #define BOOT_STR_SIZE 256 | |
| #define BUF_COUNT 12 | |
| #define LOGS_PER_BUF 80 | |
| #define MSG_SIZE 128 | |
| #ifdef CONFIG_BOOTPROF_THRESHOLD_MS | |
| #define BOOTPROF_THRESHOLD (CONFIG_BOOTPROF_THRESHOLD_MS*1000000) | |
| #else | |
| #define BOOTPROF_THRESHOLD 15000000 | |
| #endif | |
| struct log_t { | |
| /* task cmdline for first 16 bytes | |
| * and boot event for the rest | |
| */ | |
| char *comm_event; | |
| pid_t pid; | |
| u64 timestamp; | |
| }; | |
| /** | |
| * Data structures to store tracepoints information | |
| */ | |
| struct tracepoints_table { | |
| const char *name; | |
| void *func; | |
| struct tracepoint *tp; | |
| void *data; | |
| bool init; | |
| }; | |
| /** | |
| * Data structures to store initcall start time info | |
| */ | |
| struct initcall_list_t { | |
| pid_t pid; | |
| pid_t tid; | |
| u64 timestamp; | |
| struct list_head dev_entry; | |
| }; | |
| static void tp_deinit(void); | |
| /* Parameters */ | |
| static struct log_t *bootprof[BUF_COUNT]; | |
| static unsigned long log_count; | |
| static DEFINE_SPINLOCK(bootprof_lock); | |
| static bool enabled; | |
| static int bf_lk_t, bf_pl_t, bf_logo_t; | |
| static int bf_bl2ext_t, bf_gz_t, bf_tfa_t, bf_sec_os_t; | |
| static u64 timestamp_on, timestamp_off; | |
| static bool boot_finish; | |
| static struct list_head initcall_list; | |
| static DEFINE_SPINLOCK(initcall_lock); | |
| atomic_t initcall_num = ATOMIC_INIT(0); | |
| /*Get info form cmdline*/ | |
| module_param_named(pl_t, bf_pl_t, int, 0644); | |
| module_param_named(lk_t, bf_lk_t, int, 0644); | |
| module_param_named(logo_t, bf_logo_t, int, 0644); | |
| bool mt_boot_finish(void) | |
| { | |
| return boot_finish; | |
| } | |
| EXPORT_SYMBOL_GPL(mt_boot_finish); | |
| static long long msec_high(unsigned long long nsec) | |
| { | |
| if ((long long)nsec < 0) { | |
| nsec = -nsec; | |
| do_div(nsec, 1000000); | |
| return -nsec; | |
| } | |
| do_div(nsec, 1000000); | |
| return nsec; | |
| } | |
| static unsigned long msec_low(unsigned long long nsec) | |
| { | |
| if ((long long)nsec < 0) | |
| nsec = -nsec; | |
| return do_div(nsec, 1000000); | |
| } | |
| void bootprof_log_boot(char *str) | |
| { | |
| unsigned long long ts; | |
| struct log_t *p = NULL; | |
| size_t n; | |
| int err = 0; | |
| if (!str) { | |
| return; | |
| } | |
| n = strlen(str) + 1; | |
| ts = sched_clock(); | |
| spin_lock(&bootprof_lock); | |
| if (!enabled) { | |
| spin_unlock(&bootprof_lock); | |
| return; | |
| } | |
| if (log_count >= (LOGS_PER_BUF * BUF_COUNT)) { | |
| enabled = false; | |
| err = 1; | |
| goto out; | |
| } else if (log_count && !(log_count % LOGS_PER_BUF)) { | |
| bootprof[log_count / LOGS_PER_BUF] = | |
| kcalloc(LOGS_PER_BUF, sizeof(struct log_t), | |
| GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN); | |
| } | |
| if (!bootprof[log_count / LOGS_PER_BUF]) { | |
| err = 2; | |
| goto out; | |
| } | |
| p = &bootprof[log_count / LOGS_PER_BUF][log_count % LOGS_PER_BUF]; | |
| p->timestamp = ts; | |
| p->pid = current->pid; | |
| n += TASK_COMM_LEN; | |
| p->comm_event = kzalloc(n, GFP_ATOMIC | __GFP_NORETRY | | |
| __GFP_NOWARN); | |
| if (!p->comm_event) { | |
| enabled = false; | |
| err = 3; | |
| goto out; | |
| } | |
| memcpy(p->comm_event, current->comm, TASK_COMM_LEN); | |
| memcpy(p->comm_event + TASK_COMM_LEN, str, n - TASK_COMM_LEN); | |
| log_count++; | |
| out: | |
| spin_unlock(&bootprof_lock); | |
| pr_info("BOOTPROF:%10lld.%06ld:%s\n", msec_high(ts), msec_low(ts), str); | |
| if (err > 0) | |
| pr_info("[BOOTPROF] Error(Ret:%d): Skip log.\n", err); | |
| } | |
| EXPORT_SYMBOL_GPL(bootprof_log_boot); | |
| static void bootprof_bootloader(void) | |
| { | |
| struct device_node *node; | |
| node = of_find_node_by_name(NULL, "bootprof"); | |
| if (node) { | |
| of_property_read_s32(node, "pl_t", &bf_pl_t); | |
| of_property_read_s32(node, "lk_t", &bf_lk_t); | |
| if (of_property_read_s32(node, "logo_t", &bf_logo_t)) | |
| of_property_read_s32(node, "lk_logo_t", &bf_logo_t); | |
| of_property_read_s32(node, "logo_t", &bf_logo_t); | |
| of_property_read_s32(node, "bl2_ext_t", &bf_bl2ext_t); | |
| of_property_read_s32(node, "tfa_t", &bf_tfa_t); | |
| of_property_read_s32(node, "sec_os_t", &bf_sec_os_t); | |
| of_property_read_s32(node, "gz_t", &bf_gz_t); | |
| pr_info("BOOTPROF: pl=%d, bl2ext=%d ,lk=%d, logo=%d, tfa=%d, sec_os=%d, gz=%d\n", | |
| bf_pl_t, bf_bl2ext_t, bf_lk_t, bf_logo_t, bf_tfa_t, | |
| bf_sec_os_t, bf_gz_t); | |
| } | |
| } | |
| void bootprof_initcall(initcall_t fn, unsigned long long ts) | |
| { | |
| /* log more than threshold initcalls */ | |
| unsigned long msec_rem; | |
| char msgbuf[MSG_SIZE]; | |
| int len; | |
| atomic_inc(&initcall_num); | |
| if (ts > BOOTPROF_THRESHOLD) { | |
| msec_rem = do_div(ts, NSEC_PER_MSEC); | |
| len = scnprintf(msgbuf, sizeof(msgbuf), | |
| "initcall: %ps %5llu.%06lums", | |
| fn, ts, msec_rem); | |
| if (len < 0) | |
| pr_info("BOOTPROF: initcall - Invalid argument.\n"); | |
| bootprof_log_boot(msgbuf); | |
| } | |
| } | |
| #ifndef MODULE | |
| /*Build-in*/ | |
| void bootprof_probe(unsigned long long ts, struct device *dev, | |
| struct device_driver *drv, unsigned long probe) | |
| { | |
| /* log more than threshold probes*/ | |
| unsigned long msec_rem; | |
| char msgbuf[MSG_SIZE]; | |
| int pos, len; | |
| if (ts <= BOOTPROF_THRESHOLD) | |
| return; | |
| msec_rem = do_div(ts, NSEC_PER_MSEC); | |
| pos = scnprintf(msgbuf, sizeof(msgbuf), "probe: probe=%ps", | |
| (void *)probe); | |
| if (pos < 0) | |
| pos = 0; | |
| if (drv) { | |
| len = scnprintf(msgbuf + pos, sizeof(msgbuf) - pos, | |
| " drv=%s(%ps)", drv->name ? drv->name : "", | |
| (void *)drv); | |
| if (len >= 0) | |
| pos += len; | |
| } | |
| if (dev && dev->init_name) { | |
| len = scnprintf(msgbuf + pos, sizeof(msgbuf) - pos, | |
| " dev=%s(%ps)", dev->init_name, (void *)dev); | |
| if (len >= 0) | |
| pos += len; | |
| } | |
| scnprintf(msgbuf + pos, sizeof(msgbuf) - pos, | |
| " %5llu.%06lums", ts, msec_rem); | |
| bootprof_log_boot(msgbuf); | |
| } | |
| EXPORT_SYMBOL_GPL(bootprof_probe); | |
| void bootprof_pdev_register(unsigned long long ts, struct platform_device *pdev) | |
| { | |
| /* log more than threshold register*/ | |
| unsigned long msec_rem; | |
| char msgbuf[MSG_SIZE]; | |
| int len; | |
| if (ts <= BOOTPROF_THRESHOLD || !pdev) | |
| return; | |
| msec_rem = do_div(ts, NSEC_PER_MSEC); | |
| len = scnprintf(msgbuf, sizeof(msgbuf), | |
| "probe: pdev=%s(%ps) %5llu.%06lums", | |
| pdev->name, (void *)pdev, ts, msec_rem); | |
| if (len < 0) | |
| pr_info("BOOTPROF: pdev - Invalid argument.\n"); | |
| bootprof_log_boot(msgbuf); | |
| } | |
| EXPORT_SYMBOL_GPL(bootprof_pdev_register); | |
| #endif /*MODULE END*/ | |
| /* initcalls tracepoint cb while initcall_debug=1 */ | |
| static __init_or_module void | |
| tp_initcall_start_cb(void *data, initcall_t fn) | |
| { | |
| struct initcall_list_t *obj; | |
| struct initcall_list_t *pos, *next; | |
| struct list_head err_list; | |
| INIT_LIST_HEAD(&err_list); | |
| obj = kzalloc(sizeof(struct initcall_list_t), | |
| GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN); | |
| if (!obj) | |
| return; | |
| obj->pid = task_pid_nr(current); | |
| obj->tid = task_pid_vnr(current); | |
| obj->timestamp = sched_clock(); | |
| /*Check if there is duplicated enrty.*/ | |
| spin_lock(&initcall_lock); | |
| if (!list_empty(&initcall_list)) { | |
| list_for_each_entry_safe(pos, next, &initcall_list, dev_entry) { | |
| if ((pos->pid == obj->pid) && (pos->tid == obj->tid)) { | |
| list_del(&pos->dev_entry); | |
| /*Add duplicated enrty into err list*/ | |
| list_add_tail(&pos->dev_entry, &err_list); | |
| } | |
| } | |
| } | |
| list_add_tail(&obj->dev_entry, &initcall_list); | |
| spin_unlock(&initcall_lock); | |
| /*release entry of err list*/ | |
| if (!list_empty(&err_list)) { | |
| list_for_each_entry_safe(pos, next, &err_list, dev_entry) { | |
| pr_info("[BOOTPROF] Warn:duplicated entry.(pid:%d, tid:%d)\n", | |
| pos->pid, pos->tid); | |
| list_del(&pos->dev_entry); | |
| kfree(pos); | |
| } | |
| } | |
| } | |
| static __init_or_module void | |
| tp_initcall_finish_cb(void *data, initcall_t fn, int ret) | |
| { | |
| struct initcall_list_t *pos, *next; | |
| unsigned long long start_ts = 0; | |
| struct list_head memfree_list; | |
| unsigned long long end_ts = sched_clock(); | |
| unsigned long long duration; | |
| INIT_LIST_HEAD(&memfree_list); | |
| spin_lock(&initcall_lock); | |
| list_for_each_entry_safe(pos, next, &initcall_list, dev_entry) { | |
| if ((pos->pid == task_pid_nr(current)) && | |
| (pos->tid == task_pid_vnr(current))) { | |
| start_ts = pos->timestamp; | |
| list_del(&pos->dev_entry); | |
| list_add_tail(&pos->dev_entry, &memfree_list); | |
| break; | |
| } | |
| } | |
| spin_unlock(&initcall_lock); | |
| /*release entry*/ | |
| if (!list_empty(&memfree_list)) { | |
| list_for_each_entry_safe(pos, next, &memfree_list, dev_entry) { | |
| list_del(&pos->dev_entry); | |
| kfree(pos); | |
| } | |
| } | |
| /* start time of current module is 0.*/ | |
| if (start_ts == 0) { | |
| #ifdef MODULE | |
| /* if bootprof is first loading module.*/ | |
| bootprof_log_boot("Kernel_init_done"); | |
| #endif | |
| return; | |
| } | |
| duration = end_ts - start_ts; | |
| bootprof_initcall(fn, duration); | |
| } | |
| static struct tracepoints_table interests[] = { | |
| {.name = "initcall_start", .func = tp_initcall_start_cb}, | |
| {.name = "initcall_finish", .func = tp_initcall_finish_cb}, | |
| }; | |
| #define FOR_EACH_INTEREST(i) \ | |
| for (i = 0; i < sizeof(interests) / \ | |
| sizeof(struct tracepoints_table); i++) | |
| /* Find the struct tracepoint associated */ | |
| /* with a given tracepointname. */ | |
| static void tp_lookup(struct tracepoint *tp, void *ignore) | |
| { | |
| unsigned int i; | |
| if (!tp || !tp->name) | |
| return; | |
| FOR_EACH_INTEREST(i) { | |
| if (strcmp(interests[i].name, tp->name) == 0) | |
| interests[i].tp = tp; | |
| } | |
| } | |
| /* Unregister initcalls tracepoints */ | |
| static void tp_deinit(void) | |
| { | |
| unsigned int i; | |
| struct initcall_list_t *pos, *next; | |
| FOR_EACH_INTEREST(i) { | |
| if (interests[i].init) { | |
| tracepoint_probe_unregister(interests[i].tp, | |
| interests[i].func, interests[i].data); | |
| interests[i].init = false; | |
| } | |
| } | |
| spin_lock(&initcall_lock); | |
| if (!list_empty(&initcall_list)) { | |
| list_for_each_entry_safe(pos, next, &initcall_list, dev_entry) { | |
| if (pos) { | |
| list_del(&pos->dev_entry); | |
| kfree(pos); | |
| } | |
| } | |
| } | |
| spin_unlock(&initcall_lock); | |
| pr_info("BOOTPROF: Unregister initcalls tracepoint.\n"); | |
| } | |
| /* Register initcalls tracepoints */ | |
| static void tp_init(void) | |
| { | |
| unsigned int i; | |
| INIT_LIST_HEAD(&initcall_list); | |
| /* Install the tracepoints */ | |
| for_each_kernel_tracepoint(tp_lookup, NULL); | |
| FOR_EACH_INTEREST(i) { | |
| if (!interests[i].tp) { | |
| pr_info("[BOOTPROF]TP: %s not found\n", | |
| interests[i].name); | |
| /* Unload previously loaded */ | |
| tp_deinit(); | |
| return; | |
| } | |
| tracepoint_probe_register(interests[i].tp, interests[i].func, | |
| interests[i].data); | |
| interests[i].init = true; | |
| } | |
| } | |
| static void mt_bootprof_switch(int on) | |
| { | |
| bool tmp; | |
| unsigned long long ts = sched_clock(); | |
| spin_lock(&bootprof_lock); | |
| tmp = enabled ^ on; | |
| if (tmp) { | |
| if (on) | |
| enabled = 1; | |
| else | |
| enabled = 0; | |
| } | |
| spin_unlock(&bootprof_lock); | |
| if (tmp) { | |
| pr_info("BOOTPROF:%10lld.%06ld: %s%lld)\n", | |
| msec_high(ts), msec_low(ts), on ? "ON (TH:" : "OFF (KO:", | |
| on ? msec_high(BOOTPROF_THRESHOLD) : (long long)atomic_read(&initcall_num)); | |
| if (on) { | |
| timestamp_on = ts; | |
| } else { | |
| timestamp_off = ts; | |
| if (!boot_finish) { | |
| boot_finish = true; | |
| /* Unregister Initcall tracepointsk while boot finish */ | |
| tp_deinit(); | |
| } | |
| } | |
| } | |
| } | |
| static ssize_t | |
| mt_bootprof_write(struct file *filp, const char *ubuf, size_t cnt, loff_t *data) | |
| { | |
| char buf[BOOT_STR_SIZE]; | |
| size_t copy_size = cnt; | |
| if (cnt >= sizeof(buf)) | |
| copy_size = BOOT_STR_SIZE - 1; | |
| if (copy_from_user(&buf, ubuf, copy_size)) | |
| return -EFAULT; | |
| if (cnt == 1 && buf[0] == '1') { | |
| mt_bootprof_switch(1); | |
| return 1; | |
| } else if (cnt == 1 && buf[0] == '0') { | |
| mt_bootprof_switch(0); | |
| return 1; | |
| } | |
| buf[copy_size] = 0; | |
| bootprof_log_boot(buf); | |
| return cnt; | |
| } | |
| static int mt_bootprof_show(struct seq_file *m, void *v) | |
| { | |
| unsigned long i; | |
| struct log_t *p; | |
| if (!m) { | |
| pr_info("seq_file is Null.\n"); | |
| return 0; | |
| } | |
| seq_puts(m, "----------------------------------------\n"); | |
| seq_printf(m, "%-10d BOOT PROF (unit:msec)\n", enabled); | |
| seq_printf(m, "%-10d Kernel Module Total\n", atomic_read(&initcall_num)); | |
| seq_puts(m, "----------------------------------------\n"); | |
| seq_printf(m, "%10d : %s\n", bf_pl_t, "preloader"); | |
| if (bf_bl2ext_t > 0) { | |
| seq_printf(m, "%10d : %s (%s: %d)\n", bf_bl2ext_t, | |
| "bl2_ext", "Start->Show logo", bf_logo_t); | |
| if (bf_tfa_t > 0) | |
| seq_printf(m, "%10d : %s\n", bf_tfa_t, "tfa"); | |
| if (bf_sec_os_t > 0) | |
| seq_printf(m, "%10d : %s\n", bf_sec_os_t, "sec_os"); | |
| if (bf_gz_t > 0) | |
| seq_printf(m, "%10d : %s\n", bf_gz_t, "gz"); | |
| seq_printf(m, "%10d : %s\n", bf_lk_t, "lk"); | |
| } else { | |
| seq_printf(m, "%10d : %s (%s: %d)\n", bf_lk_t, | |
| "lk", "Start->Show logo", bf_logo_t); | |
| } | |
| seq_puts(m, "----------------------------------------\n"); | |
| seq_printf(m, "%10lld.%06ld : ON (Threshold:%5lldms)\n", | |
| msec_high(timestamp_on), msec_low(timestamp_on), | |
| msec_high(BOOTPROF_THRESHOLD)); | |
| for (i = 0; i < log_count; i++) { | |
| p = &bootprof[i / LOGS_PER_BUF][i % LOGS_PER_BUF]; | |
| if (!p->comm_event) | |
| continue; | |
| seq_printf(m, "%10llu.%06lu :%5d-%-16s: %s\n", | |
| msec_high(p->timestamp), | |
| msec_low(p->timestamp), | |
| p->pid, p->comm_event, | |
| p->comm_event + TASK_COMM_LEN); | |
| } | |
| seq_printf(m, "%10lld.%06ld : OFF\n", | |
| msec_high(timestamp_off), msec_low(timestamp_off)); | |
| seq_puts(m, "----------------------------------------\n"); | |
| return 0; | |
| } | |
| /*** Seq operation of mtprof ****/ | |
| static int mt_bootprof_open(struct inode *inode, struct file *file) | |
| { | |
| return single_open(file, mt_bootprof_show, inode->i_private); | |
| } | |
| static const struct proc_ops mt_bootprof_fops = { | |
| .proc_open = mt_bootprof_open, | |
| .proc_write = mt_bootprof_write, | |
| .proc_read = seq_read, | |
| .proc_lseek = seq_lseek, | |
| .proc_release = single_release, | |
| }; | |
| static int __init bootprof_init(void) | |
| { | |
| struct proc_dir_entry *pe; | |
| memset(bootprof, 0, sizeof(struct log_t *) * BUF_COUNT); | |
| bootprof[0] = kcalloc(LOGS_PER_BUF, sizeof(struct log_t), | |
| GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN); | |
| if (!bootprof[0]) { | |
| pr_info("[BOOTPROF] fail to allocate memory\n"); | |
| return -ENOMEM; | |
| } | |
| pe = proc_create("bootprof", 0664, NULL, &mt_bootprof_fops); | |
| if (!pe) { | |
| pr_info("[BOOTPROF] fail to create file node\n"); | |
| return -ENOMEM; | |
| } | |
| bootprof_bootloader(); | |
| tp_init(); | |
| mt_bootprof_switch(1); | |
| return 0; | |
| } | |
| static void __exit bootprof_exit(void) | |
| { | |
| struct log_t *p = NULL; | |
| unsigned int i; | |
| tp_deinit(); | |
| if (log_count > 0) { | |
| spin_lock(&bootprof_lock); | |
| enabled = 0; | |
| for (i = 0; i < log_count; i++) { | |
| p = &bootprof[i / LOGS_PER_BUF][i % LOGS_PER_BUF]; | |
| kfree(p->comm_event); | |
| } | |
| for (i = 0; i < ((log_count / LOGS_PER_BUF) + 1); i++) | |
| kfree(bootprof[i]); | |
| spin_unlock(&bootprof_lock); | |
| } | |
| remove_proc_entry("bootprof", NULL); | |
| pr_info("bootprof module exit.\n"); | |
| } | |
| early_initcall(bootprof_init); | |
| module_exit(bootprof_exit); | |
| MODULE_DESCRIPTION("MEDIATEK BOOT TIME PROFILING"); | |
| MODULE_LICENSE("GPL v2"); |