#include <assert.h>
#include <blkid/blkid.h>
+#include <errno.h>
#include <fcntl.h>
#include <libudev.h>
+#include <linux/loop.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
+#include <sys/stat.h>
#include <sys/swap.h>
+#include <sys/sysinfo.h>
#include <unistd.h>
#include <linux/fs.h>
return (strncmp(a, b, strlen(b)) == 0);
}
+static char loop_device[STRING_SIZE];
+
+static int setup_loop_device(const char* source, const char* device) {
+ int file_fd = open(source, O_RDWR);
+ if (file_fd < 0)
+ goto ERROR;
+
+ int device_fd = -1;
+ if ((device_fd = open(device, O_RDWR)) < 0)
+ goto ERROR;
+
+ if (ioctl(device_fd, LOOP_SET_FD, file_fd) < 0)
+ goto ERROR;
+
+ close(file_fd);
+ close(device_fd);
+
+ return 0;
+
+ERROR:
+ if (file_fd >= 0)
+ close(file_fd);
+
+ if (device_fd >= 0) {
+ ioctl(device_fd, LOOP_CLR_FD, 0);
+ close(device_fd);
+ }
+
+ return -1;
+}
+
int hw_mount(const char* source, const char* target, const char* fs, int flags) {
+ const char* loop_device = "/dev/loop0";
+
// Create target if it does not exist
if (access(target, X_OK) != 0)
mkdir(target, S_IRWXU|S_IRWXG|S_IRWXO);
+ struct stat st;
+ stat(source, &st);
+
+ if (S_ISREG(st.st_mode)) {
+ int r = setup_loop_device(source, loop_device);
+ if (r == 0) {
+ source = loop_device;
+ } else {
+ return -1;
+ }
+ }
+
return mount(source, target, fs, flags, NULL);
}
int hw_umount(const char* target) {
- return umount2(target, 0);
+ int r = umount2(target, 0);
+
+ if (r && errno == EBUSY) {
+ // Give it a moment to settle
+ sleep(1);
+
+ r = umount2(target, MNT_FORCE);
+ }
+
+ return r;
}
static int hw_test_source_medium(const char* path) {
free(disks);
}
-unsigned int hw_count_disks(struct hw_disk** disks) {
+unsigned int hw_count_disks(const struct hw_disk** disks) {
unsigned int ret = 0;
while (*disks++)
struct hw_disk** ret = hw_create_disks();
struct hw_disk** selected_disks = ret;
- unsigned int num_disks = hw_count_disks(disks);
+ unsigned int num_disks = hw_count_disks((const struct hw_disk**)disks);
for (unsigned int i = 0; i < num_disks; i++) {
if (!selection || selection[i]) {
return ret;
}
+struct hw_disk** hw_select_first_disk(const struct hw_disk** disks) {
+ struct hw_disk** ret = hw_create_disks();
+ struct hw_disk** selected_disks = ret;
+
+ unsigned int num_disks = hw_count_disks(disks);
+ assert(num_disks > 0);
+
+ for (unsigned int i = 0; i < num_disks; i++) {
+ struct hw_disk *disk = disks[i];
+ disk->ref++;
+
+ *selected_disks++ = disk;
+ break;
+ }
+
+ // Set sentinel
+ *selected_disks = NULL;
+
+ return ret;
+}
+
static unsigned long long hw_swap_size(struct hw_destination* dest) {
unsigned long long memory = hw_memory();
return 0;
}
-static int hw_calculate_partition_table(struct hw_destination* dest) {
+static int hw_calculate_partition_table(struct hw_destination* dest, int disable_swap) {
char path[DEV_SIZE];
int part_idx = 1;
}
dest->size_boot = hw_boot_size(dest);
- dest->size_swap = hw_swap_size(dest);
dest->size_root = hw_root_size(dest);
+ // Should we use swap?
+ if (disable_swap)
+ dest->size_swap = 0;
+ else
+ dest->size_swap = hw_swap_size(dest);
+
// Determine the size of the data partition.
unsigned long long used_space = dest->size_bootldr + dest->size_boot
+ dest->size_swap + dest->size_root;
return 0;
}
-struct hw_destination* hw_make_destination(int part_type, struct hw_disk** disks) {
+struct hw_destination* hw_make_destination(int part_type, struct hw_disk** disks, int disable_swap) {
struct hw_destination* dest = malloc(sizeof(*dest));
if (part_type == HW_PART_TYPE_NORMAL) {
// Is this a RAID device?
dest->is_raid = (part_type > HW_PART_TYPE_NORMAL);
- int r = hw_calculate_partition_table(dest);
+ int r = hw_calculate_partition_table(dest, disable_swap);
if (r)
return NULL;
}
unsigned long long hw_memory() {
- FILE* handle = NULL;
- char line[STRING_SIZE];
-
- unsigned long long memory = 0;
-
- /* Calculate amount of memory in machine */
- if ((handle = fopen("/proc/meminfo", "r"))) {
- while (fgets(line, sizeof(line), handle)) {
- if (!sscanf (line, "MemTotal: %llu kB", &memory)) {
- memory = 0;
- }
- }
+ struct sysinfo si;
- fclose(handle);
- }
+ int r = sysinfo(&si);
+ if (r < 0)
+ return 0;
- return memory * 1024;
+ return si.totalram;
}
static int hw_zero_out_device(const char* path, int bytes) {
}
int hw_umount_filesystems(struct hw_destination* dest, const char* prefix) {
+ int r;
+ char target[STRING_SIZE];
+
// Write all buffers to disk before umounting
hw_sync();
// boot
if (*dest->part_boot) {
- hw_umount(dest->part_boot);
+ snprintf(target, sizeof(target), "%s%s", prefix, HW_PATH_BOOT);
+ r = hw_umount(target);
+ if (r)
+ return -1;
}
// data
if (*dest->part_data) {
- hw_umount(dest->part_data);
+ snprintf(target, sizeof(target), "%s%s", prefix, HW_PATH_DATA);
+ r = hw_umount(target);
+ if (r)
+ return -1;
}
- // root
- hw_umount(dest->part_root);
-
// swap
if (*dest->part_swap) {
swapoff(dest->part_swap);
}
// misc filesystems
- char target[STRING_SIZE];
char** otherfs = other_filesystems;
-
while (*otherfs) {
snprintf(target, sizeof(target), "%s%s", prefix, *otherfs++);
- hw_umount(target);
+ r = hw_umount(target);
+ if (r)
+ return -1;
}
+ // root
+ r = hw_umount(prefix);
+ if (r)
+ return -1;
+
return 0;
}
r = system_chroot(output, DESTINATION_MOUNT_PATH, cmd);
}
+ hw_sync();
+
return r;
}
return uuid;
}
+#define FSTAB_FMT "UUID=%s %-8s %-4s %-10s %d %d\n"
+
int hw_write_fstab(struct hw_destination* dest) {
FILE* f = fopen(DESTINATION_MOUNT_PATH "/etc/fstab", "w");
if (!f)
return -1;
- const char* fmt = "UUID=%s %-8s %-4s %-10s %d %d\n";
char* uuid = NULL;
// boot
uuid = hw_get_uuid(dest->part_boot);
if (uuid) {
- fprintf(f, fmt, uuid, "/boot", "auto", "defaults", 1, 2);
+ fprintf(f, FSTAB_FMT, uuid, "/boot", "auto", "defaults", 1, 2);
free(uuid);
}
}
uuid = hw_get_uuid(dest->part_swap);
if (uuid) {
- fprintf(f, fmt, uuid, "swap", "swap", "defaults,pri=1", 0, 0);
+ fprintf(f, FSTAB_FMT, uuid, "swap", "swap", "defaults,pri=1", 0, 0);
free(uuid);
}
}
// root
uuid = hw_get_uuid(dest->part_root);
if (uuid) {
- fprintf(f, fmt, uuid, "/", "auto", "defaults", 1, 1);
+ fprintf(f, FSTAB_FMT, uuid, "/", "auto", "defaults", 1, 1);
free(uuid);
}
uuid = hw_get_uuid(dest->part_data);
if (uuid) {
- fprintf(f, fmt, uuid, "/var", "auto", "defaults", 1, 1);
+ fprintf(f, FSTAB_FMT, uuid, "/var", "auto", "defaults", 1, 1);
free(uuid);
}
}
sync();
sync();
}
+
+int hw_start_networking(const char* output) {
+ return mysystem(output, "/usr/bin/start-networking.sh");
+}
+
+char* hw_find_backup_file(const char* output, const char* search_path) {
+ char path[STRING_SIZE];
+
+ snprintf(path, sizeof(path), "%s/backup.ipf", search_path);
+ int r = access(path, R_OK);
+
+ if (r == 0)
+ return strdup(path);
+
+ return NULL;
+}
+
+int hw_restore_backup(const char* output, const char* backup_path, const char* destination) {
+ char command[STRING_SIZE];
+
+ snprintf(command, sizeof(command), "/bin/tar xzpf %s -C %s", backup_path, destination);
+ int rc = mysystem(output, command);
+
+ if (rc)
+ return -1;
+
+ return 0;
+}
projects / ipfire-2.x.git / blobdiff