Context Navigation

source: MondoRescue/branches/3.2/mondo/src/common/libmondo-mountlist.c@ 3236

Visit:

Last change on this file since 3236 was 3236, checked in by Bruno Cornec, 11 years ago
Fix again a dyn. memory allocation issue, where a variable wasn't initialized before mr_strcat was used.
Property svn:keywords set to `Id`
File size: 29.9 KB

Rev	Line
[2052]	1	/* subroutines for handling mountlist
[128]	2	$Id: libmondo-mountlist.c 3236 2014-01-03 16:44:07Z bruno $
[1]	3	*/
	4
	5
	6	/**
	7	* @file
	8	* Functions which manipulate the mountlist.
	9	*/
	10
	11	#include "my-stuff.h"
[2209]	12	#include "mr_mem.h"
[1]	13	#include "mondostructures.h"
	14	#include "libmondo-mountlist.h"
[541]	15	#include "lib-common-externs.h"
[1]	16	#include "libmondo-raid-EXT.h"
	17	#include "libmondo-devices-EXT.h"
	18	#include "libmondo-tools-EXT.h"
	19	#include "libmondo-string-EXT.h"
[1236]	20	#include "newt-specific-EXT.h"
[1]	21
	22	/@unused@/
[128]	23	//static char cvsid[] = "$Id: libmondo-mountlist.c 3236 2014-01-03 16:44:07Z bruno $";
[1]	24
[1645]	25	/* Reference to global bkpinfo */
	26	extern struct s_bkpinfo *bkpinfo;
	27
[1]	28	/**
	29	* @addtogroup mountlistGroup
	30	* @{
	31	*/
	32	/**
	33	* Evaluate a drive within the mountlist for flaws. For example, too many
	34	* primary partitions, the first logical isn't 5, duplicate partitions,
	35	* ovar-allocated or under-allocated, unsupported format, silly size, or
	36	* silly mountpoint. Under FreeBSD, this checks the disklabel too, for the above-mentioned
	37	* errors as well as too many BSD partitions (more than 'h').
	38	* @param mountlist The mountlist to check.
	39	* @param drive The drive to check (e.g. @c /dev/hda).
[2207]	40	* @return The flaws string found (NULL for success) allocated to be freed
[1]	41	* @see evaluate_mountlist
	42	*/
[2207]	43	char evaluate_drive_within_mountlist(struct mountlist_itself mountlist, char *drive)
[1]	44	#ifdef __FreeBSD__
	45	{
	46	// FreeBSD-specific version of evaluate_drive_within_mountlist()
[128]	47	/@ int ************************************************************ */
	48	int prev_part_no = 0;
[1]	49	int curr_part_no = 0;
	50	int pos = 0, npos = 0;
	51	int res = 0;
	52	int device_copies = 0;
	53	int i = 0;
	54	int cur_sp_no = 0;
	55	int prev_sp_no = 0;
	56	int foundsome = FALSE;
	57
[128]	58	/@ buffers ******************************************************* */
[2516]	59	char tmp = NULL;
[1]	60	char device[MAX_STR_LEN];
	61
[2209]	62	char *flaws_str = NULL;
	63
[128]	64	/@ long ********************************************************** */
	65	long physical_drive_size = 0;
[1]	66	long amount_allocated = 0;
	67
[128]	68	/@ pointers ****************************************************** */
[1]	69	char *part_table_fmt;
	70
[128]	71	/@ initialize **************************************************** */
	72	prev_part_no = 0;
[3185]	73	mr_asprintf(flaws_str, "%s", "");
[1]	74
	75
[128]	76	physical_drive_size = get_phys_size_of_drive(drive);
[1]	77
[128]	78	if (physical_drive_size < 0) {
[3185]	79	mr_asprintf(tmp, " %s does not exist.", drive);
[2209]	80	mr_strcat(flaws_str, "%s", tmp);
[128]	81	} else {
[3185]	82	mr_asprintf(tmp, "%s is %ld MB", drive, physical_drive_size);
[128]	83	}
	84	log_it(tmp);
[2516]	85	mr_free(tmp);
[1]	86
	87
[128]	88	/* check DD */
	89	for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
	90	sprintf(device, "%s%c", drive, cur_sp_no);
	91	if (find_device_in_mountlist(mountlist, device) >= 0)
	92	foundsome = TRUE;
	93	}
	94	if (foundsome) {
	95	for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
	96	sprintf(device, "%s%c", drive, cur_sp_no);
	97	pos = find_device_in_mountlist(mountlist, device);
	98	if (pos < 0) {
	99	continue;
	100	}
	101	/* is it too big? */
	102	if (curr_part_no > 'h') {
[3185]	103	mr_asprintf(tmp, " Can only have up to 'h' in disklabel.");
[128]	104	log_it(tmp);
[2207]	105	mr_strcat(flaws_str, tmp);
[2516]	106	mr_free(tmp);
[128]	107	res++;
	108	}
	109	/* does partition /dev/adXsYZ exist more than once in the mountlist? */
[3060]	110	for (i = 0, device_copies = 0;
[128]	111	i < mountlist->entries; i++) {
	112	if (!strcmp(device, mountlist->el[i].device)) {
	113	device_copies++;
	114	}
	115	}
	116	if (device_copies > 1) {
[3185]	117	mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
[128]	118	if (!strstr(flaws_str, tmp)) {
	119	log_it(tmp);
[2207]	120	mr_strcat(flaws_str, tmp);
[128]	121	res++;
	122	}
[2516]	123	mr_free(tmp);
[128]	124	}
	125	/* silly partition size? */
	126	if (mountlist->el[pos].size < 8192
	127	&& strcmp(mountlist->el[pos].mountpoint, "lvm")) {
[3185]	128	mr_asprintf(tmp, " %s is tiny!", device);
[128]	129	log_it(tmp);
[2207]	130	mr_strcat(flaws_str, tmp);
[2516]	131	mr_free(tmp);
[128]	132	res++;
	133	}
	134	/* mountpoint should begin with / unless it is swap, lvm or raid */
	135	if (strcmp(mountlist->el[pos].mountpoint, "swap")
	136	&& strcmp(mountlist->el[pos].mountpoint, "lvm")
	137	&& strcmp(mountlist->el[pos].mountpoint, "raid")
	138	&& strcmp(mountlist->el[pos].mountpoint, "image")
	139	&& strcmp(mountlist->el[pos].mountpoint, "none")
	140	&& mountlist->el[pos].mountpoint[0] != '/') {
[3185]	141	mr_asprintf(tmp, " %s has a weird mountpoint.", device);
[128]	142	log_it(tmp);
[2207]	143	mr_strcat(flaws_str, tmp);
[2516]	144	mr_free(tmp);
[128]	145	res++;
	146	}
	147	/* is format sensible? */
	148	if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
[3185]	149	mr_asprintf(tmp, " %s has unsupported format %s.", device, mountlist->el[pos].format);
[128]	150	log_it(tmp);
[2207]	151	mr_strcat(flaws_str, tmp);
[2516]	152	mr_free(tmp);
[128]	153	res++;
	154	}
