/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Creates and maintains a cache of mount points.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <synch.h>
#include <thread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mnttab.h>
#include <sys/swap.h>

#include "libdiskmgt.h"
#include "disks_private.h"

/*
 * The list of mount point entries in /etc/mnttab
 */

struct mntpnt_list {
	struct mntpnt_list	*next;
	char			*special;
	char			*mountp;
};

static struct mntpnt_list	*mntpoint_listp = NULL;
static rwlock_t			mntpoint_lock = DEFAULTRWLOCK;
static int			initialized = 0;
static mutex_t			init_lock = DEFAULTMUTEX;

static boolean_t	diff_mnttab(int send_event, struct mntpnt_list *firstp,
			    struct mntpnt_list *secondp);
static void		free_mnttab(struct mntpnt_list *listp);
static boolean_t	in_list(struct mntpnt_list *elementp,
			    struct mntpnt_list *listp);
static int		load_mnttab(int send_event);
static void		watch_mnttab();

/*
 * Search the list of devices from /etc/mnttab to find the mount point
 * for the specified device.
 */
int
inuse_mnt(char *slice, nvlist_t *attrs, int *errp)
{
	struct mntpnt_list	*listp;
	int			found = 0;

	*errp = 0;
	if (slice == NULL) {
	    return (found);
	}

	(void) mutex_lock(&init_lock);
	if (!initialized) {
	    thread_t	mnttab_thread;

	    /* load the mntpnt cache */
	    *errp = load_mnttab(B_FALSE);

	    if (*errp == 0) {
		/* start a thread to monitor the mnttab */
		*errp = thr_create(NULL, NULL, (void *(*)(void *))watch_mnttab,
		    NULL, THR_NEW_LWP | THR_DAEMON, &mnttab_thread);
	    }

	    if (*errp == 0) {
		initialized = 1;
	    }
	}
	(void) mutex_unlock(&init_lock);

	(void) rw_rdlock(&mntpoint_lock);
	listp = mntpoint_listp;
	while (listp != NULL) {
	    if (libdiskmgt_str_eq(slice, listp->special)) {
		libdiskmgt_add_str(attrs, DM_USED_BY, DM_USE_MOUNT, errp);
		libdiskmgt_add_str(attrs, DM_USED_NAME, listp->mountp, errp);
		found = 1;
		break;
	    }
	    listp = listp->next;
	}
	(void) rw_unlock(&mntpoint_lock);

	return (found);
}

/*
 * Return true if the lists are different.  Send an event for each different
 * device.
 */
static boolean_t
diff_mnttab(int send_event, struct mntpnt_list *firstp,
    struct mntpnt_list *secondp)
{
	boolean_t		different = B_FALSE;
	struct mntpnt_list	*listp;

	listp = firstp;
	while (listp != NULL) {
	    if (! in_list(listp, secondp)) {
		/* not in new list, so was mounted and now unmounted */
		if (send_event) {
		    events_new_slice_event(listp->special, DM_EV_TCHANGE);
		}
		different = B_TRUE;
	    }
	    listp = listp->next;
	}

	listp = secondp;
	while (listp != NULL) {
	    if (! in_list(listp, firstp)) {
		/* not in orig list, so this is a new mount */
		if (send_event) {
		    events_new_slice_event(listp->special, DM_EV_TCHANGE);
		}
		different = B_TRUE;
	    }
	    listp = listp->next;
	}

	return (different);
}

/*
 * free_mnttab()
 *
 * Free the list of metadevices from /etc/mnttab.
 */
static void
free_mnttab(struct mntpnt_list	*listp) {

	struct mntpnt_list	*nextp;

	while (listp != NULL) {
		nextp = listp->next;
		free((void *)listp->special);
		free((void *)listp->mountp);
		free((void *)listp);
		listp = nextp;
	}
}

/*
 * Return true if the element is in the list.
 */
static boolean_t
in_list(struct mntpnt_list *elementp, struct mntpnt_list *listp)
{
	while (listp != NULL) {
	    if (libdiskmgt_str_eq(elementp->special, listp->special) &&
		libdiskmgt_str_eq(elementp->mountp, listp->mountp)) {
		return (B_TRUE);
	    }
	    listp = listp->next;
	}

	return (B_FALSE);
}

/*
 * load_mnttab()
 *
 * Create a list of devices from /etc/mnttab and swap.
 * return 1 if the list has changed, 0 if the list is still the same
 */
static int
load_mnttab(int send_event)
{

	struct mntpnt_list	*currp;
	FILE			*fp;
	struct mntpnt_list	*headp;
	int			num;
	struct mntpnt_list	*prevp;

	headp = NULL;
	prevp = NULL;

	/* get the mnttab entries */
	if ((fp = fopen("/etc/mnttab", "r")) != NULL) {

		struct mnttab	entry;

		while (getmntent(fp, &entry) == 0) {

			/*
			 * Ignore entries that are incomplete or that are not
			 * devices (skips network mounts, automounter entries,
			 * /proc, etc.).
			 */
			if (entry.mnt_special == NULL ||
				entry.mnt_mountp == NULL ||
				strncmp(entry.mnt_special, "/dev", 4) != 0) {
				continue;
			}

			currp = (struct mntpnt_list *)calloc((size_t)1,
				(size_t)sizeof (struct mntpnt_list));

			if (currp == NULL) {
				/*
				 * out of memory, free what we have and return
				 */
				free_mnttab(headp);
				(void) fclose(fp);
				return (ENOMEM);
			}

			if (headp == NULL) {
				headp = currp;
			} else {
				prevp->next = currp;
			}

			currp->next = NULL;

			currp->special = strdup(entry.mnt_special);
			if (currp->special == NULL) {
				/*
				 * out of memory, free what we have and return
				 */
				free_mnttab(headp);
				(void) fclose(fp);
				return (ENOMEM);
			}

			currp->mountp = strdup(entry.mnt_mountp);
			if (currp->mountp == NULL) {
				/*
				 * out of memory, free what we have and return
				 */
				free_mnttab(headp);
				(void) fclose(fp);
				return (ENOMEM);
			}

			prevp = currp;
		}

		(void) fclose(fp);
	}

	/* get the swap entries */
	if ((num = swapctl(SC_GETNSWP, NULL)) > -1) {

	    struct swaptable 	*st;
	    struct swapent	*swapent;
	    int			i;
	    char		*path;
	    char		*pathstart;
	    char		fullpath[MAXPATHLEN+1];

	    st = malloc((size_t)((num * sizeof (swapent_t)) + sizeof (int)));
	    if (st == NULL) {
		/* out of memory, free what we have and return */
		free_mnttab(headp);
		return (ENOMEM);
	    }

	    path = malloc(num * MAXPATHLEN);
	    if (path == NULL) {
		/* out of memory, free what we have and return */
		free(st);
		free_mnttab(headp);
		return (ENOMEM);
	    }
	    pathstart = path;

	    swapent = st->swt_ent;
	    for (i = 0; i < num; i++, swapent++) {
		swapent->ste_path = path;
		path += MAXPATHLEN;
	    }

	    st->swt_n = num;
	    if ((num = swapctl(SC_LIST, st)) >= 0) {
		swapent = st->swt_ent;
		for (i = 0; i < num; i++, swapent++) {

		    currp = (struct mntpnt_list *)
			calloc((size_t)1, (size_t)sizeof (struct mntpnt_list));

		    if (currp == NULL) {
			/* out of memory, free what we have and return */
			free((void *)st);
			free((void *)pathstart);
			free_mnttab(headp);
			return (ENOMEM);
		    }

		    if (headp == NULL) {
			headp = currp;
		    } else {
			prevp->next = currp;
		    }

		    currp->next = NULL;

		    if (*swapent->ste_path != '/') {
			(void) snprintf(fullpath, sizeof (fullpath), "/dev/%s",
			    swapent->ste_path);
		    } else {
			(void) strlcpy(fullpath, swapent->ste_path,
			    sizeof (fullpath));
		    }

		    currp->special = strdup(fullpath);
		    if (currp->special == NULL) {
			/* out of memory, free what we have and return */
			free(st);
			free(pathstart);
			free_mnttab(headp);
			return (ENOMEM);
		    }

		    currp->mountp = strdup("swap");
		    if (currp->mountp == NULL) {
			/* out of memory, free what we have and return */
			free(st);
			free(pathstart);
			free_mnttab(headp);
			return (ENOMEM);
		    }

		    prevp = currp;
		}
	    }

	    free(st);
	    free(pathstart);
	}

	/* note that we unlock the mutex in both paths of this if statement */
	(void) rw_wrlock(&mntpoint_lock);
	if (diff_mnttab(send_event, mntpoint_listp, headp) == B_TRUE) {
		struct mntpnt_list	*tmpp;

		tmpp = mntpoint_listp;
		mntpoint_listp = headp;
		(void) rw_unlock(&mntpoint_lock);

		/* free the old list */
		free_mnttab(tmpp);
	} else {
		(void) rw_unlock(&mntpoint_lock);
		/* no change that we care about, so keep the current list */
		free_mnttab(headp);
	}
	return (0);
}

/*
 * This is a thread that runs forever, watching for changes in the mnttab
 * that would cause us to flush and reload the cache of mnt entries.  Only
 * changes to /dev devices will cause the cache to be flushed and reloaded.
 */
static void
watch_mnttab()
{
	struct pollfd fds[1];
	int res;

	if ((fds[0].fd = open("/etc/mnttab", O_RDONLY)) != -1) {

	    char buf[81];

	    /* do the initial read so we don't get the event right away */
	    (void) read(fds[0].fd, buf, (size_t)(sizeof (buf) - 1));
	    (void) lseek(fds[0].fd, 0, SEEK_SET);

	    fds[0].events = POLLRDBAND;
	    while (res = poll(fds, (nfds_t)1, -1)) {
		if (res <= 0)
		    continue;

		(void) load_mnttab(B_TRUE);

		(void) read(fds[0].fd, buf, (size_t)(sizeof (buf) - 1));
		(void) lseek(fds[0].fd, 0, SEEK_SET);
	    }
	}
}