libfsmgt/common/fs_mounts.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Traverses /etc/mnttab in order to find mounted file systems.
 */
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/mnttab.h>
#include <sys/types.h>
#include <sys/statvfs.h>
#include <strings.h>
#include "libfsmgt.h"

/*
 * Private variables
 */

/*
 * Private method declarations
 */

static fs_mntlist_t	*create_mntlist_entry(struct mnttab mnttab_entry);
static fs_mntlist_t	*create_extmntlist_entry(struct extmnttab mnttab_entry);
static struct mnttab	*create_mnttab_filter(char *resource, char *mountp,
				char *fstype, char *mntopts, char *time);
static void		find_overlayed_filesystems(fs_mntlist_t *mnt_list,
				boolean_t filtered_list, int *errp);
static void		free_mnttab_entry(struct mnttab *mnttab_entry);
static char		*is_option(char *opt_string, char *opt, int *errp);
boolean_t 		is_overlayed(fs_mntlist_t *complete_mnt_list,
				char *mountp);


/*
 * Public methods
 */

void
fs_free_mount_list(fs_mntlist_t *headp) {
	fs_mntlist_t	*tmp;

	while (headp != NULL) {
		tmp = headp->next;
		free(headp->resource);
		free(headp->mountp);
		free(headp->fstype);
		free(headp->mntopts);
		free(headp->time);
		headp->next = NULL;
		free(headp);

		headp = tmp;
	}
} /* fs_free_mount_list */

unsigned long long
fs_get_availablesize(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long long	availablesize;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		availablesize = stvfs.f_bfree;
		availablesize = availablesize * stvfs.f_frsize;
	} else {
		*errp = errno;
		return (0);
	}  /* if (statvfs64(mntpnt, &stvfs) != -1) */

	return (availablesize);
} /* fs_get_availablesize */

unsigned long long
fs_get_avail_for_nonsuperuser_size(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long long	avail_for_nonsu_size;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		avail_for_nonsu_size = stvfs.f_bavail;
		avail_for_nonsu_size = avail_for_nonsu_size * stvfs.f_frsize;
	} else {
		*errp = errno;
		return (0);
	} /* if (statvfs64(mntpnt, &stvfs) != -1) */

	return (avail_for_nonsu_size);
} /* fs_get_avail_for_nonsuperuser_size(char *mntpnt, int *errp) */

unsigned long long
fs_get_blocksize(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long long	blocksize;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		blocksize = stvfs.f_bsize;
	} else {
		*errp = errno;
		return (0);
	} /* if (statvfs64(mntpnt, &stvfs) != -1) */

	return (blocksize);
} /* fs_get_blocksize */

fs_mntlist_t *
fs_get_filtered_mount_list(char *resource, char *mountp, char *fstype,
	char *mntopts, char *time, boolean_t find_overlays, int *errp) {

	fs_mntlist_t	*newp;
	fs_mntlist_t	*headp;
	fs_mntlist_t	*tailp;
	FILE		*fp;

	*errp = 0;
	headp = NULL;
	tailp = NULL;

	if ((fp = fopen(MNTTAB, "r")) != NULL) {
		struct mnttab   mnttab_entry;
		struct mnttab   *search_entry;

		search_entry = create_mnttab_filter(resource, mountp, fstype,
			mntopts, time);
		if (search_entry == NULL) {
			/*
			 * Out of memory
			 */
			fs_free_mount_list(headp);
			(void) fclose(fp);
			*errp = ENOMEM;
			return (NULL);
		}

		while (getmntany(fp, &mnttab_entry, search_entry) == 0) {
			/* Add to list to be returned */
			newp = create_mntlist_entry(mnttab_entry);

			if (newp == NULL) {
				/*
				 * Out of memory
				 */
				fs_free_mount_list(headp);
				(void) fclose(fp);
				*errp = ENOMEM;
				return (NULL);
			}

			if (headp == NULL) {
				headp = newp;
				tailp = newp;
			} else {
				tailp->next = newp;
				tailp = newp;
			}

		}
		free_mnttab_entry(search_entry);
		(void) fclose(fp);
		if (find_overlays == B_TRUE)
			find_overlayed_filesystems(headp, B_TRUE, errp);
	} else {
		*errp = errno;
	} /* if ((fp = fopen(MNTTAB, "r")) != NULL) */

	return (headp);
} /* fs_get_filtered_mount_list */