[2125]	155	amount_allocated += mountlist->el[pos].size / 1024L;
[128]	156	prev_sp_no = cur_sp_no;
	157	}
	158	}
[1]	159
[128]	160	npos = pos = 0;
	161	for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
[1303]	162	build_partition_name(device, drive, curr_part_no);
[128]	163	pos = find_device_in_mountlist(mountlist, device);
	164	npos = 0;
	165	for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) {
	166	sprintf(device, "%ss%i%c", device, curr_part_no, cur_sp_no);
	167	if (find_device_in_mountlist(mountlist, device) >= 0)
	168	npos++;
	169	}
	170	if (((pos >= 0) \|\| npos) && foundsome) {
[2207]	171	mr_strcat(flaws_str, " %s has both DD and PC-style partitions.", drive);
[2209]	172	return(flaws_str); // fatal error
[128]	173	}
	174
[1303]	175	build_partition_name(device, drive, curr_part_no);
[128]	176	if (pos > 0 && !npos) {
	177	/* gap in the partition list? */
	178	if (curr_part_no - prev_part_no > 1) {
	179	if (prev_part_no == 0) {
[3185]	180	mr_asprintf(tmp, " Gap prior to %s.", device);
[128]	181	log_it(tmp);
[2209]	182	mr_strcat(flaws_str, "%s", tmp);
[2516]	183	mr_free(tmp);
[128]	184	res++;
	185	} else if (curr_part_no > 5
	186	\|\| (curr_part_no <= 4 && prev_part_no > 0)) {
[3185]	187	mr_asprintf(tmp, " Gap between %ss%d and %d.", drive, prev_part_no, curr_part_no);
[128]	188	log_it(tmp);
[2209]	189	mr_strcat(flaws_str, "%s", tmp);
[2516]	190	mr_free(tmp);
[128]	191	res++;
	192	}
	193	}
	194	/* GPT allows more than 4 primary partitions */
	195	part_table_fmt = which_partition_format(drive);
	196	/* no spare primary partitions to help accommodate the logical(s)? */
	197	if ((curr_part_no >= 5 && prev_part_no == 4)
	198	&& (strcmp(part_table_fmt, "MBR") == 0)) {
[3185]	199	mr_asprintf(tmp, " Partition %ss4 is occupied.", drive);
[128]	200	log_it(tmp);
[2209]	201	mr_strcat(flaws_str, "%s", tmp);
[2516]	202	mr_free(tmp);
[128]	203	res++;
	204	}
	205	/* does partition /dev/adXsY exist more than once in the mountlist? */
[3060]	206	for (i = 0, device_copies = 0;
[128]	207	i < mountlist->entries; i++) {
	208	if (!strcmp(device, mountlist->el[i].device)) {
	209	device_copies++;
	210	}
	211	}
	212	if (device_copies > 1) {
[3185]	213	mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
[2209]	214	if (!strstr(flaws_str, "%s", tmp)) {
[128]	215	log_it(tmp);
[2209]	216	mr_strcat(flaws_str, "%s", tmp);
[128]	217	res++;
	218	}
[2516]	219	mr_free(tmp);
[128]	220	}
	221	/* silly partition size? */
	222	if (mountlist->el[pos].size < 8192
	223	&& strcmp(mountlist->el[pos].mountpoint, "lvm")) {
[3185]	224	mr_asprintf(tmp, " %s is tiny!", device);
[128]	225	log_it(tmp);
[2209]	226	mr_strcat(flaws_str, "%s", tmp);
[2516]	227	mr_free(tmp);
[128]	228	res++;
	229	}
	230	/* mountpoint should begin with / unless it is swap, lvm or raid */
	231	if (strcmp(mountlist->el[pos].mountpoint, "swap")
	232	&& strcmp(mountlist->el[pos].mountpoint, "lvm")
	233	&& strcmp(mountlist->el[pos].mountpoint, "raid")
	234	&& strcmp(mountlist->el[pos].mountpoint, "image")
	235	&& strcmp(mountlist->el[pos].mountpoint, "none")
	236	&& mountlist->el[pos].mountpoint[0] != '/') {
[3185]	237	mr_asprintf(tmp, " %s has a weird mountpoint.", device);
[128]	238	log_it(tmp);
[2209]	239	mr_strcat(flaws_str, "%s", tmp);
[2516]	240	mr_free(tmp);
[128]	241	res++;
	242	}
	243	/* is format sensible? */
	244	if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
[3185]	245	mr_asprintf(tmp, " %s has unsupported format %s.", device, mountlist->el[pos].format);
[128]	246	log_it(tmp);
[2209]	247	mr_strcat(flaws_str, "%s", tmp);
[2516]	248	mr_free(tmp);
[128]	249	res++;
	250	}
	251	} else {
	252	/* Check subpartitions */
	253	for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
	254	sprintf(device, "%ss%d%c", drive, curr_part_no, cur_sp_no);
	255	pos = find_device_in_mountlist(mountlist, device);
	256	if (pos < 0) {
	257	continue;
	258	}
	259	/* is it too big? */
	260	if (curr_part_no > 'h') {
[3185]	261	mr_asprintf(tmp, " Can only have up to 'h' in disklabel.");
[128]	262	log_it(tmp);
[2209]	263	mr_strcat(flaws_str, "%s", tmp);
[2516]	264	mr_free(tmp);
[128]	265	res++;
	266	}
	267	/* does partition /dev/adXsYZ exist more than once in the mountlist? */
[3060]	268	for (i = 0, device_copies = 0;
[128]	269	i < mountlist->entries; i++) {
	270	if (!strcmp(device, mountlist->el[i].device)) {
	271	device_copies++;
	272	}
	273	}
	274	if (device_copies > 1) {
[3185]	275	mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
[128]	276	if (!strstr(flaws_str, tmp)) {
	277	log_it(tmp);
[2209]	278	mr_strcat(flaws_str, "%s", tmp);
[128]	279	res++;
	280	}
[2516]	281	mr_free(tmp);
[128]	282	}
	283	/* silly partition size? */
	284	if (mountlist->el[pos].size < 8192
	285	&& strcmp(mountlist->el[pos].mountpoint, "lvm")) {
[3185]	286	mr_asprintf(tmp, " %s is tiny!", device);
[128]	287	log_it(tmp);
[2209]	288	mr_strcat(flaws_str, "%s", tmp);
[2516]	289	mr_free(tmp);
[128]	290	res++;
	291	}
	292	/* mountpoint should begin with / unless it is swap, lvm or raid */
	293	if (strcmp(mountlist->el[pos].mountpoint, "swap")
	294	&& strcmp(mountlist->el[pos].mountpoint, "lvm")
	295	&& strcmp(mountlist->el[pos].mountpoint, "raid")
	296	&& strcmp(mountlist->el[pos].mountpoint, "image")
	297	&& strcmp(mountlist->el[pos].mountpoint, "none")
	298	&& mountlist->el[pos].mountpoint[0] != '/') {
[3185]	299	mr_asprintf(tmp, " %s has a weird mountpoint.", device);
[128]	300	log_it(tmp);
[2209]	301	mr_strcat(flaws_str, "%s", tmp);
[2516]	302	mr_free(tmp);
[128]	303	res++;
	304	}
	305	/* is format sensible? */
	306	if (!is_this_a_valid_disk_format
	307	(mountlist->el[pos].format)) {
[3185]	308	mr_asprintf(tmp, " %s has unsupported format %s.", device, mountlist->el[pos].format);
[128]	309	log_it(tmp);
[2209]	310	mr_strcat(flaws_str, "%s", tmp);
[2516]	311	mr_free(tmp);
[128]	312	res++;
	313	}
[2125]	314	amount_allocated += mountlist->el[pos].size / 1024L;
[128]	315	prev_sp_no = cur_sp_no;
	316	}
	317	}
	318
	319	/* OK, continue with main loop */
