← Back to branch summary

~ubuntu-branches/debian/sid/cde/sid

« back to all changes in this revision

Viewing changes to strace-4.6/bjm.c

  • Committer: Package Import Robot
  • Author(s): Yaroslav Halchenko
  • Date: 2012-02-03 19:27:05 UTC
  • Revision ID: package-import@ubuntu.com-20120203192705-ll6f1nr45ead65ed
Tags: upstream-0.1
Import upstream version 0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
strace-4.6/bjm.c
 
1
/*
 
2
 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
 
3
 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
 
4
 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
 
5
 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
 
6
 * All rights reserved.
 
7
 *
 
8
 * Redistribution and use in source and binary forms, with or without
 
9
 * modification, are permitted provided that the following conditions
 
10
 * are met:
 
11
 * 1. Redistributions of source code must retain the above copyright
 
12
 *    notice, this list of conditions and the following disclaimer.
 
13
 * 2. Redistributions in binary form must reproduce the above copyright
 
14
 *    notice, this list of conditions and the following disclaimer in the
 
15
 *    documentation and/or other materials provided with the distribution.
 
16
 * 3. The name of the author may not be used to endorse or promote products
 
17
 *    derived from this software without specific prior written permission.
 
18
 *
 
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
20
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
21
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
22
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
23
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
24
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
25
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
26
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
27
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
28
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
29
 *
 
30
 *      $Id$
 
31
 */
 
32
#include "defs.h"
 
33
 
 
34
#if defined(LINUX)
 
35
 
 
36
#include <fcntl.h>
 
37
#include <sys/stat.h>
 
38
#include <sys/time.h>
 
39
#include <sys/wait.h>
 
40
#include <sys/resource.h>
 
41
#include <sys/utsname.h>
 
42
#include <sys/user.h>
 
43
#include <sys/syscall.h>
 
44
#include <signal.h>
 
45
 
 
46
/* Bits of module.flags.  */
 
47
 
 
48
#define MOD_UNINITIALIZED       0
 
49
#define MOD_RUNNING             1
 
50
#define MOD_DELETED             2
 
51
#define MOD_AUTOCLEAN           4
 
52
#define MOD_VISITED             8
 
53
#define MOD_USED_ONCE           16
 
54
#define MOD_JUST_FREED          32
 
55
#define MOD_INITIALIZING        64
 
56
 
 
57
/* Values for query_module's which.  */
 
58
 
 
59
#define QM_MODULES      1
 
60
#define QM_DEPS         2
 
61
#define QM_REFS         3
 
62
#define QM_SYMBOLS      4
 
63
#define QM_INFO         5
 
64
 
 
65
struct module_symbol
 
66
{
 
67
        unsigned long value;
 
68
        const char *name;
 
69
};
 
70
 
 
71
struct module_info
 
72
{
 
73
        unsigned long addr;
 
74
        unsigned long size;
 
75
        unsigned long flags;
 
76
        long usecount;
 
77
};
 
78
 
 
79
static const struct xlat which[] = {
 
80
        { 0,            "0"             },
 
81
        { QM_MODULES,   "QM_MODULES"    },
 
82
        { QM_DEPS,      "QM_DEPS"       },
 
83
        { QM_REFS,      "QM_REFS"       },
 
84
        { QM_SYMBOLS,   "QM_SYMBOLS"    },
 
85
        { QM_INFO,      "QM_INFO"       },
 
86
        { 0,            NULL            },
 
87
};
 
88
 
 
89
static const struct xlat modflags[] = {
 
90
        { MOD_UNINITIALIZED,    "MOD_UNINITIALIZED"     },
 
91
        { MOD_RUNNING,          "MOD_RUNNING"           },
 
92
        { MOD_DELETED,          "MOD_DELETED"           },
 
93
        { MOD_AUTOCLEAN,        "MOD_AUTOCLEAN"         },
 
94
        { MOD_VISITED,          "MOD_VISITED"           },
 
95
        { MOD_USED_ONCE,        "MOD_USED_ONCE"         },
 
96
        { MOD_JUST_FREED,       "MOD_JUST_FREED"        },
 
97
        { 0,                    NULL                    },
 
98
};
 
99
 
 
100
int
 
101
sys_query_module(struct tcb *tcp)
 
