1 /* $NetBSD: nv_kern_netbsd.c,v 1.6 2018/10/16 13:18:25 maxv Exp $ */ 2 3 /*- 4 * Copyright (c) 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Mindaugas Rasiukevicius. 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 __RCSID("$NetBSD: nv_kern_netbsd.c,v 1.6 2018/10/16 13:18:25 maxv Exp $"); 34 35 #if !defined(_KERNEL) && !defined(_STANDALONE) 36 #include <sys/mman.h> 37 #include <errno.h> 38 #include <string.h> 39 #include <stdlib.h> 40 #include <stdio.h> 41 #endif 42 #ifdef _KERNEL 43 #include <sys/param.h> 44 #include <sys/lwp.h> 45 #include <sys/kmem.h> 46 #include <sys/malloc.h> 47 #include <sys/mman.h> 48 #include <uvm/uvm_extern.h> 49 #endif 50 #ifdef _STANDALONE 51 /* XXX */ 52 extern void *alloc(unsigned int); 53 extern void dealloc(void *, unsigned int); 54 // #include "stand.h" 55 #else 56 #include <sys/ioctl.h> 57 #endif 58 #include "nv.h" 59 #include "nv_impl.h" 60 61 #ifndef _STANDALONE 62 #ifdef _KERNEL 63 64 void 65 nv_free(void *buf) 66 { 67 if (!buf) { 68 return; 69 } 70 free(buf, M_NVLIST); 71 } 72 73 int 74 nvlist_copyin(const nvlist_ref_t *nref, nvlist_t **nvlp, size_t lim) 75 { 76 const size_t len = nref->len; 77 int flags, error; 78 nvlist_t *nvl; 79 void *buf; 80 81 if (len == 0) { 82 return EINVAL; 83 } 84 if (len >= lim) { 85 return E2BIG; 86 } 87 buf = kmem_alloc(len, KM_SLEEP); 88 error = copyin(nref->buf, buf, len); 89 if (error) { 90 kmem_free(buf, len); 91 return error; 92 } 93 flags = nref->flags & (NV_FLAG_IGNORE_CASE | NV_FLAG_NO_UNIQUE); 94 nvl = nvlist_unpack(buf, len, flags); 95 kmem_free(buf, len); 96 if (nvl == NULL) { 97 return EINVAL; 98 } 99 *nvlp = nvl; 100 return 0; 101 } 102 103 int 104 nvlist_copyout(nvlist_ref_t *nref, const nvlist_t *nvl) 105 { 106 struct proc *p = curproc; 107 void *buf, *uaddr; 108 size_t len, rlen; 109 int error; 110 111 buf = nvlist_pack(nvl, &len); 112 if (buf == NULL) { 113 return ENOMEM; 114 } 115 116 /* 117 * Map the user page(s). 118 * 119 * Note: nvlist_recv_ioctl() will unmap it. 120 */ 121 uaddr = NULL; 122 rlen = round_page(len); 123 error = uvm_mmap_anon(p, &uaddr, rlen); 124 if (error) { 125 goto err; 126 } 127 error = copyout(buf, uaddr, len); 128 if (error) { 129 uvm_unmap(&p->p_vmspace->vm_map, (vaddr_t)uaddr, 130 (vaddr_t)uaddr + rlen); 131 goto err; 132 } 133 nref->flags = nvlist_flags(nvl); 134 nref->buf = uaddr; 135 nref->len = len; 136 err: 137 free(buf, M_TEMP); 138 return error; 139 } 140 141 #else 142 143 int 144 nvlist_xfer_ioctl(int fd, unsigned long cmd, const nvlist_t *nvl, 145 nvlist_t **nvlp) 146 { 147 nvlist_ref_t nref; 148 void *buf = NULL; 149 150 memset(&nref, 0, sizeof(nvlist_ref_t)); 151 152 if (nvl) { 153 /* 154 * Sending: serialize the name-value list. 155 */ 156 buf = nvlist_pack(nvl, &nref.len); 157 if (buf == NULL) { 158 errno = ENOMEM; 159 return -1; 160 } 161 nref.buf = buf; 162 nref.flags = nvlist_flags(nvl); 163 } 164 165 /* 166 * Exchange the nvlist reference data. 167 */ 168 if (ioctl(fd, cmd, &nref) == -1) { 169 free(buf); 170 return -1; 171 } 172 free(buf); 173 174 if (nvlp) { 175 nvlist_t *retnvl; 176 177 /* 178 * Receiving: unserialize the nvlist. 179 * 180 * Note: pages are mapped by nvlist_kern_copyout() for us. 181 */ 182 if (nref.buf == NULL || nref.len == 0) { 183 errno = EIO; 184 return -1; 185 } 186 retnvl = nvlist_unpack(nref.buf, nref.len, nref.flags); 187 munmap(nref.buf, nref.len); 188 if (retnvl == NULL) { 189 errno = EIO; 190 return -1; 191 } 192 *nvlp = retnvl; 193 } 194 return 0; 195 } 196 197 int 198 nvlist_send_ioctl(int fd, unsigned long cmd, const nvlist_t *nvl) 199 { 200 return nvlist_xfer_ioctl(fd, cmd, nvl, NULL); 201 } 202 203 int 204 nvlist_recv_ioctl(int fd, unsigned long cmd, nvlist_t **nvlp) 205 { 206 return nvlist_xfer_ioctl(fd, cmd, NULL, nvlp); 207 } 208 #endif 209 #endif 210 211 void * 212 nv_calloc(size_t n, size_t s) 213 { 214 const size_t len = n * s; 215 void *buf = nv_malloc(len); 216 if (buf == NULL) 217 return NULL; 218 memset(buf, 0, len); 219 return buf; 220 } 221 222 char * 223 nv_strdup(const char *s1) 224 { 225 size_t len = strlen(s1) + 1; 226 char *s2; 227 228 s2 = nv_malloc(len); 229 if (s2) { 230 memcpy(s2, s1, len); 231 s2[len-1] = '\0'; 232 } 233 return s2; 234 } 235 236 #ifdef _STANDALONE 237 238 void * 239 nv_malloc(size_t len) 240 { 241 return alloc(len); 242 } 243 244 void 245 nv_free(void *buf) 246 { 247 if (buf == NULL) 248 return; 249 unsigned int *olen = (void *)((char *)buf - sizeof(unsigned int)); 250 dealloc(buf, *olen); 251 } 252 253 void * 254 nv_realloc(void *buf, size_t len) 255 { 256 if (buf == NULL) 257 return alloc(len); 258 259 unsigned int *olen = (void *)((char *)buf - sizeof(unsigned int)); 260 if (*olen < len) 261 return buf; 262 263 void *nbuf = alloc(len); 264 memcpy(nbuf, buf, *olen); 265 dealloc(buf, *olen); 266 return nbuf; 267 } 268 #endif 269