1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <sys/time.h>
17 #include <cutils/open_memstream.h>
18 #include <time.h>
19 #include <errno.h>
20 #include "Hprof.h"
21
22 #define HPROF_MAGIC_STRING "JAVA PROFILE 1.0.3"
23
24 #define U2_TO_BUF_BE(buf, offset, value) \
25 do { \
26 unsigned char *buf_ = (unsigned char *)(buf); \
27 int offset_ = (int)(offset); \
28 u2 value_ = (u2)(value); \
29 buf_[offset_ + 0] = (unsigned char)(value_ >> 8); \
30 buf_[offset_ + 1] = (unsigned char)(value_ ); \
31 } while (0)
32
33 #define U4_TO_BUF_BE(buf, offset, value) \
34 do { \
35 unsigned char *buf_ = (unsigned char *)(buf); \
36 int offset_ = (int)(offset); \
37 u4 value_ = (u4)(value); \
38 buf_[offset_ + 0] = (unsigned char)(value_ >> 24); \
39 buf_[offset_ + 1] = (unsigned char)(value_ >> 16); \
40 buf_[offset_ + 2] = (unsigned char)(value_ >> 8); \
41 buf_[offset_ + 3] = (unsigned char)(value_ ); \
42 } while (0)
43
44 #define U8_TO_BUF_BE(buf, offset, value) \
45 do { \
46 unsigned char *buf_ = (unsigned char *)(buf); \
47 int offset_ = (int)(offset); \
48 u8 value_ = (u8)(value); \
49 buf_[offset_ + 0] = (unsigned char)(value_ >> 56); \
50 buf_[offset_ + 1] = (unsigned char)(value_ >> 48); \
51 buf_[offset_ + 2] = (unsigned char)(value_ >> 40); \
52 buf_[offset_ + 3] = (unsigned char)(value_ >> 32); \
53 buf_[offset_ + 4] = (unsigned char)(value_ >> 24); \
54 buf_[offset_ + 5] = (unsigned char)(value_ >> 16); \
55 buf_[offset_ + 6] = (unsigned char)(value_ >> 8); \
56 buf_[offset_ + 7] = (unsigned char)(value_ ); \
57 } while (0)
58
59 /*
60 * Initialize an hprof context struct.
61 *
62 * This will take ownership of "fileName".
63 */
hprofContextInit(hprof_context_t * ctx,char * fileName,int fd,bool writeHeader,bool directToDdms)64 void hprofContextInit(hprof_context_t *ctx, char *fileName, int fd,
65 bool writeHeader, bool directToDdms)
66 {
67 memset(ctx, 0, sizeof (*ctx));
68
69 /*
70 * Have to do this here, because it must happen after we
71 * memset the struct (want to treat fileDataPtr/fileDataSize
72 * as read-only while the file is open).
73 */
74 FILE* fp = open_memstream(&ctx->fileDataPtr, &ctx->fileDataSize);
75 if (fp == NULL) {
76 /* not expected */
77 LOGE("hprof: open_memstream failed: %s", strerror(errno));
78 dvmAbort();
79 }
80
81 ctx->directToDdms = directToDdms;
82 ctx->fileName = fileName;
83 ctx->memFp = fp;
84 ctx->fd = fd;
85
86 ctx->curRec.allocLen = 128;
87 ctx->curRec.body = (unsigned char *)malloc(ctx->curRec.allocLen);
88 //xxx check for/return an error
89
90 if (writeHeader) {
91 char magic[] = HPROF_MAGIC_STRING;
92 unsigned char buf[4];
93 struct timeval now;
94 u8 nowMs;
95
96 /* Write the file header.
97 *
98 * [u1]*: NUL-terminated magic string.
99 */
100 fwrite(magic, 1, sizeof(magic), fp);
101
102 /* u4: size of identifiers. We're using addresses
103 * as IDs, so make sure a pointer fits.
104 */
105 U4_TO_BUF_BE(buf, 0, sizeof(void *));
106 fwrite(buf, 1, sizeof(u4), fp);
107
108 /* The current time, in milliseconds since 0:00 GMT, 1/1/70.
109 */
110 if (gettimeofday(&now, NULL) < 0) {
111 nowMs = 0;
112 } else {
113 nowMs = (u8)now.tv_sec * 1000 + now.tv_usec / 1000;
114 }
115
116 /* u4: high word of the 64-bit time.
117 */
118 U4_TO_BUF_BE(buf, 0, (u4)(nowMs >> 32));
119 fwrite(buf, 1, sizeof(u4), fp);
120
121 /* u4: low word of the 64-bit time.
122 */
123 U4_TO_BUF_BE(buf, 0, (u4)(nowMs & 0xffffffffULL));
124 fwrite(buf, 1, sizeof(u4), fp); //xxx fix the time
125 }
126 }
127
hprofFlushRecord(hprof_record_t * rec,FILE * fp)128 int hprofFlushRecord(hprof_record_t *rec, FILE *fp)
129 {
130 if (rec->dirty) {
131 unsigned char headBuf[sizeof (u1) + 2 * sizeof (u4)];
132 int nb;
133
134 headBuf[0] = rec->tag;
135 U4_TO_BUF_BE(headBuf, 1, rec->time);
136 U4_TO_BUF_BE(headBuf, 5, rec->length);
137
138 nb = fwrite(headBuf, 1, sizeof(headBuf), fp);
139 if (nb != sizeof(headBuf)) {
140 return UNIQUE_ERROR();
141 }
142 nb = fwrite(rec->body, 1, rec->length, fp);
143 if (nb != (int)rec->length) {
144 return UNIQUE_ERROR();
145 }
146
147 rec->dirty = false;
148 }
149 //xxx if we used less than half (or whatever) of allocLen, shrink the buffer.
150
151 return 0;
152 }
153
hprofFlushCurrentRecord(hprof_context_t * ctx)154 int hprofFlushCurrentRecord(hprof_context_t *ctx)
155 {
156 return hprofFlushRecord(&ctx->curRec, ctx->memFp);
157 }
158
hprofStartNewRecord(hprof_context_t * ctx,u1 tag,u4 time)159 int hprofStartNewRecord(hprof_context_t *ctx, u1 tag, u4 time)
160 {
161 hprof_record_t *rec = &ctx->curRec;
162 int err;
163
164 err = hprofFlushRecord(rec, ctx->memFp);
165 if (err != 0) {
166 return err;
167 } else if (rec->dirty) {
168 return UNIQUE_ERROR();
169 }
170
171 rec->dirty = true;
172 rec->tag = tag;
173 rec->time = time;
174 rec->length = 0;
175
176 return 0;
177 }
178
guaranteeRecordAppend(hprof_record_t * rec,size_t nmore)179 static inline int guaranteeRecordAppend(hprof_record_t *rec, size_t nmore)
180 {
181 size_t minSize;
182
183 minSize = rec->length + nmore;
184 if (minSize > rec->allocLen) {
185 unsigned char *newBody;
186 size_t newAllocLen;
187
188 newAllocLen = rec->allocLen * 2;
189 if (newAllocLen < minSize) {
190 newAllocLen = rec->allocLen + nmore + nmore/2;
191 }
192 newBody = (unsigned char *)realloc(rec->body, newAllocLen);
193 if (newBody != NULL) {
194 rec->body = newBody;
195 rec->allocLen = newAllocLen;
196 } else {
197 //TODO: set an error flag so future ops will fail
198 return UNIQUE_ERROR();
199 }
200 }
201
202 assert(rec->length + nmore <= rec->allocLen);
203 return 0;
204 }
205
hprofAddU1ListToRecord(hprof_record_t * rec,const u1 * values,size_t numValues)206 int hprofAddU1ListToRecord(hprof_record_t *rec, const u1 *values,
207 size_t numValues)
208 {
209 int err;
210
211 err = guaranteeRecordAppend(rec, numValues);
212 if (err != 0) {
213 return err;
214 }
215
216 memcpy(rec->body + rec->length, values, numValues);
217 rec->length += numValues;
218
219 return 0;
220 }
221
hprofAddU1ToRecord(hprof_record_t * rec,u1 value)222 int hprofAddU1ToRecord(hprof_record_t *rec, u1 value)
223 {
224 int err;
225
226 err = guaranteeRecordAppend(rec, 1);
227 if (err != 0) {
228 return err;
229 }
230
231 rec->body[rec->length++] = value;
232
233 return 0;
234 }
235
hprofAddUtf8StringToRecord(hprof_record_t * rec,const char * str)236 int hprofAddUtf8StringToRecord(hprof_record_t *rec, const char *str)
237 {
238 /* The terminating NUL character is NOT written.
239 */
240 //xxx don't do a strlen; add and grow as necessary, until NUL
241 return hprofAddU1ListToRecord(rec, (const u1 *)str, strlen(str));
242 }
243
hprofAddU2ListToRecord(hprof_record_t * rec,const u2 * values,size_t numValues)244 int hprofAddU2ListToRecord(hprof_record_t *rec, const u2 *values,
245 size_t numValues)
246 {
247 int err = guaranteeRecordAppend(rec, numValues * 2);
248 if (err != 0) {
249 return err;
250 }
251
252 //xxx this can be way smarter
253 //xxx also, don't do this bytewise if aligned and on a matching-endian arch
254 unsigned char *insert = rec->body + rec->length;
255 for (size_t i = 0; i < numValues; i++) {
256 U2_TO_BUF_BE(insert, 0, *values++);
257 insert += sizeof(*values);
258 }
259 rec->length += numValues * 2;
260
261 return 0;
262 }
263
hprofAddU2ToRecord(hprof_record_t * rec,u2 value)264 int hprofAddU2ToRecord(hprof_record_t *rec, u2 value)
265 {
266 return hprofAddU2ListToRecord(rec, &value, 1);
267 }
268
hprofAddU4ListToRecord(hprof_record_t * rec,const u4 * values,size_t numValues)269 int hprofAddU4ListToRecord(hprof_record_t *rec, const u4 *values,
270 size_t numValues)
271 {
272 int err = guaranteeRecordAppend(rec, numValues * 4);
273 if (err != 0) {
274 return err;
275 }
276
277 //xxx this can be way smarter
278 //xxx also, don't do this bytewise if aligned and on a matching-endian arch
279 unsigned char *insert = rec->body + rec->length;
280 for (size_t i = 0; i < numValues; i++) {
281 U4_TO_BUF_BE(insert, 0, *values++);
282 insert += sizeof(*values);
283 }
284 rec->length += numValues * 4;
285
286 return 0;
287 }
288
hprofAddU4ToRecord(hprof_record_t * rec,u4 value)289 int hprofAddU4ToRecord(hprof_record_t *rec, u4 value)
290 {
291 return hprofAddU4ListToRecord(rec, &value, 1);
292 }
293
hprofAddU8ListToRecord(hprof_record_t * rec,const u8 * values,size_t numValues)294 int hprofAddU8ListToRecord(hprof_record_t *rec, const u8 *values,
295 size_t numValues)
296 {
297 int err = guaranteeRecordAppend(rec, numValues * 8);
298 if (err != 0) {
299 return err;
300 }
301
302 //xxx this can be way smarter
303 //xxx also, don't do this bytewise if aligned and on a matching-endian arch
304 unsigned char *insert = rec->body + rec->length;
305 for (size_t i = 0; i < numValues; i++) {
306 U8_TO_BUF_BE(insert, 0, *values++);
307 insert += sizeof(*values);
308 }
309 rec->length += numValues * 8;
310
311 return 0;
312 }
313
hprofAddU8ToRecord(hprof_record_t * rec,u8 value)314 int hprofAddU8ToRecord(hprof_record_t *rec, u8 value)
315 {
316 return hprofAddU8ListToRecord(rec, &value, 1);
317 }
318