![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src|
Return to uio.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV3 1
3:
4: /*
5: * Implementations of the functions which manipulate the uio(4) structure
6: * under the DDI/DKI. This function runs in _SYSV3 mode to interface with
7: * the iBCS2 Coherent kernel.
8: */
9: /*
10: *-IMPORTS:
11: * <common/ccompat.h>
12: * __CONST__
13: * __EXTERN_C_BEGIN__
14: * __EXTERN_C_END__
15: * __USE_PROTO__
16: * __ARGS ()
17: * __PROTO ()
18: * <sys/debug.h>
19: * ASSERT ()
20: * <sys/types.h>
21: * _VOID
22: * size_t
23: * <sys/errno.h>
24: * EFAULT
25: * <limits.h>
26: * CHAR_BIT
27: * UCHAR_MAX
28: * <string.h>
29: * memcpy ()
30: */
31:
32: #include <common/ccompat.h>
33: #include <sys/debug.h>
34: #include <sys/types.h>
35: #include <sys/errno.h>
36: #include <limits.h>
37: #include <string.h>
38:
39: #include <sys/uio.h>
40:
41: #if __COHERENT__
42:
43: #include <sys/coherent.h>
44:
45:
46: /*
47: * Routines to perform transfers between the user and kernel address spaces.
48: */
49:
50: __EXTERN_C_BEGIN__
51:
52: int kucopy __PROTO ((__CONST__ caddr_t ker, caddr_t usr,
53: size_t n));
54: int ukcopy __PROTO ((__CONST__ caddr_t usr, caddr_t ker,
55: size_t n));
56: int getubd __PROTO ((__CONST__ caddr_t usr));
57: void putubd __PROTO ((caddr_t usr, int ch));
58:
59: __EXTERN_C_END__
60:
61: #define TOUSER(usr,ker,n) kucopy ((caddr_t) ker, (caddr_t) usr, n)
62: #define FROMUSER(ker,usr,n) ukcopy ((caddr_t) usr, (caddr_t) ker, n)
63:
64: #define PUTBYTE(c,usr) (putubd (usr, c), u.u_error)
65: #define GETBYTE(usr) ((unsigned char) getubd (usr) - \
66: (u.u_error > 0 ? UCHAR_MAX : 0))
67:
68: #else /* if ! defined (COHERENT) */
69:
70:
71: #define TOUSER(usr,ker,n) (memcpy ((usr), (ker), (n)), (n))
72: #define FROMUSER(ker,usr,n) (memcpy ((ker), (usr), (n)), (n))
73:
74: #define PUTBYTE(c,usr) (* (usr) = (c), 0)
75: #define GETBYTE(usr) (* (unsigned char *) (usr))
76:
77:
78: #endif
79:
80:
81: /*
82: * For some reason the System V DDI/DKI uses "longs" and "ints" in many cases
83: * where a size_t is far more appropriate. We will only work for cases where
84: * the request does not exceed the half range of a size_t.
85: */
86:
87: #define SIZE_T_MAX ((1UL << (sizeof (size_t) * CHAR_BIT - 1)) - 1)
88:
89:
90: /*
91: *-STATUS:
92: * DDI/DKI
93: *
94: *-NAME:
95: * bcopy Copy data between address locations in the kernel.
96: *
97: *-SYNOPSIS:
98: * #include <sys/types.h>
99: *
100: * void bcopy (caddr_t from, caddr_t to, size_t bcount);
101: *
102: *-ARGUMENTS:
103: * from Source address from which the copy is made.
104: *
105: * to Destination address to which the copy is made.
106: *
107: * bcount Number of bytes to be copied.
108: *
109: *-DESCRIPTION:
110: * bcopy () copies "bcount" bytes from one kernel address to another. It
111: * chooses the best algorithm based on address alignment and number of
112: * bytes to copy. If the input and output addresses over, the function
113: * executes, but the results are undefined.
114: *
115: *-RETURN VALUE:
116: * None.
117: *
118: *-LEVEL:
119: * Base or interrupt.
120: *
121: *-NOTES:
122: * Does not sleep.
123: *
124: * Driver-defined basic locks, read/write locks, and sleep locks may be
125: * held across calls to this function.
126: *
127: * The source and destination address ranges must both be within the
128: * kernel address space and must be memory resident. No range checking is
129: * done. Since there is no mechanism by which drivers that conform to the
130: * rules of the DDI/DKI can obtain and use a kernel address which is not
131: * memory resident (an address which is paged out), DDI/DKI conforming
132: * drivers can assume that any address to which they have access is
133: * memory resident and therefore a valid argument to bcopy (). Addresses
134: * within user space are not valid arguments, and specifying such an
135: * address may cause the driver to corrupt the system in an unpredictable
136: * way. For copying between kernel and user space, drivers must use an
137: * appropriate function defined for that purpose (for example, copyin (),
138: * copyout (), uiomove (), ureadc (), or uwritec ()).
139: *
140: *-SEE ALSO:
141: * bzero (), copyin (), copyout (), uiomove (), ureadc (), uwritec ()
142: */
143:
144: #if __USE_PROTO__
145: void (bcopy) (__CONST__ _VOID * from, _VOID * to, size_t bcount)
146: #else
147: void
148: bcopy __ARGS ((from, to, bcount))
149: __CONST__ _VOID
150: * from;
151: _VOID * to;
152: size_t bcount;
153: #endif
154: {
155: ASSERT (to != NULL);
156:
157: (void) memcpy (to, from, bcount);
158: }
159:
160:
161: /*
162: *-STATUS:
163: * DDI/DKI
164: *
165: *-NAME:
166: * bzero Clear memory for a given number of bytes.
167: *
168: *-SYNOPSIS:
169: * #include <sys/types.h>
170: *
171: * void bzero (caddr_t addr, size_t bytes);
172: *
173: *-ARGUMENTS:
174: * addr Starting virtual address of memory to be cleared.
175: *
176: * bytes Number of bytes to clear.
177: *
178: *-DESCRIPTION:
179: * The bzero () function clears a contiguous portion of memory by filling
180: * the memory with zeroes. It chooses the best algorithm based on address
181: * alignment and number of bytes to clear.
182: *
183: *-RETURN VALUE:
184: * None.
185: *
186: *-LEVEL:
187: * Base or interrupt.
188: *
189: *-NOTES:
190: * Does not sleep.
191: *
192: * Driver-defined basic locks, read/write locks, and sleep locks may be
193: * held across calls to this function.
194: *
195: * There are no alignment restrictions on "addr", and no length
196: * restrictions on "bytes", other than the address range specified must
197: * be within the kernel address space and must be memory resident. No
198: * range checking is done. Since there is no mechanism by which drivers
199: * that conform to the rules of the DDI/DKI can obtain and use a kernel
200: * address that is not memory resident (an address that is paged out),
201: * DDI/DKI conforming drivers can assume that any address to which they
202: * have access is memory resident and therefore a valid argument to
203: * bzero (). An address within user space is not a valid argument to
204: * bzero (), and specifying such an address may cause the driver to
205: * corrupt the system in an unpredictable way.
206: *
207: *-SEE ALSO:
208: * bcopy (), kmem_zalloc ()
209: */
210:
211: #if __USE_PROTO__
212: void (bzero) (_VOID * addr, size_t bytes)
213: #else
214: void
215: bzero __ARGS ((addr, bytes))
216: _VOID * addr;
217: size_t bytes;
218: #endif
219: {
220: ASSERT (addr != NULL);
221:
222: (void) memset (addr, 0, bytes);
223: }
224:
225:
226: /*
227: *-STATUS:
228: * DDI/DKI
229: *
230: *-NAME:
231: * copyin Copy data from a user buffer to a driver buffer.
232: *
233: *-SYNOPSIS:
234: * #include <sys/types.h>
235: *
236: * int copyin (caddr_t userbuf, caddr_t driverbuf, size_t count);
237: *
238: *-ARGUMENTS:
239: * userbuf User source address from which copy is made.
240: *
241: * driverbuf Driver destination address to which copy is made.
242: *
243: * count Number of bytes to copy.
244: *
245: *-DESCRIPTION:
246: * copyin () copies "count" bytes of data from the user virtual address
247: * specified by "userbuf" to the kernel virtual address specified by
248: * "driverbuf". The driver must ensure that adequate space is allocated
249: * for the destination address.
250: *
251: * copyin () chooses the best algorithm based on address alignment and
252: * number of bytes to copy. Although the source and destination addresses
253: * are not required to be word aligned, word aligned addresses may result
254: * in a more efficient copy.
255: *
256: *-RETURN VALUE:
257: * If the copy is successful, 0 is returned. Otherwise, -1 is returned to
258: * indicate the specified user address range is invalid.
259: *
260: *-LEVEL:
261: * Base only.
262: *
263: *-NOTES:
264: * May sleep.
265: *
266: * Drivers usually convert a return value of -1 to an EFAULT error.
267: *
268: * Driver-defined basic locks and read/write locks may not be held across
269: * calls to this function.
270: *
271: * Driver-defined sleep locks may be held across calls to this function.
272: *
273: * When holding sleep locks across calls to this function, drivers must
274: * be careful to avoid creating a deadlock. During the data transfer,
275: * page fault resolution might result in another I/O to the same device.
276: * For example, this could occur if the driver controls the disk drive
277: * used as the swap device.
278: *
279: * The driver destination buffer must be completely within the kernel
280: * address space, or the system can panic.
281: *
282: *-SEE ALSO:
283: * copyout (), uiomove (), ureadc (), uwritec ()
284: */
285:
286: #if __USE_PROTO__
287: int (copyin) (_VOID * userbuf, _VOID * driverbuf, size_t count)
288: #else
289: int
290: copyin __ARGS ((userbuf, driverbuf, count))
291: _VOID * userbuf;
292: _VOID * driverbuf;
293: size_t count;
294: #endif
295: {
296: ASSERT (driverbuf != 0);
297:
298: return FROMUSER (driverbuf, userbuf, count) != count ? -1 : 0;
299: }
300:
301:
302: /*
303: *-STATUS:
304: * DDI/DKI
305: *
306: *-NAME:
307: * copyout Copy data from a driver buffer to a user buffer.
308: *
309: *-SYNOPSIS:
310: * #include <sys/types.h>
311: *
312: * int copyout (caddr_t driverbuf, caddr_t userbuf, size_t count);
313: *
314: *-ARGUMENTS:
315: * driverbuf Driver source address from which copy is made.
316: *
317: * userbuf User destination address to which copy is made.
318: *
319: * count Number of bytes to copy.
320: *
321: *-DESCRIPTION:
322: * copyout () copies "count" bytes of data from the kernel virtual
323: * address specified by "driverbuf" to the user virtual address specified
324: * by "userbuf".
325: *
326: * copyout () chooses the best algorithm based on address alignment and
327: * number of bytes to copy. Although the source and destination addresses
328: * are not required to be word aligned, word aligned addresses may result
329: * in a more efficient copy.
330: *
331: *-RETURN VALUE:
332: * If the copy is successful, 0 is returned. Otherwise, -1 is returned to
333: * indicate that the specified user address range is not valid.
334: *
335: *-LEVEL:
336: * Base only.
337: *
338: *-NOTES:
339: * May sleep.
340: *
341: * Drivers usually convert a return value of -1 into an EFAULT error.
342: *
343: * Driver-defined basic locks and read/write locks may not be held across
344: * calls to this function.
345: *
346: * Driver-defined sleep locks may be held across calls to this function.
347: *
348: * When holding sleep locks across calls to this function, drivers must
349: * be careful to avoid creating a deadlock. During the data transfer,
350: * page fault resolution may result in another I/O to the same device.
351: * For example, this could occur if the driver controls the disk drive
352: * used as the swap device.
353: *
354: * The driver source buffer must be completely within the kernel address
355: * space, or the system can panic.
356: *
357: *-SEE ALSO:
358: * copyin (), uiomove (), ureadc (), uwritec ()
359: */
360:
361: #if __USE_PROTO__
362: int (copyout) (_VOID * driverbuf, _VOID * userbuf, size_t count)
363: #else
364: int
365: copyout __ARGS ((driverbuf, userbuf, count))
366: _VOID * driverbuf;
367: _VOID * userbuf;
368: size_t count;
369: #endif
370: {
371: ASSERT (driverbuf != NULL);
372:
373: return TOUSER (userbuf, driverbuf, count) != count ? -1 : 0;
374: }
375:
376:
377: /*
378: *-STATUS:
379: * DDI/DKI
380: *
381: *-NAME:
382: * uiomove Copy data using uio structure.
383: *
384: *-SYNOPSIS:
385: * #include <sys/types.h>
386: * #include <sys/uio.h>
387: *
388: * int uiomove (caddr_t addr, long nbytes, uio_rw_t rwflag, uio_t * uiop);
389: *
390: *-ARGUMENTS:
391: * addr Source/destination kernel address of the copy.
392: *
393: * nbytes Number of bytes to copy.
394: *
395: * rwflag Flag indicating read or write operation. Possible
396: * values are UIO_READ and UIO_WRITE.
397: *
398: * uiop Pointer to the "uio" structure for the copy.
399: *
400: *-DESCRIPTION:
401: * The uiomove () function copies "nbytes" of data between the kernel
402: * address "addr" and the space defined by the "uio" structure pointed to
403: * by "uiop". If "rwflg" is "UIO_READ", the data is copied from "addr" to
404: * the space described by the "uio" structure. If "rwflag" is "UIO_WRITE",
405: * the data is copied from the space described by the "uio" structure to
406: * "addr".
407: *
408: * The "uio_segflg" member of the "uio" structure specifies the type of
409: * space described by the "uio" structure. If "uio_segflg" is set to
410: * "UIO_SYSSPACE" the "uio" structure describes a portion of the kernel
411: * address space. If "uio_segflg" is set to "UIO_USERSPACE" the "uio"
412: * structure describes a portion of the user address space.
413: *
414: * If the copy is successful, uiomove () updates the appropriate members
415: * of the "uio" and "iovec" structures to reflect the copy ("uio_offset"
416: * and "iov_base" and increased by "nbytes" and "uio_resid" and "iov_len"
417: * are decreased by "nbytes").
418: *
419: *-RETURN VALUE:
420: * uiomove () returns 0 on success or an error number on failure. If a
421: * partial transfer occurs, the "uio" structure is updated to indicate
422: * the amount not transferred and an error is returned.
423: *
424: *-LEVEL:
425: * Base only if "uio_segflg" is set to "UIO_USERSPACE". Base or interrupt
426: * if "uio_segflg" is set to "UIO_SYSSPACE".
427: *
428: *-NOTES:
429: * May sleep if "uio_segflg" is set to "UIO_USERSPACE".
430: *
431: * Driver-defined basic locks and read/write locks may be held across
432: * calls to this function if "uio_segflg" is "UIO_SYSSPACE" but may not be
433: * held if "uio_segflg" is "UIO_USERSPACE".
434: *
435: * Driver-defined sleep locks may be held across calls to this function
436: * regardless of the value of "uio_segflg".
437: *
438: * When holding locks across calls to this function, drivers must be
439: * careful to avoid creating a deadlock. During the data transfer, page
440: * fault resolution might result in another I/O to the same device. For
441: * example, this could occur if the driver controls the disk drive used
442: * as the swap device.
443: *
444: * If "addr" specifies an address in user space, or if the value of
445: * "uio_segflg" is not consistent with the type of address space
446: * described by the "uio" structure, the system can panic.
447: *
448: *-SEE ALSO:
449: * bcopy (), copyin (), copyout (), ureadc (), uwritec (), iovec, uio
450: */
451:
452: #if __USE_PROTO__
453: int (uiomove) (caddr_t addr, long nbytes, uio_rw_t rwflag, uio_t * uiop)
454: #else
455: int
456: uiomove __ARGS ((addr, nbytes, rwflag, uiop))
457: caddr_t addr;
458: long nbytes;
459: uio_rw_t rwflag;
460: uio_t * uiop;
461: #endif
462: {
463: iovec_t * scan;
464: iovec_t * end;
465:
466: ASSERT (addr != NULL);
467: ASSERT (uiop != NULL);
468: ASSERT (nbytes > 0);
469: ASSERT (nbytes <= SIZE_T_MAX);
470: ASSERT (uiop->uio_resid <= SIZE_T_MAX);
471: ASSERT (rwflag == UIO_READ || rwflag == UIO_WRITE);
472: ASSERT (uiop->uio_segflg == UIO_SYSSPACE ||
473: uiop->uio_segflg == UIO_USERSPACE);
474: ASSERT (uiop->uio_resid > 0);
475:
476: for (scan = uiop->uio_iov, end = scan + uiop->uio_iovcnt ;
477: nbytes > 0 ; scan ++) {
478: size_t size;
479:
480:
481: /*
482: * Now we are going to move a single block of the scatter/
483: * gather request. We assume that scan->iov_len is
484: * less than or equal to uiop->uio_resid!
485: */
486:
487: ASSERT (scan < end);
488: ASSERT (scan->iov_len > 0);
489: ASSERT (scan->iov_len <= uiop->uio_resid);
490:
491: if (nbytes < (size = (size_t) uiop->uio_iov->iov_len))
492: size = (size_t) nbytes;
493:
494: if (size == 0)
495: continue;
496:
497:
498: /*
499: * Transfer a segment as indicated.
500: */
501:
502: if (rwflag == UIO_READ) {
503:
504: if (uiop->uio_segflg == UIO_USERSPACE) {
505: /*
506: * Transfers involving user memory may sleep
507: * due to paging!
508: */
509:
510: if (TOUSER (scan->iov_base, addr,
511: size) != size)
512: break;
513: } else
514: memcpy (scan->iov_base, addr, size);
515: } else {
516:
517: if (uiop->uio_segflg == UIO_USERSPACE) {
518: /*
519: * Transfers involving user memory may sleep
520: * due to paging!
521: */
522:
523:
524: if (FROMUSER (addr, scan->iov_base,
525: size) != size)
526: break;
527: } else
528: memcpy (addr, scan->iov_base, size);
529: }
530:
531: addr += size;
532: nbytes -= size;
533:
534: uiop->uio_resid -= size;
535: uiop->uio_offset += size;
536:
537: scan->iov_len -= size;
538: scan->iov_base += size;
539: }
540:
541: return nbytes == 0 ? 0 : EFAULT;
542: }
543:
544:
545: /*
546: *-STATUS:
547: * DDI/DKI
548: *
549: *-NAME:
550: * ureadc Copy a character to space described by a "uio"
551: * structure.
552: *
553: *-SYNOPSIS:
554: * #include <sys/uio.h>
555: *
556: * int ureadc (int c, uio_t * uiop);
557: *
558: *-ARGUMENTS:
559: * c The character to be copied.
560: *
561: * uiop Pointer to the "uio" structure.
562: *
563: *-DESCRIPTION:
564: * ureadc () copies the character "c" into the space described by the
565: * "uio" structure pointed to by "uiop".
566: *
567: * The "uio_segflg" member of the "uio" structure specifies the type of
568: * space to which the copy is made. If "uio_segflg" is set to
569: * "UIO_SYSSPACE" the character is copied to a kernel address. If
570: * "uio_segflg" is set to "UIO_USERSPACE" the character is copied to a
571: * user address.
572: *
573: * If the character is successfully copied, ureadc () updates the
574: * appropriate members of the "uio" and "iovec" structures to reflect
575: * the copy ("uio_offset" and "iov_base" are incremented and "uio_resid"
576: * and "iov_len" are decremented).
577: *
578: *-RETURN VALUE:
579: * ureadc () returns 0 on success or an error number on failure.
580: *
581: *-LEVEL:
582: * Base only if "uio_segflg" is set to "UIO_USERSPACE". Base or interrupt
583: * if "uio_segflg" is set to "UIO_SYSSPACE".
584: *
585: *-NOTES:
586: * May sleep if "uio_segflg" is set to "UIO_USERSPACE".
587: *
588: * Driver-defined basic locks and read/write locks may be held across
589: * calls to this function if "uio_segflg" is set to "UIO_SYSSPACE" but
590: * may not be held if "uio_segflg" is set to "UIO_USERSPACE".
591: *
592: * Driver-defined sleep locks may be held across calls to this function
593: * regardless of the value of "uio_segflg".
594: *
595: * When holding locks across calls to this function, drivers must be
596: * careful to avoid creating a deadlock. During the data transfer, page
597: * fault resolution might result in another I/O to the same device. For
598: * example, this could occur if the driver controls the disk drive used
599: * as the swap device.
600: *
601: *-SEE ALSO:
602: * uiomove (), uwritec (), iovec, uio
603: */
604:
605: #if __USE_PROTO__
606: int (ureadc) (int c, uio_t * uiop)
607: #else
608: int
609: ureadc __ARGS ((c, uiop))
610: int c;
611: uio_t * uiop;
612: #endif
613: {
614: iovec_t * scan;
615:
616:
617: ASSERT (uiop != NULL);
618: ASSERT (uiop->uio_segflg == UIO_SYSSPACE ||
619: uiop->uio_segflg == UIO_USERSPACE);
620: ASSERT (uiop->uio_segflg == UIO_SYSSPACE ||
621: uiop->uio_segflg == UIO_USERSPACE);
622: ASSERT (uiop->uio_resid > 0);
623:
624: /*
625: * What to do if the structure is empty? As indicated above, I
626: * consider that an error worthy of a kernel panic. At a minimum we
627: * should make it a recoverable error as the code below does.
628: */
629:
630: if (uiop->uio_resid <= 0)
631: return EFAULT;
632:
633:
634: /*
635: * For now, we loop over any initial empty segments. It is not clear
636: * to me whether this code can alter "uio_iov" or not, although we
637: * definitely are permitted to maintain a separate entry in the
638: * structure to the same effect.
639: */
640:
641: for (scan = uiop->uio_iov ; scan->iov_len == 0 ; scan ++)
642: ;
643:
644: ASSERT (scan < uiop->uio_iov + uiop->uio_iovcnt);
645:
646: /*
647: * Now, write a single character to the space indicated.
648: */
649:
650: if (uiop->uio_segflg == UIO_USERSPACE) {
651:
652: if (PUTBYTE (c, scan->iov_base) != 0)
653: return EFAULT;
654:
655: scan->iov_base ++;
656: } else
657: * scan->iov_base ++ = c;
658:
659: scan->iov_len ++;
660:
661: uiop->uio_resid --;
662: uiop->uio_offset ++;
663:
664: return 0;
665: }
666:
667:
668: /*
669: *-STATUS:
670: * DDI/DKI
671: *
672: *-NAME:
673: * uwritec Return a character from space described by a "uio"
674: * structure.
675: *
676: *-SYNOPSIS:
677: * #include <sys/uio.h>
678: *
679: * int uwritec (uio_t * uiop);
680: *
681: *-ARGUMENTS:
682: * uiop Pointer to the "uio" structure.
683: *
684: *-DESCRIPTION:
685: * uwritec () copies a character from the space described by the "uio"
686: * structure pointed to by "uiop" and returns the character to the
687: * caller.
688: *
689: * The "uio_segflg" member of the "uio" structure specifies the type of
690: * space from which the copy is made. If "uio_segflg" is set to
691: * "UIO_SYSSPACE" the character is copied from a kernel address. If
692: * "uio_segflg" is set to "UIO_USERSPACE" the character is copied from a
693: * user address.
694: *
695: * If the character is successfully copied, uwritec () updates the
696: * appropriate members of the "uio" and "iovec" structures to reflect the
697: * copy ("uio_offset" and "iov_base" are incremented and "uio_resid" and
698: * "iov_len" are decremented).
699: *
700: *-RETURN VALUE:
701: * If successful, uwritec () returns the character. -1 is returned if the
702: * space described by the "uio" structure is empty or if there is an
703: * error.
704: *
705: *-LEVEL:
706: * Base only if "uio_segflg" is set to "UIO_USERSPACE". Base or interrupt
707: * if "uio_segflg" is set to "UIO_SYSSPACE".
708: *
709: *-NOTES:
710: * May sleep if "uio_segflg" is set to "UIO_USERSPACE".
711: * Driver-defined basic locks and read/write locks may be held across
712: * calls to this function if "uio_segflg" is "UIO_SYSSPACE" but may not
713: * be held if "uio_segflg" is "UIO_USERSPACE".
714: *
715: * Driver-defined sleep locks may be held across calls to this function
716: * regardless of the value of "uio_segflg".
717: *
718: * When holding locks across calls to this function, drivers must be
719: * careful to avoid creating a deadlock. During the data transfer, page
720: * fault resolution might result in another I/O to the same device. For
721: * example, this could occur if the driver controls the disk drive used
722: * as the swap device.
723: *
724: *-SEE ALSO:
725: * uiomove (), ureadc (), iovec, uio
726: */
727:
728: #if __USE_PROTO__
729: int (uwritec) (uio_t * uiop)
730: #else
731: int
732: uwritec __ARGS ((uiop))
733: uio_t * uiop;
734: #endif
735: {
736: iovec_t * scan;
737: int c;
738:
739:
740: ASSERT (uiop != NULL);
741: ASSERT (uiop->uio_segflg == UIO_SYSSPACE ||
742: uiop->uio_segflg == UIO_USERSPACE);
743: ASSERT (uiop->uio_segflg == UIO_SYSSPACE ||
744: uiop->uio_segflg == UIO_USERSPACE);
745:
746: /*
747: * What to do if the structure is empty? Unlike ureadc (), we are
748: * allowed to return -1.
749: */
750:
751: if (uiop->uio_resid <= 0)
752: return -1;
753:
754:
755: /*
756: * For now, we loop over any initial empty segments. It is not clear
757: * to me whether this code can alter "uio_iov" or not, although we
758: * definitely are permitted to maintain a separate entry in the
759: * structure to the same effect.
760: */
761:
762: for (scan = uiop->uio_iov ; scan->iov_len == 0 ; scan ++)
763: ;
764:
765: ASSERT (scan < uiop->uio_iov + uiop->uio_iovcnt);
766:
767: /*
768: * Now, read a single character from the space indicated.
769: */
770:
771: if (uiop->uio_segflg == UIO_USERSPACE) {
772:
773: if ((c = GETBYTE (scan->iov_base)) < 0)
774: return -1;
775:
776: scan->iov_base ++;
777: } else
778: c = * scan->iov_base ++;
779:
780: scan->iov_len --;
781:
782: uiop->uio_resid --;
783: uiop->uio_offset ++;
784:
785: return c;
786: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.