uts: Squelch pointer to different-sized int warnings

5 files changed, 213 insertions, 224 deletions

diff --git a/usr/src/uts/common/avs/ns/dsw/dsw_dev.c b/usr/src/uts/common/avs/ns/dsw/dsw_dev.c
index f9cd9a9ead..098990bc15 100644
--- a/usr/src/uts/common/avs/ns/dsw/dsw_dev.c
+++ b/usr/src/uts/common/avs/ns/dsw/dsw_dev.c
@@ -32,6 +32,7 @@
 #include <sys/debug.h>
 #include <sys/ddi.h>
 #include <sys/nsc_thread.h>
+#include <sys/sysmacros.h>
 #include <sys/unistat/spcs_s.h>
 #include <sys/unistat/spcs_errors.h>
 
@@ -67,7 +68,7 @@
 
 
 #define	II_TAIL_COPY(d, s, m, t)	bcopy(&(s.m), &(d.m), \
-					sizeof (d) - (uint_t)&((t *)0)->m)
+					sizeof (d) - (uintptr_t)&((t *)0)->m)
 extern dev_info_t *ii_dip;
 
 #define	II_LINK_CLUSTER(ip, cluster) \
@@ -4234,7 +4235,8 @@ _ii_gc_list(intptr_t arg, int ilp32, int *rvp, kmutex_t *mutex,
 {
 	dsw_aioctl_t ulist;
 	dsw_aioctl32_t ulist32;
-	int name_offset, i;
+	size_t name_offset;
+	int i;
 	spcs_s_info_t kstatus;
 	char *carg = (char *)arg;
 	uint64_t hash;
@@ -4242,13 +4244,13 @@ _ii_gc_list(intptr_t arg, int ilp32, int *rvp, kmutex_t *mutex,
 	_ii_lstinfo_t *np;
 
 	*rvp = 0;
-	name_offset = (int)&(((dsw_aioctl_t *)0)->shadow_vol[0]);
+	name_offset = offsetof(dsw_aioctl_t, shadow_vol[0]);
 	if (ilp32) {
 		if (copyin((void *) arg, &ulist32, sizeof (ulist32)) < 0)
 			return (EFAULT);
 		II_TAIL_COPY(ulist, ulist32, flags, dsw_aioctl_t);
 		ulist.status = (spcs_s_info_t)ulist32.status;
-		name_offset = (int)&(((dsw_aioctl32_t *)0)->shadow_vol[0]);
+		name_offset = offsetof(dsw_aioctl32_t, shadow_vol[0]);
 	} else if (copyin((void *) arg, &ulist, sizeof (ulist)) < 0)
 		return (EFAULT);
 
@@ -4323,20 +4325,21 @@ _ii_olist(intptr_t arg, int ilp32, int *rvp)
 	dsw_aioctl_t ulist;
 	dsw_aioctl32_t ulist32;
 	_ii_overflow_t *op;
+	size_t name_offset;
 	int rc = 0;
-	int name_offset, i;
+	int i;
 	char *carg = (char *)arg;
 	spcs_s_info_t kstatus;
 
 	*rvp = 0;
 
-	name_offset = (int)&(((dsw_aioctl_t *)0)->shadow_vol[0]);
+	name_offset = offsetof(dsw_aioctl_t, shadow_vol[0]);
 	if (ilp32) {
 		if (copyin((void *)arg, &ulist32, sizeof (ulist32)) < 0)
 			return (EFAULT);
 		II_TAIL_COPY(ulist, ulist32, flags, dsw_aioctl_t);
 		ulist.status = (spcs_s_info_t)ulist32.status;
-		name_offset = (int)&(((dsw_aioctl32_t *)0)->shadow_vol[0]);
+		name_offset = offsetof(dsw_aioctl32_t, shadow_vol[0]);
 	} else if (copyin((void *)arg, &ulist, sizeof (ulist)) < 0)
 		return (EFAULT);
 
@@ -5220,7 +5223,7 @@ int
 _ii_acopy(intptr_t arg, int ilp32, int *rvp)
 {
 	int rc;
-	int name_offset;
+	size_t name_offset;
 	char *list;
 	char *nptr;
 	char name[DSW_NAMELEN];
@@ -5230,14 +5233,14 @@ _ii_acopy(intptr_t arg, int ilp32, int *rvp)
 
 	*rvp = 0;
 
-	name_offset = (int)&(((dsw_aioctl_t *)0)->shadow_vol[0]);
+	name_offset = offsetof(dsw_aioctl_t, shadow_vol[0]);
 
 	if (ilp32) {
 		if (copyin((void *)arg, &ucopy32, sizeof (ucopy32)) < 0)
 			return (EFAULT);
 		II_TAIL_COPY(ucopy, ucopy32, flags, dsw_ioctl_t);
 		ucopy.status = (spcs_s_info_t)ucopy32.status;
-		name_offset = (int)&(((dsw_aioctl32_t *)0)->shadow_vol[0]);
+		name_offset = offsetof(dsw_aioctl32_t, shadow_vol[0]);
 	} else if (copyin((void *)arg, &ucopy, sizeof (ucopy)) < 0)
 		return (EFAULT);
 
diff --git a/usr/src/uts/common/fs/udfs/udf_alloc.c b/usr/src/uts/common/fs/udfs/udf_alloc.c
index baf78a80e9..0f0c32a85e 100644
--- a/usr/src/uts/common/fs/udfs/udf_alloc.c
+++ b/usr/src/uts/common/fs/udfs/udf_alloc.c
@@ -24,8 +24,6 @@
  * Use is subject to license terms.
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #include <sys/types.h>
 #include <sys/t_lock.h>
 #include <sys/param.h>
@@ -175,10 +173,10 @@ ud_alloc_space(struct vfs *vfsp, uint16_t prn,
 	if (ud_part->udp_nfree != 0) {
 		if (ud_part->udp_flags == UDP_BITMAPS) {
 			error = ud_alloc_space_bmap(vfsp, ud_part, proximity,
-				blkcount, start_blkno, size, less_is_ok);
+			    blkcount, start_blkno, size, less_is_ok);
 		} else {
 			error = ud_alloc_space_stbl(vfsp, ud_part, proximity,
-				blkcount, start_blkno, size, less_is_ok);
+			    blkcount, start_blkno, size, less_is_ok);
 		}
 		if (error == 0) {
 			mutex_enter(&udf_vfsp->udf_lock);
@@ -258,7 +256,7 @@ ud_alloc_space_bmap(struct vfs *vfsp,
 		 */
 		temp = blkcount;
 		if (ud_check_free_and_mark_used(vfsp,
-				ud_part, proximity, &temp) == 0) {
+		    ud_part, proximity, &temp) == 0) {
 			if (temp != 0) {
 				*start_blkno = proximity;
 				*size = temp;
@@ -290,17 +288,17 @@ retry:
 			 * due to the way bread is implemented
 			 */
 			if ((bp == NULL) ||
-				((eblk - bno) < blkcount)) {
+			    ((eblk - bno) < blkcount)) {
 				if (bp != NULL) {
 					brelse(bp);
 				}
 				begin = ud_part->udp_unall_loc +
-						bno / bb_count;
+				    bno / bb_count;
 				bp = ud_bread(vfsp->vfs_dev,
-					ud_xlate_to_daddr(udf_vfsp,
-						ud_part->udp_number,
-						begin, 1, &dummy)
-					<< udf_vfsp->udf_l2d_shift, lbsz);
+				    ud_xlate_to_daddr(udf_vfsp,
+				    ud_part->udp_number,
+				    begin, 1, &dummy)
+				    << udf_vfsp->udf_l2d_shift, lbsz);
 				if (bp->b_flags & B_ERROR) {
 					brelse(bp);
 					return (EIO);
@@ -317,14 +315,14 @@ retry:
 				temp = blkcount;
 			}
 			if ((new_size = ud_check_free(addr, eaddr,
-					bno - bblk, temp)) == temp) {
+			    bno - bblk, temp)) == temp) {
 				ud_mark_used(addr, bno - bblk, temp);
 				bdwrite(bp);
 				*start_blkno = bno - HDR_BLKS;
 				*size = temp;
 				mutex_enter(&udf_vfsp->udf_lock);
 				ud_part->udp_last_alloc =
-					bno + temp - HDR_BLKS;
+				    bno + temp - HDR_BLKS;
 				mutex_exit(&udf_vfsp->udf_lock);
 				return (0);
 			}
@@ -380,7 +378,7 @@ retry:
 		 * already allocated behind us
 		 */
 		if (ud_check_free_and_mark_used(vfsp,
-				ud_part, old_loc, &old_size) == 0) {
+		    ud_part, old_loc, &old_size) == 0) {
 			if (old_size != 0) {
 				*start_blkno = old_loc;
 				*size = old_size;
@@ -423,9 +421,9 @@ ud_check_free_and_mark_used(struct vfs *vfsp,
 	 */
 	begin = ud_part->udp_unall_loc + (start / bb_count);
 	bp = ud_bread(vfsp->vfs_dev,
-		ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number,
-			begin, 1, &dummy) << udf_vfsp->udf_l2d_shift,
-			udf_vfsp->udf_lbsize);
+	    ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number,
+	    begin, 1, &dummy) << udf_vfsp->udf_l2d_shift,
+	    udf_vfsp->udf_lbsize);
 	if (bp->b_flags & B_ERROR) {
 		brelse(bp);
 		return (EIO);
@@ -440,8 +438,8 @@ ud_check_free_and_mark_used(struct vfs *vfsp,
 		ASSERT(*count > 0);
 	}
 	if (ud_check_free((uint8_t *)bp->b_un.b_addr,
-			(uint8_t *)bp->b_un.b_addr + bp->b_bcount,
-			start, *count) != *count) {
+	    (uint8_t *)bp->b_un.b_addr + bp->b_bcount, start,
+	    *count) != *count) {
 		brelse(bp);
 		return (1);
 	}
@@ -517,9 +515,8 @@ ud_alloc_space_stbl(struct vfs *vfsp,
 	ASSERT((ud_part->udp_unall_len + 40) <= udf_vfsp->udf_lbsize);
 
 	bp = ud_bread(vfsp->vfs_dev,
-			ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number,
-				ud_part->udp_unall_loc, 1, &temp),
-			udf_vfsp->udf_lbsize);
+	    ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number,
+	    ud_part->udp_unall_loc, 1, &temp), udf_vfsp->udf_lbsize);
 
 	use = (struct unall_space_ent *)bp->b_un.b_addr;
 	sz = SWAP_32(use->use_len_ad);
@@ -538,7 +535,7 @@ ud_alloc_space_stbl(struct vfs *vfsp,
 		larg_index = larg_sz = 0;
 		for (index = 0; index < count; index++, sad++) {
 			temp = SWAP_32(sad->sad_ext_len) >>
-					udf_vfsp->udf_l2b_shift;
+			    udf_vfsp->udf_l2b_shift;
 			if (temp == blkcount) {
 				/*
 				 * We found the right fit
@@ -559,7 +556,7 @@ ud_alloc_space_stbl(struct vfs *vfsp,
 				*start_blkno = SWAP_32(sad->sad_ext_loc);
 				*size = blkcount;
 				temp = (temp - blkcount) <<
-					udf_vfsp->udf_l2b_shift;
+				    udf_vfsp->udf_l2b_shift;
 				sad->sad_ext_len = SWAP_32(temp);
 				temp = SWAP_32(sad->sad_ext_loc) + blkcount;
 				sad->sad_ext_loc = SWAP_32(temp);
@@ -577,8 +574,7 @@ ud_alloc_space_stbl(struct vfs *vfsp,
 			}
 		}
 compress_sad:
-		if ((less_is_ok) &&
-			(larg_sz != 0)) {
+		if ((less_is_ok) && (larg_sz != 0)) {
 			/*
 			 * If we came here we could
 			 * not find a extent to cover the entire size
@@ -590,7 +586,7 @@ compress_sad:
 			*start_blkno = SWAP_32(sad->sad_ext_loc);
 			*size = larg_sz;
 			for (index = larg_index; index < count;
-					index++, sad++) {
+			    index++, sad++) {
 				*sad = *(sad+1);
 			}
 			sz -= sizeof (struct short_ad);
@@ -613,7 +609,7 @@ compress_sad:
 		larg_index = larg_sz = 0;
 		for (index = 0; index < count; index++, lad++) {
 			temp = SWAP_32(lad->lad_ext_len) >>
-					udf_vfsp->udf_l2b_shift;
+			    udf_vfsp->udf_l2b_shift;
 			if (temp == blkcount) {
 				/*
 				 * We found the right fit
@@ -634,7 +630,7 @@ compress_sad:
 				*start_blkno = SWAP_32(lad->lad_ext_loc);
 				*size = blkcount;
 				temp = (temp - blkcount) <<
-					udf_vfsp->udf_l2b_shift;
+				    udf_vfsp->udf_l2b_shift;
 				lad->lad_ext_len = SWAP_32(temp);
 				temp = SWAP_32(lad->lad_ext_loc) + blkcount;
 				lad->lad_ext_loc = SWAP_32(temp);
@@ -652,8 +648,7 @@ compress_sad:
 			}
 		}
 compress_lad:
-		if ((less_is_ok) &&
-			(larg_sz != 0)) {
+		if ((less_is_ok) && (larg_sz != 0)) {
 			/*
 			 * If we came here we could
 			 * not find a extent to cover the entire size
@@ -665,7 +660,7 @@ compress_lad:
 			*start_blkno = SWAP_32(lad->lad_ext_loc);
 			*size = larg_sz;
 			for (index = larg_index; index < count;
-					index++, lad++) {
+			    index++, lad++) {
 				*lad = *(lad+1);
 			}
 			sz -= sizeof (struct long_ad);
@@ -755,7 +750,7 @@ ud_free_space_bmap(struct vfs *vfsp,
 
 	udf_vfsp = (struct udf_vfs *)vfsp->vfs_data;
 	if ((ud_part->udp_freed_len == 0) &&
-		(ud_part->udp_unall_len == 0)) {
+	    (ud_part->udp_unall_len == 0)) {
 		return (ENOSPC);
 	}
 	/*
@@ -782,10 +777,8 @@ ud_free_space_bmap(struct vfs *vfsp,
 	for (block = begin; block <= end; block++) {
 
 		bp = ud_bread(vfsp->vfs_dev,
-			ud_xlate_to_daddr(udf_vfsp,
-				ud_part->udp_number, block, 1, &dummy)
-				<< udf_vfsp->udf_l2d_shift,
-			udf_vfsp->udf_lbsize);
+		    ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number, block, 1,
+		    &dummy) << udf_vfsp->udf_l2d_shift, udf_vfsp->udf_lbsize);
 		if (bp->b_flags & B_ERROR) {
 			brelse(bp);
 			return (EIO);
@@ -855,8 +848,7 @@ ud_free_space_stbl(struct vfs *vfsp,
 	ASSERT(ud_part);
 	ASSERT(ud_part->udp_flags == UDP_SPACETBLS);
 
-	if ((ud_part->udp_freed_len == 0) &&
-		(ud_part->udp_unall_len == 0)) {
+	if ((ud_part->udp_freed_len == 0) && (ud_part->udp_unall_len == 0)) {
 		return (ENOSPC);
 	}
 
@@ -870,8 +862,8 @@ ud_free_space_stbl(struct vfs *vfsp,
 	ASSERT((ud_part->udp_unall_len + 40) <= udf_vfsp->udf_lbsize);
 
 	bp = ud_bread(vfsp->vfs_dev,
-			ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number,
-				block, 1, &dummy), udf_vfsp->udf_lbsize);
+	    ud_xlate_to_daddr(udf_vfsp, ud_part->udp_number, block, 1, &dummy),
+	    udf_vfsp->udf_lbsize);
 
 	use = (struct unall_space_ent *)bp->b_un.b_addr;
 	sz = SWAP_32(use->use_len_ad);
@@ -888,14 +880,14 @@ ud_free_space_stbl(struct vfs *vfsp,
 		 */
 		for (index = 0; index < count; index++, sad++) {
 			if (beginblk == (SWAP_32(sad->sad_ext_loc) +
-					(SWAP_32(sad->sad_ext_len) /
-					udf_vfsp->udf_lbsize))) {
+			    (SWAP_32(sad->sad_ext_len) /
+			    udf_vfsp->udf_lbsize))) {
 				dummy = SWAP_32(sad->sad_ext_len) +
-					blkcount * udf_vfsp->udf_lbsize;
+				    blkcount * udf_vfsp->udf_lbsize;
 				sad->sad_ext_len = SWAP_32(dummy);
 				goto end;
 			} else if ((beginblk + blkcount) ==
-					SWAP_32(sad->sad_ext_loc)) {
+			    SWAP_32(sad->sad_ext_loc)) {
 				sad->sad_ext_loc = SWAP_32(beginblk);
 				goto end;
 			}
@@ -906,7 +898,7 @@ ud_free_space_stbl(struct vfs *vfsp,
 		 * Check if we space.
 		 */
 		if ((40 + sz + sizeof (struct short_ad)) >
-				udf_vfsp->udf_lbsize) {
+		    udf_vfsp->udf_lbsize) {
 			error = ENOSPC;
 			goto end;
 		}
@@ -934,14 +926,14 @@ ud_free_space_stbl(struct vfs *vfsp,
 		 */
 		for (index = 0; index < count; index++, lad++) {
 			if (beginblk == (SWAP_32(lad->lad_ext_loc) +
-					(SWAP_32(lad->lad_ext_len) /
-					udf_vfsp->udf_lbsize))) {
+			    (SWAP_32(lad->lad_ext_len) /
+			    udf_vfsp->udf_lbsize))) {
 				dummy = SWAP_32(lad->lad_ext_len) +
-					blkcount * udf_vfsp->udf_lbsize;
+				    blkcount * udf_vfsp->udf_lbsize;
 				lad->lad_ext_len = SWAP_32(dummy);
 				goto end;
 			} else if ((beginblk + blkcount) ==
-					SWAP_32(lad->lad_ext_loc)) {
+			    SWAP_32(lad->lad_ext_loc)) {
 				lad->lad_ext_loc = SWAP_32(beginblk);
 				goto end;
 			}
@@ -952,7 +944,7 @@ ud_free_space_stbl(struct vfs *vfsp,
 		 * Check if we space.
 		 */
 		if ((40 + sz + sizeof (struct long_ad)) >
-				udf_vfsp->udf_lbsize) {
+		    udf_vfsp->udf_lbsize) {
 			error = ENOSPC;
 			goto end;
 		}
@@ -1019,7 +1011,7 @@ ud_ialloc(struct ud_inode *pip,
 	prn = pip->i_icb_prn;
 
 	if ((err = ud_alloc_space(pip->i_vfs, prn,
-			0, 1, &blkno, &size, 0, 1)) != 0) {
+	    0, 1, &blkno, &size, 0, 1)) != 0) {
 		return (err);
 	}
 	loc = ud_xlate_to_daddr(udf_vfsp, prn, blkno, 1, &dummy);
@@ -1048,8 +1040,8 @@ ud_ialloc(struct ud_inode *pip,
 	 * 3) Otherwise, set the group-id to the gid of the parent directory.
 	 */
 	if ((vap->va_mask & AT_GID) &&
-		((vap->va_gid == pip->i_gid) || groupmember(vap->va_gid, cr) ||
-		secpolicy_vnode_create_gid(cr) == 0)) {
+	    ((vap->va_gid == pip->i_gid) || groupmember(vap->va_gid, cr) ||
+	    secpolicy_vnode_create_gid(cr) == 0)) {
 		/*
 		 * XXX - is this only the case when a 4.0 NFS client, or a
 		 * client derived from that code, makes a call over the wire?
@@ -1058,7 +1050,7 @@ ud_ialloc(struct ud_inode *pip,
 	} else {
 		gid = crgetgid(cr);
 		fe->fe_gid = (pip->i_char & ISGID) ?
-				SWAP_32(pip->i_gid) : SWAP_32(gid);
+		    SWAP_32(pip->i_gid) : SWAP_32(gid);
 	}
 
 	imode = MAKEIMODE(vap->va_type, vap->va_mode);
@@ -1115,19 +1107,18 @@ ud_ialloc(struct ud_inode *pip,
 	mutex_exit(&udf_vfsp->udf_lock);
 
 	ea_len = 0;
-	if ((vap->va_type == VBLK) ||
-		(vap->va_type == VCHR)) {
+	if ((vap->va_type == VBLK) || (vap->va_type == VCHR)) {
 		eah = (struct ext_attr_hdr *)fe->fe_spec;
 		ea_len = (sizeof (struct ext_attr_hdr) + 3) & ~3;
 		eah->eah_ial = SWAP_32(ea_len);
 
 		ds = (struct dev_spec_ear *)&fe->fe_spec[ea_len];
 		ea_len += ud_make_dev_spec_ear(ds,
-			getmajor(vap->va_rdev), getminor(vap->va_rdev));
+		    getmajor(vap->va_rdev), getminor(vap->va_rdev));
 		ea_len = (ea_len + 3) & ~3;
 		eah->eah_aal = SWAP_32(ea_len);
 		ud_make_tag(udf_vfsp, &eah->eah_tag,
-			UD_EXT_ATTR_HDR, blkno, ea_len);
+		    UD_EXT_ATTR_HDR, blkno, ea_len);
 	}
 
 	fe->fe_len_ear = SWAP_32(ea_len);
@@ -1172,7 +1163,7 @@ ud_ialloc(struct ud_inode *pip,
 	} else {
 		if ((ichar & ISGID) &&
 		    secpolicy_vnode_setids_setgids(cr,
-			    (gid_t)SWAP_32(fe->fe_gid)) != 0) {
+		    (gid_t)SWAP_32(fe->fe_gid)) != 0) {
 			ichar &= ~ISGID;
 		}
 	}
@@ -1187,8 +1178,8 @@ ud_ialloc(struct ud_inode *pip,
 	}
 	icb->itag_flags = SWAP_16(flags);
 	ud_make_tag(udf_vfsp, &fe->fe_tag, UD_FILE_ENTRY, blkno,
-		((uint32_t)&((struct file_entry *)0)->fe_spec) +
-			SWAP_32(fe->fe_len_ear) + SWAP_32(fe->fe_len_adesc));
+	    offsetof(struct file_entry, fe_spec) +
+	    SWAP_32(fe->fe_len_ear) + SWAP_32(fe->fe_len_adesc));
 
 	BWRITE2(bp);
 
@@ -1206,7 +1197,7 @@ ud_ialloc(struct ud_inode *pip,
 
 		if ((ip = ud_search_icache(pip->i_vfs, prn, blkno)) != NULL) {
 			cmn_err(CE_NOTE, "duplicate %p %x\n",
-				(void *)ip, (uint32_t)ip->i_icb_lbano);
+			    (void *)ip, (uint32_t)ip->i_icb_lbano);
 		}
 	}
 #endif
@@ -1239,8 +1230,7 @@ ud_ifree(struct ud_inode *ip, vtype_t type)
 
 	udf_vfsp = (struct udf_vfs *)ip->i_vfs->vfs_data;
 	bp = ud_bread(ip->i_dev, ip->i_icb_lbano <<
-			udf_vfsp->udf_l2d_shift,
-			udf_vfsp->udf_lbsize);
+	    udf_vfsp->udf_l2d_shift, udf_vfsp->udf_lbsize);
 	if (bp->b_flags & B_ERROR) {
 		/*
 		 * Error get rid of bp
@@ -1253,8 +1243,7 @@ ud_ifree(struct ud_inode *ip, vtype_t type)
 		bzero(bp->b_un.b_addr, 0x10);
 		BWRITE(bp);
 	}
-	ud_free_space(ip->i_vfs, ip->i_icb_prn,
-		ip->i_icb_block, 1);
+	ud_free_space(ip->i_vfs, ip->i_icb_prn, ip->i_icb_block, 1);
 	mutex_enter(&udf_vfsp->udf_lock);
 	if (type == VDIR) {
 		if (udf_vfsp->udf_ndirs > 1) {
@@ -1377,8 +1366,7 @@ ud_alloc_from_cache(struct udf_vfs *udf_vfsp,
 		mutex_exit(&udf_vfsp->udf_lock);
 		/* allocate new cluster */
 		if ((error = ud_alloc_space(udf_vfsp->udf_vfs,
-				part->udp_number, 0, CLSTR_SIZE,
-				&bno, &sz, 1, 0)) != 0) {
+		    part->udp_number, 0, CLSTR_SIZE, &bno, &sz, 1, 0)) != 0) {
 			return (error);
 		}
 		if (sz == 0) {
@@ -1424,7 +1412,7 @@ ud_release_cache(struct udf_vfs *udf_vfsp)
 			part->udp_cache_count = 0;
 			mutex_exit(&udf_vfsp->udf_lock);
 			ud_free_space(udf_vfsp->udf_vfs,
-				part->udp_number, start, nblks);
+			    part->udp_number, start, nblks);
 			mutex_enter(&udf_vfsp->udf_lock);
 		}
 	}
diff --git a/usr/src/uts/common/fs/udfs/udf_inode.c b/usr/src/uts/common/fs/udfs/udf_inode.c
index e30a5ffe6d..62e446c926 100644
--- a/usr/src/uts/common/fs/udfs/udf_inode.c
+++ b/usr/src/uts/common/fs/udfs/udf_inode.c
@@ -1237,7 +1237,7 @@ ud_iupdat(struct ud_inode *ip, int32_t waitfor)
 
 		ud_update_regid(&fe->fe_impl_id);
 
-		crc_len = ((uint32_t)&((struct file_entry *)0)->fe_spec) +
+		crc_len = offsetof(struct file_entry, fe_spec) +
 		    SWAP_32(fe->fe_len_ear);
 		if (ip->i_desc_type == ICB_FLAG_ONE_AD) {
 			crc_len += ip->i_size;
diff --git a/usr/src/uts/common/fs/udfs/udf_vnops.c b/usr/src/uts/common/fs/udfs/udf_vnops.c
index f3f024d6ae..432134e3bf 100644
--- a/usr/src/uts/common/fs/udfs/udf_vnops.c
+++ b/usr/src/uts/common/fs/udfs/udf_vnops.c
@@ -2831,7 +2831,7 @@ ud_putapage(struct vnode *vp,
 			(void) kcopy(kaddr, caddr, ip->i_size);
 			ppmapout(kaddr);
 		}
-		crc_len = ((uint32_t)&((struct file_entry *)0)->fe_spec) +
+		crc_len = offsetof(struct file_entry, fe_spec) +
 		    SWAP_32(fe->fe_len_ear);
 		crc_len += ip->i_size;
 		ud_make_tag(ip->i_udf, &fe->fe_tag,
diff --git a/usr/src/uts/common/gssapi/gssd_clnt_stubs.c b/usr/src/uts/common/gssapi/gssd_clnt_stubs.c
index e21a21b72d..5e50d4b42f 100644
--- a/usr/src/uts/common/gssapi/gssd_clnt_stubs.c
+++ b/usr/src/uts/common/gssapi/gssd_clnt_stubs.c
@@ -376,7 +376,7 @@ kgss_add_cred_wrapped(minor_status,
 	arg.uid = (OM_uint32)uid;
 	arg.input_cred_handle.GSS_CRED_ID_T_len =
 			input_cred_handle ==
-			(gssd_cred_id_t)GSS_C_NO_CREDENTIAL ?
+			(gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL ?
 			0 : (uint_t)sizeof (gssd_cred_id_t);
 	arg.input_cred_handle.GSS_CRED_ID_T_val = (char *)&input_cred_handle;
 	arg.gssd_cred_verifier = gssd_cred_verifier;
@@ -495,8 +495,10 @@ kgss_add_cred(minor_status,
 	if (input_cred_handle != GSS_C_NO_CREDENTIAL) {
 		gssd_cred_verifier = KCRED_TO_CREDV(input_cred_handle);
 		gssd_input_cred_handle = KCRED_TO_CRED(input_cred_handle);
-	} else
-		gssd_input_cred_handle = (gssd_cred_id_t)GSS_C_NO_CREDENTIAL;
+	} else {
+		gssd_input_cred_handle =
+		    (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL;
+	}
 
 	err = kgss_add_cred_wrapped(minor_status, gssd_input_cred_handle,
 			gssd_cred_verifier, desired_name, desired_mech_type,
@@ -638,15 +640,15 @@ kgss_init_sec_context_wrapped(
 
 	if ((clnt = getgssd_handle()) == NULL) {
 		GSSLOG(1,
-		"kgss_init_sec_context: can't connect to server on %s\n",
-		server);
+		    "kgss_init_sec_context: can't connect to server on %s\n",
+		    server);
 		return (GSS_S_FAILURE);
 	}
 
 	/* convert the target name from internal to external format */
 
 	if (gss_display_name(&minor_status_temp, target_name,
-		&external_name, &name_type) != GSS_S_COMPLETE) {
+	    &external_name, &name_type) != GSS_S_COMPLETE) {
 
 		*minor_status = (OM_uint32) minor_status_temp;
 		killgssd_handle(clnt);
@@ -660,34 +662,38 @@ kgss_init_sec_context_wrapped(
 	arg.uid = (OM_uint32)uid;
 
 	arg.context_handle.GSS_CTX_ID_T_len =
-		*context_handle == (gssd_ctx_id_t)GSS_C_NO_CONTEXT ?
-			0 : (uint_t)sizeof (gssd_ctx_id_t);
+	    *context_handle == (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT ?
+	    0 : (uint_t)sizeof (gssd_ctx_id_t);
 	arg.context_handle.GSS_CTX_ID_T_val =  (char *)context_handle;
 
 	arg.gssd_context_verifier =  *gssd_context_verifier;
 
-	arg.claimant_cred_handle.GSS_CRED_ID_T_len =
-		claimant_cred_handle == (gssd_cred_id_t)GSS_C_NO_CREDENTIAL ?
-			0 : (uint_t)sizeof (gssd_cred_id_t);
+	if (claimant_cred_handle ==
+	    (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL) {
+		arg.claimant_cred_handle.GSS_CRED_ID_T_len = 0;
+	} else {
+		arg.claimant_cred_handle.GSS_CRED_ID_T_len =
+		    (uint_t)sizeof (gss_cred_id_t);
+	}
+
 	arg.claimant_cred_handle.GSS_CRED_ID_T_val =
-						(char *)&claimant_cred_handle;
+	    (char *)&claimant_cred_handle;
 	arg.gssd_cred_verifier = gssd_cred_verifier;
 
 	arg.target_name.GSS_BUFFER_T_len = (uint_t)external_name.length;
 	arg.target_name.GSS_BUFFER_T_val = (char *)external_name.value;
 
 	arg.name_type.GSS_OID_len =
-		name_type == GSS_C_NULL_OID ?
-			0 : (uint_t)name_type->length;
+	    name_type == GSS_C_NULL_OID ? 0 : (uint_t)name_type->length;
 
 	arg.name_type.GSS_OID_val =
-		name_type == GSS_C_NULL_OID ?
-			(char *)NULL : (char *)name_type->elements;
+	    name_type == GSS_C_NULL_OID ?
+	    (char *)NULL : (char *)name_type->elements;
 
-	arg.mech_type.GSS_OID_len = (uint_t)(mech_type != GSS_C_NULL_OID ?
-						mech_type->length : 0);
-	arg.mech_type.GSS_OID_val = (char *)(mech_type != GSS_C_NULL_OID ?
-						mech_type->elements : 0);
+	arg.mech_type.GSS_OID_len =
+	    (uint_t)(mech_type != GSS_C_NULL_OID ? mech_type->length : 0);
+	arg.mech_type.GSS_OID_val =
+	    (char *)(mech_type != GSS_C_NULL_OID ? mech_type->elements : 0);
 
 	arg.req_flags = req_flags;
 
@@ -696,21 +702,21 @@ kgss_init_sec_context_wrapped(
 	if (input_chan_bindings != GSS_C_NO_CHANNEL_BINDINGS) {
 		arg.input_chan_bindings.present = YES;
 		arg.input_chan_bindings.initiator_addrtype =
-			input_chan_bindings->initiator_addrtype;
+		    input_chan_bindings->initiator_addrtype;
 		arg.input_chan_bindings.initiator_address.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->initiator_address.length;
+		    (uint_t)input_chan_bindings->initiator_address.length;
 		arg.input_chan_bindings.initiator_address.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->initiator_address.value;
+		    (void *)input_chan_bindings->initiator_address.value;
 		arg.input_chan_bindings.acceptor_addrtype =
-			input_chan_bindings->acceptor_addrtype;
+		    input_chan_bindings->acceptor_addrtype;
 		arg.input_chan_bindings.acceptor_address.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->acceptor_address.length;
+		    (uint_t)input_chan_bindings->acceptor_address.length;
 		arg.input_chan_bindings.acceptor_address.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->acceptor_address.value;
+		    (void *)input_chan_bindings->acceptor_address.value;
 		arg.input_chan_bindings.application_data.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->application_data.length;
+		    (uint_t)input_chan_bindings->application_data.length;
 		arg.input_chan_bindings.application_data.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->application_data.value;
+		    (void *)input_chan_bindings->application_data.value;
 	} else {
 		arg.input_chan_bindings.present = NO;
 		arg.input_chan_bindings.initiator_addrtype = 0;
@@ -724,11 +730,9 @@ kgss_init_sec_context_wrapped(
 	}
 
 	arg.input_token.GSS_BUFFER_T_len =
-		(uint_t)(input_token != GSS_C_NO_BUFFER ?
-		input_token->length : 0);
+	    (uint_t)(input_token != GSS_C_NO_BUFFER ? input_token->length : 0);
 	arg.input_token.GSS_BUFFER_T_val =
-		(char *)(input_token != GSS_C_NO_BUFFER ?
-		input_token->value : 0);
+	    (char *)(input_token != GSS_C_NO_BUFFER ? input_token->value : 0);
 
 	/* call the remote procedure */
 
@@ -766,41 +770,36 @@ kgss_init_sec_context_wrapped(
 
 	if (output_token != NULL && res.output_token.GSS_BUFFER_T_val != NULL) {
 		output_token->length =
-			(size_t)res.output_token.GSS_BUFFER_T_len;
+		    (size_t)res.output_token.GSS_BUFFER_T_len;
 		output_token->value =
-			(void *)MALLOC(output_token->length);
+		    (void *)MALLOC(output_token->length);
 		(void) memcpy(output_token->value,
-			    res.output_token.GSS_BUFFER_T_val,
-			    output_token->length);
+		    res.output_token.GSS_BUFFER_T_val, output_token->length);
 	}
 
 	/* if the call was successful, copy out the results */
 	if (res.status == (OM_uint32) GSS_S_COMPLETE ||
-		res.status == (OM_uint32) GSS_S_CONTINUE_NEEDED) {
+	    res.status == (OM_uint32) GSS_S_CONTINUE_NEEDED) {
 		/*
 		 * if the return code is GSS_S_CONTINUE_NEEDED
 		 * ignore all return parameters except for
 		 * status codes, output token and context handle.
 		 */
 		*context_handle =
-			*((gssd_ctx_id_t *)
-			res.context_handle.GSS_CTX_ID_T_val);
+		    *((gssd_ctx_id_t *)res.context_handle.GSS_CTX_ID_T_val);
 		*gssd_context_verifier = res.gssd_context_verifier;
 
 		if (res.status == GSS_S_COMPLETE) {
 			if (actual_mech_type != NULL) {
 				*actual_mech_type =
-					(gss_OID) MALLOC(sizeof (gss_OID_desc));
+				    (gss_OID) MALLOC(sizeof (gss_OID_desc));
 				(*actual_mech_type)->length =
-					(OM_UINT32)
-					res.actual_mech_type.GSS_OID_len;
+				    (OM_UINT32)res.actual_mech_type.GSS_OID_len;
 				(*actual_mech_type)->elements =
-					(void *)
-					MALLOC((*actual_mech_type)->length);
+				    (void *)MALLOC((*actual_mech_type)->length);
 				(void) memcpy((*actual_mech_type)->elements,
-					(void *)
-					res.actual_mech_type.GSS_OID_val,
-					(*actual_mech_type)->length);
+				    (void *)res.actual_mech_type.GSS_OID_val,
+				    (*actual_mech_type)->length);
 			}
 
 
@@ -893,7 +892,7 @@ kgss_init_sec_context(
 		 * upcalls to gssd.
 		 */
 		kctx->mech = &default_gc;
-		kctx->gssd_ctx = (gssd_ctx_id_t)GSS_C_NO_CONTEXT;
+		kctx->gssd_ctx = (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT;
 		*context_handle = (gss_ctx_id_t)kctx;
 	} else
 		kctx = (struct kgss_ctx *)*context_handle;
@@ -901,8 +900,10 @@ kgss_init_sec_context(
 	if (claimant_cred_handle != GSS_C_NO_CREDENTIAL) {
 		gssd_cred_verifier = KCRED_TO_CREDV(claimant_cred_handle);
 		gssd_cl_cred_handle = KCRED_TO_CRED(claimant_cred_handle);
-	} else
-		gssd_cl_cred_handle = (gssd_cred_id_t)GSS_C_NO_CREDENTIAL;
+	} else {
+		gssd_cl_cred_handle =
+		    (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL;
+	}
 
 	/*
 	 * We need to know the resulting mechanism oid, so allocate
@@ -912,10 +913,10 @@ kgss_init_sec_context(
 		actual_mech_type = &amt;
 
 	err = kgss_init_sec_context_wrapped(minor_status, gssd_cl_cred_handle,
-		gssd_cred_verifier, &kctx->gssd_ctx, &kctx->gssd_ctx_verifier,
-		target_name, mech_type, req_flags, time_req,
-		input_chan_bindings, input_token, actual_mech_type,
-		output_token, ret_flags, time_rec, uid);
+	    gssd_cred_verifier, &kctx->gssd_ctx, &kctx->gssd_ctx_verifier,
+	    target_name, mech_type, req_flags, time_req,
+	    input_chan_bindings, input_token, actual_mech_type,
+	    output_token, ret_flags, time_rec, uid);
 
 	if (GSS_ERROR(err)) {
 		KGSS_FREE(kctx);
@@ -965,8 +966,8 @@ kgss_accept_sec_context_wrapped(
 
 	if ((clnt = getgssd_handle()) == NULL) {
 		GSSLOG(1,
-		"kgss_accept_sec_context: can't connect to server on %s\n",
-		server);
+		    "kgss_accept_sec_context: can't connect to server on %s\n",
+		    server);
 		return (GSS_S_FAILURE);
 	}
 
@@ -975,44 +976,42 @@ kgss_accept_sec_context_wrapped(
 	arg.uid = (OM_uint32)uid;
 
 	arg.context_handle.GSS_CTX_ID_T_len =
-		*context_handle == (gssd_ctx_id_t)GSS_C_NO_CONTEXT ?
-			0 : (uint_t)sizeof (gssd_ctx_id_t);
+	    *context_handle == (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT ?
+	    0 : (uint_t)sizeof (gssd_ctx_id_t);
 	arg.context_handle.GSS_CTX_ID_T_val =  (char *)context_handle;
 	arg.gssd_context_verifier = *gssd_context_verifier;
 
 	arg.verifier_cred_handle.GSS_CRED_ID_T_len =
-			verifier_cred_handle ==
-			(gssd_cred_id_t)GSS_C_NO_CREDENTIAL ?
-			0 : (uint_t)sizeof (gssd_cred_id_t);
+	    verifier_cred_handle ==
+	    (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL ?
+	    0 : (uint_t)sizeof (gssd_cred_id_t);
 	arg.verifier_cred_handle.GSS_CRED_ID_T_val =
-						(char *)&verifier_cred_handle;
+	    (char *)&verifier_cred_handle;
 	arg.gssd_cred_verifier = gssd_cred_verifier;
 
 	arg.input_token_buffer.GSS_BUFFER_T_len =
-			(uint_t)(input_token != GSS_C_NO_BUFFER ?
-						input_token->length : 0);
+	    (uint_t)(input_token != GSS_C_NO_BUFFER ? input_token->length : 0);
 	arg.input_token_buffer.GSS_BUFFER_T_val =
-			(char *)(input_token != GSS_C_NO_BUFFER ?
-						input_token->value : 0);
+	    (char *)(input_token != GSS_C_NO_BUFFER ? input_token->value : 0);
 
 	if (input_chan_bindings != GSS_C_NO_CHANNEL_BINDINGS) {
 		arg.input_chan_bindings.present = YES;
 		arg.input_chan_bindings.initiator_addrtype =
-			input_chan_bindings->initiator_addrtype;
+		    input_chan_bindings->initiator_addrtype;
 		arg.input_chan_bindings.initiator_address.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->initiator_address.length;
+		    (uint_t)input_chan_bindings->initiator_address.length;
 		arg.input_chan_bindings.initiator_address.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->initiator_address.value;
+		    (void *)input_chan_bindings->initiator_address.value;
 		arg.input_chan_bindings.acceptor_addrtype =
-			input_chan_bindings->acceptor_addrtype;
+		    input_chan_bindings->acceptor_addrtype;
 		arg.input_chan_bindings.acceptor_address.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->acceptor_address.length;
+		    (uint_t)input_chan_bindings->acceptor_address.length;
 		arg.input_chan_bindings.acceptor_address.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->acceptor_address.value;
+		    (void *)input_chan_bindings->acceptor_address.value;
 		arg.input_chan_bindings.application_data.GSS_BUFFER_T_len =
-			(uint_t)input_chan_bindings->application_data.length;
+		    (uint_t)input_chan_bindings->application_data.length;
 		arg.input_chan_bindings.application_data.GSS_BUFFER_T_val =
-			(void *)input_chan_bindings->application_data.value;
+		    (void *)input_chan_bindings->application_data.value;
 	} else {
 
 		arg.input_chan_bindings.present = NO;
@@ -1057,19 +1056,16 @@ kgss_accept_sec_context_wrapped(
 		*minor_status = res.minor_status;
 
 	if (output_token != NULL && res.output_token.GSS_BUFFER_T_val != NULL) {
-		output_token->length =
-			res.output_token.GSS_BUFFER_T_len;
-		output_token->value =
-			(void *)  MALLOC(output_token->length);
+		output_token->length = res.output_token.GSS_BUFFER_T_len;
+		output_token->value = (void *)  MALLOC(output_token->length);
 		(void) memcpy(output_token->value,
-			    res.output_token.GSS_BUFFER_T_val,
-			    output_token->length);
+		    res.output_token.GSS_BUFFER_T_val, output_token->length);
 	}
 
 	/* if the call was successful, copy out the results */
 
 	if (res.status == (OM_uint32) GSS_S_COMPLETE ||
-		res.status == (OM_uint32) GSS_S_CONTINUE_NEEDED) {
+	    res.status == (OM_uint32) GSS_S_CONTINUE_NEEDED) {
 
 		/*
 		 * the only parameters that are ready when we
@@ -1078,17 +1074,18 @@ kgss_accept_sec_context_wrapped(
 		 */
 
 		*context_handle = *((gssd_ctx_id_t *)
-			res.context_handle.GSS_CTX_ID_T_val);
+		    res.context_handle.GSS_CTX_ID_T_val);
 			*gssd_context_verifier = res.gssd_context_verifier;
 
 		/* these other parameters are only ready upon GSS_S_COMPLETE */
 		if (res.status == (OM_uint32) GSS_S_COMPLETE) {
 
 			if (src_name != NULL) {
-			    src_name->length = res.src_name.GSS_BUFFER_T_len;
-			    src_name->value = res.src_name.GSS_BUFFER_T_val;
-			    res.src_name.GSS_BUFFER_T_val = NULL;
-			    res.src_name.GSS_BUFFER_T_len = 0;
+				src_name->length =
+				    res.src_name.GSS_BUFFER_T_len;
+				src_name->value = res.src_name.GSS_BUFFER_T_val;
+				res.src_name.GSS_BUFFER_T_val = NULL;
+				res.src_name.GSS_BUFFER_T_len = 0;
 			}
 
 			/*
@@ -1096,15 +1093,15 @@ kgss_accept_sec_context_wrapped(
 			 * for gss_import_name_for_mech()
 			 */
 			if (mech_type != NULL) {
-				*mech_type = (gss_OID)
-					MALLOC(sizeof (gss_OID_desc));
+				*mech_type =
+				    (gss_OID)MALLOC(sizeof (gss_OID_desc));
 				(*mech_type)->length =
-					(OM_UINT32) res.mech_type.GSS_OID_len;
+				    (OM_UINT32) res.mech_type.GSS_OID_len;
 				(*mech_type)->elements =
-					(void *) MALLOC((*mech_type)->length);
+				    (void *) MALLOC((*mech_type)->length);
 				(void) memcpy((*mech_type)->elements,
-					res.mech_type.GSS_OID_val,
-					(*mech_type)->length);
+				    res.mech_type.GSS_OID_val,
+				    (*mech_type)->length);
 			}
 
 			if (ret_flags != NULL)
@@ -1114,14 +1111,14 @@ kgss_accept_sec_context_wrapped(
 				*time_rec = res.time_rec;
 
 			if ((delegated_cred_handle != NULL) &&
-				(res.delegated_cred_handle.GSS_CRED_ID_T_len
-				!= 0)) {
+			    (res.delegated_cred_handle.GSS_CRED_ID_T_len
+			    != 0)) {
 				kcred = KGSS_CRED_ALLOC();
 				kcred->gssd_cred =
-				*((gssd_cred_id_t *)
-				res.delegated_cred_handle.GSS_CRED_ID_T_val);
+				    *((gssd_cred_id_t *)
+				    res.delegated_cred_handle.GSS_CRED_ID_T_val);
 				kcred->gssd_cred_verifier =
-					res.gssd_context_verifier;
+				    res.gssd_context_verifier;
 				*delegated_cred_handle = (gss_cred_id_t)kcred;
 			}
 
@@ -1172,7 +1169,7 @@ kgss_accept_sec_context(
 	if (*context_handle == GSS_C_NO_CONTEXT) {
 		kctx = KGSS_ALLOC();
 		kctx->mech = &default_gc;
-		kctx->gssd_ctx = (gssd_ctx_id_t)GSS_C_NO_CONTEXT;
+		kctx->gssd_ctx = (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT;
 		*context_handle = (gss_ctx_id_t)kctx;
 	} else
 		kctx = (struct kgss_ctx *)*context_handle;
@@ -1180,15 +1177,17 @@ kgss_accept_sec_context(
 	if (verifier_cred_handle != GSS_C_NO_CREDENTIAL) {
 		gssd_cred_verifier = KCRED_TO_CREDV(verifier_cred_handle);
 		gssd_ver_cred_handle = KCRED_TO_CRED(verifier_cred_handle);
-	} else
-		gssd_ver_cred_handle = (gssd_cred_id_t)GSS_C_NO_CREDENTIAL;
+	} else {
+		gssd_ver_cred_handle =
+		    (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL;
+	}
 
 	err = kgss_accept_sec_context_wrapped(minor_status,
-		&kctx->gssd_ctx, &kctx->gssd_ctx_verifier,
-		gssd_ver_cred_handle, gssd_cred_verifier,
-		input_token, input_chan_bindings, src_name,
-		mech_type, output_token, ret_flags,
-		time_rec, delegated_cred_handle, uid);
+	    &kctx->gssd_ctx, &kctx->gssd_ctx_verifier,
+	    gssd_ver_cred_handle, gssd_cred_verifier,
+	    input_token, input_chan_bindings, src_name,
+	    mech_type, output_token, ret_flags,
+	    time_rec, delegated_cred_handle, uid);
 
 	if (GSS_ERROR(err)) {
 		KGSS_FREE(kctx);
@@ -1304,7 +1303,7 @@ kgss_delete_sec_context_wrapped(void *private,
 	/* copy the procedure arguments into the rpc arg parameter */
 
 	arg.context_handle.GSS_CTX_ID_T_len =
-		*context_handle == (gssd_ctx_id_t)GSS_C_NO_CONTEXT ?
+		*context_handle == (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT ?
 			0 : (uint_t)sizeof (gssd_ctx_id_t);
 	arg.context_handle.GSS_CTX_ID_T_val =  (char *)context_handle;
 
@@ -1377,17 +1376,18 @@ kgss_delete_sec_context(
 		kctx = (struct kgss_ctx *)*context_handle;
 
 	if (kctx->ctx_imported == FALSE) {
-		if (kctx->gssd_ctx == (gssd_ctx_id_t)GSS_C_NO_CONTEXT) {
+		if (kctx->gssd_ctx ==
+		    (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT) {
 			KGSS_FREE(kctx);
 			*context_handle = GSS_C_NO_CONTEXT;
 			return (GSS_S_COMPLETE);
 		}
 		err = kgss_delete_sec_context_wrapped(
-				KCTX_TO_PRIVATE(*context_handle),
-				minor_status,
-				&kctx->gssd_ctx,
-				output_token,
-				kctx->gssd_ctx_verifier);
+		    KCTX_TO_PRIVATE(*context_handle),
+		    minor_status,
+		    &kctx->gssd_ctx,
+		    output_token,
+		    kctx->gssd_ctx_verifier);
 	} else {
 		if (kctx->gssd_i_ctx == (gss_ctx_id_t)GSS_C_NO_CONTEXT) {
 			KGSS_FREE(kctx);
@@ -1395,7 +1395,7 @@ kgss_delete_sec_context(
 			return (GSS_S_COMPLETE);
 		}
 		err = KGSS_DELETE_SEC_CONTEXT(minor_status, kctx,
-				&kctx->gssd_i_ctx,  output_token);
+		    &kctx->gssd_i_ctx,  output_token);
 	}
 	KGSS_FREE(kctx);
 	*context_handle = GSS_C_NO_CONTEXT;
@@ -1553,7 +1553,7 @@ gss_buffer_desc token;
 gss_ctx_id_t	internal_ctx_id;
 	kctx = (struct kgss_ctx *)context_handle;
 
-	if (kctx->gssd_ctx != (gssd_ctx_id_t)GSS_C_NO_CONTEXT) {
+	if (kctx->gssd_ctx != (gssd_ctx_id_t)(uintptr_t)GSS_C_NO_CONTEXT) {
 		return (GSS_S_FAILURE);
 	}
 
@@ -1682,7 +1682,7 @@ kgss_sign_wrapped(void *private,
 		msg_token->length = res.msg_token.GSS_BUFFER_T_len;
 		msg_token->value = (void *) MALLOC(msg_token->length);
 		(void) memcpy(msg_token->value, res.msg_token.GSS_BUFFER_T_val,
-			msg_token->length);
+		    msg_token->length);
 	}
 
 	/*
@@ -1707,7 +1707,7 @@ kgss_sign(
 	if (context_handle == GSS_C_NO_CONTEXT)
 		return (GSS_S_FAILURE);
 	return (KGSS_SIGN(minor_status, context_handle, qop_req,
-			message_buffer, msg_token));
+	    message_buffer, msg_token));
 }
 
 /*ARGSUSED*/
@@ -1732,7 +1732,7 @@ kgss_verify_wrapped(void *private,
 
 	if ((clnt = getgssd_handle()) == NULL) {
 		GSSLOG(1, "kgss_verify: can't connect to server on %s\n",
-			server);
+		    server);
 		return (GSS_S_FAILURE);
 	}
 
@@ -1796,9 +1796,7 @@ kgss_verify(OM_uint32 *minor_status,
 	if (context_handle == GSS_C_NO_CONTEXT)
 		return (GSS_S_FAILURE);
 	return (KGSS_VERIFY(minor_status, context_handle,
-			    message_buffer,
-			    token_buffer,
-			    qop_state));
+	    message_buffer, token_buffer, qop_state));
 }
 
 /* EXPORT DELETE START */
@@ -1844,10 +1842,10 @@ kgss_seal_wrapped(void *private,
 	arg.qop_req = qop_req;
 
 	arg.input_message_buffer.GSS_BUFFER_T_len =
-					(uint_t)input_message_buffer->length;
+	    (uint_t)input_message_buffer->length;
 
 	arg.input_message_buffer.GSS_BUFFER_T_val =
-					(char *)input_message_buffer->value;
+	    (char *)input_message_buffer->value;
 
 	/* call the remote procedure */
 
@@ -1881,13 +1879,13 @@ kgss_seal_wrapped(void *private,
 
 	if (output_message_buffer != NULL) {
 		output_message_buffer->length =
-				res.output_message_buffer.GSS_BUFFER_T_len;
+		    res.output_message_buffer.GSS_BUFFER_T_len;
 
 		output_message_buffer->value =
-				(void *) MALLOC(output_message_buffer->length);
+		    (void *) MALLOC(output_message_buffer->length);
 		(void) memcpy(output_message_buffer->value,
-			res.output_message_buffer.GSS_BUFFER_T_val,
-			output_message_buffer->length);
+		    res.output_message_buffer.GSS_BUFFER_T_val,
+		    output_message_buffer->length);
 	}
 
 	/*
@@ -1942,7 +1940,7 @@ kgss_unseal_wrapped(void *private,
 
 	if ((clnt = getgssd_handle()) == NULL) {
 		GSSLOG(1, "kgss_unseal: can't connect to server on %s\n",
-			server);
+		    server);
 		return (GSS_S_FAILURE);
 	}
 
@@ -1956,10 +1954,10 @@ kgss_unseal_wrapped(void *private,
 	arg.gssd_context_verifier = gssd_context_verifier;
 
 	arg.input_message_buffer.GSS_BUFFER_T_len =
-					(uint_t)input_message_buffer->length;
+	    (uint_t)input_message_buffer->length;
 
 	arg.input_message_buffer.GSS_BUFFER_T_val =
-					(char *)input_message_buffer->value;
+	    (char *)input_message_buffer->value;
 
 	/* call the remote procedure */
 
@@ -1992,13 +1990,13 @@ kgss_unseal_wrapped(void *private,
 
 	if (output_message_buffer != NULL) {
 		output_message_buffer->length =
-				res.output_message_buffer.GSS_BUFFER_T_len;
+		    res.output_message_buffer.GSS_BUFFER_T_len;
 
 		output_message_buffer->value =
-			(void *) MALLOC(output_message_buffer->length);
+		    (void *) MALLOC(output_message_buffer->length);
 		(void) memcpy(output_message_buffer->value,
-			res.output_message_buffer.GSS_BUFFER_T_val,
-			output_message_buffer->length);
+		    res.output_message_buffer.GSS_BUFFER_T_val,
+		    output_message_buffer->length);
 	}
 
 	if (conf_state != NULL)
@@ -2030,7 +2028,7 @@ kgss_unseal(OM_uint32 *minor_status,
 		return (GSS_S_FAILURE);
 
 	return (KGSS_UNSEAL(minor_status, context_handle, input_message_buffer,
-		output_message_buffer, conf_state, qop_state));
+	    output_message_buffer, conf_state, qop_state));
 }
 
 /* EXPORT DELETE END */
@@ -2258,8 +2256,8 @@ kgss_inquire_cred_wrapped(minor_status,
 	arg.uid = (OM_uint32) uid;
 
 	arg.cred_handle.GSS_CRED_ID_T_len =
-			cred_handle == (gssd_cred_id_t)GSS_C_NO_CREDENTIAL ?
-			0 : (uint_t)sizeof (gssd_cred_id_t);
+	    cred_handle == (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL ?
+	    0 : (uint_t)sizeof (gssd_cred_id_t);
 	arg.cred_handle.GSS_CRED_ID_T_val = (char *)&cred_handle;
 	arg.gssd_cred_verifier = gssd_cred_verifier;
 
@@ -2410,8 +2408,8 @@ kgss_inquire_cred_by_mech_wrapped(minor_status,
 	arg.uid = (OM_uint32) uid;
 
 	arg.cred_handle.GSS_CRED_ID_T_len =
-			cred_handle == (gssd_cred_id_t)GSS_C_NO_CREDENTIAL ?
-			0 : (uint_t)sizeof (gssd_cred_id_t);
+	    cred_handle == (gssd_cred_id_t)(uintptr_t)GSS_C_NO_CREDENTIAL ?
+	    0 : (uint_t)sizeof (gssd_cred_id_t);
 	arg.cred_handle.GSS_CRED_ID_T_val = (char *)&cred_handle;
 	arg.gssd_cred_verifier = gssd_cred_verifier;
 
@@ -2701,7 +2699,7 @@ kgss_get_kmod(gss_OID mech_oid)
 	/* get the client GSSD handle */
 	if ((clnt = getgssd_handle()) == NULL) {
 		GSSLOG(1, "kgss_get_kmod: can't connect to server on %s\n",
-			server);
+		    server);
 		return (NULL);
 	}
 
@@ -2763,9 +2761,9 @@ __kgss_reset_mech(gss_mechanism *mechp, gss_OID mech_oid)
 			 * appropriate comment
 			 */
 			cmn_err(CE_NOTE, "kgss_reset_mech: Algorithm modload "
-				"(%s) failed. Userland gssd will now handle "
-				"all GSSAPI calls, which may result in "
-				"reduced performance.\n", kmod);
+			    "(%s) failed. Userland gssd will now handle "
+			    "all GSSAPI calls, which may result in "
+			    "reduced performance.\n", kmod);
 		};
 
 		/*