source: branches/3.2/mondo/src/common/mondostructures.h @ 3375

Last change on this file since 3375 was 3375, checked in by Bruno Cornec, 5 years ago
  • Create a new mr_boot_type function and boot_type mondo struct entry to manage BIOS/EFI/UEFI types
  • Property svn:keywords set to Id
File size: 20.4 KB
Line 
1/***************************************************************************
2                          mondostructures.h  -  description
3                             -------------------
4    begin                : Fri Apr 19 2002
5    copyright            : (C) 2002 by Stan Benoit
6    email                : troff@nakedsoul.org
7    cvsid                : $Id: mondostructures.h 3375 2015-04-27 14:25:30Z bruno $
8 ***************************************************************************/
9
10/***************************************************************************
11 *                                                                         *
12 *   This program is free software; you can redistribute it and/or modify  *
13 *   it under the terms of the GNU General Public License as published by  *
14 *   the Free Software Foundation; either version 2 of the License, or     *
15 *   (at your option) any later version.                                   *
16 *                                                                         *
17 ***************************************************************************/
18
19
20/**
21 * @file
22 * The header file defining all of Mondo's structures.
23 */
24
25
26/**
27 * Structure indicating one entry in the mountlist.
28 * There is one mountlist_line for each device we're keeping track of in the mountlist.
29 */
30struct mountlist_line {
31  /**
32   * The name of the device (/dev entry) for this mountlist line. Guaranteed to be unique.
33   */
34    char device[64];
35
36  /**
37   * The mountpoint for this mountlist line. Should be unique.
38   * This can be "raid", for a RAID subdisk, or "lvm", for an LVM PV.
39   */
40    char mountpoint[256];
41
42  /**
43   * The filesystem type of this entry. Examples: ext2, ext3, reiserfs, xfs, swap.
44   * Also, this can be "raid", for a RAID subdisk, or "lvm", for an LVM PV.
45   */
46    char format[64];
47
48  /**
49   * The size in kilobytes of this device. 0 or -1 indicates LVM.
50   */
51    long long size;
52
53  /**
54   * For ext2 and ext3, this is the filesystem label or uuid (if there is one). If not, this should be "".
55   */
56    char label[256];
57
58};
59
60/**
61 * The mountlist structure.
62 * This is used to keep track of a list of all the devices/partitions/formats/sizes/labels in the
63 * system, so we can recreate them in a nuke restore.
64 */
65struct mountlist_itself {
66  /**
67   * Number of entries in the mountlist.
68   */
69    int entries;
70
71  /**
72   * The list of entries, all @p entries of them.
73   */
74    struct mountlist_line el[MAX_MOUNTLIST_ENTRIES];
75};
76
77/**
78 * A structure which holds references to elements of the mountlist.
79 * This is used in resize_drive_proportionately_to_fit_new_drives() to
80 * ensure accurate resizing.
81 */
82struct mountlist_reference {
83  /**
84   * The number of entries in the list of mountlist references.
85   */
86    int entries;
87
88  /**
89   * The array of mountlist_line, allocated on demand.
90   */
91    struct mountlist_line **el;
92};
93
94/**
95 * A line in @p additional_raid_variables.
96 */
97struct raid_var_line {
98  /**
99   * The label for this RAID variable.
100   */
101    char label[64];
102
103  /**
104   * The value for this RAID variable.
105   */
106    char value[64];
107};
108
109/**
110 * The additional RAID variables structure.
111 * This is used to store a list of additional variables to be put in the raidtab,
112 * to allow users to use (new) features of RAID which Mondo doesn't (yet) support directly.
113 * Each @p raid_device_record has one.
114 */
115struct additional_raid_variables {
116  /**
117   * The number of entries in the list.
118   */
119    int entries;
120
121  /**
122   * The list of entries, all @p entries of them.
123   */
124    struct raid_var_line el[MAXIMUM_ADDITIONAL_RAID_VARS];
125};
126
127/**
128 * One disk in a @p list_of_disks.
129 */
130struct s_disk {
131#ifdef __FreeBSD__
132    /**
133     * The name of this disk. If blank it will eventually get filled in automatically.
134     */
135    char name[64];
136#endif
137  /**
138   * The device this entry describes.
139   */
140    char device[64];
141
142  /**
143   * Index number of this entry in the whole disklist.
144   */
145    int index;
146
147  /**
148   * Type of disk.
149   */
150    char type;  // ' ' = data (default), S = spare, F = faulty
151
152};
153
154/**
155 * A list of @p s_disk. Every @p raid_device_record has four.
156 */
157struct list_of_disks {
158  /**
159   * The number of entries in the disklist.
160   */
161    int entries;
162
163  /**
164   * The entries themselves, all @p entries of them.
165   */
166    struct s_disk el[MAXIMUM_DISKS_PER_RAID_DEV];
167};
168
169/**
170 * A type of media we're backing up to.
171 */
172typedef enum { none = 0,        ///< No type has been set yet.
173    iso,                        ///< Back up to ISO images.
174    cdr,                        ///< Back up to recordable CDs (do not erase them).
175    cdrw,                       ///< Back up to CD-RWs and blank them first.
176    dvd,                        ///< Back up to DVD+R[W] or DVD-R[W] disks.
177    cdstream,                   ///< Back up to recordable CDs but treat them like a tape streamer.
178    netfs,                      ///< Back up to an NETFS mount on the local subnet.
179    tape,                       ///< Back up to tapes.
180    usb,                        ///< Back up to USB devices.
181    udev                        ///< Back up to another unsupported device; just send a stream of bytes.
182} t_bkptype;
183
184/**
185 * A type of boot
186 */
187typedef enum { 
188    BIOS,                       /// System uses Legacy Boot mode (aka BIOS)
189    EFI,                        /// System uses EFI Boot mode
190    UEFI,                       /// System uses UEFI Boot mode
191} t_boot;
192
193/**
194 * A type of file in the catalog of recent archives.
195 */
196typedef enum { 
197    other,                      ///< Some other kind of file.
198    fileset,                    ///< An afioball (fileset), optionally compressed.
199    biggieslice                 ///< A slice of a biggiefile, optionally compressed.
200} t_archtype;
201
202/**
203 * A type of file in the catalog of recent archives.
204 */
205typedef enum {
206    nuke = 0,                   /// Nuke mode
207    interactive,                    /// Interactive mode
208    compare,                    /// Compare mode
209    mbr,                        /// MBR mode
210    isoonly,                    /// ISO mode
211    isonuke,                    /// ISO+Nuke mode
212} t_restore_mode;
213
214
215#ifdef __FreeBSD__
216
217struct vinum_subdisk {
218    char which_device[64];
219};
220
221struct vinum_plex {
222    int raidlevel;
223    int stripesize;
224    int subdisks;
225    struct vinum_subdisk sd[MAXIMUM_RAID_DEVS];
226};
227
228struct vinum_volume {
229    char volname[64];
230    int plexes;
231    struct vinum_plex plex[9];
232};
233
234struct raidlist_itself {
235    int entries;
236    struct list_of_disks spares;
237    struct list_of_disks disks;
238    struct vinum_volume el[MAXIMUM_RAID_DEVS];
239};
240
241#else
242
243        /**
244         * A RAID device in the raidlist.
245         */
246struct raid_device_record {
247      /**
248       * The name of the RAID device (e.g. /dev/md0).
249       */
250    char raid_device[64];
251
252      /**
253       * The RAID level (-1 to 5) we're using.
254       */
255    int raid_level;
256
257      /**
258       * Whether the disk has a persistent superblock.
259       */
260    int persistent_superblock;
261
262      /**
263       * The chunk size of this RAID device.
264       */
265    int chunk_size;
266
267      /**
268       * The parity algorithm of this RAID device. (RAID5 only)
269       */
270    int parity; // 0=left-asymmetric, 1=right-asymmetric, 2=left-symmetric, 3=right-symmetric
271
272      /**
273       * A list of the disks to use for storing data.
274       */
275    struct list_of_disks data_disks;
276
277      /**
278       * A list of the disks to use as "hot spares" in case one dies.
279       */
280    struct list_of_disks spare_disks;
281
282      /**
283       * A list of the disks to use for storing parity information.
284       */
285    struct list_of_disks parity_disks;
286
287      /**
288       * A list of the disks in this RAID device that have failed\. Rare.
289       */
290    struct list_of_disks failed_disks;
291
292      /**
293       * The additional RAID variables for this device.
294       */
295    struct additional_raid_variables additional_vars;
296
297      /**
298       * Resync progress for this device.
299       */
300    int progress;
301};
302
303        /**
304         * The list of RAID devices.
305         * This is intended to be used along with the mountlist, and it can be
306         * directly loaded from/saved to raidtab format.
307         */
308struct raidlist_itself {
309      /**
310       * The number of entries in the list.
311       */
312    int entries;
313
314      /**
315       * The RAID devices in the raidlist, all @p entries of them.
316       */
317    struct raid_device_record el[MAXIMUM_RAID_DEVS];
318};
319
320#endif
321
322/**
323 * The backup information structure.
324 *
325 * This is the central structure to all the activity going on inside Mondo.
326 * It is passed to almost every function that is not just a helper, even those
327 * which only use one variable of it, because it is useful keeping all the information
328 * together in one place. The usage of particular fields in the bkpinfo is marked in
329 * function documentation, but it is best to fill out as many fields as apply, because
330 * that function may in turn pass the bkpinfo to other functions which use other fields.
331 *
332 * To fill out the bkpinfo first call reset_bkpinfo() and pre_param_configuration(). Then set
333 * the backup-specific parameters (see mondo/mondoarchive/mondo-cli.c-\>process_switches for
334 * an example). After that, you should call post_param_configuration() to set some final
335 * parameters based on those you have already set. Failure to do the last step will result in
336 * extremely strange and hard-to-track errors in chop_filelist(), since optimal_set_size is 0.
337 */
338struct s_bkpinfo {
339  /**
340   * The device we're backing up to.
341   * If backup_media_type is @b cdr, @b cdrw, or @b cdstream, this should be the SCSI node (e.g. 0,1,0).
342   * If backup_media_type is @b dvd, @b tape, @b usb or @b udev, this should be a /dev entry.
343   * If backup_media_type is anything else, this should be blank.
344   */
345    char media_device[MAX_STR_LEN / 4];
346
347  /**
348   * A field containing the sizes of the media in our backup set, in MB.
349   * If the size should be autodetected, make it -1 (preferable) or 0.
350   */
351    long media_size;
352
353  /**
354   * The boot loader that is installed. Available choices are:
355   * - 'G' for GRUB
356   * - 'L' for LILO
357   * - 'E' for ELILO
358   * - (FreeBSD only) 'B' for boot0
359   * - (FreeBSD only) 'D' for dangerously dedicated
360   * - 'R' for Raw
361   * - 'U' for Unknown or None
362   *
363   * The function which_boot_loader() can help you set this.
364   */
365    char boot_loader;
366
367  /**
368   * The boot device on which @p boot_loader is installed.
369   * This is a bit difficult to autodetect; you may want
370   * to take truncate_to_drive_name() of where_is_root_mounted().
371   */
372    char *boot_device;
373
374  /**
375   * The compression program to use. Currently supported
376   * choices are lzop, bzip2, gzip or lzma. This is ignored if
377   * compression_level is 0.
378   */
379    char zip_exe[MAX_STR_LEN / 4];
380
381  /**
382   * The extension your compression program uses. lzop uses lzo, bzip uses
383   * bz2, gzip uses gz, etc. Do not include the dot.
384   */
385    char zip_suffix[MAX_STR_LEN / 4];
386
387  /**
388   * Devices to back up as biggiefiles.
389   *
390   * This is useful for backing up NTFS partitions.
391   * @c ntfsclone is used to back up only the used sectors, so the space tradeoff is not bad.
392   * However, several caveats apply to such a partition:
393   * - It must not be mounted during the backup
394   * - It must be in a format that ntfsclone knows how to handle, i.e. NTFS
395   * - It cannot be verified during the verify or compare phase
396   * - It may not be resized or selectively restored at restore-time (all or nothing)
397   *
398   * This is a useful feature, but use at your own risk.
399   */
400    char image_devs[MAX_STR_LEN / 4];
401
402  /**
403   * The compression level (1-9) to use. 0 disables compression.
404   */
405    int compression_level;
406
407  /**
408   * If TRUE, then use @c lzop to compress data.
409   * This is used mainly in estimates. The backup/restore may or may
410   * not work if you do not set this. You should also set @p zip_exe
411   * and @p zip_suffix.
412   */
413    bool use_lzo;
414
415  /**
416   * If TRUE, then use @c gzip to compress data.
417   * This is used mainly in estimates. The backup/restore may or may
418   * not work if you do not set this. You should also set @p zip_exe
419   * and @p zip_suffix.
420   */
421    bool use_gzip;
422
423/**
424   * If TRUE, then use @c lzma to compress data.
425   * This is used mainly in estimates. The backup/restore may or may
426   * not work if you do not set this. You should also set @p zip_exe
427   * and @p zip_suffix.
428   */
429    bool use_lzma;
430
431  /**
432   * If TRUE, then we should verify a backup.
433   */
434    bool verify_data;
435
436  /**
437   * If TRUE, then we should back up some data.
438   */
439    bool backup_data;
440
441  /**
442   * If TRUE, then we should restore some data.
443   */
444    bool restore_data;
445
446
447  /**
448    * If TRUE, then we should backup/restore using star, not afio
449   */
450    bool use_star;
451
452
453  /**
454   * Size of internal block reads/writes
455   */
456    long internal_tape_block_size;
457
458  /**
459   * If TRUE, we're making a CD that will autonuke without confirmation when booted.
460   */
461    bool disaster_recovery;
462
463  /**
464   * The directory we're backing up to.
465   * If backup_media_type is @b iso, then this is that directory.
466   * If backup_media_type is @b netfs, then this is the directory where the share is mounted.
467   * If backup_media_type is anything else, this is ignored.
468   */
469    char isodir[MAX_STR_LEN / 4];
470
471/**
472   * The prefix to put in front of media number
473   * If backup_media_type is @b iso, then this is the prefix for the filename
474   * If backup_media_type is anything else, this is ignored.
475   */
476    char prefix[MAX_STR_LEN / 4];
477
478  /**
479   * The scratch directory to use.
480   * This is the "stage" that the CD image is made directly from.
481   * As such, it needs to be at least as large as the largest CD/DVD/ISO.
482   */
483    char scratchdir[MAX_STR_LEN / 4];
484
485  /**
486   * The temp directory to use.
487   * This is where filesets are stored by the archival threads before
488   * the main thread moves them to the scratchdir. You don't need a lot
489   * of space here.
490   */
491    char tmpdir[MAX_STR_LEN / 4];
492
493  /**
494   * The optimal size for each fileset. This is set automatically in
495   * post_param_configuration() based on your @p backup_media_type; you
496   * needn't set it yourself.
497   */
498    long optimal_set_size;
499
500  /**
501   * The type of media we're backing up to.
502   */
503    t_bkptype backup_media_type;
504
505  /**
506   * Whether we should use a premade filelist or generate our own.
507   * If TRUE, then we generate our own filelist from the directories in @p include_paths.
508   * If FALSE, then we use the filelist whose name is specified in @p include_paths.
509   */
510    bool make_filelist;
511
512  /**
513   * Directories to back up, or (if !make_filelist) the filelist to use.
514   * In the former case, multiple directories should be separated by spaces.
515   * If you do nothing, "/" will be used.
516   */
517    char *include_paths;
518
519  /**
520   * Directories to NOT back up. Ignored if make_filelist == FALSE.
521   * Multiple directories should be separated by spaces. /tmp, /proc,
522   * the scratchdir, and the tempdir are automatically excluded.
523   */
524    char *exclude_paths;
525
526  /**
527   * Devices to NOT back up.
528   * Multiple devices should be separated by spaces.
529   */
530    char *exclude_devs;
531
532  /**
533   * The path to restore files relative to during a restore.
534   * This is useful if you want to extract the files (to test, for example)
535   * without overwriting the old ones. Ignored during a backup.
536   */
537    char restore_path[MAX_STR_LEN];
538
539  /**
540   * A command to call BEFORE making an ISO image.
541   */
542    char call_before_iso[MAX_STR_LEN];
543
544  /**
545   * A command to call to make an ISO image.
546   */
547    char call_make_iso[MAX_STR_LEN];
548
549  /**
550   * A command to call to burn the ISO image.
551   */
552    char call_burn_iso[MAX_STR_LEN];
553
554  /**
555   * A command to call AFTER making an ISO image.
556   */
557    char call_after_iso[MAX_STR_LEN];
558
559  /**
560   * Path to the user's kernel
561   */
562    char kernel_path[MAX_STR_LEN];
563
564  /**
565   * The NETFS mount to back up to/restore from.
566   * If backup_media_type is not @b netfs, this is ignored.
567   * It must contain a colon, and the server's address should be in dotted-decimal IP
568   * address form. (Domain names will be resolved in post_param_configuration().)
569   */
570    char *netfs_mount;
571
572  /**
573   * The directory, relative to the root of @p netfs_mount, to put
574   * the backups in.
575   */
576    char *netfs_remote_dir;
577
578  /**
579   * The potential user to use for NETFS backup
580   */
581    char *netfs_user;
582
583  /**
584   * The potential subdirectory under which are located ISO images on HDD (restore mode only)
585   */
586    char *subdir;
587
588  /**
589   * The protocol to use for Network backup (NFS, SSHFS, ...)
590   */
591    char *netfs_proto;
592
593  /**
594   * A tarball containing a program called "usr/bin/post-nuke" that will be run
595   * after nuking the system. If "", do not use a post-nuke tarball.
596   */
597    char postnuke_tarball[MAX_STR_LEN];
598
599  /**
600   * If TRUE, then pass cdrecord the argument "blank=fast" to wipe the CDs before
601   * writing to them. This has no effect for DVDs.
602   */
603    bool wipe_media_first;
604
605// patch by Herman Kuster
606  /**
607   * The differential level of this backup. Currently only 0 (full backup) and 1
608   * (files changed since last full backup) are supported.
609   */
610    int differential;
611// end patch
612
613  /**
614   * If TRUE, then don't eject media when backing up or restoring.
615   */
616    bool please_dont_eject;
617
618  /**
619   * The speed of the CD-R[W] drive.
620   */
621    int cdrw_speed;
622
623  /**
624   * If TRUE, then cdrecord will be passed some flags to help compensate for PCs
625   * with eccentric CD-ROM drives. If it has BurnProof technology, or is in a laptop,
626   * it probably falls into this category.
627   */
628    bool manual_cd_tray;
629
630  /**
631   * If TRUE, do not make the first CD bootable. This is dangerous but it saves a minute
632   * or so. It is useful in testing. Use with care.
633   */
634    bool nonbootable_backup;
635
636  /**
637   * If TRUE, make the bootable CD use LILO/ELILO. If FALSE, use isolinux (the default).
638   */
639    bool make_cd_use_lilo;
640
641  /**
642   * If TRUE, make the the tape bootable. If FALSE, normal tape, the default
643   */
644    bool use_obdr;
645
646  /**
647   * Nature of the restore
648   */
649    t_restore_mode restore_mode;
650
651  /**
652   * The type of boot of our ssytem
653   */
654    t_boot boot_type;
655
656};
657
658
659
660/**
661 * A node in a directory structure.
662 * Its internals are managed by load_filelist() et al; you only need to keep track of the top node.
663 * @bug My understanding of this structure is horrendously incomplete. Could you please fill in the details?
664 */
665struct s_node {
666  /**
667   * The character this node contains.
668   */
669    char ch;
670
671  /**
672   * The node to the right of this one.
673   */
674    struct s_node *right;
675
676  /**
677   * The node below this one.
678   */
679    struct s_node *down;
680
681  /**
682   * If TRUE, then this node is selected (for restore, for example).
683   */
684    bool selected;
685
686  /**
687   * If TRUE, then we want to see the directories below this one.
688   */
689    bool expanded;
690};
691
692
693
694/**
695 * Information about one file.
696 * This is used as the "zeroth slice" of a biggiefile to be able to recreate
697 * its name, mode, owner, group, mtime, atime, and to be able to verify it in Compare Mode.
698 */
699struct s_filename_and_lstat_info {
700        /**
701     * The filename of the file this structure is describing.
702     */
703    char filename[MAX_STR_LEN];
704
705        /**
706     * The MD5 checksum (32 hex digits) of this file.
707     */
708    char checksum[64];
709
710        /**
711     * Unused; kept for backwards compatibility.
712     */
713    char for_backward_compatibility;
714
715        /**
716     * The stat buffer for this file.
717     * Generated with a call to <tt>lstat(&(struc->properties))</tt> where @p struc
718     * is the @p s_filename_and_lstat_info.
719     */
720    struct stat properties;
721    bool use_ntfsprog;
722};
723
724
725/**
726 * A file with associated severity if it differed in a verify or compare.
727 */
728struct s_filelist_entry {
729        /**
730     * The name of the file.
731     */
732    char filename[MAX_STR_LEN];
733        /**
734     * The severity if the file has changed between the backup and live filesystem.
735     * This is on a scale from 1 to 3, 3 being the most important. File patterns which cause
736     * a severity of 1 are:
737     * - /etc/adjtime
738     * - /etc/mtab
739     * - /var/lib/slocate
740     * - /var/lock
741     * - /var/log
742     * - /var/spool (except /var/spool/mail)
743     * - /var/run
744     * - *~
745     * - *.log
746     * - *cache*
747     * - other temporary or unimportant files
748     *
749     * File patterns which cause a severity of 2 are:
750     * - /var (except /var/lock, /var/log, /var/run, /var/spool)
751     * - /home
752     * - /root/.*
753     * - /var/lib (except /var/lib/slocate, /var/lib/rpm)
754     * - /var/spool/mail
755     *
756     * File patterns which cause a severity of 3 are:
757     * - /etc (except /etc/adjtime, /etc/mtab)
758     * - /root (except /root/.*)
759     * - /usr
760     * - /var/lib/rpm
761     * - Anything else not matched explicitly
762     *
763     * @see severity_of_difference
764     */
765    int severity;
766};
767
768
769/**
770 * A list of @c s_filelist_entry.
771 */
772struct s_filelist {
773        /**
774     * The number of entries in the list.
775     */
776    int entries;
777
778        /**
779     * The entries themselves, all @p entries of them.
780     */
781    struct s_filelist_entry el[ARBITRARY_MAXIMUM];
782};
783
784
785/**
786 * An entry in the tape catalog.
787 */
788struct s_tapecat_entry {
789        /**
790     * The type of archive it is (afioball, slice, or something else).
791     */
792    t_archtype type;
793
794        /**
795     * The filelist number or biggiefile (not slice!) number.
796     */
797    int number;
798
799        /**
800     * The slice number if it's a biggiefile.
801     */
802    long aux;
803
804        /**
805     * The tape position at the point this entry was added.
806     */
807    long long tape_posK;
808
809        /**
810     * The filename of the file cataloged here.
811     */
812    char fname[MAX_TAPECAT_FNAME_LEN + 1];
813};
814
815
816/**
817 * A tape catalog, made of a list of @p s_tapecat_entry.
818 */
819struct s_tapecatalog {
820        /**
821     * The number of entries in the tape catalog.
822     */
823    int entries;
824
825        /**
826     * The entries themselves, all @p entries of them.
827     */
828    struct s_tapecat_entry el[MAX_TAPECATALOG_ENTRIES];
829};
Note: See TracBrowser for help on using the repository browser.