2 * Copyright (C) 2008 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * Miscellaneous utility functions.
31 * Print a hex dump in this format:
33 01234567: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff 0123456789abcdef\n
35 * If "mode" is kHexDumpLocal, we start at offset zero, and show a full
36 * 16 bytes on the first line. If it's kHexDumpMem, we make this look
37 * like a memory dump, using the actual address, outputting a partial line
38 * if "vaddr" isn't aligned on a 16-byte boundary.
40 * "priority" and "tag" determine the values passed to the log calls.
42 * Does not use printf() or other string-formatting calls.
44 void dvmPrintHexDumpEx(int priority, const char* tag, const void* vaddr,
45 size_t length, HexDumpMode mode)
47 static const char gHexDigit[] = "0123456789abcdef";
48 const unsigned char* addr = vaddr;
49 char out[77]; /* exact fit */
50 unsigned int offset; /* offset to show while printing */
56 if (mode == kHexDumpLocal)
61 memset(out, ' ', sizeof(out)-1);
63 out[sizeof(out)-2] = '\n';
64 out[sizeof(out)-1] = '\0';
66 gap = (int) offset & 0x0f;
68 unsigned int lineOffset = offset & ~0x0f;
74 for (i = 0; i < 8; i++) {
75 *hex++ = gHexDigit[lineOffset >> 28];
81 count = ((int)length > 16-gap) ? 16-gap : (int)length; /* cap length */
83 assert(count+gap <= 16);
86 /* only on first line */
91 for (i = gap ; i < count+gap; i++) {
92 *hex++ = gHexDigit[*addr >> 4];
93 *hex++ = gHexDigit[*addr & 0x0f];
95 if (*addr >= 0x20 && *addr < 0x7f /*isprint(*addr)*/)
101 for ( ; i < 16; i++) {
102 /* erase extra stuff; only happens on last line */
109 LOG_PRI(priority, tag, "%s", out);
110 #if 0 //def HAVE_ANDROID_OS
112 * We can overrun logcat easily by writing at full speed. On the
113 * other hand, we can make Eclipse time out if we're showing
114 * packet dumps while debugging JDWP.
117 if (trickle++ == 8) {
132 * Fill out a DebugOutputTarget, suitable for printing to the log.
134 void dvmCreateLogOutputTarget(DebugOutputTarget* target, int priority,
137 assert(target != NULL);
140 target->which = kDebugTargetLog;
141 target->data.log.priority = priority;
142 target->data.log.tag = tag;
146 * Fill out a DebugOutputTarget suitable for printing to a file pointer.
148 void dvmCreateFileOutputTarget(DebugOutputTarget* target, FILE* fp)
150 assert(target != NULL);
153 target->which = kDebugTargetFile;
154 target->data.file.fp = fp;
158 * Free "target" and any associated data.
160 void dvmFreeOutputTarget(DebugOutputTarget* target)
166 * Print a debug message, to either a file or the log.
168 void dvmPrintDebugMessage(const DebugOutputTarget* target, const char* format,
173 va_start(args, format);
175 switch (target->which) {
176 case kDebugTargetLog:
177 LOG_PRI_VA(target->data.log.priority, target->data.log.tag,
180 case kDebugTargetFile:
181 vfprintf(target->data.file.fp, format, args);
184 LOGE("unexpected 'which' %d\n", target->which);
193 * Allocate a bit vector with enough space to hold at least the specified
196 BitVector* dvmAllocBitVector(int startBits, bool expandable)
201 assert(sizeof(bv->storage[0]) == 4); /* assuming 32-bit units */
202 assert(startBits >= 0);
204 bv = (BitVector*) malloc(sizeof(BitVector));
206 count = (startBits + 31) >> 5;
208 bv->storageSize = count;
209 bv->expandable = expandable;
210 bv->storage = (u4*) malloc(count * sizeof(u4));
211 memset(bv->storage, 0x00, count * sizeof(u4));
218 void dvmFreeBitVector(BitVector* pBits)
223 free(pBits->storage);
228 * "Allocate" the first-available bit in the bitmap.
230 * This is not synchronized. The caller is expected to hold some sort of
231 * lock that prevents multiple threads from executing simultaneously in
232 * dvmAllocBit/dvmFreeBit.
234 int dvmAllocBit(BitVector* pBits)
239 for (word = 0; word < pBits->storageSize; word++) {
240 if (pBits->storage[word] != 0xffffffff) {
242 * There are unallocated bits in this word. Return the first.
244 bit = ffs(~(pBits->storage[word])) -1;
245 assert(bit >= 0 && bit < 32);
246 pBits->storage[word] |= 1 << bit;
247 return (word << 5) | bit;
252 * Ran out of space, allocate more if we're allowed to.
254 if (!pBits->expandable)
257 pBits->storage = realloc(pBits->storage,
258 (pBits->storageSize + kBitVectorGrowth) * sizeof(u4));
259 memset(&pBits->storage[pBits->storageSize], 0x00,
260 kBitVectorGrowth * sizeof(u4));
261 pBits->storageSize += kBitVectorGrowth;
266 * Mark the specified bit as "set".
268 * Returns "false" if the bit is outside the range of the vector and we're
269 * not allowed to expand.
271 bool dvmSetBit(BitVector* pBits, int num)
274 if (num >= pBits->storageSize * (int)sizeof(u4) * 8) {
275 if (!pBits->expandable)
278 int newSize = (num + 31) >> 5;
279 assert(newSize > pBits->storageSize);
280 pBits->storage = realloc(pBits->storage, newSize * sizeof(u4));
281 memset(&pBits->storage[pBits->storageSize], 0x00,
282 (newSize - pBits->storageSize) * sizeof(u4));
285 pBits->storage[num >> 5] |= 1 << (num & 0x1f);
290 * Mark the specified bit as "clear".
292 void dvmClearBit(BitVector* pBits, int num)
294 assert(num >= 0 && num < (int) pBits->storageSize * (int)sizeof(u4) * 8);
296 pBits->storage[num >> 5] &= ~(1 << (num & 0x1f));
300 * Mark all bits bit as "clear".
302 void dvmClearAllBits(BitVector* pBits)
304 int count = pBits->storageSize;
305 memset(pBits->storage, 0, count * sizeof(u4));
309 * Determine whether or not the specified bit is set.
311 bool dvmIsBitSet(const BitVector* pBits, int num)
313 assert(num >= 0 && num < (int) pBits->storageSize * (int)sizeof(u4) * 8);
315 int val = pBits->storage[num >> 5] & (1 << (num & 0x1f));
320 * Count the number of bits that are set.
322 int dvmCountSetBits(const BitVector* pBits)
327 for (word = 0; word < pBits->storageSize; word++) {
328 u4 val = pBits->storage[word];
331 if (val == 0xffffffff) {
334 /* count the number of '1' bits */
347 * Return a newly-allocated string in which all occurrences of '.' have
348 * been changed to '/'. If we find a '/' in the original string, NULL
349 * is returned to avoid ambiguity.
351 char* dvmDotToSlash(const char* str)
353 char* newStr = strdup(str);
356 while (*cp != '\0') {
370 * Return a newly-allocated string for the "dot version" of the class
371 * name for the given type descriptor. That is, The initial "L" and
372 * final ";" (if any) have been removed and all occurrences of '/'
373 * have been changed to '.'.
375 char* dvmDescriptorToDot(const char* str)
377 size_t at = strlen(str);
380 if ((at >= 2) && (str[0] == 'L') && (str[at - 1] == ';')) {
381 at -= 2; /* Two fewer chars to copy. */
382 str++; /* Skip the 'L'. */
385 newStr = malloc(at + 1); /* Add one for the '\0'. */
390 newStr[at] = (str[at] == '/') ? '.' : str[at];
397 * Return a newly-allocated string for the type descriptor
398 * corresponding to the "dot version" of the given class name. That
399 * is, non-array names are surrounded by "L" and ";", and all
400 * occurrences of '.' are changed to '/'.
402 char* dvmDotToDescriptor(const char* str)
404 size_t length = strlen(str);
410 length += 2; /* for "L" and ";" */
414 newStr = at = malloc(length + 1); /* + 1 for the '\0' */
416 if (newStr == NULL) {
441 * Return a newly-allocated string for the internal-form class name for
442 * the given type descriptor. That is, the initial "L" and final ";" (if
443 * any) have been removed.
445 char* dvmDescriptorToName(const char* str)
448 size_t length = strlen(str) - 1;
449 char* newStr = malloc(length);
451 if (newStr == NULL) {
455 strlcpy(newStr, str + 1, length);
463 * Return a newly-allocated string for the type descriptor for the given
464 * internal-form class name. That is, a non-array class name will get
465 * surrounded by "L" and ";", while array names are left as-is.
467 char* dvmNameToDescriptor(const char* str)
470 size_t length = strlen(str);
471 char* descriptor = malloc(length + 3);
473 if (descriptor == NULL) {
478 strcpy(descriptor + 1, str);
479 descriptor[length + 1] = ';';
480 descriptor[length + 2] = '\0';
489 * Get a notion of the current time, in nanoseconds. This is meant for
490 * computing durations (e.g. "operation X took 52nsec"), so the result
491 * should not be used to get the current date/time.
493 u8 dvmGetRelativeTimeNsec(void)
495 #ifdef HAVE_POSIX_CLOCKS
497 clock_gettime(CLOCK_MONOTONIC, &now);
498 return (u8)now.tv_sec*1000000000LL + now.tv_nsec;
501 gettimeofday(&now, NULL);
502 return (u8)now.tv_sec*1000000000LL + now.tv_usec * 1000LL;
507 * Get the per-thread CPU time, in nanoseconds.
509 * Only useful for time deltas.
511 u8 dvmGetThreadCpuTimeNsec(void)
513 #ifdef HAVE_POSIX_CLOCKS
515 clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
516 return (u8)now.tv_sec*1000000000LL + now.tv_nsec;
523 * Get the per-thread CPU time, in nanoseconds, for the specified thread.
525 u8 dvmGetOtherThreadCpuTimeNsec(pthread_t thread)
527 #if 0 /*def HAVE_POSIX_CLOCKS*/
530 if (pthread_getcpuclockid(thread, &clockId) != 0)
534 clock_gettime(clockId, &now);
535 return (u8)now.tv_sec*1000000000LL + now.tv_nsec;
543 * Call this repeatedly, with successively higher values for "iteration",
544 * to sleep for a period of time not to exceed "maxTotalSleep".
546 * For example, when called with iteration==0 we will sleep for a very
547 * brief time. On the next call we will sleep for a longer time. When
548 * the sum total of all sleeps reaches "maxTotalSleep", this returns false.
550 * The initial start time value for "relStartTime" MUST come from the
551 * dvmGetRelativeTimeUsec call. On the device this must come from the
552 * monotonic clock source, not the wall clock.
554 * This should be used wherever you might be tempted to call sched_yield()
555 * in a loop. The problem with sched_yield is that, for a high-priority
556 * thread, the kernel might not actually transfer control elsewhere.
558 * Returns "false" if we were unable to sleep because our time was up.
560 bool dvmIterativeSleep(int iteration, int maxTotalSleep, u8 relStartTime)
562 const int minSleep = 10000;
567 * Get current time, and see if we've already exceeded the limit.
569 curTime = dvmGetRelativeTimeUsec();
570 if (curTime >= relStartTime + maxTotalSleep) {
571 LOGVV("exsl: sleep exceeded (start=%llu max=%d now=%llu)\n",
572 relStartTime, maxTotalSleep, curTime);
577 * Compute current delay. We're bounded by "maxTotalSleep", so no
578 * real risk of overflow assuming "usleep" isn't returning early.
579 * (Besides, 2^30 usec is about 18 minutes by itself.)
581 * For iteration==0 we just call sched_yield(), so the first sleep
582 * at iteration==1 is actually (minSleep * 2).
585 while (iteration-- > 0)
587 assert(curDelay > 0);
589 if (curTime + curDelay >= relStartTime + maxTotalSleep) {
590 LOGVV("exsl: reduced delay from %d to %d\n",
591 curDelay, (int) ((relStartTime + maxTotalSleep) - curTime));
592 curDelay = (int) ((relStartTime + maxTotalSleep) - curTime);
595 if (iteration == 0) {
596 LOGVV("exsl: yield\n");
599 LOGVV("exsl: sleep for %d\n", curDelay);
607 * Set the "close on exec" flag so we don't expose our file descriptors
608 * to processes launched by us.
610 bool dvmSetCloseOnExec(int fd)
615 * There's presently only one flag defined, so getting the previous
616 * value of the fd flags is probably unnecessary.
618 flags = fcntl(fd, F_GETFD);
620 LOGW("Unable to get fd flags for fd %d\n", fd);
623 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
624 LOGW("Unable to set close-on-exec for fd %d\n", fd);
631 /* Implementation of strlcpy() for platforms that don't already have it. */
632 size_t strlcpy(char *dst, const char *src, size_t size) {
633 size_t srcLength = strlen(src);
634 size_t copyLength = srcLength;
636 if (srcLength > (size - 1)) {
637 copyLength = size - 1;
641 strncpy(dst, src, copyLength);
642 dst[copyLength] = '\0';