PSARC 2008/208 Flexible Credentials for Kernel Door Upcalls

6667255 dlmgmtd door commands do not check caller credentials

14 files changed, 407 insertions, 649 deletions

diff --git a/usr/src/cmd/dlmgmtd/dlmgmt_db.c b/usr/src/cmd/dlmgmtd/dlmgmt_db.c
index d805ab0788..013deaf388 100644
--- a/usr/src/cmd/dlmgmtd/dlmgmt_db.c
+++ b/usr/src/cmd/dlmgmtd/dlmgmt_db.c
@@ -196,11 +196,11 @@ write_uint64(char *buffer, size_t buffer_length, char *name, void *value)
 static size_t
 read_str(char *buffer, void **value)
 {
-	char		*ptr = calloc(MAXLINKATTRLEN, sizeof (char));
+	char		*ptr = calloc(MAXLINKATTRVALLEN, sizeof (char));
 	ssize_t		len;
 
-	if (ptr == NULL || (len = snprintf(ptr, MAXLINKATTRLEN, "%s", buffer))
-	    >= MAXLINKATTRLEN) {
+	if (ptr == NULL || (len = strlcpy(ptr, buffer, MAXLINKATTRVALLEN))
+	    >= MAXLINKATTRVALLEN) {
 		free(ptr);
 		return (0);
 	}
diff --git a/usr/src/cmd/dlmgmtd/dlmgmt_door.c b/usr/src/cmd/dlmgmtd/dlmgmt_door.c
index a4c0de808e..1481d0dfa3 100644
--- a/usr/src/cmd/dlmgmtd/dlmgmt_door.c
+++ b/usr/src/cmd/dlmgmtd/dlmgmt_door.c
@@ -29,17 +29,29 @@
 /*
  * Main door handler functions used by dlmgmtd to process the different door
  * call requests. Door call requests can come from the user-land applications,
- * which will be handled by dlmgmt_call_handler(); or they can come from the
- * kernel, which will be handled by dlmgmt_upcall_handler().
+ * or from the kernel.
  */
 
 #include <assert.h>
-#include <stdlib.h>
 #include <alloca.h>
+#include <errno.h>
+#include <priv_utils.h>
+#include <stdlib.h>
 #include <strings.h>
 #include <libdlmgmt.h>
 #include "dlmgmt_impl.h"
 
+typedef void dlmgmt_door_handler_t(void *, void *);
+
+typedef struct dlmgmt_door_info_s {
+	uint_t			di_cmd;
+	boolean_t		di_set;
+	size_t			di_reqsz;
+	size_t			di_acksz;
+	dlmgmt_door_handler_t	*di_handler;
+} dlmgmt_door_info_t;
+
+
 static dlmgmt_link_t *
 dlmgmt_getlink_by_dev(char *devname)
 {
@@ -56,9 +68,10 @@ dlmgmt_getlink_by_dev(char *devname)
 }
 
 static void
-dlmgmt_upcall_create(dlmgmt_upcall_arg_create_t *create,
-    dlmgmt_create_retval_t *retvalp)
+dlmgmt_upcall_create(void *argp, void *retp)
 {
+	dlmgmt_upcall_arg_create_t *create = argp;
+	dlmgmt_create_retval_t	*retvalp = retp;
 	datalink_class_t	class;
 	uint32_t		media;
 	dlmgmt_link_t		*linkp;
@@ -157,12 +170,13 @@ done:
 }
 
 static void
-dlmgmt_upcall_update(dlmgmt_upcall_arg_update_t *update,
-    dlmgmt_update_retval_t *retvalp)
+dlmgmt_upcall_update(void *argp, void *retp)
 {
-	uint32_t	media = update->ld_media;
-	dlmgmt_link_t	*linkp;
-	int		err = 0;
+	dlmgmt_upcall_arg_update_t	*update = argp;
+	dlmgmt_update_retval_t		*retvalp = retp;
+	uint32_t			media = update->ld_media;
+	dlmgmt_link_t			*linkp;
+	int				err = 0;
 
 	/*
 	 * Hold the writer lock to update the link table.
@@ -224,13 +238,14 @@ done:
 }
 
 static void
-dlmgmt_upcall_destroy(dlmgmt_upcall_arg_destroy_t *destroy,
-    dlmgmt_destroy_retval_t *retvalp)
+dlmgmt_upcall_destroy(void *argp, void *retp)
 {
-	datalink_id_t	linkid = destroy->ld_linkid;
-	dlmgmt_link_t	*linkp = NULL;
-	uint32_t	flags, dflags = 0;
-	int		err = 0;
+	dlmgmt_upcall_arg_destroy_t	*destroy = argp;
+	dlmgmt_destroy_retval_t		*retvalp = retp;
+	datalink_id_t			linkid = destroy->ld_linkid;
+	dlmgmt_link_t			*linkp = NULL;
+	uint32_t			flags, dflags = 0;
+	int				err = 0;
 
 	flags = DLMGMT_ACTIVE | (destroy->ld_persist ? DLMGMT_PERSIST : 0);
 
@@ -267,10 +282,12 @@ done:
 }
 
 static void
-dlmgmt_getname(dlmgmt_door_getname_t *getname, dlmgmt_getname_retval_t *retvalp)
+dlmgmt_getname(void *argp, void *retp)
 {
-	dlmgmt_link_t	*linkp;
-	int		err = 0;
+	dlmgmt_door_getname_t	*getname = argp;
+	dlmgmt_getname_retval_t	*retvalp = retp;
+	dlmgmt_link_t		*linkp;
+	int			err = 0;
 
 	/*
 	 * Hold the reader lock to access the link
@@ -299,11 +316,12 @@ done:
 }
 
 static void
-dlmgmt_getlinkid(dlmgmt_door_getlinkid_t *getlinkid,
-    dlmgmt_getlinkid_retval_t *retvalp)
+dlmgmt_getlinkid(void *argp, void *retp)
 {
-	dlmgmt_link_t	*linkp;
-	int		err = 0;
+	dlmgmt_door_getlinkid_t	*getlinkid = argp;
+	dlmgmt_getlinkid_retval_t *retvalp = retp;
+	dlmgmt_link_t		*linkp;
+	int			err = 0;
 
 	/*
 	 * Hold the reader lock to access the link
@@ -328,12 +346,14 @@ done:
 }
 
 static void
-dlmgmt_getnext(dlmgmt_door_getnext_t *getnext, dlmgmt_getnext_retval_t *retvalp)
+dlmgmt_getnext(void *argp, void *retp)
 {
-	dlmgmt_link_t	link, *linkp;
-	datalink_id_t	linkid = getnext->ld_linkid;
-	avl_index_t	where;
-	int		err = 0;
+	dlmgmt_door_getnext_t	*getnext = argp;
+	dlmgmt_getnext_retval_t	*retvalp = retp;
+	dlmgmt_link_t		link, *linkp;
+	datalink_id_t		linkid = getnext->ld_linkid;
+	avl_index_t		where;
+	int			err = 0;
 
 	/*
 	 * Hold the reader lock to access the link
@@ -366,16 +386,12 @@ dlmgmt_getnext(dlmgmt_door_getnext_t *getnext, dlmgmt_getnext_retval_t *retvalp)
 	retvalp->lr_err = err;
 }
 
-/*
- * Note that the caller needs to free the memory of *retvalp, when it returns
- * success.
- */
-static int
-dlmgmt_upcall_getattr(dlmgmt_upcall_arg_getattr_t *getattr,
-    dlmgmt_getattr_retval_t **retvalpp, size_t *retszp)
+static void
+dlmgmt_upcall_getattr(void *argp, void *retp)
 {
-	dlmgmt_link_t	*linkp;
-	int		err = 0;
+	dlmgmt_upcall_arg_getattr_t	*getattr = argp;
+	dlmgmt_getattr_retval_t		*retvalp = retp;
+	dlmgmt_link_t			*linkp;
 
 	/*
 	 * Hold the reader lock to access the link
@@ -385,108 +401,25 @@ dlmgmt_upcall_getattr(dlmgmt_upcall_arg_getattr_t *getattr,
 		/*
 		 * The link does not exist.
 		 */
-		err = ENOENT;
+		retvalp->lr_err = ENOENT;
 		goto done;
 	}
 
-	err = dlmgmt_getattr_common(&linkp->ll_head, getattr->ld_attr,
-	    retvalpp, retszp);
+	dlmgmt_getattr_common(&linkp->ll_head, getattr->ld_attr, retvalp);
 
 done:
 	dlmgmt_table_unlock();
-	return (err);
-}
-
-static void
-dlmgmt_upcall_handler(void *arg, int cmd)
-{
-	switch (cmd) {
-	case DLMGMT_CMD_DLS_CREATE: {
-		dlmgmt_create_retval_t retval;
-
-		dlmgmt_upcall_create(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_DLS_UPDATE: {
-		dlmgmt_update_retval_t retval;
-
-		dlmgmt_upcall_update(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_DLS_GETATTR: {
-		dlmgmt_getattr_retval_t retval;
-		dlmgmt_getattr_retval_t *retvalp = NULL;
-		dlmgmt_getattr_retval_t *tmp;
-		size_t retsz = 0;
-		int err;
-
-		if ((err = dlmgmt_upcall_getattr(arg, &retvalp, &retsz)) != 0) {
-			retval.lr_err = err;
-			retvalp = &retval;
-			retsz = sizeof (retval);
-		} else {
-			/*
-			 * For the successful case, retvalp points to
-			 * memory that was allocated with malloc.  But, since
-			 * door_return never returns, that memory gets leaked.
-			 * Use alloca and free retvalp.
-			 */
-			tmp = alloca(retsz);
-			bcopy(retvalp, tmp, retsz);
-			free(retvalp);
-			retvalp = tmp;
-		}
-		(void) door_return((char *)retvalp, retsz, NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_DLS_DESTROY: {
-		dlmgmt_destroy_retval_t retval;
-
-		dlmgmt_upcall_destroy(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_GETNAME: {
-		dlmgmt_getname_retval_t retval;
-
-		dlmgmt_getname(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_GETLINKID: {
-		dlmgmt_getlinkid_retval_t retval;
-
-		dlmgmt_getlinkid(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_GETNEXT: {
-		dlmgmt_getnext_retval_t retval;
-
-		dlmgmt_getnext(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	default: {
-		struct dlmgmt_null_retval_s retval;
-
-		retval.lr_err = EINVAL;
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	}
 }
 
 static void
-dlmgmt_createid(dlmgmt_door_createid_t *createid,
-    dlmgmt_createid_retval_t *retvalp)
+dlmgmt_createid(void *argp, void *retp)
 {
-	dlmgmt_link_t	*linkp;
-	datalink_id_t	linkid = DATALINK_INVALID_LINKID;
-	char		link[MAXLINKNAMELEN];
-	int		err;
+	dlmgmt_door_createid_t	*createid = argp;
+	dlmgmt_createid_retval_t *retvalp = retp;
+	dlmgmt_link_t		*linkp;
+	datalink_id_t		linkid = DATALINK_INVALID_LINKID;
+	char			link[MAXLINKNAMELEN];
+	int			err;
 
 	/*
 	 * Hold the writer lock to update the dlconf table.
@@ -523,13 +456,14 @@ done:
 }
 
 static void
-dlmgmt_destroyid(dlmgmt_door_destroyid_t *destroyid,
-    dlmgmt_destroyid_retval_t *retvalp)
+dlmgmt_destroyid(void *argp, void *retp)
 {
-	datalink_id_t	linkid = destroyid->ld_linkid;
-	uint32_t	flags = destroyid->ld_flags;
-	dlmgmt_link_t	*linkp = NULL;
-	int		err = 0;
+	dlmgmt_door_destroyid_t	*destroyid = argp;
+	dlmgmt_destroyid_retval_t *retvalp = retp;
+	datalink_id_t		linkid = destroyid->ld_linkid;
+	uint32_t		flags = destroyid->ld_flags;
+	dlmgmt_link_t		*linkp = NULL;
+	int			err = 0;
 
 	/*
 	 * Hold the writer lock to update the link table.
@@ -560,13 +494,14 @@ done:
  * the given link name.
  */
 static void
-dlmgmt_remapid(dlmgmt_door_remapid_t *remapid,
-    dlmgmt_remapid_retval_t *retvalp)
+dlmgmt_remapid(void *argp, void *retp)
 {
-	datalink_id_t	linkid1 = remapid->ld_linkid;
-	dlmgmt_link_t	link, *linkp1, *tmp;
-	avl_index_t	where;
-	int		err = 0;
+	dlmgmt_door_remapid_t	*remapid = argp;
+	dlmgmt_remapid_retval_t	*retvalp = retp;
+	datalink_id_t		linkid1 = remapid->ld_linkid;
+	dlmgmt_link_t		link, *linkp1, *tmp;
+	avl_index_t		where;
+	int			err = 0;
 
 	if (!dladm_valid_linkname(remapid->ld_link)) {
 		retvalp->lr_err = EINVAL;
@@ -606,10 +541,12 @@ done:
 }
 
 static void
-dlmgmt_upid(dlmgmt_door_upid_t *upid, dlmgmt_upid_retval_t *retvalp)
+dlmgmt_upid(void *argp, void *retp)
 {
-	dlmgmt_link_t	*linkp;
-	int		err = 0;
+	dlmgmt_door_upid_t	*upid = argp;
+	dlmgmt_upid_retval_t	*retvalp = retp;
+	dlmgmt_link_t		*linkp;
+	int			err = 0;
 
 	/*
 	 * Hold the writer lock to update the link table.
@@ -633,12 +570,13 @@ done:
 }
 
 static void
-dlmgmt_createconf(dlmgmt_door_createconf_t *createconf,
-    dlmgmt_createconf_retval_t *retvalp)
+dlmgmt_createconf(void *argp, void *retp)
 {
-	dlmgmt_dlconf_t	dlconf, *dlconfp, *tmp;
-	avl_index_t	where;
-	int		err;
+	dlmgmt_door_createconf_t *createconf = argp;
+	dlmgmt_createconf_retval_t *retvalp = retp;
+	dlmgmt_dlconf_t		dlconf, *dlconfp, *tmp;
+	avl_index_t		where;
+	int			err;
 
 	/*
 	 * Hold the writer lock to update the dlconf table.
@@ -663,17 +601,12 @@ done:
 }
 
 static void
-dlmgmt_setattr(dlmgmt_door_setattr_t *setattr, size_t argsz,
-    dlmgmt_setattr_retval_t *retvalp)
+dlmgmt_setattr(void *argp, void *retp)
 {
-	dlmgmt_dlconf_t	dlconf, *dlconfp;
-	int		err = 0;
-
-	if (argsz < sizeof (dlmgmt_door_setattr_t) ||
-	    argsz != sizeof (dlmgmt_door_setattr_t) + setattr->ld_attrsz - 1) {
-		retvalp->lr_err = EINVAL;
-		return;
-	}
+	dlmgmt_door_setattr_t	*setattr = argp;
+	dlmgmt_setattr_retval_t	*retvalp = retp;
+	dlmgmt_dlconf_t		dlconf, *dlconfp;
+	int			err = 0;
 
 	/*
 	 * Hold the writer lock to update the dlconf table.
@@ -696,11 +629,12 @@ done:
 }
 
 static void
-dlmgmt_unsetattr(dlmgmt_door_unsetattr_t *unsetattr,
-    dlmgmt_unsetattr_retval_t *retvalp)
+dlmgmt_unsetconfattr(void *argp, void *retp)
 {
-	dlmgmt_dlconf_t	dlconf, *dlconfp;
-	int		err = 0;
+	dlmgmt_door_unsetattr_t	*unsetattr = argp;
+	dlmgmt_unsetattr_retval_t *retvalp = retp;
+	dlmgmt_dlconf_t		dlconf, *dlconfp;
+	int			err = 0;
 
 	/*
 	 * Hold the writer lock to update the dlconf table.
@@ -734,9 +668,10 @@ done:
  * across the pair of dladm_read_conf() and dladm_write_conf() calls.
  */
 static void
-dlmgmt_writeconf(dlmgmt_door_writeconf_t *writeconf,
-    dlmgmt_writeconf_retval_t *retvalp)
+dlmgmt_writeconf(void *argp, void *retp)
 {
+	dlmgmt_door_writeconf_t	*writeconf = argp;
+	dlmgmt_writeconf_retval_t *retvalp = retp;
 	dlmgmt_dlconf_t		dlconf, *dlconfp;
 	dlmgmt_link_t		*linkp;
 	dlmgmt_linkattr_t	*attrp, *next;
@@ -809,10 +744,11 @@ done:
 }
 
 static void
-dlmgmt_removeconf(dlmgmt_door_removeconf_t *removeconf,
-    dlmgmt_removeconf_retval_t *retvalp)
+dlmgmt_removeconf(void *argp, void *retp)
 {
-	int err;
+	dlmgmt_door_removeconf_t 	*removeconf = argp;
+	dlmgmt_removeconf_retval_t	*retvalp = retp;
+	int				err;
 
 	dlmgmt_table_lock(B_TRUE);
 	err = dlmgmt_delete_db_entry(removeconf->ld_linkid, DLMGMT_PERSIST);
@@ -821,11 +757,12 @@ dlmgmt_removeconf(dlmgmt_door_removeconf_t *removeconf,
 }
 
 static void
-dlmgmt_destroyconf(dlmgmt_door_destroyconf_t *destroyconf,
-    dlmgmt_destroyconf_retval_t *retvalp)
+dlmgmt_destroyconf(void *argp, void *retp)
 {
-	dlmgmt_dlconf_t	dlconf, *dlconfp;
-	int		err = 0;
+	dlmgmt_door_destroyconf_t	*destroyconf = argp;
+	dlmgmt_destroyconf_retval_t	*retvalp = retp;
+	dlmgmt_dlconf_t			dlconf, *dlconfp;
+	int				err = 0;
 
 	/*
 	 * Hold the writer lock to update the dlconf table.
@@ -852,9 +789,10 @@ done:
  * ensure atomicity across the {dlmgmt_readconf(), dlmgmt_writeconf()} pair.
  */
 static void
-dlmgmt_readconf(dlmgmt_door_readconf_t *readconf,
-    dlmgmt_readconf_retval_t *retvalp)
+dlmgmt_readconf(void *argp, void *retp)
 {
+	dlmgmt_door_readconf_t	*readconf = argp;
+	dlmgmt_readconf_retval_t *retvalp = retp;
 	dlmgmt_link_t 		*linkp;
 	datalink_id_t		linkid = readconf->ld_linkid;
 	dlmgmt_dlconf_t		*dlconfp, *tmp, dlconf;
@@ -910,166 +848,126 @@ done:
 /*
  * Note: the caller must free *retvalpp in case of success.
  */
-static int
-dlmgmt_getattr(dlmgmt_door_getattr_t *getattr,
-    dlmgmt_getattr_retval_t **retvalpp, size_t *retszp)
+static void
+dlmgmt_getattr(void *argp, void *retp)
 {
+	dlmgmt_door_getattr_t	*getattr = argp;
+	dlmgmt_getattr_retval_t	*retvalp = retp;
 	dlmgmt_dlconf_t		dlconf, *dlconfp;
-	int			err = 0;
 
 	/*
-	 * Hold the writer lock to update the dlconf table.
+	 * Hold the read lock to access the dlconf table.
 	 */
 	dlmgmt_dlconf_table_lock(B_FALSE);
 
 	dlconf.ld_id = (int)getattr->ld_conf;
 	dlconfp = avl_find(&dlmgmt_dlconf_avl, &dlconf, NULL);
 	if (dlconfp == NULL) {
-		err = ENOENT;
+		retvalp->lr_err = ENOENT;
 		goto done;
 	}
 
-	err = dlmgmt_getattr_common(&dlconfp->ld_head, getattr->ld_attr,
-	    retvalpp, retszp);
+	dlmgmt_getattr_common(&dlconfp->ld_head, getattr->ld_attr, retvalp);
 
 done:
 	dlmgmt_dlconf_table_unlock();
-	return (err);
 }
 
-static void
-dlmgmt_call_handler(void *arg, size_t argsz, int cmd)
-{
-	switch (cmd) {
-	case DLMGMT_CMD_CREATE_LINKID: {
-		dlmgmt_createid_retval_t retval;
-
-		dlmgmt_createid(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_DESTROY_LINKID: {
-		dlmgmt_destroyid_retval_t retval;
-
-		dlmgmt_destroyid(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_REMAP_LINKID: {
-		dlmgmt_remapid_retval_t retval;
-
-		dlmgmt_remapid(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_UP_LINKID: {
-		dlmgmt_upid_retval_t retval;
-
-		dlmgmt_upid(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_CREATECONF: {
-		dlmgmt_createconf_retval_t retval;
+static dlmgmt_door_info_t i_dlmgmt_door_info_tbl[] = {
+	{ DLMGMT_CMD_DLS_CREATE, B_TRUE, sizeof (dlmgmt_upcall_arg_create_t),
+	    sizeof (dlmgmt_create_retval_t), dlmgmt_upcall_create },
+	{ DLMGMT_CMD_DLS_GETATTR, B_FALSE, sizeof (dlmgmt_upcall_arg_getattr_t),
+	    sizeof (dlmgmt_getattr_retval_t), dlmgmt_upcall_getattr },
+	{ DLMGMT_CMD_DLS_DESTROY, B_TRUE, sizeof (dlmgmt_upcall_arg_destroy_t),
+	    sizeof (dlmgmt_destroy_retval_t), dlmgmt_upcall_destroy },
+	{ DLMGMT_CMD_GETNAME, B_FALSE, sizeof (dlmgmt_door_getname_t),
+	    sizeof (dlmgmt_getname_retval_t), dlmgmt_getname },
+	{ DLMGMT_CMD_GETLINKID,	B_FALSE, sizeof (dlmgmt_door_getlinkid_t),
+	    sizeof (dlmgmt_getlinkid_retval_t), dlmgmt_getlinkid },
+	{ DLMGMT_CMD_GETNEXT, B_FALSE, sizeof (dlmgmt_door_getnext_t),
+	    sizeof (dlmgmt_getnext_retval_t), dlmgmt_getnext },
+	{ DLMGMT_CMD_DLS_UPDATE, B_TRUE, sizeof (dlmgmt_upcall_arg_update_t),
+	    sizeof (dlmgmt_update_retval_t), dlmgmt_upcall_update },
+	{ DLMGMT_CMD_CREATE_LINKID, B_TRUE, sizeof (dlmgmt_door_createid_t),
+	    sizeof (dlmgmt_createid_retval_t), dlmgmt_createid },
+	{ DLMGMT_CMD_DESTROY_LINKID, B_TRUE, sizeof (dlmgmt_door_destroyid_t),
+	    sizeof (dlmgmt_destroyid_retval_t), dlmgmt_destroyid },
+	{ DLMGMT_CMD_REMAP_LINKID, B_TRUE, sizeof (dlmgmt_door_remapid_t),
+	    sizeof (dlmgmt_remapid_retval_t), dlmgmt_remapid },
+	{ DLMGMT_CMD_CREATECONF, B_TRUE, sizeof (dlmgmt_door_createconf_t),
+	    sizeof (dlmgmt_createconf_retval_t), dlmgmt_createconf },
+	{ DLMGMT_CMD_READCONF, B_FALSE, sizeof (dlmgmt_door_readconf_t),
+	    sizeof (dlmgmt_readconf_retval_t), dlmgmt_readconf },
+	{ DLMGMT_CMD_WRITECONF, B_TRUE, sizeof (dlmgmt_door_writeconf_t),
+	    sizeof (dlmgmt_writeconf_retval_t), dlmgmt_writeconf },
+	{ DLMGMT_CMD_UP_LINKID, B_TRUE, sizeof (dlmgmt_door_upid_t),
+	    sizeof (dlmgmt_upid_retval_t), dlmgmt_upid },
+	{ DLMGMT_CMD_SETATTR, B_TRUE, sizeof (dlmgmt_door_setattr_t),
+	    sizeof (dlmgmt_setattr_retval_t), dlmgmt_setattr },
+	{ DLMGMT_CMD_UNSETATTR, B_TRUE, sizeof (dlmgmt_door_unsetattr_t),
+	    sizeof (dlmgmt_unsetattr_retval_t), dlmgmt_unsetconfattr },
+	{ DLMGMT_CMD_REMOVECONF, B_TRUE, sizeof (dlmgmt_door_removeconf_t),
+	    sizeof (dlmgmt_removeconf_retval_t), dlmgmt_removeconf },
+	{ DLMGMT_CMD_DESTROYCONF, B_TRUE, sizeof (dlmgmt_door_destroyconf_t),
+	    sizeof (dlmgmt_destroyconf_retval_t), dlmgmt_destroyconf },
+	{ DLMGMT_CMD_GETATTR, B_FALSE, sizeof (dlmgmt_door_getattr_t),
+	    sizeof (dlmgmt_getattr_retval_t), dlmgmt_getattr }
+};
+
+#define	DLMGMT_INFO_TABLE_SIZE	(sizeof (i_dlmgmt_door_info_tbl) /	\
+    sizeof (i_dlmgmt_door_info_tbl[0]))
 
-		dlmgmt_createconf(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_SETATTR: {
-		dlmgmt_setattr_retval_t retval;
-
-		dlmgmt_setattr(arg, argsz, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_UNSETATTR: {
-		dlmgmt_unsetattr_retval_t retval;
-
-		dlmgmt_unsetattr(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_WRITECONF: {
-		dlmgmt_writeconf_retval_t retval;
+/* ARGSUSED */
+void
+dlmgmt_handler(void *cookie, char *argp, size_t argsz, door_desc_t *dp,
+    uint_t n_desc)
+{
+	dlmgmt_door_info_t	*infop = NULL;
+	dlmgmt_retval_t		retval;
+	void			*retvalp;
+	int			err;
+	int			i;
 
-		dlmgmt_writeconf(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
+	for (i = 0; i < DLMGMT_INFO_TABLE_SIZE; i++) {
+		if (i_dlmgmt_door_info_tbl[i].di_cmd ==
+		    ((dlmgmt_door_arg_t *)(void *)argp)->ld_cmd) {
+			infop = i_dlmgmt_door_info_tbl + i;
+			break;
+		}
 	}
-	case DLMGMT_CMD_REMOVECONF: {
-		dlmgmt_removeconf_retval_t retval;
 
-		dlmgmt_removeconf(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
+	if (infop == NULL || argsz != infop->di_reqsz) {
+		err = EINVAL;
+		goto fail;
 	}
-	case DLMGMT_CMD_DESTROYCONF: {
-		dlmgmt_destroyconf_retval_t retval;
 
-		dlmgmt_destroyconf(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_READCONF: {
-		dlmgmt_readconf_retval_t retval;
+	if (infop->di_set) {
+		ucred_t	*cred = NULL;
+		const priv_set_t *eset;
 
-		dlmgmt_readconf(arg, &retval);
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
-	case DLMGMT_CMD_GETATTR: {
-		dlmgmt_getattr_retval_t retval;
-		dlmgmt_getattr_retval_t *retvalp = NULL;
-		dlmgmt_getattr_retval_t *tmp;
-		int err;
-		size_t retsz = 0;
-
-		if ((err = dlmgmt_getattr(arg, &retvalp, &retsz)) != 0) {
-			retval.lr_err = err;
-			retvalp = &retval;
-			retsz = sizeof (retval);
-		} else {
-			/*
-			 * For the successful case, retvalp points to memory
-			 * that was allocated in dlmgmt_getattr().  Since
-			 * door_return never returns, that memory would get
-			 * leaked. So we use alloca instead, and free retvalp.
-			 */
-			tmp = alloca(retsz);
-			bcopy(retvalp, tmp, retsz);
-			free(retvalp);
-			retvalp = tmp;
+		if (door_ucred(&cred) != 0) {
+			err = errno;
+			goto fail;
 		}
-		(void) door_return((char *)retvalp, retsz, NULL, 0);
-		break;
-	}
-	default: {
-		struct dlmgmt_null_retval_s retval;
 
-		retval.lr_err = EINVAL;
-		(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
-		break;
-	}
+		eset = ucred_getprivset(cred, PRIV_EFFECTIVE);
+		if (eset == NULL || !priv_ismember(eset, PRIV_SYS_NET_CONFIG)) {
+			ucred_free(cred);
+			err = EACCES;
+			goto fail;
+		}
 	}
-}
 
-/* ARGSUSED */
-void
-dlmgmt_handler(void *cookie, char *argp, size_t argsz, door_desc_t *dp,
-    uint_t n_desc)
-{
-	int cmd = ((dlmgmt_door_arg_t *)(void *)argp)->ld_cmd;
-
-	if (cmd < DLMGMT_CMD_BASE) {
-		/*
-		 * Upcall request from the dls module.
-		 */
-		dlmgmt_upcall_handler(argp, cmd);
-	} else {
-		/*
-		 * Door call request from libdladm.
-		 */
-		dlmgmt_call_handler(argp, argsz, cmd);
-	}
+	/*
+	 * We cannot use malloc() here because door_return never returns, and
+	 * memory allocated by malloc() would get leaked. Use alloca() instead.
+	 */
+	retvalp = alloca(infop->di_acksz);
+	infop->di_handler(argp, retvalp);
+	(void) door_return(retvalp, infop->di_acksz, NULL, 0);
+	return;
+
+fail:
+	retval.lr_err = err;
+	(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
 }
diff --git a/usr/src/cmd/dlmgmtd/dlmgmt_impl.h b/usr/src/cmd/dlmgmtd/dlmgmt_impl.h
index 92fb82459b..b8a9258102 100644
--- a/usr/src/cmd/dlmgmtd/dlmgmt_impl.h
+++ b/usr/src/cmd/dlmgmtd/dlmgmt_impl.h
@@ -102,8 +102,8 @@ dlmgmt_link_t	*link_by_name(const char *);
 int		dlmgmt_create_common(const char *, datalink_class_t,
 		    uint32_t, uint32_t, dlmgmt_link_t **);
 int		dlmgmt_destroy_common(dlmgmt_link_t *, uint32_t);
-int		dlmgmt_getattr_common(dlmgmt_linkattr_t **, const char *,
-		    dlmgmt_getattr_retval_t **, size_t *);
+void		dlmgmt_getattr_common(dlmgmt_linkattr_t **, const char *,
+		    dlmgmt_getattr_retval_t *);
 
 void		dlmgmt_advance(dlmgmt_link_t *);
 void		dlmgmt_table_lock(boolean_t);
diff --git a/usr/src/cmd/dlmgmtd/dlmgmt_util.c b/usr/src/cmd/dlmgmtd/dlmgmt_util.c
index 06416db018..ce41103dc4 100644
--- a/usr/src/cmd/dlmgmtd/dlmgmt_util.c
+++ b/usr/src/cmd/dlmgmtd/dlmgmt_util.c
@@ -473,30 +473,30 @@ dlmgmt_destroy_common(dlmgmt_link_t *linkp, uint32_t flags)
 	return (0);
 }
 
-int
+void
 dlmgmt_getattr_common(dlmgmt_linkattr_t **headp, const char *attr,
-    dlmgmt_getattr_retval_t **retvalpp, size_t *retszp)
+    dlmgmt_getattr_retval_t *retvalp)
 {
 	int			err;
 	void			*attrval;
 	size_t			attrsz;
 	dladm_datatype_t	attrtype;
-	dlmgmt_getattr_retval_t	*retvalp;
 
 	err = linkattr_get(headp, attr, &attrval, &attrsz, &attrtype);
 	if (err != 0)
-		return (err);
+		goto done;
 
 	assert(attrsz > 0);
-	*retszp = sizeof (dlmgmt_getattr_retval_t) + attrsz - 1;
-	if ((retvalp = malloc(*retszp)) == NULL)
-		return (ENOMEM);
+	if (attrsz > MAXLINKATTRVALLEN) {
+		err = EINVAL;
+		goto done;
+	}
 
-	retvalp->lr_err = 0;
 	retvalp->lr_type = attrtype;
-	bcopy(attrval, retvalp->lr_attr, attrsz);
-	*retvalpp = retvalp;
-	return (0);
+	retvalp->lr_attrsz = attrsz;
+	bcopy(attrval, retvalp->lr_attrval, attrsz);
+done:
+	retvalp->lr_err = err;
 }
 
 void
diff --git a/usr/src/lib/libdladm/common/libdlmgmt.c b/usr/src/lib/libdladm/common/libdlmgmt.c
index 1826edf810..79932c7bde 100644
--- a/usr/src/lib/libdladm/common/libdlmgmt.c
+++ b/usr/src/lib/libdladm/common/libdlmgmt.c
@@ -52,10 +52,9 @@ static size_t dladm_datatype_size[] = {
 };
 
 static dladm_status_t
-dladm_door_call(void *arg, size_t asize, void *rbuf, size_t *rsizep)
+dladm_door_call(void *arg, size_t asize, void *rbuf, size_t rsize)
 {
 	door_arg_t	darg;
-	dlmgmt_retval_t	*retvalp = rbuf;
 	int		fd;
 	dladm_status_t	status = DLADM_STATUS_OK;
 
@@ -67,7 +66,7 @@ dladm_door_call(void *arg, size_t asize, void *rbuf, size_t *rsizep)
 	darg.desc_ptr	= NULL;
 	darg.desc_num	= 0;
 	darg.rbuf	= rbuf;
-	darg.rsize	= *rsizep;
+	darg.rsize	= rsize;
 
 	if (door_call(fd, &darg) == -1)
 		status = dladm_errno2status(errno);
@@ -85,14 +84,10 @@ dladm_door_call(void *arg, size_t asize, void *rbuf, size_t *rsizep)
 		(void) munmap(darg.rbuf, darg.rsize);
 		return (DLADM_STATUS_TOOSMALL);
 	}
-	if (darg.rsize > *rsizep || darg.rsize < sizeof (uint_t))
+	if (darg.rsize != rsize)
 		return (DLADM_STATUS_FAILED);
 
-	if (retvalp->lr_err != 0)
-		status = dladm_errno2status(retvalp->lr_err);
-	else
-		*rsizep = darg.rsize;
-	return (status);
+	return (dladm_errno2status(((dlmgmt_retval_t *)rbuf)->lr_err));
 }
 
 /*
@@ -102,13 +97,12 @@ dladm_status_t
 dladm_create_datalink_id(const char *link, datalink_class_t class,
     uint32_t media, uint32_t flags, datalink_id_t *linkidp)
 {
-	dlmgmt_door_createid_t createid;
+	dlmgmt_door_createid_t	createid;
 	dlmgmt_createid_retval_t retval;
-	uint32_t dlmgmt_flags;
-	dladm_status_t status;
-	size_t rsize;
+	uint32_t		dlmgmt_flags;
+	dladm_status_t		status;
 
-	if (link == NULL || *link == '\0' || class == DATALINK_CLASS_ALL ||
+	if (link == NULL || class == DATALINK_CLASS_ALL ||
 	    !(flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST)) ||
 	    linkidp == NULL) {
 		return (DLADM_STATUS_BADARG);
@@ -123,17 +117,12 @@ dladm_create_datalink_id(const char *link, datalink_class_t class,
 	createid.ld_flags = dlmgmt_flags;
 	createid.ld_cmd = DLMGMT_CMD_CREATE_LINKID;
 	createid.ld_prefix = (flags & DLADM_OPT_PREFIX);
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&createid, sizeof (createid), &retval, &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
 
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	*linkidp = retval.lr_linkid;
-	return (DLADM_STATUS_OK);
+	if ((status = dladm_door_call(&createid, sizeof (createid), &retval,
+	    sizeof (retval))) == DLADM_STATUS_OK) {
+		*linkidp = retval.lr_linkid;
+	}
+	return (status);
 }
 
 /*
@@ -145,8 +134,6 @@ dladm_destroy_datalink_id(datalink_id_t linkid, uint32_t flags)
 	dlmgmt_door_destroyid_t		destroyid;
 	dlmgmt_destroyid_retval_t	retval;
 	uint32_t			dlmgmt_flags;
-	size_t				rsize;
-	dladm_status_t			status;
 
 	dlmgmt_flags = (flags & DLADM_OPT_ACTIVE) ? DLMGMT_ACTIVE : 0;
 	dlmgmt_flags |= ((flags & DLADM_OPT_PERSIST) ? DLMGMT_PERSIST : 0);
@@ -154,17 +141,9 @@ dladm_destroy_datalink_id(datalink_id_t linkid, uint32_t flags)
 	destroyid.ld_cmd = DLMGMT_CMD_DESTROY_LINKID;
 	destroyid.ld_linkid = linkid;
 	destroyid.ld_flags = dlmgmt_flags;
-	rsize = sizeof (retval);
 
-	status = dladm_door_call(&destroyid, sizeof (destroyid), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&destroyid, sizeof (destroyid),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -175,22 +154,13 @@ dladm_remap_datalink_id(datalink_id_t linkid, const char *link)
 {
 	dlmgmt_door_remapid_t	remapid;
 	dlmgmt_remapid_retval_t	retval;
-	size_t			rsize;
-	dladm_status_t		status;
 
 	remapid.ld_cmd = DLMGMT_CMD_REMAP_LINKID;
 	remapid.ld_linkid = linkid;
 	(void) strlcpy(remapid.ld_link, link, MAXLINKNAMELEN);
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&remapid, sizeof (remapid), &retval, &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
 
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&remapid, sizeof (remapid),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -199,23 +169,14 @@ dladm_remap_datalink_id(datalink_id_t linkid, const char *link)
 dladm_status_t
 dladm_up_datalink_id(datalink_id_t linkid)
 {
-	dlmgmt_door_upid_t		upid;
-	dlmgmt_upid_retval_t		retval;
-	size_t				rsize;
-	dladm_status_t			status;
+	dlmgmt_door_upid_t	upid;
+	dlmgmt_upid_retval_t	retval;
 
 	upid.ld_cmd = DLMGMT_CMD_UP_LINKID;
 	upid.ld_linkid = linkid;
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&upid, sizeof (upid), &retval, &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
 
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&upid, sizeof (upid),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -225,12 +186,11 @@ dladm_status_t
 dladm_create_conf(const char *link, datalink_id_t linkid,
     datalink_class_t class, uint32_t media, dladm_conf_t *confp)
 {
-	dlmgmt_door_createconf_t createconf;
-	dlmgmt_createconf_retval_t retval;
-	dladm_status_t status;
-	size_t rsize;
+	dlmgmt_door_createconf_t	createconf;
+	dlmgmt_createconf_retval_t	retval;
+	dladm_status_t			status;
 
-	if (link == NULL || *link == '\0' || confp == NULL)
+	if (link == NULL || confp == NULL)
 		return (DLADM_STATUS_BADARG);
 
 	(void) strlcpy(createconf.ld_link, link, MAXLINKNAMELEN);
@@ -238,18 +198,12 @@ dladm_create_conf(const char *link, datalink_id_t linkid,
 	createconf.ld_media = media;
 	createconf.ld_linkid = linkid;
 	createconf.ld_cmd = DLMGMT_CMD_CREATECONF;
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&createconf, sizeof (createconf), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
 
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	*confp = retval.lr_conf;
-	return (DLADM_STATUS_OK);
+	if ((status = dladm_door_call(&createconf, sizeof (createconf),
+	    &retval, sizeof (retval))) == DLADM_STATUS_OK) {
+		*confp = retval.lr_conf;
+	}
+	return (status);
 }
 
 /*
@@ -292,7 +246,6 @@ dladm_walk_datalink_id(int (*fn)(datalink_id_t, void *), void *argp,
 	dlmgmt_door_getnext_t	getnext;
 	dlmgmt_getnext_retval_t	retval;
 	uint32_t 		dlmgmt_flags;
-	size_t			rsize;
 	datalink_id_t		linkid = DATALINK_INVALID_LINKID;
 	dladm_status_t		status = DLADM_STATUS_OK;
 
@@ -306,24 +259,17 @@ dladm_walk_datalink_id(int (*fn)(datalink_id_t, void *), void *argp,
 	getnext.ld_class = class;
 	getnext.ld_dmedia = dmedia;
 	getnext.ld_flags = dlmgmt_flags;
-	rsize = sizeof (retval);
 
 	do {
 		getnext.ld_linkid = linkid;
-		status = dladm_door_call(&getnext, sizeof (getnext),
-		    &retval, &rsize);
-		if (status != DLADM_STATUS_OK) {
+		if ((status = dladm_door_call(&getnext, sizeof (getnext),
+		    &retval, sizeof (retval))) != DLADM_STATUS_OK) {
 			/*
 			 * done with walking
 			 */
 			break;
 		}
 
-		if (rsize != sizeof (retval)) {
-			status = DLADM_STATUS_BADARG;
-			break;
-		}
-
 		linkid = retval.lr_linkid;
 		if ((retval.lr_class == DATALINK_CLASS_PHYS) &&
 		    (retval.lr_flags & DLMGMT_ACTIVE)) {
@@ -354,28 +300,21 @@ dladm_walk_datalink_id(int (*fn)(datalink_id_t, void *), void *argp,
 dladm_status_t
 dladm_read_conf(datalink_id_t linkid, dladm_conf_t *confp)
 {
-	dlmgmt_door_readconf_t 		readconf;
+	dlmgmt_door_readconf_t		readconf;
 	dlmgmt_readconf_retval_t	retval;
 	dladm_status_t			status;
-	size_t				rsize;
 
 	if (linkid == DATALINK_INVALID_LINKID || confp == NULL)
 		return (DLADM_STATUS_BADARG);
 
 	readconf.ld_linkid = linkid;
 	readconf.ld_cmd = DLMGMT_CMD_READCONF;
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&readconf, sizeof (readconf), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
 
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	*confp = retval.lr_conf;
-	return (DLADM_STATUS_OK);
+	if ((status = dladm_door_call(&readconf, sizeof (readconf),
+	    &retval, sizeof (retval))) == DLADM_STATUS_OK) {
+		*confp = retval.lr_conf;
+	}
+	return (status);
 }
 
 /*
@@ -387,25 +326,15 @@ dladm_write_conf(dladm_conf_t conf)
 {
 	dlmgmt_door_writeconf_t		writeconf;
 	dlmgmt_writeconf_retval_t	retval;
-	dladm_status_t			status;
-	size_t				rsize;
 
 	if (conf == DLADM_INVALID_CONF)
 		return (DLADM_STATUS_BADARG);
 
 	writeconf.ld_cmd = DLMGMT_CMD_WRITECONF;
 	writeconf.ld_conf = conf;
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(&writeconf, sizeof (writeconf), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
 
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&writeconf, sizeof (writeconf),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -416,13 +345,12 @@ dladm_status_t
 dladm_get_conf_field(dladm_conf_t conf, const char *attr, void *attrval,
     size_t attrsz)
 {
-	dlmgmt_door_getattr_t getattr;
-	dlmgmt_getattr_retval_t *retvalp;
-	dladm_status_t status = DLADM_STATUS_OK;
-	size_t oldsize, size;
+	dlmgmt_door_getattr_t	getattr;
+	dlmgmt_getattr_retval_t	retval;
+	dladm_status_t		status;
 
 	if (conf == DLADM_INVALID_CONF || attrval == NULL ||
-	    attrsz == 0 || attr == NULL || *attr == '\0') {
+	    attrsz == 0 || attr == NULL) {
 		return (DLADM_STATUS_BADARG);
 	}
 
@@ -430,20 +358,16 @@ dladm_get_conf_field(dladm_conf_t conf, const char *attr, void *attrval,
 	getattr.ld_conf = conf;
 	(void) strlcpy(getattr.ld_attr, attr, MAXLINKATTRLEN);
 
-	oldsize = size = attrsz + sizeof (dlmgmt_getattr_retval_t) - 1;
-	if ((retvalp = calloc(1, oldsize)) == NULL)
-		return (DLADM_STATUS_NOMEM);
+	if ((status = dladm_door_call(&getattr, sizeof (getattr), &retval,
+	    sizeof (retval))) != DLADM_STATUS_OK) {
+		return (status);
+	}
 
-	status = dladm_door_call(&getattr, sizeof (getattr), retvalp, &size);
-	if (status != DLADM_STATUS_OK)
-		goto done;
+	if (retval.lr_attrsz > attrsz)
+		return (DLADM_STATUS_TOOSMALL);
 
-	assert(size <= oldsize);
-	size = size + 1 - sizeof (dlmgmt_getattr_retval_t);
-	bcopy(retvalp->lr_attr, attrval, size);
-done:
-	free(retvalp);
-	return (status);
+	bcopy(retval.lr_attrval, attrval, retval.lr_attrsz);
+	return (DLADM_STATUS_OK);
 }
 
 /*
@@ -456,20 +380,15 @@ dladm_name2info(const char *link, datalink_id_t *linkidp, uint32_t *flagp,
 	dlmgmt_door_getlinkid_t		getlinkid;
 	dlmgmt_getlinkid_retval_t	retval;
 	datalink_id_t			linkid;
-	size_t				rsize;
 	dladm_status_t			status;
 
 	getlinkid.ld_cmd = DLMGMT_CMD_GETLINKID;
 	(void) strlcpy(getlinkid.ld_link, link, MAXLINKNAMELEN);
-	rsize = sizeof (retval);
 
-	status = dladm_door_call(&getlinkid, sizeof (getlinkid), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
+	if ((status = dladm_door_call(&getlinkid, sizeof (getlinkid),
+	    &retval, sizeof (retval))) != DLADM_STATUS_OK) {
 		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
+	}
 
 	linkid = retval.lr_linkid;
 	if (retval.lr_class == DATALINK_CLASS_PHYS &&
@@ -505,10 +424,9 @@ dladm_status_t
 dladm_datalink_id2info(datalink_id_t linkid, uint32_t *flagp,
     datalink_class_t *classp, uint32_t *mediap, char *link, size_t len)
 {
-	dlmgmt_door_getname_t		getname;
-	dlmgmt_getname_retval_t		retval;
-	size_t				rsize;
-	dladm_status_t			status;
+	dlmgmt_door_getname_t	getname;
+	dlmgmt_getname_retval_t	retval;
+	dladm_status_t		status;
 
 	if ((linkid == DATALINK_INVALID_LINKID) || (link != NULL && len == 0) ||
 	    (link == NULL && len != 0)) {
@@ -517,15 +435,13 @@ dladm_datalink_id2info(datalink_id_t linkid, uint32_t *flagp,
 
 	getname.ld_cmd = DLMGMT_CMD_GETNAME;
 	getname.ld_linkid = linkid;
-	rsize = sizeof (retval);
-	status = dladm_door_call(&getname, sizeof (getname), &retval, &rsize);
-	if (status != DLADM_STATUS_OK)
+	if ((status = dladm_door_call(&getname, sizeof (getname), &retval,
+	    sizeof (retval))) != DLADM_STATUS_OK) {
 		return (status);
+	}
 
-	if ((rsize != sizeof (retval)) ||
-	    (len != 0 && (strlen(retval.lr_link) + 1 > len))) {
+	if (len != 0 && (strlen(retval.lr_link) + 1 > len))
 		return (DLADM_STATUS_TOOSMALL);
-	}
 
 	if (retval.lr_class == DATALINK_CLASS_PHYS &&
 	    retval.lr_flags & DLMGMT_ACTIVE) {
@@ -560,12 +476,11 @@ dladm_status_t
 dladm_set_conf_field(dladm_conf_t conf, const char *attr,
     dladm_datatype_t type, const void *attrval)
 {
-	dlmgmt_door_setattr_t		*setattrp;
-	dlmgmt_setattr_retval_t		retval;
-	dladm_status_t			status;
-	size_t				asize, attrsz, rsize;
+	dlmgmt_door_setattr_t	setattr;
+	dlmgmt_setattr_retval_t	retval;
+	size_t			attrsz;
 
-	if (attr == NULL || attr == '\0' || attrval == NULL)
+	if (attr == NULL || attrval == NULL)
 		return (DLADM_STATUS_BADARG);
 
 	if (type == DLADM_TYPE_STR)
@@ -573,28 +488,18 @@ dladm_set_conf_field(dladm_conf_t conf, const char *attr,
 	else
 		attrsz = dladm_datatype_size[type];
 
-	asize = sizeof (dlmgmt_door_setattr_t) + attrsz - 1;
-	if ((setattrp = calloc(1, asize)) == NULL)
-		return (DLADM_STATUS_NOMEM);
-
-	setattrp->ld_cmd = DLMGMT_CMD_SETATTR;
-	setattrp->ld_conf = conf;
-	(void) strlcpy(setattrp->ld_attr, attr, MAXLINKATTRLEN);
-	setattrp->ld_attrsz = attrsz;
-	setattrp->ld_type = type;
-	bcopy(attrval, &setattrp->ld_attrval, attrsz);
-	rsize = sizeof (retval);
-
-	status = dladm_door_call(setattrp, asize, &retval, &rsize);
-	if (status != DLADM_STATUS_OK)
-		goto done;
+	if (attrsz > MAXLINKATTRVALLEN)
+		return (DLADM_STATUS_TOOSMALL);
 
-	if (rsize != sizeof (retval))
-		status = DLADM_STATUS_BADARG;
+	setattr.ld_cmd = DLMGMT_CMD_SETATTR;
+	setattr.ld_conf = conf;
+	(void) strlcpy(setattr.ld_attr, attr, MAXLINKATTRLEN);
+	setattr.ld_attrsz = attrsz;
+	setattr.ld_type = type;
+	bcopy(attrval, &setattr.ld_attrval, attrsz);
 
-done:
-	free(setattrp);
-	return (status);
+	return (dladm_door_call(&setattr, sizeof (setattr),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -605,26 +510,16 @@ dladm_unset_conf_field(dladm_conf_t conf, const char *attr)
 {
 	dlmgmt_door_unsetattr_t		unsetattr;
 	dlmgmt_unsetattr_retval_t	retval;
-	dladm_status_t			status;
-	size_t				rsize;
 
-	if (attr == NULL || attr == '\0')
+	if (attr == NULL)
 		return (DLADM_STATUS_BADARG);
 
 	unsetattr.ld_cmd = DLMGMT_CMD_UNSETATTR;
 	unsetattr.ld_conf = conf;
 	(void) strlcpy(unsetattr.ld_attr, attr, MAXLINKATTRLEN);
-	rsize = sizeof (retval);
 
-	status = dladm_door_call(&unsetattr, sizeof (unsetattr), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&unsetattr, sizeof (unsetattr),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -636,22 +531,12 @@ dladm_remove_conf(datalink_id_t linkid)
 {
 	dlmgmt_door_removeconf_t	removeconf;
 	dlmgmt_removeconf_retval_t	retval;
-	size_t				rsize;
-	dladm_status_t			status;
 
 	removeconf.ld_cmd = DLMGMT_CMD_REMOVECONF;
 	removeconf.ld_linkid = linkid;
-	rsize = sizeof (retval);
 
-	status = dladm_door_call(&removeconf, sizeof (removeconf), &retval,
-	    &rsize);
-	if (status != DLADM_STATUS_OK)
-		return (status);
-
-	if (rsize != sizeof (retval))
-		return (DLADM_STATUS_BADARG);
-
-	return (DLADM_STATUS_OK);
+	return (dladm_door_call(&removeconf, sizeof (removeconf),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -662,15 +547,13 @@ dladm_destroy_conf(dladm_conf_t conf)
 {
 	dlmgmt_door_destroyconf_t	destroyconf;
 	dlmgmt_destroyconf_retval_t	retval;
-	size_t				rsize;
 
 	if (conf == DLADM_INVALID_CONF)
 		return;
 
 	destroyconf.ld_cmd = DLMGMT_CMD_DESTROYCONF;
 	destroyconf.ld_conf = conf;
-	rsize = sizeof (retval);
 
-	(void) dladm_door_call(&destroyconf, sizeof (destroyconf), &retval,
-	    &rsize);
+	(void) dladm_door_call(&destroyconf, sizeof (destroyconf),
+	    &retval, sizeof (retval));
 }
diff --git a/usr/src/lib/libdladm/common/libdlmgmt.h b/usr/src/lib/libdladm/common/libdlmgmt.h
index 0459d7360b..3b02299be7 100644
--- a/usr/src/lib/libdladm/common/libdlmgmt.h
+++ b/usr/src/lib/libdladm/common/libdlmgmt.h
@@ -100,7 +100,7 @@ typedef struct dlmgmt_door_setattr_s {
 	char			ld_attr[MAXLINKATTRLEN];
 	size_t			ld_attrsz;
 	dladm_datatype_t	ld_type;
-	char			ld_attrval[1];
+	char			ld_attrval[MAXLINKATTRVALLEN];
 } dlmgmt_door_setattr_t;
 
 typedef struct dlmgmt_door_unsetattr_s {
@@ -135,63 +135,22 @@ typedef struct dlmgmt_door_getattr_s {
 	char		ld_attr[MAXLINKATTRLEN];
 } dlmgmt_door_getattr_t;
 
-typedef union dlmgmt_door_arg_s {
-	int				ld_cmd;
-	dlmgmt_upcall_arg_create_t	kcreate;
-	dlmgmt_upcall_arg_destroy_t	kdestroy;
-	dlmgmt_upcall_arg_getattr_t	kgetattr;
-	dlmgmt_door_getlinkid_t		getlinkid;
-	dlmgmt_door_getnext_t		getnext;
-	dlmgmt_door_createid_t		createid;
-	dlmgmt_door_destroyid_t		destroyid;
-	dlmgmt_door_remapid_t		remapid;
-	dlmgmt_door_upid_t		upid;
-	dlmgmt_door_createconf_t	createconf;
-	dlmgmt_door_getname_t		getname;
-	dlmgmt_door_getattr_t		getattr;
-	dlmgmt_door_setattr_t		setattr;
-	dlmgmt_door_writeconf_t		writeconf;
-	dlmgmt_door_removeconf_t	removeconf;
-	dlmgmt_door_destroyconf_t	destroyconf;
-	dlmgmt_door_readconf_t		readconf;
-} dlmgmt_door_arg_t;
-
 typedef struct dlmgmt_handle_retval_s {
 	uint_t			lr_err;
 	dladm_conf_t		lr_conf;
 } dlmgmt_createconf_retval_t, dlmgmt_readconf_retval_t;
 
-typedef struct dlmgmt_null_retval_s	dlmgmt_remapid_retval_t,
-	dlmgmt_upid_retval_t,
-	dlmgmt_destroyid_retval_t,
-	dlmgmt_setattr_retval_t,
-	dlmgmt_unsetattr_retval_t,
-	dlmgmt_writeconf_retval_t,
-	dlmgmt_removeconf_retval_t,
-	dlmgmt_destroyconf_retval_t;
+typedef struct dlmgmt_retval_s	dlmgmt_remapid_retval_t,
+				dlmgmt_upid_retval_t,
+				dlmgmt_destroyid_retval_t,
+				dlmgmt_setattr_retval_t,
+				dlmgmt_unsetattr_retval_t,
+				dlmgmt_writeconf_retval_t,
+				dlmgmt_removeconf_retval_t,
+				dlmgmt_destroyconf_retval_t;
 
 typedef struct dlmgmt_linkid_retval_s	dlmgmt_createid_retval_t;
 
-typedef union dlmgmt_retval {
-	uint_t				lr_err; /* return error code */
-	dlmgmt_create_retval_t		kcreate;
-	dlmgmt_destroy_retval_t		kdestroy;
-	dlmgmt_getattr_retval_t		getattr;
-	dlmgmt_getname_retval_t		getname;
-	dlmgmt_getlinkid_retval_t	getlinkid;
-	dlmgmt_getnext_retval_t		getnext;
-	dlmgmt_createid_retval_t	createid;
-	dlmgmt_destroyid_retval_t	destroyid;
-	dlmgmt_remapid_retval_t		remapid;
-	dlmgmt_upid_retval_t		upid;
-	dlmgmt_createconf_retval_t	createconf;
-	dlmgmt_readconf_retval_t	readconf;
-	dlmgmt_setattr_retval_t		setattr;
-	dlmgmt_writeconf_retval_t	writeconf;
-	dlmgmt_removeconf_retval_t	removeconf;
-	dlmgmt_destroyconf_retval_t	destroyconf;
-} dlmgmt_retval_t;
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/usr/src/uts/common/c2/audit_io.c b/usr/src/uts/common/c2/audit_io.c
index e498dcdd58..d18a9c9d6a 100644
--- a/usr/src/uts/common/c2/audit_io.c
+++ b/usr/src/uts/common/c2/audit_io.c
@@ -537,7 +537,8 @@ au_door_upcall(au_kcontext_t *kctx, au_dbuf_t *aubuf)
 
 		retry = 0;
 		mutex_enter(&(kctx->auk_svc_lock));
-		if ((rc = door_upcall(kctx->auk_current_vp, &darg)) != 0) {
+		rc = door_upcall(kctx->auk_current_vp, &darg, NULL);
+		if (rc != 0) {
 			mutex_exit(&(kctx->auk_svc_lock));
 			if (rc == EAGAIN)
 				ticks_to_wait = AGAIN_TICKS;
diff --git a/usr/src/uts/common/fs/doorfs/door_sys.c b/usr/src/uts/common/fs/doorfs/door_sys.c
index 15aadeb415..bfb941f326 100644
--- a/usr/src/uts/common/fs/doorfs/door_sys.c
+++ b/usr/src/uts/common/fs/doorfs/door_sys.c
@@ -1639,10 +1639,18 @@ door_ucred(struct ucred_s *uch)
 	DOOR_T_HOLD(ct);
 	mutex_exit(&door_knob);
 
-	/* Get the credentials of the calling process */
 	p = ttoproc(caller);
 
-	res = pgetucred(p);
+	/*
+	 * If the credentials are not specified by the client, get the one
+	 * associated with the calling process.
+	 */
+	if (ct->d_cred == NULL) {
+		res = pgetucred(p);
+	} else {
+		res = cred2ucred(ct->d_cred, ct->d_upcall ?
+		    p0.p_pid : p->p_pid, NULL, CRED());
+	}
 
 	mutex_enter(&door_knob);
 	DOOR_T_RELEASE(ct);
@@ -2114,7 +2122,7 @@ door_unref(void)
 		dp->door_flags |= DOOR_UNREF_ACTIVE;
 		mutex_exit(&door_knob);
 
-		(void) door_upcall(DTOV(dp), &unref_args);
+		(void) door_upcall(DTOV(dp), &unref_args, NULL);
 
 		mutex_enter(&door_knob);
 		ASSERT(dp->door_flags & DOOR_UNREF_ACTIVE);
@@ -3005,10 +3013,11 @@ door_copy(struct as *as, caddr_t src, caddr_t dest, uint_t len)
  *	in the event of an error, and passed without duplication
  *	otherwise.  Note that param->rbuf must be 64-bit aligned in
  *	a 64-bit kernel, since it may be used to store door descriptors
- *	if they are returned by the server.
+ *	if they are returned by the server.  The caller is responsible
+ *	for holding a reference to the cred passed in.
  */
 int
-door_upcall(vnode_t *vp, door_arg_t *param)
+door_upcall(vnode_t *vp, door_arg_t *param, struct cred *cred)
 {
 	/* Locals */
 	door_node_t	*dp;
@@ -3096,6 +3105,7 @@ door_upcall(vnode_t *vp, door_arg_t *param)
 	}
 
 	ct->d_upcall = 1;
+	ct->d_cred = cred;
 	if (param->rsize == 0)
 		ct->d_noresults = 1;
 	else
@@ -3253,6 +3263,7 @@ out:
 		ct->d_fpp_size = 0;
 	}
 
+	ct->d_cred = NULL;
 	ct->d_upcall = 0;
 	ct->d_noresults = 0;
 	ct->d_buf = NULL;
@@ -3304,17 +3315,29 @@ door_list_delete(door_node_t *dp)
  */
 
 /*
- * door_ki_upcall invokes a user-level door server from the kernel.
+ * door_ki_upcall invokes a user-level door server from the kernel, with
+ * the credentials associated with curthread.
  */
 int
 door_ki_upcall(door_handle_t dh, door_arg_t *param)
 {
+	return (door_ki_upcall_cred(dh, param, NULL));
+}
+
+/*
+ * door_ki_upcall_cred invokes a user-level door server from the kernel with
+ * the given credentials. If the "cred" argument is NULL, uses the credentials
+ * associated with current thread.
+ */
+int
+door_ki_upcall_cred(door_handle_t dh, door_arg_t *param, struct cred *cred)
+{
 	file_t *fp = DHTOF(dh);
 	vnode_t *realvp;
 
 	if (VOP_REALVP(fp->f_vnode, &realvp, NULL))
 		realvp = fp->f_vnode;
-	return (door_upcall(realvp, param));
+	return (door_upcall(realvp, param, cred));
 }
 
 /*
diff --git a/usr/src/uts/common/io/dls/dls_mgmt.c b/usr/src/uts/common/io/dls/dls_mgmt.c
index aff6ba26b1..7a753b2341 100644
--- a/usr/src/uts/common/io/dls/dls_mgmt.c
+++ b/usr/src/uts/common/io/dls/dls_mgmt.c
@@ -200,12 +200,11 @@ i_dls_mgmt_door_revoked(door_handle_t dh)
  * Upcall to the datalink management daemon (dlmgmtd).
  */
 static int
-i_dls_mgmt_upcall(void *arg, size_t asize, void *rbuf, size_t *rsizep)
+i_dls_mgmt_upcall(void *arg, size_t asize, void *rbuf, size_t rsize)
 {
 	door_arg_t			darg, save_arg;
-	struct dlmgmt_null_retval_s	*retvalp;
 	door_handle_t			dh;
-	int				err = EINVAL;
+	int				err;
 	int				retry = 0;
 
 #define	MAXRETRYNUM	3
@@ -216,7 +215,7 @@ i_dls_mgmt_upcall(void *arg, size_t asize, void *rbuf, size_t *rsizep)
 	darg.desc_ptr = NULL;
 	darg.desc_num = 0;
 	darg.rbuf = rbuf;
-	darg.rsize = *rsizep;
+	darg.rsize = rsize;
 	save_arg = darg;
 
 retry:
@@ -231,7 +230,7 @@ retry:
 
 	for (;;) {
 		retry++;
-		if ((err = door_ki_upcall(dh, &darg)) == 0)
+		if ((err = door_ki_upcall_cred(dh, &darg, kcred)) == 0)
 			break;
 
 		/*
@@ -283,19 +282,12 @@ retry:
 		goto done;
 	}
 
-	if (darg.rsize > *rsizep || darg.rsize < sizeof (uint_t)) {
+	if (darg.rsize != rsize) {
 		err = EINVAL;
 		goto done;
 	}
 
-	/* LINTED E_BAD_PTR_CAST_ALIGN */
-	retvalp = (struct dlmgmt_null_retval_s *)darg.rbuf;
-	if (retvalp->lr_err != 0) {
-		err = retvalp->lr_err;
-		goto done;
-	}
-
-	*rsizep = darg.rsize;
+	err = ((dlmgmt_retval_t *)rbuf)->lr_err;
 
 done:
 	door_ki_rele(dh);
@@ -322,7 +314,6 @@ dls_mgmt_create(const char *devname, dev_t dev, datalink_class_t class,
 {
 	dlmgmt_upcall_arg_create_t	create;
 	dlmgmt_create_retval_t		retval;
-	size_t				rsize;
 	int				err;
 
 	create.ld_cmd = DLMGMT_CMD_DLS_CREATE;
@@ -334,11 +325,10 @@ dls_mgmt_create(const char *devname, dev_t dev, datalink_class_t class,
 	if (strlcpy(create.ld_devname, devname, MAXNAMELEN) >= MAXNAMELEN)
 		return (EINVAL);
 
-	rsize = sizeof (retval);
-
-	err = i_dls_mgmt_upcall(&create, sizeof (create), &retval, &rsize);
-	if (err == 0)
+	if ((err = i_dls_mgmt_upcall(&create, sizeof (create), &retval,
+	    sizeof (retval))) == 0) {
 		*linkidp = retval.lr_linkid;
+	}
 	return (err);
 }
 
@@ -351,14 +341,13 @@ dls_mgmt_destroy(datalink_id_t linkid, boolean_t persist)
 {
 	dlmgmt_upcall_arg_destroy_t	destroy;
 	dlmgmt_destroy_retval_t		retval;
-	size_t				rsize;
 
 	destroy.ld_cmd = DLMGMT_CMD_DLS_DESTROY;
 	destroy.ld_linkid = linkid;
 	destroy.ld_persist = persist;
-	rsize = sizeof (retval);
 
-	return (i_dls_mgmt_upcall(&destroy, sizeof (destroy), &retval, &rsize));
+	return (i_dls_mgmt_upcall(&destroy, sizeof (destroy),
+	    &retval, sizeof (retval)));
 }
 
 /*
@@ -383,7 +372,6 @@ dls_mgmt_update(const char *devname, uint32_t media, boolean_t novanity,
 {
 	dlmgmt_upcall_arg_update_t	update;
 	dlmgmt_update_retval_t		retval;
-	size_t				rsize;
 	int				err;
 
 	update.ld_cmd = DLMGMT_CMD_DLS_UPDATE;
@@ -393,10 +381,9 @@ dls_mgmt_update(const char *devname, uint32_t media, boolean_t novanity,
 
 	update.ld_media = media;
 	update.ld_novanity = novanity;
-	rsize = sizeof (retval);
 
-	err = i_dls_mgmt_upcall(&update, sizeof (update), &retval, &rsize);
-	if (err == EEXIST) {
+	if ((err = i_dls_mgmt_upcall(&update, sizeof (update), &retval,
+	    sizeof (retval))) == EEXIST) {
 		*linkidp = retval.lr_linkid;
 		*mediap = retval.lr_media;
 	} else if (err == 0) {
@@ -419,16 +406,15 @@ dls_mgmt_get_linkinfo(datalink_id_t linkid, char *link,
 {
 	dlmgmt_door_getname_t	getname;
 	dlmgmt_getname_retval_t	retval;
-	size_t			rsize;
 	int			err, len;
 
 	getname.ld_cmd = DLMGMT_CMD_GETNAME;
 	getname.ld_linkid = linkid;
-	rsize = sizeof (retval);
 
-	err = i_dls_mgmt_upcall(&getname, sizeof (getname), &retval, &rsize);
-	if (err != 0)
+	if ((err = i_dls_mgmt_upcall(&getname, sizeof (getname), &retval,
+	    sizeof (retval))) != 0) {
 		return (err);
+	}
 
 	len = strlen(retval.lr_link);
 	if (len <= 1 || len >= MAXLINKNAMELEN)
@@ -455,17 +441,15 @@ dls_mgmt_get_linkid(const char *link, datalink_id_t *linkid)
 {
 	dlmgmt_door_getlinkid_t		getlinkid;
 	dlmgmt_getlinkid_retval_t	retval;
-	size_t				rsize;
 	int				err;
 
 	getlinkid.ld_cmd = DLMGMT_CMD_GETLINKID;
 	(void) strlcpy(getlinkid.ld_link, link, MAXLINKNAMELEN);
-	rsize = sizeof (retval);
 
-	err = i_dls_mgmt_upcall(&getlinkid, sizeof (getlinkid), &retval,
-	    &rsize);
-	if (err == 0)
+	if ((err = i_dls_mgmt_upcall(&getlinkid, sizeof (getlinkid), &retval,
+	    sizeof (retval))) == 0) {
 		*linkid = retval.lr_linkid;
+	}
 	return (err);
 }
 
@@ -475,17 +459,17 @@ dls_mgmt_get_next(datalink_id_t linkid, datalink_class_t class,
 {
 	dlmgmt_door_getnext_t	getnext;
 	dlmgmt_getnext_retval_t	retval;
-	size_t			rsize;
 
 	getnext.ld_cmd = DLMGMT_CMD_GETNEXT;
 	getnext.ld_class = class;
 	getnext.ld_dmedia = dmedia;
 	getnext.ld_flags = flags;
 	getnext.ld_linkid = linkid;
-	rsize = sizeof (retval);
 
-	if (i_dls_mgmt_upcall(&getnext, sizeof (getnext), &retval, &rsize) != 0)
+	if (i_dls_mgmt_upcall(&getnext, sizeof (getnext), &retval,
+	    sizeof (retval)) != 0) {
 		return (DATALINK_INVALID_LINKID);
+	}
 
 	return (retval.lr_linkid);
 }
@@ -495,25 +479,21 @@ i_dls_mgmt_get_linkattr(const datalink_id_t linkid, const char *attr,
     void *attrval, size_t *attrszp)
 {
 	dlmgmt_upcall_arg_getattr_t	getattr;
-	dlmgmt_getattr_retval_t		*retvalp;
-	size_t				oldsize, size;
+	dlmgmt_getattr_retval_t		retval;
 	int				err;
 
 	getattr.ld_cmd = DLMGMT_CMD_DLS_GETATTR;
 	getattr.ld_linkid = linkid;
 	(void) strlcpy(getattr.ld_attr, attr, MAXLINKATTRLEN);
 
-	oldsize = size = *attrszp + sizeof (dlmgmt_getattr_retval_t) - 1;
-	retvalp = kmem_zalloc(oldsize, KM_SLEEP);
-
-	err = i_dls_mgmt_upcall(&getattr, sizeof (getattr), retvalp, &size);
-	if (err == 0) {
-		ASSERT(size <= oldsize);
-		*attrszp = size + 1 - sizeof (dlmgmt_getattr_retval_t);
-		bcopy(retvalp->lr_attr, attrval, *attrszp);
+	if ((err = i_dls_mgmt_upcall(&getattr, sizeof (getattr), &retval,
+	    sizeof (retval))) == 0) {
+		if (*attrszp < retval.lr_attrsz)
+			return (EINVAL);
+		*attrszp = retval.lr_attrsz;
+		bcopy(retval.lr_attrval, attrval, retval.lr_attrsz);
 	}
 
-	kmem_free(retvalp, oldsize);
 	return (err);
 }
 
diff --git a/usr/src/uts/common/sys/dls.h b/usr/src/uts/common/sys/dls.h
index 7b6954e2b4..20f556c86f 100644
--- a/usr/src/uts/common/sys/dls.h
+++ b/usr/src/uts/common/sys/dls.h
@@ -88,6 +88,7 @@ typedef uint64_t	datalink_media_t;
 	B_TRUE : ((uint32_t)((dmedia) & 0xfffffffful) == (media)))
 
 #define	MAXLINKATTRLEN		32
+#define	MAXLINKATTRVALLEN	1024
 
 /*
  * Link attributes used by the kernel.
@@ -131,6 +132,10 @@ typedef uint64_t	datalink_media_t;
 #define	DLMGMT_PERSIST		0x02
 
 /* upcall argument */
+typedef struct dlmgmt_door_arg {
+	uint_t			ld_cmd;
+} dlmgmt_door_arg_t;
+
 typedef struct dlmgmt_upcall_arg_create {
 	int			ld_cmd;
 	datalink_class_t	ld_class;
@@ -141,18 +146,23 @@ typedef struct dlmgmt_upcall_arg_create {
 	char			ld_devname[MAXNAMELEN];
 } dlmgmt_upcall_arg_create_t;
 
+/*
+ * Note: ld_padding is necessary to keep the size of the structure the
+ * same on amd64 and i386.  The same note applies to other ld_padding
+ * and lr_paddding fields in structures throughout this file.
+ */
 typedef struct dlmgmt_upcall_arg_destroy {
 	int			ld_cmd;
 	datalink_id_t		ld_linkid;
 	boolean_t		ld_persist;
-	int			ld_reserved;
+	int			ld_padding;
 } dlmgmt_upcall_arg_destroy_t;
 
 typedef struct dlmgmt_upcall_arg_update {
 	int			ld_cmd;
 	boolean_t		ld_novanity;
 	uint32_t		ld_media;
-	uint32_t		ld_reserved;
+	uint32_t		ld_padding;
 	char			ld_devname[MAXNAMELEN];
 } dlmgmt_upcall_arg_update_t;
 
@@ -181,13 +191,19 @@ typedef struct dlmgmt_door_getnext_s {
 } dlmgmt_door_getnext_t;
 
 /* upcall return value */
+typedef struct dlmgmt_retval_s {
+	uint_t			lr_err; /* return error code */
+} dlmgmt_retval_t;
+
+typedef dlmgmt_retval_t	dlmgmt_destroy_retval_t;
+
 struct dlmgmt_linkid_retval_s {
 	uint_t			lr_err;
 	datalink_id_t		lr_linkid;
 	uint32_t		lr_flags;
 	datalink_class_t	lr_class;
 	uint32_t		lr_media;
-	uint32_t		lr_reserved;
+	uint32_t		lr_padding;
 };
 
 typedef struct dlmgmt_linkid_retval_s	dlmgmt_create_retval_t,
@@ -203,16 +219,12 @@ typedef struct dlmgmt_getname_retval_s {
 	uint32_t		lr_flags;
 } dlmgmt_getname_retval_t;
 
-struct dlmgmt_null_retval_s {
-	uint_t			lr_err;
-};
-
-typedef struct dlmgmt_null_retval_s	dlmgmt_destroy_retval_t;
-
 typedef struct dlmgmt_getattr_retval_s {
 	uint_t			lr_err;
 	uint_t			lr_type;
-	char			lr_attr[1];
+	uint_t			lr_attrsz;
+	uint_t			lr_padding;
+	char			lr_attrval[MAXLINKATTRVALLEN];
 } dlmgmt_getattr_retval_t;
 
 #ifdef	_KERNEL
diff --git a/usr/src/uts/common/sys/door.h b/usr/src/uts/common/sys/door.h
index bccb2e4c76..ec7e79c88f 100644
--- a/usr/src/uts/common/sys/door.h
+++ b/usr/src/uts/common/sys/door.h
@@ -2,9 +2,8 @@
  * 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.
+ * 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.
@@ -20,7 +19,7 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -275,7 +274,7 @@ struct file;
 int	door_insert(struct file *, door_desc_t *);
 int	door_finish_dispatch(caddr_t);
 uintptr_t door_final_sp(uintptr_t, size_t, int);
-int	door_upcall(vnode_t *, door_arg_t *);
+int	door_upcall(vnode_t *, door_arg_t *, struct cred *);
 void	door_slam(void);
 void	door_exit(void);
 void	door_revoke_all(void);
@@ -294,6 +293,7 @@ extern size_t door_max_arg;
  * and may change incompatibly in a minor release of Solaris.
  */
 int	door_ki_upcall(door_handle_t, door_arg_t *);
+int	door_ki_upcall_cred(door_handle_t, door_arg_t *, struct cred *);
 int	door_ki_create(void (*)(void *, door_arg_t *,
     void (**)(void *, void *), void **, int *), void *, door_attr_t,
     door_handle_t *);
diff --git a/usr/src/uts/common/sys/door_data.h b/usr/src/uts/common/sys/door_data.h
index 59aa73e5d1..9c36f86a90 100644
--- a/usr/src/uts/common/sys/door_data.h
+++ b/usr/src/uts/common/sys/door_data.h
@@ -2,9 +2,8 @@
  * 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.
+ * 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.
@@ -20,7 +19,7 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -59,6 +58,7 @@ typedef struct door_layout {
  */
 typedef struct door_client {
 	door_arg_t	d_args;		/* Door arg/results */
+	struct cred	*d_cred;	/* Cred overridden by the client */
 	caddr_t		d_buf;		/* Temp buffer for data transfer */
 	int		d_bufsize;	/* Size of temp buffer */
 	int		d_fpp_size;	/* Number of File ptrs */
diff --git a/usr/src/uts/intel/ia32/ml/modstubs.s b/usr/src/uts/intel/ia32/ml/modstubs.s
index e49fe5c4b8..6524fa1bd7 100644
--- a/usr/src/uts/intel/ia32/ml/modstubs.s
+++ b/usr/src/uts/intel/ia32/ml/modstubs.s
@@ -885,6 +885,7 @@ fcnname/**/_info:							\
 	NO_UNLOAD_STUB(doorfs, door_ki_open,		nomod_einval);
 	NO_UNLOAD_STUB(doorfs, door_ki_lookup,		nomod_zero);
 	WSTUB(doorfs, door_ki_upcall,			nomod_einval);
+	WSTUB(doorfs, door_ki_upcall_cred,		nomod_einval);
 	WSTUB(doorfs, door_ki_hold,			nomod_zero);
 	WSTUB(doorfs, door_ki_rele,			nomod_zero);
 	WSTUB(doorfs, door_ki_info,			nomod_einval);
diff --git a/usr/src/uts/sparc/ml/modstubs.s b/usr/src/uts/sparc/ml/modstubs.s
index abc8c124f6..22be0e8a44 100644
--- a/usr/src/uts/sparc/ml/modstubs.s
+++ b/usr/src/uts/sparc/ml/modstubs.s
@@ -806,6 +806,7 @@ stubs_base:
 	NO_UNLOAD_STUB(doorfs, door_ki_open,		nomod_einval);
 	NO_UNLOAD_STUB(doorfs, door_ki_lookup,		nomod_zero);
 	WSTUB(doorfs, door_ki_upcall,			nomod_einval);
+	WSTUB(doorfs, door_ki_upcall_cred,		nomod_einval);
 	WSTUB(doorfs, door_ki_hold,			nomod_zero);
 	WSTUB(doorfs, door_ki_rele,			nomod_zero);
 	WSTUB(doorfs, door_ki_info,			nomod_einval);