unsigned long
fs_get_fragsize(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long		fragsize;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		fragsize = stvfs.f_frsize;
	} else {
		*errp = errno;
		return (0);
	} /* (statvfs64(mntpnt, &stvfs) != -1) */

	return (fragsize);
} /* fs_get_fragsize(char *mntpnt, int *errp) */

unsigned long
fs_get_maxfilenamelen(char *mntpnt, int *errp) {
	long int		returned_val;
	unsigned long		maxfilenamelen;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	returned_val = pathconf(mntpnt, _PC_PATH_MAX);
	if (returned_val != -1) {
		maxfilenamelen = (unsigned long)returned_val;
	} else {
		*errp = errno;
		return (0);
	}

	return (maxfilenamelen);
} /* fs_get_maxfilenamelen */

fs_mntlist_t *
fs_get_mounts_by_mntopt(char *mntopt, boolean_t find_overlays, int *errp) {

	fs_mntlist_t	*newp;
	fs_mntlist_t	*headp;
	fs_mntlist_t	*tailp;
	FILE		*fp;

	*errp = 0;
	headp = NULL;
	tailp = NULL;

	if (mntopt == NULL)
		return (NULL);

	if ((fp = fopen(MNTTAB, "r")) != NULL) {
		struct mnttab mnttab_entry;
		char *opt_found;

		while (getmntent(fp, &mnttab_entry) == 0) {
			opt_found = hasmntopt(&mnttab_entry, mntopt);
			if (opt_found != NULL) {
				/*
				 * Add to list to be returned
				 */
				newp = create_mntlist_entry(mnttab_entry);

				if (newp == NULL) {
					/*
					 * Out of memory
					 */
					fs_free_mount_list(headp);
					(void) fclose(fp);
					*errp = ENOMEM;
					return (NULL);
				}

				if (headp == NULL) {
					headp = newp;
					tailp = newp;
				} else {
					tailp->next = newp;
					tailp = newp;
				}
			} /* if (char != NULL) */
		}
		(void) fclose(fp);
		if (find_overlays == B_TRUE)
			find_overlayed_filesystems(headp, B_TRUE, errp);

	} else {
		*errp = errno;
	} /* if ((fp = fopen(MNTTAB, "r")) != NULL) */

	return (headp);
} /* fs_get_mounts_by_mntpnt */

fs_mntlist_t *
fs_get_mount_list(boolean_t find_overlays, int *errp) {
	FILE 		*fp;
	fs_mntlist_t	*headp;
	fs_mntlist_t	*tailp;
	fs_mntlist_t	*newp;

	*errp = 0;
	headp = NULL;
	tailp = NULL;

	if ((fp = fopen(MNTTAB, "r")) != NULL) {
		struct extmnttab	mnttab_entry;

		resetmnttab(fp);

		/*
		 * getextmntent() Is used here so that we can use mnt_major
		 * and mnt_minor to get the fsid. The fsid is used when
		 * getting mount information from kstat.
		 */
		while (getextmntent(fp, &mnttab_entry,
		    sizeof (struct extmnttab)) == 0) {

			newp = create_extmntlist_entry(mnttab_entry);

			if (newp == NULL) {
				/*
				 * Out of memory
				 */
				fs_free_mount_list(headp);
				(void) fclose(fp);
				*errp = ENOMEM;
				return (NULL);
			}

			if (headp == NULL) {
				headp = newp;
				tailp = newp;
			} else {
				tailp->next = newp;
				tailp = newp;
			}

		} /* while (getmntent(fp, &mnttab_entry) == 0) */
		(void) fclose(fp);
		if (find_overlays)
			find_overlayed_filesystems(headp, B_FALSE, errp);
	} else {
		*errp = errno;
	} /* if ((fp = fopen(MNTTAB, "r")) != NULL) */

	/*
	 * Caller must free the mount list
	 */
	return (headp);
} /* fs_get_mount_list */

boolean_t
fs_is_readonly(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	boolean_t		readonly;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (B_FALSE);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		readonly = stvfs.f_flag & ST_RDONLY;
	} else {
		*errp = errno;
		return (B_FALSE);
	}

	return (readonly);
} /* fs_is_readonly */

/*
 * This method will parse the given comma delimited option list (optlist) for
 * the option passed into the function.  If the option (opt) to search for
 * is one that sets a value such as onerror=, the value to the right of the "="
 * character will be returned from the function.  This function expects the
 * opt parameter to have the "=" character appended when searching for options
 * which set a value.
 *
 * If the option is found in the given optlist, the function will return the
 * option as found in the option list.
 * If the option is not found in the given optlist, the function will return
 * NULL.
 * If an error occurs, the function will return NULL and the errp will
 * reflect the error that has occurred.
 *
 * NOTE: The caller must free the space allocated for the return value by using
 * free().
 */
char *
fs_parse_optlist_for_option(char *optlist, char *opt, int *errp) {
	const char	*delimiter = ",";
	char		*token;
	char		*return_value;
	char		*optlist_copy;

	*errp = 0;
	optlist_copy = strdup(optlist);
	if (optlist_copy == NULL) {
		*errp = errno;
		return (NULL);
	}

	token = strtok(optlist_copy, delimiter);
	/*
	 * Check to see if we have found the option.
	 */
	if (token == NULL) {
		free(optlist_copy);
		return (NULL);
	} else if ((return_value = is_option(token, opt, errp)) != NULL) {
		free(optlist_copy);
		return (return_value);
	}

	while (token != NULL) {
		token = NULL;
		token = strtok(NULL, delimiter);
		/*
		 * If token is NULL then then we are at the end of the list
		 * and we can return NULL because the option was never found in
		 * the option list.
		 */
		if (token == NULL) {
			free(optlist_copy);
			return (NULL);
		} else if ((return_value =
			is_option(token, opt, errp)) != NULL) {

			free(optlist_copy);
			return (return_value);

		}
	}
	free(optlist_copy);
	return (NULL);
}

unsigned long long
fs_get_totalsize(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long long 	totalsize;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		totalsize = stvfs.f_blocks;
		totalsize = totalsize * stvfs.f_frsize;

	} else {
		*errp = errno;
		return (0);
	} /* if (statvfs64(mntpnt, &stvfs) != -1) */

	return (totalsize);
} /* fs_get_totalsize */

unsigned long long
fs_get_usedsize(char *mntpnt, int *errp) {
	struct statvfs64	stvfs;
	unsigned long long	usedsize;

	*errp = 0;
	if (mntpnt == NULL) {
		/*
		 * Set errp to invalid parameter - EINVAL
		 */
		*errp = EINVAL;
		return (0);
	}

	if (statvfs64(mntpnt, &stvfs) != -1) {
		usedsize = stvfs.f_blocks - stvfs.f_bfree;
		usedsize = usedsize * stvfs.f_frsize;
	} else {
		*errp = errno;
		return (0);
	} /* if (statvfs64(mntpnt, &stvfs) != -1) */

	return (usedsize);
} /* fs_get_usedsize */

/*
 * Private methods
 */

