const char *
sprintsigmask_n(const char *prefix, const void *sig_mask, unsigned int bytes)
{
/*
* The maximum number of signal names to be printed
* is NSIG_BYTES * 8 * 2 / 3.
* Most of signal names have length 7,
* average length of signal names is less than 7.
* The length of prefix string does not exceed 16.
*/
static char outstr[128 + 8 * (NSIG_BYTES * 8 * 2 / 3)];
char *s;
const uint32_t *mask;
uint32_t inverted_mask[NSIG_BYTES / 4];
unsigned int size;
int i;
char sep;
s = stpcpy(outstr, prefix);
mask = sig_mask;
/* length of signal mask in 4-byte words */
size = (bytes >= NSIG_BYTES) ? NSIG_BYTES / 4 : (bytes + 3) / 4;
/* check whether 2/3 or more bits are set */
if (popcount32(mask, size) >= size * (4 * 8) * 2 / 3) {
/* show those signals that are NOT in the mask */
unsigned int j;
for (j = 0; j < size; ++j)
inverted_mask[j] = ~mask[j];
mask = inverted_mask;
*s++ = '~';
}
sep = '[';
for (i = 0; (i = next_set_bit(mask, i, size * (4 * 8))) >= 0; ) {
++i;
*s++ = sep;
if ((unsigned) i < nsignals) {
s = stpcpy(s, signalent[i] + 3);
}
#ifdef ASM_SIGRTMAX
else if (i >= ASM_SIGRTMIN && i <= ASM_SIGRTMAX) {
s = xappendstr(outstr, s, "RT_%u", i - ASM_SIGRTMIN);
}
#endif
else {
s = xappendstr(outstr, s, "%u", i);
}
sep = ' ';
}
if (sep == '[')
*s++ = sep;
*s++ = ']';
*s = '\0';
return outstr;
}
static int
decode_bitset(struct tcb *const tcp, const kernel_ulong_t arg,
const struct xlat decode_nr[], const unsigned int max_nr,
const char *const dflt)
{
tprints(", ");
unsigned int size;
if ((kernel_ulong_t) tcp->u_rval > max_nr)
size = max_nr;
else
size = tcp->u_rval;
char decoded_arg[size];
if (umove_or_printaddr(tcp, arg, &decoded_arg))
return 1;
tprints("[");
int bit_displayed = 0;
int i = next_set_bit(decoded_arg, 0, size);
if (i < 0) {
tprints(" 0 ");
} else {
printxval(decode_nr, i, dflt);
while ((i = next_set_bit(decoded_arg, i + 1, size)) > 0) {
if (abbrev(tcp) && bit_displayed >= 3) {
tprints(", ...");
break;
}
tprints(", ");
printxval(decode_nr, i, dflt);
bit_displayed++;
}
}
tprints("]");
return 1;
}
static void
print_affinitylist(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len)
{
const unsigned int max_size = get_cpuset_size();
const unsigned int umove_size = len < max_size ? len : max_size;
const unsigned int size =
(umove_size + current_wordsize - 1) & -current_wordsize;
const unsigned int ncpu = size * 8;
void *cpu;
if (!verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
!addr || !len || !(cpu = calloc(size, 1))) {
printaddr(addr);
return;
}
if (!umoven_or_printaddr(tcp, addr, umove_size, cpu)) {
int i = 0;
const char *sep = "";
tprints("[");
for (;; i++) {
i = next_set_bit(cpu, i, ncpu);
if (i < 0)
break;
tprintf("%s%d", sep, i);
sep = ", ";
}
if (size < len)
tprintf("%s...", sep);
tprints("]");
}
free(cpu);
}
int main( int argc, char** argv )
{
bit_index<64*64*64> b;
b.set_all();
for( int i = 0; i < 66; ++i )
{
b.clear(i);
assert( !b.get(i) );
fprintf( stderr, "\nI: %d\n", i );
if( i >= 62 )
b.dump();
if( b.first_set_bit() != i+1 )
{
exit(1);
}
}
for( int i = 0; i < 66; ++i )
{
assert( !b.get(i) );
}
assert( b.get(67) );
return 0;
fprintf( stderr, "pow64(1) = %d\n", pow64<1>::value );
fprintf( stderr, "pow64(2) = %d\n", pow64<2>::value );
fprintf( stderr, "log64(pow64(2)) = %d\n", log64<pow64<2>::value>::value );
fprintf( stderr, "pow64(log64(64*64)) = %d\n", pow64<log64<64*64>::value>::value );
fprintf( stderr, "pow64(log64(64*64*64)) = %d\n", pow64<log64<64*64*64>::value>::value );
fprintf(stderr, "=========== 64 =============\n" );
bit_index<64> _index;
fprintf( stderr, "first set bit: %d\n", _index.first_set_bit() );
assert( _index.first_set_bit() == 64 );
_index.set( 34 );
fprintf( stderr, "first set bit: %d\n", _index.first_set_bit() );
assert( _index.get(34) );
assert( _index.first_set_bit() == 34 );
_index.clear(34);
assert( !_index.get(34) );
assert( _index.first_set_bit() == 64 );
fprintf(stderr, "=========== 64*64 =============\n" );
bit_index<64*64> _b62;
_b62.set(1010);
fprintf( stderr, "first set bit: %d\n", _b62.first_set_bit() );
assert( _b62.first_set_bit() == 1010 );
assert( _b62.get(1010) );
assert( _b62.clear(1010) );
assert( !_b62.get(1010) );
fprintf(stderr, "=========== 64*64*64 =============\n" );
bit_index<64*64*64> _b64;
fprintf( stderr, "init first bit b64: %d\n", _b64.first_set_bit() );
_b64.set( 660 );
fprintf( stderr, "first set: %d\n", _b64.first_set_bit() );
assert( _b64.get(660) );
_b64.clear(660);
fprintf( stderr, "final first bit b64: %d\n", _b64.first_set_bit() );
assert( !_b64.get(660) );
bit_index<64*64*64> _b6464;
fprintf( stderr, "SET BIT 66\n" );
_b6464.set( 66 );
fprintf( stderr, "first set 66?? : %d\n", _b6464.first_set_bit() );
fprintf( stderr, "size of %d 64*64*64\n", int(sizeof(_b64) ) );
bit_index<64*64*64*64> _bbb;
fprintf( stderr, "size of %d 64*64*64*64 \n\n\n", int(sizeof(_bbb) ) );
_bbb.set(444);
assert(_bbb.get(444) );
{
bit_index<64*64> _bbb;
fprintf( stderr, "size of %d 64*64*64*64 \n\n\n", int(sizeof(_bbb) ) );
_bbb.set(444);
assert(_bbb.get(444) );
}
/*
{
bit_index<20*64*64> _bbb;
fprintf( stderr, "size of %d 64*64*64*64 \n\n\n", int(sizeof(_bbb) ) );
_bbb.set(444);
assert(_bbb.get(444) );
}
*/
_index.set(3);
_index.set(9);
_index.set(27);
auto itr = _index.at( _index.first_set_bit() );
while( !itr.end() )
{
fprintf( stderr, "next bit %lld\n", itr.bit() );
itr.next_set_bit();
}
{
_b62.set(3);
_b62.set(9);
_b62.set(270);
_b62.set(570);
_b62.set(1270);
auto itr = _b62.at( _b62.first_set_bit() );
while( !itr.end() )
{
fprintf( stderr, "_b62 next bit %lld\n", itr.bit() );
itr.next_set_bit();
}
}
auto tmp = _bbb.begin();
return 0;
}
/*
* Return true if syscall accesses a selected path
* (or if no paths have been specified for tracing).
*/
int
pathtrace_match(struct tcb *tcp)
{
const struct_sysent *s;
s = tcp->s_ent;
if (!(s->sys_flags & (TRACE_FILE | TRACE_DESC | TRACE_NETWORK)))
return 0;
/*
* Check for special cases where we need to do something
* other than test arg[0].
*/
if (s->sys_func == sys_dup2 ||
s->sys_func == sys_dup3 ||
s->sys_func == sys_sendfile ||
s->sys_func == sys_sendfile64 ||
s->sys_func == sys_tee)
{
/* fd, fd */
return fdmatch(tcp, tcp->u_arg[0]) ||
fdmatch(tcp, tcp->u_arg[1]);
}
if (s->sys_func == sys_inotify_add_watch ||
s->sys_func == sys_faccessat ||
s->sys_func == sys_fchmodat ||
s->sys_func == sys_futimesat ||
s->sys_func == sys_unlinkat ||
s->sys_func == sys_newfstatat ||
s->sys_func == sys_mknodat ||
s->sys_func == sys_openat ||
s->sys_func == sys_readlinkat ||
s->sys_func == sys_utimensat ||
s->sys_func == sys_fchownat ||
s->sys_func == sys_pipe2)
{
/* fd, path */
return fdmatch(tcp, tcp->u_arg[0]) ||
upathmatch(tcp, tcp->u_arg[1]);
}
if (s->sys_func == sys_link ||
s->sys_func == sys_mount)
{
/* path, path */
return upathmatch(tcp, tcp->u_arg[0]) ||
upathmatch(tcp, tcp->u_arg[1]);
}
if (s->sys_func == sys_quotactl)
{
/* x, path */
return upathmatch(tcp, tcp->u_arg[1]);
}
if (s->sys_func == sys_renameat ||
s->sys_func == sys_renameat2 ||
s->sys_func == sys_linkat)
{
/* fd, path, fd, path */
return fdmatch(tcp, tcp->u_arg[0]) ||
fdmatch(tcp, tcp->u_arg[2]) ||
upathmatch(tcp, tcp->u_arg[1]) ||
upathmatch(tcp, tcp->u_arg[3]);
}
if (
s->sys_func == sys_old_mmap ||
#if defined(S390)
s->sys_func == sys_old_mmap_pgoff ||
#endif
s->sys_func == sys_mmap ||
s->sys_func == sys_mmap_pgoff ||
s->sys_func == sys_mmap_4koff
) {
/* x, x, x, x, fd */
return fdmatch(tcp, tcp->u_arg[4]);
}
if (s->sys_func == sys_symlinkat) {
/* path, fd, path */
return fdmatch(tcp, tcp->u_arg[1]) ||
upathmatch(tcp, tcp->u_arg[0]) ||
upathmatch(tcp, tcp->u_arg[2]);
}
if (s->sys_func == sys_splice) {
/* fd, x, fd, x, x */
return fdmatch(tcp, tcp->u_arg[0]) ||
fdmatch(tcp, tcp->u_arg[2]);
}
if (s->sys_func == sys_epoll_ctl) {
/* x, x, fd, x */
return fdmatch(tcp, tcp->u_arg[2]);
}
if (s->sys_func == sys_fanotify_mark) {
/* x, x, x, fd, path */
return fdmatch(tcp, tcp->u_arg[3]) ||
upathmatch(tcp, tcp->u_arg[4]);
}
if (s->sys_func == sys_select ||
s->sys_func == sys_oldselect ||
s->sys_func == sys_pselect6)
{
int i, j;
int nfds;
long *args, oldargs[5];
unsigned fdsize;
fd_set *fds;
args = tcp->u_arg;
if (s->sys_func == sys_oldselect) {
if (umoven(tcp, tcp->u_arg[0], sizeof oldargs,
oldargs) < 0)
{
fprintf(stderr, "umoven() failed\n");
return 0;
}
args = oldargs;
}
/* Kernel truncates arg[0] to int, we do the same. */
nfds = (int) args[0];
/* Kernel rejects negative nfds, so we don't parse it either. */
if (nfds <= 0)
return 0;
/* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */
if (nfds > 1024*1024)
nfds = 1024*1024;
fdsize = (((nfds + 7) / 8) + current_wordsize-1) & -current_wordsize;
fds = malloc(fdsize);
if (!fds)
die_out_of_memory();
for (i = 1; i <= 3; ++i) {
if (args[i] == 0)
continue;
if (umoven(tcp, args[i], fdsize, fds) < 0) {
fprintf(stderr, "umoven() failed\n");
continue;
}
for (j = 0;; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
if (fdmatch(tcp, j)) {
free(fds);
return 1;
}
}
}
free(fds);
return 0;
}
if (s->sys_func == sys_poll ||
s->sys_func == sys_ppoll)
{
struct pollfd fds;
unsigned nfds;
unsigned long start, cur, end;
start = tcp->u_arg[0];
nfds = tcp->u_arg[1];
end = start + sizeof(fds) * nfds;
if (nfds == 0 || end < start)
return 0;
for (cur = start; cur < end; cur += sizeof(fds))
if ((umoven(tcp, cur, sizeof fds, &fds) == 0)
&& fdmatch(tcp, fds.fd))
return 1;
return 0;
}
if (s->sys_func == printargs ||
s->sys_func == sys_pipe ||
s->sys_func == sys_pipe2 ||
s->sys_func == sys_eventfd2 ||
s->sys_func == sys_eventfd ||
s->sys_func == sys_inotify_init1 ||
s->sys_func == sys_timerfd_create ||
s->sys_func == sys_timerfd_settime ||
s->sys_func == sys_timerfd_gettime ||
s->sys_func == sys_epoll_create ||
s->sys_func == sys_socket ||
s->sys_func == sys_socketpair ||
s->sys_func == sys_fanotify_init)
{
/*
* These have TRACE_FILE or TRACE_DESCRIPTOR or TRACE_NETWORK set,
* but they don't have any file descriptor or path args to test.
*/
return 0;
}
/*
* Our fallback position for calls that haven't already
* been handled is to just check arg[0].
*/
if (s->sys_flags & TRACE_FILE)
return upathmatch(tcp, tcp->u_arg[0]);
if (s->sys_flags & (TRACE_DESC | TRACE_NETWORK))
return fdmatch(tcp, tcp->u_arg[0]);
return 0;
}
static int
decode_select(struct tcb *tcp, long *args, enum bitness_t bitness)
{
int i, j;
int nfds, fdsize;
fd_set *fds = NULL;
const char *sep;
long arg;
/* Kernel truncates arg[0] to int, we do the same. */
nfds = (int) args[0];
/* Kernel rejects negative nfds, so we don't parse it either. */
if (nfds < 0)
nfds = 0;
/* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */
if (nfds > 1024*1024)
nfds = 1024*1024;
/*
* We had bugs a-la "while (j < args[0])" and "umoven(args[0])" below.
* Instead of args[0], use nfds for fd count, fdsize for array lengths.
*/
fdsize = (((nfds + 7) / 8) + current_wordsize-1) & -current_wordsize;
if (entering(tcp)) {
tprintf("%d", (int) args[0]);
if (verbose(tcp) && fdsize > 0) {
fds = malloc(fdsize);
if (!fds)
die_out_of_memory();
}
for (i = 0; i < 3; i++) {
arg = args[i+1];
if (arg == 0) {
tprints(", NULL");
continue;
}
if (!fds) {
tprintf(", %#lx", arg);
continue;
}
if (umoven(tcp, arg, fdsize, fds) < 0) {
tprints(", [?]");
continue;
}
tprints(", [");
for (j = 0, sep = "";; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
tprints(sep);
printfd(tcp, j);
sep = " ";
}
tprints("]");
}
free(fds);
tprints(", ");
printtv_bitness(tcp, args[4], bitness, 0);
}
else {
static char outstr[1024];
char *outptr;
#define end_outstr (outstr + sizeof(outstr))
int ready_fds;
if (syserror(tcp))
return 0;
ready_fds = tcp->u_rval;
if (ready_fds == 0) {
tcp->auxstr = "Timeout";
return RVAL_STR;
}
fds = malloc(fdsize);
if (!fds)
die_out_of_memory();
outptr = outstr;
sep = "";
for (i = 0; i < 3 && ready_fds > 0; i++) {
int first = 1;
arg = args[i+1];
if (!arg || umoven(tcp, arg, fdsize, fds) < 0)
continue;
for (j = 0;; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
/* +2 chars needed at the end: ']',NUL */
if (outptr < end_outstr - (sizeof(", except [") + sizeof(int)*3 + 2)) {
if (first) {
outptr += sprintf(outptr, "%s%s [%u",
sep,
i == 0 ? "in" : i == 1 ? "out" : "except",
j
);
first = 0;
sep = ", ";
}
else {
outptr += sprintf(outptr, " %u", j);
}
}
if (--ready_fds == 0)
break;
}
if (outptr != outstr)
*outptr++ = ']';
}
free(fds);
/* This contains no useful information on SunOS. */
if (args[4]) {
if (outptr < end_outstr - (10 + TIMEVAL_TEXT_BUFSIZE)) {
outptr += sprintf(outptr, "%sleft ", sep);
outptr = sprinttv(outptr, tcp, args[4], bitness, /*special:*/ 0);
}
}
*outptr = '\0';
tcp->auxstr = outstr;
return RVAL_STR;
#undef end_outstr
}
return 0;
}
static int
decode_select(struct tcb *const tcp, const kernel_ulong_t *const args,
void (*const print_tv_ts) (struct tcb *, kernel_ulong_t),
const char * (*const sprint_tv_ts) (struct tcb *, kernel_ulong_t))
{
int i, j;
int nfds, fdsize;
fd_set *fds = NULL;
const char *sep;
kernel_ulong_t addr;
/* Kernel truncates args[0] to int, we do the same. */
nfds = (int) args[0];
/* Kernel rejects negative nfds, so we don't parse it either. */
if (nfds < 0)
nfds = 0;
/* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */
if (nfds > 1024*1024)
nfds = 1024*1024;
/*
* We had bugs a-la "while (j < args[0])" and "umoven(args[0])" below.
* Instead of args[0], use nfds for fd count, fdsize for array lengths.
*/
fdsize = (((nfds + 7) / 8) + current_wordsize-1) & -current_wordsize;
if (entering(tcp)) {
tprintf("%d", (int) args[0]);
if (verbose(tcp) && fdsize > 0)
fds = malloc(fdsize);
for (i = 0; i < 3; i++) {
addr = args[i+1];
tprints(", ");
if (!fds) {
printaddr(addr);
continue;
}
if (umoven_or_printaddr(tcp, addr, fdsize, fds))
continue;
tprints("[");
for (j = 0, sep = "";; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
tprints(sep);
printfd(tcp, j);
sep = " ";
}
tprints("]");
}
free(fds);
tprints(", ");
print_tv_ts(tcp, args[4]);
} else {
static char outstr[1024];
char *outptr;
#define end_outstr (outstr + sizeof(outstr))
int ready_fds;
if (syserror(tcp))
return 0;
ready_fds = tcp->u_rval;
if (ready_fds == 0) {
tcp->auxstr = "Timeout";
return RVAL_STR;
}
fds = malloc(fdsize);
outptr = outstr;
sep = "";
for (i = 0; i < 3 && ready_fds > 0; i++) {
int first = 1;
addr = args[i+1];
if (!addr || !fds || umoven(tcp, addr, fdsize, fds) < 0)
continue;
for (j = 0;; j++) {
j = next_set_bit(fds, j, nfds);
if (j < 0)
break;
/* +2 chars needed at the end: ']',NUL */
if (outptr < end_outstr - (sizeof(", except [") + sizeof(int)*3 + 2)) {
if (first) {
outptr += sprintf(outptr, "%s%s [%u",
sep,
i == 0 ? "in" : i == 1 ? "out" : "except",
j
);
first = 0;
sep = ", ";
} else {
outptr += sprintf(outptr, " %u", j);
}
}
if (--ready_fds == 0)
break;
}
if (outptr != outstr)
*outptr++ = ']';
}
free(fds);
/* This contains no useful information on SunOS. */
if (args[4]) {
const char *str = sprint_tv_ts(tcp, args[4]);
if (outptr + sizeof("left ") + strlen(sep) + strlen(str) < end_outstr) {
outptr += sprintf(outptr, "%sleft %s", sep, str);
}
}
*outptr = '\0';
tcp->auxstr = outstr;
return RVAL_STR;
#undef end_outstr
}
return 0;
}
