1 /*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * System utilities.
5 */
6 #include <stdlib.h>
7 #include <stdio.h>
8 #include <unistd.h>
9 #include <string.h>
10 #include <sys/mman.h>
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <fcntl.h>
14 #include <limits.h>
15 #include <errno.h>
16 #include <assert.h>
17
18 #define LOG_TAG "sysutil"
19 #include "Log.h"
20 #include "SysUtil.h"
21
getFileStartAndLength(int fd,off_t * start_,size_t * length_)22 static int getFileStartAndLength(int fd, off_t *start_, size_t *length_)
23 {
24 off_t start, end;
25 size_t length;
26
27 assert(start_ != NULL);
28 assert(length_ != NULL);
29
30 // TODO: isn't start always 0 for the single call site? just use fstat instead?
31
32 start = TEMP_FAILURE_RETRY(lseek(fd, 0L, SEEK_CUR));
33 end = TEMP_FAILURE_RETRY(lseek(fd, 0L, SEEK_END));
34
35 if (TEMP_FAILURE_RETRY(lseek(fd, start, SEEK_SET)) == -1 ||
36 start == (off_t) -1 || end == (off_t) -1) {
37 LOGE("could not determine length of file\n");
38 return -1;
39 }
40
41 length = end - start;
42 if (length == 0) {
43 LOGE("file is empty\n");
44 return -1;
45 }
46
47 *start_ = start;
48 *length_ = length;
49
50 return 0;
51 }
52
53 /*
54 * Map a file (from fd's current offset) into a private, read-only memory
55 * segment. The file offset must be a multiple of the page size.
56 *
57 * On success, returns 0 and fills out "pMap". On failure, returns a nonzero
58 * value and does not disturb "pMap".
59 */
sysMapFD(int fd,MemMapping * pMap)60 static int sysMapFD(int fd, MemMapping* pMap)
61 {
62 off_t start;
63 size_t length;
64 void* memPtr;
65
66 assert(pMap != NULL);
67
68 if (getFileStartAndLength(fd, &start, &length) < 0)
69 return -1;
70
71 memPtr = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, start);
72 if (memPtr == MAP_FAILED) {
73 LOGW("mmap(%d, R, PRIVATE, %d, %d) failed: %s\n", (int) length,
74 fd, (int) start, strerror(errno));
75 return -1;
76 }
77
78 pMap->addr = memPtr;
79 pMap->length = length;
80 pMap->range_count = 1;
81 pMap->ranges = malloc(sizeof(MappedRange));
82 pMap->ranges[0].addr = memPtr;
83 pMap->ranges[0].length = length;
84
85 return 0;
86 }
87
sysMapBlockFile(FILE * mapf,MemMapping * pMap)88 static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
89 {
90 char block_dev[PATH_MAX+1];
91 size_t size;
92 unsigned int blksize;
93 unsigned int blocks;
94 unsigned int range_count;
95 unsigned int i;
96
97 if (fgets(block_dev, sizeof(block_dev), mapf) == NULL) {
98 LOGW("failed to read block device from header\n");
99 return -1;
100 }
101 for (i = 0; i < sizeof(block_dev); ++i) {
102 if (block_dev[i] == '\n') {
103 block_dev[i] = 0;
104 break;
105 }
106 }
107
108 if (fscanf(mapf, "%zu %u\n%u\n", &size, &blksize, &range_count) != 3) {
109 LOGW("failed to parse block map header\n");
110 return -1;
111 }
112
113 blocks = ((size-1) / blksize) + 1;
114
115 pMap->range_count = range_count;
116 pMap->ranges = malloc(range_count * sizeof(MappedRange));
117 memset(pMap->ranges, 0, range_count * sizeof(MappedRange));
118
119 // Reserve enough contiguous address space for the whole file.
120 unsigned char* reserve;
121 reserve = mmap64(NULL, blocks * blksize, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
122 if (reserve == MAP_FAILED) {
123 LOGW("failed to reserve address space: %s\n", strerror(errno));
124 return -1;
125 }
126
127 pMap->ranges[range_count-1].addr = reserve;
128 pMap->ranges[range_count-1].length = blocks * blksize;
129
130 int fd = open(block_dev, O_RDONLY);
131 if (fd < 0) {
132 LOGW("failed to open block device %s: %s\n", block_dev, strerror(errno));
133 return -1;
134 }
135
136 unsigned char* next = reserve;
137 for (i = 0; i < range_count; ++i) {
138 int start, end;
139 if (fscanf(mapf, "%d %d\n", &start, &end) != 2) {
140 LOGW("failed to parse range %d in block map\n", i);
141 return -1;
142 }
143
144 void* addr = mmap64(next, (end-start)*blksize, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, ((off64_t)start)*blksize);
145 if (addr == MAP_FAILED) {
146 LOGW("failed to map block %d: %s\n", i, strerror(errno));
147 return -1;
148 }
149 pMap->ranges[i].addr = addr;
150 pMap->ranges[i].length = (end-start)*blksize;
151
152 next += pMap->ranges[i].length;
153 }
154
155 pMap->addr = reserve;
156 pMap->length = size;
157
158 LOGI("mmapped %d ranges\n", range_count);
159
160 return 0;
161 }
162
sysMapFile(const char * fn,MemMapping * pMap)163 int sysMapFile(const char* fn, MemMapping* pMap)
164 {
165 memset(pMap, 0, sizeof(*pMap));
166
167 if (fn && fn[0] == '@') {
168 // A map of blocks
169 FILE* mapf = fopen(fn+1, "r");
170 if (mapf == NULL) {
171 LOGV("Unable to open '%s': %s\n", fn+1, strerror(errno));
172 return -1;
173 }
174
175 if (sysMapBlockFile(mapf, pMap) != 0) {
176 LOGW("Map of '%s' failed\n", fn);
177 return -1;
178 }
179
180 fclose(mapf);
181 } else {
182 // This is a regular file.
183 int fd = open(fn, O_RDONLY, 0);
184 if (fd < 0) {
185 LOGE("Unable to open '%s': %s\n", fn, strerror(errno));
186 return -1;
187 }
188
189 if (sysMapFD(fd, pMap) != 0) {
190 LOGE("Map of '%s' failed\n", fn);
191 close(fd);
192 return -1;
193 }
194
195 close(fd);
196 }
197 return 0;
198 }
199
200 /*
201 * Release a memory mapping.
202 */
sysReleaseMap(MemMapping * pMap)203 void sysReleaseMap(MemMapping* pMap)
204 {
205 int i;
206 for (i = 0; i < pMap->range_count; ++i) {
207 if (munmap(pMap->ranges[i].addr, pMap->ranges[i].length) < 0) {
208 LOGW("munmap(%p, %d) failed: %s\n",
209 pMap->ranges[i].addr, (int)pMap->ranges[i].length, strerror(errno));
210 }
211 }
212 free(pMap->ranges);
213 pMap->ranges = NULL;
214 pMap->range_count = 0;
215 }
216