xref: /onnv-gate/usr/src/uts/sun4v/io/platsvc.c (revision 12260:806de32452bd)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * sun4v Platform Services Module
 */

#include <sys/modctl.h>
#include <sys/cmn_err.h>
#include <sys/machsystm.h>
#include <sys/note.h>
#include <sys/uadmin.h>
#include <sys/ds.h>
#include <sys/platsvc.h>
#include <sys/ddi.h>
#include <sys/suspend.h>
#include <sys/proc.h>
#include <sys/disp.h>
#include <sys/drctl.h>

/*
 * Debugging routines
 */
#ifdef DEBUG
uint_t ps_debug = 0x0;
#define	DBG	if (ps_debug) printf
#else /* DEBUG */
#define	DBG	_NOTE(CONSTCOND) if (0) printf
#endif /* DEBUG */

/*
 * Time resolution conversions.
 */
#define	MS2NANO(x)	((x) * MICROSEC)
#define	MS2SEC(x)	((x) / MILLISEC)
#define	MS2MIN(x)	(MS2SEC(x) / 60)
#define	SEC2HZ(x)	(drv_usectohz((x) * MICROSEC))

/*
 * Domains Services interaction
 */
static ds_svc_hdl_t	ds_md_handle;
static ds_svc_hdl_t	ds_shutdown_handle;
static ds_svc_hdl_t	ds_panic_handle;
static ds_svc_hdl_t	ds_suspend_handle;

static ds_ver_t		ps_vers[] = {{ 1, 0 }};
#define	PS_NVERS	(sizeof (ps_vers) / sizeof (ps_vers[0]))

static ds_capability_t ps_md_cap = {
	"md-update",		/* svc_id */
	ps_vers,		/* vers */
	PS_NVERS		/* nvers */
};

static ds_capability_t ps_shutdown_cap = {
	"domain-shutdown",	/* svc_id */
	ps_vers,		/* vers */
	PS_NVERS		/* nvers */
};

static ds_capability_t ps_panic_cap = {
	"domain-panic",		/* svc_id */
	ps_vers,		/* vers */
	PS_NVERS		/* nvers */
};

static ds_capability_t ps_suspend_cap = {
	"domain-suspend",	/* svc_id */
	ps_vers,		/* vers */
	PS_NVERS		/* nvers */
};

static void ps_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl);
static void ps_unreg_handler(ds_cb_arg_t arg);

static void ps_md_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);
static void ps_shutdown_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);
static void ps_panic_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);
static void ps_suspend_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);

static ds_clnt_ops_t ps_md_ops = {
	ps_reg_handler,			/* ds_reg_cb */
	ps_unreg_handler,		/* ds_unreg_cb */
	ps_md_data_handler,		/* ds_data_cb */
	&ds_md_handle			/* cb_arg */
};

static ds_clnt_ops_t ps_shutdown_ops = {
	ps_reg_handler,			/* ds_reg_cb */
	ps_unreg_handler,		/* ds_unreg_cb */
	ps_shutdown_data_handler,	/* ds_data_cb */
	&ds_shutdown_handle		/* cb_arg */
};

static ds_clnt_ops_t ps_panic_ops = {
	ps_reg_handler,			/* ds_reg_cb */
	ps_unreg_handler,		/* ds_unreg_cb */
	ps_panic_data_handler,		/* ds_data_cb */
	&ds_panic_handle		/* cb_arg */
};

static ds_clnt_ops_t ps_suspend_ops = {
	ps_reg_handler,			/* ds_reg_cb */
	ps_unreg_handler,		/* ds_unreg_cb */
	ps_suspend_data_handler,	/* ds_data_cb */
	&ds_suspend_handle		/* cb_arg */
};

static int ps_init(void);
static void ps_fini(void);

/*
 * Power down timeout value of 5 minutes.
 */
#define	PLATSVC_POWERDOWN_DELAY		1200

/*
 * Set to true if OS suspend is supported. If OS suspend is not
 * supported, the suspend service will not be started.
 */
