uiomove(9f) [opensolaris man page]

uiomove(9F)						   Kernel Functions for Drivers 					       uiomove(9F)

NAME

       uiomove - copy kernel data using uio structure

SYNOPSIS

       #include <sys/types.h>
       #include <sys/uio.h>

       int uiomove(caddr_t address, size_t nbytes, enum uio_rw rwflag,
	    uio_t *uio_p);

INTERFACE LEVEL

       Architecture independent level 1 (DDI/DKI).

PARAMETERS

       address	  Source/destination kernel address of the copy.

       nbytes	  Number of bytes to copy.

       rwflag	  Flag indicating read or write operation. Possible values are UIO_READ and UIO_WRITE.

       uio_p	  Pointer to the uio structure for the copy.

DESCRIPTION

       The uiomove() function copies nbytes of data to or from the space defined by the uio structure (described in uio(9S)) and the driver.

       The  uio_segflg	member	of the uio(9S) structure determines the type of space to or from which the transfer is being made. If it is set to
       UIO_SYSSPACE, the data transfer is between addresses in the kernel. If it is set to UIO_USERSPACE, the transfer is between a  user  program
       and kernel space.

       rwflag indicates the direction of the transfer. If UIO_READ is set, the data will be transferred from address to the buffer(s) described by
       uio_p. If UIO_WRITE is set, the data will be transferred from the buffer(s) described by uio_p to address.

       In addition to moving the data, uiomove() adds the number of bytes moved to the iov_base member of the iovec(9S) structure,  decreases  the
       iov_len member, increases the uio_offset member of the uio(9S) structure, and decreases the uio_resid member.

       This function automatically handles page faults. nbytes does not have to be word-aligned.

RETURN VALUES

       The uiomove() function returns 0 upon success or EFAULT on failure.

CONTEXT

       User context only, if uio_segflg is set to UIO_USERSPACE. User, interrupt, or kernel context, if uio_segflg is set to UIO_SYSSPACE.

SEE ALSO

       ureadc(9F), uwritec(9F), iovec(9S), uio(9S)

       Writing Device Drivers

WARNINGS

       If uio_segflg is set to UIO_SYSSPACE and address is selected from user space, the system may panic.

SunOS 5.11							    16 Jan 2006 						       uiomove(9F)

UIO(9)							   BSD Kernel Developer's Manual						    UIO(9)

NAME

     uio, uiomove -- device driver I/O routines

SYNOPSIS

     #include <sys/types.h>
     #include <sys/uio.h>

     struct uio {
	     struct  iovec *uio_iov;	     /* scatter/gather list */
	     int     uio_iovcnt;	     /* length of scatter/gather list */
	     off_t   uio_offset;	     /* offset in target object */
	     ssize_t uio_resid; 	     /* remaining bytes to copy */
	     enum    uio_seg uio_segflg;     /* address space */
	     enum    uio_rw uio_rw;	     /* operation */
	     struct  thread *uio_td;	     /* owner */
     };

     int
     uiomove(void *buf, int howmuch, struct uio *uiop);

DESCRIPTION

     The function uiomove() is used to handle transfer of data between buffers and I/O vectors that might possibly also cross the user/kernel
     space boundary.

     As a result of any read(2), write(2), readv(2), or writev(2) system call that is being passed to a character-device driver, the appropriate
     driver d_read or d_write entry will be called with a pointer to a struct uio being passed.  The transfer request is encoded in this struc-
     ture.  The driver itself should use uiomove() to get at the data in this structure.

     The fields in the uio structure are:

     uio_iov	 The array of I/O vectors to be processed.  In the case of scatter/gather I/O, this will be more than one vector.

     uio_iovcnt  The number of I/O vectors present.

     uio_offset  The offset into the device.

     uio_resid	 The remaining number of bytes to process, updated after transfer.

     uio_segflg  One of the following flags:

		 UIO_USERSPACE	The I/O vector points into a process's address space.

		 UIO_SYSSPACE	The I/O vector points into the kernel address space.

		 UIO_NOCOPY	Do not copy, already in object.

     uio_rw	 The direction of the desired transfer, either UIO_READ, or UIO_WRITE.

     uio_td	 The pointer to a struct thread for the associated thread; used if uio_segflg indicates that the transfer is to be made from/to a
		 process's address space.

RETURN VALUES

     On success uiomove() will return 0, on error it will return an appropriate errno.

ERRORS

     uiomove() will fail and return the following error code if:

     [EFAULT]		The invoked copyin(9) or copyout(9) returned EFAULT

EXAMPLES

     The idea is that the driver maintains a private buffer for its data, and processes the request in chunks of maximal the size of this buffer.
     Note that the buffer handling below is very simplified and will not work (the buffer pointer is not being advanced in case of a partial
     read), it is just here to demonstrate the uio handling.

     /* MIN() can be found there: */
     #include <sys/param.h>

     #define BUFSIZE 512
     static char buffer[BUFSIZE];

     static int data_available;      /* amount of data that can be read */

     static int
     fooread(dev_t dev, struct uio *uio, int flag)
     {
	     int rv, amnt;

	     rv = 0;
	     while (uio->uio_resid > 0) {
		     if (data_available > 0) {
			     amnt = MIN(uio->uio_resid, data_available);
			     rv = uiomove(buffer, amnt, uio);
			     if (rv != 0)
				     break;
			     data_available -= amnt;
		     } else
			     tsleep(...);    /* wait for a better time */
	     }
	     if (rv != 0) {
		     /* do error cleanup here */
	     }
	     return (rv);
     }

SEE ALSO

     read(2), readv(2), write(2), writev(2), copyin(9), copyout(9), sleep(9)

HISTORY

     The uio mechanism appeared in some early version of UNIX.

AUTHORS

     This manual page was written by Jorg Wunsch.

BSD
								  March 21, 2010							       BSD