[2125]	320	amount_allocated += mountlist->el[pos].size / 1024L;
[2665]	321
	322	/* This should only happen at the end but not tested now */
	323	if (amount_allocated > physical_drive_size) {
	324	// Used to be +1, but what if you're 1 MB too high?
[3191]	325	mr_asprintf(tmp, " %ld MB over-allocated on %s.",amount_allocated - physical_drive_size, drive);
[2665]	326	log_it(tmp);
	327
	328	/* Do we have more than 1 MB per partition ? */
	329	if (amount_allocated - physical_drive_size <= curr_part_no) {
	330	/* Probably a rouding error, just passing over
	331	* by reducing the last partition if possible */
	332	amount_allocated -= mountlist->el[pos].size / 1024L;
	333	mountlist->el[pos].size = (mountlist->el[pos].size - curr_part_no*1024L);
	334	amount_allocated += mountlist->el[pos].size / 1024L;
	335	} else {
	336	mr_strcat(flaws_str, "%s", tmp);
	337	res++;
	338	}
	339	mr_free(tmp);
	340	}
[128]	341	prev_part_no = curr_part_no;
	342	}
	343
	344	/* Over-allocated the disk? Unallocated space on disk? */
[3191]	345	if (amount_allocated > physical_drive_size) // Used to be +1, but what if you're 1 MB too high?
	346	{
	347	mr_asprintf(tmp, " %ld MB over-allocated on %s.", amount_allocated - physical_drive_size, drive);
[1236]	348	log_it(tmp);
[2209]	349	mr_strcat(flaws_str, "%s", tmp);
[2516]	350	mr_free(tmp);
[3191]	351	res++;
	352	} else if (amount_allocated < physical_drive_size - 1) { /* NOT AN ERROR, JUST A WARNING :-) */
	353	mr_asprintf(tmp, " %ld MB unallocated on %s.", physical_drive_size - amount_allocated, drive);
	354	log_it(tmp);
	355	mr_strcat(flaws_str, "%s", tmp);
	356	mr_free(tmp);
[128]	357	}
	358	if (res) {
[2209]	359	return (NULL);
[128]	360	} else {
[2209]	361	return (flaws_str);
[128]	362	}
[1]	363	}
	364
	365	#else
	366	// Linux-specific version of evaluate_drive_within_mountlist()
	367	{
	368
[128]	369	/@ int ************************************************************ */
	370	int prev_part_no = 0;
[1]	371	int curr_part_no = 0;
	372	int pos = 0;
	373	int res = 0;
	374	int device_copies = 0;
	375	int i = 0;
	376
[128]	377	/@ buffers ******************************************************* */
[2516]	378	char *tmp = NULL;
	379	char *device = NULL;
[2209]	380	char *flaws_str = NULL;
[1]	381
[128]	382	/@ long ********************************************************** */
[1295]	383	long physical_drive_size = 0L;
	384	long amount_allocated = 0L;
[1]	385
[128]	386	/@ pointers ****************************************************** */
[2204]	387	char *part_table_fmt = NULL;
[1]	388
[128]	389	/@ initialize **************************************************** */
	390	assert_string_is_neither_NULL_nor_zerolength(drive);
	391	assert(mountlist != NULL);
[3185]	392	mr_asprintf(flaws_str, "%s", "");
[1]	393
[128]	394	malloc_string(device);
	395	prev_part_no = 0;
[1]	396
[128]	397	physical_drive_size = get_phys_size_of_drive(drive);
[1]	398
[128]	399	if (physical_drive_size < 0) {
[2733]	400	if (strstr(drive,"/dev/dm-") == NULL) {
[3185]	401	mr_asprintf(tmp, " %s does not exist.", drive);
[2731]	402	log_it(tmp);
	403	mr_strcat(flaws_str, "%s", tmp);
	404	res++;
	405	mr_free(tmp);
	406	goto endoffunc;
	407	} else {
[3191]	408	log_it(" %s (dm) will be setup later on", drive);
[2731]	409	}
[128]	410	} else {
[3191]	411	log_it("%s is %ld MB", drive, physical_drive_size);
[128]	412	}
[1]	413
[128]	414	for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
[1298]	415	build_partition_name(device, drive, curr_part_no);
[128]	416	pos = find_device_in_mountlist(mountlist, device);
	417	if (pos < 0) {
	418	continue;
	419	}
[2380]	420	log_msg(2, "Processing partition %s on %s #%d in mountlist", device, drive, pos);
[128]	421	/* gap in the partition list? */
	422	if (curr_part_no - prev_part_no > 1) {
	423	if (prev_part_no == 0) {
[3185]	424	mr_asprintf(tmp, " Gap prior to %s.", device);
[128]	425	log_it(tmp);
[2209]	426	mr_strcat(flaws_str, "%s", tmp);
[2516]	427	mr_free(tmp);
[128]	428	res++;
	429	} else if (curr_part_no > 5
	430	\|\| (curr_part_no <= 4 && prev_part_no > 0)) {
[3191]	431	mr_asprintf(tmp, " Gap on %s between %d and %d.", drive, prev_part_no, curr_part_no);
[128]	432	log_it(tmp);
[2209]	433	mr_strcat(flaws_str, "%s", tmp);
[2516]	434	mr_free(tmp);
[128]	435	res++;
	436	}
	437	}
	438	/* GPT allows more than 4 primary partitions */
	439	part_table_fmt = which_partition_format(drive);
	440	/* no spare primary partitions to help accommodate the logical(s)? */
[3191]	441	if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt, "MBR") == 0)) {
[3185]	442	mr_asprintf(tmp, " Partition 4 of %s is occupied.", drive);
[128]	443	log_it(tmp);
[2209]	444	mr_strcat(flaws_str, "%s", tmp);
[2516]	445	mr_free(tmp);
[128]	446	res++;
	447	}