static boolean_t ps_suspend_enabled = B_FALSE;

/*
 * Suspend service request handling
 */
typedef struct ps_suspend_data {
	void		*buf;
	size_t		buflen;
} ps_suspend_data_t;

static kmutex_t ps_suspend_mutex;
static kcondvar_t ps_suspend_cv;

static ps_suspend_data_t *ps_suspend_data = NULL;
static boolean_t ps_suspend_thread_exit = B_FALSE;
static kthread_t *ps_suspend_thread = NULL;

static void ps_suspend_sequence(ps_suspend_data_t *data);
static void ps_suspend_thread_func(void);

/*
 * The DELAY timeout is the time (in seconds) to wait for the
 * suspend service to be re-registered after a suspend/resume
 * operation. The INTVAL time is the time (in seconds) to wait
 * between retry attempts when sending the post-suspend message
 * after a suspend/resume operation.
 */
#define	PLATSVC_SUSPEND_REREG_DELAY	60
#define	PLATSVC_SUSPEND_RETRY_INTVAL	1
static int ps_suspend_rereg_delay = PLATSVC_SUSPEND_REREG_DELAY;
static int ps_suspend_retry_intval = PLATSVC_SUSPEND_RETRY_INTVAL;


static struct modlmisc modlmisc = {
	&mod_miscops,
	"sun4v Platform Services"
};

static struct modlinkage modlinkage = {
	MODREV_1,
	(void *)&modlmisc,
	NULL
};

