trace_output.c 29 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382
  1. /*
  2. * trace_output.c
  3. *
  4. * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  5. *
  6. */
  7. #include <linux/module.h>
  8. #include <linux/mutex.h>
  9. #include <linux/ftrace.h>
  10. #include "trace_output.h"
  11. /* must be a power of 2 */
  12. #define EVENT_HASHSIZE 128
  13. DECLARE_RWSEM(trace_event_mutex);
  14. static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
  15. static int next_event_type = __TRACE_LAST_TYPE + 1;
  16. int trace_print_seq(struct seq_file *m, struct trace_seq *s)
  17. {
  18. int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;
  19. int ret;
  20. ret = seq_write(m, s->buffer, len);
  21. /*
  22. * Only reset this buffer if we successfully wrote to the
  23. * seq_file buffer.
  24. */
  25. if (!ret)
  26. trace_seq_init(s);
  27. return ret;
  28. }
  29. enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
  30. {
  31. struct trace_seq *s = &iter->seq;
  32. struct trace_entry *entry = iter->ent;
  33. struct bprint_entry *field;
  34. int ret;
  35. trace_assign_type(field, entry);
  36. ret = trace_seq_bprintf(s, field->fmt, field->buf);
  37. if (!ret)
  38. return TRACE_TYPE_PARTIAL_LINE;
  39. return TRACE_TYPE_HANDLED;
  40. }
  41. enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
  42. {
  43. struct trace_seq *s = &iter->seq;
  44. struct trace_entry *entry = iter->ent;
  45. struct print_entry *field;
  46. int ret;
  47. trace_assign_type(field, entry);
  48. ret = trace_seq_printf(s, "%s", field->buf);
  49. if (!ret)
  50. return TRACE_TYPE_PARTIAL_LINE;
  51. return TRACE_TYPE_HANDLED;
  52. }
  53. /**
  54. * trace_seq_printf - sequence printing of trace information
  55. * @s: trace sequence descriptor
  56. * @fmt: printf format string
  57. *
  58. * It returns 0 if the trace oversizes the buffer's free
  59. * space, 1 otherwise.
  60. *
  61. * The tracer may use either sequence operations or its own
  62. * copy to user routines. To simplify formating of a trace
  63. * trace_seq_printf is used to store strings into a special
  64. * buffer (@s). Then the output may be either used by
  65. * the sequencer or pulled into another buffer.
  66. */
  67. int
  68. trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
  69. {
  70. int len = (PAGE_SIZE - 1) - s->len;
  71. va_list ap;
  72. int ret;
  73. if (s->full || !len)
  74. return 0;
  75. va_start(ap, fmt);
  76. ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
  77. va_end(ap);
  78. /* If we can't write it all, don't bother writing anything */
  79. if (ret >= len) {
  80. s->full = 1;
  81. return 0;
  82. }
  83. s->len += ret;
  84. return 1;
  85. }
  86. EXPORT_SYMBOL_GPL(trace_seq_printf);
  87. /**
  88. * trace_seq_vprintf - sequence printing of trace information
  89. * @s: trace sequence descriptor
  90. * @fmt: printf format string
  91. *
  92. * The tracer may use either sequence operations or its own
  93. * copy to user routines. To simplify formating of a trace
  94. * trace_seq_printf is used to store strings into a special
  95. * buffer (@s). Then the output may be either used by
  96. * the sequencer or pulled into another buffer.
  97. */
  98. int
  99. trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
  100. {
  101. int len = (PAGE_SIZE - 1) - s->len;
  102. int ret;
  103. if (s->full || !len)
  104. return 0;
  105. ret = vsnprintf(s->buffer + s->len, len, fmt, args);
  106. /* If we can't write it all, don't bother writing anything */
  107. if (ret >= len) {
  108. s->full = 1;
  109. return 0;
  110. }
  111. s->len += ret;
  112. return len;
  113. }
  114. EXPORT_SYMBOL_GPL(trace_seq_vprintf);
  115. int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
  116. {
  117. int len = (PAGE_SIZE - 1) - s->len;
  118. int ret;
  119. if (s->full || !len)
  120. return 0;
  121. ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
  122. /* If we can't write it all, don't bother writing anything */
  123. if (ret >= len) {
  124. s->full = 1;
  125. return 0;
  126. }
  127. s->len += ret;
  128. return len;
  129. }
  130. /**
  131. * trace_seq_puts - trace sequence printing of simple string
  132. * @s: trace sequence descriptor
  133. * @str: simple string to record
  134. *
  135. * The tracer may use either the sequence operations or its own
  136. * copy to user routines. This function records a simple string
  137. * into a special buffer (@s) for later retrieval by a sequencer
  138. * or other mechanism.
  139. */
  140. int trace_seq_puts(struct trace_seq *s, const char *str)
  141. {
  142. int len = strlen(str);
  143. if (s->full)
  144. return 0;
  145. if (len > ((PAGE_SIZE - 1) - s->len)) {
  146. s->full = 1;
  147. return 0;
  148. }
  149. memcpy(s->buffer + s->len, str, len);
  150. s->len += len;
  151. return len;
  152. }
  153. int trace_seq_putc(struct trace_seq *s, unsigned char c)
  154. {
  155. if (s->full)
  156. return 0;
  157. if (s->len >= (PAGE_SIZE - 1)) {
  158. s->full = 1;
  159. return 0;
  160. }
  161. s->buffer[s->len++] = c;
  162. return 1;
  163. }
  164. EXPORT_SYMBOL(trace_seq_putc);
  165. int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len)
  166. {
  167. if (s->full)
  168. return 0;
  169. if (len > ((PAGE_SIZE - 1) - s->len)) {
  170. s->full = 1;
  171. return 0;
  172. }
  173. memcpy(s->buffer + s->len, mem, len);
  174. s->len += len;
  175. return len;
  176. }
  177. int trace_seq_putmem_hex(struct trace_seq *s, const void *mem, size_t len)
  178. {
  179. unsigned char hex[HEX_CHARS];
  180. const unsigned char *data = mem;
  181. int i, j;
  182. if (s->full)
  183. return 0;
  184. #ifdef __BIG_ENDIAN
  185. for (i = 0, j = 0; i < len; i++) {
  186. #else
  187. for (i = len-1, j = 0; i >= 0; i--) {
  188. #endif
  189. hex[j++] = hex_asc_hi(data[i]);
  190. hex[j++] = hex_asc_lo(data[i]);
  191. }
  192. hex[j++] = ' ';
  193. return trace_seq_putmem(s, hex, j);
  194. }
  195. void *trace_seq_reserve(struct trace_seq *s, size_t len)
  196. {
  197. void *ret;
  198. if (s->full)
  199. return NULL;
  200. if (len > ((PAGE_SIZE - 1) - s->len)) {
  201. s->full = 1;
  202. return NULL;
  203. }
  204. ret = s->buffer + s->len;
  205. s->len += len;
  206. return ret;
  207. }
  208. int trace_seq_path(struct trace_seq *s, const struct path *path)
  209. {
  210. unsigned char *p;
  211. if (s->full)
  212. return 0;
  213. if (s->len >= (PAGE_SIZE - 1)) {
  214. s->full = 1;
  215. return 0;
  216. }
  217. p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
  218. if (!IS_ERR(p)) {
  219. p = mangle_path(s->buffer + s->len, p, "\n");
  220. if (p) {
  221. s->len = p - s->buffer;
  222. return 1;
  223. }
  224. } else {
  225. s->buffer[s->len++] = '?';
  226. return 1;
  227. }
  228. s->full = 1;
  229. return 0;
  230. }
  231. const char *
  232. ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
  233. unsigned long flags,
  234. const struct trace_print_flags *flag_array)
  235. {
  236. unsigned long mask;
  237. const char *str;
  238. const char *ret = p->buffer + p->len;
  239. int i, first = 1;
  240. for (i = 0; flag_array[i].name && flags; i++) {
  241. mask = flag_array[i].mask;
  242. if ((flags & mask) != mask)
  243. continue;
  244. str = flag_array[i].name;
  245. flags &= ~mask;
  246. if (!first && delim)
  247. trace_seq_puts(p, delim);
  248. else
  249. first = 0;
  250. trace_seq_puts(p, str);
  251. }
  252. /* check for left over flags */
  253. if (flags) {
  254. if (!first && delim)
  255. trace_seq_puts(p, delim);
  256. trace_seq_printf(p, "0x%lx", flags);
  257. }
  258. trace_seq_putc(p, 0);
  259. return ret;
  260. }
  261. EXPORT_SYMBOL(ftrace_print_flags_seq);
  262. const char *
  263. ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
  264. const struct trace_print_flags *symbol_array)
  265. {
  266. int i;
  267. const char *ret = p->buffer + p->len;
  268. for (i = 0; symbol_array[i].name; i++) {
  269. if (val != symbol_array[i].mask)
  270. continue;
  271. trace_seq_puts(p, symbol_array[i].name);
  272. break;
  273. }
  274. if (ret == (const char *)(p->buffer + p->len))
  275. trace_seq_printf(p, "0x%lx", val);
  276. trace_seq_putc(p, 0);
  277. return ret;
  278. }
  279. EXPORT_SYMBOL(ftrace_print_symbols_seq);
  280. #if BITS_PER_LONG == 32
  281. const char *
  282. ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
  283. const struct trace_print_flags_u64 *symbol_array)
  284. {
  285. int i;
  286. const char *ret = p->buffer + p->len;
  287. for (i = 0; symbol_array[i].name; i++) {
  288. if (val != symbol_array[i].mask)
  289. continue;
  290. trace_seq_puts(p, symbol_array[i].name);
  291. break;
  292. }
  293. if (ret == (const char *)(p->buffer + p->len))
  294. trace_seq_printf(p, "0x%llx", val);
  295. trace_seq_putc(p, 0);
  296. return ret;
  297. }
  298. EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
  299. #endif
  300. const char *
  301. ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
  302. {
  303. int i;
  304. const char *ret = p->buffer + p->len;
  305. for (i = 0; i < buf_len; i++)
  306. trace_seq_printf(p, "%s%2.2x", i == 0 ? "" : " ", buf[i]);
  307. trace_seq_putc(p, 0);
  308. return ret;
  309. }
  310. EXPORT_SYMBOL(ftrace_print_hex_seq);
  311. int ftrace_raw_output_prep(struct trace_iterator *iter,
  312. struct trace_event *trace_event)
  313. {
  314. struct ftrace_event_call *event;
  315. struct trace_seq *s = &iter->seq;
  316. struct trace_seq *p = &iter->tmp_seq;
  317. struct trace_entry *entry;
  318. int ret;
  319. event = container_of(trace_event, struct ftrace_event_call, event);
  320. entry = iter->ent;
  321. if (entry->type != event->event.type) {
  322. WARN_ON_ONCE(1);
  323. return TRACE_TYPE_UNHANDLED;
  324. }
  325. trace_seq_init(p);
  326. ret = trace_seq_printf(s, "%s: ", event->name);
  327. if (!ret)
  328. return TRACE_TYPE_PARTIAL_LINE;
  329. return 0;
  330. }
  331. EXPORT_SYMBOL(ftrace_raw_output_prep);
  332. #ifdef CONFIG_KRETPROBES
  333. static inline const char *kretprobed(const char *name)
  334. {
  335. static const char tramp_name[] = "kretprobe_trampoline";
  336. int size = sizeof(tramp_name);
  337. if (strncmp(tramp_name, name, size) == 0)
  338. return "[unknown/kretprobe'd]";
  339. return name;
  340. }
  341. #else
  342. static inline const char *kretprobed(const char *name)
  343. {
  344. return name;
  345. }
  346. #endif /* CONFIG_KRETPROBES */
  347. static int
  348. seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
  349. {
  350. #ifdef CONFIG_KALLSYMS
  351. char str[KSYM_SYMBOL_LEN];
  352. const char *name;
  353. kallsyms_lookup(address, NULL, NULL, NULL, str);
  354. name = kretprobed(str);
  355. return trace_seq_printf(s, fmt, name);
  356. #endif
  357. return 1;
  358. }
  359. static int
  360. seq_print_sym_offset(struct trace_seq *s, const char *fmt,
  361. unsigned long address)
  362. {
  363. #ifdef CONFIG_KALLSYMS
  364. char str[KSYM_SYMBOL_LEN];
  365. const char *name;
  366. sprint_symbol(str, address);
  367. name = kretprobed(str);
  368. return trace_seq_printf(s, fmt, name);
  369. #endif
  370. return 1;
  371. }
  372. #ifndef CONFIG_64BIT
  373. # define IP_FMT "%08lx"
  374. #else
  375. # define IP_FMT "%016lx"
  376. #endif
  377. int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
  378. unsigned long ip, unsigned long sym_flags)
  379. {
  380. struct file *file = NULL;
  381. unsigned long vmstart = 0;
  382. int ret = 1;
  383. if (s->full)
  384. return 0;
  385. if (mm) {
  386. const struct vm_area_struct *vma;
  387. down_read(&mm->mmap_sem);
  388. vma = find_vma(mm, ip);
  389. if (vma) {
  390. file = vma->vm_file;
  391. vmstart = vma->vm_start;
  392. }
  393. if (file) {
  394. ret = trace_seq_path(s, &file->f_path);
  395. if (ret)
  396. ret = trace_seq_printf(s, "[+0x%lx]",
  397. ip - vmstart);
  398. }
  399. up_read(&mm->mmap_sem);
  400. }
  401. if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
  402. ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
  403. return ret;
  404. }
  405. int
  406. seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
  407. unsigned long sym_flags)
  408. {
  409. struct mm_struct *mm = NULL;
  410. int ret = 1;
  411. unsigned int i;
  412. if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
  413. struct task_struct *task;
  414. /*
  415. * we do the lookup on the thread group leader,
  416. * since individual threads might have already quit!
  417. */
  418. rcu_read_lock();
  419. task = find_task_by_vpid(entry->tgid);
  420. if (task)
  421. mm = get_task_mm(task);
  422. rcu_read_unlock();
  423. }
  424. for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
  425. unsigned long ip = entry->caller[i];
  426. if (ip == ULONG_MAX || !ret)
  427. break;
  428. if (ret)
  429. ret = trace_seq_puts(s, " => ");
  430. if (!ip) {
  431. if (ret)
  432. ret = trace_seq_puts(s, "??");
  433. if (ret)
  434. ret = trace_seq_puts(s, "\n");
  435. continue;
  436. }
  437. if (!ret)
  438. break;
  439. if (ret)
  440. ret = seq_print_user_ip(s, mm, ip, sym_flags);
  441. ret = trace_seq_puts(s, "\n");
  442. }
  443. if (mm)
  444. mmput(mm);
  445. return ret;
  446. }
  447. int
  448. seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
  449. {
  450. int ret;
  451. if (!ip)
  452. return trace_seq_printf(s, "0");
  453. if (sym_flags & TRACE_ITER_SYM_OFFSET)
  454. ret = seq_print_sym_offset(s, "%s", ip);
  455. else
  456. ret = seq_print_sym_short(s, "%s", ip);
  457. if (!ret)
  458. return 0;
  459. if (sym_flags & TRACE_ITER_SYM_ADDR)
  460. ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
  461. return ret;
  462. }
  463. /**
  464. * trace_print_lat_fmt - print the irq, preempt and lockdep fields
  465. * @s: trace seq struct to write to
  466. * @entry: The trace entry field from the ring buffer
  467. *
  468. * Prints the generic fields of irqs off, in hard or softirq, preempt
  469. * count.
  470. */
  471. int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
  472. {
  473. char hardsoft_irq;
  474. char need_resched;
  475. char irqs_off;
  476. int hardirq;
  477. int softirq;
  478. int ret;
  479. hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
  480. softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
  481. irqs_off =
  482. (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
  483. (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' :
  484. '.';
  485. need_resched =
  486. (entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.';
  487. hardsoft_irq =
  488. (hardirq && softirq) ? 'H' :
  489. hardirq ? 'h' :
  490. softirq ? 's' :
  491. '.';
  492. if (!trace_seq_printf(s, "%c%c%c",
  493. irqs_off, need_resched, hardsoft_irq))
  494. return 0;
  495. if (entry->preempt_count)
  496. ret = trace_seq_printf(s, "%x", entry->preempt_count);
  497. else
  498. ret = trace_seq_putc(s, '.');
  499. return ret;
  500. }
  501. static int
  502. lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
  503. {
  504. char comm[TASK_COMM_LEN];
  505. trace_find_cmdline(entry->pid, comm);
  506. if (!trace_seq_printf(s, "%8.8s-%-5d %3d",
  507. comm, entry->pid, cpu))
  508. return 0;
  509. return trace_print_lat_fmt(s, entry);
  510. }
  511. static unsigned long preempt_mark_thresh_us = 100;
  512. static int
  513. lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
  514. {
  515. unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE;
  516. unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
  517. unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start;
  518. unsigned long long rel_ts = next_ts - iter->ts;
  519. struct trace_seq *s = &iter->seq;
  520. if (in_ns) {
  521. abs_ts = ns2usecs(abs_ts);
  522. rel_ts = ns2usecs(rel_ts);
  523. }
  524. if (verbose && in_ns) {
  525. unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC);
  526. unsigned long abs_msec = (unsigned long)abs_ts;
  527. unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);
  528. unsigned long rel_msec = (unsigned long)rel_ts;
  529. return trace_seq_printf(
  530. s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
  531. ns2usecs(iter->ts),
  532. abs_msec, abs_usec,
  533. rel_msec, rel_usec);
  534. } else if (verbose && !in_ns) {
  535. return trace_seq_printf(
  536. s, "[%016llx] %lld (+%lld): ",
  537. iter->ts, abs_ts, rel_ts);
  538. } else if (!verbose && in_ns) {
  539. return trace_seq_printf(
  540. s, " %4lldus%c: ",
  541. abs_ts,
  542. rel_ts > preempt_mark_thresh_us ? '!' :
  543. rel_ts > 1 ? '+' : ' ');
  544. } else { /* !verbose && !in_ns */
  545. return trace_seq_printf(s, " %4lld: ", abs_ts);
  546. }
  547. }
  548. int trace_print_context(struct trace_iterator *iter)
  549. {
  550. struct trace_seq *s = &iter->seq;
  551. struct trace_entry *entry = iter->ent;
  552. unsigned long long t;
  553. unsigned long secs, usec_rem;
  554. char comm[TASK_COMM_LEN];
  555. int ret;
  556. trace_find_cmdline(entry->pid, comm);
  557. ret = trace_seq_printf(s, "%16s-%-5d [%03d] ",
  558. comm, entry->pid, iter->cpu);
  559. if (!ret)
  560. return 0;
  561. if (trace_flags & TRACE_ITER_IRQ_INFO) {
  562. ret = trace_print_lat_fmt(s, entry);
  563. if (!ret)
  564. return 0;
  565. }
  566. if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
  567. t = ns2usecs(iter->ts);
  568. usec_rem = do_div(t, USEC_PER_SEC);
  569. secs = (unsigned long)t;
  570. return trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem);
  571. } else
  572. return trace_seq_printf(s, " %12llu: ", iter->ts);
  573. }
  574. int trace_print_lat_context(struct trace_iterator *iter)
  575. {
  576. u64 next_ts;
  577. int ret;
  578. /* trace_find_next_entry will reset ent_size */
  579. int ent_size = iter->ent_size;
  580. struct trace_seq *s = &iter->seq;
  581. struct trace_entry *entry = iter->ent,
  582. *next_entry = trace_find_next_entry(iter, NULL,
  583. &next_ts);
  584. unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
  585. /* Restore the original ent_size */
  586. iter->ent_size = ent_size;
  587. if (!next_entry)
  588. next_ts = iter->ts;
  589. if (verbose) {
  590. char comm[TASK_COMM_LEN];
  591. trace_find_cmdline(entry->pid, comm);
  592. ret = trace_seq_printf(
  593. s, "%16s %5d %3d %d %08x %08lx ",
  594. comm, entry->pid, iter->cpu, entry->flags,
  595. entry->preempt_count, iter->idx);
  596. } else {
  597. ret = lat_print_generic(s, entry, iter->cpu);
  598. }
  599. if (ret)
  600. ret = lat_print_timestamp(iter, next_ts);
  601. return ret;
  602. }
  603. static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
  604. static int task_state_char(unsigned long state)
  605. {
  606. int bit = state ? __ffs(state) + 1 : 0;
  607. return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
  608. }
  609. /**
  610. * ftrace_find_event - find a registered event
  611. * @type: the type of event to look for
  612. *
  613. * Returns an event of type @type otherwise NULL
  614. * Called with trace_event_read_lock() held.
  615. */
  616. struct trace_event *ftrace_find_event(int type)
  617. {
  618. struct trace_event *event;
  619. struct hlist_node *n;
  620. unsigned key;
  621. key = type & (EVENT_HASHSIZE - 1);
  622. hlist_for_each_entry(event, n, &event_hash[key], node) {
  623. if (event->type == type)
  624. return event;
  625. }
  626. return NULL;
  627. }
  628. static LIST_HEAD(ftrace_event_list);
  629. static int trace_search_list(struct list_head **list)
  630. {
  631. struct trace_event *e;
  632. int last = __TRACE_LAST_TYPE;
  633. if (list_empty(&ftrace_event_list)) {
  634. *list = &ftrace_event_list;
  635. return last + 1;
  636. }
  637. /*
  638. * We used up all possible max events,
  639. * lets see if somebody freed one.
  640. */
  641. list_for_each_entry(e, &ftrace_event_list, list) {
  642. if (e->type != last + 1)
  643. break;
  644. last++;
  645. }
  646. /* Did we used up all 65 thousand events??? */
  647. if ((last + 1) > FTRACE_MAX_EVENT)
  648. return 0;
  649. *list = &e->list;
  650. return last + 1;
  651. }
  652. void trace_event_read_lock(void)
  653. {
  654. down_read(&trace_event_mutex);
  655. }
  656. void trace_event_read_unlock(void)
  657. {
  658. up_read(&trace_event_mutex);
  659. }
  660. /**
  661. * register_ftrace_event - register output for an event type
  662. * @event: the event type to register
  663. *
  664. * Event types are stored in a hash and this hash is used to
  665. * find a way to print an event. If the @event->type is set
  666. * then it will use that type, otherwise it will assign a
  667. * type to use.
  668. *
  669. * If you assign your own type, please make sure it is added
  670. * to the trace_type enum in trace.h, to avoid collisions
  671. * with the dynamic types.
  672. *
  673. * Returns the event type number or zero on error.
  674. */
  675. int register_ftrace_event(struct trace_event *event)
  676. {
  677. unsigned key;
  678. int ret = 0;
  679. down_write(&trace_event_mutex);
  680. if (WARN_ON(!event))
  681. goto out;
  682. if (WARN_ON(!event->funcs))
  683. goto out;
  684. INIT_LIST_HEAD(&event->list);
  685. if (!event->type) {
  686. struct list_head *list = NULL;
  687. if (next_event_type > FTRACE_MAX_EVENT) {
  688. event->type = trace_search_list(&list);
  689. if (!event->type)
  690. goto out;
  691. } else {
  692. event->type = next_event_type++;
  693. list = &ftrace_event_list;
  694. }
  695. if (WARN_ON(ftrace_find_event(event->type)))
  696. goto out;
  697. list_add_tail(&event->list, list);
  698. } else if (event->type > __TRACE_LAST_TYPE) {
  699. printk(KERN_WARNING "Need to add type to trace.h\n");
  700. WARN_ON(1);
  701. goto out;
  702. } else {
  703. /* Is this event already used */
  704. if (ftrace_find_event(event->type))
  705. goto out;
  706. }
  707. if (event->funcs->trace == NULL)
  708. event->funcs->trace = trace_nop_print;
  709. if (event->funcs->raw == NULL)
  710. event->funcs->raw = trace_nop_print;
  711. if (event->funcs->hex == NULL)
  712. event->funcs->hex = trace_nop_print;
  713. if (event->funcs->binary == NULL)
  714. event->funcs->binary = trace_nop_print;
  715. key = event->type & (EVENT_HASHSIZE - 1);
  716. hlist_add_head(&event->node, &event_hash[key]);
  717. ret = event->type;
  718. out:
  719. up_write(&trace_event_mutex);
  720. return ret;
  721. }
  722. EXPORT_SYMBOL_GPL(register_ftrace_event);
  723. /*
  724. * Used by module code with the trace_event_mutex held for write.
  725. */
  726. int __unregister_ftrace_event(struct trace_event *event)
  727. {
  728. hlist_del(&event->node);
  729. list_del(&event->list);
  730. return 0;
  731. }
  732. /**
  733. * unregister_ftrace_event - remove a no longer used event
  734. * @event: the event to remove
  735. */
  736. int unregister_ftrace_event(struct trace_event *event)
  737. {
  738. down_write(&trace_event_mutex);
  739. __unregister_ftrace_event(event);
  740. up_write(&trace_event_mutex);
  741. return 0;
  742. }
  743. EXPORT_SYMBOL_GPL(unregister_ftrace_event);
  744. /*
  745. * Standard events
  746. */
  747. enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,
  748. struct trace_event *event)
  749. {
  750. if (!trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type))
  751. return TRACE_TYPE_PARTIAL_LINE;
  752. return TRACE_TYPE_HANDLED;
  753. }
  754. /* TRACE_FN */
  755. static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
  756. struct trace_event *event)
  757. {
  758. struct ftrace_entry *field;
  759. struct trace_seq *s = &iter->seq;
  760. trace_assign_type(field, iter->ent);
  761. if (!seq_print_ip_sym(s, field->ip, flags))
  762. goto partial;
  763. if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
  764. if (!trace_seq_printf(s, " <-"))
  765. goto partial;
  766. if (!seq_print_ip_sym(s,
  767. field->parent_ip,
  768. flags))
  769. goto partial;
  770. }
  771. if (!trace_seq_printf(s, "\n"))
  772. goto partial;
  773. return TRACE_TYPE_HANDLED;
  774. partial:
  775. return TRACE_TYPE_PARTIAL_LINE;
  776. }
  777. static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
  778. struct trace_event *event)
  779. {
  780. struct ftrace_entry *field;
  781. trace_assign_type(field, iter->ent);
  782. if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
  783. field->ip,
  784. field->parent_ip))
  785. return TRACE_TYPE_PARTIAL_LINE;
  786. return TRACE_TYPE_HANDLED;
  787. }
  788. static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
  789. struct trace_event *event)
  790. {
  791. struct ftrace_entry *field;
  792. struct trace_seq *s = &iter->seq;
  793. trace_assign_type(field, iter->ent);
  794. SEQ_PUT_HEX_FIELD_RET(s, field->ip);
  795. SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
  796. return TRACE_TYPE_HANDLED;
  797. }
  798. static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
  799. struct trace_event *event)
  800. {
  801. struct ftrace_entry *field;
  802. struct trace_seq *s = &iter->seq;
  803. trace_assign_type(field, iter->ent);
  804. SEQ_PUT_FIELD_RET(s, field->ip);
  805. SEQ_PUT_FIELD_RET(s, field->parent_ip);
  806. return TRACE_TYPE_HANDLED;
  807. }
  808. static struct trace_event_functions trace_fn_funcs = {
  809. .trace = trace_fn_trace,
  810. .raw = trace_fn_raw,
  811. .hex = trace_fn_hex,
  812. .binary = trace_fn_bin,
  813. };
  814. static struct trace_event trace_fn_event = {
  815. .type = TRACE_FN,
  816. .funcs = &trace_fn_funcs,
  817. };
  818. /* TRACE_CTX an TRACE_WAKE */
  819. static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
  820. char *delim)
  821. {
  822. struct ctx_switch_entry *field;
  823. char comm[TASK_COMM_LEN];
  824. int S, T;
  825. trace_assign_type(field, iter->ent);
  826. T = task_state_char(field->next_state);
  827. S = task_state_char(field->prev_state);
  828. trace_find_cmdline(field->next_pid, comm);
  829. if (!trace_seq_printf(&iter->seq,
  830. " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
  831. field->prev_pid,
  832. field->prev_prio,
  833. S, delim,
  834. field->next_cpu,
  835. field->next_pid,
  836. field->next_prio,
  837. T, comm))
  838. return TRACE_TYPE_PARTIAL_LINE;
  839. return TRACE_TYPE_HANDLED;
  840. }
  841. static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,
  842. struct trace_event *event)
  843. {
  844. return trace_ctxwake_print(iter, "==>");
  845. }
  846. static enum print_line_t trace_wake_print(struct trace_iterator *iter,
  847. int flags, struct trace_event *event)
  848. {
  849. return trace_ctxwake_print(iter, " +");
  850. }
  851. static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
  852. {
  853. struct ctx_switch_entry *field;
  854. int T;
  855. trace_assign_type(field, iter->ent);
  856. if (!S)
  857. S = task_state_char(field->prev_state);
  858. T = task_state_char(field->next_state);
  859. if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
  860. field->prev_pid,
  861. field->prev_prio,
  862. S,
  863. field->next_cpu,
  864. field->next_pid,
  865. field->next_prio,
  866. T))
  867. return TRACE_TYPE_PARTIAL_LINE;
  868. return TRACE_TYPE_HANDLED;
  869. }
  870. static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,
  871. struct trace_event *event)
  872. {
  873. return trace_ctxwake_raw(iter, 0);
  874. }
  875. static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags,
  876. struct trace_event *event)
  877. {
  878. return trace_ctxwake_raw(iter, '+');
  879. }
  880. static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
  881. {
  882. struct ctx_switch_entry *field;
  883. struct trace_seq *s = &iter->seq;
  884. int T;
  885. trace_assign_type(field, iter->ent);
  886. if (!S)
  887. S = task_state_char(field->prev_state);
  888. T = task_state_char(field->next_state);
  889. SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
  890. SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
  891. SEQ_PUT_HEX_FIELD_RET(s, S);
  892. SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
  893. SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
  894. SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
  895. SEQ_PUT_HEX_FIELD_RET(s, T);
  896. return TRACE_TYPE_HANDLED;
  897. }
  898. static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,
  899. struct trace_event *event)
  900. {
  901. return trace_ctxwake_hex(iter, 0);
  902. }
  903. static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags,
  904. struct trace_event *event)
  905. {
  906. return trace_ctxwake_hex(iter, '+');
  907. }
  908. static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
  909. int flags, struct trace_event *event)
  910. {
  911. struct ctx_switch_entry *field;
  912. struct trace_seq *s = &iter->seq;
  913. trace_assign_type(field, iter->ent);
  914. SEQ_PUT_FIELD_RET(s, field->prev_pid);
  915. SEQ_PUT_FIELD_RET(s, field->prev_prio);
  916. SEQ_PUT_FIELD_RET(s, field->prev_state);
  917. SEQ_PUT_FIELD_RET(s, field->next_pid);
  918. SEQ_PUT_FIELD_RET(s, field->next_prio);
  919. SEQ_PUT_FIELD_RET(s, field->next_state);
  920. return TRACE_TYPE_HANDLED;
  921. }
  922. static struct trace_event_functions trace_ctx_funcs = {
  923. .trace = trace_ctx_print,
  924. .raw = trace_ctx_raw,
  925. .hex = trace_ctx_hex,
  926. .binary = trace_ctxwake_bin,
  927. };
  928. static struct trace_event trace_ctx_event = {
  929. .type = TRACE_CTX,
  930. .funcs = &trace_ctx_funcs,
  931. };
  932. static struct trace_event_functions trace_wake_funcs = {
  933. .trace = trace_wake_print,
  934. .raw = trace_wake_raw,
  935. .hex = trace_wake_hex,
  936. .binary = trace_ctxwake_bin,
  937. };
  938. static struct trace_event trace_wake_event = {
  939. .type = TRACE_WAKE,
  940. .funcs = &trace_wake_funcs,
  941. };
  942. /* TRACE_STACK */
  943. static enum print_line_t trace_stack_print(struct trace_iterator *iter,
  944. int flags, struct trace_event *event)
  945. {
  946. struct stack_entry *field;
  947. struct trace_seq *s = &iter->seq;
  948. unsigned long *p;
  949. unsigned long *end;
  950. trace_assign_type(field, iter->ent);
  951. end = (unsigned long *)((long)iter->ent + iter->ent_size);
  952. if (!trace_seq_puts(s, "<stack trace>\n"))
  953. goto partial;
  954. for (p = field->caller; p && *p != ULONG_MAX && p < end; p++) {
  955. if (!trace_seq_puts(s, " => "))
  956. goto partial;
  957. if (!seq_print_ip_sym(s, *p, flags))
  958. goto partial;
  959. if (!trace_seq_puts(s, "\n"))
  960. goto partial;
  961. }
  962. return TRACE_TYPE_HANDLED;
  963. partial:
  964. return TRACE_TYPE_PARTIAL_LINE;
  965. }
  966. static struct trace_event_functions trace_stack_funcs = {
  967. .trace = trace_stack_print,
  968. };
  969. static struct trace_event trace_stack_event = {
  970. .type = TRACE_STACK,
  971. .funcs = &trace_stack_funcs,
  972. };
  973. /* TRACE_USER_STACK */
  974. static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
  975. int flags, struct trace_event *event)
  976. {
  977. struct userstack_entry *field;
  978. struct trace_seq *s = &iter->seq;
  979. trace_assign_type(field, iter->ent);
  980. if (!trace_seq_puts(s, "<user stack trace>\n"))
  981. goto partial;
  982. if (!seq_print_userip_objs(field, s, flags))
  983. goto partial;
  984. return TRACE_TYPE_HANDLED;
  985. partial:
  986. return TRACE_TYPE_PARTIAL_LINE;
  987. }
  988. static struct trace_event_functions trace_user_stack_funcs = {
  989. .trace = trace_user_stack_print,
  990. };
  991. static struct trace_event trace_user_stack_event = {
  992. .type = TRACE_USER_STACK,
  993. .funcs = &trace_user_stack_funcs,
  994. };
  995. /* TRACE_BPRINT */
  996. static enum print_line_t
  997. trace_bprint_print(struct trace_iterator *iter, int flags,
  998. struct trace_event *event)
  999. {
  1000. struct trace_entry *entry = iter->ent;
  1001. struct trace_seq *s = &iter->seq;
  1002. struct bprint_entry *field;
  1003. trace_assign_type(field, entry);
  1004. if (!seq_print_ip_sym(s, field->ip, flags))
  1005. goto partial;
  1006. if (!trace_seq_puts(s, ": "))
  1007. goto partial;
  1008. if (!trace_seq_bprintf(s, field->fmt, field->buf))
  1009. goto partial;
  1010. return TRACE_TYPE_HANDLED;
  1011. partial:
  1012. return TRACE_TYPE_PARTIAL_LINE;
  1013. }
  1014. static enum print_line_t
  1015. trace_bprint_raw(struct trace_iterator *iter, int flags,
  1016. struct trace_event *event)
  1017. {
  1018. struct bprint_entry *field;
  1019. struct trace_seq *s = &iter->seq;
  1020. trace_assign_type(field, iter->ent);
  1021. if (!trace_seq_printf(s, ": %lx : ", field->ip))
  1022. goto partial;
  1023. if (!trace_seq_bprintf(s, field->fmt, field->buf))
  1024. goto partial;
  1025. return TRACE_TYPE_HANDLED;
  1026. partial:
  1027. return TRACE_TYPE_PARTIAL_LINE;
  1028. }
  1029. static struct trace_event_functions trace_bprint_funcs = {
  1030. .trace = trace_bprint_print,
  1031. .raw = trace_bprint_raw,
  1032. };
  1033. static struct trace_event trace_bprint_event = {
  1034. .type = TRACE_BPRINT,
  1035. .funcs = &trace_bprint_funcs,
  1036. };
  1037. /* TRACE_PRINT */
  1038. static enum print_line_t trace_print_print(struct trace_iterator *iter,
  1039. int flags, struct trace_event *event)
  1040. {
  1041. struct print_entry *field;
  1042. struct trace_seq *s = &iter->seq;
  1043. trace_assign_type(field, iter->ent);
  1044. if (!seq_print_ip_sym(s, field->ip, flags))
  1045. goto partial;
  1046. if (!trace_seq_printf(s, ": %s", field->buf))
  1047. goto partial;
  1048. return TRACE_TYPE_HANDLED;
  1049. partial:
  1050. return TRACE_TYPE_PARTIAL_LINE;
  1051. }
  1052. static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
  1053. struct trace_event *event)
  1054. {
  1055. struct print_entry *field;
  1056. trace_assign_type(field, iter->ent);
  1057. if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
  1058. goto partial;
  1059. return TRACE_TYPE_HANDLED;
  1060. partial:
  1061. return TRACE_TYPE_PARTIAL_LINE;
  1062. }
  1063. static struct trace_event_functions trace_print_funcs = {
  1064. .trace = trace_print_print,
  1065. .raw = trace_print_raw,
  1066. };
  1067. static struct trace_event trace_print_event = {
  1068. .type = TRACE_PRINT,
  1069. .funcs = &trace_print_funcs,
  1070. };
  1071. static struct trace_event *events[] __initdata = {
  1072. &trace_fn_event,
  1073. &trace_ctx_event,
  1074. &trace_wake_event,
  1075. &trace_stack_event,
  1076. &trace_user_stack_event,
  1077. &trace_bprint_event,
  1078. &trace_print_event,
  1079. NULL
  1080. };
  1081. __init static int init_events(void)
  1082. {
  1083. struct trace_event *event;
  1084. int i, ret;
  1085. for (i = 0; events[i]; i++) {
  1086. event = events[i];
  1087. ret = register_ftrace_event(event);
  1088. if (!ret) {
  1089. printk(KERN_WARNING "event %d failed to register\n",
  1090. event->type);
  1091. WARN_ON_ONCE(1);
  1092. }
  1093. }
  1094. return 0;
  1095. }
  1096. early_initcall(init_events);