[3191]	448	mr_free(part_table_fmt);
	449
[128]	450	/* does partition /dev/hdNX exist more than once in the mountlist? */
[3060]	451	for (i = 0, device_copies = 0;
[128]	452	i < mountlist->entries; i++) {
	453	if (!strcmp(device, mountlist->el[i].device)) {
	454	device_copies++;
	455	}
	456	}
	457	if (device_copies > 1) {
[3191]	458	mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
[128]	459	if (!strstr(flaws_str, tmp)) {
	460	log_it(tmp);
[2209]	461	mr_strcat(flaws_str, "%s", tmp);
[128]	462	res++;
	463	}
[2516]	464	mr_free(tmp);
[128]	465	}
	466	/* silly partition size? */
	467	if (mountlist->el[pos].size < 8192
	468	&& strcmp(mountlist->el[pos].mountpoint, "lvm")) {
[3185]	469	mr_asprintf(tmp, " %s is tiny!", device);
[128]	470	log_it(tmp);
[2209]	471	mr_strcat(flaws_str, "%s", tmp);
[2516]	472	mr_free(tmp);
[128]	473	res++;
	474	}
	475	/* mountpoint should begin with / unless it is swap, lvm or raid */
	476	if (strcmp(mountlist->el[pos].mountpoint, "swap")
	477	&& strcmp(mountlist->el[pos].mountpoint, "lvm")
	478	&& strcmp(mountlist->el[pos].mountpoint, "raid")
	479	&& strcmp(mountlist->el[pos].mountpoint, "image")
	480	&& mountlist->el[pos].mountpoint[0] != '/') {
[3185]	481	mr_asprintf(tmp, " %s has a weird mountpoint.", device);
[128]	482	log_it(tmp);
[2209]	483	mr_strcat(flaws_str, "%s", tmp);
[2516]	484	mr_free(tmp);
[128]	485	res++;
	486	}
	487	/* is format sensible? */
	488	if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
[3185]	489	mr_asprintf(tmp, " %s has unsupported format %s.", device, mountlist->el[pos].format);
[128]	490	log_it(tmp);
[2209]	491	mr_strcat(flaws_str, "%s", tmp);
[2516]	492	mr_free(tmp);
[128]	493	res++;
	494	}
	495	/* OK, continue with main loop */
[2125]	496	amount_allocated += mountlist->el[pos].size / 1024L;
[128]	497	prev_part_no = curr_part_no;
[1]	498	}
[128]	499
	500	/* Over-allocated the disk? Unallocated space on disk? */
	501	if (amount_allocated > physical_drive_size + 1) {
[3191]	502	mr_asprintf(tmp, " %ld MB over-allocated on %s.", amount_allocated - physical_drive_size, drive);
[128]	503	log_it(tmp);
[2209]	504	mr_strcat(flaws_str, "%s", tmp);
[2516]	505	mr_free(tmp);
[128]	506	res++;
	507	} else if (amount_allocated < physical_drive_size - 1) { /* NOT AN ERROR, JUST A WARNING :-) */
[3191]	508	mr_asprintf(tmp, " %ld MB unallocated on %s.", physical_drive_size - amount_allocated, drive);
[1236]	509	log_it(tmp);
[2209]	510	mr_strcat(flaws_str, "%s", tmp);
[2516]	511	mr_free(tmp);
[1]	512	}
	513
[128]	514	endoffunc:
	515	paranoid_free(device);
[1]	516
[2371]	517	if (res == 0) {
	518	mr_free(flaws_str);
[2380]	519	log_msg(2, "Fine, no error in evaluate_drive_within_mountlist");
[2209]	520	return (NULL);
[128]	521	} else {
[2380]	522	log_msg(2, "Error in evaluate_drive_within_mountlist: %s", flaws_str);
[2209]	523	return (flaws_str);
[128]	524	}
[1]	525	}
	526	#endif
	527
	528
	529	/**
	530	* Evaluate a whole mountlist for flaws. Calls evaluate_drive_within_mountlist()
	531	* for each drive, and then spreads the flaws across three lines.
	532	* @param mountlist The mountlist to evaluate.
[2394]	533	* @return The flaws string (NULL for success).
[1]	534	* @see evaluate_drive_within_mountlist
	535	*/
[2394]	536	char evaluate_mountlist(struct mountlist_itself mountlist) {
[1]	537
[128]	538	/@ buffer ********************************************************** */
	539	struct list_of_disks *drivelist;
[2202]	540	char *tmp = NULL;
	541	char *flaws_str = NULL;
[1]	542
[2384]	543	int currline = 0;
	544	int copies = 0;
	545	int last_copy = 0;
	546
	547	/@ buffetr ******************************************************** */
	548	char *curr_mountpoint = NULL;
	549
[128]	550	/@ int ************************************************************* */
[1]	551	int i = 0;
	552
[128]	553	/@ initialize ****************************************************** */
[1]	554
[128]	555	drivelist = malloc(sizeof(struct list_of_disks));
	556	assert(mountlist != NULL);
[3236]	557	mr_asprintf(flaws_str, "%s", "");
[1]	558
[128]	559	make_list_of_drives_in_mountlist(mountlist, drivelist);
[1]	560
[128]	561	log_it("Evaluating mountlist...");
[1]	562
[128]	563	for (i = 0; i < drivelist->entries; i++) {
[3236]	564	if (strstr(drivelist->el[i].device, DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE)) {
[3191]	565	log_it(" Not evaluating %s (I don't know how yet)", drivelist->el[i].device);
[128]	566	} else {
[2235]	567	log_msg(8, "Evaluating drive #%d (%s) within mountlist", i, drivelist->el[i].device);
[2304]	568	tmp = evaluate_drive_within_mountlist(mountlist, drivelist->el[i].device);
[128]	569	}
[2207]	570	log_msg(8,"Entry: %d (%s)", i, drivelist->el[i].device);
[2304]	571	/* BCO: tmp can be NULL */
[2219]	572	if (tmp != NULL) {
[2394]	573	log_msg(8,"Adding: %s to flaws_str", tmp);
[2219]	574	mr_strcat(flaws_str, "%s", tmp);
[3191]	575	mr_free(tmp);
[2219]	576	}
[1]	577	}
[2384]	578
	579	/* Look for duplicate mountpoints in mountlist. */
	580	for (currline = 0; currline < mountlist->entries; currline++) {
[3185]	581	mr_asprintf(curr_mountpoint, "%s", mountlist->el[currline].mountpoint);
[2384]	582	for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries; i++) {
	583	if (!strcmp(mountlist->el[i].mountpoint, curr_mountpoint)
	584	&& strcmp(mountlist->el[i].mountpoint, "lvm")
	585	&& strcmp(mountlist->el[i].mountpoint, "swap")) {
	586	last_copy = i;
	587	copies++;
	588	}
	589	}
	590	if (copies > 1 && last_copy == currline
	591	&& strcmp(curr_mountpoint, "raid")) {
[3185]	592	mr_asprintf(tmp, " %s %s's.", number_to_text(copies), curr_mountpoint);
[2384]	593	mr_strcat(flaws_str, "%s", tmp);
[2394]	594	log_msg(8,"Adding: %s to flaws_str", tmp);
[3191]	595	mr_free(tmp);
[2384]	596	}
[3191]	597	mr_free(curr_mountpoint);
[2384]	598	}
	599
