Changeset 2007

Timestamp:

08/10/08 19:48:51 (5 months ago)

Author:

bruno

Message:

Patch and comment from Michael Shapiro:

I wrote a function called get_dsf_mount_list() that, given a whole disk device special file (dsf), it will return a list of all of the mounted file systems residing on that disk in the
variable included_dsf_list, and a list of all of the mounted file systems that are not residing on that disk in the variable excluded_dsf_list:

static int
get_dsf_mount_list (char *dsf,

char **included_dsf_list,
char **excluded_dsf_list);

The function does the following:

- Verifies that the dsf exists and has a partition table on it.

- Creates a linked list of all of the locally mounted file systems (i.e. the mount points that start with "/dev/") using a new structure called mounted_fs_struct. Each structure contains the name of the
device, the device's mount point, and a variable called check that will be set to 1 if the mount point resides on the disk and a 0 if the mount point does not reside on the disk.

- Loops through each partition on the disk and:

-- If the partition is swap, it ignores it.

-- If the partition is mounted (e.g. /dev/sda1 is mounted on /boot, /dev/sda2 is mounted on /usr, etc.), it finds its entry on the linked list and sets check == 1.

-- If the partition is part of a Volume Group that has Logical Volumes mounted, it finds its entry on the linked list for each mounted Logical Volume in that Volume Group and sets check == 1. Note that if
the Volume Group contains more than one disk, it will still add the entry even if the Logical Volume's extents are not on, or only partially on, the dsf that was passed in to the function. For example,
Volume Group VolGroup?00 contains the disks /dev/sda1 and /dev/sdb1, and the Logical Volumes LogVol?01, which is mounted on /var and has all of its extents on /dev/sda1, and LogVol?02, which is mounted as /usr
and has all of its extents on /dev/sdb1. If you pass /dev/sda into the function, both /var and /usr will be archived even though /usr is actually on/dev/sdb.

-- If the partition is part of a Volume Group that has Logical Volumes used in a mounted software raid device, it finds its entry on the linked list and sets check == 1.

-- If the partition is part of a mounted software raid device, it finds its entry on the linked list and sets check == 1.

- At the end of the function, it walks through the linked list and, for every entry where check == 1, catenates the mount point to included_dsf_list. For every entry where check == 0, it catenates the mount
point to excluded_dsf_list.

In process_switches():

- I added code to the section that processes the -I option and, if a whole disk device special file is passed in, it calls get_dsf_mount_list(), sets bkpinfo->include_paths == "/", and catenates the
contents of excluded_dsf_list to bkpinfo->exclude_paths. If a whole disk device special file is not passed in, it processes the -I option normally.

- I added code to the section that processes the -E option and, if a whole disk device special file is passed in, it calls get_dsf_mount_list() and catenates the contents of included_dsf_list to
bkpinfo->exclude_paths. If a whole disk device special file is not passed in, it processes the -E option normally.

Files:

• branches/2.2.7/mondo/src/common/libmondo-cli.c (modified) (5 diffs)

branches/2.2.7/mondo/src/common/libmondo-cli.c

