~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/tests/code-reading.c

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 #include <errno.h>
  3 #include <linux/kernel.h>
  4 #include <linux/types.h>
  5 #include <inttypes.h>
  6 #include <stdlib.h>
  7 #include <unistd.h>
  8 #include <stdio.h>
  9 #include <string.h>
 10 #include <sys/param.h>
 11 
 12 #include "parse-events.h"
 13 #include "evlist.h"
 14 #include "evsel.h"
 15 #include "thread_map.h"
 16 #include "cpumap.h"
 17 #include "machine.h"
 18 #include "map.h"
 19 #include "symbol.h"
 20 #include "event.h"
 21 #include "thread.h"
 22 
 23 #include "tests.h"
 24 
 25 #include "sane_ctype.h"
 26 
 27 #define BUFSZ   1024
 28 #define READLEN 128
 29 
 30 struct state {
 31         u64 done[1024];
 32         size_t done_cnt;
 33 };
 34 
 35 static unsigned int hex(char c)
 36 {
 37         if (c >= '' && c <= '9')
 38                 return c - '';
 39         if (c >= 'a' && c <= 'f')
 40                 return c - 'a' + 10;
 41         return c - 'A' + 10;
 42 }
 43 
 44 static size_t read_objdump_chunk(const char **line, unsigned char **buf,
 45                                  size_t *buf_len)
 46 {
 47         size_t bytes_read = 0;
 48         unsigned char *chunk_start = *buf;
 49 
 50         /* Read bytes */
 51         while (*buf_len > 0) {
 52                 char c1, c2;
 53 
 54                 /* Get 2 hex digits */
 55                 c1 = *(*line)++;
 56                 if (!isxdigit(c1))
 57                         break;
 58                 c2 = *(*line)++;
 59                 if (!isxdigit(c2))
 60                         break;
 61 
 62                 /* Store byte and advance buf */
 63                 **buf = (hex(c1) << 4) | hex(c2);
 64                 (*buf)++;
 65                 (*buf_len)--;
 66                 bytes_read++;
 67 
 68                 /* End of chunk? */
 69                 if (isspace(**line))
 70                         break;
 71         }
 72 
 73         /*
 74          * objdump will display raw insn as LE if code endian
 75          * is LE and bytes_per_chunk > 1. In that case reverse
 76          * the chunk we just read.
 77          *
 78          * see disassemble_bytes() at binutils/objdump.c for details
 79          * how objdump chooses display endian)
 80          */
 81         if (bytes_read > 1 && !bigendian()) {
 82                 unsigned char *chunk_end = chunk_start + bytes_read - 1;
 83                 unsigned char tmp;
 84 
 85                 while (chunk_start < chunk_end) {
 86                         tmp = *chunk_start;
 87                         *chunk_start = *chunk_end;
 88                         *chunk_end = tmp;
 89                         chunk_start++;
 90                         chunk_end--;
 91                 }
 92         }
 93 
 94         return bytes_read;
 95 }
 96 
 97 static size_t read_objdump_line(const char *line, unsigned char *buf,
 98                                 size_t buf_len)
 99 {
100         const char *p;
101         size_t ret, bytes_read = 0;
102 
103         /* Skip to a colon */
104         p = strchr(line, ':');
105         if (!p)
106                 return 0;
107         p++;
108 
109         /* Skip initial spaces */
110         while (*p) {
111                 if (!isspace(*p))
112                         break;
113                 p++;
114         }
115 
116         do {
117                 ret = read_objdump_chunk(&p, &buf, &buf_len);
118                 bytes_read += ret;
119                 p++;
120         } while (ret > 0);
121 
122         /* return number of successfully read bytes */
123         return bytes_read;
124 }
125 
126 static int read_objdump_output(FILE *f, void *buf, size_t *len, u64 start_addr)
127 {
128         char *line = NULL;
129         size_t line_len, off_last = 0;
130         ssize_t ret;
131         int err = 0;
132         u64 addr, last_addr = start_addr;
133 
134         while (off_last < *len) {
135                 size_t off, read_bytes, written_bytes;
136                 unsigned char tmp[BUFSZ];
137 
138                 ret = getline(&line, &line_len, f);
139                 if (feof(f))
140                         break;
141                 if (ret < 0) {
142                         pr_debug("getline failed\n");
143                         err = -1;
144                         break;
145                 }
146 
147                 /* read objdump data into temporary buffer */
148                 read_bytes = read_objdump_line(line, tmp, sizeof(tmp));
149                 if (!read_bytes)
150                         continue;
151 
152                 if (sscanf(line, "%"PRIx64, &addr) != 1)
153                         continue;
154                 if (addr < last_addr) {
155                         pr_debug("addr going backwards, read beyond section?\n");
156                         break;
157                 }
158                 last_addr = addr;
159 
160                 /* copy it from temporary buffer to 'buf' according
161                  * to address on current objdump line */
162                 off = addr - start_addr;
163                 if (off >= *len)
164                         break;
165                 written_bytes = MIN(read_bytes, *len - off);
166                 memcpy(buf + off, tmp, written_bytes);
167                 off_last = off + written_bytes;
168         }
169 
170         /* len returns number of bytes that could not be read */
171         *len -= off_last;
172 
173         free(line);
174 
175         return err;
176 }
177 
178 static int read_via_objdump(const char *filename, u64 addr, void *buf,
179                             size_t len)
180 {
181         char cmd[PATH_MAX * 2];
182         const char *fmt;
183         FILE *f;
184         int ret;
185 
186         fmt = "%s -z -d --start-address=0x%"PRIx64" --stop-address=0x%"PRIx64" %s";
187         ret = snprintf(cmd, sizeof(cmd), fmt, "objdump", addr, addr + len,
188                        filename);
189         if (ret <= 0 || (size_t)ret >= sizeof(cmd))
190                 return -1;
191 
192         pr_debug("Objdump command is: %s\n", cmd);
193 
194         /* Ignore objdump errors */
195         strcat(cmd, " 2>/dev/null");
196 
197         f = popen(cmd, "r");
198         if (!f) {
199                 pr_debug("popen failed\n");
200                 return -1;
201         }
202 
203         ret = read_objdump_output(f, buf, &len, addr);
204         if (len) {
205                 pr_debug("objdump read too few bytes: %zd\n", len);
206                 if (!ret)
207                         ret = len;
208         }
209 
210         pclose(f);
211 
212         return ret;
213 }
214 
215 static void dump_buf(unsigned char *buf, size_t len)
216 {
217         size_t i;
218 
219         for (i = 0; i < len; i++) {
220                 pr_debug("0x%02x ", buf[i]);
221                 if (i % 16 == 15)
222                         pr_debug("\n");
223         }
224         pr_debug("\n");
225 }
226 
227 static int read_object_code(u64 addr, size_t len, u8 cpumode,
228                             struct thread *thread, struct state *state)
229 {
230         struct addr_location al;
231         unsigned char buf1[BUFSZ];
232         unsigned char buf2[BUFSZ];
233         size_t ret_len;
234         u64 objdump_addr;
235         const char *objdump_name;
236         char decomp_name[KMOD_DECOMP_LEN];
237         bool decomp = false;
238         int ret;
239 
240         pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
241 
242         if (!thread__find_map(thread, cpumode, addr, &al) || !al.map->dso) {
243                 if (cpumode == PERF_RECORD_MISC_HYPERVISOR) {
244                         pr_debug("Hypervisor address can not be resolved - skipping\n");
245                         return 0;
246                 }
247 
248                 pr_debug("thread__find_map failed\n");
249                 return -1;
250         }
251 
252         pr_debug("File is: %s\n", al.map->dso->long_name);
253 
254         if (al.map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
255             !dso__is_kcore(al.map->dso)) {
256                 pr_debug("Unexpected kernel address - skipping\n");
257                 return 0;
258         }
259 
260         pr_debug("On file address is: %#"PRIx64"\n", al.addr);
261 
262         if (len > BUFSZ)
263                 len = BUFSZ;
264 
265         /* Do not go off the map */
266         if (addr + len > al.map->end)
267                 len = al.map->end - addr;
268 
269         /* Read the object code using perf */
270         ret_len = dso__data_read_offset(al.map->dso, thread->mg->machine,
271                                         al.addr, buf1, len);
272         if (ret_len != len) {
273                 pr_debug("dso__data_read_offset failed\n");
274                 return -1;
275         }
276 
277         /*
278          * Converting addresses for use by objdump requires more information.
279          * map__load() does that.  See map__rip_2objdump() for details.
280          */
281         if (map__load(al.map))
282                 return -1;
283 
284         /* objdump struggles with kcore - try each map only once */
285         if (dso__is_kcore(al.map->dso)) {
286                 size_t d;
287 
288                 for (d = 0; d < state->done_cnt; d++) {
289                         if (state->done[d] == al.map->start) {
290                                 pr_debug("kcore map tested already");
291                                 pr_debug(" - skipping\n");
292                                 return 0;
293                         }
294                 }
295                 if (state->done_cnt >= ARRAY_SIZE(state->done)) {
296                         pr_debug("Too many kcore maps - skipping\n");
297                         return 0;
298                 }
299                 state->done[state->done_cnt++] = al.map->start;
300         }
301 
302         objdump_name = al.map->dso->long_name;
303         if (dso__needs_decompress(al.map->dso)) {
304                 if (dso__decompress_kmodule_path(al.map->dso, objdump_name,
305                                                  decomp_name,
306                                                  sizeof(decomp_name)) < 0) {
307                         pr_debug("decompression failed\n");
308                         return -1;
309                 }
310 
311                 decomp = true;
312                 objdump_name = decomp_name;
313         }
314 
315         /* Read the object code using objdump */
316         objdump_addr = map__rip_2objdump(al.map, al.addr);
317         ret = read_via_objdump(objdump_name, objdump_addr, buf2, len);
318 
319         if (decomp)
320                 unlink(objdump_name);
321 
322         if (ret > 0) {
323                 /*
324                  * The kernel maps are inaccurate - assume objdump is right in
325                  * that case.
326                  */
327                 if (cpumode == PERF_RECORD_MISC_KERNEL ||
328                     cpumode == PERF_RECORD_MISC_GUEST_KERNEL) {
329                         len -= ret;
330                         if (len) {
331                                 pr_debug("Reducing len to %zu\n", len);
332                         } else if (dso__is_kcore(al.map->dso)) {
333                                 /*
334                                  * objdump cannot handle very large segments
335                                  * that may be found in kcore.
336                                  */
337                                 pr_debug("objdump failed for kcore");
338                                 pr_debug(" - skipping\n");
339                                 return 0;
340                         } else {
341                                 return -1;
342                         }
343                 }
344         }
345         if (ret < 0) {
346                 pr_debug("read_via_objdump failed\n");
347                 return -1;
348         }
349 
350         /* The results should be identical */
351         if (memcmp(buf1, buf2, len)) {
352                 pr_debug("Bytes read differ from those read by objdump\n");
353                 pr_debug("buf1 (dso):\n");
354                 dump_buf(buf1, len);
355                 pr_debug("buf2 (objdump):\n");
356                 dump_buf(buf2, len);
357                 return -1;
358         }
359         pr_debug("Bytes read match those read by objdump\n");
360 
361         return 0;
362 }
363 
364 static int process_sample_event(struct machine *machine,
365                                 struct perf_evlist *evlist,
366                                 union perf_event *event, struct state *state)
367 {
368         struct perf_sample sample;
369         struct thread *thread;
370         int ret;
371 
372         if (perf_evlist__parse_sample(evlist, event, &sample)) {
373                 pr_debug("perf_evlist__parse_sample failed\n");
374                 return -1;
375         }
376 
377         thread = machine__findnew_thread(machine, sample.pid, sample.tid);
378         if (!thread) {
379                 pr_debug("machine__findnew_thread failed\n");
380                 return -1;
381         }
382 
383         ret = read_object_code(sample.ip, READLEN, sample.cpumode, thread, state);
384         thread__put(thread);
385         return ret;
386 }
387 
388 static int process_event(struct machine *machine, struct perf_evlist *evlist,
389                          union perf_event *event, struct state *state)
390 {
391         if (event->header.type == PERF_RECORD_SAMPLE)
392                 return process_sample_event(machine, evlist, event, state);
393 
394         if (event->header.type == PERF_RECORD_THROTTLE ||
395             event->header.type == PERF_RECORD_UNTHROTTLE)
396                 return 0;
397 
398         if (event->header.type < PERF_RECORD_MAX) {
399                 int ret;
400 
401                 ret = machine__process_event(machine, event, NULL);
402                 if (ret < 0)
403                         pr_debug("machine__process_event failed, event type %u\n",
404                                  event->header.type);
405                 return ret;
406         }
407 
408         return 0;
409 }
410 
411 static int process_events(struct machine *machine, struct perf_evlist *evlist,
412                           struct state *state)
413 {
414         union perf_event *event;
415         struct perf_mmap *md;
416         int i, ret;
417 
418         for (i = 0; i < evlist->nr_mmaps; i++) {
419                 md = &evlist->mmap[i];
420                 if (perf_mmap__read_init(md) < 0)
421                         continue;
422 
423                 while ((event = perf_mmap__read_event(md)) != NULL) {
424                         ret = process_event(machine, evlist, event, state);
425                         perf_mmap__consume(md);
426                         if (ret < 0)
427                                 return ret;
428                 }
429                 perf_mmap__read_done(md);
430         }
431         return 0;
432 }
433 
434 static int comp(const void *a, const void *b)
435 {
436         return *(int *)a - *(int *)b;
437 }
438 
439 static void do_sort_something(void)
440 {
441         int buf[40960], i;
442 
443         for (i = 0; i < (int)ARRAY_SIZE(buf); i++)
444                 buf[i] = ARRAY_SIZE(buf) - i - 1;
445 
446         qsort(buf, ARRAY_SIZE(buf), sizeof(int), comp);
447 
448         for (i = 0; i < (int)ARRAY_SIZE(buf); i++) {
449                 if (buf[i] != i) {
450                         pr_debug("qsort failed\n");
451                         break;
452                 }
453         }
454 }
455 
456 static void sort_something(void)
457 {
458         int i;
459 
460         for (i = 0; i < 10; i++)
461                 do_sort_something();
462 }
463 
464 static void syscall_something(void)
465 {
466         int pipefd[2];
467         int i;
468 
469         for (i = 0; i < 1000; i++) {
470                 if (pipe(pipefd) < 0) {
471                         pr_debug("pipe failed\n");
472                         break;
473                 }
474                 close(pipefd[1]);
475                 close(pipefd[0]);
476         }
477 }
478 
479 static void fs_something(void)
480 {
481         const char *test_file_name = "temp-perf-code-reading-test-file--";
482         FILE *f;
483         int i;
484 
485         for (i = 0; i < 1000; i++) {
486                 f = fopen(test_file_name, "w+");
487                 if (f) {
488                         fclose(f);
489                         unlink(test_file_name);
490                 }
491         }
492 }
493 
494 static const char *do_determine_event(bool excl_kernel)
495 {
496         const char *event = excl_kernel ? "cycles:u" : "cycles";
497 
498 #ifdef __s390x__
499         char cpuid[128], model[16], model_c[16], cpum_cf_v[16];
500         unsigned int family;
501         int ret, cpum_cf_a;
502 
503         if (get_cpuid(cpuid, sizeof(cpuid)))
504                 goto out_clocks;
505         ret = sscanf(cpuid, "%*[^,],%u,%[^,],%[^,],%[^,],%x", &family, model_c,
506                      model, cpum_cf_v, &cpum_cf_a);
507         if (ret != 5)            /* Not available */
508                 goto out_clocks;
509         if (excl_kernel && (cpum_cf_a & 4))
510                 return event;
511         if (!excl_kernel && (cpum_cf_a & 2))
512                 return event;
513 
514         /* Fall through: missing authorization */
515 out_clocks:
516         event = excl_kernel ? "cpu-clock:u" : "cpu-clock";
517 
518 #endif
519         return event;
520 }
521 
522 static void do_something(void)
523 {
524         fs_something();
525 
526         sort_something();
527 
528         syscall_something();
529 }
530 
531 enum {
532         TEST_CODE_READING_OK,
533         TEST_CODE_READING_NO_VMLINUX,
534         TEST_CODE_READING_NO_KCORE,
535         TEST_CODE_READING_NO_ACCESS,
536         TEST_CODE_READING_NO_KERNEL_OBJ,
537 };
538 
539 static int do_test_code_reading(bool try_kcore)
540 {
541         struct machine *machine;
542         struct thread *thread;
543         struct record_opts opts = {
544                 .mmap_pages          = UINT_MAX,
545                 .user_freq           = UINT_MAX,
546                 .user_interval       = ULLONG_MAX,
547                 .freq                = 500,
548                 .target              = {
549                         .uses_mmap   = true,
550                 },
551         };
552         struct state state = {
553                 .done_cnt = 0,
554         };
555         struct thread_map *threads = NULL;
556         struct cpu_map *cpus = NULL;
557         struct perf_evlist *evlist = NULL;
558         struct perf_evsel *evsel = NULL;
559         int err = -1, ret;
560         pid_t pid;
561         struct map *map;
562         bool have_vmlinux, have_kcore, excl_kernel = false;
563 
564         pid = getpid();
565 
566         machine = machine__new_host();
567         machine->env = &perf_env;
568 
569         ret = machine__create_kernel_maps(machine);
570         if (ret < 0) {
571                 pr_debug("machine__create_kernel_maps failed\n");
572                 goto out_err;
573         }
574 
575         /* Force the use of kallsyms instead of vmlinux to try kcore */
576         if (try_kcore)
577                 symbol_conf.kallsyms_name = "/proc/kallsyms";
578 
579         /* Load kernel map */
580         map = machine__kernel_map(machine);
581         ret = map__load(map);
582         if (ret < 0) {
583                 pr_debug("map__load failed\n");
584                 goto out_err;
585         }
586         have_vmlinux = dso__is_vmlinux(map->dso);
587         have_kcore = dso__is_kcore(map->dso);
588 
589         /* 2nd time through we just try kcore */
590         if (try_kcore && !have_kcore)
591                 return TEST_CODE_READING_NO_KCORE;
592 
593         /* No point getting kernel events if there is no kernel object */
594         if (!have_vmlinux && !have_kcore)
595                 excl_kernel = true;
596 
597         threads = thread_map__new_by_tid(pid);
598         if (!threads) {
599                 pr_debug("thread_map__new_by_tid failed\n");
600                 goto out_err;
601         }
602 
603         ret = perf_event__synthesize_thread_map(NULL, threads,
604                                                 perf_event__process, machine, false);
605         if (ret < 0) {
606                 pr_debug("perf_event__synthesize_thread_map failed\n");
607                 goto out_err;
608         }
609 
610         thread = machine__findnew_thread(machine, pid, pid);
611         if (!thread) {
612                 pr_debug("machine__findnew_thread failed\n");
613                 goto out_put;
614         }
615 
616         cpus = cpu_map__new(NULL);
617         if (!cpus) {
618                 pr_debug("cpu_map__new failed\n");
619                 goto out_put;
620         }
621 
622         while (1) {
623                 const char *str;
624 
625                 evlist = perf_evlist__new();
626                 if (!evlist) {
627                         pr_debug("perf_evlist__new failed\n");
628                         goto out_put;
629                 }
630 
631                 perf_evlist__set_maps(evlist, cpus, threads);
632 
633                 str = do_determine_event(excl_kernel);
634                 pr_debug("Parsing event '%s'\n", str);
635                 ret = parse_events(evlist, str, NULL);
636                 if (ret < 0) {
637                         pr_debug("parse_events failed\n");
638                         goto out_put;
639                 }
640 
641                 perf_evlist__config(evlist, &opts, NULL);
642 
643                 evsel = perf_evlist__first(evlist);
644 
645                 evsel->attr.comm = 1;
646                 evsel->attr.disabled = 1;
647                 evsel->attr.enable_on_exec = 0;
648 
649                 ret = perf_evlist__open(evlist);
650                 if (ret < 0) {
651                         if (!excl_kernel) {
652                                 excl_kernel = true;
653                                 /*
654                                  * Both cpus and threads are now owned by evlist
655                                  * and will be freed by following perf_evlist__set_maps
656                                  * call. Getting refference to keep them alive.
657                                  */
658                                 cpu_map__get(cpus);
659                                 thread_map__get(threads);
660                                 perf_evlist__set_maps(evlist, NULL, NULL);
661                                 perf_evlist__delete(evlist);
662                                 evlist = NULL;
663                                 continue;
664                         }
665 
666                         if (verbose > 0) {
667                                 char errbuf[512];
668                                 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
669                                 pr_debug("perf_evlist__open() failed!\n%s\n", errbuf);
670                         }
671 
672                         goto out_put;
673                 }
674                 break;
675         }
676 
677         ret = perf_evlist__mmap(evlist, UINT_MAX);
678         if (ret < 0) {
679                 pr_debug("perf_evlist__mmap failed\n");
680                 goto out_put;
681         }
682 
683         perf_evlist__enable(evlist);
684 
685         do_something();
686 
687         perf_evlist__disable(evlist);
688 
689         ret = process_events(machine, evlist, &state);
690         if (ret < 0)
691                 goto out_put;
692 
693         if (!have_vmlinux && !have_kcore && !try_kcore)
694                 err = TEST_CODE_READING_NO_KERNEL_OBJ;
695         else if (!have_vmlinux && !try_kcore)
696                 err = TEST_CODE_READING_NO_VMLINUX;
697         else if (excl_kernel)
698                 err = TEST_CODE_READING_NO_ACCESS;
699         else
700                 err = TEST_CODE_READING_OK;
701 out_put:
702         thread__put(thread);
703 out_err:
704 
705         if (evlist) {
706                 perf_evlist__delete(evlist);
707         } else {
708                 cpu_map__put(cpus);
709                 thread_map__put(threads);
710         }
711         machine__delete_threads(machine);
712         machine__delete(machine);
713 
714         return err;
715 }
716 
717 int test__code_reading(struct test *test __maybe_unused, int subtest __maybe_unused)
718 {
719         int ret;
720 
721         ret = do_test_code_reading(false);
722         if (!ret)
723                 ret = do_test_code_reading(true);
724 
725         switch (ret) {
726         case TEST_CODE_READING_OK:
727                 return 0;
728         case TEST_CODE_READING_NO_VMLINUX:
729                 pr_debug("no vmlinux\n");
730                 return 0;
731         case TEST_CODE_READING_NO_KCORE:
732                 pr_debug("no kcore\n");
733                 return 0;
734         case TEST_CODE_READING_NO_ACCESS:
735                 pr_debug("no access\n");
736                 return 0;
737         case TEST_CODE_READING_NO_KERNEL_OBJ:
738                 pr_debug("no kernel obj\n");
739                 return 0;
740         default:
741                 return -1;
742         };
743 }
744 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp