Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | #include <stddef.h> |
2 | #include <string.h> | |
3 | #include <errno.h> | |
4 | /* _XOPEN_SOURCE is needed for pread, but we define _GNU_SOURCE, which defines | |
5 | * that. | |
6 | */ | |
7 | #include <unistd.h> | |
8 | #include <byteswap.h> | |
9 | #include <sys/time.h> | |
10 | #include <sys/param.h> | |
11 | #include <sys/user.h> | |
1da177e4 LT |
12 | |
13 | #include "os.h" | |
14 | ||
15 | #include "cow.h" | |
16 | #include "cow_sys.h" | |
17 | ||
18 | #define PATH_LEN_V1 256 | |
19 | ||
20 | struct cow_header_v1 { | |
21 | int magic; | |
22 | int version; | |
23 | char backing_file[PATH_LEN_V1]; | |
24 | time_t mtime; | |
25 | __u64 size; | |
26 | int sectorsize; | |
27 | }; | |
28 | ||
29 | #define PATH_LEN_V2 MAXPATHLEN | |
30 | ||
31 | struct cow_header_v2 { | |
32 | __u32 magic; | |
33 | __u32 version; | |
34 | char backing_file[PATH_LEN_V2]; | |
35 | time_t mtime; | |
36 | __u64 size; | |
37 | int sectorsize; | |
38 | }; | |
39 | ||
40 | /* Define PATH_LEN_V3 as the usual value of MAXPATHLEN, just hard-code it in | |
41 | * case other systems have different values for MAXPATHLEN | |
42 | */ | |
43 | #define PATH_LEN_V3 4096 | |
44 | ||
45 | /* Changes from V2 - | |
46 | * PATH_LEN_V3 as described above | |
47 | * Explicitly specify field bit lengths for systems with different | |
48 | * lengths for the usual C types. Not sure whether char or | |
49 | * time_t should be changed, this can be changed later without | |
50 | * breaking compatibility | |
51 | * Add alignment field so that different alignments can be used for the | |
52 | * bitmap and data | |
53 | * Add cow_format field to allow for the possibility of different ways | |
54 | * of specifying the COW blocks. For now, the only value is 0, | |
55 | * for the traditional COW bitmap. | |
56 | * Move the backing_file field to the end of the header. This allows | |
57 | * for the possibility of expanding it into the padding required | |
58 | * by the bitmap alignment. | |
59 | * The bitmap and data portions of the file will be aligned as specified | |
60 | * by the alignment field. This is to allow COW files to be | |
61 | * put on devices with restrictions on access alignments, such as | |
62 | * /dev/raw, with a 512 byte alignment restriction. This also | |
63 | * allows the data to be more aligned more strictly than on | |
64 | * sector boundaries. This is needed for ubd-mmap, which needs | |
65 | * the data to be page aligned. | |
66 | * Fixed (finally!) the rounding bug | |
67 | */ | |
68 | ||
69 | struct cow_header_v3 { | |
70 | __u32 magic; | |
71 | __u32 version; | |
72 | __u32 mtime; | |
73 | __u64 size; | |
74 | __u32 sectorsize; | |
75 | __u32 alignment; | |
76 | __u32 cow_format; | |
77 | char backing_file[PATH_LEN_V3]; | |
78 | }; | |
79 | ||
80 | /* COW format definitions - for now, we have only the usual COW bitmap */ | |
81 | #define COW_BITMAP 0 | |
82 | ||
83 | union cow_header { | |
84 | struct cow_header_v1 v1; | |
85 | struct cow_header_v2 v2; | |
86 | struct cow_header_v3 v3; | |
87 | }; | |
88 | ||
89 | #define COW_MAGIC 0x4f4f4f4d /* MOOO */ | |
90 | #define COW_VERSION 3 | |
91 | ||
92 | #define DIV_ROUND(x, len) (((x) + (len) - 1) / (len)) | |
93 | #define ROUND_UP(x, align) DIV_ROUND(x, align) * (align) | |
94 | ||
95 | void cow_sizes(int version, __u64 size, int sectorsize, int align, | |
96 | int bitmap_offset, unsigned long *bitmap_len_out, | |
97 | int *data_offset_out) | |
98 | { | |
99 | if(version < 3){ | |
100 | *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize); | |
101 | ||
102 | *data_offset_out = bitmap_offset + *bitmap_len_out; | |
103 | *data_offset_out = (*data_offset_out + sectorsize - 1) / | |
104 | sectorsize; | |
105 | *data_offset_out *= sectorsize; | |
106 | } | |
107 | else { | |
108 | *bitmap_len_out = DIV_ROUND(size, sectorsize); | |
109 | *bitmap_len_out = DIV_ROUND(*bitmap_len_out, 8); | |
110 | ||
111 | *data_offset_out = bitmap_offset + *bitmap_len_out; | |
112 | *data_offset_out = ROUND_UP(*data_offset_out, align); | |
113 | } | |
114 | } | |
115 | ||
116 | static int absolutize(char *to, int size, char *from) | |
117 | { | |
118 | char save_cwd[256], *slash; | |
119 | int remaining; | |
120 | ||
121 | if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) { | |
122 | cow_printf("absolutize : unable to get cwd - errno = %d\n", | |
123 | errno); | |
124 | return(-1); | |
125 | } | |
126 | slash = strrchr(from, '/'); | |
127 | if(slash != NULL){ | |
128 | *slash = '\0'; | |
129 | if(chdir(from)){ | |
130 | *slash = '/'; | |
131 | cow_printf("absolutize : Can't cd to '%s' - " | |
132 | "errno = %d\n", from, errno); | |
133 | return(-1); | |
134 | } | |
135 | *slash = '/'; | |
136 | if(getcwd(to, size) == NULL){ | |
137 | cow_printf("absolutize : unable to get cwd of '%s' - " | |
138 | "errno = %d\n", from, errno); | |
139 | return(-1); | |
140 | } | |
141 | remaining = size - strlen(to); | |
142 | if(strlen(slash) + 1 > remaining){ | |
143 | cow_printf("absolutize : unable to fit '%s' into %d " | |
144 | "chars\n", from, size); | |
145 | return(-1); | |
146 | } | |
147 | strcat(to, slash); | |
148 | } | |
149 | else { | |
150 | if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){ | |
151 | cow_printf("absolutize : unable to fit '%s' into %d " | |
152 | "chars\n", from, size); | |
153 | return(-1); | |
154 | } | |
155 | strcpy(to, save_cwd); | |
156 | strcat(to, "/"); | |
157 | strcat(to, from); | |
158 | } | |
159 | chdir(save_cwd); | |
160 | return(0); | |
161 | } | |
162 | ||
163 | int write_cow_header(char *cow_file, int fd, char *backing_file, | |
164 | int sectorsize, int alignment, unsigned long long *size) | |
165 | { | |
166 | struct cow_header_v3 *header; | |
167 | unsigned long modtime; | |
168 | int err; | |
169 | ||
170 | err = cow_seek_file(fd, 0); | |
171 | if(err < 0){ | |
172 | cow_printf("write_cow_header - lseek failed, err = %d\n", -err); | |
173 | goto out; | |
174 | } | |
175 | ||
176 | err = -ENOMEM; | |
177 | header = cow_malloc(sizeof(*header)); | |
178 | if(header == NULL){ | |
179 | cow_printf("Failed to allocate COW V3 header\n"); | |
180 | goto out; | |
181 | } | |
182 | header->magic = htonl(COW_MAGIC); | |
183 | header->version = htonl(COW_VERSION); | |
184 | ||
185 | err = -EINVAL; | |
186 | if(strlen(backing_file) > sizeof(header->backing_file) - 1){ | |
187 | cow_printf("Backing file name \"%s\" is too long - names are " | |
188 | "limited to %d characters\n", backing_file, | |
189 | sizeof(header->backing_file) - 1); | |
190 | goto out_free; | |
191 | } | |
192 | ||
193 | if(absolutize(header->backing_file, sizeof(header->backing_file), | |
194 | backing_file)) | |
195 | goto out_free; | |
196 | ||
197 | err = os_file_modtime(header->backing_file, &modtime); | |
198 | if(err < 0){ | |
199 | cow_printf("Backing file '%s' mtime request failed, " | |
200 | "err = %d\n", header->backing_file, -err); | |
201 | goto out_free; | |
202 | } | |
203 | ||
204 | err = cow_file_size(header->backing_file, size); | |
205 | if(err < 0){ | |
206 | cow_printf("Couldn't get size of backing file '%s', " | |
207 | "err = %d\n", header->backing_file, -err); | |
208 | goto out_free; | |
209 | } | |
210 | ||
211 | header->mtime = htonl(modtime); | |
212 | header->size = htonll(*size); | |
213 | header->sectorsize = htonl(sectorsize); | |
214 | header->alignment = htonl(alignment); | |
215 | header->cow_format = COW_BITMAP; | |
216 | ||
217 | err = os_write_file(fd, header, sizeof(*header)); | |
218 | if(err != sizeof(*header)){ | |
219 | cow_printf("Write of header to new COW file '%s' failed, " | |
220 | "err = %d\n", cow_file, -err); | |
221 | goto out_free; | |
222 | } | |
223 | err = 0; | |
224 | out_free: | |
225 | cow_free(header); | |
226 | out: | |
227 | return(err); | |
228 | } | |
229 | ||
230 | int file_reader(__u64 offset, char *buf, int len, void *arg) | |
231 | { | |
232 | int fd = *((int *) arg); | |
233 | ||
234 | return(pread(fd, buf, len, offset)); | |
235 | } | |
236 | ||
237 | /* XXX Need to sanity-check the values read from the header */ | |
238 | ||
239 | int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg, | |
240 | __u32 *version_out, char **backing_file_out, | |
241 | time_t *mtime_out, unsigned long long *size_out, | |
242 | int *sectorsize_out, __u32 *align_out, | |
243 | int *bitmap_offset_out) | |
244 | { | |
245 | union cow_header *header; | |
246 | char *file; | |
247 | int err, n; | |
248 | unsigned long version, magic; | |
249 | ||
250 | header = cow_malloc(sizeof(*header)); | |
251 | if(header == NULL){ | |
252 | cow_printf("read_cow_header - Failed to allocate header\n"); | |
253 | return(-ENOMEM); | |
254 | } | |
255 | err = -EINVAL; | |
256 | n = (*reader)(0, (char *) header, sizeof(*header), arg); | |
257 | if(n < offsetof(typeof(header->v1), backing_file)){ | |
258 | cow_printf("read_cow_header - short header\n"); | |
259 | goto out; | |
260 | } | |
261 | ||
262 | magic = header->v1.magic; | |
263 | if(magic == COW_MAGIC) { | |
264 | version = header->v1.version; | |
265 | } | |
266 | else if(magic == ntohl(COW_MAGIC)){ | |
267 | version = ntohl(header->v1.version); | |
268 | } | |
269 | /* No error printed because the non-COW case comes through here */ | |
270 | else goto out; | |
271 | ||
272 | *version_out = version; | |
273 | ||
274 | if(version == 1){ | |
275 | if(n < sizeof(header->v1)){ | |
276 | cow_printf("read_cow_header - failed to read V1 " | |
277 | "header\n"); | |
278 | goto out; | |
279 | } | |
280 | *mtime_out = header->v1.mtime; | |
281 | *size_out = header->v1.size; | |
282 | *sectorsize_out = header->v1.sectorsize; | |
283 | *bitmap_offset_out = sizeof(header->v1); | |
284 | *align_out = *sectorsize_out; | |
285 | file = header->v1.backing_file; | |
286 | } | |
287 | else if(version == 2){ | |
288 | if(n < sizeof(header->v2)){ | |
289 | cow_printf("read_cow_header - failed to read V2 " | |
290 | "header\n"); | |
291 | goto out; | |
292 | } | |
293 | *mtime_out = ntohl(header->v2.mtime); | |
294 | *size_out = ntohll(header->v2.size); | |
295 | *sectorsize_out = ntohl(header->v2.sectorsize); | |
296 | *bitmap_offset_out = sizeof(header->v2); | |
297 | *align_out = *sectorsize_out; | |
298 | file = header->v2.backing_file; | |
299 | } | |
300 | else if(version == 3){ | |
301 | if(n < sizeof(header->v3)){ | |
302 | cow_printf("read_cow_header - failed to read V2 " | |
303 | "header\n"); | |
304 | goto out; | |
305 | } | |
306 | *mtime_out = ntohl(header->v3.mtime); | |
307 | *size_out = ntohll(header->v3.size); | |
308 | *sectorsize_out = ntohl(header->v3.sectorsize); | |
309 | *align_out = ntohl(header->v3.alignment); | |
310 | *bitmap_offset_out = ROUND_UP(sizeof(header->v3), *align_out); | |
311 | file = header->v3.backing_file; | |
312 | } | |
313 | else { | |
314 | cow_printf("read_cow_header - invalid COW version\n"); | |
315 | goto out; | |
316 | } | |
317 | err = -ENOMEM; | |
318 | *backing_file_out = cow_strdup(file); | |
319 | if(*backing_file_out == NULL){ | |
320 | cow_printf("read_cow_header - failed to allocate backing " | |
321 | "file\n"); | |
322 | goto out; | |
323 | } | |
324 | err = 0; | |
325 | out: | |
326 | cow_free(header); | |
327 | return(err); | |
328 | } | |
329 | ||
330 | int init_cow_file(int fd, char *cow_file, char *backing_file, int sectorsize, | |
331 | int alignment, int *bitmap_offset_out, | |
332 | unsigned long *bitmap_len_out, int *data_offset_out) | |
333 | { | |
334 | unsigned long long size, offset; | |
335 | char zero = 0; | |
336 | int err; | |
337 | ||
338 | err = write_cow_header(cow_file, fd, backing_file, sectorsize, | |
339 | alignment, &size); | |
340 | if(err) | |
341 | goto out; | |
342 | ||
343 | *bitmap_offset_out = ROUND_UP(sizeof(struct cow_header_v3), alignment); | |
344 | cow_sizes(COW_VERSION, size, sectorsize, alignment, *bitmap_offset_out, | |
345 | bitmap_len_out, data_offset_out); | |
346 | ||
347 | offset = *data_offset_out + size - sizeof(zero); | |
348 | err = cow_seek_file(fd, offset); | |
349 | if(err < 0){ | |
350 | cow_printf("cow bitmap lseek failed : err = %d\n", -err); | |
351 | goto out; | |
352 | } | |
353 | ||
354 | /* does not really matter how much we write it is just to set EOF | |
355 | * this also sets the entire COW bitmap | |
356 | * to zero without having to allocate it | |
357 | */ | |
358 | err = cow_write_file(fd, &zero, sizeof(zero)); | |
359 | if(err != sizeof(zero)){ | |
360 | cow_printf("Write of bitmap to new COW file '%s' failed, " | |
361 | "err = %d\n", cow_file, -err); | |
362 | err = -EINVAL; | |
363 | goto out; | |
364 | } | |
365 | ||
366 | return(0); | |
367 | ||
368 | out: | |
369 | return(err); | |
370 | } | |
371 | ||
372 | /* | |
373 | * --------------------------------------------------------------------------- | |
374 | * Local variables: | |
375 | * c-file-style: "linux" | |
376 | * End: | |
377 | */ |