1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2021, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2023 Rockchip Electronics Co., Ltd.
5 */
6
7 #include <linux/mm.h>
8 #include <linux/swap.h>
9 #include <linux/mman.h>
10 #include <linux/seq_buf.h>
11 #include <linux/vmalloc.h>
12 #include <linux/android_debug_symbols.h>
13 #include <linux/cma.h>
14 #include <linux/slab.h>
15 #include <linux/page_ext.h>
16 #include <linux/page_owner.h>
17 #include <linux/debugfs.h>
18 #include <linux/ctype.h>
19 #include <soc/rockchip/rk_minidump.h>
20 #include <linux/dma-map-ops.h>
21 #include <linux/jhash.h>
22 #include <linux/dma-buf.h>
23 #include <linux/dma-resv.h>
24 #include <linux/fdtable.h>
25 #include "minidump_memory.h"
26 #include "minidump_private.h"
27 #include "../../../mm/slab.h"
28 #include "../mm/internal.h"
29
30 #define DMA_BUF_HASH_SIZE (1 << 20)
31 #define DMA_BUF_HASH_SEED 0x9747b28c
32 static bool dma_buf_hash[DMA_BUF_HASH_SIZE];
33
34 struct priv_buf {
35 char *buf;
36 size_t size;
37 size_t offset;
38 };
39
40 struct dma_buf_priv {
41 struct priv_buf *priv_buf;
42 struct task_struct *task;
43 int count;
44 size_t size;
45 };
46
show_val_kb(struct seq_buf * m,const char * s,unsigned long num)47 static void show_val_kb(struct seq_buf *m, const char *s, unsigned long num)
48 {
49 seq_buf_printf(m, "%s : %lu KB\n", s, num << (PAGE_SHIFT - 10));
50 }
51
md_dump_meminfo(struct seq_buf * m)52 void md_dump_meminfo(struct seq_buf *m)
53 {
54 struct sysinfo i;
55 long cached;
56 long available;
57 unsigned long pages[NR_LRU_LISTS];
58 unsigned long sreclaimable, sunreclaim;
59 int lru;
60 unsigned long *addr;
61
62 si_meminfo(&i);
63 si_swapinfo(&i);
64
65 cached = global_node_page_state(NR_FILE_PAGES) -
66 total_swapcache_pages() - i.bufferram;
67 if (cached < 0)
68 cached = 0;
69
70 for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)
71 pages[lru] = global_node_page_state(NR_LRU_BASE + lru);
72
73 available = si_mem_available();
74 sreclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B);
75 sunreclaim = global_node_page_state_pages(NR_SLAB_UNRECLAIMABLE_B);
76
77 show_val_kb(m, "MemTotal: ", i.totalram);
78 show_val_kb(m, "MemFree: ", i.freeram);
79 show_val_kb(m, "MemAvailable: ", available);
80 show_val_kb(m, "Buffers: ", i.bufferram);
81 show_val_kb(m, "Cached: ", cached);
82 show_val_kb(m, "SwapCached: ", total_swapcache_pages());
83 show_val_kb(m, "Active: ", pages[LRU_ACTIVE_ANON] +
84 pages[LRU_ACTIVE_FILE]);
85 show_val_kb(m, "Inactive: ", pages[LRU_INACTIVE_ANON] +
86 pages[LRU_INACTIVE_FILE]);
87 show_val_kb(m, "Active(anon): ", pages[LRU_ACTIVE_ANON]);
88 show_val_kb(m, "Inactive(anon): ", pages[LRU_INACTIVE_ANON]);
89 show_val_kb(m, "Active(file): ", pages[LRU_ACTIVE_FILE]);
90 show_val_kb(m, "Inactive(file): ", pages[LRU_INACTIVE_FILE]);
91 show_val_kb(m, "Unevictable: ", pages[LRU_UNEVICTABLE]);
92 show_val_kb(m, "Mlocked: ", global_zone_page_state(NR_MLOCK));
93
94 #ifdef CONFIG_HIGHMEM
95 show_val_kb(m, "HighTotal: ", i.totalhigh);
96 show_val_kb(m, "HighFree: ", i.freehigh);
97 show_val_kb(m, "LowTotal: ", i.totalram - i.totalhigh);
98 show_val_kb(m, "LowFree: ", i.freeram - i.freehigh);
99 #endif
100
101 show_val_kb(m, "SwapTotal: ", i.totalswap);
102 show_val_kb(m, "SwapFree: ", i.freeswap);
103 show_val_kb(m, "Dirty: ",
104 global_node_page_state(NR_FILE_DIRTY));
105 show_val_kb(m, "Writeback: ",
106 global_node_page_state(NR_WRITEBACK));
107 show_val_kb(m, "AnonPages: ",
108 global_node_page_state(NR_ANON_MAPPED));
109 show_val_kb(m, "Mapped: ",
110 global_node_page_state(NR_FILE_MAPPED));
111 show_val_kb(m, "Shmem: ", i.sharedram);
112 show_val_kb(m, "KReclaimable: ", sreclaimable +
113 global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE));
114 show_val_kb(m, "Slab: ", sreclaimable + sunreclaim);
115 show_val_kb(m, "SReclaimable: ", sreclaimable);
116 show_val_kb(m, "SUnreclaim: ", sunreclaim);
117 seq_buf_printf(m, "KernelStack: %8lu kB\n",
118 global_node_page_state(NR_KERNEL_STACK_KB));
119 #ifdef CONFIG_SHADOW_CALL_STACK
120 seq_buf_printf(m, "ShadowCallStack:%8lu kB\n",
121 global_node_page_state(NR_KERNEL_SCS_KB));
122 #endif
123 show_val_kb(m, "PageTables: ",
124 global_zone_page_state(NR_PAGETABLE));
125 show_val_kb(m, "Bounce: ",
126 global_zone_page_state(NR_BOUNCE));
127 show_val_kb(m, "WritebackTmp: ",
128 global_node_page_state(NR_WRITEBACK_TEMP));
129 seq_buf_printf(m, "VmallocTotal: %8lu kB\n",
130 (unsigned long)VMALLOC_TOTAL >> 10);
131 show_val_kb(m, "Percpu: ", pcpu_nr_pages());
132
133 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
134 show_val_kb(m, "AnonHugePages: ",
135 global_node_page_state(NR_ANON_THPS) * HPAGE_PMD_NR);
136 show_val_kb(m, "ShmemHugePages: ",
137 global_node_page_state(NR_SHMEM_THPS) * HPAGE_PMD_NR);
138 show_val_kb(m, "ShmemPmdMapped: ",
139 global_node_page_state(NR_SHMEM_PMDMAPPED) * HPAGE_PMD_NR);
140 show_val_kb(m, "FileHugePages: ",
141 global_node_page_state(NR_FILE_THPS) * HPAGE_PMD_NR);
142 show_val_kb(m, "FilePmdMapped: ",
143 global_node_page_state(NR_FILE_PMDMAPPED) * HPAGE_PMD_NR);
144 #endif
145
146 #ifdef CONFIG_CMA
147 addr = (unsigned long *)android_debug_symbol(ADS_TOTAL_CMA);
148 show_val_kb(m, "CmaTotal: ", *addr);
149 show_val_kb(m, "CmaFree: ",
150 global_zone_page_state(NR_FREE_CMA_PAGES));
151 #endif
152 rk_md_flush_dcache_area((void *)m->buffer, m->len);
153 }
154
155 #ifdef CONFIG_SLUB_DEBUG
slabinfo_stats(struct seq_buf * m,struct kmem_cache * cachep)156 static void slabinfo_stats(struct seq_buf *m, struct kmem_cache *cachep)
157 {
158 #ifdef CONFIG_DEBUG_SLAB
159 { /* node stats */
160 unsigned long high = cachep->high_mark;
161 unsigned long allocs = cachep->num_allocations;
162 unsigned long grown = cachep->grown;
163 unsigned long reaped = cachep->reaped;
164 unsigned long errors = cachep->errors;
165 unsigned long max_freeable = cachep->max_freeable;
166 unsigned long node_allocs = cachep->node_allocs;
167 unsigned long node_frees = cachep->node_frees;
168 unsigned long overflows = cachep->node_overflow;
169
170 seq_buf_printf(m,
171 " : globalstat %7lu %6lu %5lu %4lu %4lu %4lu %4lu %4lu %4lu",
172 allocs, high, grown,
173 reaped, errors, max_freeable,
174 node_allocs, node_frees, overflows);
175 }
176 /* cpu stats */
177 {
178 unsigned long allochit = atomic_read(&cachep->allochit);
179 unsigned long allocmiss = atomic_read(&cachep->allocmiss);
180 unsigned long freehit = atomic_read(&cachep->freehit);
181 unsigned long freemiss = atomic_read(&cachep->freemiss);
182
183 seq_buf_printf(m,
184 " : cpustat %6lu %6lu %6lu %6lu",
185 allochit, allocmiss, freehit, freemiss);
186 }
187 #endif
188 }
189
md_dump_slabinfo(struct seq_buf * m)190 void md_dump_slabinfo(struct seq_buf *m)
191 {
192 struct kmem_cache *s;
193 struct slabinfo sinfo;
194 struct list_head *slab_caches;
195 struct mutex *slab_mutex;
196
197 slab_caches = (struct list_head *)android_debug_symbol(ADS_SLAB_CACHES);
198 slab_mutex = (struct mutex *) android_debug_symbol(ADS_SLAB_MUTEX);
199
200 /* print_slabinfo_header */
201 seq_buf_printf(m,
202 "# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab>");
203 seq_buf_printf(m,
204 " : tunables <limit> <batchcount> <sharedfactor>");
205 seq_buf_printf(m,
206 " : slabdata <active_slabs> <num_slabs> <sharedavail>");
207 #ifdef CONFIG_DEBUG_SLAB
208 seq_buf_printf(m,
209 " : globalstat <listallocs> <maxobjs> <grown> <reaped> <error> <maxfreeable> <nodeallocs> <remotefrees> <alienoverflow>");
210 seq_buf_printf(m,
211 " : cpustat <allochit> <allocmiss> <freehit> <freemiss>");
212 #endif
213 seq_buf_printf(m, "\n");
214
215 /* Loop through all slabs */
216 mutex_lock(slab_mutex);
217 list_for_each_entry(s, slab_caches, list) {
218 memset(&sinfo, 0, sizeof(sinfo));
219 get_slabinfo(s, &sinfo);
220
221 seq_buf_printf(m, "%-17s %6lu %6lu %6u %4u %4d",
222 s->name, sinfo.active_objs, sinfo.num_objs, s->size,
223 sinfo.objects_per_slab, (1 << sinfo.cache_order));
224
225 seq_buf_printf(m, " : tunables %4u %4u %4u",
226 sinfo.limit, sinfo.batchcount, sinfo.shared);
227 seq_buf_printf(m, " : slabdata %6lu %6lu %6lu",
228 sinfo.active_slabs, sinfo.num_slabs, sinfo.shared_avail);
229 slabinfo_stats(m, s);
230 seq_buf_printf(m, "\n");
231 }
232 mutex_unlock(slab_mutex);
233 }
234 #endif
235
md_register_memory_dump(int size,char * name)236 bool md_register_memory_dump(int size, char *name)
237 {
238 struct md_region md_entry;
239 void *buffer_start;
240 struct page *page;
241 int ret;
242
243 page = cma_alloc(dma_contiguous_default_area, size >> PAGE_SHIFT,
244 0, GFP_KERNEL);
245
246 if (!page) {
247 pr_err("Failed to allocate %s minidump, increase cma size\n",
248 name);
249 return false;
250 }
251
252 buffer_start = page_to_virt(page);
253 strscpy(md_entry.name, name, sizeof(md_entry.name));
254 md_entry.virt_addr = (uintptr_t) buffer_start;
255 md_entry.phys_addr = virt_to_phys(buffer_start);
256 md_entry.size = size;
257 ret = rk_minidump_add_region(&md_entry);
258 if (ret < 0) {
259 cma_release(dma_contiguous_default_area, page, size >> PAGE_SHIFT);
260 pr_err("Failed to add %s entry in Minidump\n", name);
261 return false;
262 }
263 memset(buffer_start, 0, size);
264
265 /* Complete registration before adding entries */
266 smp_mb();
267
268 #ifdef CONFIG_PAGE_OWNER
269 if (!strcmp(name, "PAGEOWNER"))
270 WRITE_ONCE(md_pageowner_dump_addr, buffer_start);
271 #endif
272 #ifdef CONFIG_SLUB_DEBUG
273 if (!strcmp(name, "SLABOWNER"))
274 WRITE_ONCE(md_slabowner_dump_addr, buffer_start);
275 #endif
276 if (!strcmp(name, "DMABUF_INFO"))
277 WRITE_ONCE(md_dma_buf_info_addr, buffer_start);
278 if (!strcmp(name, "DMABUF_PROCS"))
279 WRITE_ONCE(md_dma_buf_procs_addr, buffer_start);
280 return true;
281 }
282
md_unregister_memory_dump(char * name)283 bool md_unregister_memory_dump(char *name)
284 {
285 struct page *page;
286 struct md_region *mdr;
287 struct md_region md_entry;
288
289 mdr = md_get_region(name);
290 if (!mdr) {
291 pr_err("minidump entry for %s not found\n", name);
292 return false;
293 }
294 strscpy(md_entry.name, mdr->name, sizeof(md_entry.name));
295 md_entry.virt_addr = mdr->virt_addr;
296 md_entry.phys_addr = mdr->phys_addr;
297 md_entry.size = mdr->size;
298 page = virt_to_page(mdr->virt_addr);
299
300 if (rk_minidump_remove_region(&md_entry) < 0)
301 return false;
302
303 cma_release(dma_contiguous_default_area, page,
304 (md_entry.size) >> PAGE_SHIFT);
305 return true;
306 }
307
update_dump_size(char * name,size_t size,char ** addr,size_t * dump_size)308 static void update_dump_size(char *name, size_t size, char **addr, size_t *dump_size)
309 {
310 if ((*dump_size) == 0) {
311 if (md_register_memory_dump(size * SZ_1M,
312 name)) {
313 *dump_size = size * SZ_1M;
314 pr_info_ratelimited("%s Minidump set to %zd MB size\n",
315 name, size);
316 }
317 return;
318 }
319 if (md_unregister_memory_dump(name)) {
320 *addr = NULL;
321 if (size == 0) {
322 *dump_size = 0;
323 pr_info_ratelimited("%s Minidump : disabled\n", name);
324 return;
325 }
326 if (md_register_memory_dump(size * SZ_1M,
327 name)) {
328 *dump_size = size * SZ_1M;
329 pr_info_ratelimited("%s Minidump : set to %zd MB\n",
330 name, size);
331 } else if (md_register_memory_dump(*dump_size,
332 name)) {
333 pr_info_ratelimited("%s Minidump : Fallback to %zd MB\n",
334 name, (*dump_size) / SZ_1M);
335 } else {
336 pr_err_ratelimited("%s Minidump : disabled, Can't fallback to %zd MB,\n",
337 name, (*dump_size) / SZ_1M);
338 *dump_size = 0;
339 }
340 } else {
341 pr_err_ratelimited("Failed to unregister %s Minidump\n", name);
342 }
343 }
344
345 #ifdef CONFIG_PAGE_OWNER
346 static unsigned long page_owner_filter = 0xF;
347 static unsigned long page_owner_handles_size = SZ_16K;
348 static int nr_handles;
349 static LIST_HEAD(accounted_call_site_list);
350 static DEFINE_MUTEX(accounted_call_site_lock);
351 struct accounted_call_site {
352 struct list_head list;
353 char name[50];
354 };
355
is_page_owner_enabled(void)356 bool is_page_owner_enabled(void)
357 {
358 return *(bool *)android_debug_symbol(ADS_PAGE_OWNER_ENABLED);
359 }
360
found_stack(depot_stack_handle_t handle,char * dump_addr,char * cur)361 static bool found_stack(depot_stack_handle_t handle,
362 char *dump_addr, char *cur)
363 {
364 int *handles, i;
365
366 handles = (int *) (dump_addr +
367 md_pageowner_dump_size - page_owner_handles_size);
368
369 for (i = 0; i < nr_handles; i++)
370 if (handle == handles[i])
371 return true;
372
373 if ((handles + nr_handles)
374 < (int *)(dump_addr +
375 md_pageowner_dump_size)) {
376 handles[nr_handles] = handle;
377 nr_handles += 1;
378 } else {
379 pr_err_ratelimited("Can't stores handles increase page_owner_handles_size\n");
380 }
381 return false;
382 }
383
check_unaccounted(char * buf,ssize_t count,struct page * page,depot_stack_handle_t handle)384 static bool check_unaccounted(char *buf, ssize_t count,
385 struct page *page, depot_stack_handle_t handle)
386 {
387 int i, ret = 0;
388 unsigned long *entries;
389 unsigned int nr_entries;
390 struct accounted_call_site *call_site;
391
392 if ((page->flags &
393 ((1UL << PG_lru) | (1UL << PG_slab) | (1UL << PG_swapbacked))))
394 return false;
395
396 nr_entries = stack_depot_fetch(handle, &entries);
397 for (i = 0; i < nr_entries; i++) {
398 ret = scnprintf(buf, count, "%pS\n",
399 (void *)entries[i]);
400 if (ret == count - 1)
401 return false;
402
403 mutex_lock(&accounted_call_site_lock);
404 list_for_each_entry(call_site,
405 &accounted_call_site_list, list) {
406 if (strnstr(buf, call_site->name,
407 strlen(buf))) {
408 mutex_unlock(&accounted_call_site_lock);
409 return false;
410 }
411 }
412 mutex_unlock(&accounted_call_site_lock);
413 }
414 return true;
415 }
416
dump_page_owner_md(char * buf,size_t count,unsigned long pfn,struct page * page,depot_stack_handle_t handle)417 static ssize_t dump_page_owner_md(char *buf, size_t count,
418 unsigned long pfn, struct page *page,
419 depot_stack_handle_t handle)
420 {
421 int i, bit, ret = 0;
422 unsigned long *entries;
423 unsigned int nr_entries;
424
425 if (page_owner_filter == 0xF)
426 goto dump;
427
428 for (bit = 1; page_owner_filter >= bit; bit *= 2) {
429 if (page_owner_filter & bit) {
430 switch (bit) {
431 case 0x1:
432 if (check_unaccounted(buf, count, page, handle))
433 goto dump;
434 break;
435 case 0x2:
436 if (page->flags & (1UL << PG_slab))
437 goto dump;
438 break;
439 case 0x4:
440 if (page->flags & (1UL << PG_swapbacked))
441 goto dump;
442 break;
443 case 0x8:
444 if ((page->flags & (1UL << PG_lru)) &&
445 ~(page->flags & (1UL << PG_swapbacked)))
446 goto dump;
447 break;
448 default:
449 break;
450 }
451 }
452 if (bit >= 0x8)
453 return ret;
454 }
455
456 if (bit > page_owner_filter)
457 return ret;
458 dump:
459 nr_entries = stack_depot_fetch(handle, &entries);
460 if ((buf > (md_pageowner_dump_addr +
461 md_pageowner_dump_size - page_owner_handles_size))
462 || !found_stack(handle, md_pageowner_dump_addr, buf)) {
463 ret = scnprintf(buf, count, "%lu %u %u\n",
464 pfn, handle, nr_entries);
465 if (ret == count - 1)
466 goto err;
467
468 for (i = 0; i < nr_entries; i++) {
469 ret += scnprintf(buf + ret, count - ret,
470 "%p\n", (void *)entries[i]);
471 if (ret == count - 1)
472 goto err;
473 }
474 } else {
475 ret = scnprintf(buf, count, "%lu %u %u\n", pfn, handle, 0);
476 }
477 err:
478 return ret;
479 }
480
md_dump_pageowner(char * addr,size_t dump_size)481 void md_dump_pageowner(char *addr, size_t dump_size)
482 {
483 unsigned long pfn;
484 struct page *page;
485 struct page_ext *page_ext;
486 depot_stack_handle_t handle;
487 ssize_t size;
488 unsigned long min_low_pfn, max_pfn;
489
490 min_low_pfn = *(unsigned long *)android_debug_symbol(ADS_MIN_LOW_PFN);
491 max_pfn = *(unsigned long *)android_debug_symbol(ADS_MAX_PFN);
492 page = NULL;
493 pfn = min_low_pfn;
494
495 /* Find a valid PFN or the start of a MAX_ORDER_NR_PAGES area */
496 while (!pfn_valid(pfn) && (pfn & (MAX_ORDER_NR_PAGES - 1)) != 0)
497 pfn++;
498
499 /* Find an allocated page */
500 for (; pfn < max_pfn; pfn++) {
501 /*
502 * If the new page is in a new MAX_ORDER_NR_PAGES area,
503 * validate the area as existing, skip it if not
504 */
505 if ((pfn & (MAX_ORDER_NR_PAGES - 1)) == 0 && !pfn_valid(pfn)) {
506 pfn += MAX_ORDER_NR_PAGES - 1;
507 continue;
508 }
509
510 /* Check for holes within a MAX_ORDER area */
511 if (!pfn_valid_within(pfn))
512 continue;
513
514 page = pfn_to_page(pfn);
515 if (PageBuddy(page)) {
516 unsigned long freepage_order = buddy_order_unsafe(page);
517
518 if (freepage_order < MAX_ORDER)
519 pfn += (1UL << freepage_order) - 1;
520 continue;
521 }
522
523 page_ext = lookup_page_ext(page);
524 if (unlikely(!page_ext))
525 continue;
526
527 /*
528 * Some pages could be missed by concurrent allocation or free,
529 * because we don't hold the zone lock.
530 */
531 if (!test_bit(PAGE_EXT_OWNER, &page_ext->flags))
532 continue;
533
534 /*
535 * Although we do have the info about past allocation of free
536 * pages, it's not relevant for current memory usage.
537 */
538 if (!test_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags))
539 continue;
540
541 handle = get_page_owner_handle(page_ext, pfn);
542 if (!handle)
543 continue;
544
545 size = dump_page_owner_md(addr, dump_size, pfn, page, handle);
546 if (size == dump_size - 1) {
547 pr_err("pageowner minidump region exhausted\n");
548 return;
549 }
550 dump_size -= size;
551 addr += size;
552 }
553 }
554
555 static DEFINE_MUTEX(page_owner_dump_size_lock);
556
page_owner_dump_size_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)557 static ssize_t page_owner_dump_size_write(struct file *file,
558 const char __user *ubuf,
559 size_t count, loff_t *offset)
560 {
561 unsigned long long size;
562
563 if (kstrtoull_from_user(ubuf, count, 0, &size)) {
564 pr_err_ratelimited("Invalid format for size\n");
565 return -EINVAL;
566 }
567 mutex_lock(&page_owner_dump_size_lock);
568 update_dump_size("PAGEOWNER", size,
569 &md_pageowner_dump_addr, &md_pageowner_dump_size);
570 mutex_unlock(&page_owner_dump_size_lock);
571 return count;
572 }
573
page_owner_dump_size_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)574 static ssize_t page_owner_dump_size_read(struct file *file, char __user *ubuf,
575 size_t count, loff_t *offset)
576 {
577 char buf[100];
578
579 snprintf(buf, sizeof(buf), "%llu MB\n",
580 md_pageowner_dump_size / SZ_1M);
581 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
582 }
583
584 static const struct file_operations proc_page_owner_dump_size_ops = {
585 .open = simple_open,
586 .write = page_owner_dump_size_write,
587 .read = page_owner_dump_size_read,
588 };
589
page_owner_filter_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)590 static ssize_t page_owner_filter_write(struct file *file,
591 const char __user *ubuf,
592 size_t count, loff_t *offset)
593 {
594 unsigned long filter;
595
596 if (kstrtoul_from_user(ubuf, count, 0, &filter)) {
597 pr_err_ratelimited("Invalid format for filter\n");
598 return -EINVAL;
599 }
600
601 if (filter & (~0xF)) {
602 pr_err_ratelimited("Invalid filter : use following filters or any combinations of these\n"
603 "0x1 - unaccounted\n"
604 "0x2 - slab\n"
605 "0x4 - Anon\n"
606 "0x8 - File\n");
607 return -EINVAL;
608 }
609 page_owner_filter = filter;
610 return count;
611 }
612
page_owner_filter_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)613 static ssize_t page_owner_filter_read(struct file *file, char __user *ubuf,
614 size_t count, loff_t *offset)
615 {
616 char buf[64];
617
618 snprintf(buf, sizeof(buf), "0x%lx\n", page_owner_filter);
619 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
620 }
621
622 static const struct file_operations proc_page_owner_filter_ops = {
623 .open = simple_open,
624 .write = page_owner_filter_write,
625 .read = page_owner_filter_read,
626 };
627
page_owner_handle_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)628 static ssize_t page_owner_handle_write(struct file *file,
629 const char __user *ubuf,
630 size_t count, loff_t *offset)
631 {
632 unsigned long size;
633
634 if (kstrtoul_from_user(ubuf, count, 0, &size)) {
635 pr_err_ratelimited("Invalid format for handle size\n");
636 return -EINVAL;
637 }
638
639 if (size) {
640 if (size > (md_pageowner_dump_size / SZ_16K)) {
641 pr_err_ratelimited("size : %lu KB exceeds max size : %lu KB\n",
642 size, (md_pageowner_dump_size / SZ_16K));
643 goto err;
644 }
645 page_owner_handles_size = size * SZ_1K;
646 }
647 err:
648 return count;
649 }
650
page_owner_handle_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)651 static ssize_t page_owner_handle_read(struct file *file, char __user *ubuf,
652 size_t count, loff_t *offset)
653 {
654 char buf[64];
655
656 snprintf(buf, sizeof(buf), "%lu KB\n",
657 (page_owner_handles_size / SZ_1K));
658 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
659 }
660
661 static const struct file_operations proc_page_owner_handle_ops = {
662 .open = simple_open,
663 .write = page_owner_handle_write,
664 .read = page_owner_handle_read,
665 };
666
page_owner_call_site_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)667 static ssize_t page_owner_call_site_write(struct file *file,
668 const char __user *ubuf,
669 size_t count, loff_t *offset)
670 {
671 struct accounted_call_site *call_site;
672 char buf[50];
673
674 if (count >= 50) {
675 pr_err_ratelimited("Input string size too large\n");
676 return -EINVAL;
677 }
678
679 memset(buf, 0, 50);
680
681 if (copy_from_user(buf, ubuf, count)) {
682 pr_err_ratelimited("Couldn't copy from user\n");
683 return -EFAULT;
684 }
685
686 if (!isalpha(buf[0]) && buf[0] != '_') {
687 pr_err_ratelimited("Invalid call site name\n");
688 return -EINVAL;
689 }
690
691 call_site = kzalloc(sizeof(*call_site), GFP_KERNEL);
692 if (!call_site)
693 return -ENOMEM;
694
695 strscpy(call_site->name, buf, strlen(call_site->name));
696 mutex_lock(&accounted_call_site_lock);
697 list_add_tail(&call_site->list, &accounted_call_site_list);
698 mutex_unlock(&accounted_call_site_lock);
699
700 return count;
701 }
702
page_owner_call_site_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)703 static ssize_t page_owner_call_site_read(struct file *file, char __user *ubuf,
704 size_t count, loff_t *offset)
705 {
706 char *kbuf;
707 struct accounted_call_site *call_site;
708 int i = 1, ret = 0;
709 size_t size = PAGE_SIZE;
710
711 kbuf = kmalloc(size, GFP_KERNEL);
712 if (!kbuf)
713 return -ENOMEM;
714
715 ret = scnprintf(kbuf, count, "%s\n", "Accounted call sites:");
716 mutex_lock(&accounted_call_site_lock);
717 list_for_each_entry(call_site, &accounted_call_site_list, list) {
718 ret += scnprintf(kbuf + ret, size - ret,
719 "%d. %s\n", i, call_site->name);
720 i += 1;
721 if (ret == size) {
722 ret = -ENOMEM;
723 mutex_unlock(&accounted_call_site_lock);
724 goto err;
725 }
726 }
727 mutex_unlock(&accounted_call_site_lock);
728 ret = simple_read_from_buffer(ubuf, count, offset, kbuf, strlen(kbuf));
729 err:
730 kfree(kbuf);
731 return ret;
732 }
733
734 static const struct file_operations proc_page_owner_call_site_ops = {
735 .open = simple_open,
736 .write = page_owner_call_site_write,
737 .read = page_owner_call_site_read,
738 };
739
md_debugfs_pageowner(struct dentry * minidump_dir)740 void md_debugfs_pageowner(struct dentry *minidump_dir)
741 {
742 debugfs_create_file("page_owner_dump_size_mb", 0400, minidump_dir, NULL,
743 &proc_page_owner_dump_size_ops);
744 debugfs_create_file("page_owner_filter", 0400, minidump_dir, NULL,
745 &proc_page_owner_filter_ops);
746 debugfs_create_file("page_owner_handles_size_kb", 0400, minidump_dir, NULL,
747 &proc_page_owner_handle_ops);
748 debugfs_create_file("page_owner_call_sites", 0400, minidump_dir, NULL,
749 &proc_page_owner_call_site_ops);
750 }
751 #endif
752
753 #ifdef CONFIG_SLUB_DEBUG
754 #define STACK_HASH_SEED 0x9747b28c
755
756 static unsigned long slab_owner_filter;
757 static unsigned long slab_owner_handles_size = SZ_16K;
758 static int num_handles;
759
is_slub_debug_enabled(void)760 bool is_slub_debug_enabled(void)
761 {
762 slab_flags_t slub_debug;
763
764 slub_debug = *(slab_flags_t *)android_debug_symbol(ADS_SLUB_DEBUG);
765 if (slub_debug)
766 return true;
767 return false;
768 }
769
find_stack(u32 handle,char * md_slabowner_dump_addr,char * cur)770 static bool find_stack(u32 handle,
771 char *md_slabowner_dump_addr, char *cur)
772 {
773 int *handles, i;
774
775 handles = (int *) (md_slabowner_dump_addr +
776 md_slabowner_dump_size - slab_owner_handles_size);
777
778 for (i = 0; i < num_handles; i++)
779 if (handle == handles[i])
780 return true;
781
782 if ((handles + num_handles)
783 < (int *)(md_slabowner_dump_addr +
784 md_slabowner_dump_size)) {
785 handles[num_handles] = handle;
786 num_handles += 1;
787 } else {
788 pr_err_ratelimited("Can't stores handles increase slab_owner_handle_size\n");
789 }
790 return false;
791 }
792
793 /* Calculate hash for a stack */
hash_stack(const unsigned long * entries,unsigned int size)794 static u32 hash_stack(const unsigned long *entries, unsigned int size)
795 {
796 return jhash2((u32 *)entries,
797 size * sizeof(unsigned long) / sizeof(u32),
798 STACK_HASH_SEED);
799 }
800
dump_tracking(const struct kmem_cache * s,const void * object,const struct track * t,void * private)801 static int dump_tracking(const struct kmem_cache *s,
802 const void *object,
803 const struct track *t, void *private)
804 {
805 int ret = 0;
806 u32 handle, nr_entries;
807 struct priv_buf *priv_buf;
808 char *buf;
809 size_t size;
810
811 if (!t->addr)
812 return 0;
813
814 priv_buf = (struct priv_buf *)private;
815 buf = priv_buf->buf + priv_buf->offset;
816 size = priv_buf->size - priv_buf->offset;
817 #ifdef CONFIG_STACKTRACE
818 {
819 int i;
820
821 for (i = 0; i < TRACK_ADDRS_COUNT; i++)
822 if (t->addrs[i])
823 continue;
824 else
825 break;
826 nr_entries = i;
827 handle = hash_stack(t->addrs, nr_entries);
828
829 if ((buf > (md_slabowner_dump_addr +
830 md_slabowner_dump_size - slab_owner_handles_size))
831 || !find_stack(handle, md_slabowner_dump_addr, buf)) {
832
833 ret = scnprintf(buf, size, "%p %u %u\n",
834 object, handle, nr_entries);
835 if (ret == size - 1)
836 goto err;
837
838 for (i = 0; i < nr_entries; i++) {
839 ret += scnprintf(buf + ret, size - ret,
840 "%p\n", (void *)t->addrs[i]);
841 if (ret == size - 1)
842 goto err;
843 }
844 } else {
845 ret = scnprintf(buf, size, "%p %u %u\n",
846 object, handle, 0);
847 }
848 }
849 #else
850 ret = scnprintf(buf, size, "%p %p\n", object, (void *)t->addr);
851
852 #endif
853 err:
854 priv_buf->offset += ret;
855 return ret;
856 }
857
md_dump_slabowner(char * m,size_t dump_size)858 void md_dump_slabowner(char *m, size_t dump_size)
859 {
860 struct kmem_cache *s;
861 int node;
862 struct priv_buf buf;
863 struct kmem_cache_node *n;
864 ssize_t ret;
865 int i;
866
867 buf.buf = m;
868 buf.size = dump_size;
869 buf.offset = 0;
870
871 for (i = 0; i <= KMALLOC_SHIFT_HIGH; i++) {
872 if (!test_bit(i, &slab_owner_filter))
873 continue;
874 s = kmalloc_caches[KMALLOC_NORMAL][i];
875 if (!s)
876 continue;
877 ret = scnprintf(buf.buf, buf.size, "%s\n", s->name);
878 if (ret == buf.size - 1)
879 return;
880 buf.buf += ret;
881 for_each_kmem_cache_node(s, node, n) {
882 unsigned long flags;
883 struct page *page;
884
885 if (!atomic_long_read(&n->nr_slabs))
886 continue;
887
888 spin_lock_irqsave(&n->list_lock, flags);
889 list_for_each_entry(page, &n->partial, lru) {
890 ret = get_each_object_track(s, page, TRACK_ALLOC,
891 dump_tracking, &buf);
892 if (buf.offset == buf.size - 1) {
893 spin_unlock_irqrestore(&n->list_lock, flags);
894 pr_err("slabowner minidump region exhausted\n");
895 return;
896 }
897 }
898 list_for_each_entry(page, &n->full, lru) {
899 ret = get_each_object_track(s, page, TRACK_ALLOC,
900 dump_tracking, &buf);
901 if (buf.offset == buf.size - 1) {
902 spin_unlock_irqrestore(&n->list_lock, flags);
903 pr_err("slabowner minidump region exhausted\n");
904 return;
905 }
906 }
907 spin_unlock_irqrestore(&n->list_lock, flags);
908 }
909 ret = scnprintf(buf.buf, buf.size, "\n");
910 if (ret == buf.size - 1)
911 return;
912 buf.buf += ret;
913 }
914 }
915
slab_owner_dump_size_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)916 static ssize_t slab_owner_dump_size_write(struct file *file,
917 const char __user *ubuf,
918 size_t count, loff_t *offset)
919 {
920 unsigned long long size;
921
922 if (kstrtoull_from_user(ubuf, count, 0, &size)) {
923 pr_err_ratelimited("Invalid format for size\n");
924 return -EINVAL;
925 }
926 update_dump_size("SLABOWNER", size,
927 &md_slabowner_dump_addr, &md_slabowner_dump_size);
928 return count;
929 }
930
slab_owner_dump_size_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)931 static ssize_t slab_owner_dump_size_read(struct file *file, char __user *ubuf,
932 size_t count, loff_t *offset)
933 {
934 char buf[100];
935
936 snprintf(buf, sizeof(buf), "%llu MB\n", md_slabowner_dump_size/SZ_1M);
937 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
938 }
939
940 static const struct file_operations proc_slab_owner_dump_size_ops = {
941 .open = simple_open,
942 .write = slab_owner_dump_size_write,
943 .read = slab_owner_dump_size_read,
944 };
945
slab_owner_filter_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)946 static ssize_t slab_owner_filter_write(struct file *file,
947 const char __user *ubuf,
948 size_t count, loff_t *offset)
949 {
950 unsigned long filter;
951 int bit, i;
952 struct kmem_cache *s;
953
954 if (kstrtoul_from_user(ubuf, count, 0, &filter)) {
955 pr_err_ratelimited("Invalid format for filter\n");
956 return -EINVAL;
957 }
958
959 for (i = 0, bit = 1; filter >= bit; bit *= 2, i++) {
960 if (filter & bit) {
961 s = kmalloc_caches[KMALLOC_NORMAL][i];
962 if (!s) {
963 pr_err("Invalid filter : %lx kmalloc-%d doesn't exist\n",
964 filter, bit);
965 return -EINVAL;
966 }
967 }
968 }
969 slab_owner_filter = filter;
970 return count;
971 }
972
slab_owner_filter_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)973 static ssize_t slab_owner_filter_read(struct file *file, char __user *ubuf,
974 size_t count, loff_t *offset)
975 {
976 char buf[64];
977
978 snprintf(buf, sizeof(buf), "0x%lx\n", slab_owner_filter);
979 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
980 }
981
982 static const struct file_operations proc_slab_owner_filter_ops = {
983 .open = simple_open,
984 .write = slab_owner_filter_write,
985 .read = slab_owner_filter_read,
986 };
987
slab_owner_handle_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)988 static ssize_t slab_owner_handle_write(struct file *file,
989 const char __user *ubuf,
990 size_t count, loff_t *offset)
991 {
992 unsigned long size;
993
994 if (kstrtoul_from_user(ubuf, count, 0, &size)) {
995 pr_err_ratelimited("Invalid format for handle size\n");
996 return -EINVAL;
997 }
998
999 if (size) {
1000 if (size > (md_slabowner_dump_size / SZ_16K)) {
1001 pr_err_ratelimited("size : %lu KB exceeds max size : %lu KB\n",
1002 size, (md_slabowner_dump_size / SZ_16K));
1003 goto err;
1004 }
1005 slab_owner_handles_size = size * SZ_1K;
1006 }
1007 err:
1008 return count;
1009 }
1010
slab_owner_handle_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)1011 static ssize_t slab_owner_handle_read(struct file *file, char __user *ubuf,
1012 size_t count, loff_t *offset)
1013 {
1014 char buf[64];
1015
1016 snprintf(buf, sizeof(buf), "%lu KB\n",
1017 (slab_owner_handles_size / SZ_1K));
1018 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
1019 }
1020
1021 static const struct file_operations proc_slab_owner_handle_ops = {
1022 .open = simple_open,
1023 .write = slab_owner_handle_write,
1024 .read = slab_owner_handle_read,
1025 };
1026
md_debugfs_slabowner(struct dentry * minidump_dir)1027 void md_debugfs_slabowner(struct dentry *minidump_dir)
1028 {
1029 int i;
1030
1031 debugfs_create_file("slab_owner_dump_size_mb", 0400, minidump_dir, NULL,
1032 &proc_slab_owner_dump_size_ops);
1033 debugfs_create_file("slab_owner_filter", 0400, minidump_dir, NULL,
1034 &proc_slab_owner_filter_ops);
1035 debugfs_create_file("slab_owner_handles_size_kb", 0400,
1036 minidump_dir, NULL, &proc_slab_owner_handle_ops);
1037 for (i = 0; i <= KMALLOC_SHIFT_HIGH; i++) {
1038 if (kmalloc_caches[KMALLOC_NORMAL][i])
1039 set_bit(i, &slab_owner_filter);
1040 }
1041 }
1042 #endif /* CONFIG_SLUB_DEBUG */
1043
dump_bufinfo(const struct dma_buf * buf_obj,void * private)1044 static int dump_bufinfo(const struct dma_buf *buf_obj, void *private)
1045 {
1046 int ret;
1047 struct dma_buf_attachment *attach_obj;
1048 struct dma_resv *robj;
1049 struct dma_resv_list *fobj;
1050 struct dma_fence *fence;
1051 unsigned int seq;
1052 int attach_count, shared_count, i = 0;
1053 struct dma_buf_priv *buf = (struct dma_buf_priv *)private;
1054 struct priv_buf *priv_buf = buf->priv_buf;
1055
1056
1057 ret = dma_resv_lock(buf_obj->resv, NULL);
1058 if (ret)
1059 goto err;
1060
1061 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1062 priv_buf->size - priv_buf->offset,
1063 "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
1064 buf_obj->size,
1065 buf_obj->file->f_flags, buf_obj->file->f_mode,
1066 file_count(buf_obj->file),
1067 buf_obj->exp_name,
1068 file_inode(buf_obj->file)->i_ino,
1069 buf_obj->name ?: "");
1070 priv_buf->offset += ret;
1071 if (priv_buf->offset == priv_buf->size - 1)
1072 goto err;
1073
1074 robj = buf_obj->resv;
1075 while (true) {
1076 seq = read_seqcount_begin(&robj->seq);
1077 rcu_read_lock();
1078 fobj = rcu_dereference(robj->fence);
1079 shared_count = fobj ? fobj->shared_count : 0;
1080 fence = rcu_dereference(robj->fence_excl);
1081 if (!read_seqcount_retry(&robj->seq, seq))
1082 break;
1083 rcu_read_unlock();
1084 }
1085
1086 if (fence) {
1087 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1088 priv_buf->size - priv_buf->offset,
1089 "\tExclusive fence: %s %s %ssignalled\n",
1090 fence->ops->get_driver_name(fence),
1091 fence->ops->get_timeline_name(fence),
1092 dma_fence_is_signaled(fence) ? "" : "un");
1093 priv_buf->offset += ret;
1094 if (priv_buf->offset == priv_buf->size - 1)
1095 goto err;
1096 }
1097 for (i = 0; i < shared_count; i++) {
1098 fence = rcu_dereference(fobj->shared[i]);
1099 if (!dma_fence_get_rcu(fence))
1100 continue;
1101 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1102 priv_buf->size - priv_buf->offset,
1103 "\tShared fence: %s %s %ssignalled\n",
1104 fence->ops->get_driver_name(fence),
1105 fence->ops->get_timeline_name(fence),
1106 dma_fence_is_signaled(fence) ? "" : "un");
1107 priv_buf->offset += ret;
1108 if (priv_buf->offset == priv_buf->size - 1)
1109 goto err;
1110 dma_fence_put(fence);
1111 }
1112 rcu_read_unlock();
1113
1114 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1115 priv_buf->size - priv_buf->offset,
1116 "\tAttached Devices:\n");
1117 priv_buf->offset += ret;
1118 if (priv_buf->offset == priv_buf->size - 1)
1119 goto err;
1120 attach_count = 0;
1121
1122 list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
1123 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1124 priv_buf->size - priv_buf->offset,
1125 "\t%s\n", dev_name(attach_obj->dev));
1126 priv_buf->offset += ret;
1127 if (priv_buf->offset == priv_buf->size - 1)
1128 goto err;
1129 attach_count++;
1130 }
1131 dma_resv_unlock(buf_obj->resv);
1132
1133 ret = scnprintf(priv_buf->buf + priv_buf->offset,
1134 priv_buf->size - priv_buf->offset,
1135 "Total %d devices attached\n\n",
1136 attach_count);
1137 priv_buf->offset += ret;
1138 if (priv_buf->offset == priv_buf->size - 1)
1139 goto err;
1140
1141 buf->count += 1;
1142 buf->size += buf_obj->size;
1143
1144 return 0;
1145 err:
1146 pr_err("DMABUF_INFO minidump region exhausted\n");
1147 return -ENOSPC;
1148 }
1149
md_dma_buf_info(char * m,size_t dump_size)1150 void md_dma_buf_info(char *m, size_t dump_size)
1151 {
1152 int ret;
1153 struct dma_buf_priv dma_buf_priv;
1154 struct priv_buf buf;
1155
1156 buf.buf = m;
1157 buf.size = dump_size;
1158 buf.offset = 0;
1159 dma_buf_priv.priv_buf = &buf;
1160 dma_buf_priv.count = 0;
1161 dma_buf_priv.size = 0;
1162
1163 ret = scnprintf(buf.buf, buf.size, "\nDma-buf Objects:\n");
1164 ret += scnprintf(buf.buf + ret, buf.size - ret,
1165 "%-8s\t%-8s\t%-8s\t%-8s\texp_name\t%-8s\n",
1166 "size", "flags", "mode", "count", "ino");
1167 buf.offset = ret;
1168
1169 get_each_dmabuf(dump_bufinfo, &dma_buf_priv);
1170
1171 scnprintf(buf.buf + buf.offset, buf.size - buf.offset,
1172 "\nTotal %d objects, %zu bytes\n",
1173 dma_buf_priv.count, dma_buf_priv.size);
1174 rk_md_flush_dcache_area((void *)m, dump_size);
1175 }
1176
dma_buf_info_size_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)1177 static ssize_t dma_buf_info_size_write(struct file *file,
1178 const char __user *ubuf,
1179 size_t count, loff_t *offset)
1180 {
1181 unsigned long long size;
1182
1183 if (kstrtoull_from_user(ubuf, count, 0, &size)) {
1184 pr_err_ratelimited("Invalid format for size\n");
1185 return -EINVAL;
1186 }
1187 update_dump_size("DMABUF_INFO", size,
1188 &md_dma_buf_info_addr, &md_dma_buf_info_size);
1189 return count;
1190 }
1191
dma_buf_info_size_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)1192 static ssize_t dma_buf_info_size_read(struct file *file, char __user *ubuf,
1193 size_t count, loff_t *offset)
1194 {
1195 char buf[100];
1196
1197 snprintf(buf, sizeof(buf), "%zu MB\n", md_dma_buf_info_size / SZ_1M);
1198 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
1199 }
1200
1201 static const struct file_operations proc_dma_buf_info_size_ops = {
1202 .open = simple_open,
1203 .write = dma_buf_info_size_write,
1204 .read = dma_buf_info_size_read,
1205 };
1206
md_debugfs_dmabufinfo(struct dentry * minidump_dir)1207 void md_debugfs_dmabufinfo(struct dentry *minidump_dir)
1208 {
1209 debugfs_create_file("dma_buf_info_size_mb", 0400, minidump_dir, NULL,
1210 &proc_dma_buf_info_size_ops);
1211 }
1212
get_dma_info(const void * data,struct file * file,unsigned int n)1213 static int get_dma_info(const void *data, struct file *file, unsigned int n)
1214 {
1215 struct priv_buf *buf;
1216 struct dma_buf_priv *dma_buf_priv;
1217 struct dma_buf *dmabuf;
1218 struct task_struct *task;
1219 int ret;
1220 u32 index;
1221
1222 if (!is_dma_buf_file(file))
1223 return 0;
1224
1225 dma_buf_priv = (struct dma_buf_priv *)data;
1226 buf = dma_buf_priv->priv_buf;
1227 task = dma_buf_priv->task;
1228 if (dma_buf_priv->count == 0) {
1229 ret = scnprintf(buf->buf + buf->offset, buf->size - buf->offset,
1230 "\n%s (PID %d)\nDMA Buffers:\n",
1231 task->comm, task->tgid);
1232 buf->offset += ret;
1233 if (buf->offset == buf->size - 1)
1234 return -EINVAL;
1235 }
1236 dmabuf = (struct dma_buf *)file->private_data;
1237 index = jhash(dmabuf, sizeof(struct dma_buf), DMA_BUF_HASH_SEED);
1238 index = index & (DMA_BUF_HASH_SIZE - 1);
1239 if (dma_buf_hash[index])
1240 return 0;
1241 dma_buf_hash[index] = true;
1242 dma_buf_priv->count += 1;
1243 ret = scnprintf(buf->buf + buf->offset, buf->size - buf->offset,
1244 "%-8s\t%-8s\t%-8s\t%-8s\texp_name\t%-8s\n",
1245 "size", "flags", "mode", "count", "ino");
1246 buf->offset += ret;
1247 if (buf->offset == buf->size - 1)
1248 return -EINVAL;
1249 ret = scnprintf(buf->buf + buf->offset, buf->size - buf->offset,
1250 "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
1251 dmabuf->size,
1252 dmabuf->file->f_flags, dmabuf->file->f_mode,
1253 file_count(dmabuf->file),
1254 dmabuf->exp_name,
1255 file_inode(dmabuf->file)->i_ino,
1256 dmabuf->name ?: "");
1257 buf->offset += ret;
1258 if (buf->offset == buf->size - 1)
1259 return -EINVAL;
1260 dma_buf_priv->size += dmabuf->size;
1261 return 0;
1262 }
1263
md_dma_buf_procs(char * m,size_t dump_size)1264 void md_dma_buf_procs(char *m, size_t dump_size)
1265 {
1266 struct task_struct *task, *thread;
1267 struct files_struct *files;
1268 int ret = 0;
1269 struct priv_buf buf;
1270 struct dma_buf_priv dma_buf_priv;
1271
1272 buf.buf = m;
1273 buf.size = dump_size;
1274 buf.offset = 0;
1275 dma_buf_priv.priv_buf = &buf;
1276 dma_buf_priv.count = 0;
1277 dma_buf_priv.size = 0;
1278
1279 rcu_read_lock();
1280 for_each_process(task) {
1281 struct files_struct *group_leader_files = NULL;
1282
1283 dma_buf_priv.task = task;
1284 for_each_thread(task, thread) {
1285 task_lock(thread);
1286 if (unlikely(!group_leader_files))
1287 group_leader_files = task->group_leader->files;
1288 files = thread->files;
1289 if (files && (group_leader_files != files ||
1290 thread == task->group_leader))
1291 ret = iterate_fd(files, 0, get_dma_info, &dma_buf_priv);
1292 task_unlock(thread);
1293 if (ret)
1294 goto err;
1295 }
1296 if (dma_buf_priv.count) {
1297 ret = scnprintf(buf.buf + buf.offset, buf.size - buf.offset,
1298 "\nTotal %d objects, %zu bytes\n",
1299 dma_buf_priv.count, dma_buf_priv.size);
1300 buf.offset += ret;
1301 if (buf.offset == buf.size - 1)
1302 goto err;
1303 dma_buf_priv.count = 0;
1304 dma_buf_priv.size = 0;
1305 memset(dma_buf_hash, 0, sizeof(dma_buf_hash));
1306 }
1307 }
1308 rcu_read_unlock();
1309 rk_md_flush_dcache_area((void *)m, dump_size);
1310 return;
1311 err:
1312 rcu_read_unlock();
1313 pr_err("DMABUF_PROCS Minidump region exhausted\n");
1314 }
1315
dma_buf_procs_size_write(struct file * file,const char __user * ubuf,size_t count,loff_t * offset)1316 static ssize_t dma_buf_procs_size_write(struct file *file,
1317 const char __user *ubuf,
1318 size_t count, loff_t *offset)
1319 {
1320 unsigned long long size;
1321
1322 if (kstrtoull_from_user(ubuf, count, 0, &size)) {
1323 pr_err_ratelimited("Invalid format for size\n");
1324 return -EINVAL;
1325 }
1326 update_dump_size("DMABUF_PROCS", size,
1327 &md_dma_buf_procs_addr, &md_dma_buf_procs_size);
1328 return count;
1329 }
1330
dma_buf_procs_size_read(struct file * file,char __user * ubuf,size_t count,loff_t * offset)1331 static ssize_t dma_buf_procs_size_read(struct file *file, char __user *ubuf,
1332 size_t count, loff_t *offset)
1333 {
1334 char buf[100];
1335
1336 snprintf(buf, sizeof(buf), "%zu MB\n", md_dma_buf_procs_size / SZ_1M);
1337 return simple_read_from_buffer(ubuf, count, offset, buf, strlen(buf));
1338 }
1339
1340 static const struct file_operations proc_dma_buf_procs_size_ops = {
1341 .open = simple_open,
1342 .write = dma_buf_procs_size_write,
1343 .read = dma_buf_procs_size_read,
1344 };
1345
md_debugfs_dmabufprocs(struct dentry * minidump_dir)1346 void md_debugfs_dmabufprocs(struct dentry *minidump_dir)
1347 {
1348 debugfs_create_file("dma_buf_procs_size_mb", 0400, minidump_dir, NULL,
1349 &proc_dma_buf_procs_size_ops);
1350 }
1351