1999-02-19 03:21:36 +03:00
/*
* Copyright ( c ) 1991 , 1992 Paul Kranenburg < pk @ cs . few . eur . nl >
* Copyright ( c ) 1993 Branko Lankester < branko @ hacktic . nl >
* Copyright ( c ) 1993 , 1994 , 1995 , 1996 Rick Sladkey < jrs @ world . std . com >
1999-12-23 17:20:14 +03:00
* Copyright ( c ) 1996 - 1999 Wichert Akkerman < wichert @ cistron . nl >
* Copyright ( c ) 1999 IBM Deutschland Entwicklung GmbH , IBM Corporation
* Linux for s390 port by D . J . Barrow
* < barrow_dj @ mail . yahoo . com , djbarrow @ de . ibm . com >
1999-02-19 03:21:36 +03:00
* All rights reserved .
*
* Redistribution and use in source and binary forms , with or without
* modification , are permitted provided that the following conditions
* are met :
* 1. Redistributions of source code must retain the above copyright
* notice , this list of conditions and the following disclaimer .
* 2. Redistributions in binary form must reproduce the above copyright
* notice , this list of conditions and the following disclaimer in the
* documentation and / or other materials provided with the distribution .
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission .
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ` ` AS IS ' ' AND ANY EXPRESS OR
* IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED .
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT , INDIRECT ,
* INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL DAMAGES ( INCLUDING , BUT
* NOT LIMITED TO , PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE ,
* DATA , OR PROFITS ; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT LIABILITY , OR TORT
* ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE , EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE .
*/
# include "defs.h"
# include <sys/param.h>
# include <fcntl.h>
decode extend getsockopt/setsockopt options
Currently the code assumes the set of valid options between getsockopt
and setsockopt are exactly the same and thus maintains one list. The
kernel unfortunately does not do this -- it allows for different opts
between the get and set functions. See the {g,s}et_opt{min,max} fields
in the various netfilter subcores.
To support this, extend the printxval function to take multiple sets of
xlats as varargs. Then we add the new get/set lists, and pass them down
in the net code when decoding things.
A simple example is iptables; before:
getsockopt(4, SOL_IP, 0x40 /* IP_??? */, ...) = 0
getsockopt(4, SOL_IP, 0x41 /* IP_??? */, ...) = 0
after:
getsockopt(4, SOL_IP, IPT_SO_GET_INFO, ...) = 0
getsockopt(4, SOL_IP, IPT_SO_GET_ENTRIES, ...) = 0
If these were setsockopt calls, then 0x40 & 0x41 would be
IPT_SO_SET_REPLACE & IPT_SO_SET_ADD_COUNTERS.
* configure.ac: Check for netfilter headers.
* defs.h (printxvals): New prototype.
(printxval): Change to a define.
* net.c: Include netfilter headers and new sockopts headers.
(print_sockopt_fd_level_name): Add a is_getsockopt argument. Change SOL_IP
and SOL_IPV6 decoding to use printxvals, and use is_getsockopt to pass more
xlats down.
(getsockopt): Call print_sockopt_fd_level_name with is_getsockopt as true.
(setsockopt): Call print_sockopt_fd_level_name with is_getsockopt as false.
* util.c (printxval): Rename to ...
(printxvals): ... this. Rewrite to be varargs based.
* xlat/getsockipoptions.in: New xlat list.
* xlat/getsockipv6options.in, xlat/setsockipoptions.in,
xlat/setsockipv6options.in: Likewise.
2015-08-19 20:29:27 +03:00
# include <stdarg.h>
2015-06-17 23:09:13 +03:00
# ifdef HAVE_SYS_XATTR_H
2014-11-22 13:03:33 +03:00
# include <sys / xattr.h>
# endif
2014-11-21 23:46:16 +03:00
# include <sys/uio.h>
2017-01-01 01:12:08 +03:00
# include <asm/unistd.h>
1999-07-13 19:45:02 +04:00
2017-01-03 01:37:57 +03:00
# include "scno.h"
2015-02-13 05:12:14 +03:00
# include "regs.h"
2015-02-28 15:20:21 +03:00
# include "ptrace.h"
1999-05-09 04:29:58 +04:00
2012-03-26 01:49:48 +04:00
int
2016-11-16 03:58:05 +03:00
string_to_uint_ex ( const char * const str , char * * const endptr ,
const unsigned int max_val , const char * const accepted_ending )
2012-03-26 01:49:48 +04:00
{
2016-11-16 03:58:05 +03:00
char * end ;
long val ;
2012-03-26 01:49:48 +04:00
if ( ! * str )
return - 1 ;
2016-11-16 03:58:05 +03:00
2016-11-30 17:39:02 +03:00
errno = 0 ;
2016-11-16 03:58:05 +03:00
val = strtol ( str , & end , 10 ) ;
2016-11-30 17:39:02 +03:00
if ( str = = end | | val < 0 | | ( unsigned long ) val > max_val
| | ( val = = LONG_MAX & & errno = = ERANGE ) )
2012-03-26 01:49:48 +04:00
return - 1 ;
2016-11-16 03:58:05 +03:00
if ( * end & & ( ! accepted_ending | | ! strchr ( accepted_ending , * end ) ) )
return - 1 ;
if ( endptr )
* endptr = end ;
return ( int ) val ;
}
int
string_to_uint ( const char * const str )
{
return string_to_uint_upto ( str , INT_MAX ) ;
2012-03-26 01:49:48 +04:00
}
1999-02-19 03:21:36 +03:00
int
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_nz ( const struct timeval * a )
1999-02-19 03:21:36 +03:00
{
return a - > tv_sec | | a - > tv_usec ;
}
int
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_cmp ( const struct timeval * a , const struct timeval * b )
1999-02-19 03:21:36 +03:00
{
if ( a - > tv_sec < b - > tv_sec
| | ( a - > tv_sec = = b - > tv_sec & & a - > tv_usec < b - > tv_usec ) )
return - 1 ;
if ( a - > tv_sec > b - > tv_sec
| | ( a - > tv_sec = = b - > tv_sec & & a - > tv_usec > b - > tv_usec ) )
return 1 ;
return 0 ;
}
double
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_float ( const struct timeval * tv )
1999-02-19 03:21:36 +03:00
{
return tv - > tv_sec + tv - > tv_usec / 1000000.0 ;
}
void
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_add ( struct timeval * tv , const struct timeval * a , const struct timeval * b )
1999-02-19 03:21:36 +03:00
{
tv - > tv_sec = a - > tv_sec + b - > tv_sec ;
tv - > tv_usec = a - > tv_usec + b - > tv_usec ;
2007-07-24 05:38:22 +04:00
if ( tv - > tv_usec > = 1000000 ) {
1999-02-19 03:21:36 +03:00
tv - > tv_sec + + ;
tv - > tv_usec - = 1000000 ;
}
}
void
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_sub ( struct timeval * tv , const struct timeval * a , const struct timeval * b )
1999-02-19 03:21:36 +03:00
{
tv - > tv_sec = a - > tv_sec - b - > tv_sec ;
tv - > tv_usec = a - > tv_usec - b - > tv_usec ;
if ( ( ( long ) tv - > tv_usec ) < 0 ) {
tv - > tv_sec - - ;
tv - > tv_usec + = 1000000 ;
}
}
void
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_div ( struct timeval * tv , const struct timeval * a , int n )
1999-02-19 03:21:36 +03:00
{
tv - > tv_usec = ( a - > tv_sec % n * 1000000 + a - > tv_usec + n / 2 ) / n ;
tv - > tv_sec = a - > tv_sec / n + tv - > tv_usec / 1000000 ;
tv - > tv_usec % = 1000000 ;
}
void
Constify tv_* functions
* defs.h (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div): Add
const qualifier to read only arguments.
* util.c (tv_nz, tv_cmp, tv_float, tv_add, tv_sub, tv_mul, tv_div):
Likewise.
2014-05-29 21:59:01 +04:00
tv_mul ( struct timeval * tv , const struct timeval * a , int n )
1999-02-19 03:21:36 +03:00
{
tv - > tv_usec = a - > tv_usec * n ;
2007-06-30 01:25:56 +04:00
tv - > tv_sec = a - > tv_sec * n + tv - > tv_usec / 1000000 ;
1999-02-19 03:21:36 +03:00
tv - > tv_usec % = 1000000 ;
}
2007-01-12 01:05:04 +03:00
const char *
2016-05-15 00:55:35 +03:00
xlookup ( const struct xlat * xlat , const uint64_t val )
1999-02-19 03:21:36 +03:00
{
for ( ; xlat - > str ! = NULL ; xlat + + )
if ( xlat - > val = = val )
return xlat - > str ;
return NULL ;
}
2014-09-22 02:42:45 +04:00
static int
xlat_bsearch_compare ( const void * a , const void * b )
{
2016-04-28 21:37:54 +03:00
const uint64_t val1 = * ( const uint64_t * ) a ;
const uint64_t val2 = ( ( const struct xlat * ) b ) - > val ;
2014-09-22 02:42:45 +04:00
return ( val1 > val2 ) ? 1 : ( val1 < val2 ) ? - 1 : 0 ;
}
const char *
2016-04-28 21:37:54 +03:00
xlat_search ( const struct xlat * xlat , const size_t nmemb , const uint64_t val )
2014-09-22 02:42:45 +04:00
{
const struct xlat * e =
2016-04-28 21:37:54 +03:00
bsearch ( ( const void * ) & val ,
2014-09-22 02:42:45 +04:00
xlat , nmemb , sizeof ( * xlat ) , xlat_bsearch_compare ) ;
return e ? e - > str : NULL ;
}
2011-09-01 18:31:48 +04:00
# if !defined HAVE_STPCPY
2011-08-31 14:07:38 +04:00
char *
stpcpy ( char * dst , const char * src )
{
while ( ( * dst = * src + + ) ! = ' \0 ' )
dst + + ;
return dst ;
}
2011-09-01 18:31:48 +04:00
# endif
2011-08-31 14:07:38 +04:00
2013-11-09 23:40:31 +04:00
/* Find a next bit which is set.
* Starts testing at cur_bit .
* Returns - 1 if no more bits are set .
*
* We never touch bytes we don ' t need to .
* On big - endian , array is assumed to consist of
* current_wordsize wide words : for example , is current_wordsize is 4 ,
* the bytes are walked in 3 , 2 , 1 , 0 , 7 , 6 , 5 , 4 , 11 , 10 , 9 , 8 . . . sequence .
* On little - endian machines , word size is immaterial .
*/
int
next_set_bit ( const void * bit_array , unsigned cur_bit , unsigned size_bits )
{
const unsigned endian = 1 ;
2016-07-26 18:59:28 +03:00
int little_endian = * ( char * ) ( void * ) & endian ;
2013-11-09 23:40:31 +04:00
const uint8_t * array = bit_array ;
unsigned pos = cur_bit / 8 ;
unsigned pos_xor_mask = little_endian ? 0 : current_wordsize - 1 ;
for ( ; ; ) {
uint8_t bitmask ;
uint8_t cur_byte ;
if ( cur_bit > = size_bits )
return - 1 ;
cur_byte = array [ pos ^ pos_xor_mask ] ;
if ( cur_byte = = 0 ) {
cur_bit = ( cur_bit + 8 ) & ( - 8 ) ;
pos + + ;
continue ;
}
bitmask = 1 < < ( cur_bit & 7 ) ;
for ( ; ; ) {
if ( cur_byte & bitmask )
return cur_bit ;
cur_bit + + ;
if ( cur_bit > = size_bits )
return - 1 ;
bitmask < < = 1 ;
/* This check *can't be* optimized out: */
if ( bitmask = = 0 )
break ;
}
pos + + ;
}
}
2016-11-27 18:04:58 +03:00
/**
1999-02-19 03:21:36 +03:00
* Print entry in struct xlat table , if there .
2016-11-27 18:04:58 +03:00
*
* @ param val Value to search a literal representation for .
* @ param dflt String ( abbreviated in comment syntax ) which should be emitted
* if no appropriate xlat value has been found .
* @ param xlat ( And the following arguments ) Pointers to arrays of xlat values .
* The last argument should be NULL .
* @ return 1 if appropriate xlat value has been found , 0 otherwise .
1999-02-19 03:21:36 +03:00
*/
2016-11-27 18:04:58 +03:00
int
2016-04-28 21:42:10 +03:00
printxvals ( const uint64_t val , const char * dflt , const struct xlat * xlat , . . . )
1999-02-19 03:21:36 +03:00
{
decode extend getsockopt/setsockopt options
Currently the code assumes the set of valid options between getsockopt
and setsockopt are exactly the same and thus maintains one list. The
kernel unfortunately does not do this -- it allows for different opts
between the get and set functions. See the {g,s}et_opt{min,max} fields
in the various netfilter subcores.
To support this, extend the printxval function to take multiple sets of
xlats as varargs. Then we add the new get/set lists, and pass them down
in the net code when decoding things.
A simple example is iptables; before:
getsockopt(4, SOL_IP, 0x40 /* IP_??? */, ...) = 0
getsockopt(4, SOL_IP, 0x41 /* IP_??? */, ...) = 0
after:
getsockopt(4, SOL_IP, IPT_SO_GET_INFO, ...) = 0
getsockopt(4, SOL_IP, IPT_SO_GET_ENTRIES, ...) = 0
If these were setsockopt calls, then 0x40 & 0x41 would be
IPT_SO_SET_REPLACE & IPT_SO_SET_ADD_COUNTERS.
* configure.ac: Check for netfilter headers.
* defs.h (printxvals): New prototype.
(printxval): Change to a define.
* net.c: Include netfilter headers and new sockopts headers.
(print_sockopt_fd_level_name): Add a is_getsockopt argument. Change SOL_IP
and SOL_IPV6 decoding to use printxvals, and use is_getsockopt to pass more
xlats down.
(getsockopt): Call print_sockopt_fd_level_name with is_getsockopt as true.
(setsockopt): Call print_sockopt_fd_level_name with is_getsockopt as false.
* util.c (printxval): Rename to ...
(printxvals): ... this. Rewrite to be varargs based.
* xlat/getsockipoptions.in: New xlat list.
* xlat/getsockipv6options.in, xlat/setsockipoptions.in,
xlat/setsockipv6options.in: Likewise.
2015-08-19 20:29:27 +03:00
va_list args ;
1999-02-19 03:21:36 +03:00
decode extend getsockopt/setsockopt options
Currently the code assumes the set of valid options between getsockopt
and setsockopt are exactly the same and thus maintains one list. The
kernel unfortunately does not do this -- it allows for different opts
between the get and set functions. See the {g,s}et_opt{min,max} fields
in the various netfilter subcores.
To support this, extend the printxval function to take multiple sets of
xlats as varargs. Then we add the new get/set lists, and pass them down
in the net code when decoding things.
A simple example is iptables; before:
getsockopt(4, SOL_IP, 0x40 /* IP_??? */, ...) = 0
getsockopt(4, SOL_IP, 0x41 /* IP_??? */, ...) = 0
after:
getsockopt(4, SOL_IP, IPT_SO_GET_INFO, ...) = 0
getsockopt(4, SOL_IP, IPT_SO_GET_ENTRIES, ...) = 0
If these were setsockopt calls, then 0x40 & 0x41 would be
IPT_SO_SET_REPLACE & IPT_SO_SET_ADD_COUNTERS.
* configure.ac: Check for netfilter headers.
* defs.h (printxvals): New prototype.
(printxval): Change to a define.
* net.c: Include netfilter headers and new sockopts headers.
(print_sockopt_fd_level_name): Add a is_getsockopt argument. Change SOL_IP
and SOL_IPV6 decoding to use printxvals, and use is_getsockopt to pass more
xlats down.
(getsockopt): Call print_sockopt_fd_level_name with is_getsockopt as true.
(setsockopt): Call print_sockopt_fd_level_name with is_getsockopt as false.
* util.c (printxval): Rename to ...
(printxvals): ... this. Rewrite to be varargs based.
* xlat/getsockipoptions.in: New xlat list.
* xlat/getsockipv6options.in, xlat/setsockipoptions.in,
xlat/setsockipv6options.in: Likewise.
2015-08-19 20:29:27 +03:00
va_start ( args , xlat ) ;
for ( ; xlat ; xlat = va_arg ( args , const struct xlat * ) ) {
const char * str = xlookup ( xlat , val ) ;
if ( str ) {
tprints ( str ) ;
va_end ( args ) ;
2016-11-27 18:04:58 +03:00
return 1 ;
decode extend getsockopt/setsockopt options
Currently the code assumes the set of valid options between getsockopt
and setsockopt are exactly the same and thus maintains one list. The
kernel unfortunately does not do this -- it allows for different opts
between the get and set functions. See the {g,s}et_opt{min,max} fields
in the various netfilter subcores.
To support this, extend the printxval function to take multiple sets of
xlats as varargs. Then we add the new get/set lists, and pass them down
in the net code when decoding things.
A simple example is iptables; before:
getsockopt(4, SOL_IP, 0x40 /* IP_??? */, ...) = 0
getsockopt(4, SOL_IP, 0x41 /* IP_??? */, ...) = 0
after:
getsockopt(4, SOL_IP, IPT_SO_GET_INFO, ...) = 0
getsockopt(4, SOL_IP, IPT_SO_GET_ENTRIES, ...) = 0
If these were setsockopt calls, then 0x40 & 0x41 would be
IPT_SO_SET_REPLACE & IPT_SO_SET_ADD_COUNTERS.
* configure.ac: Check for netfilter headers.
* defs.h (printxvals): New prototype.
(printxval): Change to a define.
* net.c: Include netfilter headers and new sockopts headers.
(print_sockopt_fd_level_name): Add a is_getsockopt argument. Change SOL_IP
and SOL_IPV6 decoding to use printxvals, and use is_getsockopt to pass more
xlats down.
(getsockopt): Call print_sockopt_fd_level_name with is_getsockopt as true.
(setsockopt): Call print_sockopt_fd_level_name with is_getsockopt as false.
* util.c (printxval): Rename to ...
(printxvals): ... this. Rewrite to be varargs based.
* xlat/getsockipoptions.in: New xlat list.
* xlat/getsockipv6options.in, xlat/setsockipoptions.in,
xlat/setsockipv6options.in: Likewise.
2015-08-19 20:29:27 +03:00
}
}
/* No hits -- print raw # instead. */
2016-11-27 18:03:38 +03:00
tprintf ( " %# " PRIx64 , val ) ;
Introduce tprintf_comment and tprints_comment functions
* defs.h (tprintf_comment, tprints_comment): New prototypes.
* strace.c (tvprintf): New function.
(tprintf): Use it.
(tprintf_comment, tprints_comment): New functions.
* aio.c (tprint_lio_opcode): Use tprints_comment.
* dm.c (dm_decode_dm_target_spec, dm_decode_dm_target_deps,
dm_decode_dm_name_list, dm_decode_dm_target_versions,
dm_decode_dm_target_msg, dm_decode_string, dm_known_ioctl): Likewise.
* futex.c (SYS_FUNC(futex)): Likewise.
* perf.c (print_perf_event_attr): Likewise.
* seccomp.c (decode_bpf_code): Likewise.
* util.c (printxvals, printxval_searchn, printflags64): Likewise.
* btrfs.c (print_u64, btrfs_print_key_type, btrfs_print_objectid,
print_key_value_internal): Likewise.
(btrfs_ioctl): Use tprints_comment and tprintf_comment.
* dirent.c (SYS_FUNC(getdents)): Likewise.
* dirent64.c (SYS_FUNC(getdents64)): Likewise.
* execve.c (printargc): Use tprintf_comment.
* tests/btrfs.c (btrfs_test_get_dev_stats_ioctl,
btrfs_test_features_ioctls): Update expected output.
2017-04-24 22:31:54 +03:00
tprints_comment ( dflt ) ;
decode extend getsockopt/setsockopt options
Currently the code assumes the set of valid options between getsockopt
and setsockopt are exactly the same and thus maintains one list. The
kernel unfortunately does not do this -- it allows for different opts
between the get and set functions. See the {g,s}et_opt{min,max} fields
in the various netfilter subcores.
To support this, extend the printxval function to take multiple sets of
xlats as varargs. Then we add the new get/set lists, and pass them down
in the net code when decoding things.
A simple example is iptables; before:
getsockopt(4, SOL_IP, 0x40 /* IP_??? */, ...) = 0
getsockopt(4, SOL_IP, 0x41 /* IP_??? */, ...) = 0
after:
getsockopt(4, SOL_IP, IPT_SO_GET_INFO, ...) = 0
getsockopt(4, SOL_IP, IPT_SO_GET_ENTRIES, ...) = 0
If these were setsockopt calls, then 0x40 & 0x41 would be
IPT_SO_SET_REPLACE & IPT_SO_SET_ADD_COUNTERS.
* configure.ac: Check for netfilter headers.
* defs.h (printxvals): New prototype.
(printxval): Change to a define.
* net.c: Include netfilter headers and new sockopts headers.
(print_sockopt_fd_level_name): Add a is_getsockopt argument. Change SOL_IP
and SOL_IPV6 decoding to use printxvals, and use is_getsockopt to pass more
xlats down.
(getsockopt): Call print_sockopt_fd_level_name with is_getsockopt as true.
(setsockopt): Call print_sockopt_fd_level_name with is_getsockopt as false.
* util.c (printxval): Rename to ...
(printxvals): ... this. Rewrite to be varargs based.
* xlat/getsockipoptions.in: New xlat list.
* xlat/getsockipv6options.in, xlat/setsockipoptions.in,
xlat/setsockipv6options.in: Likewise.
2015-08-19 20:29:27 +03:00
va_end ( args ) ;
2016-11-27 18:04:58 +03:00
return 0 ;
1999-02-19 03:21:36 +03:00
}
2016-11-27 18:04:58 +03:00
/**
2016-10-29 05:26:50 +03:00
* Print entry in sorted struct xlat table , if it is there .
2016-11-27 18:04:58 +03:00
*
* @ param xlat Pointer to an array of xlat values ( not terminated with
* XLAT_END ) .
* @ param xlat_size Number of xlat elements present in array ( usually ARRAY_SIZE
* if array is declared in the unit ' s scope and not
* terminated with XLAT_END ) .
* @ param val Value to search literal representation for .
* @ param dflt String ( abbreviated in comment syntax ) which should be
* emitted if no appropriate xlat value has been found .
* @ return 1 if appropriate xlat value has been found , 0
* otherwise .
2016-10-29 05:26:50 +03:00
*/
2016-11-27 18:04:58 +03:00
int
2016-10-29 05:26:50 +03:00
printxval_searchn ( const struct xlat * xlat , size_t xlat_size , uint64_t val ,
const char * dflt )
{
const char * s = xlat_search ( xlat , xlat_size , val ) ;
if ( s ) {
tprints ( s ) ;
2016-11-27 18:04:58 +03:00
return 1 ;
2016-10-29 05:26:50 +03:00
}
2016-11-27 18:04:58 +03:00
tprintf ( " %# " PRIx64 , val ) ;
Introduce tprintf_comment and tprints_comment functions
* defs.h (tprintf_comment, tprints_comment): New prototypes.
* strace.c (tvprintf): New function.
(tprintf): Use it.
(tprintf_comment, tprints_comment): New functions.
* aio.c (tprint_lio_opcode): Use tprints_comment.
* dm.c (dm_decode_dm_target_spec, dm_decode_dm_target_deps,
dm_decode_dm_name_list, dm_decode_dm_target_versions,
dm_decode_dm_target_msg, dm_decode_string, dm_known_ioctl): Likewise.
* futex.c (SYS_FUNC(futex)): Likewise.
* perf.c (print_perf_event_attr): Likewise.
* seccomp.c (decode_bpf_code): Likewise.
* util.c (printxvals, printxval_searchn, printflags64): Likewise.
* btrfs.c (print_u64, btrfs_print_key_type, btrfs_print_objectid,
print_key_value_internal): Likewise.
(btrfs_ioctl): Use tprints_comment and tprintf_comment.
* dirent.c (SYS_FUNC(getdents)): Likewise.
* dirent64.c (SYS_FUNC(getdents64)): Likewise.
* execve.c (printargc): Use tprintf_comment.
* tests/btrfs.c (btrfs_test_get_dev_stats_ioctl,
btrfs_test_features_ioctls): Update expected output.
2017-04-24 22:31:54 +03:00
tprints_comment ( dflt ) ;
2016-11-27 18:04:58 +03:00
return 0 ;
2016-10-29 05:26:50 +03:00
}
2009-11-04 19:08:34 +03:00
/*
2015-01-10 03:08:58 +03:00
* Fetch 64 bit argument at position arg_no and
* return the index of the next argument .
2009-11-04 19:08:34 +03:00
*/
int
2015-01-10 03:08:58 +03:00
getllval ( struct tcb * tcp , unsigned long long * val , int arg_no )
2009-11-04 19:08:34 +03:00
{
2016-12-26 19:54:31 +03:00
# if SIZEOF_KERNEL_LONG_T > 4
2016-12-19 21:30:22 +03:00
# ifndef current_klongsize
2016-12-26 19:54:31 +03:00
if ( current_klongsize < SIZEOF_KERNEL_LONG_T ) {
2013-05-04 23:51:57 +04:00
# if defined(AARCH64) || defined(POWERPC64)
Fix preadv/pwritev offset decoding on bigendian architectures
This partially reverts commit 7845a42b39e59e904d01e75e21f7bc7eb6462560.
* util.c (printllval): Remove align argument.
* defs.h (printllval): Update prototype.
(printllval_aligned, printllval_unaligned): Remove.
* file.c (sys_readahead, sys_truncate64, sys_ftruncate64, sys_fadvise64,
sys_fadvise64_64, sys_sync_file_range, sys_sync_file_range2,
sys_fallocate): Replace printllval_aligned call with printllval.
* io.c (sys_pread, sys_pwrite): Likewise.
(print_llu_from_low_high_val): New function.
(sys_preadv, sys_pwritev): Use it instead of printllval_unaligned.
2014-08-07 04:07:28 +04:00
/* Align arg_no to the next even number. */
arg_no = ( arg_no + 1 ) & 0xe ;
2015-01-10 03:08:58 +03:00
# endif /* AARCH64 || POWERPC64 */
2016-12-23 22:12:38 +03:00
* val = ULONG_LONG ( tcp - > u_arg [ arg_no ] , tcp - > u_arg [ arg_no + 1 ] ) ;
2013-03-01 13:41:02 +04:00
arg_no + = 2 ;
2016-12-19 21:30:22 +03:00
} else
# endif /* !current_klongsize */
{
* val = tcp - > u_arg [ arg_no ] ;
arg_no + + ;
2009-11-04 19:08:34 +03:00
}
2016-12-26 19:54:31 +03:00
# else /* SIZEOF_KERNEL_LONG_T == 4 */
2013-05-06 22:23:01 +04:00
# if defined __ARM_EABI__ || \
defined LINUX_MIPSO32 | | \
defined POWERPC | | \
defined XTENSA
Fix preadv/pwritev offset decoding on bigendian architectures
This partially reverts commit 7845a42b39e59e904d01e75e21f7bc7eb6462560.
* util.c (printllval): Remove align argument.
* defs.h (printllval): Update prototype.
(printllval_aligned, printllval_unaligned): Remove.
* file.c (sys_readahead, sys_truncate64, sys_ftruncate64, sys_fadvise64,
sys_fadvise64_64, sys_sync_file_range, sys_sync_file_range2,
sys_fallocate): Replace printllval_aligned call with printllval.
* io.c (sys_pread, sys_pwrite): Likewise.
(print_llu_from_low_high_val): New function.
(sys_preadv, sys_pwritev): Use it instead of printllval_unaligned.
2014-08-07 04:07:28 +04:00
/* Align arg_no to the next even number. */
arg_no = ( arg_no + 1 ) & 0xe ;
2016-08-20 17:02:55 +03:00
# elif defined SH
/*
* The SH4 ABI does allow long longs in odd - numbered registers , but
* does not allow them to be split between registers and memory - and
* there are only four argument registers for normal functions . As a
* result , pread , for example , takes an extra padding argument before
* the offset . This was changed late in the 2.4 series ( around 2.4 .20 ) .
*/
if ( arg_no = = 3 )
arg_no + + ;
# endif /* __ARM_EABI__ || LINUX_MIPSO32 || POWERPC || XTENSA || SH */
2016-12-23 22:12:38 +03:00
* val = ULONG_LONG ( tcp - > u_arg [ arg_no ] , tcp - > u_arg [ arg_no + 1 ] ) ;
2013-03-01 13:41:02 +04:00
arg_no + = 2 ;
2013-02-18 01:41:33 +04:00
# endif
2013-05-04 23:51:57 +04:00
2013-03-01 13:41:02 +04:00
return arg_no ;
2009-11-04 19:08:34 +03:00
}
2015-01-10 03:08:58 +03:00
/*
* Print 64 bit argument at position arg_no and
* return the index of the next argument .
*/
int
printllval ( struct tcb * tcp , const char * format , int arg_no )
{
unsigned long long val = 0 ;
arg_no = getllval ( tcp , & val , arg_no ) ;
tprintf ( format , val ) ;
return arg_no ;
}
1999-02-19 03:21:36 +03:00
/*
* Interpret ` xlat ' as an array of flags
* print the entries whose bits are on in ` flags '
*/
2011-08-19 20:06:46 +04:00
void
2016-04-28 21:19:27 +03:00
addflags ( const struct xlat * xlat , uint64_t flags )
1999-02-19 03:21:36 +03:00
{
2011-08-19 20:06:46 +04:00
for ( ; xlat - > str ; xlat + + ) {
1999-02-19 03:21:36 +03:00
if ( xlat - > val & & ( flags & xlat - > val ) = = xlat - > val ) {
tprintf ( " |%s " , xlat - > str ) ;
flags & = ~ xlat - > val ;
}
}
if ( flags ) {
2016-04-28 21:19:27 +03:00
tprintf ( " |%# " PRIx64 , flags ) ;
1999-02-19 03:21:36 +03:00
}
}
2007-11-02 00:46:22 +03:00
/*
2011-08-19 20:06:46 +04:00
* Interpret ` xlat ' as an array of flags .
2007-11-02 00:46:22 +03:00
* Print to static string the entries whose bits are on in ` flags '
* Return static string .
*/
const char *
2016-05-15 17:26:03 +03:00
sprintflags ( const char * prefix , const struct xlat * xlat , uint64_t flags )
2007-11-02 00:46:22 +03:00
{
static char outstr [ 1024 ] ;
2011-08-31 14:07:38 +04:00
char * outptr ;
2007-11-02 00:46:22 +03:00
int found = 0 ;
2011-08-31 14:07:38 +04:00
outptr = stpcpy ( outstr , prefix ) ;
2007-11-02 00:46:22 +03:00
2015-11-15 23:44:13 +03:00
if ( flags = = 0 & & xlat - > val = = 0 & & xlat - > str ) {
strcpy ( outptr , xlat - > str ) ;
return outstr ;
}
2007-11-02 00:46:22 +03:00
for ( ; xlat - > str ; xlat + + ) {
2015-11-15 23:44:13 +03:00
if ( xlat - > val & & ( flags & xlat - > val ) = = xlat - > val ) {
2007-11-02 00:46:22 +03:00
if ( found )
2011-08-31 14:07:38 +04:00
* outptr + + = ' | ' ;
outptr = stpcpy ( outptr , xlat - > str ) ;
2007-11-02 00:46:22 +03:00
found = 1 ;
2012-01-30 01:38:35 +04:00
flags & = ~ xlat - > val ;
if ( ! flags )
break ;
2007-11-02 00:46:22 +03:00
}
}
if ( flags ) {
if ( found )
2011-08-31 14:07:38 +04:00
* outptr + + = ' | ' ;
2016-04-28 21:49:36 +03:00
outptr + = sprintf ( outptr , " %# " PRIx64 , flags ) ;
2007-11-02 00:46:22 +03:00
}
return outstr ;
}
1999-02-19 03:21:36 +03:00
int
2016-04-28 21:55:18 +03:00
printflags64 ( const struct xlat * xlat , uint64_t flags , const char * dflt )
1999-02-19 03:21:36 +03:00
{
int n ;
2010-09-07 02:08:24 +04:00
const char * sep ;
1999-02-19 03:21:36 +03:00
2015-10-31 07:47:59 +03:00
if ( flags = = 0 & & xlat - > val = = 0 & & xlat - > str ) {
2011-09-01 11:55:05 +04:00
tprints ( xlat - > str ) ;
1999-02-19 03:21:36 +03:00
return 1 ;
}
sep = " " ;
for ( n = 0 ; xlat - > str ; xlat + + ) {
if ( xlat - > val & & ( flags & xlat - > val ) = = xlat - > val ) {
tprintf ( " %s%s " , sep , xlat - > str ) ;
flags & = ~ xlat - > val ;
sep = " | " ;
n + + ;
}
}
2005-05-31 Dmitry V. Levin <ldv@altlinux.org>
* util.c (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument, "const char *", with similar
meaning to the third argument of printxval().
* defs.h (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument.
* bjm.c (sys_query_module) [LINUX]: Pass third argument to
printflags().
* desc.c (sys_fcntl): Likewise.
(sys_flock) [LOCK_SH]: Likewise.
(print_epoll_event) [HAVE_SYS_EPOLL_H]: Likewise.
* file.c (sys_open): Likewise.
(solaris_open) [LINUXSPARC]: Likewise.
(sys_access): Likewise.
(sys_chflags, sys_fchflags) [FREEBSD]: Likewise.
(realprintstat) [HAVE_LONG_LONG_OFF_T &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(printstat64) [HAVE_STAT64 &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(sys_setxattr, sys_fsetxattr): Likewise.
* ipc.c (sys_msgget, sys_msgsnd, sys_msgrcv, sys_semget,
sys_shmget, sys_shmat) [LINUX || SUNOS4 || FREEBSD]: Likewise.
(sys_mq_open) [LINUX]: Likewise.
(printmqattr) [HAVE_MQUEUE_H]: Likewise.
* mem.c (print_mmap) [!HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mmap64) [_LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mprotect): Likewise.
(sys_mremap, sys_madvise, sys_mlockall) [LINUX]: Likewise.
(sys_msync) [MS_ASYNC]: Likewise.
(sys_mctl) [MC_SYNC]: Likewise.
(sys_remap_file_pages, sys_mbind, sys_get_mempolicy) [LINUX]:
Likewise.
* net.c (printmsghdr) [HAVE_STRUCT_MSGHDR_MSG_CONTROL]: Likewise.
(sys_send, sys_sendto): Likewise.
(sys_sendmsg) [HAVE_SENDMSG]: Likewise.
(sys_recv, sys_recvfrom): Likewise.
(sys_recvmsg) [HAVE_SENDMSG]: Likewise.
(printicmpfilter) [ICMP_FILTER]: Likewise.
* proc.c (proc_ioctl) [SVR4 && !HAVE_MP_PROCFS || FREEBSD]: Likewise.
* process.c (sys_clone) [LINUX]: Likewise.
(printwaitn): Likewise.
(sys_waitid) [SVR4 || LINUX]: Likewise.
* signal.c (sys_sigvec) [SUNOS4 || FREEBSD]: Likewise.
(sys_sigaction): Likewise.
(printcontext) [SVR4]: Likewise.
(print_stack_t) [LINUX) || FREEBSD]: Likewise.
(sys_rt_sigaction) [LINUX]: Likewise.
* sock.c (sock_ioctl) [LINUX]: Likewise.
* stream.c (sys_putmsg, sys_getmsg): Likewise.
(sys_putpmsg) [SYS_putpmsg]: Likewise.
(sys_getpmsg) [SYS_getpmsg]: Likewise.
(sys_poll): Likewise.
(print_transport_message) [TI_BIND]: Likewise.
(stream_ioctl): Likewise.
* system.c (sys_mount, sys_reboot): Likewise.
(sys_cacheflush) [LINUX && M68K]: Likewise.
(sys_capget, sys_capset) [SYS_capget]: Likewise.
* term.c (term_ioctl) [TIOCMGET]: Likewise.
* time.c (sys_clock_nanosleep, sys_timer_settime) [LINUX]:
Likewise.
Fixes RH#159310.
2005-06-01 23:02:36 +04:00
if ( n ) {
if ( flags ) {
2016-04-28 21:55:18 +03:00
tprintf ( " %s%# " PRIx64 , sep , flags ) ;
2005-05-31 Dmitry V. Levin <ldv@altlinux.org>
* util.c (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument, "const char *", with similar
meaning to the third argument of printxval().
* defs.h (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument.
* bjm.c (sys_query_module) [LINUX]: Pass third argument to
printflags().
* desc.c (sys_fcntl): Likewise.
(sys_flock) [LOCK_SH]: Likewise.
(print_epoll_event) [HAVE_SYS_EPOLL_H]: Likewise.
* file.c (sys_open): Likewise.
(solaris_open) [LINUXSPARC]: Likewise.
(sys_access): Likewise.
(sys_chflags, sys_fchflags) [FREEBSD]: Likewise.
(realprintstat) [HAVE_LONG_LONG_OFF_T &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(printstat64) [HAVE_STAT64 &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(sys_setxattr, sys_fsetxattr): Likewise.
* ipc.c (sys_msgget, sys_msgsnd, sys_msgrcv, sys_semget,
sys_shmget, sys_shmat) [LINUX || SUNOS4 || FREEBSD]: Likewise.
(sys_mq_open) [LINUX]: Likewise.
(printmqattr) [HAVE_MQUEUE_H]: Likewise.
* mem.c (print_mmap) [!HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mmap64) [_LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mprotect): Likewise.
(sys_mremap, sys_madvise, sys_mlockall) [LINUX]: Likewise.
(sys_msync) [MS_ASYNC]: Likewise.
(sys_mctl) [MC_SYNC]: Likewise.
(sys_remap_file_pages, sys_mbind, sys_get_mempolicy) [LINUX]:
Likewise.
* net.c (printmsghdr) [HAVE_STRUCT_MSGHDR_MSG_CONTROL]: Likewise.
(sys_send, sys_sendto): Likewise.
(sys_sendmsg) [HAVE_SENDMSG]: Likewise.
(sys_recv, sys_recvfrom): Likewise.
(sys_recvmsg) [HAVE_SENDMSG]: Likewise.
(printicmpfilter) [ICMP_FILTER]: Likewise.
* proc.c (proc_ioctl) [SVR4 && !HAVE_MP_PROCFS || FREEBSD]: Likewise.
* process.c (sys_clone) [LINUX]: Likewise.
(printwaitn): Likewise.
(sys_waitid) [SVR4 || LINUX]: Likewise.
* signal.c (sys_sigvec) [SUNOS4 || FREEBSD]: Likewise.
(sys_sigaction): Likewise.
(printcontext) [SVR4]: Likewise.
(print_stack_t) [LINUX) || FREEBSD]: Likewise.
(sys_rt_sigaction) [LINUX]: Likewise.
* sock.c (sock_ioctl) [LINUX]: Likewise.
* stream.c (sys_putmsg, sys_getmsg): Likewise.
(sys_putpmsg) [SYS_putpmsg]: Likewise.
(sys_getpmsg) [SYS_getpmsg]: Likewise.
(sys_poll): Likewise.
(print_transport_message) [TI_BIND]: Likewise.
(stream_ioctl): Likewise.
* system.c (sys_mount, sys_reboot): Likewise.
(sys_cacheflush) [LINUX && M68K]: Likewise.
(sys_capget, sys_capset) [SYS_capget]: Likewise.
* term.c (term_ioctl) [TIOCMGET]: Likewise.
* time.c (sys_clock_nanosleep, sys_timer_settime) [LINUX]:
Likewise.
Fixes RH#159310.
2005-06-01 23:02:36 +04:00
n + + ;
}
} else {
if ( flags ) {
2016-04-28 21:55:18 +03:00
tprintf ( " %# " PRIx64 , flags ) ;
Introduce tprintf_comment and tprints_comment functions
* defs.h (tprintf_comment, tprints_comment): New prototypes.
* strace.c (tvprintf): New function.
(tprintf): Use it.
(tprintf_comment, tprints_comment): New functions.
* aio.c (tprint_lio_opcode): Use tprints_comment.
* dm.c (dm_decode_dm_target_spec, dm_decode_dm_target_deps,
dm_decode_dm_name_list, dm_decode_dm_target_versions,
dm_decode_dm_target_msg, dm_decode_string, dm_known_ioctl): Likewise.
* futex.c (SYS_FUNC(futex)): Likewise.
* perf.c (print_perf_event_attr): Likewise.
* seccomp.c (decode_bpf_code): Likewise.
* util.c (printxvals, printxval_searchn, printflags64): Likewise.
* btrfs.c (print_u64, btrfs_print_key_type, btrfs_print_objectid,
print_key_value_internal): Likewise.
(btrfs_ioctl): Use tprints_comment and tprintf_comment.
* dirent.c (SYS_FUNC(getdents)): Likewise.
* dirent64.c (SYS_FUNC(getdents64)): Likewise.
* execve.c (printargc): Use tprintf_comment.
* tests/btrfs.c (btrfs_test_get_dev_stats_ioctl,
btrfs_test_features_ioctls): Update expected output.
2017-04-24 22:31:54 +03:00
tprints_comment ( dflt ) ;
2005-05-31 Dmitry V. Levin <ldv@altlinux.org>
* util.c (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument, "const char *", with similar
meaning to the third argument of printxval().
* defs.h (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument.
* bjm.c (sys_query_module) [LINUX]: Pass third argument to
printflags().
* desc.c (sys_fcntl): Likewise.
(sys_flock) [LOCK_SH]: Likewise.
(print_epoll_event) [HAVE_SYS_EPOLL_H]: Likewise.
* file.c (sys_open): Likewise.
(solaris_open) [LINUXSPARC]: Likewise.
(sys_access): Likewise.
(sys_chflags, sys_fchflags) [FREEBSD]: Likewise.
(realprintstat) [HAVE_LONG_LONG_OFF_T &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(printstat64) [HAVE_STAT64 &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(sys_setxattr, sys_fsetxattr): Likewise.
* ipc.c (sys_msgget, sys_msgsnd, sys_msgrcv, sys_semget,
sys_shmget, sys_shmat) [LINUX || SUNOS4 || FREEBSD]: Likewise.
(sys_mq_open) [LINUX]: Likewise.
(printmqattr) [HAVE_MQUEUE_H]: Likewise.
* mem.c (print_mmap) [!HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mmap64) [_LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mprotect): Likewise.
(sys_mremap, sys_madvise, sys_mlockall) [LINUX]: Likewise.
(sys_msync) [MS_ASYNC]: Likewise.
(sys_mctl) [MC_SYNC]: Likewise.
(sys_remap_file_pages, sys_mbind, sys_get_mempolicy) [LINUX]:
Likewise.
* net.c (printmsghdr) [HAVE_STRUCT_MSGHDR_MSG_CONTROL]: Likewise.
(sys_send, sys_sendto): Likewise.
(sys_sendmsg) [HAVE_SENDMSG]: Likewise.
(sys_recv, sys_recvfrom): Likewise.
(sys_recvmsg) [HAVE_SENDMSG]: Likewise.
(printicmpfilter) [ICMP_FILTER]: Likewise.
* proc.c (proc_ioctl) [SVR4 && !HAVE_MP_PROCFS || FREEBSD]: Likewise.
* process.c (sys_clone) [LINUX]: Likewise.
(printwaitn): Likewise.
(sys_waitid) [SVR4 || LINUX]: Likewise.
* signal.c (sys_sigvec) [SUNOS4 || FREEBSD]: Likewise.
(sys_sigaction): Likewise.
(printcontext) [SVR4]: Likewise.
(print_stack_t) [LINUX) || FREEBSD]: Likewise.
(sys_rt_sigaction) [LINUX]: Likewise.
* sock.c (sock_ioctl) [LINUX]: Likewise.
* stream.c (sys_putmsg, sys_getmsg): Likewise.
(sys_putpmsg) [SYS_putpmsg]: Likewise.
(sys_getpmsg) [SYS_getpmsg]: Likewise.
(sys_poll): Likewise.
(print_transport_message) [TI_BIND]: Likewise.
(stream_ioctl): Likewise.
* system.c (sys_mount, sys_reboot): Likewise.
(sys_cacheflush) [LINUX && M68K]: Likewise.
(sys_capget, sys_capset) [SYS_capget]: Likewise.
* term.c (term_ioctl) [TIOCMGET]: Likewise.
* time.c (sys_clock_nanosleep, sys_timer_settime) [LINUX]:
Likewise.
Fixes RH#159310.
2005-06-01 23:02:36 +04:00
} else {
if ( dflt )
2011-09-01 12:00:28 +04:00
tprints ( " 0 " ) ;
2005-05-31 Dmitry V. Levin <ldv@altlinux.org>
* util.c (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument, "const char *", with similar
meaning to the third argument of printxval().
* defs.h (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument.
* bjm.c (sys_query_module) [LINUX]: Pass third argument to
printflags().
* desc.c (sys_fcntl): Likewise.
(sys_flock) [LOCK_SH]: Likewise.
(print_epoll_event) [HAVE_SYS_EPOLL_H]: Likewise.
* file.c (sys_open): Likewise.
(solaris_open) [LINUXSPARC]: Likewise.
(sys_access): Likewise.
(sys_chflags, sys_fchflags) [FREEBSD]: Likewise.
(realprintstat) [HAVE_LONG_LONG_OFF_T &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(printstat64) [HAVE_STAT64 &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(sys_setxattr, sys_fsetxattr): Likewise.
* ipc.c (sys_msgget, sys_msgsnd, sys_msgrcv, sys_semget,
sys_shmget, sys_shmat) [LINUX || SUNOS4 || FREEBSD]: Likewise.
(sys_mq_open) [LINUX]: Likewise.
(printmqattr) [HAVE_MQUEUE_H]: Likewise.
* mem.c (print_mmap) [!HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mmap64) [_LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mprotect): Likewise.
(sys_mremap, sys_madvise, sys_mlockall) [LINUX]: Likewise.
(sys_msync) [MS_ASYNC]: Likewise.
(sys_mctl) [MC_SYNC]: Likewise.
(sys_remap_file_pages, sys_mbind, sys_get_mempolicy) [LINUX]:
Likewise.
* net.c (printmsghdr) [HAVE_STRUCT_MSGHDR_MSG_CONTROL]: Likewise.
(sys_send, sys_sendto): Likewise.
(sys_sendmsg) [HAVE_SENDMSG]: Likewise.
(sys_recv, sys_recvfrom): Likewise.
(sys_recvmsg) [HAVE_SENDMSG]: Likewise.
(printicmpfilter) [ICMP_FILTER]: Likewise.
* proc.c (proc_ioctl) [SVR4 && !HAVE_MP_PROCFS || FREEBSD]: Likewise.
* process.c (sys_clone) [LINUX]: Likewise.
(printwaitn): Likewise.
(sys_waitid) [SVR4 || LINUX]: Likewise.
* signal.c (sys_sigvec) [SUNOS4 || FREEBSD]: Likewise.
(sys_sigaction): Likewise.
(printcontext) [SVR4]: Likewise.
(print_stack_t) [LINUX) || FREEBSD]: Likewise.
(sys_rt_sigaction) [LINUX]: Likewise.
* sock.c (sock_ioctl) [LINUX]: Likewise.
* stream.c (sys_putmsg, sys_getmsg): Likewise.
(sys_putpmsg) [SYS_putpmsg]: Likewise.
(sys_getpmsg) [SYS_getpmsg]: Likewise.
(sys_poll): Likewise.
(print_transport_message) [TI_BIND]: Likewise.
(stream_ioctl): Likewise.
* system.c (sys_mount, sys_reboot): Likewise.
(sys_cacheflush) [LINUX && M68K]: Likewise.
(sys_capget, sys_capset) [SYS_capget]: Likewise.
* term.c (term_ioctl) [TIOCMGET]: Likewise.
* time.c (sys_clock_nanosleep, sys_timer_settime) [LINUX]:
Likewise.
Fixes RH#159310.
2005-06-01 23:02:36 +04:00
}
1999-02-19 03:21:36 +03:00
}
2005-05-31 Dmitry V. Levin <ldv@altlinux.org>
* util.c (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument, "const char *", with similar
meaning to the third argument of printxval().
* defs.h (printxval): Change third argument from "char *" to
"const char *".
(printflags): Add third argument.
* bjm.c (sys_query_module) [LINUX]: Pass third argument to
printflags().
* desc.c (sys_fcntl): Likewise.
(sys_flock) [LOCK_SH]: Likewise.
(print_epoll_event) [HAVE_SYS_EPOLL_H]: Likewise.
* file.c (sys_open): Likewise.
(solaris_open) [LINUXSPARC]: Likewise.
(sys_access): Likewise.
(sys_chflags, sys_fchflags) [FREEBSD]: Likewise.
(realprintstat) [HAVE_LONG_LONG_OFF_T &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(printstat64) [HAVE_STAT64 &&
HAVE_STRUCT_STAT_ST_FLAGS]: Likewise.
(sys_setxattr, sys_fsetxattr): Likewise.
* ipc.c (sys_msgget, sys_msgsnd, sys_msgrcv, sys_semget,
sys_shmget, sys_shmat) [LINUX || SUNOS4 || FREEBSD]: Likewise.
(sys_mq_open) [LINUX]: Likewise.
(printmqattr) [HAVE_MQUEUE_H]: Likewise.
* mem.c (print_mmap) [!HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mmap64) [_LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T]: Likewise.
(sys_mprotect): Likewise.
(sys_mremap, sys_madvise, sys_mlockall) [LINUX]: Likewise.
(sys_msync) [MS_ASYNC]: Likewise.
(sys_mctl) [MC_SYNC]: Likewise.
(sys_remap_file_pages, sys_mbind, sys_get_mempolicy) [LINUX]:
Likewise.
* net.c (printmsghdr) [HAVE_STRUCT_MSGHDR_MSG_CONTROL]: Likewise.
(sys_send, sys_sendto): Likewise.
(sys_sendmsg) [HAVE_SENDMSG]: Likewise.
(sys_recv, sys_recvfrom): Likewise.
(sys_recvmsg) [HAVE_SENDMSG]: Likewise.
(printicmpfilter) [ICMP_FILTER]: Likewise.
* proc.c (proc_ioctl) [SVR4 && !HAVE_MP_PROCFS || FREEBSD]: Likewise.
* process.c (sys_clone) [LINUX]: Likewise.
(printwaitn): Likewise.
(sys_waitid) [SVR4 || LINUX]: Likewise.
* signal.c (sys_sigvec) [SUNOS4 || FREEBSD]: Likewise.
(sys_sigaction): Likewise.
(printcontext) [SVR4]: Likewise.
(print_stack_t) [LINUX) || FREEBSD]: Likewise.
(sys_rt_sigaction) [LINUX]: Likewise.
* sock.c (sock_ioctl) [LINUX]: Likewise.
* stream.c (sys_putmsg, sys_getmsg): Likewise.
(sys_putpmsg) [SYS_putpmsg]: Likewise.
(sys_getpmsg) [SYS_getpmsg]: Likewise.
(sys_poll): Likewise.
(print_transport_message) [TI_BIND]: Likewise.
(stream_ioctl): Likewise.
* system.c (sys_mount, sys_reboot): Likewise.
(sys_cacheflush) [LINUX && M68K]: Likewise.
(sys_capget, sys_capset) [SYS_capget]: Likewise.
* term.c (term_ioctl) [TIOCMGET]: Likewise.
* time.c (sys_clock_nanosleep, sys_timer_settime) [LINUX]:
Likewise.
Fixes RH#159310.
2005-06-01 23:02:36 +04:00
1999-02-19 03:21:36 +03:00
return n ;
}
2015-07-06 01:09:29 +03:00
void
2016-12-26 05:17:29 +03:00
printaddr ( const kernel_ulong_t addr )
2015-07-06 01:09:29 +03:00
{
if ( ! addr )
tprints ( " NULL " ) ;
else
Use kernel_ulong_t instead of unsigned long long where appropriate
* defs.h (printaddr_ull): Rename to printaddr_klu, change argument
type from unsigned long long to kernel_ulong_t. All callers updated.
(getarg_ull): Rename to getarg_klu, change return value type
from unsigned long long to kernel_ulong_t. All callers updated.
(PRI_kl, PRI_kld, PRI_klu, PRI_klx): New macros.
* bjm.c (SYS_FUNC(init_module)): Print kernel_ulong_t type using
PRI_klu format.
* desc.c (SYS_FUNC(pselect6)): Likewise.
* fadvise.c (SYS_FUNC(fadvise64)): Likewise.
* lookup_dcookie.c (SYS_FUNC(lookup_dcookie)): Likewise.
* mq.c (SYS_FUNC(mq_timedsend), SYS_FUNC(mq_timedreceive)): Likewise.
* kcmp.c (SYS_FUNC(kcmp)): Print kernel_ulong_t type using
PRI_klx format.
* keyctl.c (SYS_FUNC(keyctl)): Likewise.
* pkeys.c (SYS_FUNC(pkey_alloc)): Likewise.
* prctl.c (print_prctl_args, SYS_FUNC(prctl), SYS_FUNC(arch_prctl)):
Print kernel_ulong_t type using PRI_kld, PRI_klu, or PRI_klx format.
* util.c (printaddr_ull): Rename to printaddr_klu, change argument
type from unsigned long long to kernel_ulong_t, print it using
PRI_klx format.
(getarg_ull): Rename to getarg_klu, change return value type
from unsigned long long to kernel_ulong_t, print it using
PRI_klx format.
2016-12-19 19:56:45 +03:00
tprintf ( " %# " PRI_klx , addr ) ;
2015-07-06 01:09:29 +03:00
}
2015-07-06 01:09:29 +03:00
# define DEF_PRINTNUM(name, type) \
2015-08-19 00:57:27 +03:00
bool \
2016-12-26 13:26:03 +03:00
printnum_ # # name ( struct tcb * const tcp , const kernel_ulong_t addr , \
2016-12-21 01:33:52 +03:00
const char * const fmt ) \
2015-07-06 01:09:29 +03:00
{ \
type num ; \
2015-08-19 00:57:27 +03:00
if ( umove_or_printaddr ( tcp , addr , & num ) ) \
return false ; \
tprints ( " [ " ) ; \
tprintf ( fmt , num ) ; \
tprints ( " ] " ) ; \
return true ; \
1999-02-19 03:21:36 +03:00
}
2016-12-11 18:50:53 +03:00
# define DEF_PRINTNUM_ADDR(name, type) \
bool \
printnum_addr_ # # name ( struct tcb * tcp , const kernel_ulong_t addr ) \
{ \
type num ; \
if ( umove_or_printaddr ( tcp , addr , & num ) ) \
return false ; \
tprints ( " [ " ) ; \
printaddr ( num ) ; \
tprints ( " ] " ) ; \
return true ; \
}
2015-07-06 01:09:29 +03:00
# define DEF_PRINTPAIR(name, type) \
2015-08-19 00:57:27 +03:00
bool \
2016-12-26 13:26:03 +03:00
printpair_ # # name ( struct tcb * const tcp , const kernel_ulong_t addr , \
2016-12-21 01:33:52 +03:00
const char * const fmt ) \
2015-07-06 01:09:29 +03:00
{ \
type pair [ 2 ] ; \
2015-08-19 00:57:27 +03:00
if ( umove_or_printaddr ( tcp , addr , & pair ) ) \
return false ; \
tprints ( " [ " ) ; \
tprintf ( fmt , pair [ 0 ] ) ; \
tprints ( " , " ) ; \
tprintf ( fmt , pair [ 1 ] ) ; \
tprints ( " ] " ) ; \
return true ; \
2015-07-06 01:09:29 +03:00
}
2015-07-06 01:09:29 +03:00
DEF_PRINTNUM ( int , int )
2016-12-11 18:50:53 +03:00
DEF_PRINTNUM_ADDR ( int , unsigned int )
2015-07-06 01:09:29 +03:00
DEF_PRINTPAIR ( int , int )
2015-07-06 01:09:29 +03:00
DEF_PRINTNUM ( short , short )
DEF_PRINTNUM ( int64 , uint64_t )
2016-12-11 18:50:53 +03:00
DEF_PRINTNUM_ADDR ( int64 , uint64_t )
2015-07-06 01:09:29 +03:00
DEF_PRINTPAIR ( int64 , uint64_t )
Fix printing tracee's long integers
Replace ambiguous printnum_long that used to fetch native long integers
from tracee's memory with printnum_ptr, printnum_slong, and printnum_ulong
that fetch tracee's pointer, signed long, and unsigned long integers.
* defs.h (printnum_long, printpair_long): Remove prototypes.
(printnum_int64, printpair_int64): Remove macros, declare functions
unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New prototype.
(printnum_ptr, printnum_slong, printnum_ulong): New macros.
* aio.c (sys_io_setup): Use printnum_ulong.
* block.c (block_ioctl): Use printnum_slong and printnum_ulong.
* get_robust_list.c (sys_get_robust_list): Use printnum_ptr
and printnum_ulong.
* io.c (print_off_t): Remove.
(sys_sendfile): Use printnum_ulong.
* ipc.c (sys_semctl): Use printnum_ptr.
* prctl.c (sys_prctl): Likewise.
* process.c (sys_ptrace): Likewise.
* rtc.c (rtc_ioctl): Use printnum_ulong.
* util.c (printnum_long, printpair_long): Remove.
(printnum_int64, printpair_int64): Define unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New function.
Signed-off-by: Dmitry V. Levin <ldv@altlinux.org>
Signed-off-by: Elvira Khabirova <lineprinter0@gmail.com>
2015-08-18 17:58:27 +03:00
2016-12-26 16:50:14 +03:00
# ifndef current_wordsize
2015-08-19 00:57:27 +03:00
bool
2016-12-26 13:26:03 +03:00
printnum_long_int ( struct tcb * const tcp , const kernel_ulong_t addr ,
2016-12-21 01:33:52 +03:00
const char * const fmt_long , const char * const fmt_int )
Fix printing tracee's long integers
Replace ambiguous printnum_long that used to fetch native long integers
from tracee's memory with printnum_ptr, printnum_slong, and printnum_ulong
that fetch tracee's pointer, signed long, and unsigned long integers.
* defs.h (printnum_long, printpair_long): Remove prototypes.
(printnum_int64, printpair_int64): Remove macros, declare functions
unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New prototype.
(printnum_ptr, printnum_slong, printnum_ulong): New macros.
* aio.c (sys_io_setup): Use printnum_ulong.
* block.c (block_ioctl): Use printnum_slong and printnum_ulong.
* get_robust_list.c (sys_get_robust_list): Use printnum_ptr
and printnum_ulong.
* io.c (print_off_t): Remove.
(sys_sendfile): Use printnum_ulong.
* ipc.c (sys_semctl): Use printnum_ptr.
* prctl.c (sys_prctl): Likewise.
* process.c (sys_ptrace): Likewise.
* rtc.c (rtc_ioctl): Use printnum_ulong.
* util.c (printnum_long, printpair_long): Remove.
(printnum_int64, printpair_int64): Define unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New function.
Signed-off-by: Dmitry V. Levin <ldv@altlinux.org>
Signed-off-by: Elvira Khabirova <lineprinter0@gmail.com>
2015-08-18 17:58:27 +03:00
{
if ( current_wordsize > sizeof ( int ) ) {
2015-08-19 00:57:27 +03:00
return printnum_int64 ( tcp , addr , fmt_long ) ;
Fix printing tracee's long integers
Replace ambiguous printnum_long that used to fetch native long integers
from tracee's memory with printnum_ptr, printnum_slong, and printnum_ulong
that fetch tracee's pointer, signed long, and unsigned long integers.
* defs.h (printnum_long, printpair_long): Remove prototypes.
(printnum_int64, printpair_int64): Remove macros, declare functions
unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New prototype.
(printnum_ptr, printnum_slong, printnum_ulong): New macros.
* aio.c (sys_io_setup): Use printnum_ulong.
* block.c (block_ioctl): Use printnum_slong and printnum_ulong.
* get_robust_list.c (sys_get_robust_list): Use printnum_ptr
and printnum_ulong.
* io.c (print_off_t): Remove.
(sys_sendfile): Use printnum_ulong.
* ipc.c (sys_semctl): Use printnum_ptr.
* prctl.c (sys_prctl): Likewise.
* process.c (sys_ptrace): Likewise.
* rtc.c (rtc_ioctl): Use printnum_ulong.
* util.c (printnum_long, printpair_long): Remove.
(printnum_int64, printpair_int64): Define unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New function.
Signed-off-by: Dmitry V. Levin <ldv@altlinux.org>
Signed-off-by: Elvira Khabirova <lineprinter0@gmail.com>
2015-08-18 17:58:27 +03:00
} else {
2015-08-19 00:57:27 +03:00
return printnum_int ( tcp , addr , fmt_int ) ;
Fix printing tracee's long integers
Replace ambiguous printnum_long that used to fetch native long integers
from tracee's memory with printnum_ptr, printnum_slong, and printnum_ulong
that fetch tracee's pointer, signed long, and unsigned long integers.
* defs.h (printnum_long, printpair_long): Remove prototypes.
(printnum_int64, printpair_int64): Remove macros, declare functions
unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New prototype.
(printnum_ptr, printnum_slong, printnum_ulong): New macros.
* aio.c (sys_io_setup): Use printnum_ulong.
* block.c (block_ioctl): Use printnum_slong and printnum_ulong.
* get_robust_list.c (sys_get_robust_list): Use printnum_ptr
and printnum_ulong.
* io.c (print_off_t): Remove.
(sys_sendfile): Use printnum_ulong.
* ipc.c (sys_semctl): Use printnum_ptr.
* prctl.c (sys_prctl): Likewise.
* process.c (sys_ptrace): Likewise.
* rtc.c (rtc_ioctl): Use printnum_ulong.
* util.c (printnum_long, printpair_long): Remove.
(printnum_int64, printpair_int64): Define unconditionally.
[SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4] (printnum_long_int):
New function.
Signed-off-by: Dmitry V. Levin <ldv@altlinux.org>
Signed-off-by: Elvira Khabirova <lineprinter0@gmail.com>
2015-08-18 17:58:27 +03:00
}
}
2016-12-11 18:50:53 +03:00
bool
printnum_addr_long_int ( struct tcb * tcp , const kernel_ulong_t addr )
{
if ( current_wordsize > sizeof ( int ) ) {
return printnum_addr_int64 ( tcp , addr ) ;
} else {
return printnum_addr_int ( tcp , addr ) ;
}
}
2016-12-26 16:50:14 +03:00
# endif /* !current_wordsize */
2005-07-05 03:28:10 +04:00
2016-12-11 22:18:11 +03:00
# ifndef current_klongsize
bool
printnum_addr_klong_int ( struct tcb * tcp , const kernel_ulong_t addr )
{
if ( current_klongsize > sizeof ( int ) ) {
return printnum_addr_int64 ( tcp , addr ) ;
} else {
return printnum_addr_int ( tcp , addr ) ;
}
}
# endif /* !current_klongsize */
2014-12-06 06:53:16 +03:00
const char *
sprinttime ( time_t t )
{
struct tm * tmp ;
2016-08-13 20:27:38 +03:00
static char buf [ sizeof ( int ) * 3 * 6 + sizeof ( " +0000 " ) ] ;
2014-12-06 06:53:16 +03:00
2017-03-01 04:25:20 +03:00
if ( t = = 0 )
return " 0 " ;
2014-12-06 06:53:16 +03:00
tmp = localtime ( & t ) ;
if ( tmp )
2016-08-13 20:27:38 +03:00
strftime ( buf , sizeof ( buf ) , " %FT%T%z " , tmp ) ;
2014-12-06 06:53:16 +03:00
else
2016-08-13 20:27:38 +03:00
snprintf ( buf , sizeof ( buf ) , " %lu " , ( unsigned long ) t ) ;
2014-12-06 06:53:16 +03:00
return buf ;
}
2016-07-06 18:49:22 +03:00
enum sock_proto
2016-06-17 19:29:53 +03:00
getfdproto ( struct tcb * tcp , int fd )
2014-11-22 13:03:33 +03:00
{
2015-06-17 23:09:13 +03:00
# ifdef HAVE_SYS_XATTR_H
2016-06-17 19:29:53 +03:00
size_t bufsize = 256 ;
char buf [ bufsize ] ;
2014-11-22 13:03:33 +03:00
ssize_t r ;
char path [ sizeof ( " /proc/%u/fd/%u " ) + 2 * sizeof ( int ) * 3 ] ;
if ( fd < 0 )
2016-06-17 19:29:53 +03:00
return SOCK_PROTO_UNKNOWN ;
2014-11-22 13:03:33 +03:00
sprintf ( path , " /proc/%u/fd/%u " , tcp - > pid , fd ) ;
r = getxattr ( path , " system.sockprotoname " , buf , bufsize - 1 ) ;
if ( r < = 0 )
2016-06-17 19:29:53 +03:00
return SOCK_PROTO_UNKNOWN ;
2014-11-22 13:03:33 +03:00
else {
/*
* This is a protection for the case when the kernel
* side does not append a null byte to the buffer .
*/
buf [ r ] = ' \0 ' ;
2016-06-17 19:29:53 +03:00
return get_proto_by_name ( buf ) ;
2014-11-22 13:03:33 +03:00
}
# else
2016-06-17 19:29:53 +03:00
return SOCK_PROTO_UNKNOWN ;
2014-11-22 13:03:33 +03:00
# endif
}
Fix decoding of file descriptors
* defs.h (printfd): New function prototype.
* util.c (printfd): New function.
* file.c (print_dirfd): Update prototype to use printfd().
(sys_openat, sys_faccessat, sys_newfstatat, sys_mkdirat, sys_linkat,
sys_unlinkat, sys_readlinkat, sys_renameat, sys_fchownat, sys_fchmodat,
sys_futimesat, sys_utimensat, sys_mknodat): Update use of print_dirfd().
(sys_lseek, sys_llseek, sys_readahead, sys_ftruncate, sys_ftruncate64,
sys_fstat, sys_fstat64, sys_oldfstat, sys_fstatfs, sys_fstatfs64,
sys_fchdir, sys_fchroot, sys_linkat, sys_fchown, sys_fchmod, sys_fsync,
sys_readdir, sys_getdents, sys_getdirentries, sys_fsetxattr,
sys_fgetxattr, sys_flistxattr, sys_fremovexattr, sys_fadvise64,
sys_fadvise64_64, sys_inotify_add_watch, sys_inotify_rm_watch,
sys_fallocate): Use printfd() for decoding of file descriptors.
* desc.c (sys_fcntl, sys_flock, sys_close, sys_dup, do_dup2,
decode_select, sys_epoll_ctl, epoll_wait_common): Use printfd() for
decoding of file descriptors.
* io.c (sys_read, sys_write, sys_readv, sys_writev, sys_pread,
sys_pwrite, sys_sendfile, sys_sendfile64, sys_pread64, sys_pwrite64,
sys_ioctl): Likewise.
* mem.c (print_mmap, sys_mmap64): Likewise.
* signal.c (do_signalfd): Likewise.
* stream.c (decode_poll): Likewise.
* time.c (sys_timerfd_settime, sys_timerfd_gettime): Likewise.
Based on patch from Grant Edwards <grant.b.edwards@gmail.com>.
2011-03-04 05:08:02 +03:00
void
printfd ( struct tcb * tcp , int fd )
{
2013-03-06 21:24:34 +04:00
char path [ PATH_MAX + 1 ] ;
2014-08-21 07:17:48 +04:00
if ( show_fd_path & & getfdpath ( tcp , fd , path , sizeof ( path ) ) > = 0 ) {
static const char socket_prefix [ ] = " socket:[ " ;
const size_t socket_prefix_len = sizeof ( socket_prefix ) - 1 ;
2015-01-24 22:51:39 +03:00
const size_t path_len = strlen ( path ) ;
2014-08-21 07:17:48 +04:00
2015-01-24 22:51:39 +03:00
tprintf ( " %d< " , fd ) ;
2014-08-21 07:17:48 +04:00
if ( show_fd_path > 1 & &
strncmp ( path , socket_prefix , socket_prefix_len ) = = 0 & &
2015-01-24 22:51:39 +03:00
path [ path_len - 1 ] = = ' ] ' ) {
Implement caching of print_sockaddr_by_inode
As -yy parser, compared to -y, needs to do at least 5 extra syscalls
(getxattr, socket, sendmsg, recvmsg, close) to print socket details,
caching results of netlink conversations between strace and kernel
noticeably reduces amount of system time spent by strace.
The caching is safe since sockets do not change their addresses after
successful bind or connect syscall.
* defs.h (string_quote, print_sockaddr_by_inode_cached): New prototypes.
* socketutils.c (cache_entry): New type.
(CACHE_SIZE, CACHE_MASK): New macros.
(cache): New static array.
(cache_and_print_inode_details): New static function.
(print_sockaddr_by_inode_cached): New function.
(inet_parse_response, unix_parse_response): Use
cache_and_print_inode_details.
* util.c (printfd): Use string_quote and print_sockaddr_by_inode_cached.
(string_quote): Remove static qualifier.
* NEWS: Mention this improvement.
* tests/unix-yy.c (main): Update.
2016-02-02 02:14:59 +03:00
unsigned long inode =
2016-01-23 19:35:02 +03:00
strtoul ( path + socket_prefix_len , NULL , 10 ) ;
Implement caching of print_sockaddr_by_inode
As -yy parser, compared to -y, needs to do at least 5 extra syscalls
(getxattr, socket, sendmsg, recvmsg, close) to print socket details,
caching results of netlink conversations between strace and kernel
noticeably reduces amount of system time spent by strace.
The caching is safe since sockets do not change their addresses after
successful bind or connect syscall.
* defs.h (string_quote, print_sockaddr_by_inode_cached): New prototypes.
* socketutils.c (cache_entry): New type.
(CACHE_SIZE, CACHE_MASK): New macros.
(cache): New static array.
(cache_and_print_inode_details): New static function.
(print_sockaddr_by_inode_cached): New function.
(inet_parse_response, unix_parse_response): Use
cache_and_print_inode_details.
* util.c (printfd): Use string_quote and print_sockaddr_by_inode_cached.
(string_quote): Remove static qualifier.
* NEWS: Mention this improvement.
* tests/unix-yy.c (main): Update.
2016-02-02 02:14:59 +03:00
if ( ! print_sockaddr_by_inode_cached ( inode ) ) {
2016-06-17 19:29:53 +03:00
const enum sock_proto proto =
getfdproto ( tcp , fd ) ;
Implement caching of print_sockaddr_by_inode
As -yy parser, compared to -y, needs to do at least 5 extra syscalls
(getxattr, socket, sendmsg, recvmsg, close) to print socket details,
caching results of netlink conversations between strace and kernel
noticeably reduces amount of system time spent by strace.
The caching is safe since sockets do not change their addresses after
successful bind or connect syscall.
* defs.h (string_quote, print_sockaddr_by_inode_cached): New prototypes.
* socketutils.c (cache_entry): New type.
(CACHE_SIZE, CACHE_MASK): New macros.
(cache): New static array.
(cache_and_print_inode_details): New static function.
(print_sockaddr_by_inode_cached): New function.
(inet_parse_response, unix_parse_response): Use
cache_and_print_inode_details.
* util.c (printfd): Use string_quote and print_sockaddr_by_inode_cached.
(string_quote): Remove static qualifier.
* NEWS: Mention this improvement.
* tests/unix-yy.c (main): Update.
2016-02-02 02:14:59 +03:00
if ( ! print_sockaddr_by_inode ( inode , proto ) )
tprints ( path ) ;
}
2014-08-21 07:17:48 +04:00
} else {
2015-01-24 22:51:39 +03:00
print_quoted_string ( path , path_len ,
QUOTE_OMIT_LEADING_TRAILING_QUOTES ) ;
2014-08-21 07:17:48 +04:00
}
2015-01-24 22:51:39 +03:00
tprints ( " > " ) ;
2014-08-21 07:17:48 +04:00
} else
2011-04-08 00:25:40 +04:00
tprintf ( " %d " , fd ) ;
Fix decoding of file descriptors
* defs.h (printfd): New function prototype.
* util.c (printfd): New function.
* file.c (print_dirfd): Update prototype to use printfd().
(sys_openat, sys_faccessat, sys_newfstatat, sys_mkdirat, sys_linkat,
sys_unlinkat, sys_readlinkat, sys_renameat, sys_fchownat, sys_fchmodat,
sys_futimesat, sys_utimensat, sys_mknodat): Update use of print_dirfd().
(sys_lseek, sys_llseek, sys_readahead, sys_ftruncate, sys_ftruncate64,
sys_fstat, sys_fstat64, sys_oldfstat, sys_fstatfs, sys_fstatfs64,
sys_fchdir, sys_fchroot, sys_linkat, sys_fchown, sys_fchmod, sys_fsync,
sys_readdir, sys_getdents, sys_getdirentries, sys_fsetxattr,
sys_fgetxattr, sys_flistxattr, sys_fremovexattr, sys_fadvise64,
sys_fadvise64_64, sys_inotify_add_watch, sys_inotify_rm_watch,
sys_fallocate): Use printfd() for decoding of file descriptors.
* desc.c (sys_fcntl, sys_flock, sys_close, sys_dup, do_dup2,
decode_select, sys_epoll_ctl, epoll_wait_common): Use printfd() for
decoding of file descriptors.
* io.c (sys_read, sys_write, sys_readv, sys_writev, sys_pread,
sys_pwrite, sys_sendfile, sys_sendfile64, sys_pread64, sys_pwrite64,
sys_ioctl): Likewise.
* mem.c (print_mmap, sys_mmap64): Likewise.
* signal.c (do_signalfd): Likewise.
* stream.c (decode_poll): Likewise.
* time.c (sys_timerfd_settime, sys_timerfd_gettime): Likewise.
Based on patch from Grant Edwards <grant.b.edwards@gmail.com>.
2011-03-04 05:08:02 +03:00
}
2008-11-11 02:19:13 +03:00
/*
* Quote string ` instr ' of length ` size '
* Write up to ( 3 + ` size ' * 4 ) bytes to ` outstr ' buffer .
2012-01-20 14:56:00 +04:00
*
2015-01-26 04:17:08 +03:00
* If QUOTE_0_TERMINATED ` style ' flag is set ,
* treat ` instr ' as a NUL - terminated string ,
* checking up to ( ` size ' + 1 ) bytes of ` instr ' .
*
* If QUOTE_OMIT_LEADING_TRAILING_QUOTES ` style ' flag is set ,
* do not add leading and trailing quoting symbols .
*
* Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen , 1 otherwise .
* Note that if QUOTE_0_TERMINATED is not set , always returns 1.
2008-11-11 02:19:13 +03:00
*/
Implement caching of print_sockaddr_by_inode
As -yy parser, compared to -y, needs to do at least 5 extra syscalls
(getxattr, socket, sendmsg, recvmsg, close) to print socket details,
caching results of netlink conversations between strace and kernel
noticeably reduces amount of system time spent by strace.
The caching is safe since sockets do not change their addresses after
successful bind or connect syscall.
* defs.h (string_quote, print_sockaddr_by_inode_cached): New prototypes.
* socketutils.c (cache_entry): New type.
(CACHE_SIZE, CACHE_MASK): New macros.
(cache): New static array.
(cache_and_print_inode_details): New static function.
(print_sockaddr_by_inode_cached): New function.
(inet_parse_response, unix_parse_response): Use
cache_and_print_inode_details.
* util.c (printfd): Use string_quote and print_sockaddr_by_inode_cached.
(string_quote): Remove static qualifier.
* NEWS: Mention this improvement.
* tests/unix-yy.c (main): Update.
2016-02-02 02:14:59 +03:00
int
2015-01-26 04:17:08 +03:00
string_quote ( const char * instr , char * outstr , const unsigned int size ,
const unsigned int style )
1999-02-19 03:21:36 +03:00
{
2007-10-09 01:48:01 +04:00
const unsigned char * ustr = ( const unsigned char * ) instr ;
char * s = outstr ;
2015-01-26 04:17:08 +03:00
unsigned int i ;
int usehex , c , eol ;
1999-02-19 03:21:36 +03:00
2015-01-26 04:17:08 +03:00
if ( style & QUOTE_0_TERMINATED )
2011-08-31 14:22:56 +04:00
eol = ' \0 ' ;
2015-01-26 04:17:08 +03:00
else
eol = 0x100 ; /* this can never match a char */
2011-08-31 14:22:56 +04:00
usehex = 0 ;
2017-01-06 11:55:30 +03:00
if ( ( xflag > 1 ) | | ( style & QUOTE_FORCE_HEX ) ) {
2007-10-09 01:48:01 +04:00
usehex = 1 ;
2017-01-06 11:55:30 +03:00
} else if ( xflag ) {
2008-11-11 02:19:13 +03:00
/* Check for presence of symbol which require
to hex - quote the whole string . */
2007-10-09 01:48:01 +04:00
for ( i = 0 ; i < size ; + + i ) {
c = ustr [ i ] ;
2008-11-11 02:19:13 +03:00
/* Check for NUL-terminated string. */
2011-08-31 14:22:56 +04:00
if ( c = = eol )
break ;
2013-03-07 02:44:23 +04:00
/* Force hex unless c is printable or whitespace */
if ( c > 0x7e ) {
usehex = 1 ;
break ;
}
/* In ASCII isspace is only these chars: "\t\n\v\f\r".
* They happen to have ASCII codes 9 , 10 , 11 , 12 , 13.
*/
if ( c < ' ' & & ( unsigned ) ( c - 9 ) > = 5 ) {
2007-10-09 01:48:01 +04:00
usehex = 1 ;
break ;
}
}
1999-02-19 03:21:36 +03:00
}
2007-10-09 01:48:01 +04:00
2015-01-26 04:17:08 +03:00
if ( ! ( style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ) )
* s + + = ' \" ' ;
2007-10-09 01:48:01 +04:00
if ( usehex ) {
2008-11-11 02:19:13 +03:00
/* Hex-quote the whole string. */
2007-10-09 01:48:01 +04:00
for ( i = 0 ; i < size ; + + i ) {
c = ustr [ i ] ;
2008-11-11 02:19:13 +03:00
/* Check for NUL-terminated string. */
2011-08-31 14:22:56 +04:00
if ( c = = eol )
goto asciz_ended ;
* s + + = ' \\ ' ;
* s + + = ' x ' ;
* s + + = " 0123456789abcdef " [ c > > 4 ] ;
* s + + = " 0123456789abcdef " [ c & 0xf ] ;
2007-10-09 01:48:01 +04:00
}
} else {
for ( i = 0 ; i < size ; + + i ) {
c = ustr [ i ] ;
2008-11-11 02:19:13 +03:00
/* Check for NUL-terminated string. */
2011-08-31 14:22:56 +04:00
if ( c = = eol )
goto asciz_ended ;
2016-10-03 21:35:37 +03:00
if ( ( i = = ( size - 1 ) ) & &
( style & QUOTE_OMIT_TRAILING_0 ) & & ( c = = ' \0 ' ) )
goto asciz_ended ;
2007-10-09 01:48:01 +04:00
switch ( c ) {
case ' \" ' : case ' \\ ' :
* s + + = ' \\ ' ;
* s + + = c ;
break ;
case ' \f ' :
* s + + = ' \\ ' ;
* s + + = ' f ' ;
break ;
case ' \n ' :
* s + + = ' \\ ' ;
* s + + = ' n ' ;
break ;
case ' \r ' :
* s + + = ' \\ ' ;
* s + + = ' r ' ;
break ;
case ' \t ' :
* s + + = ' \\ ' ;
* s + + = ' t ' ;
break ;
case ' \v ' :
* s + + = ' \\ ' ;
* s + + = ' v ' ;
break ;
default :
2013-03-07 02:44:23 +04:00
if ( c > = ' ' & & c < = 0x7e )
2007-10-09 01:48:01 +04:00
* s + + = c ;
2011-08-31 14:22:56 +04:00
else {
/* Print \octal */
* s + + = ' \\ ' ;
if ( i + 1 < size
& & ustr [ i + 1 ] > = ' 0 '
& & ustr [ i + 1 ] < = ' 9 '
) {
/* Print \ooo */
* s + + = ' 0 ' + ( c > > 6 ) ;
* s + + = ' 0 ' + ( ( c > > 3 ) & 0x7 ) ;
} else {
/* Print \[[o]o]o */
if ( ( c > > 3 ) ! = 0 ) {
if ( ( c > > 6 ) ! = 0 )
* s + + = ' 0 ' + ( c > > 6 ) ;
* s + + = ' 0 ' + ( ( c > > 3 ) & 0x7 ) ;
}
}
* s + + = ' 0 ' + ( c & 0x7 ) ;
2007-10-09 01:48:01 +04:00
}
break ;
}
1999-02-19 03:21:36 +03:00
}
}
2015-01-26 04:17:08 +03:00
if ( ! ( style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ) )
* s + + = ' \" ' ;
2007-10-09 01:48:01 +04:00
* s = ' \0 ' ;
2007-11-02 02:53:59 +03:00
2011-08-31 14:22:56 +04:00
/* Return zero if we printed entire ASCIZ string (didn't truncate it) */
2015-01-26 04:17:08 +03:00
if ( style & QUOTE_0_TERMINATED & & ustr [ i ] = = ' \0 ' ) {
2011-08-31 14:22:56 +04:00
/* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
* but next char is NUL .
*/
return 0 ;
}
return 1 ;
asciz_ended :
2015-01-26 04:17:08 +03:00
if ( ! ( style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ) )
* s + + = ' \" ' ;
2011-08-31 14:22:56 +04:00
* s = ' \0 ' ;
/* Return zero: we printed entire ASCIZ string (didn't truncate it) */
return 0 ;
1999-02-19 03:21:36 +03:00
}
2015-01-26 04:17:08 +03:00
# ifndef ALLOCA_CUTOFF
# define ALLOCA_CUTOFF 4032
# endif
# define use_alloca(n) ((n) <= ALLOCA_CUTOFF)
/*
* Quote string ` str ' of length ` size ' and print the result .
*
* If QUOTE_0_TERMINATED ` style ' flag is set ,
* treat ` str ' as a NUL - terminated string and
* quote at most ( ` size ' - 1 ) bytes .
*
* If QUOTE_OMIT_LEADING_TRAILING_QUOTES ` style ' flag is set ,
* do not add leading and trailing quoting symbols .
*
* Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen , 1 otherwise .
* Note that if QUOTE_0_TERMINATED is not set , always returns 1.
*/
int
print_quoted_string ( const char * str , unsigned int size ,
const unsigned int style )
{
char * buf ;
char * outstr ;
unsigned int alloc_size ;
int rc ;
if ( size & & style & QUOTE_0_TERMINATED )
- - size ;
alloc_size = 4 * size ;
if ( alloc_size / 4 ! = size ) {
error_msg ( " Out of memory " ) ;
tprints ( " ??? " ) ;
return - 1 ;
}
alloc_size + = 1 + ( style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ? 0 : 2 ) ;
if ( use_alloca ( alloc_size ) ) {
outstr = alloca ( alloc_size ) ;
buf = NULL ;
} else {
outstr = buf = malloc ( alloc_size ) ;
if ( ! buf ) {
error_msg ( " Out of memory " ) ;
tprints ( " ??? " ) ;
return - 1 ;
}
}
rc = string_quote ( str , outstr , size , style ) ;
tprints ( outstr ) ;
free ( buf ) ;
return rc ;
}
2008-11-11 02:19:13 +03:00
/*
* Print path string specified by address ` addr ' and length ` n ' .
* If path length exceeds ` n ' , append ` . . . ' to the output .
*/
1999-02-19 03:21:36 +03:00
void
2016-12-26 13:26:03 +03:00
printpathn ( struct tcb * const tcp , const kernel_ulong_t addr , unsigned int n )
1999-02-19 03:21:36 +03:00
{
2014-11-22 01:28:34 +03:00
char path [ PATH_MAX + 1 ] ;
2012-01-20 14:56:00 +04:00
int nul_seen ;
2012-01-19 20:20:23 +04:00
2008-11-11 02:19:13 +03:00
if ( ! addr ) {
2011-09-01 12:00:28 +04:00
tprints ( " NULL " ) ;
2007-10-09 01:48:01 +04:00
return ;
}
2012-01-20 14:56:00 +04:00
/* Cap path length to the path buffer size */
2008-11-11 02:19:13 +03:00
if ( n > sizeof path - 1 )
n = sizeof path - 1 ;
/* Fetch one byte more to find out whether path length > n. */
2012-01-20 14:56:00 +04:00
nul_seen = umovestr ( tcp , addr , n + 1 , path ) ;
if ( nul_seen < 0 )
2016-06-11 04:28:21 +03:00
printaddr ( addr ) ;
1999-02-19 03:21:36 +03:00
else {
2015-01-26 04:17:08 +03:00
path [ n + + ] = ' \0 ' ;
print_quoted_string ( path , n , QUOTE_0_TERMINATED ) ;
2012-01-20 14:56:00 +04:00
if ( ! nul_seen )
2012-01-19 20:20:23 +04:00
tprints ( " ... " ) ;
1999-02-19 03:21:36 +03:00
}
}
void
2016-12-26 13:26:03 +03:00
printpath ( struct tcb * const tcp , const kernel_ulong_t addr )
2007-10-09 01:48:01 +04:00
{
2012-01-19 20:20:23 +04:00
/* Size must correspond to char path[] size in printpathn */
2014-11-22 01:28:34 +03:00
printpathn ( tcp , addr , PATH_MAX ) ;
2007-10-09 01:48:01 +04:00
}
2008-11-11 02:19:13 +03:00
/*
* Print string specified by address ` addr ' and length ` len ' .
2016-11-20 00:01:03 +03:00
* If ` user_style ' has QUOTE_0_TERMINATED bit set , treat the string
* as a NUL - terminated string .
* Pass ` user_style ' on to ` string_quote ' .
* Append ` . . . ' to the output if either the string length exceeds ` max_strlen ' ,
2016-12-24 20:35:40 +03:00
* or QUOTE_0_TERMINATED bit is set and the string length exceeds ` len ' .
2008-11-11 02:19:13 +03:00
*/
2007-10-09 01:48:01 +04:00
void
2016-12-26 13:26:03 +03:00
printstr_ex ( struct tcb * const tcp , const kernel_ulong_t addr ,
const kernel_ulong_t len , const unsigned int user_style )
1999-02-19 03:21:36 +03:00
{
2007-10-09 01:48:01 +04:00
static char * str = NULL ;
1999-02-19 03:21:36 +03:00
static char * outstr ;
2014-09-10 17:46:04 +04:00
unsigned int size ;
2016-11-19 19:33:37 +03:00
unsigned int style = user_style ;
int rc ;
2012-01-19 20:20:23 +04:00
int ellipsis ;
1999-02-19 03:21:36 +03:00
if ( ! addr ) {
2011-09-01 12:00:28 +04:00
tprints ( " NULL " ) ;
1999-02-19 03:21:36 +03:00
return ;
}
2008-11-11 02:19:13 +03:00
/* Allocate static buffers if they are not allocated yet. */
2011-08-31 16:00:02 +04:00
if ( ! str ) {
2012-03-26 02:56:53 +04:00
unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3 ;
if ( outstr_size / 4 ! = max_strlen )
die_out_of_memory ( ) ;
Introduce memory allocation wrappers
Introduce wrappers to the following functions that do memory allocation:
malloc, calloc, realloc, strdup.
This commit is a follow-up to the related discussions in strace-devel ML:
http://sourceforge.net/p/strace/mailman/message/33618180/
http://sourceforge.net/p/strace/mailman/message/33733470/
* defs.h (xmalloc, xcalloc, xreallocarray, xstrdup): New prototypes.
* xmalloc.c: New file.
* Makefile.am (strace_SOURCES): Add it.
* count.c (count_syscall, call_summary_pers): Use xcalloc.
* desc.c (decode_select): Use xmalloc.
* dirent.c (sys_getdents, sys_getdents64): Likewise.
* net.c (sys_recvmmsg): Use xstrdup.
* pathtrace.c (storepath): Use xreallocarray.
(pathtrace_match): Use xmalloc.
* strace.c (die_out_of_memory): Move to xmalloc.c.
(expand_tcbtab): Use xcalloc and xreallocarray.
(startup_child): Use xstrdup.
(init): Use xmalloc, xcalloc, and xstrdup.
* syscall.c (reallocate_qual): Use xreallocarray.
(qualify): Use xstrdup.
* unwind.c (unwind_tcb_init): Use xmalloc.
(build_mmap_cache): Use xcalloc, xreallocarray, and xstrdup.
(get_symbol_name): Use xreallocarray.
(stacktrace_walk, queue_put): Use xmalloc.
* util.c (printstr): Use xmalloc.
* vsprintf.c (strace_vfprintf): Likewise.
2015-05-25 23:41:02 +03:00
str = xmalloc ( max_strlen + 1 ) ;
outstr = xmalloc ( outstr_size ) ;
1999-02-19 03:21:36 +03:00
}
2007-10-09 01:48:01 +04:00
2016-12-24 20:35:40 +03:00
/* Fetch one byte more because string_quote may look one byte ahead. */
2016-10-10 19:55:54 +03:00
size = max_strlen + 1 ;
2016-12-24 20:35:40 +03:00
2016-12-24 22:24:37 +03:00
if ( size > len )
size = len ;
2016-12-24 20:35:40 +03:00
if ( style & QUOTE_0_TERMINATED )
2016-11-19 19:33:37 +03:00
rc = umovestr ( tcp , addr , size , str ) ;
2016-12-24 20:35:40 +03:00
else
rc = umoven ( tcp , addr , size , str ) ;
2016-11-19 19:33:37 +03:00
if ( rc < 0 ) {
printaddr ( addr ) ;
return ;
1999-02-19 03:21:36 +03:00
}
2016-10-10 19:55:54 +03:00
if ( size > max_strlen )
size = max_strlen ;
2016-11-20 03:29:46 +03:00
else
str [ size ] = ' \xff ' ;
2016-10-10 19:55:54 +03:00
2012-01-20 14:56:00 +04:00
/* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
* or we were requested to print more than - s NUM chars ) . . .
*/
2016-11-20 03:29:46 +03:00
ellipsis = string_quote ( str , outstr , size , style )
& & len
& & ( ( style & QUOTE_0_TERMINATED )
2016-12-24 22:24:37 +03:00
| | len > max_strlen ) ;
1999-02-19 03:21:36 +03:00
2012-01-19 20:20:23 +04:00
tprints ( outstr ) ;
if ( ellipsis )
tprints ( " ... " ) ;
1999-02-19 03:21:36 +03:00
}
2001-07-10 17:48:44 +04:00
void
2016-12-26 13:26:03 +03:00
dumpiov_upto ( struct tcb * const tcp , const int len , const kernel_ulong_t addr ,
kernel_ulong_t data_size )
2001-07-10 17:48:44 +04:00
{
2016-12-26 23:12:23 +03:00
# if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
2006-12-13 20:08:08 +03:00
union {
Replace u_int{8,16,32,64} with uint{8,16,32,64}
* util.c: Replace u_int{32,64} with uint{32,64}.
* quota.c: Replace u_int{8,16,32,64} with uint{8,16,32,64}.
2016-01-17 01:50:09 +03:00
struct { uint32_t base ; uint32_t len ; } * iov32 ;
struct { uint64_t base ; uint64_t len ; } * iov64 ;
2006-12-13 20:08:08 +03:00
} iovu ;
# define iov iovu.iov64
# define sizeof_iov \
2012-03-19 12:36:42 +04:00
( current_wordsize = = 4 ? sizeof ( * iovu . iov32 ) : sizeof ( * iovu . iov64 ) )
2006-12-13 20:08:08 +03:00
# define iov_iov_base(i) \
2012-03-19 12:36:42 +04:00
( current_wordsize = = 4 ? ( uint64_t ) iovu . iov32 [ i ] . base : iovu . iov64 [ i ] . base )
2006-12-13 20:08:08 +03:00
# define iov_iov_len(i) \
2012-03-19 12:36:42 +04:00
( current_wordsize = = 4 ? ( uint64_t ) iovu . iov32 [ i ] . len : iovu . iov64 [ i ] . len )
2006-12-13 20:08:08 +03:00
# else
2001-07-10 17:48:44 +04:00
struct iovec * iov ;
2006-12-13 20:08:08 +03:00
# define sizeof_iov sizeof(*iov)
2016-12-26 04:37:21 +03:00
# define iov_iov_base(i) ptr_to_kulong(iov[i].iov_base)
2006-12-13 20:08:08 +03:00
# define iov_iov_len(i) iov[i].iov_len
# endif
2001-07-10 17:48:44 +04:00
int i ;
2011-09-01 18:35:44 +04:00
unsigned size ;
2001-07-10 17:48:44 +04:00
2011-09-01 18:35:44 +04:00
size = sizeof_iov * len ;
/* Assuming no sane program has millions of iovs */
if ( ( unsigned ) len > 1024 * 1024 /* insane or negative size? */
2006-12-13 20:08:08 +03:00
| | ( iov = malloc ( size ) ) = = NULL ) {
2015-05-25 23:33:31 +03:00
error_msg ( " Out of memory " ) ;
2011-09-01 18:35:44 +04:00
return ;
2001-07-10 17:48:44 +04:00
}
2015-03-21 21:50:53 +03:00
if ( umoven ( tcp , addr , size , iov ) > = 0 ) {
2001-07-10 17:48:44 +04:00
for ( i = 0 ; i < len ; i + + ) {
2016-12-26 13:26:03 +03:00
kernel_ulong_t iov_len = iov_iov_len ( i ) ;
2016-01-20 03:17:02 +03:00
if ( iov_len > data_size )
iov_len = data_size ;
if ( ! iov_len )
break ;
data_size - = iov_len ;
2008-12-30 21:47:55 +03:00
/* include the buffer number to make it easy to
* match up the trace with the source */
2016-12-26 13:16:35 +03:00
tprintf ( " * % " PRI_klu " bytes in buffer %d \n " , iov_len , i ) ;
2016-12-26 04:37:21 +03:00
dumpstr ( tcp , iov_iov_base ( i ) , iov_len ) ;
2008-12-30 21:47:55 +03:00
}
2001-07-10 17:48:44 +04:00
}
2011-09-01 18:35:44 +04:00
free ( iov ) ;
2006-12-13 20:08:08 +03:00
# undef sizeof_iov
# undef iov_iov_base
# undef iov_iov_len
# undef iov
2001-07-10 17:48:44 +04:00
}
1999-02-19 03:21:36 +03:00
void
2016-12-26 13:26:03 +03:00
dumpstr ( struct tcb * const tcp , const kernel_ulong_t addr , const int len )
1999-02-19 03:21:36 +03:00
{
static int strsize = - 1 ;
static unsigned char * str ;
2013-02-22 17:47:39 +04:00
char outbuf [
(
( sizeof (
" xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx "
" 1234567890123456 " ) + /*in case I'm off by few:*/ 4 )
/*align to 8 to make memset easier:*/ + 7 ) & - 8
] ;
const unsigned char * src ;
int i ;
memset ( outbuf , ' ' , sizeof ( outbuf ) ) ;
if ( strsize < len + 16 ) {
2011-08-20 14:48:18 +04:00
free ( str ) ;
2013-02-22 17:47:39 +04:00
str = malloc ( len + 16 ) ;
2011-09-01 18:35:44 +04:00
if ( ! str ) {
strsize = - 1 ;
2015-05-25 23:33:31 +03:00
error_msg ( " Out of memory " ) ;
2011-09-01 18:35:44 +04:00
return ;
}
2013-02-22 17:47:39 +04:00
strsize = len + 16 ;
1999-02-19 03:21:36 +03:00
}
2015-03-21 21:50:53 +03:00
if ( umoven ( tcp , addr , len , str ) < 0 )
1999-02-19 03:21:36 +03:00
return ;
2013-02-22 17:47:39 +04:00
/* Space-pad to 16 bytes */
i = len ;
while ( i & 0xf )
str [ i + + ] = ' ' ;
i = 0 ;
src = str ;
while ( i < len ) {
char * dst = outbuf ;
/* Hex dump */
do {
if ( i < len ) {
* dst + + = " 0123456789abcdef " [ * src > > 4 ] ;
* dst + + = " 0123456789abcdef " [ * src & 0xf ] ;
1999-02-19 03:21:36 +03:00
}
else {
2013-02-22 17:47:39 +04:00
* dst + + = ' ' ;
* dst + + = ' ' ;
1999-02-19 03:21:36 +03:00
}
2013-02-22 17:47:39 +04:00
dst + + ; /* space is there by memset */
i + + ;
if ( ( i & 7 ) = = 0 )
dst + + ; /* space is there by memset */
src + + ;
} while ( i & 0xf ) ;
/* ASCII dump */
i - = 16 ;
src - = 16 ;
do {
if ( * src > = ' ' & & * src < 0x7f )
* dst + + = * src ;
1999-02-19 03:21:36 +03:00
else
2013-02-22 17:47:39 +04:00
* dst + + = ' . ' ;
src + + ;
} while ( + + i & 0xf ) ;
* dst = ' \0 ' ;
2013-02-22 18:00:11 +04:00
tprintf ( " | %05x %s | \n " , i - 16 , outbuf ) ;
1999-02-19 03:21:36 +03:00
}
}
2012-02-14 17:38:28 +04:00
static bool process_vm_readv_not_supported = 0 ;
2017-01-03 16:46:26 +03:00
# ifndef HAVE_PROCESS_VM_READV
/*
* Need to do this since process_vm_readv ( ) is not yet available in libc .
2012-01-28 04:46:33 +04:00
* When libc is be updated , only " static bool process_vm_readv_not_supported "
* line should remain .
*/
2012-05-05 03:37:29 +04:00
/* Have to avoid duplicating with the C library headers. */
static ssize_t strace_process_vm_readv ( pid_t pid ,
2012-01-28 04:46:33 +04:00
const struct iovec * lvec ,
unsigned long liovcnt ,
const struct iovec * rvec ,
unsigned long riovcnt ,
unsigned long flags )
{
return syscall ( __NR_process_vm_readv , ( long ) pid , lvec , liovcnt , rvec , riovcnt , flags ) ;
}
2017-01-03 16:46:26 +03:00
# define process_vm_readv strace_process_vm_readv
# endif /* !HAVE_PROCESS_VM_READV */
2012-01-28 04:46:33 +04:00
2015-03-31 22:45:08 +03:00
static ssize_t
2016-12-21 00:23:39 +03:00
vm_read_mem ( const pid_t pid , void * const laddr ,
2016-12-26 13:26:03 +03:00
const kernel_ulong_t raddr , const size_t len )
2015-03-31 22:45:08 +03:00
{
2016-12-26 04:21:04 +03:00
const unsigned long truncated_raddr = raddr ;
2016-12-26 13:26:03 +03:00
if ( raddr ! = ( kernel_ulong_t ) truncated_raddr ) {
2016-12-26 04:21:04 +03:00
errno = EIO ;
return - 1 ;
}
2015-03-31 22:45:08 +03:00
const struct iovec local = {
. iov_base = laddr ,
. iov_len = len
} ;
const struct iovec remote = {
2016-12-26 04:21:04 +03:00
. iov_base = ( void * ) truncated_raddr ,
2015-03-31 22:45:08 +03:00
. iov_len = len
} ;
return process_vm_readv ( pid , & local , 1 , & remote , 1 , 0 ) ;
}
1999-02-19 03:21:36 +03:00
/*
* move ` len ' bytes of data from process ` pid '
2015-03-21 21:50:53 +03:00
* at address ` addr ' to our space at ` our_addr '
1999-02-19 03:21:36 +03:00
*/
int
2016-12-26 13:26:03 +03:00
umoven ( struct tcb * const tcp , kernel_ulong_t addr , unsigned int len ,
2016-12-21 00:23:39 +03:00
void * const our_addr )
1999-02-19 03:21:36 +03:00
{
2015-03-21 21:50:53 +03:00
char * laddr = our_addr ;
2009-06-03 03:49:22 +04:00
int pid = tcp - > pid ;
2015-01-14 11:05:45 +03:00
unsigned int n , m , nread ;
1999-02-19 03:21:36 +03:00
union {
long val ;
char x [ sizeof ( long ) ] ;
} u ;
2016-12-26 23:12:23 +03:00
# if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
2016-12-26 16:18:00 +03:00
if ( current_wordsize < sizeof ( addr )
& & ( addr & ( ~ ( kernel_ulong_t ) - 1U ) ) ) {
return - 1 ;
}
2012-02-25 03:43:22 +04:00
# endif
2012-01-28 04:46:33 +04:00
if ( ! process_vm_readv_not_supported ) {
2015-03-31 22:45:08 +03:00
int r = vm_read_mem ( pid , laddr , addr , len ) ;
2015-01-14 11:05:45 +03:00
if ( ( unsigned int ) r = = len )
Make umoven report success as 0, not >=0, stop returning success on partial reads
umoven() uses process_vm_readv() when available but it returns the
return value of that syscall, which is the number of bytes copied,
while its callers expect it to simply return zero on success.
It was causing syscalls that take a user-space argument to print
the abbreviated version, e.g.:
epoll_ctl(5, EPOLL_CTL_ADD, 10, {...})
Instead of:
epoll_ctl(5, EPOLL_CTL_ADD, 10, {EPOLLIN, {u32=10, u64=10}})
* util.c (umoven): Make umove[n] report success as 0, not >=0,
stop returning "success" on partial reads.
Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2013-02-26 15:24:25 +04:00
return 0 ;
2013-02-27 01:16:22 +04:00
if ( r > = 0 ) {
2016-12-26 13:16:35 +03:00
error_msg ( " umoven: short read (%u < %u) @0x% " PRI_klx ,
2015-01-14 11:05:45 +03:00
( unsigned int ) r , len , addr ) ;
2013-02-27 01:16:22 +04:00
return - 1 ;
}
switch ( errno ) {
case ENOSYS :
2012-01-28 04:46:33 +04:00
process_vm_readv_not_supported = 1 ;
2013-02-27 01:16:22 +04:00
break ;
2015-03-30 18:21:55 +03:00
case EPERM :
/* operation not permitted, try PTRACE_PEEKDATA */
break ;
2013-02-27 01:16:22 +04:00
case ESRCH :
/* the process is gone */
return - 1 ;
2015-03-30 18:21:55 +03:00
case EFAULT : case EIO :
2013-02-27 01:16:22 +04:00
/* address space is inaccessible */
return - 1 ;
default :
/* all the rest is strange and should be reported */
2013-02-26 15:30:09 +04:00
perror_msg ( " process_vm_readv " ) ;
2013-02-27 01:16:22 +04:00
return - 1 ;
2012-01-28 04:46:33 +04:00
}
}
2013-02-27 01:16:22 +04:00
nread = 0 ;
1999-02-19 03:21:36 +03:00
if ( addr & ( sizeof ( long ) - 1 ) ) {
/* addr not a multiple of sizeof(long) */
2015-01-14 11:05:45 +03:00
n = addr & ( sizeof ( long ) - 1 ) ; /* residue */
addr & = - sizeof ( long ) ; /* aligned address */
2009-06-03 03:49:22 +04:00
errno = 0 ;
2016-12-26 04:26:54 +03:00
u . val = ptrace ( PTRACE_PEEKDATA , pid , addr , 0 ) ;
2013-02-27 01:16:22 +04:00
switch ( errno ) {
case 0 :
break ;
case ESRCH : case EINVAL :
/* these could be seen if the process is gone */
return - 1 ;
case EFAULT : case EIO : case EPERM :
/* address space is inaccessible */
return - 1 ;
default :
/* all the rest is strange and should be reported */
2016-12-26 13:16:35 +03:00
perror_msg ( " umoven: PTRACE_PEEKDATA pid:%d @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
pid , addr ) ;
return - 1 ;
2009-06-03 03:49:22 +04:00
}
2012-01-21 07:01:56 +04:00
m = MIN ( sizeof ( long ) - n , len ) ;
memcpy ( laddr , & u . x [ n ] , m ) ;
2013-03-01 21:52:59 +04:00
addr + = sizeof ( long ) ;
laddr + = m ;
nread + = m ;
len - = m ;
1999-02-19 03:21:36 +03:00
}
while ( len ) {
2009-06-03 03:49:22 +04:00
errno = 0 ;
2016-12-26 04:26:54 +03:00
u . val = ptrace ( PTRACE_PEEKDATA , pid , addr , 0 ) ;
2013-02-27 01:16:22 +04:00
switch ( errno ) {
case 0 :
break ;
case ESRCH : case EINVAL :
/* these could be seen if the process is gone */
return - 1 ;
case EFAULT : case EIO : case EPERM :
/* address space is inaccessible */
if ( nread ) {
2016-12-26 13:16:35 +03:00
perror_msg ( " umoven: short read (%u < %u) @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
nread , nread + len , addr - nread ) ;
}
return - 1 ;
default :
/* all the rest is strange and should be reported */
2016-12-26 13:16:35 +03:00
perror_msg ( " umoven: PTRACE_PEEKDATA pid:%d @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
pid , addr ) ;
return - 1 ;
2009-06-03 03:49:22 +04:00
}
2012-01-21 07:01:56 +04:00
m = MIN ( sizeof ( long ) , len ) ;
memcpy ( laddr , u . x , m ) ;
2013-03-01 21:52:59 +04:00
addr + = sizeof ( long ) ;
laddr + = m ;
nread + = m ;
len - = m ;
1999-02-19 03:21:36 +03:00
}
return 0 ;
}
2015-07-06 01:09:29 +03:00
int
2016-12-26 13:26:03 +03:00
umoven_or_printaddr ( struct tcb * const tcp , const kernel_ulong_t addr ,
2016-12-21 00:23:39 +03:00
const unsigned int len , void * const our_addr )
2015-07-06 01:09:29 +03:00
{
2016-06-11 04:28:21 +03:00
if ( ! addr | | ! verbose ( tcp ) | | ( exiting ( tcp ) & & syserror ( tcp ) ) | |
2015-07-06 01:09:29 +03:00
umoven ( tcp , addr , len , our_addr ) < 0 ) {
2016-06-11 04:28:21 +03:00
printaddr ( addr ) ;
2015-07-06 01:09:29 +03:00
return - 1 ;
}
return 0 ;
}
2016-10-15 02:27:21 +03:00
int
2016-12-21 00:23:39 +03:00
umoven_or_printaddr_ignore_syserror ( struct tcb * const tcp ,
2016-12-26 13:26:03 +03:00
const kernel_ulong_t addr ,
2016-12-21 00:23:39 +03:00
const unsigned int len ,
void * const our_addr )
2016-10-15 02:27:21 +03:00
{
if ( ! addr | | ! verbose ( tcp ) | | umoven ( tcp , addr , len , our_addr ) < 0 ) {
printaddr ( addr ) ;
return - 1 ;
}
return 0 ;
}
1999-02-19 03:21:36 +03:00
/*
2012-01-20 14:56:00 +04:00
* Like ` umove ' but make the additional effort of looking
1999-02-19 03:21:36 +03:00
* for a terminating zero byte .
2012-01-20 14:56:00 +04:00
*
* Returns < 0 on error , > 0 if NUL was seen ,
* ( TODO if useful : return count of bytes including NUL ) ,
* else 0 if len bytes were read but no NUL byte seen .
*
* Note : there is no guarantee we won ' t overwrite some bytes
* in laddr [ ] _after_ terminating NUL ( but , of course ,
* we never write past laddr [ len - 1 ] ) .
1999-02-19 03:21:36 +03:00
*/
int
2016-12-26 13:26:03 +03:00
umovestr ( struct tcb * const tcp , kernel_ulong_t addr , unsigned int len , char * laddr )
1999-02-19 03:21:36 +03:00
{
2016-12-15 18:51:26 +03:00
const unsigned long x01010101 = ( unsigned long ) 0x0101010101010101ULL ;
const unsigned long x80808080 = ( unsigned long ) 0x8080808080808080ULL ;
2013-03-01 21:52:59 +04:00
2009-06-03 03:49:22 +04:00
int pid = tcp - > pid ;
2015-01-14 11:05:45 +03:00
unsigned int n , m , nread ;
1999-02-19 03:21:36 +03:00
union {
2013-03-01 21:52:59 +04:00
unsigned long val ;
1999-02-19 03:21:36 +03:00
char x [ sizeof ( long ) ] ;
} u ;
2016-12-26 23:12:23 +03:00
# if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
2016-12-26 15:16:38 +03:00
if ( current_wordsize < sizeof ( addr )
& & ( addr & ( ~ ( kernel_ulong_t ) - 1U ) ) ) {
return - 1 ;
}
2011-12-27 00:12:02 +04:00
# endif
2013-02-27 01:16:22 +04:00
nread = 0 ;
2012-01-28 04:46:33 +04:00
if ( ! process_vm_readv_not_supported ) {
2015-03-31 22:45:08 +03:00
const size_t page_size = get_pagesize ( ) ;
const size_t page_mask = page_size - 1 ;
2012-01-28 04:46:33 +04:00
while ( len > 0 ) {
2015-01-14 11:05:45 +03:00
unsigned int chunk_len ;
unsigned int end_in_page ;
2012-01-28 04:46:33 +04:00
2015-03-31 22:45:08 +03:00
/*
* Don ' t cross pages , otherwise we can get EFAULT
2012-01-28 04:46:33 +04:00
* and fail to notice that terminating NUL lies
* in the existing ( first ) page .
*/
2015-03-31 22:45:08 +03:00
chunk_len = len > page_size ? page_size : len ;
end_in_page = ( addr + chunk_len ) & page_mask ;
2015-01-14 11:05:45 +03:00
if ( chunk_len > end_in_page ) /* crosses to the next page */
chunk_len - = end_in_page ;
2012-01-28 04:46:33 +04:00
2015-03-31 22:45:08 +03:00
int r = vm_read_mem ( pid , laddr , addr , chunk_len ) ;
2013-02-27 01:16:22 +04:00
if ( r > 0 ) {
2015-03-31 22:45:08 +03:00
if ( memchr ( laddr , ' \0 ' , r ) )
2013-02-27 01:16:22 +04:00
return 1 ;
2015-03-31 22:45:08 +03:00
addr + = r ;
laddr + = r ;
2013-02-27 01:16:22 +04:00
nread + = r ;
2015-03-31 22:45:08 +03:00
len - = r ;
2013-02-27 01:16:22 +04:00
continue ;
}
switch ( errno ) {
case ENOSYS :
2012-01-28 04:46:33 +04:00
process_vm_readv_not_supported = 1 ;
2013-02-27 01:16:22 +04:00
goto vm_readv_didnt_work ;
case ESRCH :
/* the process is gone */
return - 1 ;
2015-03-30 18:21:55 +03:00
case EPERM :
/* operation not permitted, try PTRACE_PEEKDATA */
if ( ! nread )
goto vm_readv_didnt_work ;
/* fall through */
case EFAULT : case EIO :
2013-02-27 01:16:22 +04:00
/* address space is inaccessible */
if ( nread ) {
2016-12-26 13:16:35 +03:00
perror_msg ( " umovestr: short read (%d < %d) @0x% " PRI_klx ,
2015-03-31 22:45:08 +03:00
nread , nread + len , addr - nread ) ;
2013-02-27 01:16:22 +04:00
}
return - 1 ;
default :
/* all the rest is strange and should be reported */
2013-02-26 15:30:09 +04:00
perror_msg ( " process_vm_readv " ) ;
2013-02-27 01:16:22 +04:00
return - 1 ;
2012-01-28 04:46:33 +04:00
}
}
return 0 ;
}
vm_readv_didnt_work :
1999-02-19 03:21:36 +03:00
if ( addr & ( sizeof ( long ) - 1 ) ) {
/* addr not a multiple of sizeof(long) */
2015-01-14 11:05:45 +03:00
n = addr & ( sizeof ( long ) - 1 ) ; /* residue */
addr & = - sizeof ( long ) ; /* aligned address */
2009-06-03 03:49:22 +04:00
errno = 0 ;
2016-12-26 04:26:54 +03:00
u . val = ptrace ( PTRACE_PEEKDATA , pid , addr , 0 ) ;
2013-02-27 01:16:22 +04:00
switch ( errno ) {
case 0 :
break ;
case ESRCH : case EINVAL :
/* these could be seen if the process is gone */
return - 1 ;
case EFAULT : case EIO : case EPERM :
/* address space is inaccessible */
return - 1 ;
default :
/* all the rest is strange and should be reported */
2016-12-26 13:16:35 +03:00
perror_msg ( " umovestr: PTRACE_PEEKDATA pid:%d @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
pid , addr ) ;
return - 1 ;
2009-06-03 03:49:22 +04:00
}
2012-01-21 07:01:56 +04:00
m = MIN ( sizeof ( long ) - n , len ) ;
memcpy ( laddr , & u . x [ n ] , m ) ;
1999-02-19 03:21:36 +03:00
while ( n & ( sizeof ( long ) - 1 ) )
if ( u . x [ n + + ] = = ' \0 ' )
2012-01-20 14:56:00 +04:00
return 1 ;
2013-03-01 21:52:59 +04:00
addr + = sizeof ( long ) ;
laddr + = m ;
nread + = m ;
len - = m ;
1999-02-19 03:21:36 +03:00
}
2013-03-01 21:52:59 +04:00
1999-02-19 03:21:36 +03:00
while ( len ) {
2009-06-03 03:49:22 +04:00
errno = 0 ;
2016-12-26 04:26:54 +03:00
u . val = ptrace ( PTRACE_PEEKDATA , pid , addr , 0 ) ;
2013-02-27 01:16:22 +04:00
switch ( errno ) {
case 0 :
break ;
case ESRCH : case EINVAL :
/* these could be seen if the process is gone */
return - 1 ;
case EFAULT : case EIO : case EPERM :
/* address space is inaccessible */
if ( nread ) {
2016-12-26 13:16:35 +03:00
perror_msg ( " umovestr: short read (%d < %d) @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
nread , nread + len , addr - nread ) ;
}
return - 1 ;
default :
/* all the rest is strange and should be reported */
2016-12-26 13:16:35 +03:00
perror_msg ( " umovestr: PTRACE_PEEKDATA pid:%d @0x% " PRI_klx ,
2013-02-27 01:16:22 +04:00
pid , addr ) ;
return - 1 ;
2009-06-03 03:49:22 +04:00
}
2012-01-21 07:01:56 +04:00
m = MIN ( sizeof ( long ) , len ) ;
memcpy ( laddr , u . x , m ) ;
2013-03-01 21:52:59 +04:00
/* "If a NUL char exists in this word" */
if ( ( u . val - x01010101 ) & ~ u . val & x80808080 )
return 1 ;
addr + = sizeof ( long ) ;
laddr + = m ;
nread + = m ;
len - = m ;
1999-02-19 03:21:36 +03:00
}
2001-05-15 18:53:43 +04:00
return 0 ;
1999-02-19 03:21:36 +03:00
}
2016-05-07 02:26:43 +03:00
/*
* Iteratively fetch and print up to nmemb elements of elem_size size
* from the array that starts at tracee ' s address start_addr .
*
* Array elements are being fetched to the address specified by elem_buf .
*
* The fetcher callback function specified by umoven_func should follow
* the same semantics as umoven_or_printaddr function .
*
* The printer callback function specified by print_func is expected
* to print something ; if it returns false , no more iterations will be made .
*
* The pointer specified by opaque_data is passed to each invocation
* of print_func callback function .
*
* This function prints :
* - " NULL " , if start_addr is NULL ;
* - " [] " , if nmemb is 0 ;
* - start_addr , if nmemb * elem_size overflows or wraps around ;
* - nothing , if the first element cannot be fetched
* ( if umoven_func returns non - zero ) , but it is assumed that
* umoven_func has printed the address it failed to fetch data from ;
* - elements of the array , delimited by " , " , with the array itself
* enclosed with [ ] brackets .
*
* If abbrev ( tcp ) is true , then
* - the maximum number of elements printed equals to max_strlen ;
* - " ... " is printed instead of max_strlen + 1 element
* and no more iterations will be made .
*
* This function returns true only if
* - umoven_func has been called at least once AND
* - umoven_func has not returned false .
*/
bool
2016-12-21 00:46:10 +03:00
print_array ( struct tcb * const tcp ,
2016-12-26 13:26:03 +03:00
const kernel_ulong_t start_addr ,
2016-05-07 02:26:43 +03:00
const size_t nmemb ,
void * const elem_buf ,
const size_t elem_size ,
int ( * const umoven_func ) ( struct tcb * ,
2016-12-26 13:26:03 +03:00
kernel_ulong_t ,
2016-05-07 02:26:43 +03:00
unsigned int ,
void * ) ,
bool ( * const print_func ) ( struct tcb * ,
void * elem_buf ,
size_t elem_size ,
void * opaque_data ) ,
void * const opaque_data )
{
if ( ! start_addr ) {
tprints ( " NULL " ) ;
return false ;
}
if ( ! nmemb ) {
tprints ( " [] " ) ;
return false ;
}
const size_t size = nmemb * elem_size ;
2016-12-26 13:26:03 +03:00
const kernel_ulong_t end_addr = start_addr + size ;
2016-05-07 02:26:43 +03:00
if ( end_addr < = start_addr | | size / elem_size ! = nmemb ) {
printaddr ( start_addr ) ;
return false ;
}
2016-12-26 13:26:03 +03:00
const kernel_ulong_t abbrev_end =
2016-05-07 02:26:43 +03:00
( abbrev ( tcp ) & & max_strlen < nmemb ) ?
start_addr + elem_size * max_strlen : end_addr ;
2016-12-26 13:26:03 +03:00
kernel_ulong_t cur ;
2016-05-07 02:26:43 +03:00
for ( cur = start_addr ; cur < end_addr ; cur + = elem_size ) {
if ( cur ! = start_addr )
tprints ( " , " ) ;
if ( umoven_func ( tcp , cur , elem_size , elem_buf ) )
break ;
if ( cur = = start_addr )
tprints ( " [ " ) ;
if ( cur > = abbrev_end ) {
tprints ( " ... " ) ;
cur = end_addr ;
break ;
}
if ( ! print_func ( tcp , elem_buf , elem_size , opaque_data ) ) {
cur = end_addr ;
break ;
}
}
if ( cur ! = start_addr )
tprints ( " ] " ) ;
return cur > = end_addr ;
}
2016-06-12 16:39:02 +03:00
2016-09-22 00:21:27 +03:00
int
printargs ( struct tcb * tcp )
{
2016-11-27 17:19:09 +03:00
const int n = tcp - > s_ent - > nargs ;
int i ;
for ( i = 0 ; i < n ; + + i )
2016-12-26 05:28:04 +03:00
tprintf ( " %s%# " PRI_klx , i ? " , " : " " , tcp - > u_arg [ i ] ) ;
2016-11-27 17:19:09 +03:00
return RVAL_DECODED ;
2016-06-12 16:39:02 +03:00
}
int
printargs_u ( struct tcb * tcp )
{
const int n = tcp - > s_ent - > nargs ;
int i ;
for ( i = 0 ; i < n ; + + i )
tprintf ( " %s%u " , i ? " , " : " " ,
( unsigned int ) tcp - > u_arg [ i ] ) ;
return RVAL_DECODED ;
}
int
printargs_d ( struct tcb * tcp )
{
const int n = tcp - > s_ent - > nargs ;
int i ;
for ( i = 0 ; i < n ; + + i )
tprintf ( " %s%d " , i ? " , " : " " ,
( int ) tcp - > u_arg [ i ] ) ;
return RVAL_DECODED ;
}
2016-07-04 01:15:45 +03:00
2017-03-29 20:55:35 +03:00
/* Print abnormal high bits of a kernel_ulong_t value. */
void
print_abnormal_hi ( const kernel_ulong_t val )
{
if ( current_klongsize > 4 ) {
const unsigned int hi = ( unsigned int ) ( ( uint64_t ) val > > 32 ) ;
if ( hi )
tprintf ( " %#x<<32| " , hi ) ;
}
}
2016-07-04 01:15:45 +03:00
# if defined _LARGEFILE64_SOURCE && defined HAVE_OPEN64
# define open_file open64
# else
# define open_file open
# endif
int
read_int_from_file ( const char * const fname , int * const pvalue )
{
const int fd = open_file ( fname , O_RDONLY ) ;
if ( fd < 0 )
return - 1 ;
long lval ;
char buf [ sizeof ( lval ) * 3 ] ;
int n = read ( fd , buf , sizeof ( buf ) - 1 ) ;
int saved_errno = errno ;
close ( fd ) ;
if ( n < 0 ) {
errno = saved_errno ;
return - 1 ;
}
buf [ n ] = ' \0 ' ;
char * endptr = 0 ;
errno = 0 ;
lval = strtol ( buf , & endptr , 10 ) ;
if ( ! endptr | | ( * endptr & & ' \n ' ! = * endptr )
# if INT_MAX < LONG_MAX
| | lval > INT_MAX | | lval < INT_MIN
# endif
| | ERANGE = = errno ) {
if ( ! errno )
errno = EINVAL ;
return - 1 ;
}
* pvalue = ( int ) lval ;
return 0 ;
}