bsd/sys/uio_internal.h

   1 /*
   2  * Copyright (c) 2006 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  31 /*
  32  * Copyright (c) 1982, 1986, 1993, 1994
  33  *      The Regents of the University of California.  All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  * 3. All advertising materials mentioning features or use of this software
  44  *    must display the following acknowledgement:
  45  *      This product includes software developed by the University of
  46  *      California, Berkeley and its contributors.
  47  * 4. Neither the name of the University nor the names of its contributors
  48  *    may be used to endorse or promote products derived from this software
  49  *    without specific prior written permission.
  50  *
  51  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  52  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  53  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  54  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  55  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  56  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  57  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  58  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  59  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  60  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  61  * SUCH DAMAGE.
  62  *
  63  *      @(#)uio.h       8.5 (Berkeley) 2/22/94
  64  */
  65
  66 #ifndef _SYS_UIO_INTERNAL_H_
  67 #define _SYS_UIO_INTERNAL_H_
  68
  69 #include <sys/appleapiopts.h>
  70
  71 #ifdef KERNEL_PRIVATE
  72 #include <sys/uio.h>
  73 #include <sys/malloc.h>
  74
  75 /*
  76  * user / kernel address space type flags.
  77  * WARNING - make sure to check when adding flags!  Be sure new flags
  78  * don't overlap the definitions in uio.h
  79  */
  80 //      UIO_USERSPACE                           0       defined in uio.h
  81 #define UIO_USERISPACE                  1
  82 //      UIO_SYSSPACE                            2       defined in uio.h
  83 #define UIO_PHYS_USERSPACE              3
  84 #define UIO_PHYS_SYSSPACE               4
  85 //      UIO_USERSPACE32                         5       defined in uio.h
  86 #define UIO_USERISPACE32                6
  87 #define UIO_PHYS_USERSPACE32    7
  88 //      UIO_USERSPACE64                         8       defined in uio.h
  89 #define UIO_USERISPACE64                9
  90 #define UIO_PHYS_USERSPACE64    10
  91 //      UIO_SYSSPACE32                          11      defined in uio.h
  92 #define UIO_PHYS_SYSSPACE32             12
  93 #define UIO_SYSSPACE64                  13
  94 #define UIO_PHYS_SYSSPACE64             14
  95
  96 __BEGIN_DECLS
  97 struct user_iovec;
  98
  99 // uio_iovsaddr was __private_extern__ temporary chnage for 3777436
 100 struct user_iovec * uio_iovsaddr( uio_t a_uio );
 101 __private_extern__ void uio_calculateresid( uio_t a_uio );
 102 __private_extern__ void uio_setcurriovlen( uio_t a_uio, user_size_t a_value );
 103 // uio_spacetype was __private_extern__ temporary chnage for 3777436
 104 int uio_spacetype( uio_t a_uio );
 105 __private_extern__ uio_t
 106         uio_createwithbuffer( int a_iovcount, off_t a_offset, int a_spacetype,
 107                                                         int a_iodirection, void *a_buf_p, int a_buffer_size );
 108
 109 /* use kern_iovec for system space requests */
 110 struct kern_iovec {
 111         u_int32_t       iov_base;       /* Base address. */
 112         u_int32_t       iov_len;        /* Length. */
 113 };
 114
 115 /* use user_iovec for user space requests */
 116 struct user_iovec {
 117         user_addr_t     iov_base;       /* Base address. */
 118         user_size_t     iov_len;        /* Length. */
 119 };
 120
 121 #if 1 // LP64todo - remove this after kext adopt new KPI
 122 #define uio_iov uio_iovs.iovp
 123 #define iovec_32 kern_iovec
 124 #define iovec_64 user_iovec
 125 #define iov32p kiovp
 126 #define iov64p uiovp
 127 #endif
 128
 129 union iovecs {
 130         struct iovec            *iovp;
 131         struct kern_iovec       *kiovp;
 132         struct user_iovec       *uiovp;
 133 };
 134
 135 /* WARNING - use accessor calls for uio_iov and uio_resid since these */
 136 /* fields vary depending on the originating address space. */
 137 struct uio {
 138         union iovecs    uio_iovs;               /* current iovec */
 139         int                             uio_iovcnt;             /* active iovecs */
 140         off_t                   uio_offset;
 141         int                             uio_resid;              /* compatibility uio_resid (pre-LP64) */
 142         enum uio_seg    uio_segflg;
 143         enum uio_rw     uio_rw;
 144         proc_t                  uio_procp;              /* obsolete - not used! */
 145         user_ssize_t    uio_resid_64;
 146         int                             uio_size;               /* size for use with kfree */
 147         int                             uio_max_iovs;   /* max number of iovecs this uio_t can hold */
 148         u_int32_t               uio_flags;
 149 };
 150
 151 /* values for uio_flags */
 152 #define UIO_FLAGS_INITED                0x00000001
 153 #define UIO_FLAGS_WE_ALLOCED    0x00000002
 154
 155 __END_DECLS
 156
 157 /*
 158  * UIO_SIZEOF - return the amount of space a uio_t requires to
 159  *      contain the given number of iovecs.  Use this macro to
 160  *  create a stack buffer that can be passed to uio_createwithbuffer.
 161  */
 162 #define UIO_SIZEOF( a_iovcount ) \
 163         ( sizeof(struct uio) + (sizeof(struct user_iovec) * (a_iovcount)) )
 164
 165 #define UIO_IS_64_BIT_SPACE( a_uio_t )  \
 166         ( (a_uio_t)->uio_segflg == UIO_USERSPACE64 || (a_uio_t)->uio_segflg == UIO_USERISPACE64 || \
 167           (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE64  || (a_uio_t)->uio_segflg == UIO_SYSSPACE64 || \
 168           (a_uio_t)->uio_segflg == UIO_PHYS_SYSSPACE64 )
 169
 170 #define UIO_IS_32_BIT_SPACE( a_uio_t )  \
 171         ( (a_uio_t)->uio_segflg == UIO_USERSPACE || (a_uio_t)->uio_segflg == UIO_USERISPACE || \
 172           (a_uio_t)->uio_segflg == UIO_SYSSPACE  || (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE || \
 173           (a_uio_t)->uio_segflg == UIO_USERISPACE32  || (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE32 || \
 174           (a_uio_t)->uio_segflg == UIO_SYSSPACE32  || (a_uio_t)->uio_segflg == UIO_PHYS_SYSSPACE32 || \
 175           (a_uio_t)->uio_segflg == UIO_PHYS_SYSSPACE || (a_uio_t)->uio_segflg == UIO_USERSPACE32 )
 176
 177 #define UIO_IS_USER_SPACE32( a_uio_t )  \
 178         ( (a_uio_t)->uio_segflg == UIO_USERSPACE32 || (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE32 || \
 179           (a_uio_t)->uio_segflg == UIO_USERISPACE32 )
 180 #define UIO_IS_USER_SPACE64( a_uio_t )  \
 181         ( (a_uio_t)->uio_segflg == UIO_USERSPACE64 || (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE64 || \
 182           (a_uio_t)->uio_segflg == UIO_USERISPACE64 )
 183 #define UIO_IS_USER_SPACE( a_uio_t )  \
 184         ( UIO_IS_USER_SPACE32((a_uio_t)) || UIO_IS_USER_SPACE64((a_uio_t)) || \
 185           (a_uio_t)->uio_segflg == UIO_USERSPACE || (a_uio_t)->uio_segflg == UIO_USERISPACE || \
 186            (a_uio_t)->uio_segflg == UIO_PHYS_USERSPACE )
 187
 188
 189 /*
 190  * W A R N I N G!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 191  * anything in this section will be removed.  please move to the uio KPI
 192  */
 193
 194 #if 1 // UIO_KPI - WARNING OBSOLETE!!!!   LP64todo - remove these!!!!
 195 // DO NOT USE THESE
 196 #define IS_UIO_USER_SPACE32( segflg )  \
 197         ( (segflg) == UIO_USERSPACE32 || (segflg) == UIO_PHYS_USERSPACE32 || \
 198           (segflg) == UIO_USERISPACE32 )
 199 #define IS_UIO_USER_SPACE64( segflg )  \
 200         ( (segflg) == UIO_USERSPACE64 || (segflg) == UIO_PHYS_USERSPACE64 || \
 201           (segflg) == UIO_USERISPACE64 )
 202 #define IS_UIO_USER_SPACE( segflg )  \
 203         ( IS_UIO_USER_SPACE32((segflg)) || IS_UIO_USER_SPACE64((segflg)) || \
 204           (segflg) == UIO_USERSPACE || (segflg) == UIO_USERISPACE || \
 205            (segflg) == UIO_PHYS_USERSPACE )
 206
 207 #define IS_UIO_SYS_SPACE32( segflg )  \
 208         ( (segflg) == UIO_SYSSPACE32 || (segflg) == UIO_PHYS_SYSSPACE32 || \
 209           (segflg) == UIO_SYSSPACE || (segflg) == UIO_PHYS_SYSSPACE )
 210 #define IS_UIO_SYS_SPACE64( segflg )  \
 211         ( (segflg) == UIO_SYSSPACE64 || (segflg) == UIO_PHYS_SYSSPACE64 )
 212 #define IS_UIO_SYS_SPACE( segflg )  \
 213         ( IS_UIO_SYS_SPACE32((segflg)) || IS_UIO_SYS_SPACE64((segflg)) )
 214
 215 #define IS_OBSOLETE_UIO_SEGFLG(segflg)  \
 216         ( (segflg) == UIO_USERSPACE || (segflg) == UIO_USERISPACE || \
 217           (segflg) == UIO_SYSSPACE  || (segflg) == UIO_PHYS_USERSPACE || \
 218           (segflg) == UIO_PHYS_SYSSPACE )
 219 #define IS_VALID_UIO_SEGFLG(segflg)  \
 220         ( IS_UIO_USER_SPACE((segflg)) || IS_UIO_SYS_SPACE((segflg)) )
 221
 222 /* accessor routines for uio and embedded iovecs */
 223 // WARNING all these are OBSOLETE!!!!
 224 static inline int64_t uio_uio_resid( struct uio *a_uiop );
 225 static inline void uio_uio_resid_add( struct uio *a_uiop, int64_t a_amount );
 226 static inline void uio_uio_resid_set( struct uio *a_uiop, int64_t a_value );
 227
 228 static inline void uio_iov_base_add( struct uio *a_uiop, int64_t a_amount );
 229 static inline void uio_iov_base_add_at( struct uio *a_uiop, int64_t a_amount, int a_index );
 230 static inline void uio_iov_len_add( struct uio *a_uiop, int64_t a_amount );
 231 static inline void uio_iov_len_add_at( struct uio *a_uiop, int64_t a_amount, int a_index );
 232 static inline u_int64_t uio_iov_len( struct uio *a_uiop );
 233 static inline u_int64_t uio_iov_len_at( struct uio *a_uiop, int a_index );
 234 static inline u_int64_t uio_iov_base( struct uio *a_uiop );
 235 static inline u_int64_t uio_iov_base_at( struct uio *a_uiop, int a_index );
 236 static inline void uio_next_iov( struct uio *a_uiop );
 237 static inline void uio_iov_len_set( struct uio *a_uiop, u_int64_t a_value );
 238 static inline void uio_iov_len_set_at( struct uio *a_uiop, u_int64_t a_value, int a_index );
 239
 240
 241 static inline int64_t uio_uio_resid( struct uio *a_uiop )
 242 {
 243 //#warning obsolete - use uio_resid call
 244         return( (int64_t)a_uiop->uio_resid );
 245 }
 246
 247 static inline void uio_uio_resid_add( struct uio *a_uiop, int64_t a_amount )
 248 {
 249 //#warning obsolete - use uio_update or uio_addiov or uio_setresid if in kernel and you must
 250         a_uiop->uio_resid += ((int32_t) a_amount);
 251 }
 252
 253 static inline void uio_uio_resid_set( struct uio *a_uiop, int64_t a_value )
 254 {
 255 //#warning obsolete - use uio_update or uio_addiov or uio_setresid if in kernel and you must
 256         a_uiop->uio_resid = a_value;
 257 }
 258
 259 static inline u_int64_t uio_iov_base( struct uio *a_uiop )
 260 {
 261 //#warning obsolete - use uio_curriovbase call
 262         return(uio_iov_base_at(a_uiop, 0));
 263 }
 264
 265 static inline u_int64_t uio_iov_base_at( struct uio *a_uiop, int a_index )
 266 {
 267 //#warning obsolete - use uio_curriovbase call
 268         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) || IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 269                 /* user space iovec was most likely a struct iovec so we must cast to uintptr_t first */
 270                 return((u_int64_t)((uintptr_t)a_uiop->uio_iovs.iov32p[a_index].iov_base));
 271         }
 272         if (IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)) {
 273                 return((u_int64_t)a_uiop->uio_iovs.iov32p[a_index].iov_base);
 274         }
 275         if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 276                 return(a_uiop->uio_iovs.iov64p[a_index].iov_base);
 277         }
 278         return(0);
 279 }
 280
 281 static inline u_int64_t uio_iov_len( struct uio *a_uiop )
 282 {
 283 //#warning obsolete - use uio_curriovlen call
 284         return(uio_iov_len_at(a_uiop, 0));
 285 }
 286
 287 static inline u_int64_t uio_iov_len_at( struct uio *a_uiop, int a_index )
 288 {
 289 //#warning obsolete - use uio_curriovlen call
 290         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) ||
 291                 IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)  ||
 292                 IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 293                 return((u_int64_t)a_uiop->uio_iovs.iov32p[a_index].iov_len);
 294         }
 295         if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 296                 return(a_uiop->uio_iovs.iov64p[a_index].iov_len);
 297         }
 298         return(0);
 299 }
 300
 301 static inline void uio_iov_len_set_at( struct uio *a_uiop, u_int64_t a_value, int a_index )
 302 {
 303 //#warning obsolete - use uio_addiov call
 304         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) ||
 305                 IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)  ||
 306                 IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 307                 a_uiop->uio_iovs.iov32p[a_index].iov_len = a_value;
 308         }
 309         else if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 310                 a_uiop->uio_iovs.iov64p[a_index].iov_len = a_value;
 311         }
 312         return;
 313 }
 314
 315 static inline void uio_iov_len_set( struct uio *a_uiop, u_int64_t a_value )
 316 {
 317 //#warning obsolete - use uio_addiov call
 318         return(uio_iov_len_set_at(a_uiop, a_value, 0));
 319 }
 320
 321 static inline void uio_iov_len_add_at( struct uio *a_uiop, int64_t a_amount, int a_index )
 322 {
 323 //#warning obsolete - use uio_addiov call
 324         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) ||
 325                 IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)  ||
 326                 IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 327                 a_uiop->uio_iovs.iov32p[a_index].iov_len += ((int32_t) a_amount);
 328         }
 329         else if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 330                 a_uiop->uio_iovs.iov64p[a_index].iov_len += a_amount;
 331         }
 332         return;
 333 }
 334
 335 static inline void uio_iov_len_add( struct uio *a_uiop, int64_t a_amount )
 336 {
 337 //#warning obsolete - use uio_addiov call
 338         return(uio_iov_len_add_at(a_uiop, a_amount, 0));
 339 }
 340
 341 static inline void uio_iov_base_add_at( struct uio *a_uiop, int64_t a_amount, int a_index )
 342 {
 343 //#warning obsolete - use uio_addiov call
 344         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) ||
 345                 IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)  ||
 346                 IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 347                 a_uiop->uio_iovs.iov32p[a_index].iov_base += ((int32_t) a_amount);
 348         }
 349         else if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 350                 a_uiop->uio_iovs.iov64p[a_index].iov_base += a_amount;
 351         }
 352         return;
 353 }
 354
 355 static inline void uio_iov_base_add( struct uio *a_uiop, int64_t a_amount )
 356 {
 357 //#warning obsolete - use uio_addiov call
 358         return(uio_iov_base_add_at(a_uiop, a_amount, 0));
 359 }
 360
 361 static inline void uio_next_iov( struct uio *a_uiop )
 362 {
 363 //#warning obsolete - use uio_update call
 364         if (IS_UIO_USER_SPACE32(a_uiop->uio_segflg) ||
 365                 IS_UIO_SYS_SPACE32(a_uiop->uio_segflg)  ||
 366                 IS_OBSOLETE_UIO_SEGFLG(a_uiop->uio_segflg)) {
 367                 a_uiop->uio_iovs.iov32p++;
 368         }
 369         else if (IS_UIO_USER_SPACE64(a_uiop->uio_segflg) || IS_UIO_SYS_SPACE64(a_uiop->uio_segflg)) {
 370                 a_uiop->uio_iovs.iov64p++;
 371         }
 372         return;
 373 }
 374
 375 /*
 376  * WARNING - this routine relies on iovec_64 being larger than iovec_32 and will
 377  * not work if you are going to initialize an array of iovec_64 as an array of
 378  * iovec_32 then pass that array in a uio (since uio_iov is always expected to
 379  * be an array of like sized iovecs - see how uio_next_iov gets to the next iovec)
 380  */
 381 static inline void init_iovec( u_int64_t a_base,
 382                                                            u_int64_t a_len,
 383                                                            struct iovec_64 *a_iovp,
 384                                                            int is_64bit_process )
 385 {
 386 //#warning obsolete - use uio_create call
 387         if (is_64bit_process) {
 388                 a_iovp->iov_base = a_base;
 389                 a_iovp->iov_len = a_len;
 390         }
 391         else {
 392                 struct iovec_32 *a_iov32p = (struct iovec_32 *) a_iovp;
 393                 a_iov32p->iov_base = a_base;
 394                 a_iov32p->iov_len = a_len;
 395         }
 396         return;
 397 }
 398
 399 #define INIT_UIO_BASE( uiop, iovcnt, offset, resid, rw, procp ) \
 400 { \
 401         (uiop)->uio_iovcnt = (iovcnt); \
 402         (uiop)->uio_offset = (offset); \
 403         (uiop)->uio_resid = (resid); \
 404         (uiop)->uio_rw = (rw); \
 405         (uiop)->uio_procp = (procp); \
 406 }
 407 #define INIT_UIO_USER32( uiop, iovp, iovcnt, offset, resid, rw, procp ) \
 408 { \
 409         (uiop)->uio_iovs.iov32p = (iovp);  \
 410         (uiop)->uio_segflg = UIO_USERSPACE; \
 411         INIT_UIO_BASE((uiop), (iovcnt), (offset), (resid), (rw), (procp)); \
 412 }
 413 #define INIT_UIO_USER64( uiop, iovp, iovcnt, offset, resid, rw, procp ) \
 414 { \
 415         (uiop)->uio_iovs.iov64p = (iovp);  \
 416         (uiop)->uio_segflg = UIO_USERSPACE64; \
 417         INIT_UIO_BASE((uiop), (iovcnt), (offset), (resid), (rw), (procp)); \
 418 }
 419 #define INIT_UIO_SYS32( uiop, iovp, iovcnt, offset, resid, rw, procp ) \
 420 { \
 421         (uiop)->uio_iovs.iov32p = (iovp);  \
 422         (uiop)->uio_segflg = UIO_SYSSPACE; \
 423         INIT_UIO_BASE((uiop), (iovcnt), (offset), (resid), (rw), (procp)); \
 424 }
 425 #define INIT_UIO_USERSPACE( uiop, iovp, iovcnt, offset, resid, rw, procp ) \
 426 { \
 427         if (IS_64BIT_PROCESS((procp))) { \
 428                 (uiop)->uio_iovs.iov64p = (iovp);  \
 429                 (uiop)->uio_segflg = UIO_USERSPACE64; \
 430         } \
 431         else {  \
 432                 (uiop)->uio_iovs.iov32p = (struct iovec_32 *)(iovp);  \
 433                 (uiop)->uio_segflg = UIO_USERSPACE; \
 434         }  \
 435         INIT_UIO_BASE((uiop), (iovcnt), (offset), (resid), (rw), (procp)); \
 436 }
 437 #define INIT_UIO_SYSSPACE( uiop, iovp, iovcnt, offset, resid, rw, procp ) \
 438 { \
 439         if (0) { /* we do not support 64-bit system space yet */ \
 440                 (uiop)->uio_iovs.iov64p = (iovp);  \
 441                 (uiop)->uio_segflg = UIO_SYSSPACE64; \
 442         } \
 443         else {  \
 444                 (uiop)->uio_iovs.iov32p = (struct iovec_32 *)(iovp);  \
 445                 (uiop)->uio_segflg = UIO_SYSSPACE; \
 446         }  \
 447         INIT_UIO_BASE((uiop), (iovcnt), (offset), (resid), (rw), (procp)); \
 448 }
 449 #endif // UIO_KPI - WARNING OBSOLETE!!!!
 450
 451
 452 #endif /* KERNEL */
 453 #endif /* !_SYS_UIO_INTERNAL_H_ */