LCOV - code coverage report
Current view: top level - strace - perf.c (source / functions) Hit Total Coverage
Test: strace-4.18.0.129.97bbb Code Coverage Lines: 141 147 95.9 %
Date: 2017-07-31 03:46:08 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 71 77 92.2 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 2013 Ben Noordhuis <info@bnoordhuis.nl>
       3                 :            :  * Copyright (c) 2013-2015 Dmitry V. Levin <ldv@altlinux.org>
       4                 :            :  * Copyright (c) 2016 Eugene Syromyatnikov <evgsyr@gmail.com>
       5                 :            :  * Copyright (c) 2015-2017 The strace developers.
       6                 :            :  * All rights reserved.
       7                 :            :  *
       8                 :            :  * Redistribution and use in source and binary forms, with or without
       9                 :            :  * modification, are permitted provided that the following conditions
      10                 :            :  * are met:
      11                 :            :  * 1. Redistributions of source code must retain the above copyright
      12                 :            :  *    notice, this list of conditions and the following disclaimer.
      13                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      14                 :            :  *    notice, this list of conditions and the following disclaimer in the
      15                 :            :  *    documentation and/or other materials provided with the distribution.
      16                 :            :  * 3. The name of the author may not be used to endorse or promote products
      17                 :            :  *    derived from this software without specific prior written permission.
      18                 :            :  *
      19                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
      20                 :            :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      21                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      22                 :            :  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
      23                 :            :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      24                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      25                 :            :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      26                 :            :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      27                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      28                 :            :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      29                 :            :  */
      30                 :            : 
      31                 :            : #include "defs.h"
      32                 :            : 
      33                 :            : #include "perf_event_struct.h"
      34                 :            : 
      35                 :            : #include "xlat/hw_breakpoint_len.h"
      36                 :            : #include "xlat/hw_breakpoint_type.h"
      37                 :            : #include "xlat/perf_attr_size.h"
      38                 :            : #include "xlat/perf_branch_sample_type.h"
      39                 :            : #include "xlat/perf_event_open_flags.h"
      40                 :            : #include "xlat/perf_event_read_format.h"
      41                 :            : #include "xlat/perf_event_sample_format.h"
      42                 :            : #include "xlat/perf_hw_cache_id.h"
      43                 :            : #include "xlat/perf_hw_cache_op_id.h"
      44                 :            : #include "xlat/perf_hw_cache_op_result_id.h"
      45                 :            : #include "xlat/perf_hw_id.h"
      46                 :            : #include "xlat/perf_sw_ids.h"
      47                 :            : #include "xlat/perf_type_id.h"
      48                 :            : 
      49                 :            : struct pea_desc {
      50                 :            :         struct perf_event_attr *attr;
      51                 :            :         uint32_t size;
      52                 :            : };
      53                 :            : 
      54                 :            : static void
      55                 :       1250 : free_pea_desc(void *pea_desc_ptr)
      56                 :            : {
      57                 :       1250 :         struct pea_desc *desc = pea_desc_ptr;
      58                 :            : 
      59                 :       1250 :         free(desc->attr);
      60                 :       1250 :         free(desc);
      61                 :       1250 : }
      62                 :            : 
      63                 :            : static int
      64                 :       1276 : fetch_perf_event_attr(struct tcb *const tcp, const kernel_ulong_t addr)
      65                 :            : {
      66                 :            :         struct pea_desc *desc;
      67                 :            :         struct perf_event_attr *attr;
      68                 :            :         uint32_t size;
      69                 :            : 
      70         [ +  + ]:       1276 :         if (umove(tcp, addr + offsetof(struct perf_event_attr, size), &size)) {
      71                 :         16 :                 printaddr(addr);
      72                 :         16 :                 return 1;
      73                 :            :         }
      74                 :            : 
      75         [ +  + ]:       1260 :         if (size > sizeof(*attr))
      76                 :         98 :                 size = sizeof(*attr);
      77                 :            : 
      78         [ +  + ]:       1260 :         if (!size)
      79                 :          4 :                 size = PERF_ATTR_SIZE_VER0;
      80                 :            : 
      81                 :            :         /*
      82                 :            :          * Kernel (rightfully) deems invalid attribute structures with size less
      83                 :            :          * than first published format size, and we do the same.
      84                 :            :          */
      85         [ +  + ]:       1260 :         if (size < PERF_ATTR_SIZE_VER0) {
      86                 :          4 :                 printaddr(addr);
      87                 :          4 :                 return 1;
      88                 :            :         }
      89                 :            : 
      90         [ +  + ]:       1256 :         if (abbrev(tcp))
      91                 :        630 :                 size = offsetofend(struct perf_event_attr, config);
      92                 :            : 
      93                 :            :         /* Size should be multiple of 8, but kernel doesn't check for it */
      94                 :            :         /* size &= ~7; */
      95                 :            : 
      96                 :       1256 :         attr = xcalloc(1, sizeof(*attr));
      97                 :            : 
      98         [ +  + ]:       1256 :         if (umoven_or_printaddr(tcp, addr, size, attr)) {
      99                 :          6 :                 free(attr);
     100                 :            : 
     101                 :          6 :                 return 1;
     102                 :            :         }
     103                 :            : 
     104                 :       1250 :         desc = xmalloc(sizeof(*desc));
     105                 :            : 
     106                 :       1250 :         desc->attr = attr;
     107                 :       1250 :         desc->size = size;
     108                 :            : 
     109                 :       1250 :         set_tcb_priv_data(tcp, desc, free_pea_desc);
     110                 :            : 
     111                 :       1250 :         return 0;
     112                 :            : }
     113                 :            : 
     114                 :            : #define PRINT_XLAT(prefix, xlat, x, dflt) \
     115                 :            :         do { \
     116                 :            :                 tprints(prefix); \
     117                 :            :                 printxval_search(xlat, x, dflt); \
     118                 :            :         } while (0)
     119                 :            : 
     120                 :            : static void
     121                 :       1250 : print_perf_event_attr(struct tcb *const tcp, const kernel_ulong_t addr)
     122                 :            : {
     123                 :            :         static const char *precise_ip_desc[] = {
     124                 :            :                 "arbitrary skid",
     125                 :            :                 "constant skid",
     126                 :            :                 "requested to have 0 skid",
     127                 :            :                 "must have 0 skid",
     128                 :            :         };
     129                 :            : 
     130                 :            :         struct pea_desc *desc;
     131                 :            :         struct perf_event_attr *attr;
     132                 :            :         uint32_t size;
     133                 :            :         uint32_t new_size;
     134                 :       1250 :         int use_new_size = 0;
     135                 :            : 
     136                 :            :         /*
     137                 :            :          * Amusingly, kernel accepts structures with only part of the field
     138                 :            :          * present, so we making check like this (instead of checking
     139                 :            :          * offsetofend against size) in order to print fields as kernel sees
     140                 :            :          * them. This also should work great on big endian architectures.
     141                 :            :          */
     142                 :            :         #define _PERF_CHECK_FIELD(_field) \
     143                 :            :                 do { \
     144                 :            :                         if (offsetof(struct perf_event_attr, _field) >= size) \
     145                 :            :                                 goto print_perf_event_attr_out; \
     146                 :            :                 } while (0)
     147                 :            : 
     148                 :       1250 :         desc = get_tcb_priv_data(tcp);
     149                 :            : 
     150                 :       1250 :         attr = desc->attr;
     151                 :       1250 :         size = desc->size;
     152                 :            : 
     153                 :            :         /* The only error which expected to change size field currently */
     154         [ -  + ]:       1250 :         if (tcp->u_error == E2BIG) {
     155         [ #  # ]:          0 :                 if (umove(tcp, addr + offsetof(struct perf_event_attr, size),
     156                 :            :                     &new_size))
     157                 :            :                         use_new_size = -1;
     158                 :            :                 else
     159                 :          0 :                         use_new_size = 1;
     160                 :            :         }
     161                 :            : 
     162                 :       1250 :         PRINT_XLAT("{type=", perf_type_id, attr->type, "PERF_TYPE_???");
     163                 :       1250 :         tprints(", size=");
     164                 :       1250 :         printxval(perf_attr_size, attr->size, "PERF_ATTR_SIZE_???");
     165                 :            : 
     166         [ -  + ]:       1250 :         if (use_new_size) {
     167                 :          0 :                 tprints(" => ");
     168                 :            : 
     169         [ #  # ]:          0 :                 if (use_new_size > 0)
     170                 :          0 :                         printxval(perf_attr_size, new_size,
     171                 :            :                                   "PERF_ATTR_SIZE_???");
     172                 :            :                 else
     173                 :          0 :                         tprints("???");
     174                 :            :         }
     175                 :            : 
     176   [ +  +  +  +  :       1250 :         switch (attr->type) {
                      + ]
     177                 :            :         case PERF_TYPE_HARDWARE:
     178                 :        158 :                 PRINT_XLAT(", config=", perf_hw_id, attr->config,
     179                 :            :                            "PERF_COUNT_HW_???");
     180                 :        158 :                 break;
     181                 :            :         case PERF_TYPE_SOFTWARE:
     182                 :        156 :                 PRINT_XLAT(", config=", perf_sw_ids, attr->config,
     183                 :            :                            "PERF_COUNT_SW_???");
     184                 :        156 :                 break;
     185                 :            :         case PERF_TYPE_TRACEPOINT:
     186                 :            :                 /*
     187                 :            :                  * "The value to use in config can be obtained from under
     188                 :            :                  * debugfs tracing/events/../../id if ftrace is enabled
     189                 :            :                  * in the kernel."
     190                 :            :                  */
     191                 :        156 :                 tprintf(", config=%" PRIu64, attr->config);
     192                 :        156 :                 break;
     193                 :            :         case PERF_TYPE_HW_CACHE:
     194                 :            :                 /*
     195                 :            :                  * (perf_hw_cache_id) | (perf_hw_cache_op_id << 8) |
     196                 :            :                  * (perf_hw_cache_op_result_id << 16)
     197                 :            :                  */
     198                 :        156 :                 PRINT_XLAT(", config=", perf_hw_cache_id, attr->config & 0xFF,
     199                 :            :                            "PERF_COUNT_HW_CACHE_???");
     200                 :        156 :                 PRINT_XLAT("|", perf_hw_cache_op_id, (attr->config >> 8) & 0xFF,
     201                 :            :                            "PERF_COUNT_HW_CACHE_OP_???");
     202                 :            :                 /*
     203                 :            :                  * Current code (see set_ext_hw_attr in arch/x86/events/core.c,
     204                 :            :                  * tile_map_cache_event in arch/tile/kernel/perf_event.c,
     205                 :            :                  * arc_pmu_cache_event in arch/arc/kernel/perf_event.c,
     206                 :            :                  * hw_perf_cache_event in arch/blackfin/kernel/perf_event.c,
     207                 :            :                  * _hw_perf_cache_event in arch/metag/kernel/perf/perf_event.c,
     208                 :            :                  * mipspmu_map_cache_event in arch/mips/kernel/perf_event_mipsxx.c,
     209                 :            :                  * hw_perf_cache_event in arch/powerpc/perf/core-book3s.c,
     210                 :            :                  * hw_perf_cache_event in arch/powerpc/perf/core-fsl-emb.c,
     211                 :            :                  * hw_perf_cache_event in arch/sh/kernel/perf_event.c,
     212                 :            :                  * sparc_map_cache_event in arch/sparc/kernel/perf_event.c,
     213                 :            :                  * xtensa_pmu_cache_event in arch/xtensa/kernel/perf_event.c,
     214                 :            :                  * armpmu_map_cache_event in drivers/perf/arm_pmu.c) assumes
     215                 :            :                  * that cache result is 8 bits in size.
     216                 :            :                  */
     217                 :        156 :                 PRINT_XLAT("<<8|", perf_hw_cache_op_result_id,
     218                 :            :                            (attr->config >> 16) & 0xFF,
     219                 :            :                            "PERF_COUNT_HW_CACHE_RESULT_???");
     220                 :        156 :                 tprints("<<16");
     221         [ +  + ]:        156 :                 if (attr->config >> 24) {
     222                 :         52 :                         tprintf("|%#" PRIx64 "<<24", attr->config >> 24);
     223                 :         52 :                         tprints_comment("PERF_COUNT_HW_CACHE_???");
     224                 :            :                 }
     225                 :            :                 break;
     226                 :            :         case PERF_TYPE_RAW:
     227                 :            :                 /*
     228                 :            :                  * "If type is PERF_TYPE_RAW, then a custom "raw" config
     229                 :            :                  * value is needed. Most CPUs support events that are not
     230                 :            :                  * covered by the "generalized" events. These are
     231                 :            :                  * implementation defined; see your CPU manual (for example the
     232                 :            :                  * Intel Volume 3B documentation or the AMD BIOS and Kernel
     233                 :            :                  * Developer Guide). The libpfm4 library can be used to
     234                 :            :                  * translate from the name in the architectural manuals
     235                 :            :                  * to the raw hex value perf_event_open() expects in this
     236                 :            :                  * field."
     237                 :            :                  */
     238                 :            :         case PERF_TYPE_BREAKPOINT:
     239                 :            :                 /*
     240                 :            :                  * "If type is PERF_TYPE_BREAKPOINT, then leave config set
     241                 :            :                  * to zero. Its parameters are set in other places."
     242                 :            :                  */
     243                 :            :         default:
     244                 :        624 :                 tprintf(", config=%#" PRIx64, attr->config);
     245                 :        624 :                 break;
     246                 :            :         }
     247                 :            : 
     248         [ +  + ]:       1250 :         if (abbrev(tcp))
     249                 :            :                 goto print_perf_event_attr_out;
     250                 :            : 
     251         [ +  + ]:        624 :         if (attr->freq)
     252                 :        312 :                 tprintf(", sample_freq=%" PRIu64, attr->sample_freq);
     253                 :            :         else
     254                 :        312 :                 tprintf(", sample_period=%" PRIu64, attr->sample_period);
     255                 :            : 
     256                 :        624 :         tprints(", sample_type=");
     257                 :        624 :         printflags64(perf_event_sample_format, attr->sample_type,
     258                 :            :                 "PERF_SAMPLE_???");
     259                 :            : 
     260                 :        624 :         tprints(", read_format=");
     261                 :        624 :         printflags64(perf_event_read_format, attr->read_format,
     262                 :            :                 "PERF_FORMAT_???");
     263                 :            : 
     264                 :        624 :         tprintf(", disabled=%u"
     265                 :            :                 ", inherit=%u"
     266                 :            :                 ", pinned=%u"
     267                 :            :                 ", exclusive=%u"
     268                 :            :                 ", exclusive_user=%u"
     269                 :            :                 ", exclude_kernel=%u"
     270                 :            :                 ", exclude_hv=%u"
     271                 :            :                 ", exclude_idle=%u"
     272                 :            :                 ", mmap=%u"
     273                 :            :                 ", comm=%u"
     274                 :            :                 ", freq=%u"
     275                 :            :                 ", inherit_stat=%u"
     276                 :            :                 ", enable_on_exec=%u"
     277                 :            :                 ", task=%u"
     278                 :            :                 ", watermark=%u"
     279                 :            :                 ", precise_ip=%u",
     280                 :        624 :                 attr->disabled,
     281                 :        624 :                 attr->inherit,
     282                 :        624 :                 attr->pinned,
     283                 :        624 :                 attr->exclusive,
     284                 :        624 :                 attr->exclude_user,
     285                 :        624 :                 attr->exclude_kernel,
     286                 :        624 :                 attr->exclude_hv,
     287                 :        624 :                 attr->exclude_idle,
     288                 :        624 :                 attr->mmap,
     289                 :        624 :                 attr->comm,
     290                 :        624 :                 attr->freq,
     291                 :        624 :                 attr->inherit_stat,
     292                 :        624 :                 attr->enable_on_exec,
     293                 :        624 :                 attr->task,
     294                 :        624 :                 attr->watermark,
     295                 :        624 :                 attr->precise_ip);
     296                 :        624 :         tprints_comment(precise_ip_desc[attr->precise_ip]);
     297                 :        624 :         tprintf(", mmap_data=%u"
     298                 :            :                 ", sample_id_all=%u"
     299                 :            :                 ", exclude_host=%u"
     300                 :            :                 ", exclude_guest=%u"
     301                 :            :                 ", exclude_callchain_kernel=%u"
     302                 :            :                 ", exclude_callchain_user=%u"
     303                 :            :                 ", mmap2=%u"
     304                 :            :                 ", comm_exec=%u"
     305                 :            :                 ", use_clockid=%u"
     306                 :            :                 ", context_switch=%u"
     307                 :            :                 ", write_backward=%u",
     308                 :        624 :                 attr->mmap_data,
     309                 :        624 :                 attr->sample_id_all,
     310                 :        624 :                 attr->exclude_host,
     311                 :        624 :                 attr->exclude_guest,
     312                 :        624 :                 attr->exclude_callchain_kernel,
     313                 :        624 :                 attr->exclude_callchain_user,
     314                 :        624 :                 attr->mmap2,
     315                 :        624 :                 attr->comm_exec,
     316                 :        624 :                 attr->use_clockid,
     317                 :        624 :                 attr->context_switch,
     318                 :        624 :                 attr->write_backward);
     319                 :            : 
     320                 :            :         /*
     321                 :            :          * Print it only in case it is non-zero, since it may contain flags we
     322                 :            :          * are not aware about.
     323                 :            :          */
     324         [ +  + ]:        624 :         if (attr->__reserved_1) {
     325                 :        568 :                 tprintf(", __reserved_1=%#" PRIx64,
     326                 :        568 :                         (uint64_t) attr->__reserved_1);
     327                 :        568 :                 tprints_comment("Bits 63..28");
     328                 :            :         }
     329                 :            : 
     330         [ +  + ]:        624 :         if (attr->watermark)
     331                 :        324 :                 tprintf(", wakeup_watermark=%u", attr->wakeup_watermark);
     332                 :            :         else
     333                 :        300 :                 tprintf(", wakeup_events=%u", attr->wakeup_events);
     334                 :            : 
     335         [ +  + ]:        624 :         if (attr->type == PERF_TYPE_BREAKPOINT)
     336                 :            :                 /* Any combination of R/W with X is deemed invalid */
     337         [ +  + ]:         78 :                 PRINT_XLAT(", bp_type=", hw_breakpoint_type, attr->bp_type,
     338                 :            :                            (attr->bp_type <=
     339                 :            :                                    (HW_BREAKPOINT_X | HW_BREAKPOINT_RW)) ?
     340                 :            :                                            "HW_BREAKPOINT_INVALID" :
     341                 :            :                                            "HW_BREAKPOINT_???");
     342                 :            : 
     343         [ +  + ]:        624 :         if (attr->type == PERF_TYPE_BREAKPOINT)
     344                 :         78 :                 tprintf(", bp_addr=%#" PRIx64, attr->bp_addr);
     345                 :            :         else
     346                 :        546 :                 tprintf(", config1=%#" PRIx64, attr->config1);
     347                 :            : 
     348                 :            :         /*
     349                 :            :          * Fields after bp_addr/config1 are optional and may not present; check
     350                 :            :          * against size is needed.
     351                 :            :          */
     352                 :            : 
     353         [ +  + ]:        624 :         _PERF_CHECK_FIELD(bp_len);
     354         [ +  + ]:        576 :         if (attr->type == PERF_TYPE_BREAKPOINT)
     355                 :         72 :                 tprintf(", bp_len=%" PRIu64, attr->bp_len);
     356                 :            :         else
     357                 :        504 :                 tprintf(", config2=%#" PRIx64, attr->config2);
     358                 :            : 
     359         [ +  + ]:        576 :         _PERF_CHECK_FIELD(branch_sample_type);
     360         [ +  + ]:        528 :         if (attr->sample_type & PERF_SAMPLE_BRANCH_STACK) {
     361                 :        264 :                 tprints(", branch_sample_type=");
     362                 :        264 :                 printflags64(perf_branch_sample_type, attr->branch_sample_type,
     363                 :            :                              "PERF_SAMPLE_BRANCH_???");
     364                 :            :         }
     365                 :            : 
     366         [ +  + ]:        528 :         _PERF_CHECK_FIELD(sample_regs_user);
     367                 :            :         /*
     368                 :            :          * "This bit mask defines the set of user CPU registers to dump on
     369                 :            :          * samples. The layout of the register mask is architecture-specific and
     370                 :            :          * described in the kernel header
     371                 :            :          * arch/ARCH/include/uapi/asm/perf_regs.h."
     372                 :            :          */
     373                 :        480 :         tprintf(", sample_regs_user=%#" PRIx64, attr->sample_regs_user);
     374                 :            : 
     375         [ +  + ]:        480 :         _PERF_CHECK_FIELD(sample_stack_user);
     376                 :            :         /*
     377                 :            :          * "size of the user stack to dump if PERF_SAMPLE_STACK_USER is
     378                 :            :          * specified."
     379                 :            :          */
     380         [ +  + ]:        432 :         if (attr->sample_type & PERF_SAMPLE_STACK_USER)
     381                 :        108 :                 tprintf(", sample_stack_user=%#" PRIx32,
     382                 :            :                         attr->sample_stack_user);
     383                 :            : 
     384         [ +  + ]:        432 :         if (attr->use_clockid) {
     385         [ +  + ]:        196 :                 _PERF_CHECK_FIELD(clockid);
     386                 :        176 :                 tprints(", clockid=");
     387                 :        176 :                 printxval(clocknames, attr->clockid, "CLOCK_???");
     388                 :            :         }
     389                 :            : 
     390         [ +  + ]:        412 :         _PERF_CHECK_FIELD(sample_regs_intr);
     391                 :        288 :         tprintf(", sample_regs_intr=%#" PRIx64, attr->sample_regs_intr);
     392                 :            : 
     393         [ +  + ]:        288 :         _PERF_CHECK_FIELD(aux_watermark);
     394                 :        240 :         tprintf(", aux_watermark=%" PRIu32, attr->aux_watermark);
     395                 :            : 
     396         [ +  + ]:        240 :         _PERF_CHECK_FIELD(sample_max_stack);
     397                 :        192 :         tprintf(", sample_max_stack=%" PRIu16, attr->sample_max_stack);
     398                 :            : 
     399                 :            :         /* _PERF_CHECK_FIELD(__reserved_2);
     400                 :            :         tprintf(", __reserved2=%" PRIu16, attr->__reserved_2); */
     401                 :            : 
     402                 :            : print_perf_event_attr_out:
     403 [ +  + ][ +  + ]:       1250 :         if ((attr->size && (attr->size > size)) ||
                 [ +  + ]
     404         [ +  + ]:          4 :             (!attr->size && (size < PERF_ATTR_SIZE_VER0)))
     405                 :        674 :                 tprints(", ...");
     406                 :            : 
     407                 :       1250 :         tprints("}");
     408                 :       1250 : }
     409                 :            : 
     410                 :       2526 : SYS_FUNC(perf_event_open)
     411                 :            : {
     412                 :            :         /*
     413                 :            :          * We try to copy out the whole structure on entering in order to check
     414                 :            :          * size value on exiting. We do not check the rest of the fields because
     415                 :            :          * they shouldn't be changed, but copy the whole structure instead
     416                 :            :          * of just size field because they could.
     417                 :            :          */
     418         [ +  + ]:       2526 :         if (entering(tcp)) {
     419         [ +  + ]:       1276 :                 if (!fetch_perf_event_attr(tcp, tcp->u_arg[0]))
     420                 :            :                         return 0;
     421                 :            :         } else {
     422                 :       1250 :                 print_perf_event_attr(tcp, tcp->u_arg[0]);
     423                 :            :         }
     424                 :            : 
     425                 :       1276 :         tprintf(", %d, %d, %d, ",
     426                 :       1276 :                 (int) tcp->u_arg[1],
     427                 :       1276 :                 (int) tcp->u_arg[2],
     428                 :       1276 :                 (int) tcp->u_arg[3]);
     429                 :       1276 :         printflags64(perf_event_open_flags, tcp->u_arg[4], "PERF_FLAG_???");
     430                 :            : 
     431                 :       1276 :         return RVAL_DECODED | RVAL_FD;
     432                 :            : }

Generated by: LCOV version 1.11