[2350]	600	return(flaws_str);
[1]	601	}
	602
	603
	604	/**
	605	* Find the index number of @p device in the mountlist.
	606	* The device given must match @p mountlist->el[N].device exactly, case-sensitive.
	607	* @param mountlist The mountlist to search in.
	608	* @param device The device to search for.
	609	* @return The zero-based index of the device, or -1 if it could not be found.
	610	*/
	611	int
[128]	612	find_device_in_mountlist(struct mountlist_itself mountlist, char device)
[1]	613	{
	614
[128]	615	/@ int ************************************************************* */
	616	int i = 0;
[1]	617
[128]	618	assert(mountlist != NULL);
	619	assert_string_is_neither_NULL_nor_zerolength(device);
	620	for (i = 0;
	621	i < mountlist->entries
	622	&& strcmp(mountlist->el[i].device, device) != 0; i++);
	623
	624	if (i == mountlist->entries) {
	625	return (-1);
	626	} else {
	627	return (i);
	628	}
[1]	629	}
	630
	631
	632	/**
	633	* Make a list of the drives mentioned in the mountlist.
	634	* @param mountlist The mountlist to examine.
	635	* @param drivelist Where to put the list of drives found.
	636	* @return The number of physical (non-RAID non-LVM) drives found, or \<= 0 for error.
	637	*/
	638	int
[128]	639	make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist,
	640	struct list_of_disks *drivelist)
[1]	641	{
	642
[128]	643	/@ int ************************************************************ */
	644	int lino;
	645	int noof_drives;
	646	int j;
[1]	647
[128]	648	/@ buffers ******************************************************** */
[2204]	649	char *drive = NULL;
[2230]	650	char *truncdrive = NULL;
[1]	651
[128]	652	long long size;
[1]	653
[128]	654	assert(mountlist != NULL);
	655	assert(drivelist != NULL);
	656	log_it("Making list of drives");
	657	for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) {
[1]	658
[3185]	659	mr_asprintf(drive, "%s", mountlist->el[lino].device);
[128]	660	if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
[2205]	661	log_msg(8, "Not putting %s in list of drives: it's a virtual drive", drive);
[3191]	662	mr_free(drive);
[128]	663	continue;
	664	}
[1]	665
[128]	666	size = mountlist->el[lino].size;
	667	if (size == 0) {
[2205]	668	log_msg(8, "Not putting %s in list of drives: it has zero size (maybe an LVM volume)", drive);
[3191]	669	mr_free(drive);
[128]	670	continue;
	671	}
	672
[2205]	673	log_msg(8, "Putting %s with size %lli in list of drives", drive, size);
[1]	674
[2237]	675	/* memory allocation */
[2230]	676	truncdrive = truncate_to_drive_name(drive);
[3191]	677	mr_free(drive);
[2237]	678
[2230]	679	log_msg(8, "drive truncated to %s", truncdrive);
[2206]	680
[128]	681	for (j = 0;
	682	j < noof_drives
[2230]	683	&& strcmp(drivelist->el[j].device, truncdrive) != 0; j++) {
[128]	684	continue;
[2205]	685	}
[128]	686	if (j == noof_drives) {
[2237]	687	strncpy(drivelist->el[noof_drives].device, truncdrive, 63);
[2235]	688	drivelist->el[noof_drives].device[63] = '\0';
[2236]	689	log_msg(8,"Adding drive %s to list", drivelist->el[noof_drives].device);
[2235]	690	noof_drives++;
[128]	691	}
[2230]	692	paranoid_free(truncdrive);
[2237]	693	if (noof_drives >= MAXIMUM_DISKS_PER_RAID_DEV) {
	694	log_msg(0, "Unable to handle mountlist with more than %d lines", MAXIMUM_DISKS_PER_RAID_DEV);
	695	log_to_screen("Unable to handle a so big mountlist");
	696	finish(1);
	697	}
[1]	698	}
[128]	699	drivelist->entries = noof_drives;
[2235]	700	log_msg(8, "Made list of %d drives",noof_drives);
[1]	701
[128]	702	return (noof_drives);
[1]	703	}
	704
	705
	706	/**
	707	* Make a list of RAID partitions not currently associated with any RAID device.
	708	* The user may add any of these partitions to the RAID device.
	709	* @param output_list Where to put the list of unallocated RAID partitions.
	710	* @param mountlist The mountlist to examine.
	711	* @param raidlist The raidlist to examine.
	712	*/
[128]	713	void make_list_of_unallocated_raid_partitions(struct mountlist_itself
	714	*output_list,
	715	struct mountlist_itself
	716	*mountlist,
	717	struct raidlist_itself
	718	*raidlist)
[1]	719	{
	720
[128]	721	/@ int ************************************************************ */
	722	int items = 0;
[1]	723	int i = 0;
	724	int used_by = 0;
	725
[128]	726	assert(output_list != NULL);
	727	assert(mountlist != NULL);
	728	assert(raidlist != NULL);
	729	log_it("MLOURP -- starting");
	730	items = 0;
[1]	731
	732
[128]	733	for (i = 0; i < mountlist->entries; i++) {
	734	if (strstr(mountlist->el[i].mountpoint, "raid")) {
[3191]	735	used_by = which_raid_device_is_using_this_partition(raidlist, mountlist->el[i].device);
[128]	736	if (used_by < 0) {
	737	memcpy((void *) &output_list->el[items++],
	738	(void *) &mountlist->el[i],
	739	sizeof(struct mountlist_line));
[3191]	740	log_it("%s is available; user may choose to add it to raid device", output_list->el[items - 1].device);
[128]	741	}
	742	}
[1]	743	}
[128]	744	output_list->entries = items;
	745	log_it("MLUORP -- ending");
[1]	746	}
	747
	748
	749	/**
	750	* Get the size of a mountlist entry by the @c device field.
	751	* @param mountlist The mountlist to search in.
	752	* @param device The device to search for
	753	* @return The size of the device (in KB), or -1 if it could not be found.
	754	*/
	755	long long
