Changeset 128 in MondoRescue for branches/2.05/mondo/mondo/common/libmondo-mountlist.c
- Timestamp:
- Nov 19, 2005, 2:27:41 AM (18 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/2.05/mondo/mondo/common/libmondo-mountlist.c
r30 r128 1 1 /* libmondo-mountlist.c subroutines for handling mountlist 2 $Id : libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp$2 $Id$ 3 3 4 4 … … 61 61 62 62 /*@unused@*/ 63 //static char cvsid[] = "$Id : libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp$";63 //static char cvsid[] = "$Id$"; 64 64 65 65 /** … … 85 85 * @see evaluate_mountlist 86 86 */ 87 int evaluate_drive_within_mountlist 88 87 int evaluate_drive_within_mountlist(struct mountlist_itself *mountlist, 88 char *drive, char *flaws_str) 89 89 #ifdef __FreeBSD__ 90 90 { 91 91 // FreeBSD-specific version of evaluate_drive_within_mountlist() 92 /*@ int ************************************************************* */93 92 /*@ int ************************************************************* */ 93 int prev_part_no = 0; 94 94 int curr_part_no = 0; 95 95 int pos = 0, npos = 0; … … 102 102 int foundsome = FALSE; 103 103 104 /*@ buffers ******************************************************** */105 104 /*@ buffers ******************************************************** */ 105 char tmp[MAX_STR_LEN]; 106 106 char device[MAX_STR_LEN]; 107 107 char mountpoint[MAX_STR_LEN]; 108 108 109 /*@ long *********************************************************** */110 109 /*@ long *********************************************************** */ 110 long physical_drive_size = 0; 111 111 long amount_allocated = 0; 112 112 113 /*@ pointers ******************************************************* */113 /*@ pointers ******************************************************* */ 114 114 char *part_table_fmt; 115 115 116 /*@ initialize ******************************************************/ 117 flaws_str[0] = '\0'; 118 prev_part_no = 0; 119 tmp[0] = '\0'; 120 121 122 physical_drive_size = get_phys_size_of_drive (drive); 123 124 if (physical_drive_size < 0) 125 { 126 sprintf (tmp, " %s does not exist.", drive); 127 strcat (flaws_str, tmp); 128 } 129 else 130 { 131 sprintf (tmp, "%s is %ld MB", drive, physical_drive_size); 132 } 133 log_it (tmp); 134 135 136 /* check DD */ 137 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 138 sprintf (device, "%s%c", drive, cur_sp_no); 139 if (find_device_in_mountlist (mountlist, device) >= 0) 140 foundsome = TRUE; 141 } 142 if (foundsome) { 143 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 144 sprintf (device, "%s%c", drive, cur_sp_no); 145 pos = find_device_in_mountlist (mountlist, device); 146 if (pos < 0) 147 { 148 continue; 149 } 150 strcpy (mountpoint, mountlist->el[pos].mountpoint); 151 /* is it too big? */ 152 if (curr_part_no > 'h') 153 { 154 sprintf (tmp, " Can only have up to 'h' in disklabel."); 155 log_it (tmp); 156 strcat (flaws_str, tmp); 157 res++; 158 } 159 /* does partition /dev/adXsYZ exist more than once in the mountlist? */ 160 for (i = 0, mountpoint_copies = 0, device_copies = 0; 161 i < mountlist->entries; i++) 162 { 163 if (!strcmp (device, mountlist->el[i].device)) 164 { 165 device_copies++; 166 } 167 } 168 if (device_copies > 1) 169 { 170 sprintf (tmp, " %s %s's.", number_to_text (device_copies), device); 171 if (!strstr (flaws_str, tmp)) 172 { 173 log_it (tmp); 174 strcat (flaws_str, tmp); 175 res++; 176 } 177 } 178 /* silly partition size? */ 179 if (mountlist->el[pos].size < 8192 180 && strcmp (mountlist->el[pos].mountpoint, "lvm")) 181 { 182 sprintf (tmp, " %s is tiny!", device); 183 log_it (tmp); 184 strcat (flaws_str, tmp); 185 res++; 186 } 187 /* mountpoint should begin with / unless it is swap, lvm or raid */ 188 if (strcmp (mountlist->el[pos].mountpoint, "swap") 189 && strcmp (mountlist->el[pos].mountpoint, "lvm") 190 && strcmp (mountlist->el[pos].mountpoint, "raid") 191 && strcmp (mountlist->el[pos].mountpoint, "image") 192 && strcmp (mountlist->el[pos].mountpoint, "none") 193 && mountlist->el[pos].mountpoint[0] != '/') 194 { 195 sprintf (tmp, " %s has a weird mountpoint.", device); 196 log_it (tmp); 197 strcat (flaws_str, tmp); 198 res++; 199 } 200 /* is format sensible? */ 201 if (!is_this_a_valid_disk_format (mountlist->el[pos].format)) 202 { 203 sprintf (tmp, " %s has unsupported format.", device); 204 log_it (tmp); 205 strcat (flaws_str, tmp); 206 res++; 207 } 208 amount_allocated += mountlist->el[pos].size / 1024; 209 prev_sp_no = cur_sp_no; 210 } 211 } 212 213 npos = pos = 0; 214 for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) 215 { 216 sprintf (device, "%ss%d", drive, curr_part_no); 217 pos = find_device_in_mountlist (mountlist, device); 218 npos = 0; 219 for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) { 220 sprintf (device, "%ss%i%c", device, curr_part_no, cur_sp_no); 221 if (find_device_in_mountlist (mountlist, device) >= 0) npos++; 222 } 223 if (((pos >= 0) || npos) && foundsome) { 224 sprintf (flaws_str + strlen (flaws_str), " %s has both DD and PC-style partitions.", drive); 225 return ++res; // fatal error 226 } 227 228 sprintf (device, "%ss%d", drive, curr_part_no); 229 strcpy (mountpoint, mountlist->el[pos].mountpoint); 230 if (pos > 0 && !npos) { 231 /* gap in the partition list? */ 232 if (curr_part_no - prev_part_no > 1) 233 { 234 if (prev_part_no == 0) 235 { 236 sprintf (tmp, " Gap prior to %s.", device); 237 log_it (tmp); 238 strcat (flaws_str, tmp); 239 res++; 240 } 241 else if (curr_part_no > 5 242 || (curr_part_no <= 4 && prev_part_no > 0)) 243 { 244 sprintf (tmp, " Gap between %ss%d and %d.", drive, prev_part_no, 245 curr_part_no); 246 log_it (tmp); 247 strcat (flaws_str, tmp); 248 res++; 249 } 250 } 251 /* GPT allows more than 4 primary partitions */ 252 part_table_fmt = which_partition_format(drive); 253 /* no spare primary partitions to help accommodate the logical(s)? */ 254 if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0)) 255 { 256 sprintf (tmp, " Partition %ss4 is occupied.", drive); 257 log_it (tmp); 258 strcat (flaws_str, tmp); 259 res++; 260 } 261 /* does partition /dev/adXsY exist more than once in the mountlist? */ 262 for (i = 0, mountpoint_copies = 0, device_copies = 0; 263 i < mountlist->entries; i++) 264 { 265 if (!strcmp (device, mountlist->el[i].device)) 266 { 267 device_copies++; 268 } 269 } 270 if (device_copies > 1) 271 { 272 sprintf (tmp, " %s %s's.", number_to_text (device_copies), device); 273 if (!strstr (flaws_str, tmp)) 274 { 275 log_it (tmp); 276 strcat (flaws_str, tmp); 277 res++; 278 } 279 } 280 /* silly partition size? */ 281 if (mountlist->el[pos].size < 8192 282 && strcmp (mountlist->el[pos].mountpoint, "lvm")) 283 { 284 sprintf (tmp, " %s is tiny!", device); 285 log_it (tmp); 286 strcat (flaws_str, tmp); 287 res++; 288 } 289 /* mountpoint should begin with / unless it is swap, lvm or raid */ 290 if (strcmp (mountlist->el[pos].mountpoint, "swap") 291 && strcmp (mountlist->el[pos].mountpoint, "lvm") 292 && strcmp (mountlist->el[pos].mountpoint, "raid") 293 && strcmp (mountlist->el[pos].mountpoint, "image") 294 && strcmp (mountlist->el[pos].mountpoint, "none") 295 && mountlist->el[pos].mountpoint[0] != '/') 296 { 297 sprintf (tmp, " %s has a weird mountpoint.", device); 298 log_it (tmp); 299 strcat (flaws_str, tmp); 300 res++; 301 } 302 /* is format sensible? */ 303 if (!is_this_a_valid_disk_format (mountlist->el[pos].format)) 304 { 305 sprintf (tmp, " %s has unsupported format.", device); 306 log_it (tmp); 307 strcat (flaws_str, tmp); 308 res++; 309 } 310 } else { 311 /* Check subpartitions */ 312 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 313 sprintf (device, "%ss%d%c", drive, curr_part_no, cur_sp_no); 314 pos = find_device_in_mountlist (mountlist, device); 315 if (pos < 0) 316 { 317 continue; 318 } 319 strcpy (mountpoint, mountlist->el[pos].mountpoint); 320 /* is it too big? */ 321 if (curr_part_no > 'h') 322 { 323 sprintf (tmp, " Can only have up to 'h' in disklabel."); 324 log_it (tmp); 325 strcat (flaws_str, tmp); 326 res++; 327 } 328 /* does partition /dev/adXsYZ exist more than once in the mountlist? */ 329 for (i = 0, mountpoint_copies = 0, device_copies = 0; 330 i < mountlist->entries; i++) 331 { 332 if (!strcmp (device, mountlist->el[i].device)) 333 { 334 device_copies++; 335 } 336 } 337 if (device_copies > 1) 338 { 339 sprintf (tmp, " %s %s's.", number_to_text (device_copies), device); 340 if (!strstr (flaws_str, tmp)) 341 { 342 log_it (tmp); 343 strcat (flaws_str, tmp); 344 res++; 345 } 346 } 347 /* silly partition size? */ 348 if (mountlist->el[pos].size < 8192 349 && strcmp (mountlist->el[pos].mountpoint, "lvm")) 350 { 351 sprintf (tmp, " %s is tiny!", device); 352 log_it (tmp); 353 strcat (flaws_str, tmp); 354 res++; 355 } 356 /* mountpoint should begin with / unless it is swap, lvm or raid */ 357 if (strcmp (mountlist->el[pos].mountpoint, "swap") 358 && strcmp (mountlist->el[pos].mountpoint, "lvm") 359 && strcmp (mountlist->el[pos].mountpoint, "raid") 360 && strcmp (mountlist->el[pos].mountpoint, "image") 361 && strcmp (mountlist->el[pos].mountpoint, "none") 362 && mountlist->el[pos].mountpoint[0] != '/') 363 { 364 sprintf (tmp, " %s has a weird mountpoint.", device); 365 log_it (tmp); 366 strcat (flaws_str, tmp); 367 res++; 368 } 369 /* is format sensible? */ 370 if (!is_this_a_valid_disk_format (mountlist->el[pos].format)) 371 { 372 sprintf (tmp, " %s has unsupported format.", device); 373 log_it (tmp); 374 strcat (flaws_str, tmp); 375 res++; 376 } 377 amount_allocated += mountlist->el[pos].size / 1024; 378 prev_sp_no = cur_sp_no; 379 } 380 } 381 382 /* OK, continue with main loop */ 383 amount_allocated += mountlist->el[pos].size / 1024; 384 prev_part_no = curr_part_no; 385 } 386 387 /* Over-allocated the disk? Unallocated space on disk? */ 388 if (amount_allocated > physical_drive_size) // Used to be +1, but what if you're 1 MB too high? 389 { 390 sprintf (tmp, " %ld MB over-allocated on %s.", 391 amount_allocated - physical_drive_size, drive); 392 log_it (tmp); 393 strcat (flaws_str, tmp); 394 res++; 395 } 396 else if (amount_allocated < physical_drive_size - 1) 397 { /* NOT AN ERROR, JUST A WARNING :-) */ 398 sprintf (tmp, " %ld MB unallocated on %s.", 399 physical_drive_size - amount_allocated, drive); 400 log_it (tmp), strcat (flaws_str, tmp); 401 } 402 if (res) 403 { 404 return (FALSE); 405 } 406 else 407 { 408 return (TRUE); 409 } 116 /*@ initialize ***************************************************** */ 117 flaws_str[0] = '\0'; 118 prev_part_no = 0; 119 tmp[0] = '\0'; 120 121 122 physical_drive_size = get_phys_size_of_drive(drive); 123 124 if (physical_drive_size < 0) { 125 sprintf(tmp, " %s does not exist.", drive); 126 strcat(flaws_str, tmp); 127 } else { 128 sprintf(tmp, "%s is %ld MB", drive, physical_drive_size); 129 } 130 log_it(tmp); 131 132 133 /* check DD */ 134 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 135 sprintf(device, "%s%c", drive, cur_sp_no); 136 if (find_device_in_mountlist(mountlist, device) >= 0) 137 foundsome = TRUE; 138 } 139 if (foundsome) { 140 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 141 sprintf(device, "%s%c", drive, cur_sp_no); 142 pos = find_device_in_mountlist(mountlist, device); 143 if (pos < 0) { 144 continue; 145 } 146 strcpy(mountpoint, mountlist->el[pos].mountpoint); 147 /* is it too big? */ 148 if (curr_part_no > 'h') { 149 sprintf(tmp, " Can only have up to 'h' in disklabel."); 150 log_it(tmp); 151 strcat(flaws_str, tmp); 152 res++; 153 } 154 /* does partition /dev/adXsYZ exist more than once in the mountlist? */ 155 for (i = 0, mountpoint_copies = 0, device_copies = 0; 156 i < mountlist->entries; i++) { 157 if (!strcmp(device, mountlist->el[i].device)) { 158 device_copies++; 159 } 160 } 161 if (device_copies > 1) { 162 sprintf(tmp, " %s %s's.", number_to_text(device_copies), 163 device); 164 if (!strstr(flaws_str, tmp)) { 165 log_it(tmp); 166 strcat(flaws_str, tmp); 167 res++; 168 } 169 } 170 /* silly partition size? */ 171 if (mountlist->el[pos].size < 8192 172 && strcmp(mountlist->el[pos].mountpoint, "lvm")) { 173 sprintf(tmp, " %s is tiny!", device); 174 log_it(tmp); 175 strcat(flaws_str, tmp); 176 res++; 177 } 178 /* mountpoint should begin with / unless it is swap, lvm or raid */ 179 if (strcmp(mountlist->el[pos].mountpoint, "swap") 180 && strcmp(mountlist->el[pos].mountpoint, "lvm") 181 && strcmp(mountlist->el[pos].mountpoint, "raid") 182 && strcmp(mountlist->el[pos].mountpoint, "image") 183 && strcmp(mountlist->el[pos].mountpoint, "none") 184 && mountlist->el[pos].mountpoint[0] != '/') { 185 sprintf(tmp, " %s has a weird mountpoint.", device); 186 log_it(tmp); 187 strcat(flaws_str, tmp); 188 res++; 189 } 190 /* is format sensible? */ 191 if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) { 192 sprintf(tmp, " %s has unsupported format.", device); 193 log_it(tmp); 194 strcat(flaws_str, tmp); 195 res++; 196 } 197 amount_allocated += mountlist->el[pos].size / 1024; 198 prev_sp_no = cur_sp_no; 199 } 200 } 201 202 npos = pos = 0; 203 for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) { 204 sprintf(device, "%ss%d", drive, curr_part_no); 205 pos = find_device_in_mountlist(mountlist, device); 206 npos = 0; 207 for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) { 208 sprintf(device, "%ss%i%c", device, curr_part_no, cur_sp_no); 209 if (find_device_in_mountlist(mountlist, device) >= 0) 210 npos++; 211 } 212 if (((pos >= 0) || npos) && foundsome) { 213 sprintf(flaws_str + strlen(flaws_str), 214 " %s has both DD and PC-style partitions.", drive); 215 return ++res; // fatal error 216 } 217 218 sprintf(device, "%ss%d", drive, curr_part_no); 219 strcpy(mountpoint, mountlist->el[pos].mountpoint); 220 if (pos > 0 && !npos) { 221 /* gap in the partition list? */ 222 if (curr_part_no - prev_part_no > 1) { 223 if (prev_part_no == 0) { 224 sprintf(tmp, " Gap prior to %s.", device); 225 log_it(tmp); 226 strcat(flaws_str, tmp); 227 res++; 228 } else if (curr_part_no > 5 229 || (curr_part_no <= 4 && prev_part_no > 0)) { 230 sprintf(tmp, " Gap between %ss%d and %d.", drive, 231 prev_part_no, curr_part_no); 232 log_it(tmp); 233 strcat(flaws_str, tmp); 234 res++; 235 } 236 } 237 /* GPT allows more than 4 primary partitions */ 238 part_table_fmt = which_partition_format(drive); 239 /* no spare primary partitions to help accommodate the logical(s)? */ 240 if ((curr_part_no >= 5 && prev_part_no == 4) 241 && (strcmp(part_table_fmt, "MBR") == 0)) { 242 sprintf(tmp, " Partition %ss4 is occupied.", drive); 243 log_it(tmp); 244 strcat(flaws_str, tmp); 245 res++; 246 } 247 /* does partition /dev/adXsY exist more than once in the mountlist? */ 248 for (i = 0, mountpoint_copies = 0, device_copies = 0; 249 i < mountlist->entries; i++) { 250 if (!strcmp(device, mountlist->el[i].device)) { 251 device_copies++; 252 } 253 } 254 if (device_copies > 1) { 255 sprintf(tmp, " %s %s's.", number_to_text(device_copies), 256 device); 257 if (!strstr(flaws_str, tmp)) { 258 log_it(tmp); 259 strcat(flaws_str, tmp); 260 res++; 261 } 262 } 263 /* silly partition size? */ 264 if (mountlist->el[pos].size < 8192 265 && strcmp(mountlist->el[pos].mountpoint, "lvm")) { 266 sprintf(tmp, " %s is tiny!", device); 267 log_it(tmp); 268 strcat(flaws_str, tmp); 269 res++; 270 } 271 /* mountpoint should begin with / unless it is swap, lvm or raid */ 272 if (strcmp(mountlist->el[pos].mountpoint, "swap") 273 && strcmp(mountlist->el[pos].mountpoint, "lvm") 274 && strcmp(mountlist->el[pos].mountpoint, "raid") 275 && strcmp(mountlist->el[pos].mountpoint, "image") 276 && strcmp(mountlist->el[pos].mountpoint, "none") 277 && mountlist->el[pos].mountpoint[0] != '/') { 278 sprintf(tmp, " %s has a weird mountpoint.", device); 279 log_it(tmp); 280 strcat(flaws_str, tmp); 281 res++; 282 } 283 /* is format sensible? */ 284 if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) { 285 sprintf(tmp, " %s has unsupported format.", device); 286 log_it(tmp); 287 strcat(flaws_str, tmp); 288 res++; 289 } 290 } else { 291 /* Check subpartitions */ 292 for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) { 293 sprintf(device, "%ss%d%c", drive, curr_part_no, cur_sp_no); 294 pos = find_device_in_mountlist(mountlist, device); 295 if (pos < 0) { 296 continue; 297 } 298 strcpy(mountpoint, mountlist->el[pos].mountpoint); 299 /* is it too big? */ 300 if (curr_part_no > 'h') { 301 sprintf(tmp, " Can only have up to 'h' in disklabel."); 302 log_it(tmp); 303 strcat(flaws_str, tmp); 304 res++; 305 } 306 /* does partition /dev/adXsYZ exist more than once in the mountlist? */ 307 for (i = 0, mountpoint_copies = 0, device_copies = 0; 308 i < mountlist->entries; i++) { 309 if (!strcmp(device, mountlist->el[i].device)) { 310 device_copies++; 311 } 312 } 313 if (device_copies > 1) { 314 sprintf(tmp, " %s %s's.", 315 number_to_text(device_copies), device); 316 if (!strstr(flaws_str, tmp)) { 317 log_it(tmp); 318 strcat(flaws_str, tmp); 319 res++; 320 } 321 } 322 /* silly partition size? */ 323 if (mountlist->el[pos].size < 8192 324 && strcmp(mountlist->el[pos].mountpoint, "lvm")) { 325 sprintf(tmp, " %s is tiny!", device); 326 log_it(tmp); 327 strcat(flaws_str, tmp); 328 res++; 329 } 330 /* mountpoint should begin with / unless it is swap, lvm or raid */ 331 if (strcmp(mountlist->el[pos].mountpoint, "swap") 332 && strcmp(mountlist->el[pos].mountpoint, "lvm") 333 && strcmp(mountlist->el[pos].mountpoint, "raid") 334 && strcmp(mountlist->el[pos].mountpoint, "image") 335 && strcmp(mountlist->el[pos].mountpoint, "none") 336 && mountlist->el[pos].mountpoint[0] != '/') { 337 sprintf(tmp, " %s has a weird mountpoint.", device); 338 log_it(tmp); 339 strcat(flaws_str, tmp); 340 res++; 341 } 342 /* is format sensible? */ 343 if (!is_this_a_valid_disk_format 344 (mountlist->el[pos].format)) { 345 sprintf(tmp, " %s has unsupported format.", device); 346 log_it(tmp); 347 strcat(flaws_str, tmp); 348 res++; 349 } 350 amount_allocated += mountlist->el[pos].size / 1024; 351 prev_sp_no = cur_sp_no; 352 } 353 } 354 355 /* OK, continue with main loop */ 356 amount_allocated += mountlist->el[pos].size / 1024; 357 prev_part_no = curr_part_no; 358 } 359 360 /* Over-allocated the disk? Unallocated space on disk? */ 361 if (amount_allocated > physical_drive_size) // Used to be +1, but what if you're 1 MB too high? 362 { 363 sprintf(tmp, " %ld MB over-allocated on %s.", 364 amount_allocated - physical_drive_size, drive); 365 log_it(tmp); 366 strcat(flaws_str, tmp); 367 res++; 368 } else if (amount_allocated < physical_drive_size - 1) { /* NOT AN ERROR, JUST A WARNING :-) */ 369 sprintf(tmp, " %ld MB unallocated on %s.", 370 physical_drive_size - amount_allocated, drive); 371 log_it(tmp), strcat(flaws_str, tmp); 372 } 373 if (res) { 374 return (FALSE); 375 } else { 376 return (TRUE); 377 } 410 378 } 411 379 … … 414 382 { 415 383 416 /*@ int ************************************************************* */417 384 /*@ int ************************************************************* */ 385 int prev_part_no = 0; 418 386 int curr_part_no = 0; 419 387 int pos = 0; … … 423 391 int i = 0; 424 392 425 /*@ buffers ******************************************************** */426 393 /*@ buffers ******************************************************** */ 394 char *tmp; 427 395 char *device; 428 396 char *mountpoint; 429 397 430 /*@ long *********************************************************** */431 398 /*@ long *********************************************************** */ 399 long physical_drive_size = 0; 432 400 long amount_allocated = 0; 433 401 434 /*@ pointers ******************************************************* */402 /*@ pointers ******************************************************* */ 435 403 char *part_table_fmt; 436 404 437 /*@ initialize ******************************************************/ 438 assert_string_is_neither_NULL_nor_zerolength(drive); 439 assert(mountlist!=NULL); 440 assert(flaws_str!=NULL); 441 442 malloc_string(tmp); 443 malloc_string(device); 444 malloc_string(mountpoint); 445 flaws_str[0] = '\0'; 446 prev_part_no = 0; 447 tmp[0] = '\0'; 448 449 450 physical_drive_size = get_phys_size_of_drive (drive); 451 452 if (physical_drive_size < 0) 453 { 454 sprintf (tmp, " %s does not exist.", drive); 455 strcat (flaws_str, tmp); 456 res++; 457 log_msg(1, tmp); 458 goto endoffunc; 459 } 460 else 461 { 462 sprintf (tmp, "%s is %ld MB", drive, physical_drive_size); 463 log_it (tmp); 464 } 465 466 for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) 467 { 468 sprintf (device, "%s%d", drive, curr_part_no); 469 pos = find_device_in_mountlist (mountlist, device); 470 if (pos < 0) 471 { 472 continue; 473 } 474 if (physical_drive_size < 0) 475 { 476 sprintf(tmp, " %s refers to non-existent hardware.", device); 477 strcat (flaws_str, tmp); 478 res++; 479 continue; 480 } 481 strcpy (mountpoint, mountlist->el[pos].mountpoint); 482 /* gap in the partition list? */ 483 if (curr_part_no - prev_part_no > 1) 484 { 485 if (prev_part_no == 0) 486 { 487 sprintf (tmp, " Gap prior to %s.", device); 488 log_it (tmp); 489 strcat (flaws_str, tmp); 490 res++; 491 } 492 else if (curr_part_no > 5 493 || (curr_part_no <= 4 && prev_part_no > 0)) 494 { 495 sprintf (tmp, " Gap between %s%d and %d.", drive, prev_part_no, 496 curr_part_no); 497 log_it (tmp); 498 strcat (flaws_str, tmp); 499 res++; 500 } 501 } 502 /* GPT allows more than 4 primary partitions */ 503 part_table_fmt = which_partition_format(drive); 504 /* no spare primary partitions to help accommodate the logical(s)? */ 505 if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0)) 506 { 507 sprintf (tmp, " Partition %s4 is occupied.", drive); 508 log_it (tmp); 509 strcat (flaws_str, tmp); 510 res++; 511 } 512 /* does partition /dev/hdNX exist more than once in the mountlist? */ 513 for (i = 0, mountpoint_copies = 0, device_copies = 0; 514 i < mountlist->entries; i++) 515 { 516 if (!strcmp (device, mountlist->el[i].device)) 517 { 518 device_copies++; 519 } 520 } 521 if (device_copies > 1) 522 { 523 sprintf (tmp, " %s %s's.", number_to_text (device_copies), device); 524 if (!strstr (flaws_str, tmp)) 525 { 526 log_it (tmp); 527 strcat (flaws_str, tmp); 528 res++; 529 } 530 } 531 /* silly partition size? */ 532 if (mountlist->el[pos].size < 8192 533 && strcmp (mountlist->el[pos].mountpoint, "lvm")) 534 { 535 sprintf (tmp, " %s is tiny!", device); 536 log_it (tmp); 537 strcat (flaws_str, tmp); 538 res++; 539 } 540 /* mountpoint should begin with / unless it is swap, lvm or raid */ 541 if (strcmp (mountlist->el[pos].mountpoint, "swap") 542 && strcmp (mountlist->el[pos].mountpoint, "lvm") 543 && strcmp (mountlist->el[pos].mountpoint, "raid") 544 && strcmp (mountlist->el[pos].mountpoint, "image") 545 && mountlist->el[pos].mountpoint[0] != '/') 546 { 547 sprintf (tmp, " %s has a weird mountpoint.", device); 548 log_it (tmp); 549 strcat (flaws_str, tmp); 550 res++; 551 } 552 /* is format sensible? */ 553 if (!is_this_a_valid_disk_format (mountlist->el[pos].format)) 554 { 555 sprintf (tmp, " %s has unsupported format.", device); 556 log_it (tmp); 557 strcat (flaws_str, tmp); 558 res++; 559 } 560 /* OK, continue with main loop */ 561 amount_allocated += mountlist->el[pos].size / 1024; 562 prev_part_no = curr_part_no; 563 } 564 565 /* Over-allocated the disk? Unallocated space on disk? */ 566 if (amount_allocated > physical_drive_size + 1) 567 { 568 sprintf (tmp, " %ld MB over-allocated on %s.", 569 amount_allocated - physical_drive_size, drive); 570 log_it (tmp); 571 strcat (flaws_str, tmp); 572 res++; 573 } 574 else if (amount_allocated < physical_drive_size - 1) 575 { /* NOT AN ERROR, JUST A WARNING :-) */ 576 sprintf (tmp, " %ld MB unallocated on %s.", 577 physical_drive_size - amount_allocated, drive); 578 log_it (tmp), strcat (flaws_str, tmp); 579 } 580 581 endoffunc: 582 paranoid_free(tmp); 583 paranoid_free(device); 584 paranoid_free(mountpoint); 585 586 if (res) 587 { 588 return (FALSE); 589 } 590 else 591 { 592 return (TRUE); 593 } 405 /*@ initialize ***************************************************** */ 406 assert_string_is_neither_NULL_nor_zerolength(drive); 407 assert(mountlist != NULL); 408 assert(flaws_str != NULL); 409 410 malloc_string(tmp); 411 malloc_string(device); 412 malloc_string(mountpoint); 413 flaws_str[0] = '\0'; 414 prev_part_no = 0; 415 tmp[0] = '\0'; 416 417 418 physical_drive_size = get_phys_size_of_drive(drive); 419 420 if (physical_drive_size < 0) { 421 sprintf(tmp, " %s does not exist.", drive); 422 strcat(flaws_str, tmp); 423 res++; 424 log_msg(1, tmp); 425 goto endoffunc; 426 } else { 427 sprintf(tmp, "%s is %ld MB", drive, physical_drive_size); 428 log_it(tmp); 429 } 430 431 for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) { 432 sprintf(device, "%s%d", drive, curr_part_no); 433 pos = find_device_in_mountlist(mountlist, device); 434 if (pos < 0) { 435 continue; 436 } 437 if (physical_drive_size < 0) { 438 sprintf(tmp, " %s refers to non-existent hardware.", device); 439 strcat(flaws_str, tmp); 440 res++; 441 continue; 442 } 443 strcpy(mountpoint, mountlist->el[pos].mountpoint); 444 /* gap in the partition list? */ 445 if (curr_part_no - prev_part_no > 1) { 446 if (prev_part_no == 0) { 447 sprintf(tmp, " Gap prior to %s.", device); 448 log_it(tmp); 449 strcat(flaws_str, tmp); 450 res++; 451 } else if (curr_part_no > 5 452 || (curr_part_no <= 4 && prev_part_no > 0)) { 453 sprintf(tmp, " Gap between %s%d and %d.", drive, 454 prev_part_no, curr_part_no); 455 log_it(tmp); 456 strcat(flaws_str, tmp); 457 res++; 458 } 459 } 460 /* GPT allows more than 4 primary partitions */ 461 part_table_fmt = which_partition_format(drive); 462 /* no spare primary partitions to help accommodate the logical(s)? */ 463 if ((curr_part_no >= 5 && prev_part_no == 4) 464 && (strcmp(part_table_fmt, "MBR") == 0)) { 465 sprintf(tmp, " Partition %s4 is occupied.", drive); 466 log_it(tmp); 467 strcat(flaws_str, tmp); 468 res++; 469 } 470 /* does partition /dev/hdNX exist more than once in the mountlist? */ 471 for (i = 0, mountpoint_copies = 0, device_copies = 0; 472 i < mountlist->entries; i++) { 473 if (!strcmp(device, mountlist->el[i].device)) { 474 device_copies++; 475 } 476 } 477 if (device_copies > 1) { 478 sprintf(tmp, " %s %s's.", number_to_text(device_copies), 479 device); 480 if (!strstr(flaws_str, tmp)) { 481 log_it(tmp); 482 strcat(flaws_str, tmp); 483 res++; 484 } 485 } 486 /* silly partition size? */ 487 if (mountlist->el[pos].size < 8192 488 && strcmp(mountlist->el[pos].mountpoint, "lvm")) { 489 sprintf(tmp, " %s is tiny!", device); 490 log_it(tmp); 491 strcat(flaws_str, tmp); 492 res++; 493 } 494 /* mountpoint should begin with / unless it is swap, lvm or raid */ 495 if (strcmp(mountlist->el[pos].mountpoint, "swap") 496 && strcmp(mountlist->el[pos].mountpoint, "lvm") 497 && strcmp(mountlist->el[pos].mountpoint, "raid") 498 && strcmp(mountlist->el[pos].mountpoint, "image") 499 && mountlist->el[pos].mountpoint[0] != '/') { 500 sprintf(tmp, " %s has a weird mountpoint.", device); 501 log_it(tmp); 502 strcat(flaws_str, tmp); 503 res++; 504 } 505 /* is format sensible? */ 506 if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) { 507 sprintf(tmp, " %s has unsupported format.", device); 508 log_it(tmp); 509 strcat(flaws_str, tmp); 510 res++; 511 } 512 /* OK, continue with main loop */ 513 amount_allocated += mountlist->el[pos].size / 1024; 514 prev_part_no = curr_part_no; 515 } 516 517 /* Over-allocated the disk? Unallocated space on disk? */ 518 if (amount_allocated > physical_drive_size + 1) { 519 sprintf(tmp, " %ld MB over-allocated on %s.", 520 amount_allocated - physical_drive_size, drive); 521 log_it(tmp); 522 strcat(flaws_str, tmp); 523 res++; 524 } else if (amount_allocated < physical_drive_size - 1) { /* NOT AN ERROR, JUST A WARNING :-) */ 525 sprintf(tmp, " %ld MB unallocated on %s.", 526 physical_drive_size - amount_allocated, drive); 527 log_it(tmp), strcat(flaws_str, tmp); 528 } 529 530 endoffunc: 531 paranoid_free(tmp); 532 paranoid_free(device); 533 paranoid_free(mountpoint); 534 535 if (res) { 536 return (FALSE); 537 } else { 538 return (TRUE); 539 } 594 540 } 595 541 #endif … … 608 554 */ 609 555 int 610 evaluate_mountlist 611 612 { 613 614 /*@ buffer *********************************************************** */615 556 evaluate_mountlist(struct mountlist_itself *mountlist, char *flaws_str_A, 557 char *flaws_str_B, char *flaws_str_C) 558 { 559 560 /*@ buffer *********************************************************** */ 561 struct list_of_disks *drivelist; 616 562 char *tmp; 617 563 char *flaws_str; 618 564 619 /*@ int ************************************************************** */565 /*@ int ************************************************************** */ 620 566 int i = 0; 621 567 int res = 0; 622 568 623 /*@ initialize ********************************************************/ 624 625 drivelist = malloc(sizeof(struct list_of_disks)); 626 malloc_string(tmp); 627 malloc_string(flaws_str); 628 assert(mountlist!=NULL); 629 assert(flaws_str_A!=NULL); 630 assert(flaws_str_B!=NULL); 631 assert(flaws_str_C!=NULL); 632 flaws_str[0] = '\0'; 633 634 make_list_of_drives_in_mountlist (mountlist, drivelist); 635 636 log_it ("Evaluating mountlist..."); 637 638 for (i = 0; i < drivelist->entries; i++) 639 { 640 if (strstr (drivelist->el[i].device, DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE)) 641 { 642 sprintf (tmp, " Not evaluating %s (I don't know how yet)", 643 drivelist->el[i].device); 644 log_it (tmp); 645 tmp[0] = '\0'; 646 } 647 else 648 { 649 if (!evaluate_drive_within_mountlist 650 (mountlist, drivelist->el[i].device, tmp)) 651 { 652 res++; 653 } 654 } 655 strcat (flaws_str, tmp); 656 } 657 res += look_for_duplicate_mountpoints (mountlist, flaws_str); 569 /*@ initialize ******************************************************* */ 570 571 drivelist = malloc(sizeof(struct list_of_disks)); 572 malloc_string(tmp); 573 malloc_string(flaws_str); 574 assert(mountlist != NULL); 575 assert(flaws_str_A != NULL); 576 assert(flaws_str_B != NULL); 577 assert(flaws_str_C != NULL); 578 flaws_str[0] = '\0'; 579 580 make_list_of_drives_in_mountlist(mountlist, drivelist); 581 582 log_it("Evaluating mountlist..."); 583 584 for (i = 0; i < drivelist->entries; i++) { 585 if (strstr 586 (drivelist->el[i].device, 587 DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE)) { 588 sprintf(tmp, " Not evaluating %s (I don't know how yet)", 589 drivelist->el[i].device); 590 log_it(tmp); 591 tmp[0] = '\0'; 592 } else { 593 if (!evaluate_drive_within_mountlist 594 (mountlist, drivelist->el[i].device, tmp)) { 595 res++; 596 } 597 } 598 strcat(flaws_str, tmp); 599 } 600 res += look_for_duplicate_mountpoints(mountlist, flaws_str); 658 601 /* res+=look_for_weird_formats(mountlist,flaws_str); .. not necessary, now that we can check to see 659 602 which formarts are actually _supported_ by the kernel */ 660 661 662 603 /* log_it(flaws_str); */ 604 return (spread_flaws_across_three_lines 605 (flaws_str, flaws_str_A, flaws_str_B, flaws_str_C, res)); 663 606 } 664 607 … … 672 615 */ 673 616 int 674 find_device_in_mountlist (struct mountlist_itself *mountlist, char *device) 675 { 676 677 /*@ int ***************************************************************/ 678 int i = 0; 679 char*tmp; 680 char*flaws_str; 681 682 malloc_string(tmp); 683 malloc_string(flaws_str); 684 685 assert(mountlist!=NULL); 686 assert_string_is_neither_NULL_nor_zerolength(device); 687 for (i = 0; 688 i < mountlist->entries 689 && strcmp (mountlist->el[i].device, device) != 0; i++); 690 691 paranoid_free(tmp); 692 paranoid_free(flaws_str); 693 694 if (i == mountlist->entries) 695 { 696 return (-1); 697 } 698 else 699 { 700 return (i); 701 } 617 find_device_in_mountlist(struct mountlist_itself *mountlist, char *device) 618 { 619 620 /*@ int ************************************************************** */ 621 int i = 0; 622 char *tmp; 623 char *flaws_str; 624 625 malloc_string(tmp); 626 malloc_string(flaws_str); 627 628 assert(mountlist != NULL); 629 assert_string_is_neither_NULL_nor_zerolength(device); 630 for (i = 0; 631 i < mountlist->entries 632 && strcmp(mountlist->el[i].device, device) != 0; i++); 633 634 paranoid_free(tmp); 635 paranoid_free(flaws_str); 636 637 if (i == mountlist->entries) { 638 return (-1); 639 } else { 640 return (i); 641 } 702 642 } 703 643 … … 713 653 */ 714 654 int 715 look_for_duplicate_mountpoints 716 char *flaws_str)717 { 718 719 /*@ int ************************************************************* */720 655 look_for_duplicate_mountpoints(struct mountlist_itself *mountlist, 656 char *flaws_str) 657 { 658 659 /*@ int ************************************************************* */ 660 int res = 0; 721 661 int currline = 0; 722 662 int i = 0; … … 724 664 int last_copy = 0; 725 665 726 /*@ buffetr ********************************************************* */727 666 /*@ buffetr ********************************************************* */ 667 char *curr_mountpoint; 728 668 char *tmp; 729 669 730 malloc_string(curr_mountpoint); 731 malloc_string(tmp); 732 assert(mountlist!=NULL); 733 assert(flaws_str!=NULL); 734 for (currline = 0; currline < mountlist->entries; currline++) 735 { 736 strcpy (curr_mountpoint, mountlist->el[currline].mountpoint); 737 for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries; i++) 738 { 739 if (!strcmp (mountlist->el[i].mountpoint, curr_mountpoint) 740 && strcmp (mountlist->el[i].mountpoint, "lvm") 741 && strcmp (mountlist->el[i].mountpoint, "swap")) 742 { 743 last_copy = i; 744 copies++; 745 } 746 } 747 if (copies > 1 && last_copy == currline 748 && strcmp (curr_mountpoint, "raid")) 749 { 750 sprintf (tmp, " %s %s's.", number_to_text (copies), 751 curr_mountpoint); 752 strcat (flaws_str, tmp); 753 log_it (tmp); 754 res++; 755 } 756 } 757 paranoid_free(curr_mountpoint); 758 paranoid_free(tmp); 759 return (res); 670 malloc_string(curr_mountpoint); 671 malloc_string(tmp); 672 assert(mountlist != NULL); 673 assert(flaws_str != NULL); 674 for (currline = 0; currline < mountlist->entries; currline++) { 675 strcpy(curr_mountpoint, mountlist->el[currline].mountpoint); 676 for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries; 677 i++) { 678 if (!strcmp(mountlist->el[i].mountpoint, curr_mountpoint) 679 && strcmp(mountlist->el[i].mountpoint, "lvm") 680 && strcmp(mountlist->el[i].mountpoint, "swap")) { 681 last_copy = i; 682 copies++; 683 } 684 } 685 if (copies > 1 && last_copy == currline 686 && strcmp(curr_mountpoint, "raid")) { 687 sprintf(tmp, " %s %s's.", number_to_text(copies), 688 curr_mountpoint); 689 strcat(flaws_str, tmp); 690 log_it(tmp); 691 res++; 692 } 693 } 694 paranoid_free(curr_mountpoint); 695 paranoid_free(tmp); 696 return (res); 760 697 } 761 698 … … 768 705 */ 769 706 int 770 look_for_weird_formats 771 { 772 773 /*@ int ************************************************************* */774 int i= 0;707 look_for_weird_formats(struct mountlist_itself *mountlist, char *flaws_str) 708 { 709 710 /*@ int ************************************************************* */ 711 int i = 0; 775 712 int res = 0; 776 713 777 /*@ buffers ********************************************************* */778 714 /*@ buffers ********************************************************* */ 715 char *tmp; 779 716 char *format_sz; 780 717 781 malloc_string(tmp); 782 malloc_string(format_sz); 783 784 assert(mountlist!=NULL); 785 assert(flaws_str!=NULL); 786 787 for (i = 0; i < mountlist->entries; i++) 788 { 789 sprintf (format_sz, " %s ", mountlist->el[i].format); 790 if (!strstr 791 (SANE_FORMATS, format_sz) 792 && strcmp (mountlist->el[i].mountpoint, "image") != 0) 793 { 794 sprintf (tmp, " %s has unknown format.", mountlist->el[i].device); 795 log_it (tmp); 796 strcat (flaws_str, tmp); 797 res++; 798 } 799 else 800 if ((!strcmp (mountlist->el[i].format, "swap") 801 && strcmp (mountlist->el[i].mountpoint, "swap") && strcmp (mountlist->el[i].mountpoint, "none")) 802 || (strcmp (mountlist->el[i].format, "swap") 803 && !strcmp (mountlist->el[i].mountpoint, "swap") && !strcmp (mountlist->el[i].mountpoint, "none"))) 804 { 805 sprintf (tmp, " %s is half-swap.", mountlist->el[i].device); 806 log_it (tmp); 807 strcat (flaws_str, tmp); 808 res++; 809 } 810 } 811 paranoid_free(tmp); 812 paranoid_free(format_sz); 813 return (res); 718 malloc_string(tmp); 719 malloc_string(format_sz); 720 721 assert(mountlist != NULL); 722 assert(flaws_str != NULL); 723 724 for (i = 0; i < mountlist->entries; i++) { 725 sprintf(format_sz, " %s ", mountlist->el[i].format); 726 if (!strstr(SANE_FORMATS, format_sz) 727 && strcmp(mountlist->el[i].mountpoint, "image") != 0) { 728 sprintf(tmp, " %s has unknown format.", 729 mountlist->el[i].device); 730 log_it(tmp); 731 strcat(flaws_str, tmp); 732 res++; 733 } else if ((!strcmp(mountlist->el[i].format, "swap") 734 && strcmp(mountlist->el[i].mountpoint, "swap") 735 && strcmp(mountlist->el[i].mountpoint, "none")) 736 || (strcmp(mountlist->el[i].format, "swap") 737 && !strcmp(mountlist->el[i].mountpoint, "swap") 738 && !strcmp(mountlist->el[i].mountpoint, "none"))) { 739 sprintf(tmp, " %s is half-swap.", mountlist->el[i].device); 740 log_it(tmp); 741 strcat(flaws_str, tmp); 742 res++; 743 } 744 } 745 paranoid_free(tmp); 746 paranoid_free(format_sz); 747 return (res); 814 748 } 815 749 … … 823 757 */ 824 758 int 825 make_list_of_drives_in_mountlist (struct mountlist_itself *mountlist, 826 struct list_of_disks *drivelist) 827 { 828 829 /*@ int **************************************************************/ 830 int lino; 831 int noof_drives; 832 int j; 833 834 /*@ buffers **********************************************************/ 835 char *drive; 836 char *tmp; 837 838 long long size; 839 840 malloc_string(drive); 841 malloc_string(tmp); 842 assert(mountlist!=NULL); 843 assert(drivelist!=NULL); 844 log_it ("Making list of drives"); 845 for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) 846 { 847 848 strcpy (drive, mountlist->el[lino].device); 849 if (!strncmp (drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) 850 { 851 sprintf (tmp, 852 "Not putting %s in list of drives: it's a virtual drive", 853 drive); 854 log_msg (8, tmp); 855 continue; 856 } 857 858 size=mountlist->el[lino].size; 859 if ( size == 0 ) 860 { 861 sprintf (tmp, 862 "Not putting %s in list of drives: it has zero size (maybe an LVM volume)", 863 drive); 864 log_msg (8, tmp); 865 continue; 866 } 759 make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist, 760 struct list_of_disks *drivelist) 761 { 762 763 /*@ int ************************************************************* */ 764 int lino; 765 int noof_drives; 766 int j; 767 768 /*@ buffers ********************************************************* */ 769 char *drive; 770 char *tmp; 771 772 long long size; 773 774 malloc_string(drive); 775 malloc_string(tmp); 776 assert(mountlist != NULL); 777 assert(drivelist != NULL); 778 log_it("Making list of drives"); 779 for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) { 780 781 strcpy(drive, mountlist->el[lino].device); 782 if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) { 783 sprintf(tmp, 784 "Not putting %s in list of drives: it's a virtual drive", 785 drive); 786 log_msg(8, tmp); 787 continue; 788 } 789 790 size = mountlist->el[lino].size; 791 if (size == 0) { 792 sprintf(tmp, 793 "Not putting %s in list of drives: it has zero size (maybe an LVM volume)", 794 drive); 795 log_msg(8, tmp); 796 continue; 797 } 867 798 868 799 /* … … 877 808 */ 878 809 879 sprintf (tmp, 880 "Putting %s with size %lli in list of drives", 881 drive, size); 882 log_msg (8, tmp); 883 884 (void) truncate_to_drive_name (drive); 885 for (j = 0; j < noof_drives && strcmp (drivelist->el[j].device, drive) != 0; j++) 886 continue; 887 if (j == noof_drives) 888 { 889 strcpy (drivelist->el[noof_drives++].device, drive); 890 } 891 } 892 drivelist->entries = noof_drives; 893 log_msg (8, "Made list of drives"); 894 paranoid_free(drive); 895 paranoid_free(tmp); 896 897 return (noof_drives); 810 sprintf(tmp, 811 "Putting %s with size %lli in list of drives", 812 drive, size); 813 log_msg(8, tmp); 814 815 (void) truncate_to_drive_name(drive); 816 for (j = 0; 817 j < noof_drives 818 && strcmp(drivelist->el[j].device, drive) != 0; j++) 819 continue; 820 if (j == noof_drives) { 821 strcpy(drivelist->el[noof_drives++].device, drive); 822 } 823 } 824 drivelist->entries = noof_drives; 825 log_msg(8, "Made list of drives"); 826 paranoid_free(drive); 827 paranoid_free(tmp); 828 829 return (noof_drives); 898 830 } 899 831 … … 910 842 * @param raidlist The raidlist to examine. 911 843 */ 912 void 913 make_list_of_unallocated_raid_partitions (struct mountlist_itself 914 *output_list, 915 struct mountlist_itself *mountlist, 916 struct raidlist_itself *raidlist) 917 { 918 919 /*@ int **************************************************************/ 920 int items = 0; 844 void make_list_of_unallocated_raid_partitions(struct mountlist_itself 845 *output_list, 846 struct mountlist_itself 847 *mountlist, 848 struct raidlist_itself 849 *raidlist) 850 { 851 852 /*@ int ************************************************************* */ 853 int items = 0; 921 854 int i = 0; 922 855 int used_by = 0; 923 856 924 /*@ buffers **********************************************************/ 925 char *tmp; 926 927 malloc_string(tmp); 928 assert(output_list!=NULL); 929 assert(mountlist!=NULL); 930 assert(raidlist!=NULL); 931 log_it ("MLOURP -- starting"); 932 items = 0; 933 934 935 for (i = 0; i < mountlist->entries; i++) 936 { 937 if (strstr (mountlist->el[i].mountpoint, "raid")) 938 { 939 used_by = 940 which_raid_device_is_using_this_partition (raidlist, 941 mountlist->el[i]. 942 device); 943 if (used_by < 0) 944 { 945 memcpy ((void *) &output_list->el[items++], 946 (void *) &mountlist->el[i], 947 sizeof (struct mountlist_line)); 948 sprintf (tmp, 949 "%s is available; user may choose to add it to raid device", 950 output_list->el[items - 1].device); 951 log_it (tmp); 952 } 953 } 954 } 955 output_list->entries = items; 956 log_it ("MLUORP -- ending"); 957 paranoid_free(tmp); 857 /*@ buffers ********************************************************* */ 858 char *tmp; 859 860 malloc_string(tmp); 861 assert(output_list != NULL); 862 assert(mountlist != NULL); 863 assert(raidlist != NULL); 864 log_it("MLOURP -- starting"); 865 items = 0; 866 867 868 for (i = 0; i < mountlist->entries; i++) { 869 if (strstr(mountlist->el[i].mountpoint, "raid")) { 870 used_by = 871 which_raid_device_is_using_this_partition(raidlist, 872 mountlist->el[i]. 873 device); 874 if (used_by < 0) { 875 memcpy((void *) &output_list->el[items++], 876 (void *) &mountlist->el[i], 877 sizeof(struct mountlist_line)); 878 sprintf(tmp, 879 "%s is available; user may choose to add it to raid device", 880 output_list->el[items - 1].device); 881 log_it(tmp); 882 } 883 } 884 } 885 output_list->entries = items; 886 log_it("MLUORP -- ending"); 887 paranoid_free(tmp); 958 888 } 959 889 … … 969 899 */ 970 900 long long 971 size_of_specific_device_in_mountlist (struct mountlist_itself *mountlist, char *device) 972 { 973 /*@ int ***************************************************************/ 974 int i = 0; 975 976 977 assert(mountlist!=NULL); 978 assert_string_is_neither_NULL_nor_zerolength(device); 979 980 for (i = 0; 981 i < mountlist->entries && strcmp (mountlist->el[i].device, device); 982 i++); 983 if (i == mountlist->entries) 984 { 985 return (-1); 986 } 987 else 988 { 989 return (mountlist->el[i].size); 990 } 901 size_of_specific_device_in_mountlist(struct mountlist_itself *mountlist, 902 char *device) 903 { 904 /*@ int ************************************************************** */ 905 int i = 0; 906 907 908 assert(mountlist != NULL); 909 assert_string_is_neither_NULL_nor_zerolength(device); 910 911 for (i = 0; 912 i < mountlist->entries && strcmp(mountlist->el[i].device, device); 913 i++); 914 if (i == mountlist->entries) { 915 return (-1); 916 } else { 917 return (mountlist->el[i].size); 918 } 991 919 } 992 920 … … 1004 932 * @return 0 for success, 1 for failure. 1005 933 */ 1006 int 1007 load_mountlist( struct mountlist_itself *mountlist, char *fname) 1008 { 1009 FILE *fin; 1010 /* malloc ***/ 1011 char *incoming; 1012 char *siz; 1013 char *tmp; 1014 char*p; 1015 1016 int items; 1017 int j; 1018 1019 assert(mountlist!=NULL); 1020 assert_string_is_neither_NULL_nor_zerolength(fname); 1021 malloc_string(incoming); 1022 malloc_string(siz); 1023 malloc_string(tmp); 1024 if ( !( fin = fopen( fname, "r" ) ) ) 1025 { 1026 log_it( "Unable to open mountlist - '%s'", fname ); 1027 log_to_screen( "Cannot open mountlist" ); 1028 paranoid_free(incoming); 1029 paranoid_free(siz); 1030 paranoid_free(tmp); 1031 return( 1 ); 1032 } 1033 items = 0; 1034 (void) fgets( incoming, MAX_STR_LEN - 1, fin ); 1035 log_it( "Loading mountlist..." ); 1036 while( !feof( fin ) ) 1037 { 934 int load_mountlist(struct mountlist_itself *mountlist, char *fname) 935 { 936 FILE *fin; 937 /* malloc ** */ 938 char *incoming; 939 char *siz; 940 char *tmp; 941 char *p; 942 943 int items; 944 int j; 945 946 assert(mountlist != NULL); 947 assert_string_is_neither_NULL_nor_zerolength(fname); 948 malloc_string(incoming); 949 malloc_string(siz); 950 malloc_string(tmp); 951 if (!(fin = fopen(fname, "r"))) { 952 log_it("Unable to open mountlist - '%s'", fname); 953 log_to_screen("Cannot open mountlist"); 954 paranoid_free(incoming); 955 paranoid_free(siz); 956 paranoid_free(tmp); 957 return (1); 958 } 959 items = 0; 960 (void) fgets(incoming, MAX_STR_LEN - 1, fin); 961 log_it("Loading mountlist..."); 962 while (!feof(fin)) { 1038 963 #if linux 1039 sscanf( incoming, 1040 "%s %s %s %s %s", 1041 mountlist->el[items].device, 1042 mountlist->el[items].mountpoint, 1043 mountlist->el[items].format, 1044 siz, 1045 mountlist->el[items].label); 964 sscanf(incoming, 965 "%s %s %s %s %s", 966 mountlist->el[items].device, 967 mountlist->el[items].mountpoint, 968 mountlist->el[items].format, 969 siz, mountlist->el[items].label); 1046 970 #elif __FreeBSD__ 1047 sscanf (incoming, 1048 "%s %s %s %s", 1049 mountlist->el[items].device, 1050 mountlist->el[items].mountpoint, 1051 mountlist->el[items].format, 1052 siz); 1053 strcpy (mountlist->el[items].label, ""); 971 sscanf(incoming, 972 "%s %s %s %s", 973 mountlist->el[items].device, 974 mountlist->el[items].mountpoint, 975 mountlist->el[items].format, siz); 976 strcpy(mountlist->el[items].label, ""); 1054 977 #endif 1055 978 1056 if ( 1057 !strcmp(mountlist->el[items].device,"/proc") || 1058 !strcmp(mountlist->el[items].device, "proc") || 1059 !strcmp(mountlist->el[items].device,"/sys") || 1060 !strcmp(mountlist->el[items].device, "sys") || 1061 !strcmp(mountlist->el[items].device,"/devpts") || 1062 !strcmp(mountlist->el[items].device, "devpts") 1063 ) 1064 { 1065 log_msg(1, "Ignoring %s in mountlist - not loading that line :) ", mountlist->el[items].device); 1066 (void) fgets( incoming, MAX_STR_LEN - 1,fin ); 1067 continue; 1068 } 1069 mountlist->el[items].size = atoll( siz ); 1070 if ( mountlist->el[items].device[0] != '\0' && mountlist->el[items].device[0] != '#' ) 1071 { 1072 if ( items >= ARBITRARY_MAXIMUM ) 1073 { 1074 log_to_screen( "Too many lines in mountlist.. ABORTING" ); 1075 finish( 1 ); 1076 } 1077 for( j=0; j < items && strcmp( mountlist->el[j].device, mountlist->el[items].device ); j++); 1078 if (j < items) 1079 { 1080 strcat( mountlist->el[items].device, "_dup" ); 1081 sprintf( tmp, "Duplicate entry in mountlist - renaming to %s",mountlist->el[items].device ); 1082 log_it( tmp ); 1083 } 1084 strcpy(tmp, mountlist->el[items].device); 1085 if (strstr(tmp, "/dev/md/")) 1086 { 1087 log_it("format_device() --- Contracting %s", tmp); 1088 p = strrchr(tmp, '/'); 1089 if (p) { *p = *(p+1); *(p+1) = *(p+2); *(p+2) = *(p+3); } 1090 log_it("It was %s; it is now %s", mountlist->el[items].device, tmp); 1091 strcpy(mountlist->el[items].device, tmp); 1092 } 1093 1094 sprintf( tmp, 1095 "%s %s %s %lld %s", 1096 mountlist->el[items].device, 1097 mountlist->el[items].mountpoint, 1098 mountlist->el[items].format, 1099 mountlist->el[items].size, 1100 mountlist->el[items].label); 1101 1102 log_it( tmp ); 1103 items++; 1104 } 1105 (void) fgets( incoming, MAX_STR_LEN - 1,fin ); 1106 } 1107 paranoid_fclose( fin ); 1108 mountlist->entries = items; 1109 1110 log_it( "Mountlist loaded successfully." ); 1111 sprintf( tmp, "%d entries in mountlist", items ); 1112 log_it( tmp ); 1113 paranoid_free(incoming); 1114 paranoid_free(siz); 1115 paranoid_free(tmp); 1116 return( 0 ); 979 if (!strcmp(mountlist->el[items].device, "/proc") || 980 !strcmp(mountlist->el[items].device, "proc") || 981 !strcmp(mountlist->el[items].device, "/sys") || 982 !strcmp(mountlist->el[items].device, "sys") || 983 !strcmp(mountlist->el[items].device, "/devpts") || 984 !strcmp(mountlist->el[items].device, "devpts") 985 ) { 986 log_msg(1, 987 "Ignoring %s in mountlist - not loading that line :) ", 988 mountlist->el[items].device); 989 (void) fgets(incoming, MAX_STR_LEN - 1, fin); 990 continue; 991 } 992 mountlist->el[items].size = atoll(siz); 993 if (mountlist->el[items].device[0] != '\0' 994 && mountlist->el[items].device[0] != '#') { 995 if (items >= ARBITRARY_MAXIMUM) { 996 log_to_screen("Too many lines in mountlist.. ABORTING"); 997 finish(1); 998 } 999 for (j = 0; 1000 j < items 1001 && strcmp(mountlist->el[j].device, 1002 mountlist->el[items].device); j++); 1003 if (j < items) { 1004 strcat(mountlist->el[items].device, "_dup"); 1005 sprintf(tmp, 1006 "Duplicate entry in mountlist - renaming to %s", 1007 mountlist->el[items].device); 1008 log_it(tmp); 1009 } 1010 strcpy(tmp, mountlist->el[items].device); 1011 if (strstr(tmp, "/dev/md/")) { 1012 log_it("format_device() --- Contracting %s", tmp); 1013 p = strrchr(tmp, '/'); 1014 if (p) { 1015 *p = *(p + 1); 1016 *(p + 1) = *(p + 2); 1017 *(p + 2) = *(p + 3); 1018 } 1019 log_it("It was %s; it is now %s", 1020 mountlist->el[items].device, tmp); 1021 strcpy(mountlist->el[items].device, tmp); 1022 } 1023 1024 sprintf(tmp, 1025 "%s %s %s %lld %s", 1026 mountlist->el[items].device, 1027 mountlist->el[items].mountpoint, 1028 mountlist->el[items].format, 1029 mountlist->el[items].size, mountlist->el[items].label); 1030 1031 log_it(tmp); 1032 items++; 1033 } 1034 (void) fgets(incoming, MAX_STR_LEN - 1, fin); 1035 } 1036 paranoid_fclose(fin); 1037 mountlist->entries = items; 1038 1039 log_it("Mountlist loaded successfully."); 1040 sprintf(tmp, "%d entries in mountlist", items); 1041 log_it(tmp); 1042 paranoid_free(incoming); 1043 paranoid_free(siz); 1044 paranoid_free(tmp); 1045 return (0); 1117 1046 } 1118 1047 … … 1126 1055 * @see load_mountlist 1127 1056 */ 1128 int 1129 save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname) 1130 { 1131 FILE *fout; 1132 int i; 1133 1134 assert(mountlist!=NULL); 1135 assert_string_is_neither_NULL_nor_zerolength(fname); 1136 1137 log_it("save_mountlist_to_disk() --- saving to %s", fname); 1138 if (!(fout=fopen(fname,"w"))) 1139 { 1140 log_OS_error("WMTD - Cannot openout mountlist"); 1141 return(1); 1142 } 1143 for( i = 0; i < mountlist->entries; i++) 1144 { 1145 fprintf(fout, 1146 "%-15s %-15s %-15s %-15lld %-15s\n",mountlist->el[i].device, 1147 mountlist->el[i].mountpoint, 1148 mountlist->el[i].format, 1149 mountlist->el[i].size, 1150 mountlist->el[i].label); 1151 } 1152 paranoid_fclose(fout); 1153 return(0); 1057 int save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname) 1058 { 1059 FILE *fout; 1060 int i; 1061 1062 assert(mountlist != NULL); 1063 assert_string_is_neither_NULL_nor_zerolength(fname); 1064 1065 log_it("save_mountlist_to_disk() --- saving to %s", fname); 1066 if (!(fout = fopen(fname, "w"))) { 1067 log_OS_error("WMTD - Cannot openout mountlist"); 1068 return (1); 1069 } 1070 for (i = 0; i < mountlist->entries; i++) { 1071 fprintf(fout, 1072 "%-15s %-15s %-15s %-15lld %-15s\n", 1073 mountlist->el[i].device, mountlist->el[i].mountpoint, 1074 mountlist->el[i].format, mountlist->el[i].size, 1075 mountlist->el[i].label); 1076 } 1077 paranoid_fclose(fout); 1078 return (0); 1154 1079 } 1155 1080 … … 1161 1086 * @param mountlist The mountlist to sort. 1162 1087 */ 1163 void 1164 sort_mountlist_by_device( struct mountlist_itself *mountlist) 1165 { 1166 int diff; 1167 int lino = -999; 1168 1169 assert(mountlist!=NULL); 1170 1171 while (lino < mountlist->entries) 1172 { 1173 for(lino = 1; lino < mountlist->entries; lino++) 1174 { 1175 diff = strcmp_inc_numbers(mountlist->el[lino-1].device,mountlist->el[lino].device); 1176 if (diff > 0) 1177 { 1178 swap_mountlist_entries( mountlist, lino - 1, lino); 1179 break; 1180 } 1181 } 1182 } 1088 void sort_mountlist_by_device(struct mountlist_itself *mountlist) 1089 { 1090 int diff; 1091 int lino = -999; 1092 1093 assert(mountlist != NULL); 1094 1095 while (lino < mountlist->entries) { 1096 for (lino = 1; lino < mountlist->entries; lino++) { 1097 diff = 1098 strcmp_inc_numbers(mountlist->el[lino - 1].device, 1099 mountlist->el[lino].device); 1100 if (diff > 0) { 1101 swap_mountlist_entries(mountlist, lino - 1, lino); 1102 break; 1103 } 1104 } 1105 } 1183 1106 } 1184 1107 … … 1189 1112 * @param reverse If TRUE, then do a reverse sort. 1190 1113 */ 1191 void 1192 sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist, bool reverse)1193 { 1194 int diff; 1195 int lino = -999;1196 1197 assert(mountlist!=NULL); 1198 1199 while(lino < mountlist->entries) 1200 1201 for(lino = 1; lino < mountlist->entries; lino++) 1202 {1203 diff = strcmp( mountlist->el[lino-1].mountpoint,mountlist->el[lino].mountpoint);1204 if ((diff >0 && !reverse) || ((diff <0 && reverse)))1205 1206 1207 1208 1209 }1210 1114 void 1115 sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist, 1116 bool reverse) 1117 { 1118 int diff; 1119 int lino = -999; 1120 1121 assert(mountlist != NULL); 1122 1123 while (lino < mountlist->entries) { 1124 for (lino = 1; lino < mountlist->entries; lino++) { 1125 diff = 1126 strcmp(mountlist->el[lino - 1].mountpoint, 1127 mountlist->el[lino].mountpoint); 1128 if ((diff > 0 && !reverse) || ((diff < 0 && reverse))) { 1129 swap_mountlist_entries(mountlist, lino - 1, lino); 1130 break; 1131 } 1132 } 1133 } 1211 1134 } 1212 1135 … … 1218 1141 * @param b The index number of the second entry. 1219 1142 */ 1220 void 1143 void 1221 1144 swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b) 1222 1145 { 1223 /*@ mallocs ****/1224 1225 1226 1227 1228 1229 1230 assert(mountlist!=NULL);1231 assert(a>=0);1232 assert(b>=0);1233 1234 strcpy(device,mountlist->el[a].device);1235 strcpy(mountpoint,mountlist->el[a].mountpoint);1236 strcpy(format,mountlist->el[a].format);1237 1238 size=mountlist->el[a].size;1239 1240 strcpy(mountlist->el[a].device,mountlist->el[b].device);1241 strcpy(mountlist->el[a].mountpoint,mountlist->el[b].mountpoint);1242 strcpy(mountlist->el[a].format,mountlist->el[b].format);1243 1244 mountlist->el[a].size=mountlist->el[b].size;1245 1246 strcpy(mountlist->el[b].device,device);1247 strcpy(mountlist->el[b].mountpoint,mountpoint);1248 strcpy(mountlist->el[b].format,format);1249 1250 mountlist->el[b].size=size;1146 /*@ mallocs *** */ 1147 char device[64]; 1148 char mountpoint[256]; 1149 char format[64]; 1150 1151 long long size; 1152 1153 assert(mountlist != NULL); 1154 assert(a >= 0); 1155 assert(b >= 0); 1156 1157 strcpy(device, mountlist->el[a].device); 1158 strcpy(mountpoint, mountlist->el[a].mountpoint); 1159 strcpy(format, mountlist->el[a].format); 1160 1161 size = mountlist->el[a].size; 1162 1163 strcpy(mountlist->el[a].device, mountlist->el[b].device); 1164 strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint); 1165 strcpy(mountlist->el[a].format, mountlist->el[b].format); 1166 1167 mountlist->el[a].size = mountlist->el[b].size; 1168 1169 strcpy(mountlist->el[b].device, device); 1170 strcpy(mountlist->el[b].mountpoint, mountpoint); 1171 strcpy(mountlist->el[b].format, format); 1172 1173 mountlist->el[b].size = size; 1251 1174 } 1252 1175
Note:
See TracChangeset
for help on using the changeset viewer.