1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 /* 12 * Copyright 2020 Toomas Soome <tsoome@me.com> 13 */ 14 15 #include <sys/types.h> 16 #include <string.h> 17 #include <libzfs.h> 18 #include <libzfsbootenv.h> 19 #include <sys/zfs_bootenv.h> 20 #include <sys/vdev_impl.h> 21 22 /* 23 * Get or create nvlist. If key is not NULL, get nvlist from bootenv, 24 * otherwise return bootenv. 25 */ 26 int 27 lzbe_nvlist_get(const char *pool, const char *key, void **ptr) 28 { 29 libzfs_handle_t *hdl; 30 zpool_handle_t *zphdl; 31 nvlist_t *nv; 32 int rv = -1; 33 34 if (pool == NULL || *pool == '\0') 35 return (rv); 36 37 if ((hdl = libzfs_init()) == NULL) { 38 return (rv); 39 } 40 41 zphdl = zpool_open(hdl, pool); 42 if (zphdl == NULL) { 43 libzfs_fini(hdl); 44 return (rv); 45 } 46 47 rv = zpool_get_bootenv(zphdl, &nv); 48 if (rv == 0) { 49 nvlist_t *nvl, *dup; 50 51 if (key != NULL) { 52 rv = nvlist_lookup_nvlist(nv, key, &nvl); 53 if (rv == 0) { 54 rv = nvlist_dup(nvl, &dup, 0); 55 nvlist_free(nv); 56 if (rv == 0) 57 nv = dup; 58 else 59 nv = NULL; 60 } else { 61 nvlist_free(nv); 62 rv = nvlist_alloc(&nv, NV_UNIQUE_NAME, 0); 63 } 64 } 65 *ptr = nv; 66 } 67 68 zpool_close(zphdl); 69 libzfs_fini(hdl); 70 return (rv); 71 } 72 73 int 74 lzbe_nvlist_set(const char *pool, const char *key, void *ptr) 75 { 76 libzfs_handle_t *hdl; 77 zpool_handle_t *zphdl; 78 nvlist_t *nv; 79 uint64_t version; 80 int rv = -1; 81 82 if (pool == NULL || *pool == '\0') 83 return (rv); 84 85 if ((hdl = libzfs_init()) == NULL) { 86 return (rv); 87 } 88 89 zphdl = zpool_open(hdl, pool); 90 if (zphdl == NULL) { 91 libzfs_fini(hdl); 92 return (rv); 93 } 94 95 if (key != NULL) { 96 rv = zpool_get_bootenv(zphdl, &nv); 97 if (rv == 0) { 98 /* 99 * We got the nvlist, check for version. 100 * if version is missing or is not VB_NVLIST, 101 * create new list. 102 */ 103 rv = nvlist_lookup_uint64(nv, BOOTENV_VERSION, 104 &version); 105 if (rv != 0 || version != VB_NVLIST) { 106 /* Drop this nvlist */ 107 fnvlist_free(nv); 108 /* Create and prepare new nvlist */ 109 nv = fnvlist_alloc(); 110 fnvlist_add_uint64(nv, BOOTENV_VERSION, 111 VB_NVLIST); 112 } 113 rv = nvlist_add_nvlist(nv, key, ptr); 114 if (rv == 0) 115 rv = zpool_set_bootenv(zphdl, nv); 116 nvlist_free(nv); 117 } 118 } else { 119 rv = zpool_set_bootenv(zphdl, ptr); 120 } 121 122 zpool_close(zphdl); 123 libzfs_fini(hdl); 124 return (rv); 125 } 126 127 /* 128 * free nvlist we got via lzbe_nvlist_get() 129 */ 130 void 131 lzbe_nvlist_free(void *ptr) 132 { 133 nvlist_free(ptr); 134 } 135 136 static const char *typenames[] = { 137 "DATA_TYPE_UNKNOWN", 138 "DATA_TYPE_BOOLEAN", 139 "DATA_TYPE_BYTE", 140 "DATA_TYPE_INT16", 141 "DATA_TYPE_UINT16", 142 "DATA_TYPE_INT32", 143 "DATA_TYPE_UINT32", 144 "DATA_TYPE_INT64", 145 "DATA_TYPE_UINT64", 146 "DATA_TYPE_STRING", 147 "DATA_TYPE_BYTE_ARRAY", 148 "DATA_TYPE_INT16_ARRAY", 149 "DATA_TYPE_UINT16_ARRAY", 150 "DATA_TYPE_INT32_ARRAY", 151 "DATA_TYPE_UINT32_ARRAY", 152 "DATA_TYPE_INT64_ARRAY", 153 "DATA_TYPE_UINT64_ARRAY", 154 "DATA_TYPE_STRING_ARRAY", 155 "DATA_TYPE_HRTIME", 156 "DATA_TYPE_NVLIST", 157 "DATA_TYPE_NVLIST_ARRAY", 158 "DATA_TYPE_BOOLEAN_VALUE", 159 "DATA_TYPE_INT8", 160 "DATA_TYPE_UINT8", 161 "DATA_TYPE_BOOLEAN_ARRAY", 162 "DATA_TYPE_INT8_ARRAY", 163 "DATA_TYPE_UINT8_ARRAY" 164 }; 165 166 static int 167 nvpair_type_from_name(const char *name) 168 { 169 unsigned i; 170 171 for (i = 0; i < ARRAY_SIZE(typenames); i++) { 172 if (strcmp(name, typenames[i]) == 0) 173 return (i); 174 } 175 return (0); 176 } 177 178 /* 179 * Add pair defined by key, type and value into nvlist. 180 */ 181 int 182 lzbe_add_pair(void *ptr, const char *key, const char *type, void *value, 183 size_t size) 184 { 185 nvlist_t *nv = ptr; 186 data_type_t dt; 187 int rv = 0; 188 189 if (ptr == NULL || key == NULL || value == NULL) 190 return (rv); 191 192 if (type == NULL) 193 type = "DATA_TYPE_STRING"; 194 dt = nvpair_type_from_name(type); 195 if (dt == DATA_TYPE_UNKNOWN) 196 return (EINVAL); 197 198 switch (dt) { 199 case DATA_TYPE_BYTE: 200 if (size != sizeof (uint8_t)) { 201 rv = EINVAL; 202 break; 203 } 204 rv = nvlist_add_byte(nv, key, *(uint8_t *)value); 205 break; 206 207 case DATA_TYPE_INT16: 208 if (size != sizeof (int16_t)) { 209 rv = EINVAL; 210 break; 211 } 212 rv = nvlist_add_int16(nv, key, *(int16_t *)value); 213 break; 214 215 case DATA_TYPE_UINT16: 216 if (size != sizeof (uint16_t)) { 217 rv = EINVAL; 218 break; 219 } 220 rv = nvlist_add_uint16(nv, key, *(uint16_t *)value); 221 break; 222 223 case DATA_TYPE_INT32: 224 if (size != sizeof (int32_t)) { 225 rv = EINVAL; 226 break; 227 } 228 rv = nvlist_add_int32(nv, key, *(int32_t *)value); 229 break; 230 231 case DATA_TYPE_UINT32: 232 if (size != sizeof (uint32_t)) { 233 rv = EINVAL; 234 break; 235 } 236 rv = nvlist_add_uint32(nv, key, *(uint32_t *)value); 237 break; 238 239 case DATA_TYPE_INT64: 240 if (size != sizeof (int64_t)) { 241 rv = EINVAL; 242 break; 243 } 244 rv = nvlist_add_int64(nv, key, *(int64_t *)value); 245 break; 246 247 case DATA_TYPE_UINT64: 248 if (size != sizeof (uint64_t)) { 249 rv = EINVAL; 250 break; 251 } 252 rv = nvlist_add_uint64(nv, key, *(uint64_t *)value); 253 break; 254 255 case DATA_TYPE_STRING: 256 rv = nvlist_add_string(nv, key, value); 257 break; 258 259 case DATA_TYPE_BYTE_ARRAY: 260 rv = nvlist_add_byte_array(nv, key, value, size); 261 break; 262 263 case DATA_TYPE_INT16_ARRAY: 264 rv = nvlist_add_int16_array(nv, key, value, size); 265 break; 266 267 case DATA_TYPE_UINT16_ARRAY: 268 rv = nvlist_add_uint16_array(nv, key, value, size); 269 break; 270 271 case DATA_TYPE_INT32_ARRAY: 272 rv = nvlist_add_int32_array(nv, key, value, size); 273 break; 274 275 case DATA_TYPE_UINT32_ARRAY: 276 rv = nvlist_add_uint32_array(nv, key, value, size); 277 break; 278 279 case DATA_TYPE_INT64_ARRAY: 280 rv = nvlist_add_int64_array(nv, key, value, size); 281 break; 282 283 case DATA_TYPE_UINT64_ARRAY: 284 rv = nvlist_add_uint64_array(nv, key, value, size); 285 break; 286 287 case DATA_TYPE_STRING_ARRAY: 288 rv = nvlist_add_string_array(nv, key, value, size); 289 break; 290 291 case DATA_TYPE_NVLIST: 292 rv = nvlist_add_nvlist(nv, key, (nvlist_t *)value); 293 break; 294 295 case DATA_TYPE_NVLIST_ARRAY: 296 rv = nvlist_add_nvlist_array(nv, key, (const nvlist_t **)value, 297 size); 298 break; 299 300 case DATA_TYPE_BOOLEAN_VALUE: 301 if (size != sizeof (boolean_t)) { 302 rv = EINVAL; 303 break; 304 } 305 rv = nvlist_add_boolean_value(nv, key, *(boolean_t *)value); 306 break; 307 308 case DATA_TYPE_INT8: 309 if (size != sizeof (int8_t)) { 310 rv = EINVAL; 311 break; 312 } 313 rv = nvlist_add_int8(nv, key, *(int8_t *)value); 314 break; 315 316 case DATA_TYPE_UINT8: 317 if (size != sizeof (uint8_t)) { 318 rv = EINVAL; 319 break; 320 } 321 rv = nvlist_add_uint8(nv, key, *(uint8_t *)value); 322 break; 323 324 case DATA_TYPE_BOOLEAN_ARRAY: 325 rv = nvlist_add_boolean_array(nv, key, value, size); 326 break; 327 328 case DATA_TYPE_INT8_ARRAY: 329 rv = nvlist_add_int8_array(nv, key, value, size); 330 break; 331 332 case DATA_TYPE_UINT8_ARRAY: 333 rv = nvlist_add_uint8_array(nv, key, value, size); 334 break; 335 336 default: 337 return (ENOTSUP); 338 } 339 340 return (rv); 341 } 342 343 int 344 lzbe_remove_pair(void *ptr, const char *key) 345 { 346 347 return (nvlist_remove_all(ptr, key)); 348 } 349