1 /* febootstrap-supermin-helper reimplementation in C.
2 * Copyright (C) 2009-2010 Red Hat Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 #include "xvasprintf.h"
36 #include "ext2internal.h"
40 /* The ext2 image that we build always has a fixed size, and we 'hope'
41 * that the files fit in (otherwise we'll get an error). Note that
42 * the file is sparsely allocated.
44 * The downside of allocating a very large initial disk is that the
45 * fixed overhead of ext2 is larger (since ext2 calculates it based on
46 * the size of the disk). For a 1GB disk the overhead is
49 * In future, make this configurable, or determine it from the input
52 #define APPLIANCE_SIZE (1024*1024*1024)
55 ext2_start (const char *hostcpu, const char *appliance,
56 const char *modpath, const char *initrd)
58 initialize_ext2_error_table ();
60 /* Make the initrd. */
61 ext2_make_initrd (modpath, initrd);
63 /* Make the appliance sparse image. */
64 int fd = open (appliance, O_WRONLY | O_CREAT | O_TRUNC | O_NOCTTY, 0644);
66 error (EXIT_FAILURE, errno, "open: %s", appliance);
68 if (lseek (fd, APPLIANCE_SIZE - 1, SEEK_SET) == -1)
69 error (EXIT_FAILURE, errno, "lseek");
72 if (write (fd, &c, 1) != 1)
73 error (EXIT_FAILURE, errno, "write");
76 error (EXIT_FAILURE, errno, "close");
78 /* Run mke2fs on the file.
79 * XXX Quoting, but this string doesn't come from an untrusted source.
81 char *cmd = xasprintf ("%s -t ext2 -F%s '%s'",
83 verbose >= 2 ? "" : "q",
86 if (r == -1 || WEXITSTATUS (r) != 0)
87 error (EXIT_FAILURE, 0, "%s: failed", cmd);
91 print_timestamped_message ("finished mke2fs");
93 /* Open the filesystem. */
95 ext2fs_open (appliance, EXT2_FLAG_RW, 0, 0, unix_io_manager, &fs);
97 error (EXIT_FAILURE, 0, "ext2fs_open: %s", error_message (err));
99 /* Bitmaps are not loaded by default, so load them. ext2fs_close will
100 * write out any changes.
102 err = ext2fs_read_bitmaps (fs);
104 error (EXIT_FAILURE, 0, "ext2fs_read_bitmaps: %s", error_message (err));
110 /* Write out changes and close. */
111 errcode_t err = ext2fs_close (fs);
113 error (EXIT_FAILURE, 0, "ext2fs_close: %s", error_message (err));
117 ext2_mkdir (ext2_ino_t dir_ino, const char *dirname, const char *basename,
118 mode_t mode, uid_t uid, gid_t gid,
119 time_t ctime, time_t atime, time_t mtime)
123 mode = LINUX_S_IFDIR | (mode & 0777);
125 /* Does the directory exist? This is legitimate: we just skip
129 err = ext2fs_namei (fs, EXT2_ROOT_INO, dir_ino, basename, &ino);
133 /* Otherwise, create it. */
134 err = ext2fs_new_inode (fs, dir_ino, mode, 0, &ino);
136 error (EXIT_FAILURE, 0, "ext2fs_new_inode: %s", error_message (err));
138 err = ext2fs_mkdir (fs, dir_ino, ino, basename);
140 error (EXIT_FAILURE, 0, "ext2fs_mkdir: %s/%s: %s",
141 dirname, basename, error_message (err));
143 /* Copy the final permissions, UID etc. to the inode. */
144 struct ext2_inode inode;
145 err = ext2fs_read_inode (fs, ino, &inode);
147 error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
151 inode.i_ctime = ctime;
152 inode.i_atime = atime;
153 inode.i_mtime = mtime;
154 err = ext2fs_write_inode (fs, ino, &inode);
156 error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
160 ext2_empty_inode (ext2_ino_t dir_ino, const char *dirname, const char *basename,
161 mode_t mode, uid_t uid, gid_t gid,
162 time_t ctime, time_t atime, time_t mtime,
163 int major, int minor, int dir_ft, ext2_ino_t *ino_ret)
166 struct ext2_inode inode;
169 err = ext2fs_new_inode (fs, dir_ino, mode, 0, &ino);
171 error (EXIT_FAILURE, 0, "ext2fs_new_inode: %s", error_message (err));
173 memset (&inode, 0, sizeof inode);
178 inode.i_links_count = 1;
179 inode.i_ctime = ctime;
180 inode.i_atime = atime;
181 inode.i_mtime = mtime;
183 inode.i_block[0] = (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
185 err = ext2fs_write_new_inode (fs, ino, &inode);
187 error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
189 ext2_link (dir_ino, basename, ino, dir_ft);
191 ext2fs_inode_alloc_stats2 (fs, ino, 1, 0);
197 /* You must create the file first with ext2_empty_inode. */
199 ext2_write_file (ext2_ino_t ino, const char *buf, size_t size)
203 err = ext2fs_file_open2 (fs, ino, NULL, EXT2_FILE_WRITE, &file);
205 error (EXIT_FAILURE, 0, "ext2fs_file_open2: %s", error_message (err));
207 /* ext2fs_file_write cannot deal with partial writes. You have
208 * to write the entire file in a single call.
210 unsigned int written;
211 err = ext2fs_file_write (file, buf, size, &written);
213 error (EXIT_FAILURE, 0, "ext2fs_file_write: %s", error_message (err));
214 if ((size_t) written != size)
215 error (EXIT_FAILURE, 0,
216 "ext2fs_file_write: size = %zu != written = %u\n",
219 err = ext2fs_file_flush (file);
221 error (EXIT_FAILURE, 0, "ext2fs_file_flush: %s", error_message (err));
222 err = ext2fs_file_close (file);
224 error (EXIT_FAILURE, 0, "ext2fs_file_close: %s", error_message (err));
226 /* Update the true size in the inode. */
227 struct ext2_inode inode;
228 err = ext2fs_read_inode (fs, ino, &inode);
230 error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
232 err = ext2fs_write_inode (fs, ino, &inode);
234 error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
237 /* This is just a wrapper around ext2fs_link which calls
238 * ext2fs_expand_dir as necessary if the directory fills up. See
239 * definition of expand_dir in the sources of debugfs.
242 ext2_link (ext2_ino_t dir_ino, const char *basename, ext2_ino_t ino, int dir_ft)
247 err = ext2fs_link (fs, dir_ino, basename, ino, dir_ft);
249 if (err == EXT2_ET_DIR_NO_SPACE) {
250 err = ext2fs_expand_dir (fs, dir_ino);
252 error (EXIT_FAILURE, 0, "ext2_link: ext2fs_expand_dir: %s: %s",
253 basename, error_message (err));
258 error (EXIT_FAILURE, 0, "ext2fs_link: %s: %s",
259 basename, error_message (err));
263 release_block (ext2_filsys fs, blk_t *blocknr,
264 int blockcnt, void *private)
269 ext2fs_block_alloc_stats (fs, block, -1);
273 /* unlink or rmdir path, if it exists. */
275 ext2_clean_path (ext2_ino_t dir_ino,
276 const char *dirname, const char *basename,
282 err = ext2fs_lookup (fs, dir_ino, basename, strlen (basename),
284 if (err == EXT2_ET_FILE_NOT_FOUND)
288 struct ext2_inode inode;
289 err = ext2fs_read_inode (fs, ino, &inode);
291 error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
292 inode.i_links_count--;
293 err = ext2fs_write_inode (fs, ino, &inode);
295 error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
297 err = ext2fs_unlink (fs, dir_ino, basename, 0, 0);
299 error (EXIT_FAILURE, 0, "ext2fs_unlink_inode: %s", error_message (err));
301 if (inode.i_links_count == 0) {
302 inode.i_dtime = time (NULL);
303 err = ext2fs_write_inode (fs, ino, &inode);
305 error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
307 if (ext2fs_inode_has_valid_blocks (&inode)) {
309 /* From the docs: "BLOCK_FLAG_READ_ONLY is a promise by the
310 * caller that it will not modify returned block number."
311 * RHEL 5 does not have this flag, so just omit it if it is
314 #ifdef BLOCK_FLAG_READ_ONLY
315 flags |= BLOCK_FLAG_READ_ONLY;
317 ext2fs_block_iterate (fs, ino, flags, NULL,
318 release_block, NULL);
321 ext2fs_inode_alloc_stats2 (fs, ino, -1, isdir);
324 /* else it's a directory, what to do? XXX */
327 /* Read in the whole file into memory. Check the size is still 'size'. */
329 read_whole_file (const char *filename, size_t size)
331 char *buf = malloc (size);
333 error (EXIT_FAILURE, errno, "malloc");
335 int fd = open (filename, O_RDONLY);
337 error (EXIT_FAILURE, errno, "open: %s", filename);
343 ssize_t r = read (fd, p, size - n);
345 error (EXIT_FAILURE, errno, "read: %s", filename);
347 error (EXIT_FAILURE, 0,
348 "error: file has changed size unexpectedly: %s", filename);
353 if (close (fd) == -1)
354 error (EXIT_FAILURE, errno, "close: %s", filename);
359 /* Add a file (or directory etc) from the host. */
361 ext2_file_stat (const char *orig_filename, const struct stat *statbuf)
366 fprintf (stderr, "ext2_file_stat %s 0%o\n",
367 orig_filename, statbuf->st_mode);
369 /* Sanity check the path. These rules are always true for the paths
370 * passed to us here from the appliance layer. The assertions just
371 * verify that the rules haven't changed.
373 size_t n = strlen (orig_filename);
374 assert (n <= PATH_MAX);
376 assert (orig_filename[0] == '/'); /* always absolute path */
377 assert (n == 1 || orig_filename[n-1] != '/'); /* no trailing slash */
379 /* Don't make the root directory, it always exists. This simplifies
380 * the code that follows.
384 const char *dirname, *basename;
385 const char *p = strrchr (orig_filename, '/');
387 if (orig_filename == p) { /* "/foo" */
389 basename = orig_filename+1;
390 dir_ino = EXT2_ROOT_INO;
391 } else { /* "/foo/bar" */
392 dirname = strndup (orig_filename, p-orig_filename);
395 /* Look up the parent directory. */
396 err = ext2fs_namei (fs, EXT2_ROOT_INO, EXT2_ROOT_INO, dirname, &dir_ino);
398 error (EXIT_FAILURE, 0, "ext2: parent directory not found: %s: %s",
399 dirname, error_message (err));
402 ext2_clean_path (dir_ino, dirname, basename, S_ISDIR (statbuf->st_mode));
406 /* Create regular file. */
407 if (S_ISREG (statbuf->st_mode)) {
408 /* XXX Hard links get duplicated here. */
410 ext2_empty_inode (dir_ino, dirname, basename,
411 statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
412 statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
413 0, 0, EXT2_FT_REG_FILE, &ino);
415 if (statbuf->st_size > 0) {
416 char *buf = read_whole_file (orig_filename, statbuf->st_size);
417 ext2_write_file (ino, buf, statbuf->st_size);
421 /* Create a symlink. */
422 else if (S_ISLNK (statbuf->st_mode)) {
424 ext2_empty_inode (dir_ino, dirname, basename,
425 statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
426 statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
427 0, 0, EXT2_FT_SYMLINK, &ino);
429 char buf[PATH_MAX+1];
430 ssize_t r = readlink (orig_filename, buf, sizeof buf);
432 error (EXIT_FAILURE, errno, "readlink: %s", orig_filename);
433 ext2_write_file (ino, buf, r);
435 /* Create directory. */
436 else if (S_ISDIR (statbuf->st_mode))
437 ext2_mkdir (dir_ino, dirname, basename,
438 statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
439 statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime);
440 /* Create a special file. */
441 else if (S_ISBLK (statbuf->st_mode)) {
442 dir_ft = EXT2_FT_BLKDEV;
445 else if (S_ISCHR (statbuf->st_mode)) {
446 dir_ft = EXT2_FT_CHRDEV;
448 } else if (S_ISFIFO (statbuf->st_mode)) {
449 dir_ft = EXT2_FT_FIFO;
451 } else if (S_ISSOCK (statbuf->st_mode)) {
452 dir_ft = EXT2_FT_SOCK;
454 ext2_empty_inode (dir_ino, dirname, basename,
455 statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
456 statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
457 major (statbuf->st_rdev), minor (statbuf->st_rdev),
463 ext2_file (const char *filename)
467 if (lstat (filename, &statbuf) == -1)
468 error (EXIT_FAILURE, errno, "lstat: %s", filename);
469 ext2_file_stat (filename, &statbuf);
472 /* In theory this could be optimized to avoid a namei lookup, but
473 * it probably wouldn't make much difference.
476 ext2_fts_entry (FTSENT *entry)
478 if (entry->fts_info & FTS_NS || entry->fts_info & FTS_NSOK)
479 ext2_file (entry->fts_path);
481 ext2_file_stat (entry->fts_path, entry->fts_statp);
484 struct writer ext2_writer = {
485 .wr_start = ext2_start,
487 .wr_file = ext2_file,
488 .wr_file_stat = ext2_file_stat,
489 .wr_fts_entry = ext2_fts_entry,
490 .wr_cpio_file = ext2_cpio_file,