int
_init(void)
{
	int	rv;

	if ((rv = ps_init()) != 0)
		return (rv);

	if ((rv = mod_install(&modlinkage)) != 0)
		ps_fini();

	return (rv);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

int platsvc_allow_unload;

int
_fini(void)
{
	int	status;

	if (platsvc_allow_unload == 0)
		return (EBUSY);

	if ((status = mod_remove(&modlinkage)) == 0)
		ps_fini();

	return (status);
}

static int
ps_init(void)
{
	int	rv;
	extern int mdeg_init(void);
	extern void mdeg_fini(void);

	/* register with domain services framework */
	rv = ds_cap_init(&ps_md_cap, &ps_md_ops);
	if (rv != 0) {
		cmn_err(CE_WARN, "ds_cap_init md-update failed: %d", rv);
		return (rv);
	}

	rv = mdeg_init();
	if (rv != 0) {
		(void) ds_cap_fini(&ps_md_cap);
		return (rv);
	}

	rv = ds_cap_init(&ps_shutdown_cap, &ps_shutdown_ops);
	if (rv != 0) {
		cmn_err(CE_WARN, "ds_cap_init domain-shutdown failed: %d", rv);
		mdeg_fini();
		(void) ds_cap_fini(&ps_md_cap);
		return (rv);
	}

	rv = ds_cap_init(&ps_panic_cap, &ps_panic_ops);
	if (rv != 0) {
		cmn_err(CE_WARN, "ds_cap_init domain-panic failed: %d", rv);
		(void) ds_cap_fini(&ps_md_cap);
		mdeg_fini();
		(void) ds_cap_fini(&ps_shutdown_cap);
		return (rv);
	}

	ps_suspend_enabled = suspend_supported();

	if (ps_suspend_enabled) {
		mutex_init(&ps_suspend_mutex, NULL, MUTEX_DEFAULT, NULL);
		cv_init(&ps_suspend_cv, NULL, CV_DEFAULT, NULL);
		ps_suspend_thread_exit = B_FALSE;

		rv = ds_cap_init(&ps_suspend_cap, &ps_suspend_ops);
		if (rv != 0) {
			cmn_err(CE_WARN, "ds_cap_init domain-suspend failed: "
			    "%d", rv);
			(void) ds_cap_fini(&ps_md_cap);
			mdeg_fini();
			(void) ds_cap_fini(&ps_shutdown_cap);
			(void) ds_cap_fini(&ps_panic_cap);
			mutex_destroy(&ps_suspend_mutex);
			cv_destroy(&ps_suspend_cv);
			return (rv);
		}

		ps_suspend_thread = thread_create(NULL, 2 * DEFAULTSTKSZ,
		    ps_suspend_thread_func, NULL, 0, &p0, TS_RUN, minclsyspri);
	}

	return (0);
}

static void
ps_fini(void)
{
	extern void mdeg_fini(void);

	/*
	 * Stop incoming requests from Zeus
	 */
	(void) ds_cap_fini(&ps_md_cap);
	(void) ds_cap_fini(&ps_shutdown_cap);
	(void) ds_cap_fini(&ps_panic_cap);

	if (ps_suspend_enabled) {
		(void) ds_cap_fini(&ps_suspend_cap);
		if (ps_suspend_thread != NULL) {
			mutex_enter(&ps_suspend_mutex);
			ps_suspend_thread_exit = B_TRUE;
			cv_signal(&ps_suspend_cv);
			mutex_exit(&ps_suspend_mutex);

			thread_join(ps_suspend_thread->t_did);
			ps_suspend_thread = NULL;

			mutex_destroy(&ps_suspend_mutex);
			cv_destroy(&ps_suspend_cv);
		}
	}

	mdeg_fini();
}

static void
ps_md_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
	extern int mach_descrip_update(void);
	extern void mdeg_notify_clients(void);
	extern void recalc_xc_timeouts(void);

	ds_svc_hdl_t		 ds_handle = ds_md_handle;
	platsvc_md_update_req_t	 *msg = buf;
	platsvc_md_update_resp_t resp_msg;
	uint_t			 rv;

	if (arg == NULL)
		return;

	if (ds_handle == DS_INVALID_HDL) {
		DBG("ps_md_data_handler: DS handle no longer valid\n");
		return;
	}

	if (msg == NULL || buflen != sizeof (platsvc_md_update_req_t)) {
		resp_msg.req_num = 0;
		resp_msg.result = MD_UPDATE_INVALID_MSG;
		if ((rv = ds_cap_send(ds_handle, &resp_msg,
		    sizeof (resp_msg))) != 0) {
			cmn_err(CE_NOTE, "md ds_cap_send failed (%d)", rv);
		}
		return;
	}

	DBG("MD Reload...\n");
	if (mach_descrip_update()) {
		cmn_err(CE_WARN, "MD reload failed\n");
		return;
	}

	recalc_xc_timeouts();

	/*
	 * notify registered clients that MD has
	 * been updated
	 */
	mdeg_notify_clients();

	resp_msg.req_num = msg->req_num;
	resp_msg.result = MD_UPDATE_SUCCESS;
	if ((rv = ds_cap_send(ds_handle, &resp_msg, sizeof (resp_msg))) != 0) {
		cmn_err(CE_NOTE, "md ds_cap_send resp failed (%d)", rv);
	}
}

static void
ps_shutdown_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
	ds_svc_hdl_t		ds_handle = ds_shutdown_handle;
	platsvc_shutdown_req_t	*msg = buf;
	platsvc_shutdown_resp_t	resp_msg;
	uint_t			rv;
	hrtime_t		start;

	if (arg == NULL)
		return;

	if (ds_handle == DS_INVALID_HDL) {
		DBG("ps_shutdown_data_handler: DS handle no longer valid\n");
		return;
	}

	if (msg == NULL || buflen != sizeof (platsvc_shutdown_req_t)) {
		resp_msg.req_num = 0;
		resp_msg.result = DOMAIN_SHUTDOWN_INVALID_MSG;
		resp_msg.reason[0] = '\0';
		if ((rv = ds_cap_send(ds_handle, &resp_msg,
		    sizeof (resp_msg))) != 0) {
			cmn_err(CE_NOTE, "shutdown ds_cap_send failed (%d)",
			    rv);
		}
		return;
	}

	resp_msg.req_num = msg->req_num;
	resp_msg.result = DOMAIN_SHUTDOWN_SUCCESS;
	resp_msg.reason[0] = '\0';

	if ((rv = ds_cap_send(ds_handle, &resp_msg, sizeof (resp_msg))) != 0) {
		cmn_err(CE_NOTE, "shutdown ds_cap_send resp failed (%d)", rv);
	}

	/*
	 * Honor the ldoms manager's shutdown delay requirement.
	 */
	cmn_err(CE_NOTE, "shutdown requested by ldom manager, "
	    "system shutdown in %d minutes", MS2MIN(msg->delay));

	start = gethrtime();
	while (gethrtime() - start < MS2NANO(msg->delay))
		;

	(void) kadmin(A_SHUTDOWN, AD_POWEROFF, NULL, kcred);
}