[128]	756	size_of_specific_device_in_mountlist(struct mountlist_itself *mountlist,
	757	char *device)
[1]	758	{
[128]	759	/@ int ************************************************************* */
	760	int i = 0;
[1]	761
	762
[128]	763	assert(mountlist != NULL);
	764	assert_string_is_neither_NULL_nor_zerolength(device);
[1]	765
[128]	766	for (i = 0;
	767	i < mountlist->entries && strcmp(mountlist->el[i].device, device);
	768	i++);
	769	if (i == mountlist->entries) {
	770	return (-1);
	771	} else {
	772	return (mountlist->el[i].size);
	773	}
[1]	774	}
	775
	776
	777	/**
	778	* Load a file on disk into @p mountlist.
	779	* The file on disk should consist of multiple lines, each containing 4 or 5
	780	* columns: the device, the mountpoint, the filesystem type, the size in kilobytes, and optionally the filesystem label.
	781	* Comments begin with a '#' without any leading whitespace. Any duplicate
	782	* entries are renamed.
	783	* @param mountlist The mountlist to load into.
	784	* @param fname The name of the file to load the mountlist from.
	785	* @return 0 for success, 1 for failure.
	786	*/
[128]	787	int load_mountlist(struct mountlist_itself mountlist, char fname)
[1]	788	{
[2204]	789	FILE *fin = NULL;
[128]	790	/* malloc ** */
[2204]	791	char *incoming = NULL;
	792	char *siz = NULL;
	793	char *tmp = NULL;
	794	char *p = NULL;
[1]	795
[2204]	796	int items = 0;
	797	int j = 0;
	798	int res = 0;
[1]	799
[128]	800	assert(mountlist != NULL);
	801	assert_string_is_neither_NULL_nor_zerolength(fname);
[2204]	802
[128]	803	if (!(fin = fopen(fname, "r"))) {
	804	log_it("Unable to open mountlist - '%s'", fname);
[541]	805	log_to_screen("Cannot open mountlist");
[128]	806	return (1);
	807	}
[2204]	808	malloc_string(siz);
[128]	809	log_it("Loading mountlist...");
[3191]	810	mr_getline(incoming, fin);
	811	while (!feof(fin)) {
[1]	812	#if linux
[3191]	813	res = sscanf(incoming, "%s %s %s %s %s", mountlist->el[items].device, mountlist->el[items].mountpoint, mountlist->el[items].format, siz, mountlist->el[items].label);
[2204]	814	if (res < 5) {
	815	/* no label found */
[2206]	816	log_msg(4, "no label found for %s",mountlist->el[items].device);
	817	strcpy(mountlist->el[items].label,"");
[2204]	818	}
[1]	819	#elif __FreeBSD__
[3191]	820	res = sscanf(incoming, "%s %s %s %s", mountlist->el[items].device, mountlist->el[items].mountpoint, mountlist->el[items].format, siz);
[2206]	821	strcpy(mountlist->el[items].label,"");
[1]	822	#endif
	823
[128]	824	if (!strcmp(mountlist->el[items].device, "/proc") \|\|
	825	!strcmp(mountlist->el[items].device, "proc") \|\|
	826	!strcmp(mountlist->el[items].device, "/sys") \|\|
	827	!strcmp(mountlist->el[items].device, "sys") \|\|
[2918]	828	!strcmp(mountlist->el[items].device, "/run") \|\|
	829	!strcmp(mountlist->el[items].device, "run") \|\|
[128]	830	!strcmp(mountlist->el[items].device, "/devpts") \|\|
	831	!strcmp(mountlist->el[items].device, "devpts")
	832	) {
[3191]	833	log_msg(1, "Ignoring %s in mountlist - not loading that line :) ", mountlist->el[items].device);
	834	mr_free(incoming);
	835	mr_getline(incoming, fin);
[128]	836	continue;
	837	}
	838	mountlist->el[items].size = atoll(siz);
	839	if (mountlist->el[items].device[0] != '\0'
	840	&& mountlist->el[items].device[0] != '#') {
	841	for (j = 0;
	842	j < items
	843	&& strcmp(mountlist->el[j].device,
	844	mountlist->el[items].device); j++);
	845	if (j < items) {
	846	strcat(mountlist->el[items].device, "_dup");
[3191]	847	log_it("Duplicate entry in mountlist - renaming to %s", mountlist->el[items].device);
[128]	848	}
[3185]	849	mr_asprintf(tmp, "%s", mountlist->el[items].device);
[128]	850	if (strstr(tmp, "/dev/md/")) {
	851	log_it("format_device() --- Contracting %s", tmp);
	852	p = strrchr(tmp, '/');
	853	if (p) {
	854	p = (p + 1);
	855	(p + 1) = (p + 2);
	856	(p + 2) = (p + 3);
	857	}
[3191]	858	log_it("It was %s; it is now %s", mountlist->el[items].device, tmp);
[128]	859	strcpy(mountlist->el[items].device, tmp);
	860	}
[2204]	861	paranoid_free(tmp);
[1]	862
[3191]	863	log_it("%s %s %s %lld %s", mountlist->el[items].device, mountlist->el[items].mountpoint, mountlist->el[items].format, mountlist->el[items].size, mountlist->el[items].label);
[128]	864	items++;
[2206]	865	if (items >= MAX_MOUNTLIST_ENTRIES) {
	866	log_to_screen("Too many lines in mountlist.. ABORTING");
	867	finish(1);
	868	}
[128]	869	}
[3191]	870	mr_free(incoming);
	871	mr_getline(incoming, fin);
[1]	872	}
[3191]	873	mr_free(incoming);
[128]	874	paranoid_fclose(fin);
	875	mountlist->entries = items;
[1]	876
[128]	877	log_it("Mountlist loaded successfully.");
[2204]	878	log_it("%d entries in mountlist", items);
	879
[128]	880	paranoid_free(siz);
	881	return (0);
[1]	882	}
	883
	884
	885
	886	/**
	887	* Save @p mountlist to a file on disk.
	888	* @param mountlist The mountlist to save.
	889	* @param fname The file to save it to.
	890	* @return 0 for success, 1 for failure.
	891	* @see load_mountlist
	892	*/
