1/* $NetBSD: dtv_scatter.c,v 1.6 2019/12/27 09:41:50 msaitoh Exp $ */ 2 3/* 4 * Copyright (c) 2008 Patrick Mahoney <pat@polycrystal.org> 5 * All rights reserved. 6 * 7 * This code was written by Patrick Mahoney (pat@polycrystal.org) as 8 * part of Google Summer of Code 2008. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32#include <sys/cdefs.h> 33__KERNEL_RCSID(0, "$NetBSD: dtv_scatter.c,v 1.6 2019/12/27 09:41:50 msaitoh Exp $"); 34 35#include <sys/param.h> 36#include <sys/ioctl.h> 37#include <sys/fcntl.h> 38#include <sys/vnode.h> 39#include <sys/poll.h> 40#include <sys/select.h> 41#include <sys/kmem.h> 42#include <sys/pool.h> 43#include <sys/conf.h> 44#include <sys/types.h> 45#include <sys/device.h> 46#include <sys/condvar.h> 47#include <sys/queue.h> 48 49#include <dev/dtv/dtvvar.h> 50 51void 52dtv_scatter_buf_init(struct dtv_scatter_buf *sb) 53{ 54 sb->sb_pool = pool_cache_init(PAGE_SIZE, 0, 0, 0, 55 "dtvscatter", NULL, IPL_SCHED, 56 NULL, NULL, NULL); 57 sb->sb_size = 0; 58 sb->sb_npages = 0; 59 sb->sb_page_ary = NULL; 60} 61 62void 63dtv_scatter_buf_destroy(struct dtv_scatter_buf *sb) 64{ 65 /* Do we need to return everything to the pool first? */ 66 dtv_scatter_buf_set_size(sb, 0); 67 pool_cache_destroy(sb->sb_pool); 68 sb->sb_pool = 0; 69 sb->sb_npages = 0; 70 sb->sb_page_ary = NULL; 71} 72 73/* Increase or decrease the size of the buffer */ 74int 75dtv_scatter_buf_set_size(struct dtv_scatter_buf *sb, size_t sz) 76{ 77 unsigned int i; 78 size_t npages, minpages, oldnpages; 79 uint8_t **old_ary; 80 81 npages = (sz >> PAGE_SHIFT) + ((sz & PAGE_MASK) > 0); 82 83 if (sb->sb_npages == npages) { 84 return 0; 85 } 86 87 oldnpages = sb->sb_npages; 88 old_ary = sb->sb_page_ary; 89 90 sb->sb_npages = npages; 91 if (npages > 0) { 92 sb->sb_page_ary = 93 kmem_alloc(sizeof(uint8_t *) * npages, KM_SLEEP); 94 } else { 95 sb->sb_page_ary = NULL; 96 } 97 98 minpages = uimin(npages, oldnpages); 99 /* copy any pages that will be reused */ 100 for (i = 0; i < minpages; ++i) 101 sb->sb_page_ary[i] = old_ary[i]; 102 /* allocate any new pages */ 103 for (; i < npages; ++i) { 104 sb->sb_page_ary[i] = pool_cache_get(sb->sb_pool, PR_WAITOK); 105 /* TODO: does pool_cache_get return NULL on 106 * ENOMEM? If so, we need to release or note 107 * the pages with did allocate 108 * successfully. */ 109 if (sb->sb_page_ary[i] == NULL) { 110 return ENOMEM; 111 } 112 } 113 /* return any pages no longer needed */ 114 for (; i < oldnpages; ++i) 115 pool_cache_put(sb->sb_pool, old_ary[i]); 116 117 if (old_ary != NULL) 118 kmem_free(old_ary, sizeof(uint8_t *) * oldnpages); 119 120 sb->sb_size = sb->sb_npages << PAGE_SHIFT; 121 122 return 0; 123} 124 125 126paddr_t 127dtv_scatter_buf_map(struct dtv_scatter_buf *sb, off_t off) 128{ 129 size_t pg; 130 paddr_t pa; 131 132 pg = off >> PAGE_SHIFT; 133 134 if (pg >= sb->sb_npages) 135 return -1; 136 else if (!pmap_extract(pmap_kernel(), (vaddr_t)sb->sb_page_ary[pg], &pa)) 137 return -1; 138 139 return atop(pa); 140} 141 142/* Initialize data for an io operation on a scatter buffer. Returns 143 * true if the transfer is valid, or false if out of range. */ 144bool 145dtv_scatter_io_init(struct dtv_scatter_buf *sb, 146 off_t off, size_t len, 147 struct dtv_scatter_io *sio) 148{ 149 if ((off + len) > sb->sb_size) { 150 printf("dtv: %s failed: off=%" PRId64 151 " len=%zu sb->sb_size=%zu\n", 152 __func__, off, len, sb->sb_size); 153 return false; 154 } 155 156 sio->sio_buf = sb; 157 sio->sio_offset = off; 158 sio->sio_resid = len; 159 160 return true; 161} 162 163/* Store the pointer and size of the next contiguous segment. Returns 164 * true if the segment is valid, or false if all has been transferred. 165 * Does not check for overflow. */ 166bool 167dtv_scatter_io_next(struct dtv_scatter_io *sio, void **p, size_t *sz) 168{ 169 size_t pg, pgo; 170 171 if (sio->sio_resid == 0) 172 return false; 173 174 pg = sio->sio_offset >> PAGE_SHIFT; 175 pgo = sio->sio_offset & PAGE_MASK; 176 177 *sz = uimin(PAGE_SIZE - pgo, sio->sio_resid); 178 *p = sio->sio_buf->sb_page_ary[pg] + pgo; 179 180 sio->sio_offset += *sz; 181 sio->sio_resid -= *sz; 182 183 return true; 184} 185 186/* Semi-undo of a failed segment copy. Updates the scatter_io 187 * struct to the previous values prior to a failed segment copy. */ 188void 189dtv_scatter_io_undo(struct dtv_scatter_io *sio, size_t sz) 190{ 191 sio->sio_offset -= sz; 192 sio->sio_resid += sz; 193} 194 195/* Copy data from src into the scatter_buf as described by io. */ 196void 197dtv_scatter_io_copyin(struct dtv_scatter_io *sio, const void *p) 198{ 199 void *dst; 200 const uint8_t *src = p; 201 size_t sz; 202 203 while (dtv_scatter_io_next(sio, &dst, &sz)) { 204 memcpy(dst, src, sz); 205 src += sz; 206 } 207} 208 209/* --not used; commented to avoid compiler warnings-- 210void 211dtv_scatter_io_copyout(struct dtv_scatter_io *sio, void *p) 212{ 213 void *src; 214 uint8_t *dst = p; 215 size_t sz; 216 217 while (dtv_scatter_io_next(sio, &src, &sz)) { 218 memcpy(dst, src, sz); 219 dst += sz; 220 } 221} 222*/ 223 224/* Performat a series of uiomove calls on a scatter buf. Returns 225 * EFAULT if uiomove EFAULTs on the first segment. Otherwise, returns 226 * an incomplete transfer but with no error. */ 227int 228dtv_scatter_io_uiomove(struct dtv_scatter_io *sio, struct uio *uio) 229{ 230 void *p; 231 size_t sz; 232 bool first = true; 233 int err; 234 235 while (dtv_scatter_io_next(sio, &p, &sz)) { 236 err = uiomove(p, sz, uio); 237 if (err == EFAULT) { 238 dtv_scatter_io_undo(sio, sz); 239 if (first) 240 return EFAULT; 241 else 242 return 0; 243 } 244 first = false; 245 } 246 247 return 0; 248} 249