static void
ps_panic_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
	ds_svc_hdl_t		ds_handle = ds_panic_handle;
	platsvc_panic_req_t	*msg = buf;
	platsvc_panic_resp_t	resp_msg;
	uint_t			rv;

	if (arg == NULL)
		return;

	if (ds_handle == DS_INVALID_HDL) {
		DBG("ps_panic_data_handler: DS handle no longer valid\n");
		return;
	}

	if (msg == NULL || buflen != sizeof (platsvc_panic_req_t)) {
		resp_msg.req_num = 0;
		resp_msg.result = DOMAIN_PANIC_INVALID_MSG;
		resp_msg.reason[0] = '\0';
		if ((rv = ds_cap_send(ds_handle, &resp_msg,
		    sizeof (resp_msg))) != 0) {
			cmn_err(CE_NOTE, "panic ds_cap_send resp failed (%d)",
			    rv);
		}
		return;
	}

	resp_msg.req_num = msg->req_num;
	resp_msg.result = DOMAIN_PANIC_SUCCESS;
	resp_msg.reason[0] = '\0';
	if ((rv = ds_cap_send(ds_handle, &resp_msg, sizeof (resp_msg))) != 0) {
		cmn_err(CE_NOTE, "panic ds_cap_send resp failed (%d)", rv);
	}

	cmn_err(CE_PANIC, "Panic forced by ldom manager");
	_NOTE(NOTREACHED)
}

/*
 * Send a suspend response message. If a timeout is specified, wait
 * intval seconds between attempts to send the message. The timeout
 * and intval arguments are in seconds.
 */
static void
ps_suspend_send_response(ds_svc_hdl_t *ds_handle, uint64_t req_num,
    uint32_t result, uint32_t rec_result, char *reason, int timeout,
    int intval)
{
	platsvc_suspend_resp_t	*resp;
	size_t			reason_length;
	int			tries = 0;
	int			rv = -1;
	time_t			deadline;

	if (reason == NULL) {
		reason_length = 0;
	} else {
		/* Get number of non-NULL bytes */
		reason_length = strnlen(reason, SUSPEND_MAX_REASON_SIZE - 1);
		ASSERT(reason[reason_length] == '\0');
		/* Account for NULL terminator */
		reason_length++;
	}

	resp = (platsvc_suspend_resp_t *)
	    kmem_zalloc(sizeof (platsvc_suspend_resp_t) + reason_length,
	    KM_SLEEP);

	resp->req_num = req_num;
	resp->result = result;
	resp->rec_result = rec_result;
	if (reason_length > 0) {
		bcopy(reason, &resp->reason, reason_length - 1);
		/* Ensure NULL terminator is present */
		resp->reason[reason_length] = '\0';
	}

	if (timeout == 0) {
		tries++;
		rv = ds_cap_send(*ds_handle, resp,
		    sizeof (platsvc_suspend_resp_t) + reason_length);
	} else {
		deadline = gethrestime_sec() + timeout;
		do {
			ds_svc_hdl_t hdl;
			/*
			 * Copy the handle so we can ensure we never pass
			 * an invalid handle to ds_cap_send. We don't want
			 * to trigger warning messages just because the
			 * service was temporarily unregistered.
			 */
			if ((hdl = *ds_handle) == DS_INVALID_HDL) {
				delay(SEC2HZ(intval));
			} else if ((rv = ds_cap_send(hdl, resp,
			    sizeof (platsvc_suspend_resp_t) +
			    reason_length)) != 0) {
				tries++;
				delay(SEC2HZ(intval));
			}
		} while ((rv != 0) && (gethrestime_sec() < deadline));
	}

	if (rv != 0) {
		cmn_err(CE_NOTE, "suspend ds_cap_send resp failed (%d) "
		    "sending message: %d, attempts: %d", rv, resp->result,
		    tries);
	}

	kmem_free(resp, sizeof (platsvc_suspend_resp_t) + reason_length);
}

/*
 * Handle data coming in for the suspend service. The suspend is
 * sequenced by the ps_suspend_thread, but perform some checks here
 * to make sure that the request is a valid request message and that
 * a suspend operation is not already in progress.
 */
/*ARGSUSED*/
static void
ps_suspend_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
	platsvc_suspend_req_t	*msg = buf;

	if (arg == NULL)
		return;

	if (ds_suspend_handle == DS_INVALID_HDL) {
		DBG("ps_suspend_data_handler: DS handle no longer valid\n");
		return;
	}

	/* Handle invalid requests */
	if (msg == NULL || buflen != sizeof (platsvc_suspend_req_t) ||
	    msg->type != DOMAIN_SUSPEND_SUSPEND) {
		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_INVALID_MSG, DOMAIN_SUSPEND_REC_SUCCESS,
		    NULL, 0, 0);
		return;
	}

	/*
	 * If ps_suspend_thread_exit is set, ds_cap_fini has been
	 * called and we shouldn't be receving data. Handle this unexpected
	 * case by returning without sending a response.
	 */
	if (ps_suspend_thread_exit) {
		DBG("ps_suspend_data_handler: ps_suspend_thread is exiting\n");
		return;
	}

	mutex_enter(&ps_suspend_mutex);

	/* If a suspend operation is in progress, abort now */
	if (ps_suspend_data != NULL) {
		mutex_exit(&ps_suspend_mutex);
		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_INPROGRESS, DOMAIN_SUSPEND_REC_SUCCESS,
		    NULL, 0, 0);
		return;
	}

	ps_suspend_data = kmem_alloc(sizeof (ps_suspend_data_t), KM_SLEEP);
	ps_suspend_data->buf = kmem_alloc(buflen, KM_SLEEP);
	ps_suspend_data->buflen = buflen;
	bcopy(buf, ps_suspend_data->buf, buflen);

	cv_signal(&ps_suspend_cv);
	mutex_exit(&ps_suspend_mutex);
}

/*
 * Schedule the suspend operation by calling the pre-suspend, suspend,
 * and post-suspend functions. When sending back response messages, we
 * only use a timeout for the post-suspend response because after
 * a resume, domain services will be re-registered and we may not
 * be able to send the response immediately.
 */