[128]	893	int save_mountlist_to_disk(struct mountlist_itself mountlist, char fname)
[1]	894	{
[128]	895	FILE *fout;
	896	int i;
[1]	897
[128]	898	assert(mountlist != NULL);
	899	assert_string_is_neither_NULL_nor_zerolength(fname);
[1]	900
[128]	901	log_it("save_mountlist_to_disk() --- saving to %s", fname);
	902	if (!(fout = fopen(fname, "w"))) {
	903	log_OS_error("WMTD - Cannot openout mountlist");
	904	return (1);
	905	}
	906	for (i = 0; i < mountlist->entries; i++) {
	907	fprintf(fout,
[1909]	908	"%-15s %-15s %-15s %-15lld %-15s\n",
[128]	909	mountlist->el[i].device, mountlist->el[i].mountpoint,
	910	mountlist->el[i].format, mountlist->el[i].size,
[1899]	911	mountlist->el[i].label);
[128]	912	}
	913	paranoid_fclose(fout);
[2944]	914	if (!(fout = fopen(MONDO_MNTLISTCHG, "w"))) {
	915	log_OS_error("WMTD - Cannot openout "MONDO_MNTLISTCHG);
	916	return (1);
	917	}
	918	fprintf(fout, "the mountlist was changed by mondorestore\n");
	919	paranoid_fclose(fout);
[128]	920	return (0);
[1]	921	}
	922
	923
	924	/**
	925	* Sort the mountlist alphabetically by device.
	926	* The sorting is done in-place.
	927	* @param mountlist The mountlist to sort.
	928	*/
[128]	929	void sort_mountlist_by_device(struct mountlist_itself *mountlist)
[1]	930	{
[128]	931	int diff;
	932	int lino = -999;
[1]	933
[128]	934	assert(mountlist != NULL);
[1]	935
[128]	936	while (lino < mountlist->entries) {
	937	for (lino = 1; lino < mountlist->entries; lino++) {
	938	diff =
	939	strcmp_inc_numbers(mountlist->el[lino - 1].device,
	940	mountlist->el[lino].device);
	941	if (diff > 0) {
	942	swap_mountlist_entries(mountlist, lino - 1, lino);
	943	break;
	944	}
	945	}
[1]	946	}
	947	}
	948
[2204]	949
[1]	950	/**
	951	* Sort the mountlist alphabetically by mountpoint.
	952	* The sorting is done in-place.
	953	* @param mountlist The mountlist to sort.
	954	* @param reverse If TRUE, then do a reverse sort.
	955	*/
[128]	956	void
	957	sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist,
	958	bool reverse)
[1]	959	{
[128]	960	int diff;
	961	int lino = -999;
[1]	962
[128]	963	assert(mountlist != NULL);
[1]	964
[128]	965	while (lino < mountlist->entries) {
	966	for (lino = 1; lino < mountlist->entries; lino++) {
	967	diff =
	968	strcmp(mountlist->el[lino - 1].mountpoint,
	969	mountlist->el[lino].mountpoint);
	970	if ((diff > 0 && !reverse) \|\| ((diff < 0 && reverse))) {
	971	swap_mountlist_entries(mountlist, lino - 1, lino);
	972	break;
	973	}
	974	}
[1]	975	}
	976	}
	977
	978
	979	/**
	980	* Swap two entries in the mountlist in-place.
	981	* @param mountlist The mountlist to swap the entries in.
	982	* @param a The index number of the first entry.
	983	* @param b The index number of the second entry.
	984	*/
[128]	985	void
[1]	986	swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b)
	987	{
[128]	988	/@ mallocs ** */
[2204]	989	char *device = NULL;
	990	char *mountpoint = NULL;
	991	char *format = NULL;
[1]	992
[128]	993	long long size;
[1]	994
[128]	995	assert(mountlist != NULL);
	996	assert(a >= 0);
	997	assert(b >= 0);
[1]	998
[3185]	999	mr_asprintf(device, "%s", mountlist->el[a].device);
	1000	mr_asprintf(mountpoint, "%s", mountlist->el[a].mountpoint);
	1001	mr_asprintf(format, "%s", mountlist->el[a].format);
[1]	1002
[128]	1003	size = mountlist->el[a].size;
[1]	1004
[128]	1005	strcpy(mountlist->el[a].device, mountlist->el[b].device);
	1006	strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint);
	1007	strcpy(mountlist->el[a].format, mountlist->el[b].format);
[1]	1008
[128]	1009	mountlist->el[a].size = mountlist->el[b].size;
[1]	1010
[128]	1011	strcpy(mountlist->el[b].device, device);
	1012	strcpy(mountlist->el[b].mountpoint, mountpoint);
	1013	strcpy(mountlist->el[b].format, format);
[1]	1014
[128]	1015	mountlist->el[b].size = size;
[3191]	1016	mr_free(device);
	1017	mr_free(mountpoint);
	1018	mr_free(format);
[1]	1019	}
	1020
	1021	/* @} - end of mountlistGroup */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: