/*
 * Common code for checking sessions for mnt use
 *
 * Copyright (C) 2014 - 2015 Chris Leech
 * Copyright (C) 2014 - 2015 Red Hat, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * See the file COPYING included with this distribution for more details.
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <dirent.h>
#include <libmount/libmount.h>

#include "initiator.h"
#include "transport.h"
#include "iscsid.h"
#include "iscsi_ipc.h"
#include "log.h"
#include "iscsi_sysfs.h"
#include "iscsi_settings.h"
#include "iface.h"
#include "host.h"
#include "sysdeps.h"
#include "iscsi_err.h"
#include "iscsi_net_util.h"

static struct libmnt_table *mtab, *swaps;
static struct libmnt_cache *mntcache;

static void libmount_cleanup(void)
{
	mnt_free_table(mtab);
	mnt_free_table(swaps);
	mnt_free_cache(mntcache);
	mtab = NULL;
	swaps = NULL;
	mntcache = NULL;
}

static int libmount_init(void)
{
	mnt_init_debug(0);
	mtab = mnt_new_table();
	swaps = mnt_new_table();
	mntcache = mnt_new_cache();
	if (!mtab || !swaps || !mntcache) {
		libmount_cleanup();
		return -ENOMEM;
	}
	mnt_table_set_cache(mtab, mntcache);
	mnt_table_set_cache(swaps, mntcache);
	mnt_table_parse_mtab(mtab, NULL);
	mnt_table_parse_swaps(swaps, NULL);
	return 0;
}

static int trans_filter(const struct dirent *d)
{
	if (!strcmp(".", d->d_name) || !strcmp("..", d->d_name))
		return 0;
	return 1;
}

static int subdir_filter(const struct dirent *d)
{
	if (!(d->d_type & DT_DIR))
		return 0;
	return trans_filter(d);
}

static int is_partition(const char *path)
{
	char *devtype;
	int rc = 0;

	devtype = sysfs_get_uevent_devtype(path);
	if (!devtype)
		return 0;
	if (strcmp(devtype, "partition") == 0)
		rc = 1;
	free(devtype);
	return rc;
}

static int blockdev_check_mnts(char *syspath)
{
	struct libmnt_fs *fs;
	char *devname = NULL;
	char *_devname = NULL;
	int rc = 0;

	devname = sysfs_get_uevent_devname(syspath);
	if (!devname)
		goto out;

	_devname = calloc(1, PATH_MAX);
	if (!_devname)
		goto out;
	snprintf(_devname, PATH_MAX, "/dev/%s", devname);

	fs = mnt_table_find_source(mtab, _devname, MNT_ITER_FORWARD);
	if (fs) {
		rc = 1;
		goto out;
	}
	fs = mnt_table_find_source(swaps, _devname, MNT_ITER_FORWARD);
	if (fs)
		rc = 1;
out:
	free(devname);
	free(_devname);
	return rc;
}

static int count_device_users(char *syspath);

static int blockdev_get_partitions(char *syspath)
{
	struct dirent **parts = NULL;
	int n, i;
	int count = 0;

	n = scandir(syspath, &parts, subdir_filter, alphasort);
	for (i = 0; i < n; i++) {
		char *newpath;

		newpath = calloc(1, PATH_MAX);
		if (!newpath)
			continue;
		snprintf(newpath, PATH_MAX, "%s/%s", syspath, parts[i]->d_name);
		free(parts[i]);
		if (is_partition(newpath)) {
			count += count_device_users(newpath);
		}
		free(newpath);
	}
	free(parts);
	return count;
}

static int blockdev_get_holders(char *syspath)
{
	char *path = NULL;
	struct dirent **holds = NULL;
	int n, i;
	int count = 0;

	path = calloc(1, PATH_MAX);
	if (!path)
		return 0;
	snprintf(path, PATH_MAX, "%s/holders", syspath);

	n = scandir(path, &holds, trans_filter, alphasort);
	for (i = 0; i < n; i++) {
		char *newpath;
		char *rp;

		newpath = calloc(1, PATH_MAX);
		if (!newpath)
			continue;
		snprintf(newpath, PATH_MAX, "%s/%s", path, holds[i]->d_name);

		free(holds[i]);
		rp = realpath(newpath, NULL);
		if (rp)
			count += count_device_users(rp);
		free(newpath);
		free(rp);
	}
	free(path);
	free(holds);
	return count;
}

static int count_device_users(char *syspath)
{
	int count = 0;
	count += blockdev_check_mnts(syspath);
	count += blockdev_get_partitions(syspath);
	count += blockdev_get_holders(syspath);
	return count;
};

static void device_in_use(void *data, int host_no, int target, int lun)
{
	char *syspath = NULL;
	char *devname = NULL;
	int *count = data;

	devname = iscsi_sysfs_get_blockdev_from_lun(host_no, target, lun);
	if (!devname)
		goto out;
	syspath = calloc(1, PATH_MAX);
	if (!syspath)
		goto out;
	snprintf(syspath, PATH_MAX, "/sys/class/block/%s", devname);
	*count += count_device_users(syspath);
out:
	free(syspath);
	free(devname);
}

int session_in_use(int sid)
{
	int host_no = -1, err = 0;
	int count = 0;

	if (libmount_init()) {
		log_error("Failed to initialize libmount, "
			  "not checking for active mounts on session [%d].", sid);
		return 0;
	}

	host_no = iscsi_sysfs_get_host_no_from_sid(sid, &err);
	if (!err)
		iscsi_sysfs_for_each_device(&count, host_no, sid, device_in_use);

	libmount_cleanup();
	return count;
}