static void
ps_suspend_sequence(ps_suspend_data_t *data)
{
	platsvc_suspend_req_t	*msg;
	uint32_t		rec_result;
	char			*error_reason;
	boolean_t		recovered = B_TRUE;
	uint_t			rv = 0;
	int			dr_block;

	ASSERT(data != NULL);

	msg = data->buf;
	error_reason = (char *)kmem_zalloc(SUSPEND_MAX_REASON_SIZE, KM_SLEEP);

	/*
	 * Abort the suspend if a DR operation is in progress. Otherwise,
	 * continue whilst blocking any new DR operations.
	 */
	if ((dr_block = drctl_tryblock()) == 0) {
		/* Pre-suspend */
		rv = suspend_pre(error_reason, SUSPEND_MAX_REASON_SIZE,
		    &recovered);
	} else {
		/* A DR operation is in progress */
		(void) strncpy(error_reason, DOMAIN_SUSPEND_DR_ERROR_STR,
		    SUSPEND_MAX_REASON_SIZE);
	}

	if (dr_block != 0 || rv != 0) {
		rec_result = (recovered ? DOMAIN_SUSPEND_REC_SUCCESS :
		    DOMAIN_SUSPEND_REC_FAILURE);

		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_PRE_FAILURE, rec_result, error_reason, 0, 0);

		if (dr_block == 0)
			drctl_unblock();
		kmem_free(error_reason, SUSPEND_MAX_REASON_SIZE);
		return;
	}

	ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
	    DOMAIN_SUSPEND_PRE_SUCCESS, 0, NULL, 0, 0);

	/* Suspend */
	rv = suspend_start(error_reason, SUSPEND_MAX_REASON_SIZE);
	if (rv != 0) {
		rec_result = (suspend_post(NULL, 0) == 0 ?
		    DOMAIN_SUSPEND_REC_SUCCESS : DOMAIN_SUSPEND_REC_FAILURE);

		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_SUSPEND_FAILURE, rec_result, error_reason,
		    0, 0);

		drctl_unblock();
		kmem_free(error_reason, SUSPEND_MAX_REASON_SIZE);
		return;
	}

	/* Post-suspend */
	rv = suspend_post(error_reason, SUSPEND_MAX_REASON_SIZE);
	if (rv != 0) {
		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_POST_FAILURE, 0, error_reason,
		    ps_suspend_rereg_delay, ps_suspend_retry_intval);
	} else {
		ps_suspend_send_response(&ds_suspend_handle, msg->req_num,
		    DOMAIN_SUSPEND_POST_SUCCESS, 0, error_reason,
		    ps_suspend_rereg_delay, ps_suspend_retry_intval);
	}

	drctl_unblock();
	kmem_free(error_reason, SUSPEND_MAX_REASON_SIZE);
}

/*
 * Wait for a suspend request or for ps_suspend_thread_exit to be set.
 */
static void
ps_suspend_thread_func(void)
{
	mutex_enter(&ps_suspend_mutex);

	while (ps_suspend_thread_exit == B_FALSE) {

		if (ps_suspend_data == NULL) {
			cv_wait(&ps_suspend_cv, &ps_suspend_mutex);
			continue;
		}

		mutex_exit(&ps_suspend_mutex);
		ps_suspend_sequence(ps_suspend_data);
		mutex_enter(&ps_suspend_mutex);

		kmem_free(ps_suspend_data->buf, ps_suspend_data->buflen);
		kmem_free(ps_suspend_data, sizeof (ps_suspend_data_t));
		ps_suspend_data = NULL;
	}

	mutex_exit(&ps_suspend_mutex);

	thread_exit();
}

static void
ps_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
{
	DBG("ps_reg_handler: arg=0x%p, ver=%d.%d, hdl=0x%lx\n",
	    arg, ver->major, ver->minor, hdl);

	if ((ds_svc_hdl_t *)arg == &ds_md_handle)
		ds_md_handle = hdl;
	if ((ds_svc_hdl_t *)arg == &ds_shutdown_handle)
		ds_shutdown_handle = hdl;
	if ((ds_svc_hdl_t *)arg == &ds_panic_handle)
		ds_panic_handle = hdl;
	if ((ds_svc_hdl_t *)arg == &ds_suspend_handle)
		ds_suspend_handle = hdl;
}

static void
ps_unreg_handler(ds_cb_arg_t arg)
{
	DBG("ps_unreg_handler: arg=0x%p\n", arg);

	if ((ds_svc_hdl_t *)arg == &ds_md_handle)
		ds_md_handle = DS_INVALID_HDL;
	if ((ds_svc_hdl_t *)arg == &ds_shutdown_handle)
		ds_shutdown_handle = DS_INVALID_HDL;
	if ((ds_svc_hdl_t *)arg == &ds_panic_handle)
		ds_panic_handle = DS_INVALID_HDL;
	if ((ds_svc_hdl_t *)arg == &ds_suspend_handle)
		ds_suspend_handle = DS_INVALID_HDL;
}