[ipfire-2.x.git] / src / installer / hw.h

/*#############################################################################
#                                                                             #
# IPFire - An Open Source Firewall Distribution                               #
# Copyright (C) 2014 IPFire development team                                  #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#ifndef HEADER_HW_H
#define HEADER_HW_H

#include <libudev.h>

#define DESTINATION_MOUNT_PATH        "/harddisk"
#define SOURCE_MOUNT_PATH             "/cdrom"
#define SOURCE_TEST_FILE              SOURCE_MOUNT_PATH "/" DISTRO_SNAME "-" DISTRO_VERSION ".media"

#define HW_MAX_DISKS                 32
#define STRING_SIZE                1024
#define DEV_SIZE                    128

#define HW_PATH_BOOT                  "/boot"
#define HW_PATH_BOOT_EFI              "/boot/efi"
#define HW_PATH_DATA                  "/var"

#define HW_PART_TYPE_NORMAL           0
#define HW_PART_TYPE_RAID1            1

#define HW_PART_TABLE_MSDOS           0
#define HW_PART_TABLE_GPT             1

#define HW_FS_SWAP                    0
#define HW_FS_REISERFS                1
#define HW_FS_EXT4                    2
#define HW_FS_EXT4_WO_JOURNAL         3
#define HW_FS_XFS                     4
#define HW_FS_FAT32                   5

#define HW_FS_DEFAULT                 HW_FS_EXT4

#define RAID_METADATA                 "1.0"

#define SERIAL_BAUDRATE               115200

#define BYTES2MB(x) ((x) / 1024 / 1024)
#define MB2BYTES(x) ((unsigned long long)(x) * 1024 * 1024)

struct hw {
	struct udev *udev;
	char arch[STRING_SIZE];
	int efi;
};

struct hw_disk {
	char path[DEV_SIZE];
	unsigned long long size;

	char description[STRING_SIZE];
	char vendor[STRING_SIZE];
	char model[STRING_SIZE];

	// Reference counter
	int ref;
};

struct hw_destination {
	char path[DEV_SIZE];

	int is_raid;
	int raid_level;
	const struct hw_disk* disk1;
	const struct hw_disk* disk2;

	int part_table;
	char part_bootldr[DEV_SIZE];
	char part_boot[DEV_SIZE];
	char part_boot_efi[DEV_SIZE];
	char part_swap[DEV_SIZE];
	char part_root[DEV_SIZE];
	int part_boot_idx;
	int part_boot_efi_idx;

	int filesystem;

	unsigned long long size;
	unsigned long long size_bootldr;
	unsigned long long size_boot;
	unsigned long long size_boot_efi;
	unsigned long long size_swap;
	unsigned long long size_root;
};

struct hw* hw_init();
void hw_free(struct hw* hw);

int hw_mount(const char* source, const char* target, const char* fs, int flags);
int hw_umount(const char* target);

char* hw_find_source_medium(struct hw* hw);

struct hw_disk** hw_find_disks(struct hw* hw, const char* sourcedrive);
void hw_free_disks(struct hw_disk** disks);
unsigned int hw_count_disks(const struct hw_disk** disks);
struct hw_disk** hw_select_disks(struct hw_disk** disks, int* selection);
struct hw_disk** hw_select_first_disk(const struct hw_disk** disks);

struct hw_destination* hw_make_destination(struct hw* hw, int part_type, struct hw_disk** disks,
	int disable_swap);

unsigned long long hw_memory();

int hw_create_partitions(struct hw_destination* dest, const char* output);
int hw_create_filesystems(struct hw_destination* dest, const char* output);

int hw_mount_filesystems(struct hw_destination* dest, const char* prefix);
int hw_umount_filesystems(struct hw_destination* dest, const char* prefix);

int hw_destroy_raid_superblocks(const struct hw_destination* dest, const char* output);
int hw_setup_raid(struct hw_destination* dest, const char* output);
int hw_stop_all_raid_arrays(const char* output);

int hw_install_bootloader(struct hw* hw, struct hw_destination* dest, const char* output);
int hw_write_fstab(struct hw_destination* dest);

char* hw_find_backup_file(const char* output, const char* search_path);
int hw_restore_backup(const char* output, const char* backup_path, const char* destination);

int hw_start_networking(const char* output);

void hw_sync();

#endif /* HEADER_HW_H */
Commit	Line	Data
	1	/*#############################################################################
	2	# #
	3	# IPFire - An Open Source Firewall Distribution #
	4	# Copyright (C) 2014 IPFire development team #
	5	# #
	6	# This program is free software: you can redistribute it and/or modify #
	7	# it under the terms of the GNU General Public License as published by #
	8	# the Free Software Foundation, either version 3 of the License, or #
	9	# (at your option) any later version. #
	10	# #
	11	# This program is distributed in the hope that it will be useful, #
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	14	# GNU General Public License for more details. #
	15	# #
	16	# You should have received a copy of the GNU General Public License #
	17	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	18	# #
	19	#############################################################################*/
	20
	21	#ifndef HEADER_HW_H
	22	#define HEADER_HW_H
	23
	24	#include <libudev.h>
	25
	26	#define DESTINATION_MOUNT_PATH "/harddisk"
	27	#define SOURCE_MOUNT_PATH "/cdrom"
	28	#define SOURCE_TEST_FILE SOURCE_MOUNT_PATH "/" DISTRO_SNAME "-" DISTRO_VERSION ".media"
	29
	30	#define HW_MAX_DISKS 32
	31	#define STRING_SIZE 1024
	32	#define DEV_SIZE 128
	33
	34	#define HW_PATH_BOOT "/boot"
	35	#define HW_PATH_BOOT_EFI "/boot/efi"
	36	#define HW_PATH_DATA "/var"
	37
	38	#define HW_PART_TYPE_NORMAL 0
	39	#define HW_PART_TYPE_RAID1 1
	40
	41	#define HW_PART_TABLE_MSDOS 0
	42	#define HW_PART_TABLE_GPT 1
	43
	44	#define HW_FS_SWAP 0
	45	#define HW_FS_REISERFS 1
	46	#define HW_FS_EXT4 2
	47	#define HW_FS_EXT4_WO_JOURNAL 3
	48	#define HW_FS_XFS 4
	49	#define HW_FS_FAT32 5
	50
	51	#define HW_FS_DEFAULT HW_FS_EXT4
	52
	53	#define RAID_METADATA "1.0"
	54
	55	#define SERIAL_BAUDRATE 115200
	56
	57	#define BYTES2MB(x) ((x) / 1024 / 1024)
	58	#define MB2BYTES(x) ((unsigned long long)(x) * 1024 * 1024)
	59
	60	struct hw {
	61	struct udev *udev;
	62	char arch[STRING_SIZE];
	63	int efi;
	64	};
	65
	66	struct hw_disk {
	67	char path[DEV_SIZE];
	68	unsigned long long size;
	69
	70	char description[STRING_SIZE];
	71	char vendor[STRING_SIZE];
	72	char model[STRING_SIZE];
	73
	74	// Reference counter
	75	int ref;
	76	};
	77
	78	struct hw_destination {
	79	char path[DEV_SIZE];
	80
	81	int is_raid;
	82	int raid_level;
	83	const struct hw_disk* disk1;
	84	const struct hw_disk* disk2;
	85
	86	int part_table;
	87	char part_bootldr[DEV_SIZE];
	88	char part_boot[DEV_SIZE];
	89	char part_boot_efi[DEV_SIZE];
	90	char part_swap[DEV_SIZE];
	91	char part_root[DEV_SIZE];
	92	int part_boot_idx;
	93	int part_boot_efi_idx;
	94
	95	int filesystem;
	96
	97	unsigned long long size;
	98	unsigned long long size_bootldr;
	99	unsigned long long size_boot;
	100	unsigned long long size_boot_efi;
	101	unsigned long long size_swap;
	102	unsigned long long size_root;
	103	};
	104
	105	struct hw* hw_init();
	106	void hw_free(struct hw* hw);
	107
	108	int hw_mount(const char* source, const char* target, const char* fs, int flags);
	109	int hw_umount(const char* target);
	110
	111	char* hw_find_source_medium(struct hw* hw);
	112
	113	struct hw_disk** hw_find_disks(struct hw* hw, const char* sourcedrive);
	114	void hw_free_disks(struct hw_disk** disks);
	115	unsigned int hw_count_disks(const struct hw_disk** disks);
	116	struct hw_disk hw_select_disks(struct hw_disk disks, int* selection);
	117	struct hw_disk hw_select_first_disk(const struct hw_disk disks);
	118
	119	struct hw_destination* hw_make_destination(struct hw* hw, int part_type, struct hw_disk** disks,
	120	int disable_swap);
	121
	122	unsigned long long hw_memory();
	123
	124	int hw_create_partitions(struct hw_destination* dest, const char* output);
	125	int hw_create_filesystems(struct hw_destination* dest, const char* output);
	126
	127	int hw_mount_filesystems(struct hw_destination* dest, const char* prefix);
	128	int hw_umount_filesystems(struct hw_destination* dest, const char* prefix);
	129
	130	int hw_destroy_raid_superblocks(const struct hw_destination* dest, const char* output);
	131	int hw_setup_raid(struct hw_destination* dest, const char* output);
	132	int hw_stop_all_raid_arrays(const char* output);
	133
	134	int hw_install_bootloader(struct hw* hw, struct hw_destination* dest, const char* output);
	135	int hw_write_fstab(struct hw_destination* dest);
	136
	137	char* hw_find_backup_file(const char* output, const char* search_path);
	138	int hw_restore_backup(const char* output, const char* backup_path, const char* destination);
	139
	140	int hw_start_networking(const char* output);
	141
	142	void hw_sync();
	143
	144	#endif /* HEADER_HW_H */