@@ -191 +191 @@
-extern pid_t g_main_pid;
-extern char *resolve_softlinks_to_get_to_actual_device_file(char *);
+
+/* Stuff that handles the -I and -E option when a whole disk DSF is used */
+typedef struct mounted_fs_struct {
+    char device[MAX_STR_LEN];       /* The name of the device */
+    char mount_point[MAX_STR_LEN];  /* The devices mount point */
+    unsigned char check;            /* 1 == included on DSF */
+    struct mounted_fs_struct *next;
+} MOUNTED_FS_STRUCT;
+static MOUNTED_FS_STRUCT *DSF_Head = NULL;      /* Points to the first entry of mounted_fs_struct list */
+static MOUNTED_FS_STRUCT *DSF_Tail = NULL;      /* Points to the last entry of mounted_fs_struct list */
+static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr);
+static void free_mounted_fs_list (void);
+static int get_dsf_mount_list (const char *dsf, char **included_dsf_list, char **excluded_dsf_list);
+static int create_list_of_non_NFS_mounted_file_systems (void);
+static MOUNTED_FS_STRUCT *find_mount_point_in_list (char *mount_point);
+static MOUNTED_FS_STRUCT *find_device_in_list (char *device);
-
-/* Do we use extended attributes and acl ? 
@@ -310 +326 @@
-}
-
+/**
+ * Frees the memory for all of the structures on the linked list of 
+ * all of the non-NFS mounted file systems.
+ */
+static void free_mounted_fs_list (void) {
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+    MOUNTED_FS_STRUCT *DSFnext = NULL;
+ 
+    DSFptr = DSF_Head;
+    while (DSFptr != NULL) {
+        DSFnext = DSFptr->next;
+        paranoid_free(DSFptr);
+        DSFptr = DSFnext;
+    }
+    DSF_Head = NULL;
+    DSF_Tail = NULL;
+}
+
+/**
+ * Creates a singly linked list of all of the non-NFS mounted file systems.
+ * @param DSFptr A pointer  to the structure MOUNTED_FS_STRUCT used to hold 
+ * the list of mounted file systems. 
+ * @return None. 
+ */
+static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr)
+{
+    assert (DSFptr);
+    if (DSF_Head == NULL) {
+        DSF_Head = DSFptr;
+    } else {
+        DSF_Tail->next = DSFptr;
+    }
+    DSFptr->next = NULL;
+    DSF_Tail = DSFptr;
+}
+
+/**
+ * Find the structure, in the singly linked list of all of the non-NFS 
+ * mounted file systems, that contains the specified device.
+ * @param device The device to find 
+ * @return NULL if it didn't find the device, a pointer to the
+ * structure if it did. 
+ */
+static MOUNTED_FS_STRUCT *find_device_in_list (char *device)
+{
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    DSFptr = DSF_Head;
+    while (DSFptr != NULL) {
+        if (!strcmp(DSFptr->device, device)) {
+            break;
+        }
+        DSFptr = DSFptr->next;
+    }
+    return (DSFptr);
+}
+
+/**
+ * Find the structure, in the singly linked list of all of the non-NFS 
+ * mounted file systems, that contains the specified mount point.
+ * @param mount_point The mount point to find 
+ * @return NULL is it didn't find the mount point, a pointer to the
+ * structure if it did. 
+ */
+static MOUNTED_FS_STRUCT *find_mount_point_in_list (char *mount_point)
+{
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    DSFptr = DSF_Head;
+    while (DSFptr != NULL) {
+        if (!strcmp(DSFptr->mount_point, mount_point)) {
+            break;
+        }
+        DSFptr = DSFptr->next;
+    }
+    return (DSFptr);
+}
+
+/**
+ * Creates a linked list of all of the non-NFS mounted file systems.
+ * We use a linked list because we don't know how many  mounted file
+ * there are (and there can be a lot).
+ * @return 0 on success and greated than 0 on failure. 
+ */
+static int create_list_of_non_NFS_mounted_file_systems (void)
+{
+    int i = 0;
+    int mount_cnt = 0;
+    char *mounted_file_system = NULL;
+    char *command = NULL;
+    char *token = NULL;
+    char token_chars[] =" :\t\r\f\a\0";
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    free_mounted_fs_list();
+    /********
+    * Find the number of mounted file system entries and their respective mount points. 
+    * I can't return all of the entries as one string because it's length can be longer
+    * than MAX_STR_LEN which is used in call_program_and_get_last_line_of_output(). 
+    * So start looping and get the number of  mounted file systems and query them one by one.
+    ********/
+    /* Get the number of mounted file systems ((those that start with "/dev/" */
+    asprintf(&command, "mount 2>/dev/null | awk '{if($1 ~ \"^/dev/\"){print $0}}'|wc -l");
+    log_msg(5, "Running: %s", command);
+    asprintf(&mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
+    paranoid_free(command);
+
+    mount_cnt = atoi(mounted_file_system);
+    log_msg (5, "mount_cnt: %d", mount_cnt);
+    paranoid_free(mounted_file_system);
+
+    for (i=mount_cnt; i > 0; i--) {
+        asprintf(&command, "mount 2>/dev/null | awk '{if($1 ~ \"^/dev/\"){print $1,$3}}'|head -n %d", i);
+        log_msg(5, "Running: %s", command);
+        asprintf(&mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
+        paranoid_free(command);
+
+        log_msg (5, "mounted_file_system: %s", mounted_file_system);
+        if ((token = strtok(mounted_file_system, token_chars)) == NULL) {
+            log_msg (4, "Could not get the list of mounted file systems");
+            paranoid_free(mounted_file_system);
+            return (1);
+        }
+        paranoid_free(mounted_file_system);
+        log_msg (5, "token: %s", token);
+        while (token != NULL) {
+            log_msg (5, "token: %s", token);
+            if ((DSFptr = (MOUNTED_FS_STRUCT *) calloc(1, sizeof(MOUNTED_FS_STRUCT))) == NULL) {
+                fatal_error ("Cannot allocate memory");
+            }
+            add_mounted_fs_struct(DSFptr);
+            strcpy(DSFptr->device, token);
+            if ((token = strtok(NULL, token_chars)) == NULL) {
+                log_msg (5, "Ran out of entries on the mounted file systems list");
+                return (1);
+            }
+            log_msg (5, "token: %s", token);
+            strcpy(DSFptr->mount_point, token);
+            token = strtok(NULL, token_chars); 
+        }
+    }
+    /********
+    * DSFptr = DSF_Head;
+    * while (DSFptr != NULL) {
+    * printf ("Dev: %s  MP: %s  Check: %d\n", DSFptr->device, DSFptr->mount_point, DSFptr->check);
+    * DSFptr = DSFptr->next;
+    * }
+    ********/
+    return (0);
+}
+
+/**
+ * Given a whole disk device special file, determine which mounted file systems
+ * are on the dsf's partitions and which mounted file systems are not.
+ * @param dsf The whole disk device special file.
+ * @param included_dsf_list A char pointer used to hold the list of mount points
+ * that are on the dsf. Memory for the array will be allocated within the function.
+ * @param excluded_dsf_list A char pointer used to hold the list of mount points
+ * that are not on the dsf. Memory for the array will be allocated within the function.
+ * @return 0 on success, -1 if no device special file was passed in, -2 if a device
+ * special file was passed in but it has no partitions on it, or 1 on failure 
+ */
+static int get_dsf_mount_list (const char *dsf, char **included_dsf_list, char **excluded_dsf_list) {
+    int i = 0;
+    int c = 0;
+    int dsf_cnt = 0;
+    int num_dsf = 0;
+    char VG[MAX_STR_LEN];
+    char *tmp = NULL;
+    char *command = NULL;
+    char *partition_list = NULL;
+    char partitions[64][MAX_STR_LEN];
+    char dsf_list[16][MAX_STR_LEN];
+    char *mount_list = NULL;
+    char *token = NULL;
+    char *DSF = NULL;
+    char token_chars[] =" \t\r\f\a\0";
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    malloc_string(DSF);
+    memset((char *)partitions, 0, sizeof(partitions));
+    memset((char *)dsf_list, 0, sizeof(dsf_list));
+
+    num_dsf = 0;
+    log_msg(5, "DSF's: %s", dsf);
+    strcpy(DSF, dsf);
+    token = strtok(DSF, token_chars);
+    while (token != NULL) {
+        log_msg (5, " dsf: %s", token);
+        strcpy(dsf_list[num_dsf], token);
+        /********
+        * See if a device special file was passed in (i.e. it must start with /dev/
+        ********/
+        if (strncmp(dsf_list[num_dsf], "/dev/", 5)) {
+            log_msg (5, "%s does not start with /dev/ and (probably) is not a  device special file", dsf_list[num_dsf]);
+            return (-1);
+        }
+        log_msg(5, "  %s looks like a device special file", dsf_list[num_dsf]);
+        /* Verify that the dsf exists */ 
+        asprintf(&command, "ls -al %s 2>/dev/null | wc -l", dsf_list[num_dsf]);
+        log_msg(5, "  Executing: %s", command);
+        asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+        paranoid_free(command);
+        log_msg(5, "  Return value: %s", tmp);
+        c = atoi(tmp);
+        paranoid_free(tmp);
+        if (!c) {
+            log_to_screen("Cannot find device special file %s", dsf_list[num_dsf]);
+            return (1);
+        }
+        log_msg(5, "  %s device special file exists", dsf_list[dsf_cnt]);
+        num_dsf++;
+        token = strtok(NULL, token_chars);
+    }
+    paranoid_free(DSF);
+    log_msg (5, " num_dsf: %d", num_dsf);
+    
+    /* Get a list of the mounted file systems */
+    if (create_list_of_non_NFS_mounted_file_systems()) {
+        log_to_screen ("Could not get the list of mounted file systems");
+        return (1);
+    }
+    /* Loop throught each dsf */
+    for (dsf_cnt=0; dsf_cnt < num_dsf; dsf_cnt++) {
+        log_msg (5, "Processing dsf: %s", dsf_list[dsf_cnt]);
+        /********
+        * Get a list of the dsf's partitions. There could be no partitions on the disk
+        * or a dsf of a partition was passed in (e.g. /dev/sda1 instead of /dev/sda).
+        * Either way, it's an error.
+        ********/
+        asprintf(&command, 
+          "fdisk -l %s 2>/dev/null|grep -E \"^/dev/\"|awk '{printf(\"%%s \", $1)}END{print \"\"}'", dsf_list[dsf_cnt]);
+        log_msg(4, "Executing: %s", command);
+        asprintf(&partition_list, call_program_and_get_last_line_of_output(command));
+        paranoid_free(command);
+        log_msg(4, "Partition list for %s: %s", dsf_list[dsf_cnt], partition_list);
+        if (!strlen(partition_list)) {
+            /* There were no partitions on the disk */
+            log_msg(4, "Cannot find any partitions on device special file %s", dsf_list[dsf_cnt]);
+            return (-2);
+        }
+
+        /* Fill the partition list */
+        i = 0;
+        token = strtok(partition_list, token_chars);
+        while (token != NULL) {
+            log_msg (5, "Found partition: %s", token);
+            strcpy(partitions[i++], token);
+            token = strtok(NULL, token_chars);
+        }
+        paranoid_free(partition_list);
+  
+        /********
+         * At this point, we have a list of all of the partitions on the dsf. Now try to
+         * see which partitions have a file system on them. 
+         *
+         * Loop through each partition on the disk and:
+         *
+         * - If the partition is swap, it ignores it.
+         *
+         * - If the partition is mounted (e.g. /dev/sda1 is mounted on /boot), it adds an entry 
+         *  to the linked list, copies to it the device name and mount point, and sets check == 1.
+         *
+         * - If the partition is part of a Volume Group that has Logical Volumes mounted, it adds 
+         *  an entry to the linked list for each mounted Logical Volume in that Volume Group, copying 
+         *  to it the device name and mount point, and sets check == 1. Note that if the Volume Group 
+         *  contains more than one disk, it will still add the entry even if the Logical Volume's 
+         *  extents are not on the dsf that was passed in to the function. For example, Volume Group 
+         *  VolGroup00 contains the disks /dev/sda1 and /dev/sdb1, and the Logical Volumes LogVol01, 
+         *  which is mounted on /var and has all of its extents on /dev/sda1, and LogVol02, which is 
+         *  mounted as /usr and has all of its extents on /dev/sdb1. If you pass /dev/sda into the 
+         *  function, both /var and /usr will be archived even though /usr is actually on/dev/sdb.
+         *
+         * - If the partition is part of a Volume Group that has Logical Volumes used in a mounted 
+         *  software raid device, it adds an entry to the linked list, copies to it the software raid 
+         *  device name and mount point, and sets check == 1.
+         *
+         * - If the partition is part of a mounted software raid device, it adds an entry to the linked 
+         *  list, copies to it the software raid device name and mount point, and sets check == 1.
+         *
+         ********/
+        for (i=0; strlen(partitions[i]); i++) {
+            log_msg(4, "Processing partition: %s", partitions[i]);
+            /* See if it's swap. If it is, ignore it. */
+            asprintf(&command,
+              "fdisk -l %s 2>/dev/null | awk '{if(($1==\"%s\")&&(toupper($0) ~ \"SWAP\")){print $1;exit}}'", 
+              dsf_list[dsf_cnt], partitions[i]);
+            log_msg(4, "  Running: %s", command);
+            asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+            paranoid_free(command);
+            log_msg(4, "  Return value: %s", tmp);
+            c = strlen(tmp);
+            paranoid_free(tmp);
+            if (c) {
+                log_msg(4, "It's swap. Ignoring partition %s", partitions[i]); 
+                continue;
+            } 
+            /* It's not swap. See if we can find the mount point from the mount command. */
+            asprintf(&command, "mount 2>/dev/null | awk '{if((NF>0)&&($1==\"%s\")){print $3}}'", partitions[i]);
+            sprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+            paranoid_free(command);
+            if (strlen(tmp)) {
+                log_msg(4, "  %s is mounted: %s", partitions[i], tmp);
+                if ((DSFptr = find_mount_point_in_list(tmp)) == NULL) {
+                    log_msg (4, "Can't find mount point %s in mounted file systems list", tmp);
+                    paranoid_free(tmp);
+                    return (1);
+                }
+                DSFptr->check = 1;
+                paranoid_free(tmp);
+                continue;
+            }
+            paranoid_free(tmp);
+            /* It's not swap and it's not mounted. See if it's LVM */
+            log_msg(4, "  It's not mounted. Checking to see if it's LVM...");
+            /* Get the partition ID; 8e for LVM */
+            asprintf(&command, "fdisk -l %s |awk '{if($1 ~ \"^%s\"){print $5}}'", dsf_list[dsf_cnt], partitions[i]);
+            log_msg(4, "  Running: %s", command);
+            asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+            paranoid_free(command);
+            if (strlen(tmp)) {
+                log_msg(4, "  Partition ID: %s", tmp);
+                if (!strcasecmp(tmp, "8e")) { 
+                    /* It's LVM: Find the VG it's in */
+                    log_msg(4, "  It's LVM: Find the VG it's in...");
+                    asprintf(&command, "pvdisplay -v %s 2>/dev/null|grep \"VG Name\"|awk '{print $NF}'", partitions[i]);
+                    log_msg(4, "  Running: %s", command);
+                    strcpy(VG, call_program_and_get_last_line_of_output(command));
+                    paranoid_free(command);
+                    log_msg(4, "  Volume Group: %s", VG);
+                    if (strlen(VG)) {
+                        /* Found the Volume Group. Now find all of the VG's mount points */
+                        log_msg(4, "  Found the Volume Group. Now find all of the VG's mount points");
+                        asprintf(&command, 
+                          "mount 2>/dev/null|grep -E \"/dev/mapper/%s-|/dev/%s/\"|awk '{printf(\"%%s \",$3)}END{print \"\"}'", 
+                          VG, VG);
+                        log_msg(4, "  Running: %s", command);
+                        asprintf(&mount_list, call_program_and_get_last_line_of_output(command));
+                        paranoid_free(command);
+                        log_msg(4, "  VG %s mount_list: %s", VG, mount_list);
+                        token = strtok(mount_list, token_chars);
+                        while (token != NULL) {
+                            log_msg (5, "mount point token: %s", token);
+                            if ((DSFptr = find_mount_point_in_list(token)) == NULL) {
+                                log_msg (4, "Can't find mount point %s in mounted file systems list", token);
+                                paranoid_free(tmp);
+                                return (1);
+                            }
+                            DSFptr->check = 1;
+                            token = strtok(NULL, token_chars);
+                        }
+                        /********
+                         * Now we want to see if there are any software raid devices using
+                         * any of the Logical Volumes on the Volume Group.
+                         *******/
+                        paranoid_free(mount_list);
+                        asprintf(&command,
+                            "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
+                        log_msg (5, "Running: %s", command);
+                        asprintf(&mount_list, call_program_and_get_last_line_of_output(command));
+                        paranoid_free(command);
+                        log_msg(4, "  Software raid device list: %s", mount_list);   
+                        token = strtok(mount_list, token_chars);
+                        while (token != NULL) {
+                            asprintf(&command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, VG); 
+                            log_msg (5, "Running: %s", command);
+                            paranoid_free(tmp);
+                            asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+                            paranoid_free(command);
+                            log_msg(4, "Number of Software raid device: %s", tmp);
+                            if (atoi(tmp)) {
+                                /* This device is on our disk */
+                                if ((DSFptr = find_device_in_list(token)) == NULL) {
+                                    log_msg (4, "Can't find device %s in mounted file systems list", token);
+                                    paranoid_free(tmp);
+                                    return (1);
+                                }
+                                DSFptr->check = 1;
+                            }
+                            token = strtok(NULL, token_chars);
+                        }
+                        paranoid_free(mount_list);
+                    } else {
+                        log_msg (4, "Error finding Volume Group for partition %s", partitions[i]);
+                        paranoid_free(tmp);
+                        return (1);
+                    }
+                    paranoid_free(tmp);
+                    continue;
+                }
+            } else {
+                log_msg (4, "Error finding partition type for the partition %s", partitions[i]);
+            }
+            paranoid_free(tmp);
+            /********
+             * It's not swap, mounted, or LVM. See if it's used in a software raid device.
+             ********/
+            log_msg (5, "It's not swap, mounted, or LVM. See if it's used in a software raid device.");
+            asprintf(command, "mdadm --examine %s 2>/dev/null | awk '{if($1 == \"UUID\"){print $3}}'", partitions[i]);
+            log_msg(4, "  Running: %s", command);
+            asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+            paranoid_free(command);
+            if (!strlen(tmp)) {
+                log_msg(4, "  Partition %s is not used in a non-LVM software raid device", partitions[i]);
+                paranoid_free(tmp);
+                continue;
+            }
+            log_msg (5, "  UUID: %s", tmp);
+            /* Get the Software raid device list */
+            asprintf(&command,
+             "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
+            log_msg (5, "  Running: %s", command);
+            asprintf(&mount_list, call_program_and_get_last_line_of_output(command));
+            paranoid_free(command);
+            log_msg(4, "  Software raid device list: %s", mount_list);   
+            /* Loop through the software raid device list to see if we can find the partition */
+            token = strtok(mount_list, token_chars);
+            while (token != NULL) {
+                asprintf(&command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, tmp);
+                log_msg(4, "  Running: %s", command);
+                paranoid_free(tmp);
+                asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
+                paranoid_free(command);
+                if (!atoi(tmp)) {
+                    log_msg (4,"  Didn't find partition %s in software raid device %s", partitions[i], token);
+                } else {
+                    if ((DSFptr = find_device_in_list(token)) == NULL) {
+                        log_msg (4, "Can't find device %s in mounted file systems list", token);
+                        paranoid_free(tmp);
+                        return (1);
+                    }
+                    DSFptr->check = 1;
+                    break;
+                }
+                token = strtok(NULL, token_chars);
+            }
+            paranoid_free(tmp);
+        }
+    }
+    paranoid_free(partition_list);
+    paranoid_free(mount_list);
+
+    /* Determine how much memory to allocate for included_dsf_list and excluded_dsf_list */
+    i = 0;
+    DSFptr= DSF_Head;
+    while (DSFptr != NULL) {
+        i += strlen(DSFptr->mount_point) + 1;
+        DSFptr = DSFptr->next;
+    }
+    log_msg (5, "i: %d", i);
+    if ((*included_dsf_list = (char *) calloc(i+100, sizeof(char))) == NULL) {
+        fatal_error ("Cannot allocate memory");
+    }
+    if ((*excluded_dsf_list = (char *) calloc(i+100, sizeof(char))) == NULL) {
+        fatal_error ("Cannot allocate memory");
+    }
+    DSFptr= DSF_Head;
+    while (DSFptr != NULL) {
+        if (DSFptr->check) {
+            log_msg (5, "%s is mounted on %s and is on disk %s\n", DSFptr->device, DSFptr->mount_point, dsf);
+            strcat(*included_dsf_list, DSFptr->mount_point);
+            strcat(*included_dsf_list, " ");
+        } else {
+            log_msg (4, "%s is mounted on %s and is NOT on disk %s\n", DSFptr->device, DSFptr->mount_point, dsf);
+            strcat(*excluded_dsf_list, DSFptr->mount_point);
+            strcat(*excluded_dsf_list, " ");
+        }
+        DSFptr = DSFptr->next;
+    }
+    log_msg (5, "included_dsf_list: %s", *included_dsf_list);
+    log_msg (5, "excluded_dsf_list: %s", *excluded_dsf_list);
+    return (0);
+}
-
-
@@ -337 +826 @@
-    char *p;
-    char *q;
+    char *mounted_on_dsf = NULL;
+    char *not_mounted_on_dsf = NULL;
-
-    long itbs = 0L;
@@ -426 +917 @@
-            strcat(bkpinfo->include_paths, " ");
-        }
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
@@ -697 +1213 @@
-        }
-        asprintf(&tmp1, flag_val['E']);
-
-q = tmp1;
-
-/* Cut the flag_val['E'] in parts containing all paths to test them */
-while (p != NULL) {
-q = strchr(p, ' ');
-if (q != NULL) {
-*q = '\0';
-/* Fix bug 14 where ending / cause a problem later 
- * so handled here for the moment */
-q--
-if (*q == '/') {
-*q = '\0'
+
+switch (get_dsf_mount_list(flag_val['E'], &mounted_on_dsf, &not_mounted_on_dsf)) {
+
+   case 1: 
+       fatal_error ("Error processing -I option");
+/* Everything is OK; proceed to archive data */
+case 0:
+if (strlen(mounted_on_dsf)) {
+   log_to_screen("Excluding the following file systems on %s:\n", flag_val['E']);
+   `log_to_screen("  %s\n", mounted_on_dsf);
+   log_msg (5, "Adding to bkpinfo->exclude_paths due to -E option: %s", mounted_on_dsf)
+   strcat(bkpinfo->exclude_paths, mounted_on_dsf);
+strcat(bkpinfo->exclude_paths, "")
-                }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    }
-