1 /*-
2 * Copyright (c) 2008 Yahoo!, Inc.
3 * All rights reserved.
4 * Written by: John Baldwin <jhb@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the author nor the names of any co-contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/bio.h>
37 #include <sys/malloc.h>
38 #include <sys/mbuf.h>
39 #include <sys/proc.h>
40 #include <sys/sglist.h>
41 #include <sys/uio.h>
42
43 #include <vm/vm.h>
44 #include <vm/vm_page.h>
45 #include <vm/pmap.h>
46 #include <vm/vm_map.h>
47
48 #include <sys/ktr.h>
49
50 static MALLOC_DEFINE(M_SGLIST, "sglist", "scatter/gather lists");
51
52 /*
53 * Convenience macros to save the state of an sglist so it can be restored
54 * if an append attempt fails. Since sglist's only grow we only need to
55 * save the current count of segments and the length of the ending segment.
56 * Earlier segments will not be changed by an append, and the only change
57 * that can occur to the ending segment is that it can be extended.
58 */
59 struct sgsave {
60 u_short sg_nseg;
61 size_t ss_len;
62 };
63
64 #define SGLIST_SAVE(sg, sgsave) do { \
65 (sgsave).sg_nseg = (sg)->sg_nseg; \
66 if ((sgsave).sg_nseg > 0) \
67 (sgsave).ss_len = (sg)->sg_segs[(sgsave).sg_nseg - 1].ss_len; \
68 else \
69 (sgsave).ss_len = 0; \
70 } while (0)
71
72 #define SGLIST_RESTORE(sg, sgsave) do { \
73 (sg)->sg_nseg = (sgsave).sg_nseg; \
74 if ((sgsave).sg_nseg > 0) \
75 (sg)->sg_segs[(sgsave).sg_nseg - 1].ss_len = (sgsave).ss_len; \
76 } while (0)
77
78 /*
79 * Append a single (paddr, len) to a sglist. sg is the list and ss is
80 * the current segment in the list. If we run out of segments then
81 * EFBIG will be returned.
82 */
83 static __inline int
84 _sglist_append_range(struct sglist *sg, struct sglist_seg **ssp,
85 vm_paddr_t paddr, size_t len)
86 {
87 struct sglist_seg *ss;
88
89 ss = *ssp;
90 if (ss->ss_paddr + ss->ss_len == paddr)
91 ss->ss_len += len;
92 else {
93 if (sg->sg_nseg == sg->sg_maxseg)
94 return (EFBIG);
95 ss++;
96 ss->ss_paddr = paddr;
97 ss->ss_len = len;
98 sg->sg_nseg++;
99 *ssp = ss;
100 }
101 return (0);
102 }
103
104 /*
105 * Worker routine to append a virtual address range (either kernel or
106 * user) to a scatter/gather list.
107 */
108 static __inline int
109 _sglist_append_buf(struct sglist *sg, void *buf, size_t len, pmap_t pmap,
110 size_t *donep)
111 {
112 struct sglist_seg *ss;
113 vm_offset_t vaddr, offset;
114 vm_paddr_t paddr;
115 size_t seglen;
116 int error;
117
118 if (donep)
119 *donep = 0;
120 if (len == 0)
121 return (0);
122
123 /* Do the first page. It may have an offset. */
124 vaddr = (vm_offset_t)buf;
125 offset = vaddr & PAGE_MASK;
126 if (pmap != NULL)
127 paddr = pmap_extract(pmap, vaddr);
128 else
129 paddr = pmap_kextract(vaddr);
130 seglen = MIN(len, PAGE_SIZE - offset);
131 if (sg->sg_nseg == 0) {
132 ss = sg->sg_segs;
133 ss->ss_paddr = paddr;
134 ss->ss_len = seglen;
135 sg->sg_nseg = 1;
136 } else {
137 ss = &sg->sg_segs[sg->sg_nseg - 1];
138 error = _sglist_append_range(sg, &ss, paddr, seglen);
139 if (error)
140 return (error);
141 }
142 vaddr += seglen;
143 len -= seglen;
144 if (donep)
145 *donep += seglen;
146
147 while (len > 0) {
148 seglen = MIN(len, PAGE_SIZE);
149 if (pmap != NULL)
150 paddr = pmap_extract(pmap, vaddr);
151 else
152 paddr = pmap_kextract(vaddr);
153 error = _sglist_append_range(sg, &ss, paddr, seglen);
154 if (error)
155 return (error);
156 vaddr += seglen;
157 len -= seglen;
158 if (donep)
159 *donep += seglen;
160 }
161
162 return (0);
163 }
164
165 /*
166 * Determine the number of scatter/gather list elements needed to
167 * describe a kernel virtual address range.
168 */
169 int
170 sglist_count(void *buf, size_t len)
171 {
172 vm_offset_t vaddr, vendaddr;
173 vm_paddr_t lastaddr, paddr;
174 int nsegs;
175
176 if (len == 0)
177 return (0);
178
179 vaddr = trunc_page((vm_offset_t)buf);
180 vendaddr = (vm_offset_t)buf + len;
181 nsegs = 1;
182 lastaddr = pmap_kextract(vaddr);
183 vaddr += PAGE_SIZE;
184 while (vaddr < vendaddr) {
185 paddr = pmap_kextract(vaddr);
186 if (lastaddr + PAGE_SIZE != paddr)
187 nsegs++;
188 lastaddr = paddr;
189 vaddr += PAGE_SIZE;
190 }
191 return (nsegs);
192 }
193
194 /*
195 * Allocate a scatter/gather list along with 'nsegs' segments. The
196 * 'mflags' parameters are the same as passed to malloc(9). The caller
197 * should use sglist_free() to free this list.
198 */
199 struct sglist *
200 sglist_alloc(int nsegs, int mflags)
201 {
202 struct sglist *sg;
203
204 sg = malloc(sizeof(struct sglist) + nsegs * sizeof(struct sglist_seg),
205 M_SGLIST, mflags);
206 if (sg == NULL)
207 return (NULL);
208 sglist_init(sg, nsegs, (struct sglist_seg *)(sg + 1));
209 return (sg);
210 }
211
212 /*
213 * Free a scatter/gather list allocated via sglist_allc().
214 */
215 void
216 sglist_free(struct sglist *sg)
217 {
218
219 if (sg == NULL)
220 return;
221
222 if (refcount_release(&sg->sg_refs))
223 free(sg, M_SGLIST);
224 }
225
226 /*
227 * Append the segments to describe a single kernel virtual address
228 * range to a scatter/gather list. If there are insufficient
229 * segments, then this fails with EFBIG.
230 */
231 int
232 sglist_append(struct sglist *sg, void *buf, size_t len)
233 {
234 struct sgsave save;
235 int error;
236
237 if (sg->sg_maxseg == 0)
238 return (EINVAL);
239 SGLIST_SAVE(sg, save);
240 error = _sglist_append_buf(sg, buf, len, NULL, NULL);
241 if (error)
242 SGLIST_RESTORE(sg, save);
243 return (error);
244 }
245
246 /*
247 * Append the segments to describe a bio's data to a scatter/gather list.
248 * If there are insufficient segments, then this fails with EFBIG.
249 *
250 * NOTE: This function expects bio_bcount to be initialized.
251 */
252 int
253 sglist_append_bio(struct sglist *sg, struct bio *bp)
254 {
255 struct sgsave save;
256 vm_paddr_t paddr;
257 size_t len, tlen;
258 int error, i, ma_offs;
259
260 if ((bp->bio_flags & BIO_UNMAPPED) == 0) {
261 error = sglist_append(sg, bp->bio_data, bp->bio_bcount);
262 return (error);
263 }
264
265 if (sg->sg_maxseg == 0)
266 return (EINVAL);
267
268 SGLIST_SAVE(sg, save);
269 tlen = bp->bio_bcount;
270 ma_offs = bp->bio_ma_offset;
271 for (i = 0; tlen > 0; i++, tlen -= len) {
272 len = min(PAGE_SIZE - ma_offs, tlen);
273 paddr = VM_PAGE_TO_PHYS(bp->bio_ma[i]) + ma_offs;
274 error = sglist_append_phys(sg, paddr, len);
275 if (error) {
276 SGLIST_RESTORE(sg, save);
277 return (error);
278 }
279 ma_offs = 0;
280 }
281 return (0);
282 }
283
284 /*
285 * Append a single physical address range to a scatter/gather list.
286 * If there are insufficient segments, then this fails with EFBIG.
287 */
288 int
289 sglist_append_phys(struct sglist *sg, vm_paddr_t paddr, size_t len)
290 {
291 struct sglist_seg *ss;
292 struct sgsave save;
293 int error;
294
295 if (sg->sg_maxseg == 0)
296 return (EINVAL);
297 if (len == 0)
298 return (0);
299
300 if (sg->sg_nseg == 0) {
301 sg->sg_segs[0].ss_paddr = paddr;
302 sg->sg_segs[0].ss_len = len;
303 sg->sg_nseg = 1;
304 return (0);
305 }
306 ss = &sg->sg_segs[sg->sg_nseg - 1];
307 SGLIST_SAVE(sg, save);
308 error = _sglist_append_range(sg, &ss, paddr, len);
309 if (error)
310 SGLIST_RESTORE(sg, save);
311 return (error);
312 }
313
314 /*
315 * Append the segments that describe a single mbuf chain to a
316 * scatter/gather list. If there are insufficient segments, then this
317 * fails with EFBIG.
318 */
319 int
320 sglist_append_mbuf(struct sglist *sg, struct mbuf *m0)
321 {
322 struct sgsave save;
323 struct mbuf *m;
324 int error;
325
326 if (sg->sg_maxseg == 0)
327 return (EINVAL);
328
329 error = 0;
330 SGLIST_SAVE(sg, save);
331 for (m = m0; m != NULL; m = m->m_next) {
332 if (m->m_len > 0) {
333 error = sglist_append(sg, m->m_data, m->m_len);
334 if (error) {
335 SGLIST_RESTORE(sg, save);
336 return (error);
337 }
338 }
339 }
340 return (0);
341 }
342
343 /*
344 * Append the segments that describe a single user address range to a
345 * scatter/gather list. If there are insufficient segments, then this
346 * fails with EFBIG.
347 */
348 int
349 sglist_append_user(struct sglist *sg, void *buf, size_t len, struct thread *td)
350 {
351 struct sgsave save;
352 int error;
353
354 if (sg->sg_maxseg == 0)
355 return (EINVAL);
356 SGLIST_SAVE(sg, save);
357 error = _sglist_append_buf(sg, buf, len,
358 vmspace_pmap(td->td_proc->p_vmspace), NULL);
359 if (error)
360 SGLIST_RESTORE(sg, save);
361 return (error);
362 }
363
364 /*
365 * Append the segments that describe a single uio to a scatter/gather
366 * list. If there are insufficient segments, then this fails with
367 * EFBIG.
368 */
369 int
370 sglist_append_uio(struct sglist *sg, struct uio *uio)
371 {
372 struct iovec *iov;
373 struct sgsave save;
374 size_t resid, minlen;
375 pmap_t pmap;
376 int error, i;
377
378 if (sg->sg_maxseg == 0)
379 return (EINVAL);
380
381 resid = uio->uio_resid;
382 iov = uio->uio_iov;
383
384 if (uio->uio_segflg == UIO_USERSPACE) {
385 KASSERT(uio->uio_td != NULL,
386 ("sglist_append_uio: USERSPACE but no thread"));
387 pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace);
388 } else
389 pmap = NULL;
390
391 error = 0;
392 SGLIST_SAVE(sg, save);
393 for (i = 0; i < uio->uio_iovcnt && resid != 0; i++) {
394 /*
395 * Now at the first iovec to load. Load each iovec
396 * until we have exhausted the residual count.
397 */
398 minlen = MIN(resid, iov[i].iov_len);
399 if (minlen > 0) {
400 error = _sglist_append_buf(sg, iov[i].iov_base, minlen,
401 pmap, NULL);
402 if (error) {
403 SGLIST_RESTORE(sg, save);
404 return (error);
405 }
406 resid -= minlen;
407 }
408 }
409 return (0);
410 }
411
412 /*
413 * Append the segments that describe at most 'resid' bytes from a
414 * single uio to a scatter/gather list. If there are insufficient
415 * segments, then only the amount that fits is appended.
416 */
417 int
418 sglist_consume_uio(struct sglist *sg, struct uio *uio, size_t resid)
419 {
420 struct iovec *iov;
421 size_t done;
422 pmap_t pmap;
423 int error, len;
424
425 if (sg->sg_maxseg == 0)
426 return (EINVAL);
427
428 if (uio->uio_segflg == UIO_USERSPACE) {
429 KASSERT(uio->uio_td != NULL,
430 ("sglist_consume_uio: USERSPACE but no thread"));
431 pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace);
432 } else
433 pmap = NULL;
434
435 error = 0;
436 while (resid > 0 && uio->uio_resid) {
437 iov = uio->uio_iov;
438 len = iov->iov_len;
439 if (len == 0) {
440 uio->uio_iov++;
441 uio->uio_iovcnt--;
442 continue;
443 }
444 if (len > resid)
445 len = resid;
446
447 /*
448 * Try to append this iovec. If we run out of room,
449 * then break out of the loop.
450 */
451 error = _sglist_append_buf(sg, iov->iov_base, len, pmap, &done);
452 iov->iov_base = (char *)iov->iov_base + done;
453 iov->iov_len -= done;
454 uio->uio_resid -= done;
455 uio->uio_offset += done;
456 resid -= done;
457 if (error)
458 break;
459 }
460 return (0);
461 }
462
463 /*
464 * Allocate and populate a scatter/gather list to describe a single
465 * kernel virtual address range.
466 */
467 struct sglist *
468 sglist_build(void *buf, size_t len, int mflags)
469 {
470 struct sglist *sg;
471 int nsegs;
472
473 if (len == 0)
474 return (NULL);
475
476 nsegs = sglist_count(buf, len);
477 sg = sglist_alloc(nsegs, mflags);
478 if (sg == NULL)
479 return (NULL);
480 if (sglist_append(sg, buf, len) != 0) {
481 sglist_free(sg);
482 return (NULL);
483 }
484 return (sg);
485 }
486
487 /*
488 * Clone a new copy of a scatter/gather list.
489 */
490 struct sglist *
491 sglist_clone(struct sglist *sg, int mflags)
492 {
493 struct sglist *new;
494
495 if (sg == NULL)
496 return (NULL);
497 new = sglist_alloc(sg->sg_maxseg, mflags);
498 if (new == NULL)
499 return (NULL);
500 new->sg_nseg = sg->sg_nseg;
501 bcopy(sg->sg_segs, new->sg_segs, sizeof(struct sglist_seg) *
502 sg->sg_nseg);
503 return (new);
504 }
505
506 /*
507 * Calculate the total length of the segments described in a
508 * scatter/gather list.
509 */
510 size_t
511 sglist_length(struct sglist *sg)
512 {
513 size_t space;
514 int i;
515
516 space = 0;
517 for (i = 0; i < sg->sg_nseg; i++)
518 space += sg->sg_segs[i].ss_len;
519 return (space);
520 }
521
522 /*
523 * Split a scatter/gather list into two lists. The scatter/gather
524 * entries for the first 'length' bytes of the 'original' list are
525 * stored in the '*head' list and are removed from 'original'.
526 *
527 * If '*head' is NULL, then a new list will be allocated using
528 * 'mflags'. If M_NOWAIT is specified and the allocation fails,
529 * ENOMEM will be returned.
530 *
531 * If '*head' is not NULL, it should point to an empty sglist. If it
532 * does not have enough room for the remaining space, then EFBIG will
533 * be returned. If '*head' is not empty, then EINVAL will be
534 * returned.
535 *
536 * If 'original' is shared (refcount > 1), then EDOOFUS will be
537 * returned.
538 */
539 int
540 sglist_split(struct sglist *original, struct sglist **head, size_t length,
541 int mflags)
542 {
543 struct sglist *sg;
544 size_t space, split;
545 int count, i;
546
547 if (original->sg_refs > 1)
548 return (EDOOFUS);
549
550 /* Figure out how big of a sglist '*head' has to hold. */
551 count = 0;
552 space = 0;
553 split = 0;
554 for (i = 0; i < original->sg_nseg; i++) {
555 space += original->sg_segs[i].ss_len;
556 count++;
557 if (space >= length) {
558 /*
559 * If 'length' falls in the middle of a
560 * scatter/gather list entry, then 'split'
561 * holds how much of that entry will remain in
562 * 'original'.
563 */
564 split = space - length;
565 break;
566 }
567 }
568
569 /* Nothing to do, so leave head empty. */
570 if (count == 0)
571 return (0);
572
573 if (*head == NULL) {
574 sg = sglist_alloc(count, mflags);
575 if (sg == NULL)
576 return (ENOMEM);
577 *head = sg;
578 } else {
579 sg = *head;
580 if (sg->sg_maxseg < count)
581 return (EFBIG);
582 if (sg->sg_nseg != 0)
583 return (EINVAL);
584 }
585
586 /* Copy 'count' entries to 'sg' from 'original'. */
587 bcopy(original->sg_segs, sg->sg_segs, count *
588 sizeof(struct sglist_seg));
589 sg->sg_nseg = count;
590
591 /*
592 * If we had to split a list entry, fixup the last entry in
593 * 'sg' and the new first entry in 'original'. We also
594 * decrement 'count' by 1 since we will only be removing
595 * 'count - 1' segments from 'original' now.
596 */
597 if (split != 0) {
598 count--;
599 sg->sg_segs[count].ss_len -= split;
600 original->sg_segs[count].ss_paddr =
601 sg->sg_segs[count].ss_paddr + split;
602 original->sg_segs[count].ss_len = split;
603 }
604
605 /* Trim 'count' entries from the front of 'original'. */
606 original->sg_nseg -= count;
607 bcopy(original->sg_segs + count, original->sg_segs, count *
608 sizeof(struct sglist_seg));
609 return (0);
610 }
611
612 /*
613 * Append the scatter/gather list elements in 'second' to the
614 * scatter/gather list 'first'. If there is not enough space in
615 * 'first', EFBIG is returned.
616 */
617 int
618 sglist_join(struct sglist *first, struct sglist *second)
619 {
620 struct sglist_seg *flast, *sfirst;
621 int append;
622
623 /* If 'second' is empty, there is nothing to do. */
624 if (second->sg_nseg == 0)
625 return (0);
626
627 /*
628 * If the first entry in 'second' can be appended to the last entry
629 * in 'first' then set append to '1'.
630 */
631 append = 0;
632 flast = &first->sg_segs[first->sg_nseg - 1];
633 sfirst = &second->sg_segs[0];
634 if (first->sg_nseg != 0 &&
635 flast->ss_paddr + flast->ss_len == sfirst->ss_paddr)
636 append = 1;
637
638 /* Make sure 'first' has enough room. */
639 if (first->sg_nseg + second->sg_nseg - append > first->sg_maxseg)
640 return (EFBIG);
641
642 /* Merge last in 'first' and first in 'second' if needed. */
643 if (append)
644 flast->ss_len += sfirst->ss_len;
645
646 /* Append new segments from 'second' to 'first'. */
647 bcopy(first->sg_segs + first->sg_nseg, second->sg_segs + append,
648 (second->sg_nseg - append) * sizeof(struct sglist_seg));
649 first->sg_nseg += second->sg_nseg - append;
650 sglist_reset(second);
651 return (0);
652 }
653
654 /*
655 * Generate a new scatter/gather list from a range of an existing
656 * scatter/gather list. The 'offset' and 'length' parameters specify
657 * the logical range of the 'original' list to extract. If that range
658 * is not a subset of the length of 'original', then EINVAL is
659 * returned. The new scatter/gather list is stored in '*slice'.
660 *
661 * If '*slice' is NULL, then a new list will be allocated using
662 * 'mflags'. If M_NOWAIT is specified and the allocation fails,
663 * ENOMEM will be returned.
664 *
665 * If '*slice' is not NULL, it should point to an empty sglist. If it
666 * does not have enough room for the remaining space, then EFBIG will
667 * be returned. If '*slice' is not empty, then EINVAL will be
668 * returned.
669 */
670 int
671 sglist_slice(struct sglist *original, struct sglist **slice, size_t offset,
672 size_t length, int mflags)
673 {
674 struct sglist *sg;
675 size_t space, end, foffs, loffs;
676 int count, i, fseg;
677
678 /* Nothing to do. */
679 if (length == 0)
680 return (0);
681
682 /* Figure out how many segments '*slice' needs to have. */
683 end = offset + length;
684 space = 0;
685 count = 0;
686 fseg = 0;
687 foffs = loffs = 0;
688 for (i = 0; i < original->sg_nseg; i++) {
689 space += original->sg_segs[i].ss_len;
690 if (space > offset) {
691 /*
692 * When we hit the first segment, store its index
693 * in 'fseg' and the offset into the first segment
694 * of 'offset' in 'foffs'.
695 */
696 if (count == 0) {
697 fseg = i;
698 foffs = offset - (space -
699 original->sg_segs[i].ss_len);
700 CTR1(KTR_DEV, "sglist_slice: foffs = %08lx",
701 foffs);
702 }
703 count++;
704
705 /*
706 * When we hit the last segment, break out of
707 * the loop. Store the amount of extra space
708 * at the end of this segment in 'loffs'.
709 */
710 if (space >= end) {
711 loffs = space - end;
712 CTR1(KTR_DEV, "sglist_slice: loffs = %08lx",
713 loffs);
714 break;
715 }
716 }
717 }
718
719 /* If we never hit 'end', then 'length' ran off the end, so fail. */
720 if (space < end)
721 return (EINVAL);
722
723 if (*slice == NULL) {
724 sg = sglist_alloc(count, mflags);
725 if (sg == NULL)
726 return (ENOMEM);
727 *slice = sg;
728 } else {
729 sg = *slice;
730 if (sg->sg_maxseg < count)
731 return (EFBIG);
732 if (sg->sg_nseg != 0)
733 return (EINVAL);
734 }
735
736 /*
737 * Copy over 'count' segments from 'original' starting at
738 * 'fseg' to 'sg'.
739 */
740 bcopy(original->sg_segs + fseg, sg->sg_segs,
741 count * sizeof(struct sglist_seg));
742 sg->sg_nseg = count;
743
744 /* Fixup first and last segments if needed. */
745 if (foffs != 0) {
746 sg->sg_segs[0].ss_paddr += foffs;
747 sg->sg_segs[0].ss_len -= foffs;
748 CTR2(KTR_DEV, "sglist_slice seg[0]: %08lx:%08lx",
749 (long)sg->sg_segs[0].ss_paddr, sg->sg_segs[0].ss_len);
750 }
751 if (loffs != 0) {
752 sg->sg_segs[count - 1].ss_len -= loffs;
753 CTR2(KTR_DEV, "sglist_slice seg[%d]: len %08x", count - 1,
754 sg->sg_segs[count - 1].ss_len);
755 }
756 return (0);
757 }
Cache object: f05127180a3d9036297f017c2e6e0769
|