1 /* 2 * Copyright 2012 Google, Inc. 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/compiler.h> 16 #include <linux/irqflags.h> 17 #include <linux/percpu.h> 18 #include <linux/smp.h> 19 #include <linux/atomic.h> 20 #include <linux/types.h> 21 #include <linux/mutex.h> 22 #include <linux/ftrace.h> 23 #include <linux/fs.h> 24 #include <linux/debugfs.h> 25 #include <linux/err.h> 26 #include <linux/cache.h> 27 #include <asm/barrier.h> 28 #include "internal.h" 29 30 /* This doesn't need to be atomic: speed is chosen over correctness here. */ 31 static u64 pstore_ftrace_stamp; 32 33 static void notrace pstore_ftrace_call(unsigned long ip, 34 unsigned long parent_ip, 35 struct ftrace_ops *op, 36 struct pt_regs *regs) 37 { 38 unsigned long flags; 39 struct pstore_ftrace_record rec = {}; 40 struct pstore_record record = { 41 .type = PSTORE_TYPE_FTRACE, 42 .buf = (char *)&rec, 43 .size = sizeof(rec), 44 .psi = psinfo, 45 }; 46 47 if (unlikely(oops_in_progress)) 48 return; 49 50 local_irq_save(flags); 51 52 rec.ip = ip; 53 rec.parent_ip = parent_ip; 54 pstore_ftrace_write_timestamp(&rec, pstore_ftrace_stamp++); 55 pstore_ftrace_encode_cpu(&rec, raw_smp_processor_id()); 56 psinfo->write(&record); 57 58 local_irq_restore(flags); 59 } 60 61 static struct ftrace_ops pstore_ftrace_ops __read_mostly = { 62 .func = pstore_ftrace_call, 63 }; 64 65 static DEFINE_MUTEX(pstore_ftrace_lock); 66 static bool pstore_ftrace_enabled; 67 68 static ssize_t pstore_ftrace_knob_write(struct file *f, const char __user *buf, 69 size_t count, loff_t *ppos) 70 { 71 u8 on; 72 ssize_t ret; 73 74 ret = kstrtou8_from_user(buf, count, 2, &on); 75 if (ret) 76 return ret; 77 78 mutex_lock(&pstore_ftrace_lock); 79 80 if (!on ^ pstore_ftrace_enabled) 81 goto out; 82 83 if (on) { 84 ftrace_ops_set_global_filter(&pstore_ftrace_ops); 85 ret = register_ftrace_function(&pstore_ftrace_ops); 86 } else { 87 ret = unregister_ftrace_function(&pstore_ftrace_ops); 88 } 89 90 if (ret) { 91 pr_err("%s: unable to %sregister ftrace ops: %zd\n", 92 __func__, on ? "" : "un", ret); 93 goto err; 94 } 95 96 pstore_ftrace_enabled = on; 97 out: 98 ret = count; 99 err: 100 mutex_unlock(&pstore_ftrace_lock); 101 102 return ret; 103 } 104 105 static ssize_t pstore_ftrace_knob_read(struct file *f, char __user *buf, 106 size_t count, loff_t *ppos) 107 { 108 char val[] = { '0' + pstore_ftrace_enabled, '\n' }; 109 110 return simple_read_from_buffer(buf, count, ppos, val, sizeof(val)); 111 } 112 113 static const struct file_operations pstore_knob_fops = { 114 .open = simple_open, 115 .read = pstore_ftrace_knob_read, 116 .write = pstore_ftrace_knob_write, 117 }; 118 119 static struct dentry *pstore_ftrace_dir; 120 121 void pstore_register_ftrace(void) 122 { 123 struct dentry *file; 124 125 if (!psinfo->write) 126 return; 127 128 pstore_ftrace_dir = debugfs_create_dir("pstore", NULL); 129 if (!pstore_ftrace_dir) { 130 pr_err("%s: unable to create pstore directory\n", __func__); 131 return; 132 } 133 134 file = debugfs_create_file("record_ftrace", 0600, pstore_ftrace_dir, 135 NULL, &pstore_knob_fops); 136 if (!file) { 137 pr_err("%s: unable to create record_ftrace file\n", __func__); 138 goto err_file; 139 } 140 141 return; 142 err_file: 143 debugfs_remove(pstore_ftrace_dir); 144 } 145 146 void pstore_unregister_ftrace(void) 147 { 148 mutex_lock(&pstore_ftrace_lock); 149 if (pstore_ftrace_enabled) { 150 unregister_ftrace_function(&pstore_ftrace_ops); 151 pstore_ftrace_enabled = 0; 152 } 153 mutex_unlock(&pstore_ftrace_lock); 154 155 debugfs_remove_recursive(pstore_ftrace_dir); 156 } 157