/* Copyright (c) 2008-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ /* * Shared memory logging implementation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "smem_private.h" #define DEBUG #undef DEBUG #ifdef DEBUG #define D_DUMP_BUFFER(prestr, cnt, buf) \ do { \ int i; \ printk(KERN_ERR "%s", prestr); \ for (i = 0; i < cnt; i++) \ printk(KERN_ERR "%.2x", buf[i]); \ printk(KERN_ERR "\n"); \ } while (0) #else #define D_DUMP_BUFFER(prestr, cnt, buf) #endif #ifdef DEBUG #define D(x...) printk(x) #else #define D(x...) do {} while (0) #endif struct smem_log_item { uint32_t identifier; uint32_t timetick; uint32_t data1; uint32_t data2; uint32_t data3; }; #define SMEM_LOG_NUM_ENTRIES 2000 #define SMEM_LOG_EVENTS_SIZE (sizeof(struct smem_log_item) * \ SMEM_LOG_NUM_ENTRIES) #define SMEM_SPINLOCK_SMEM_LOG "S:2" static remote_spinlock_t remote_spinlock; static uint32_t smem_log_enable; static int smem_log_initialized; module_param_named(log_enable, smem_log_enable, int, S_IRUGO | S_IWUSR | S_IWGRP); struct smem_log_inst { int which_log; struct smem_log_item __iomem *events; uint32_t __iomem *idx; uint32_t num; uint32_t read_idx; uint32_t last_read_avail; wait_queue_head_t read_wait; remote_spinlock_t *remote_spinlock; }; enum smem_logs { GEN = 0, NUM }; static struct smem_log_inst inst[NUM]; #if defined(CONFIG_DEBUG_FS) #define HSIZE 13 struct sym { uint32_t val; char *str; struct hlist_node node; }; struct sym id_syms[] = { { SMEM_LOG_PROC_ID_MODEM, "MODM" }, { SMEM_LOG_PROC_ID_Q6, "QDSP" }, { SMEM_LOG_PROC_ID_APPS, "APPS" }, { SMEM_LOG_PROC_ID_WCNSS, "WCNSS" }, }; struct sym base_syms[] = { { SMEM_LOG_SMEM_EVENT_BASE, "SMEM" }, { SMEM_LOG_ERROR_EVENT_BASE, "ERROR" }, { SMEM_LOG_QMI_CCI_EVENT_BASE, "QCCI" }, { SMEM_LOG_QMI_CSI_EVENT_BASE, "QCSI" }, }; struct sym event_syms[] = { { ERR_ERROR_FATAL, "ERR_ERROR_FATAL" }, { ERR_ERROR_FATAL_TASK, "ERR_ERROR_FATAL_TASK" }, { SMEM_LOG_EVENT_CB, "CB" }, { SMEM_LOG_EVENT_START, "START" }, { SMEM_LOG_EVENT_INIT, "INIT" }, { SMEM_LOG_EVENT_RUNNING, "RUNNING" }, { SMEM_LOG_EVENT_STOP, "STOP" }, { SMEM_LOG_EVENT_RESTART, "RESTART" }, { SMEM_LOG_EVENT_SS, "SS" }, { SMEM_LOG_EVENT_READ, "READ" }, { SMEM_LOG_EVENT_WRITE, "WRITE" }, { SMEM_LOG_EVENT_SIGS1, "SIGS1" }, { SMEM_LOG_EVENT_SIGS2, "SIGS2" }, { SMEM_LOG_EVENT_WRITE_DM, "WRITE_DM" }, { SMEM_LOG_EVENT_READ_DM, "READ_DM" }, { SMEM_LOG_EVENT_SKIP_DM, "SKIP_DM" }, { SMEM_LOG_EVENT_STOP_DM, "STOP_DM" }, { SMEM_LOG_EVENT_ISR, "ISR" }, { SMEM_LOG_EVENT_TASK, "TASK" }, { SMEM_LOG_EVENT_RS, "RS" }, }; struct sym smsm_syms[] = { { 0x80000000, "UN" }, { 0x7F000000, "ERR" }, { 0x00800000, "SMLP" }, { 0x00400000, "ADWN" }, { 0x00200000, "PWRS" }, { 0x00100000, "DWLD" }, { 0x00080000, "SRBT" }, { 0x00040000, "SDWN" }, { 0x00020000, "ARBT" }, { 0x00010000, "REL" }, { 0x00008000, "SLE" }, { 0x00004000, "SLP" }, { 0x00002000, "WFPI" }, { 0x00001000, "EEX" }, { 0x00000800, "TIN" }, { 0x00000400, "TWT" }, { 0x00000200, "PWRC" }, { 0x00000100, "RUN" }, { 0x00000080, "SA" }, { 0x00000040, "RES" }, { 0x00000020, "RIN" }, { 0x00000010, "RWT" }, { 0x00000008, "SIN" }, { 0x00000004, "SWT" }, { 0x00000002, "OE" }, { 0x00000001, "I" }, }; struct sym smsm_entry_type_syms[] = { { 0, "SMSM_APPS_STATE" }, { 1, "SMSM_MODEM_STATE" }, { 2, "SMSM_Q6_STATE" }, { 3, "SMSM_APPS_DEM" }, { 4, "SMSM_MODEM_DEM" }, { 5, "SMSM_Q6_DEM" }, { 6, "SMSM_POWER_MASTER_DEM" }, { 7, "SMSM_TIME_MASTER_DEM" }, }; struct sym smsm_state_syms[] = { { 0x00000001, "INIT" }, { 0x00000002, "OSENTERED" }, { 0x00000004, "SMDWAIT" }, { 0x00000008, "SMDINIT" }, { 0x00000010, "RPCWAIT" }, { 0x00000020, "RPCINIT" }, { 0x00000040, "RESET" }, { 0x00000080, "RSA" }, { 0x00000100, "RUN" }, { 0x00000200, "PWRC" }, { 0x00000400, "TIMEWAIT" }, { 0x00000800, "TIMEINIT" }, { 0x00001000, "PWRC_EARLY_EXIT" }, { 0x00002000, "WFPI" }, { 0x00004000, "SLEEP" }, { 0x00008000, "SLEEPEXIT" }, { 0x00010000, "OEMSBL_RELEASE" }, { 0x00020000, "APPS_REBOOT" }, { 0x00040000, "SYSTEM_POWER_DOWN" }, { 0x00080000, "SYSTEM_REBOOT" }, { 0x00100000, "SYSTEM_DOWNLOAD" }, { 0x00200000, "PWRC_SUSPEND" }, { 0x00400000, "APPS_SHUTDOWN" }, { 0x00800000, "SMD_LOOPBACK" }, { 0x01000000, "RUN_QUIET" }, { 0x02000000, "MODEM_WAIT" }, { 0x04000000, "MODEM_BREAK" }, { 0x08000000, "MODEM_CONTINUE" }, { 0x80000000, "UNKNOWN" }, }; enum sym_tables { ID_SYM, BASE_SYM, EVENT_SYM, SMSM_SYM, SMSM_ENTRY_TYPE_SYM, SMSM_STATE_SYM, }; static struct sym_tbl { struct sym *data; int size; struct hlist_head hlist[HSIZE]; } tbl[] = { { id_syms, ARRAY_SIZE(id_syms) }, { base_syms, ARRAY_SIZE(base_syms) }, { event_syms, ARRAY_SIZE(event_syms) }, { smsm_syms, ARRAY_SIZE(smsm_syms) }, { smsm_entry_type_syms, ARRAY_SIZE(smsm_entry_type_syms) }, { smsm_state_syms, ARRAY_SIZE(smsm_state_syms) }, }; #define hash(val) (val % HSIZE) static void init_syms(void) { int i; int j; for (i = 0; i < ARRAY_SIZE(tbl); ++i) for (j = 0; j < HSIZE; ++j) INIT_HLIST_HEAD(&tbl[i].hlist[j]); for (i = 0; i < ARRAY_SIZE(tbl); ++i) for (j = 0; j < tbl[i].size; ++j) { INIT_HLIST_NODE(&tbl[i].data[j].node); hlist_add_head(&tbl[i].data[j].node, &tbl[i].hlist[hash(tbl[i].data[j].val)]); } } static char *find_sym(uint32_t id, uint32_t val) { struct hlist_node *n; struct sym *s; hlist_for_each(n, &tbl[id].hlist[hash(val)]) { s = hlist_entry(n, struct sym, node); if (s->val == val) return s->str; } return 0; } #else static void init_syms(void) {} #endif union fifo_mem { uint64_t u64; uint8_t u8; }; /** * memcpy_to_log() - copy to SMEM log FIFO * @dest: Destination address * @src: Source address * @num_bytes: Number of bytes to copy * * @return: Address of destination * * This function copies num_bytes from src to dest maintaining natural alignment * for accesses to dest as required for Device memory. */ static void *memcpy_to_log(void *dest, const void *src, size_t num_bytes) { union fifo_mem *temp_dst = (union fifo_mem *)dest; union fifo_mem *temp_src = (union fifo_mem *)src; uintptr_t mask = sizeof(union fifo_mem) - 1; /* Do byte copies until we hit 8-byte (double word) alignment */ while ((uintptr_t)temp_dst & mask && num_bytes) { __raw_writeb_no_log(temp_src->u8, temp_dst); temp_src = (union fifo_mem *)((uintptr_t)temp_src + 1); temp_dst = (union fifo_mem *)((uintptr_t)temp_dst + 1); num_bytes--; } /* Do double word copies */ while (num_bytes >= sizeof(union fifo_mem)) { __raw_writeq_no_log(temp_src->u64, temp_dst); temp_dst++; temp_src++; num_bytes -= sizeof(union fifo_mem); } /* Copy remaining bytes */ while (num_bytes--) { __raw_writeb_no_log(temp_src->u8, temp_dst); temp_src = (union fifo_mem *)((uintptr_t)temp_src + 1); temp_dst = (union fifo_mem *)((uintptr_t)temp_dst + 1); } return dest; } static inline unsigned int read_timestamp(void) { return (unsigned int)(arch_counter_get_cntpct()); } static void smem_log_event_from_user(struct smem_log_inst *inst, const char *buf, int size, int num) { uint32_t idx; uint32_t next_idx; unsigned long flags; uint32_t identifier = 0; uint32_t timetick = 0; int first = 1; if (!inst->idx) { pr_err("%s: invalid write index\n", __func__); return; } remote_spin_lock_irqsave(inst->remote_spinlock, flags); while (num--) { idx = *inst->idx; if (idx < inst->num) { memcpy_to_log(&inst->events[idx], buf, size); if (first) { identifier = inst->events[idx]. identifier; timetick = read_timestamp(); first = 0; } else { identifier |= SMEM_LOG_CONT; } inst->events[idx].identifier = identifier; inst->events[idx].timetick = timetick; } next_idx = idx + 1; if (next_idx >= inst->num) next_idx = 0; *inst->idx = next_idx; buf += sizeof(struct smem_log_item); } wmb(); remote_spin_unlock_irqrestore(inst->remote_spinlock, flags); } static void _smem_log_event( struct smem_log_item __iomem *events, uint32_t __iomem *_idx, remote_spinlock_t *lock, int num, uint32_t id, uint32_t data1, uint32_t data2, uint32_t data3) { struct smem_log_item item; uint32_t idx; uint32_t next_idx; unsigned long flags; item.timetick = read_timestamp(); item.identifier = id; item.data1 = data1; item.data2 = data2; item.data3 = data3; remote_spin_lock_irqsave(lock, flags); idx = *_idx; if (idx < num) memcpy_to_log(&events[idx], &item, sizeof(item)); next_idx = idx + 1; if (next_idx >= num) next_idx = 0; *_idx = next_idx; wmb(); remote_spin_unlock_irqrestore(lock, flags); } static void _smem_log_event6( struct smem_log_item __iomem *events, uint32_t __iomem *_idx, remote_spinlock_t *lock, int num, uint32_t id, uint32_t data1, uint32_t data2, uint32_t data3, uint32_t data4, uint32_t data5, uint32_t data6) { struct smem_log_item item[2]; uint32_t idx; uint32_t next_idx; unsigned long flags; item[0].timetick = read_timestamp(); item[0].identifier = id; item[0].data1 = data1; item[0].data2 = data2; item[0].data3 = data3; item[1].identifier = item[0].identifier; item[1].timetick = item[0].timetick; item[1].data1 = data4; item[1].data2 = data5; item[1].data3 = data6; remote_spin_lock_irqsave(lock, flags); idx = *_idx; /* FIXME: Wrap around */ if (idx < (num-1)) memcpy_to_log(&events[idx], &item, sizeof(item)); next_idx = idx + 2; if (next_idx >= num) next_idx = 0; *_idx = next_idx; wmb(); remote_spin_unlock_irqrestore(lock, flags); } void smem_log_event(uint32_t id, uint32_t data1, uint32_t data2, uint32_t data3) { if (smem_log_enable) _smem_log_event(inst[GEN].events, inst[GEN].idx, inst[GEN].remote_spinlock, SMEM_LOG_NUM_ENTRIES, id, data1, data2, data3); } void smem_log_event6(uint32_t id, uint32_t data1, uint32_t data2, uint32_t data3, uint32_t data4, uint32_t data5, uint32_t data6) { if (smem_log_enable) _smem_log_event6(inst[GEN].events, inst[GEN].idx, inst[GEN].remote_spinlock, SMEM_LOG_NUM_ENTRIES, id, data1, data2, data3, data4, data5, data6); } static int _smem_log_init(void) { int ret; inst[GEN].which_log = GEN; inst[GEN].events = (struct smem_log_item *)smem_alloc(SMEM_SMEM_LOG_EVENTS, SMEM_LOG_EVENTS_SIZE, 0, SMEM_ANY_HOST_FLAG); inst[GEN].idx = (uint32_t *)smem_alloc(SMEM_SMEM_LOG_IDX, sizeof(uint32_t), 0, SMEM_ANY_HOST_FLAG); if (IS_ERR_OR_NULL(inst[GEN].events) || IS_ERR_OR_NULL(inst[GEN].idx)) { pr_err("%s: no log or log_idx allocated\n", __func__); return -ENODEV; } inst[GEN].num = SMEM_LOG_NUM_ENTRIES; inst[GEN].read_idx = 0; inst[GEN].last_read_avail = SMEM_LOG_NUM_ENTRIES; init_waitqueue_head(&inst[GEN].read_wait); inst[GEN].remote_spinlock = &remote_spinlock; ret = remote_spin_lock_init(&remote_spinlock, SMEM_SPINLOCK_SMEM_LOG); if (ret) { mb(); return ret; } init_syms(); mb(); return 0; } static ssize_t smem_log_write_bin(struct file *fp, const char __user *_buf, size_t count, loff_t *pos) { void *buf; int r; if (count < sizeof(struct smem_log_item)) return -EINVAL; buf = kmalloc(count, GFP_KERNEL); if (!buf) return -ENOMEM; r = copy_from_user(buf, _buf, count); if (r) { kfree(buf); return -EFAULT; } if (smem_log_enable) smem_log_event_from_user(fp->private_data, buf, sizeof(struct smem_log_item), count / sizeof(struct smem_log_item)); kfree(buf); return count; } static int smem_log_open(struct inode *ip, struct file *fp) { fp->private_data = &inst[GEN]; return 0; } static int smem_log_release(struct inode *ip, struct file *fp) { return 0; } static const struct file_operations smem_log_bin_fops = { .owner = THIS_MODULE, .write = smem_log_write_bin, .open = smem_log_open, .release = smem_log_release, }; static struct miscdevice smem_log_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "smem_log", .fops = &smem_log_bin_fops, }; #if defined(CONFIG_DEBUG_FS) #define SMEM_LOG_ITEM_PRINT_SIZE 160 #define EVENTS_PRINT_SIZE \ (SMEM_LOG_ITEM_PRINT_SIZE * SMEM_LOG_NUM_ENTRIES) static uint32_t smem_log_timeout_ms; module_param_named(timeout_ms, smem_log_timeout_ms, int, S_IRUGO | S_IWUSR | S_IWGRP); static int smem_log_debug_mask; module_param_named(debug_mask, smem_log_debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP); #define DBG(x...) do {\ if (smem_log_debug_mask) \ printk(KERN_DEBUG x);\ } while (0) static int update_read_avail(struct smem_log_inst *inst) { int curr_read_avail; unsigned long flags = 0; if (!inst->idx) return 0; remote_spin_lock_irqsave(inst->remote_spinlock, flags); curr_read_avail = (*inst->idx - inst->read_idx); if (curr_read_avail < 0) curr_read_avail = inst->num - inst->read_idx + *inst->idx; DBG("%s: read = %d write = %d curr = %d last = %d\n", __func__, inst->read_idx, *inst->idx, curr_read_avail, inst->last_read_avail); if (curr_read_avail < inst->last_read_avail) { if (inst->last_read_avail != inst->num) pr_info("smem_log: skipping %d log entries\n", inst->last_read_avail); inst->read_idx = *inst->idx + 1; inst->last_read_avail = inst->num - 1; } else inst->last_read_avail = curr_read_avail; remote_spin_unlock_irqrestore(inst->remote_spinlock, flags); DBG("%s: read = %d write = %d curr = %d last = %d\n", __func__, inst->read_idx, *inst->idx, curr_read_avail, inst->last_read_avail); return inst->last_read_avail; } static int _debug_dump(int log, char *buf, int max, uint32_t cont) { unsigned int idx; int write_idx, read_avail = 0; unsigned long flags; int i = 0; if (!inst[log].events) return 0; if (cont && update_read_avail(&inst[log]) == 0) return 0; remote_spin_lock_irqsave(inst[log].remote_spinlock, flags); if (cont) { idx = inst[log].read_idx; write_idx = (inst[log].read_idx + inst[log].last_read_avail); if (write_idx >= inst[log].num) write_idx -= inst[log].num; } else { write_idx = *inst[log].idx; idx = (write_idx + 1); } DBG("%s: read %d write %d idx %d num %d\n", __func__, inst[log].read_idx, write_idx, idx, inst[log].num - 1); while ((max - i) > 50) { if ((inst[log].num - 1) < idx) idx = 0; if (idx == write_idx) break; if (inst[log].events[idx].identifier) { i += scnprintf(buf + i, max - i, "%08x %08x %08x %08x %08x\n", inst[log].events[idx].identifier, inst[log].events[idx].timetick, inst[log].events[idx].data1, inst[log].events[idx].data2, inst[log].events[idx].data3); } idx++; } if (cont) { inst[log].read_idx = idx; read_avail = (write_idx - inst[log].read_idx); if (read_avail < 0) read_avail = inst->num - inst->read_idx + write_idx; inst[log].last_read_avail = read_avail; } remote_spin_unlock_irqrestore(inst[log].remote_spinlock, flags); DBG("%s: read %d write %d idx %d num %d\n", __func__, inst[log].read_idx, write_idx, idx, inst[log].num); return i; } static int _debug_dump_sym(int log, char *buf, int max, uint32_t cont) { unsigned int idx; int write_idx, read_avail = 0; unsigned long flags; int i = 0; char *proc; char *sub; char *id; const char *sym = NULL; uint32_t proc_val = 0; uint32_t sub_val = 0; uint32_t id_val = 0; uint32_t id_only_val = 0; uint32_t data1 = 0; uint32_t data2 = 0; uint32_t data3 = 0; if (!inst[log].events) return 0; if (cont && update_read_avail(&inst[log]) == 0) return 0; remote_spin_lock_irqsave(inst[log].remote_spinlock, flags); if (cont) { idx = inst[log].read_idx; write_idx = (inst[log].read_idx + inst[log].last_read_avail); if (write_idx >= inst[log].num) write_idx -= inst[log].num; } else { write_idx = *inst[log].idx; idx = (write_idx + 1); } DBG("%s: read %d write %d idx %d num %d\n", __func__, inst[log].read_idx, write_idx, idx, inst[log].num - 1); for (; (max - i) > SMEM_LOG_ITEM_PRINT_SIZE; idx++) { if (idx > (inst[log].num - 1)) idx = 0; if (idx == write_idx) break; if (idx < inst[log].num) { if (!inst[log].events[idx].identifier) continue; proc_val = PROC & inst[log].events[idx].identifier; sub_val = SUB & inst[log].events[idx].identifier; id_val = (SUB | ID) & inst[log].events[idx].identifier; id_only_val = ID & inst[log].events[idx].identifier; data1 = inst[log].events[idx].data1; data2 = inst[log].events[idx].data2; data3 = inst[log].events[idx].data3; if (!(proc_val & SMEM_LOG_CONT)) { i += scnprintf(buf + i, max - i, "\n"); proc = find_sym(ID_SYM, proc_val); if (proc) i += scnprintf(buf + i, max - i, "%4s: ", proc); else i += scnprintf(buf + i, max - i, "%04x: ", PROC & inst[log].events[idx]. identifier); i += scnprintf(buf + i, max - i, "%10u ", inst[log].events[idx].timetick); sub = find_sym(BASE_SYM, sub_val); if (sub) i += scnprintf(buf + i, max - i, "%9s: ", sub); else i += scnprintf(buf + i, max - i, "%08x: ", sub_val); id = find_sym(EVENT_SYM, id_val); if (id) i += scnprintf(buf + i, max - i, "%11s: ", id); else i += scnprintf(buf + i, max - i, "%08x: ", id_only_val); } if (proc_val & SMEM_LOG_CONT) { i += scnprintf(buf + i, max - i, " %08x %08x %08x", data1, data2, data3); } else if (id_val == SMEM_LOG_EVENT_CB) { unsigned vals[] = {data2, data3}; unsigned j; unsigned mask; unsigned tmp; unsigned once; i += scnprintf(buf + i, max - i, "%08x ", data1); for (j = 0; j < ARRAY_SIZE(vals); ++j) { i += scnprintf(buf + i, max - i, "["); mask = 0x80000000; once = 0; while (mask) { tmp = vals[j] & mask; mask >>= 1; if (!tmp) continue; sym = find_sym(SMSM_SYM, tmp); if (once) i += scnprintf(buf + i, max - i, " "); if (sym) i += scnprintf(buf + i, max - i, "%s", sym); else i += scnprintf(buf + i, max - i, "%08x", tmp); once = 1; } i += scnprintf(buf + i, max - i, "] "); } } else { i += scnprintf(buf + i, max - i, "%08x %08x %08x", data1, data2, data3); } } } if (cont) { inst[log].read_idx = idx; read_avail = (write_idx - inst[log].read_idx); if (read_avail < 0) read_avail = inst->num - inst->read_idx + write_idx; inst[log].last_read_avail = read_avail; } remote_spin_unlock_irqrestore(inst[log].remote_spinlock, flags); DBG("%s: read %d write %d idx %d num %d\n", __func__, inst[log].read_idx, write_idx, idx, inst[log].num); return i; } static int debug_dump(char *buf, int max, uint32_t cont) { int r; if (!inst[GEN].idx || !inst[GEN].events) return -ENODEV; while (cont) { update_read_avail(&inst[GEN]); r = wait_event_interruptible_timeout(inst[GEN].read_wait, inst[GEN].last_read_avail, smem_log_timeout_ms * HZ / 1000); DBG("%s: read available %d\n", __func__, inst[GEN].last_read_avail); if (r < 0) return 0; else if (inst[GEN].last_read_avail) break; } return _debug_dump(GEN, buf, max, cont); } static int debug_dump_sym(char *buf, int max, uint32_t cont) { int r; if (!inst[GEN].idx || !inst[GEN].events) return -ENODEV; while (cont) { update_read_avail(&inst[GEN]); r = wait_event_interruptible_timeout(inst[GEN].read_wait, inst[GEN].last_read_avail, smem_log_timeout_ms * HZ / 1000); DBG("%s: readavailable %d\n", __func__, inst[GEN].last_read_avail); if (r < 0) return 0; else if (inst[GEN].last_read_avail) break; } return _debug_dump_sym(GEN, buf, max, cont); } static char debug_buffer[EVENTS_PRINT_SIZE]; static ssize_t debug_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { int r; int bsize = 0; int (*fill)(char *, int, uint32_t) = file->private_data; if (!(*ppos)) { bsize = fill(debug_buffer, EVENTS_PRINT_SIZE, 0); if (bsize < 0) bsize = scnprintf(debug_buffer, EVENTS_PRINT_SIZE, "Log not available\n"); } DBG("%s: count %zu ppos %d\n", __func__, count, (unsigned int)*ppos); r = simple_read_from_buffer(buf, count, ppos, debug_buffer, bsize); return r; } static ssize_t debug_read_cont(struct file *file, char __user *buf, size_t count, loff_t *ppos) { int (*fill)(char *, int, uint32_t) = file->private_data; char *buffer = kmalloc(count, GFP_KERNEL); int bsize; if (!buffer) return -ENOMEM; bsize = fill(buffer, count, 1); if (bsize < 0) { if (*ppos == 0) bsize = scnprintf(buffer, count, "Log not available\n"); else bsize = 0; } DBG("%s: count %zu bsize %d\n", __func__, count, bsize); if (copy_to_user(buf, buffer, bsize)) { kfree(buffer); return -EFAULT; } *ppos += bsize; kfree(buffer); return bsize; } static int debug_open(struct inode *inode, struct file *file) { file->private_data = inode->i_private; return 0; } static const struct file_operations debug_ops = { .read = debug_read, .open = debug_open, }; static const struct file_operations debug_ops_cont = { .read = debug_read_cont, .open = debug_open, }; static void debug_create(const char *name, mode_t mode, struct dentry *dent, int (*fill)(char *buf, int max, uint32_t cont), const struct file_operations *fops) { debugfs_create_file(name, mode, dent, fill, fops); } static void smem_log_debugfs_init(void) { struct dentry *dent; dent = debugfs_create_dir("smem_log", 0); if (IS_ERR(dent)) return; debug_create("dump", 0444, dent, debug_dump, &debug_ops); debug_create("dump_sym", 0444, dent, debug_dump_sym, &debug_ops); debug_create("dump_cont", 0444, dent, debug_dump, &debug_ops_cont); debug_create("dump_sym_cont", 0444, dent, debug_dump_sym, &debug_ops_cont); smem_log_timeout_ms = 500; smem_log_debug_mask = 0; } #else static void smem_log_debugfs_init(void) {} #endif static int smem_log_initialize(void) { int ret; ret = _smem_log_init(); if (ret < 0) { pr_err("%s: init failed %d\n", __func__, ret); return ret; } ret = misc_register(&smem_log_dev); if (ret < 0) { pr_err("%s: device register failed %d\n", __func__, ret); return ret; } smem_log_enable = 1; smem_log_initialized = 1; smem_log_debugfs_init(); return ret; } static int smem_module_init_notifier(struct notifier_block *this, unsigned long code, void *_cmd) { int ret = 0; if (!smem_log_initialized) ret = smem_log_initialize(); return ret; } static struct notifier_block nb = { .notifier_call = smem_module_init_notifier, }; static int __init smem_log_init(void) { return smem_module_init_notifier_register(&nb); } module_init(smem_log_init); MODULE_DESCRIPTION("smem log"); MODULE_LICENSE("GPL v2");