102
{
 
103
        if (entering(tcp)) {
 
104
                printstr(tcp, tcp->u_arg[0], -1);
 
105
                tprintf(", ");
 
106
                printxval(which, tcp->u_arg[1], "QM_???");
 
107
                tprintf(", ");
 
108
        } else {
 
109
                size_t ret;
 
110
 
 
111
                if (!verbose(tcp) || syserror(tcp) ||
 
112
                    umove(tcp, tcp->u_arg[4], &ret) < 0) {
 
113
                        tprintf("%#lx, %lu, %#lx", tcp->u_arg[2],
 
114
                                tcp->u_arg[3], tcp->u_arg[4]);
 
115
                } else if (tcp->u_arg[1]==QM_INFO) {
 
116
                        struct module_info      mi;
 
117
                        if (umove(tcp, tcp->u_arg[2], &mi) < 0) {
 
118
                                tprintf("%#lx, ", tcp->u_arg[2]);
 
119
                        } else {
 
120
                                tprintf("{address=%#lx, size=%lu, flags=",
 
121
                                        mi.addr, mi.size);
 
122
                                printflags(modflags, mi.flags, "MOD_???");
 
123
                                tprintf(", usecount=%lu}, ", mi.usecount);
 
124
                        }
 
125
                        tprintf("%Zu", ret);
 
126
                } else if ((tcp->u_arg[1]==QM_MODULES) ||
 
127
                           (tcp->u_arg[1]==QM_DEPS) ||
 
128
                           (tcp->u_arg[1]==QM_REFS)) {
 
129
                        tprintf("{");
 
130
                        if (!abbrev(tcp)) {
 
131
                                char*   data    = malloc(tcp->u_arg[3]);
 
132
                                char*   mod     = data;
 
133
                                size_t  idx;
 
134
 
 
135
                                if (!data) {
 
136
                                        fprintf(stderr, "out of memory\n");
 
137
                                        tprintf(" /* %Zu entries */ ", ret);
 
138
                                } else {
 
139
                                        if (umoven(tcp, tcp->u_arg[2],
 
140
                                                tcp->u_arg[3], data) < 0) {
 
141
                                                tprintf(" /* %Zu entries */ ", ret);
 
142
                                        } else {
 
143
                                                for (idx=0; idx<ret; idx++) {
 
144
                                                        tprintf("%s%s",
 
145
                                                                (idx ? ", " : ""),
 
146
                                                                mod);
 
147
                                                        mod += strlen(mod)+1;
 
148
                                                }
 
149
                                        }
 
150
                                        free(data);
 
151
                                }
 
152
                        } else
 
153
                                tprintf(" /* %Zu entries */ ", ret);
 
154
                        tprintf("}, %Zu", ret);
 
155
                } else if (tcp->u_arg[1]==QM_SYMBOLS) {
 
156
                        tprintf("{");
 
157
                        if (!abbrev(tcp)) {
 
158
                                char*                   data    = malloc(tcp->u_arg[3]);
 
159
                                struct module_symbol*   sym     = (struct module_symbol*)data;
 
160
                                size_t                  idx;
 
161
 
 
162
                                if (!data) {
 
163
                                        fprintf(stderr, "out of memory\n");
 
164
                                        tprintf(" /* %Zu entries */ ", ret);
 
165
                                } else {
 
166
                                        if (umoven(tcp, tcp->u_arg[2],
 
167
                                                tcp->u_arg[3], data) < 0) {
 
168
                                                tprintf(" /* %Zu entries */ ", ret);
 
169
                                        } else {
 
170
                                                for (idx=0; idx<ret; idx++) {
 
171
                                                        tprintf("%s{name=%s, value=%lu}",
 
172
                                                                (idx ? " " : ""),
 
173
                                                                data+(long)sym->name,
 
174
                                                                sym->value);
 
175
                                                        sym++;
 
176
                                                }
 
177
                                        }
 
178
                                        free(data);
 
179
                                }
 
180
                        } else
 
181
                                tprintf(" /* %Zu entries */ ", ret);
 
182
                        tprintf("}, %Zd", ret);
 
183
                } else {
 
184
                        printstr(tcp, tcp->u_arg[2], tcp->u_arg[3]);
 
185
                        tprintf(", %#lx", tcp->u_arg[4]);
 
186
                }
 
187
        }
 
188
        return 0;
 
189
}
 
190
 
 
191
int
 
192
sys_create_module(tcp)
 
193
struct tcb *tcp;
 
194
{
 
195
        if (entering(tcp)) {
 
196
                printpath(tcp, tcp->u_arg[0]);
 
197
                tprintf(", %lu", tcp->u_arg[1]);
 
198
        }
 
199
        return RVAL_HEX;
 
200
}
 
201
 
 
202
int
 
203
sys_init_module(tcp)
 
204
struct tcb *tcp;
 
205
{
 
206
        if (entering(tcp)) {
 
207
                tprintf("%#lx, ", tcp->u_arg[0]);
 
208
                tprintf("%lu, ", tcp->u_arg[1]);
 
209
                printstr(tcp, tcp->u_arg[2], -1);
 
210
        }
 
211
        return 0;
 
212
}
 
213
#endif /* LINUX */