static fs_mntlist_t *
create_mntlist_entry(struct mnttab mnttab_entry) {

	fs_mntlist_t	*newp;

	newp = (fs_mntlist_t *)calloc((size_t)1,
		(size_t)sizeof (fs_mntlist_t));

	if (newp == NULL) {
		/*
		 * Out of memory
		 */
		return (NULL);
	}

	newp->resource = strdup(mnttab_entry.mnt_special);
	if (newp->resource == NULL) {
		/*
		 *  Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->mountp = strdup(mnttab_entry.mnt_mountp);
	if (newp->mountp == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->fstype = strdup(mnttab_entry.mnt_fstype);
	if (newp->fstype == NULL) {
		/*
		 *  Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->mntopts = strdup(mnttab_entry.mnt_mntopts);
	if (newp->mntopts == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->time = strdup(mnttab_entry.mnt_time);
	if (newp->time == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->next = NULL;

	return (newp);
} /* create_mntlist_entry */

static fs_mntlist_t *
create_extmntlist_entry(struct extmnttab mnttab_entry) {

	fs_mntlist_t	*newp;

	newp = (fs_mntlist_t *)calloc((size_t)1,
		(size_t)sizeof (fs_mntlist_t));

	if (newp == NULL) {
		/*
		 * Out of memory
		 */
		return (NULL);
	}

	newp->resource = strdup(mnttab_entry.mnt_special);
	if (newp->resource == NULL) {
		/*
		 *  Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->mountp = strdup(mnttab_entry.mnt_mountp);
	if (newp->mountp == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->fstype = strdup(mnttab_entry.mnt_fstype);
	if (newp->fstype == NULL) {
		/*
		 *  Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->mntopts = strdup(mnttab_entry.mnt_mntopts);
	if (newp->mntopts == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->time = strdup(mnttab_entry.mnt_time);
	if (newp->time == NULL) {
		/*
		 * Out of memory
		 */
		fs_free_mount_list(newp);
		return (NULL);
	}
	newp->major = mnttab_entry.mnt_major;

	newp->minor = mnttab_entry.mnt_minor;

	newp->next = NULL;

	return (newp);
} /* create_extmntlist_entry */

static struct mnttab *
create_mnttab_filter(char *resource, char *mountp, char *fstype, char *mntopts,
	char *time) {

	struct mnttab	*search_entry;

	search_entry = (struct mnttab *)calloc((size_t)1,
		(size_t)sizeof (struct mnttab));

	if (search_entry == NULL) {
		/*
		 * Out of memory
		 */
		return (NULL);
	}

	if (resource != NULL) {
		search_entry->mnt_special = strdup(resource);
		if (search_entry->mnt_special == NULL) {
			/*
			 * Out of memory
			 */
			free_mnttab_entry(search_entry);
			return (NULL);
		}
	}

	if (mountp != NULL) {
		search_entry->mnt_mountp = strdup(mountp);
		if (search_entry->mnt_mountp == NULL) {
			/*
			 * Out of memory
			 */
			free_mnttab_entry(search_entry);
			return (NULL);
		}
	}

	if (fstype != NULL) {
		search_entry->mnt_fstype = strdup(fstype);
		if (search_entry->mnt_fstype == NULL) {
			/*
			 * Out of memory
			 */
			free_mnttab_entry(search_entry);
			return (NULL);
		}
	}

	if (mntopts != NULL) {
		search_entry->mnt_mntopts = strdup(mntopts);
		if (search_entry->mnt_mntopts == NULL) {
			/*
			 * Out of memory
			 */
			free_mnttab_entry(search_entry);
			return (NULL);
		}
	}

	if (time != NULL) {
		search_entry->mnt_time = strdup(time);
		if (search_entry->mnt_time == NULL) {
			/*
			 * Out of memory
			 */
			free_mnttab_entry(search_entry);
			return (NULL);
		}
	}

	return (search_entry);
} /* create_mnttab_filter */

/*
 * We will go through the /etc/mnttab entries to determine the
 * instances of overlayed file systems.  We do this with the following
 * assumptions:
 *
 * 1.) Entries in mnttab are ordered in the way that the most recent
 * mounts are placed at the bottom of /etc/mnttab.  Contract to be
 * filed:
 * 2.) Mnttab entries that are returned from all mnttab library
 * functions such as getmntent, getextmntent, and getmntany in the order
 * as they are found in /etc/mnttab.  Goes along with assumption #1.
 * 3.) All automounted NFS file systems will have an autofs entry and
 * a NFS entry in /etc/mnttab with the same mount point.  Autofs
 * entries can be ignored.
 * 4.) The device id (dev=) uniquely identifies a mounted file system
 * on a host.
 *
 * Algorithm explanation:
 * ----------------------
 * For each mnt_list entry
 * 1.) Compare it to each /etc/mnttab entry starting at the point in mnttab
 * where the mnt_list entry mount is and look for matching mount points,
 * but ignore all "autofs" entries
 *      If a two entries are found with the same mount point mark the mnt_list
 *	entry as being overlayed.
 */
static void
find_overlayed_filesystems(fs_mntlist_t *mnt_list,
	boolean_t filtered_list, int *errp) {

	boolean_t exit = B_FALSE;
	fs_mntlist_t *mnt_list_to_compare;
	fs_mntlist_t *tmp;

	*errp = 0;
	if (filtered_list == B_TRUE) {
		/*
		 * Get the complete mount list
		 */
		mnt_list_to_compare = fs_get_mount_list(B_FALSE, errp);
		if (mnt_list_to_compare == NULL) {
			/*
			 * If complete_mnt_list is NULL there are two
			 * possibilites:
			 * 1.) There are simply no entries in /etc/mnttab.
			 * 2.) An error was encountered.  errp will reflect
			 * the error.
			 */

			return;
		}
	} else {
		mnt_list_to_compare = mnt_list;
	}

	tmp = mnt_list_to_compare;

	while (mnt_list != NULL) {
		if (!(strcmp(mnt_list->fstype, "autofs") == 0)) {
			char *dev_id;

			dev_id = fs_parse_optlist_for_option(mnt_list->mntopts,
				"dev=", errp);
			if (dev_id == NULL) {
				return;
			}

			exit = B_FALSE;
			while (tmp != NULL && exit == B_FALSE) {
				if (!(strcmp(tmp->fstype, "autofs")) == 0) {
					char *tmp_dev_id;

					tmp_dev_id =
						fs_parse_optlist_for_option(
						tmp->mntopts, "dev=", errp);
					if (tmp_dev_id == NULL) {
						return;
					}

					if (strcmp(tmp_dev_id, dev_id) == 0) {
						/*
						 * Start searching for an
						 * overlay here.
						 */
						mnt_list->overlayed =
							is_overlayed(tmp,
							mnt_list->mountp);
						exit = B_TRUE;
					}
					free(tmp_dev_id);
				}
				tmp = tmp->next;
			} /* while (tmp != NULL && exit == B_FALSE) */
			free(dev_id);
		} /* if (!(strcmp(mnt_list->fstype, "autofs") == 0)) */
		mnt_list = mnt_list->next;
	} /* while (mnt_list != NULL) */

	if (filtered_list == B_TRUE)
		fs_free_mount_list(mnt_list_to_compare);
} /* find_overlayed_filesystems */

static void
free_mnttab_entry(struct mnttab *mnttab_entry) {

	free(mnttab_entry->mnt_special);
	free(mnttab_entry->mnt_mountp);
	free(mnttab_entry->mnt_fstype);
	free(mnttab_entry->mnt_mntopts);
	free(mnttab_entry->mnt_time);

	free(mnttab_entry);

} /* free_mnttab_entry */

char *
is_option(char *opt_string, char *opt, int *errp) {
	char *equalsign = "=";
	char *found_equalsign;
	char *return_val;

	*errp = 0;
	found_equalsign = strstr(opt, equalsign);

	/*
	 * If found_equalsign is NULL then we did not find an equal sign
	 * in the option we are to be looking for.
	 */
	if (found_equalsign == NULL) {
		if (strcmp(opt_string, opt) == 0) {
			/*
			 * We have found the option so return with success.
			 */
			return_val = strdup(opt);
			if (return_val == NULL) {
				*errp = errno;
				return (NULL);
			}
		} else {
			return_val = NULL;
		}
	} else {
		int counter = 0;
		char *opt_found;
		char *value;

		opt_found = strstr(opt_string, opt);

		if (opt_found == NULL) {
			return_val = NULL;
		} else {
			size_t opt_string_len;
			size_t opt_len;
			size_t value_len;

			opt_string_len = strlen(opt_string);
			opt_len = strlen(opt);

			value_len = opt_string_len - opt_len;

			value = (char *)calloc((size_t)(value_len+1),
				(size_t)sizeof (char));

			if (value == NULL) {
				/*
				 * Out of memory
				 */
				*errp = ENOMEM;
				return (NULL);

			}

			while (counter <= (value_len-1)) {
				value[counter] = opt_string[opt_len+counter];
				counter = counter + 1;
			}
			/*
			 * Add the null terminating character.
			 */
			value[counter] = '\0';
			return_val = value;
		}
	} /* else */

	return (return_val);
} /* is_option */


boolean_t
is_overlayed(fs_mntlist_t *mnt_list, char *mountp) {
	boolean_t ret_val = B_FALSE;

	/*
	 * The first entry in the complete_mnt_list is the same mounted
	 * file system as the one we are trying to determine whether it is
	 * overlayed or not.  There is no need to compare these mounts.
	 */
	mnt_list = mnt_list->next;

	while (mnt_list != NULL && ret_val == B_FALSE) {
		if (!(strcmp(mnt_list->fstype, "autofs") == 0)) {
			if (strcmp(mnt_list->mountp, mountp) == 0) {
				ret_val = B_TRUE;
			} else {
				ret_val = B_FALSE;
			}
		}
		mnt_list = mnt_list->next;
	}
	return (ret_val);
} /* is_overlayed */