LCOV - code coverage report
Current view: top level - strace - dirent.c (source / functions) Hit Total Coverage
Test: strace-4.18.0.129.97bbb Code Coverage Lines: 62 74 83.8 %
Date: 2017-07-31 03:46:08 Functions: 4 7 57.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 35 50 70.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
       3                 :            :  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
       4                 :            :  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
       5                 :            :  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
       6                 :            :  * Copyright (c) 2005-2015 Dmitry V. Levin <ldv@altlinux.org>
       7                 :            :  * Copyright (c) 2014-2017 The strace developers.
       8                 :            :  * All rights reserved.
       9                 :            :  *
      10                 :            :  * Redistribution and use in source and binary forms, with or without
      11                 :            :  * modification, are permitted provided that the following conditions
      12                 :            :  * are met:
      13                 :            :  * 1. Redistributions of source code must retain the above copyright
      14                 :            :  *    notice, this list of conditions and the following disclaimer.
      15                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      16                 :            :  *    notice, this list of conditions and the following disclaimer in the
      17                 :            :  *    documentation and/or other materials provided with the distribution.
      18                 :            :  * 3. The name of the author may not be used to endorse or promote products
      19                 :            :  *    derived from this software without specific prior written permission.
      20                 :            :  *
      21                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
      22                 :            :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      23                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      24                 :            :  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
      25                 :            :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      26                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      27                 :            :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      28                 :            :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      29                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      30                 :            :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      31                 :            :  */
      32                 :            : 
      33                 :            : #include "defs.h"
      34                 :            : 
      35                 :            : #include DEF_MPERS_TYPE(kernel_dirent)
      36                 :            : 
      37                 :            : #include MPERS_DEFS
      38                 :            : 
      39                 :            : #define D_NAME_LEN_MAX 256
      40                 :            : 
      41                 :            : static void
      42                 :          3 : print_old_dirent(struct tcb *const tcp, const kernel_ulong_t addr)
      43                 :            : {
      44                 :            :         kernel_dirent d;
      45                 :            : 
      46         [ +  - ]:          3 :         if (umove_or_printaddr(tcp, addr, &d))
      47                 :          0 :                 return;
      48                 :            : 
      49                 :          3 :         tprintf("{d_ino=%llu, d_off=%llu, d_reclen=%u, d_name=",
      50                 :          3 :                 zero_extend_signed_to_ull(d.d_ino),
      51                 :          6 :                 zero_extend_signed_to_ull(d.d_off), d.d_reclen);
      52         [ -  + ]:          3 :         if (d.d_reclen > D_NAME_LEN_MAX)
      53                 :          0 :                 d.d_reclen = D_NAME_LEN_MAX;
      54                 :          3 :         printpathn(tcp, addr + offsetof(kernel_dirent, d_name), d.d_reclen);
      55                 :          3 :         tprints("}");
      56                 :            : }
      57                 :            : 
      58                 :          8 : SYS_FUNC(readdir)
      59                 :            : {
      60         [ +  + ]:          8 :         if (entering(tcp)) {
      61                 :          4 :                 printfd(tcp, tcp->u_arg[0]);
      62                 :          4 :                 tprints(", ");
      63                 :            :         } else {
      64         [ +  + ]:          4 :                 if (tcp->u_rval == 0)
      65                 :          1 :                         printaddr(tcp->u_arg[1]);
      66                 :            :                 else
      67                 :          3 :                         print_old_dirent(tcp, tcp->u_arg[1]);
      68                 :            :                 /* Not much point in printing this out, it is always 1. */
      69         [ -  + ]:          4 :                 if (tcp->u_arg[2] != 1)
      70                 :          0 :                         tprintf(", %" PRI_klu, tcp->u_arg[2]);
      71                 :            :         }
      72                 :          8 :         return 0;
      73                 :            : }
      74                 :            : 
      75                 :         12 : SYS_FUNC(getdents)
      76                 :            : {
      77                 :         12 :         unsigned int i, len, dents = 0;
      78                 :            :         unsigned char *buf;
      79                 :            : 
      80         [ +  + ]:         12 :         if (entering(tcp)) {
      81                 :          6 :                 printfd(tcp, tcp->u_arg[0]);
      82                 :          6 :                 return 0;
      83                 :            :         }
      84                 :            : 
      85                 :          6 :         const unsigned int count = tcp->u_arg[2];
      86                 :            : 
      87 [ +  + ][ -  + ]:          6 :         if (syserror(tcp) || !verbose(tcp)) {
      88                 :          2 :                 tprints(", ");
      89                 :          2 :                 printaddr(tcp->u_arg[1]);
      90                 :          2 :                 tprintf(", %u", count);
      91                 :          2 :                 return 0;
      92                 :            :         }
      93                 :            : 
      94                 :            :         /* Beware of insanely large or too small values in tcp->u_rval */
      95         [ +  - ]:          4 :         if (tcp->u_rval > 1024*1024)
      96                 :            :                 len = 1024*1024;
      97         [ +  + ]:          4 :         else if (tcp->u_rval < (int) sizeof(kernel_dirent))
      98                 :            :                 len = 0;
      99                 :            :         else
     100                 :          2 :                 len = tcp->u_rval;
     101                 :            : 
     102         [ +  + ]:          4 :         if (len) {
     103                 :          2 :                 buf = malloc(len);
     104 [ +  - ][ -  + ]:          2 :                 if (!buf || umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
     105                 :          0 :                         tprints(", ");
     106                 :          0 :                         printaddr(tcp->u_arg[1]);
     107                 :          0 :                         tprintf(", %u", count);
     108                 :          0 :                         free(buf);
     109                 :          0 :                         return 0;
     110                 :            :                 }
     111                 :            :         } else {
     112                 :            :                 buf = NULL;
     113                 :            :         }
     114                 :            : 
     115                 :          4 :         tprints(",");
     116         [ +  - ]:          4 :         if (!abbrev(tcp))
     117                 :          4 :                 tprints(" [");
     118 [ +  + ][ +  + ]:         10 :         for (i = 0; len && i <= len - sizeof(kernel_dirent); ) {
     119                 :          6 :                 kernel_dirent *d = (kernel_dirent *) &buf[i];
     120                 :            : 
     121         [ +  - ]:          6 :                 if (!abbrev(tcp)) {
     122 [ +  - ][ +  - ]:          6 :                         int oob = d->d_reclen < sizeof(kernel_dirent) ||
     123                 :          6 :                                   i + d->d_reclen - 1 >= len;
     124         [ -  + ]:          6 :                         int d_name_len = oob ? len - i : d->d_reclen;
     125                 :          6 :                         d_name_len -= offsetof(kernel_dirent, d_name) + 1;
     126         [ +  + ]:          6 :                         if (d_name_len > D_NAME_LEN_MAX)
     127                 :          2 :                                 d_name_len = D_NAME_LEN_MAX;
     128                 :            : 
     129         [ +  + ]:          6 :                         tprintf("%s{d_ino=%llu, d_off=%llu, d_reclen=%u"
     130                 :            :                                 ", d_name=", i ? ", " : "",
     131                 :          6 :                                 zero_extend_signed_to_ull(d->d_ino),
     132                 :          6 :                                 zero_extend_signed_to_ull(d->d_off),
     133                 :            :                                 d->d_reclen);
     134                 :            : 
     135                 :          6 :                         print_quoted_cstring(d->d_name, d_name_len);
     136                 :            : 
     137                 :          6 :                         tprints(", d_type=");
     138         [ -  + ]:          6 :                         if (oob)
     139                 :          0 :                                 tprints("?");
     140                 :            :                         else
     141                 :          6 :                                 printxval(dirent_types, buf[i + d->d_reclen - 1], "DT_???");
     142                 :          6 :                         tprints("}");
     143                 :            :                 }
     144                 :          6 :                 dents++;
     145         [ -  + ]:          6 :                 if (d->d_reclen < sizeof(kernel_dirent)) {
     146                 :          0 :                         tprints_comment("d_reclen < sizeof(struct dirent)");
     147                 :          0 :                         break;
     148                 :            :                 }
     149                 :          6 :                 i += d->d_reclen;
     150                 :            :         }
     151         [ +  - ]:          4 :         if (!abbrev(tcp))
     152                 :          4 :                 tprints("]");
     153                 :            :         else
     154                 :          0 :                 tprintf_comment("%u entries", dents);
     155                 :          4 :         tprintf(", %u", count);
     156                 :          4 :         free(buf);
     157                 :          4 :         return 0;
     158                 :            : }

Generated by: LCOV version 1.11