1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * Copyright 2019 Joyent, Inc. 27 */ 28 29 #include <sys/types.h> 30 #include <sys/sunddi.h> 31 #include <sys/kmem.h> 32 #include <sys/sysmacros.h> 33 #include <smbsrv/smb_kproto.h> 34 #include <smbsrv/alloc.h> 35 36 #define SMB_SMH_MAGIC 0x534D485F /* 'SMH_' */ 37 #define SMB_SMH_VALID(_smh_) ASSERT((_smh_)->smh_magic == SMB_SMH_MAGIC) 38 #define SMB_MEM2SMH(_mem_) ((smb_mem_header_t *)(_mem_) - 1) 39 40 typedef struct smb_mem_header { 41 uint32_t smh_magic; 42 size_t smh_size; 43 smb_request_t *smh_sr; 44 list_node_t smh_lnd; 45 } smb_mem_header_t; 46 47 static void *smb_alloc(smb_request_t *, size_t, boolean_t); 48 static void smb_free(smb_request_t *, void *, boolean_t); 49 static void *smb_realloc(smb_request_t *, void *, size_t, boolean_t); 50 51 /* 52 * Allocate memory. 53 */ 54 void * 55 smb_mem_alloc(size_t size) 56 { 57 return (smb_alloc(NULL, size, B_FALSE)); 58 } 59 60 /* 61 * Allocate memory and zero it out. 62 */ 63 void * 64 smb_mem_zalloc(size_t size) 65 { 66 return (smb_alloc(NULL, size, B_TRUE)); 67 } 68 69 /* 70 * Allocate or resize memory previously allocated. 71 * 72 * The address passed in MUST be considered invalid when this function returns. 73 */ 74 void * 75 smb_mem_realloc(void *ptr, size_t size) 76 { 77 return (smb_realloc(NULL, ptr, size, B_FALSE)); 78 } 79 80 /* 81 * Allocate or resize memory previously allocated. If the new size is greater 82 * than the current size, the extra space is zeroed out. If the new size is less 83 * then the current size the space truncated is zeroed out. 84 * 85 * The address passed in MUST be considered invalid when this function returns. 86 */ 87 void * 88 smb_mem_rezalloc(void *ptr, size_t size) 89 { 90 return (smb_realloc(NULL, ptr, size, B_TRUE)); 91 } 92 93 /* 94 * Free memory previously allocated with smb_malloc(), smb_zalloc(), 95 * smb_remalloc() or smb_rezalloc(). 96 */ 97 void 98 smb_mem_free(void *ptr) 99 { 100 smb_free(NULL, ptr, B_FALSE); 101 } 102 103 /* 104 * Free memory previously allocated with smb_mem_malloc(), smb_mem_zalloc(), 105 * smb_mem_remalloc() or smb_mem_rezalloc() or smb_mem_strdup(). The memory will 106 * be zeroed out before being actually freed. 107 */ 108 void 109 smb_mem_zfree(void *ptr) 110 { 111 smb_free(NULL, ptr, B_TRUE); 112 } 113 114 /* 115 * Duplicate a string. 116 */ 117 char * 118 smb_mem_strdup(const char *ptr) 119 { 120 char *p; 121 size_t size; 122 123 size = strlen(ptr) + 1; 124 p = smb_alloc(NULL, size, B_FALSE); 125 bcopy(ptr, p, size); 126 return (p); 127 } 128 129 /* 130 * Initialize the list for request-specific temporary storage. 131 */ 132 void 133 smb_srm_init(smb_request_t *sr) 134 { 135 list_create(&sr->sr_storage, sizeof (smb_mem_header_t), 136 offsetof(smb_mem_header_t, smh_lnd)); 137 } 138 139 /* 140 * Free everything on the request-specific temporary storage list and destroy 141 * the list. 142 */ 143 void 144 smb_srm_fini(smb_request_t *sr) 145 { 146 smb_mem_header_t *smh; 147 148 while ((smh = list_head(&sr->sr_storage)) != NULL) 149 smb_free(sr, ++smh, B_FALSE); 150 list_destroy(&sr->sr_storage); 151 } 152 153 /* 154 * Allocate memory and associate it with the specified request. 155 * Memory allocated here can only be used for the duration of this request; it 156 * will be freed automatically on completion of the request. 157 */ 158 void * 159 smb_srm_alloc(smb_request_t *sr, size_t size) 160 { 161 return (smb_alloc(sr, size, B_FALSE)); 162 } 163 164 /* 165 * Allocate memory, zero it out and associate it with the specified request. 166 * Memory allocated here can only be used for the duration of this request; it 167 * will be freed automatically on completion of the request. 168 */ 169 void * 170 smb_srm_zalloc(smb_request_t *sr, size_t size) 171 { 172 return (smb_alloc(sr, size, B_TRUE)); 173 } 174 175 /* 176 * Allocate or resize memory previously allocated for the specified request. 177 * 178 * The address passed in MUST be considered invalid when this function returns. 179 */ 180 void * 181 smb_srm_realloc(smb_request_t *sr, void *p, size_t size) 182 { 183 return (smb_realloc(sr, p, size, B_FALSE)); 184 } 185 186 /* 187 * Allocate or resize memory previously allocated for the specified request. If 188 * the new size is greater than the current size, the extra space is zeroed out. 189 * If the new size is less then the current size the space truncated is zeroed 190 * out. 191 * 192 * The address passed in MUST be considered invalid when this function returns. 193 */ 194 void * 195 smb_srm_rezalloc(smb_request_t *sr, void *p, size_t size) 196 { 197 return (smb_realloc(sr, p, size, B_TRUE)); 198 } 199 200 char * 201 smb_srm_strdup(smb_request_t *sr, const char *s) 202 { 203 char *p; 204 size_t size; 205 206 size = strlen(s) + 1; 207 p = smb_srm_alloc(sr, size); 208 bcopy(s, p, size); 209 return (p); 210 } 211 212 /* 213 * Allocate memory. 214 * 215 * sr If not NULL, request the memory allocated must be associated with. 216 * 217 * size Size of the meory to allocate. 218 * 219 * zero If true the memory allocated will be zeroed out. 220 */ 221 static void * 222 smb_alloc(smb_request_t *sr, size_t size, boolean_t zero) 223 { 224 smb_mem_header_t *smh; 225 226 if (zero) { 227 smh = kmem_zalloc(size + sizeof (smb_mem_header_t), KM_SLEEP); 228 } else { 229 smh = kmem_alloc(size + sizeof (smb_mem_header_t), KM_SLEEP); 230 smh->smh_sr = NULL; 231 bzero(&smh->smh_lnd, sizeof (smh->smh_lnd)); 232 } 233 smh->smh_sr = sr; 234 smh->smh_size = size; 235 smh->smh_magic = SMB_SMH_MAGIC; 236 if (sr != NULL) { 237 SMB_REQ_VALID(sr); 238 list_insert_tail(&sr->sr_storage, smh); 239 } 240 return (++smh); 241 } 242 243 /* 244 * Free memory. 245 * 246 * sr If not NULL, request the memory to free is associated with. 247 * 248 * ptr Memory address 249 * 250 * zero If true the memory is zeroed out before being freed. 251 */ 252 static void 253 smb_free(smb_request_t *sr, void *ptr, boolean_t zero) 254 { 255 smb_mem_header_t *smh; 256 257 if (ptr != NULL) { 258 smh = SMB_MEM2SMH(ptr); 259 SMB_SMH_VALID(smh); 260 ASSERT(sr == smh->smh_sr); 261 if (sr != NULL) { 262 SMB_REQ_VALID(sr); 263 list_remove(&sr->sr_storage, smh); 264 } 265 if (zero) 266 bzero(ptr, smh->smh_size); 267 268 smh->smh_magic = 0; 269 kmem_free(smh, smh->smh_size + sizeof (smb_mem_header_t)); 270 } 271 } 272 273 /* 274 * Allocate or resize memory previously allocated. 275 * 276 * sr If not NULL, request the memory is associated with. 277 * 278 * ptr Memory address 279 * 280 * size New size 281 * 282 * zero If true zero out the extra space or the truncated space. 283 */ 284 static void * 285 smb_realloc(smb_request_t *sr, void *ptr, size_t size, boolean_t zero) 286 { 287 smb_mem_header_t *smh; 288 void *new_ptr; 289 290 if (ptr == NULL) 291 return (smb_alloc(sr, size, zero)); 292 293 smh = SMB_MEM2SMH(ptr); 294 SMB_SMH_VALID(smh); 295 ASSERT(sr == smh->smh_sr); 296 297 if (size == 0) { 298 smb_free(sr, ptr, zero); 299 return (NULL); 300 } 301 if (smh->smh_size >= size) { 302 if ((zero) && (smh->smh_size > size)) 303 bzero((caddr_t)ptr + size, smh->smh_size - size); 304 return (ptr); 305 } 306 new_ptr = smb_alloc(sr, size, B_FALSE); 307 bcopy(ptr, new_ptr, smh->smh_size); 308 if (zero) 309 bzero((caddr_t)new_ptr + smh->smh_size, size - smh->smh_size); 310 311 smb_free(sr, ptr, zero); 312 return (new_ptr); 313 } 314