vm/hprof/HprofOutput.cpp

   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  */
  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         ALOGE("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
 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
 154 int hprofFlushCurrentRecord(hprof_context_t *ctx)
 155 {
 156     return hprofFlushRecord(&ctx->curRec, ctx->memFp);
 157 }
 158
 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
 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
 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
 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
 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
 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
 264 int hprofAddU2ToRecord(hprof_record_t *rec, u2 value)
 265 {
 266     return hprofAddU2ListToRecord(rec, &value, 1);
 267 }
 268
 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
 289 int hprofAddU4ToRecord(hprof_record_t *rec, u4 value)
 290 {
 291     return hprofAddU4ListToRecord(rec, &value, 1);
 292 }
 293
 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
 314 int hprofAddU8ToRecord(hprof_record_t *rec, u8 value)
 315 {
 316     return hprofAddU8ListToRecord(rec, &value, 1);
 317 }