Mercurial > illumos > illumos-gate
annotate usr/src/lib/libdiskmgt/common/entry.c @ 4082:2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
6533990 zpool create in-use check fails on svm swap device
| author | mmusante |
|---|---|
| date | Fri, 20 Apr 2007 17:46:13 -0700 |
| parents | 806e933bf124 |
| children | b25030891c44 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * CDDL HEADER START | |
| 3 * | |
| 4 * The contents of this file are subject to the terms of the | |
| 2082 | 5 * Common Development and Distribution License (the "License"). |
| 6 * You may not use this file except in compliance with the License. | |
| 0 | 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 /* | |
|
3741
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. |
| 0 | 23 * Use is subject to license terms. |
| 24 */ | |
| 25 | |
| 26 #pragma ident "%Z%%M% %I% %E% SMI" | |
| 27 | |
| 28 #include <fcntl.h> | |
| 29 #include <libdevinfo.h> | |
| 30 #include <stdio.h> | |
| 31 #include <sys/sunddi.h> | |
| 32 #include <sys/types.h> | |
| 33 #include <unistd.h> | |
| 34 #include <stdlib.h> | |
| 35 #include <string.h> | |
| 767 | 36 #include <libintl.h> |
| 37 #include <locale.h> | |
| 38 #include <sys/debug.h> | |
|
4082
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
39 #include <strings.h> |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
40 #include <sys/stat.h> |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
41 #include <sys/swap.h> |
| 0 | 42 |
| 43 #include "libdiskmgt.h" | |
| 44 #include "disks_private.h" | |
| 45 #include "partition.h" | |
| 46 | |
|
4082
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
47 #define ANY_ZPOOL_USE(who) \ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
48 (((who) == DM_WHO_ZPOOL_FORCE) || \ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
49 ((who) == DM_WHO_ZPOOL) || \ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
50 ((who) == DM_WHO_ZPOOL_SPARE)) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
51 |
| 767 | 52 extern char *getfullblkname(); |
| 53 | |
| 0 | 54 extern dm_desc_type_t drive_assoc_types[]; |
| 55 extern dm_desc_type_t bus_assoc_types[]; | |
| 56 extern dm_desc_type_t controller_assoc_types[]; | |
| 57 extern dm_desc_type_t media_assoc_types[]; | |
| 58 extern dm_desc_type_t slice_assoc_types[]; | |
| 59 extern dm_desc_type_t partition_assoc_types[]; | |
| 60 extern dm_desc_type_t path_assoc_types[]; | |
| 61 extern dm_desc_type_t alias_assoc_types[]; | |
| 62 | |
| 767 | 63 |
| 0 | 64 static dm_descriptor_t *ptr_array_to_desc_array(descriptor_t **ptrs, int *errp); |
| 65 static descriptor_t **desc_array_to_ptr_array(dm_descriptor_t *da, int *errp); | |
| 767 | 66 static int build_usage_string(char *dname, char *by, char *data, char **use, |
| 67 int *found, int *errp); | |
| 0 | 68 |
| 69 void | |
| 70 dm_free_descriptor(dm_descriptor_t desc) | |
| 71 { | |
| 72 descriptor_t *dp; | |
| 73 | |
| 74 if (desc == NULL) { | |
| 75 return; | |
| 76 } | |
| 556 | 77 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 78 |
| 79 cache_wlock(); | |
| 80 cache_free_descriptor(dp); | |
| 81 cache_unlock(); | |
| 82 } | |
| 83 | |
| 84 void | |
| 85 dm_free_descriptors(dm_descriptor_t *desc_list) | |
| 86 { | |
| 87 descriptor_t **dp; | |
| 88 int error; | |
| 89 | |
| 90 if (desc_list == NULL) { | |
| 91 return; | |
| 92 } | |
| 93 dp = desc_array_to_ptr_array(desc_list, &error); | |
| 94 if (error != 0) { | |
| 95 free(desc_list); | |
| 96 return; | |
| 97 } | |
| 98 | |
| 99 cache_wlock(); | |
| 100 cache_free_descriptors(dp); | |
| 101 cache_unlock(); | |
| 102 } | |
| 103 | |
| 104 /*ARGSUSED*/ | |
| 105 void | |
| 106 dm_free_name(char *name) | |
| 107 { | |
| 108 free(name); | |
| 109 } | |
| 110 | |
| 111 dm_descriptor_t * | |
| 112 dm_get_associated_descriptors(dm_descriptor_t desc, dm_desc_type_t type, | |
| 113 int *errp) | |
| 114 { | |
| 115 descriptor_t **descs = NULL; | |
| 116 descriptor_t *dp; | |
| 117 | |
| 118 | |
| 556 | 119 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 120 |
| 121 cache_wlock(); | |
| 122 | |
| 123 if (!cache_is_valid_desc(dp)) { | |
| 124 cache_unlock(); | |
| 125 *errp = EBADF; | |
| 126 return (NULL); | |
| 127 } | |
| 128 | |
| 129 /* verify that the descriptor is still valid */ | |
| 130 if (dp->p.generic == NULL) { | |
| 131 cache_unlock(); | |
| 132 *errp = ENODEV; | |
| 133 return (NULL); | |
| 134 } | |
| 135 | |
| 136 switch (dp->type) { | |
| 137 case DM_DRIVE: | |
| 138 descs = drive_get_assoc_descriptors(dp, type, errp); | |
| 139 break; | |
| 140 case DM_BUS: | |
| 141 descs = bus_get_assoc_descriptors(dp, type, errp); | |
| 142 break; | |
| 143 case DM_CONTROLLER: | |
| 144 descs = controller_get_assoc_descriptors(dp, type, errp); | |
| 145 break; | |
| 146 case DM_MEDIA: | |
| 147 descs = media_get_assoc_descriptors(dp, type, errp); | |
| 148 break; | |
| 149 case DM_SLICE: | |
| 150 descs = slice_get_assoc_descriptors(dp, type, errp); | |
| 151 break; | |
| 152 case DM_PARTITION: | |
| 153 descs = partition_get_assoc_descriptors(dp, type, errp); | |
| 154 break; | |
| 155 case DM_PATH: | |
| 156 descs = path_get_assoc_descriptors(dp, type, errp); | |
| 157 break; | |
| 158 case DM_ALIAS: | |
| 159 descs = alias_get_assoc_descriptors(dp, type, errp); | |
| 160 break; | |
| 161 default: | |
| 162 *errp = EINVAL; | |
| 163 break; | |
| 164 } | |
| 165 | |
| 166 cache_unlock(); | |
| 167 | |
| 168 return (ptr_array_to_desc_array(descs, errp)); | |
| 169 } | |
| 170 | |
| 171 dm_desc_type_t * | |
| 172 dm_get_associated_types(dm_desc_type_t type) | |
| 173 { | |
| 174 switch (type) { | |
| 175 case DM_DRIVE: | |
| 176 return (drive_assoc_types); | |
| 177 case DM_BUS: | |
| 178 return (bus_assoc_types); | |
| 179 case DM_CONTROLLER: | |
| 180 return (controller_assoc_types); | |
| 181 case DM_MEDIA: | |
| 182 return (media_assoc_types); | |
| 183 case DM_SLICE: | |
| 184 return (slice_assoc_types); | |
| 185 case DM_PARTITION: | |
| 186 return (partition_assoc_types); | |
| 187 case DM_PATH: | |
| 188 return (path_assoc_types); | |
| 189 case DM_ALIAS: | |
| 190 return (alias_assoc_types); | |
| 191 } | |
| 192 | |
| 193 return (NULL); | |
| 194 } | |
| 195 | |
| 196 nvlist_t * | |
| 197 dm_get_attributes(dm_descriptor_t desc, int *errp) | |
| 198 { | |
| 199 descriptor_t *dp; | |
| 200 nvlist_t *attrs = NULL; | |
| 201 | |
| 202 | |
| 556 | 203 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 204 |
| 205 cache_rlock(); | |
| 206 | |
| 207 if (!cache_is_valid_desc(dp)) { | |
| 208 cache_unlock(); | |
| 209 *errp = EBADF; | |
| 210 return (NULL); | |
| 211 } | |
| 212 | |
| 213 /* verify that the descriptor is still valid */ | |
| 214 if (dp->p.generic == NULL) { | |
| 215 cache_unlock(); | |
| 216 *errp = ENODEV; | |
| 217 return (NULL); | |
| 218 } | |
| 219 | |
| 220 switch (dp->type) { | |
| 221 case DM_DRIVE: | |
| 222 attrs = drive_get_attributes(dp, errp); | |
| 223 break; | |
| 224 case DM_BUS: | |
| 225 attrs = bus_get_attributes(dp, errp); | |
| 226 break; | |
| 227 case DM_CONTROLLER: | |
| 228 attrs = controller_get_attributes(dp, errp); | |
| 229 break; | |
| 230 case DM_MEDIA: | |
| 231 attrs = media_get_attributes(dp, errp); | |
| 232 break; | |
| 233 case DM_SLICE: | |
| 234 attrs = slice_get_attributes(dp, errp); | |
| 235 break; | |
| 236 case DM_PARTITION: | |
| 237 attrs = partition_get_attributes(dp, errp); | |
| 238 break; | |
| 239 case DM_PATH: | |
| 240 attrs = path_get_attributes(dp, errp); | |
| 241 break; | |
| 242 case DM_ALIAS: | |
| 243 attrs = alias_get_attributes(dp, errp); | |
| 244 break; | |
| 245 default: | |
| 246 *errp = EINVAL; | |
| 247 break; | |
| 248 } | |
| 249 | |
| 250 cache_unlock(); | |
| 251 | |
| 252 return (attrs); | |
| 253 } | |
| 254 | |
| 255 dm_descriptor_t | |
| 256 dm_get_descriptor_by_name(dm_desc_type_t desc_type, char *name, int *errp) | |
| 257 { | |
| 258 dm_descriptor_t desc = NULL; | |
| 259 | |
| 260 | |
| 261 cache_wlock(); | |
| 262 | |
| 263 switch (desc_type) { | |
| 264 case DM_DRIVE: | |
| 265 desc = (uintptr_t)drive_get_descriptor_by_name(name, errp); | |
| 266 break; | |
| 267 case DM_BUS: | |
| 268 desc = (uintptr_t)bus_get_descriptor_by_name(name, errp); | |
| 269 break; | |
| 270 case DM_CONTROLLER: | |
| 271 desc = (uintptr_t)controller_get_descriptor_by_name(name, | |
| 272 errp); | |
| 273 break; | |
| 274 case DM_MEDIA: | |
| 275 desc = (uintptr_t)media_get_descriptor_by_name(name, errp); | |
| 276 break; | |
| 277 case DM_SLICE: | |
| 278 desc = (uintptr_t)slice_get_descriptor_by_name(name, errp); | |
| 279 break; | |
| 280 case DM_PARTITION: | |
| 281 desc = (uintptr_t)partition_get_descriptor_by_name(name, | |
| 282 errp); | |
| 283 break; | |
| 284 case DM_PATH: | |
| 285 desc = (uintptr_t)path_get_descriptor_by_name(name, errp); | |
| 286 break; | |
| 287 case DM_ALIAS: | |
| 288 desc = (uintptr_t)alias_get_descriptor_by_name(name, errp); | |
| 289 break; | |
| 290 default: | |
| 291 *errp = EINVAL; | |
| 292 break; | |
| 293 } | |
| 294 | |
| 295 cache_unlock(); | |
| 296 | |
| 297 return (desc); | |
| 298 } | |
| 299 | |
| 300 dm_descriptor_t * | |
| 301 dm_get_descriptors(dm_desc_type_t type, int filter[], int *errp) | |
| 302 { | |
| 303 descriptor_t **descs = NULL; | |
| 304 | |
| 305 | |
| 306 cache_wlock(); | |
| 307 | |
| 308 switch (type) { | |
| 309 case DM_DRIVE: | |
| 310 descs = drive_get_descriptors(filter, errp); | |
| 311 break; | |
| 312 case DM_BUS: | |
| 313 descs = bus_get_descriptors(filter, errp); | |
| 314 break; | |
| 315 case DM_CONTROLLER: | |
| 316 descs = controller_get_descriptors(filter, errp); | |
| 317 break; | |
| 318 case DM_MEDIA: | |
| 319 descs = media_get_descriptors(filter, errp); | |
| 320 break; | |
| 321 case DM_SLICE: | |
| 322 descs = slice_get_descriptors(filter, errp); | |
| 323 break; | |
| 324 case DM_PARTITION: | |
| 325 descs = partition_get_descriptors(filter, errp); | |
| 326 break; | |
| 327 case DM_PATH: | |
| 328 descs = path_get_descriptors(filter, errp); | |
| 329 break; | |
| 330 case DM_ALIAS: | |
| 331 descs = alias_get_descriptors(filter, errp); | |
| 332 break; | |
| 333 default: | |
| 334 *errp = EINVAL; | |
| 335 break; | |
| 336 } | |
| 337 | |
| 338 cache_unlock(); | |
| 339 | |
| 340 return (ptr_array_to_desc_array(descs, errp)); | |
| 341 } | |
| 342 | |
| 343 char * | |
| 344 dm_get_name(dm_descriptor_t desc, int *errp) | |
| 345 { | |
| 346 descriptor_t *dp; | |
| 347 char *nm = NULL; | |
| 348 char *name = NULL; | |
| 349 | |
| 556 | 350 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 351 |
| 352 cache_rlock(); | |
| 353 | |
| 354 if (!cache_is_valid_desc(dp)) { | |
| 355 cache_unlock(); | |
| 356 *errp = EBADF; | |
| 357 return (NULL); | |
| 358 } | |
| 359 | |
| 360 /* verify that the descriptor is still valid */ | |
| 361 if (dp->p.generic == NULL) { | |
| 362 cache_unlock(); | |
| 363 *errp = ENODEV; | |
| 364 return (NULL); | |
| 365 } | |
| 366 | |
| 367 switch (dp->type) { | |
| 368 case DM_DRIVE: | |
| 369 nm = (drive_get_name(dp)); | |
| 370 break; | |
| 371 case DM_BUS: | |
| 372 nm = (bus_get_name(dp)); | |
| 373 break; | |
| 374 case DM_CONTROLLER: | |
| 375 nm = (controller_get_name(dp)); | |
| 376 break; | |
| 377 case DM_MEDIA: | |
| 378 nm = (media_get_name(dp)); | |
| 379 break; | |
| 380 case DM_SLICE: | |
| 381 nm = (slice_get_name(dp)); | |
| 382 break; | |
| 383 case DM_PARTITION: | |
| 384 nm = (partition_get_name(dp)); | |
| 385 break; | |
| 386 case DM_PATH: | |
| 387 nm = (path_get_name(dp)); | |
| 388 break; | |
| 389 case DM_ALIAS: | |
| 390 nm = (alias_get_name(dp)); | |
| 391 break; | |
| 392 } | |
| 393 | |
| 394 cache_unlock(); | |
| 395 | |
| 396 *errp = 0; | |
| 397 if (nm != NULL) { | |
| 398 name = strdup(nm); | |
| 399 if (name == NULL) { | |
| 400 *errp = ENOMEM; | |
| 401 return (NULL); | |
| 402 } | |
| 403 return (name); | |
| 404 } | |
| 405 return (NULL); | |
| 406 } | |
| 407 | |
| 408 nvlist_t * | |
| 409 dm_get_stats(dm_descriptor_t desc, int stat_type, int *errp) | |
| 410 { | |
| 411 descriptor_t *dp; | |
| 412 nvlist_t *stats = NULL; | |
| 413 | |
| 414 | |
| 556 | 415 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 416 |
| 417 cache_rlock(); | |
| 418 | |
| 419 if (!cache_is_valid_desc(dp)) { | |
| 767 | 420 cache_unlock(); |
| 421 *errp = EBADF; | |
| 422 return (NULL); | |
| 0 | 423 } |
| 424 | |
| 425 /* verify that the descriptor is still valid */ | |
| 426 if (dp->p.generic == NULL) { | |
| 767 | 427 cache_unlock(); |
| 428 *errp = ENODEV; | |
| 429 return (NULL); | |
| 0 | 430 } |
| 431 | |
| 432 switch (dp->type) { | |
| 433 case DM_DRIVE: | |
| 767 | 434 stats = drive_get_stats(dp, stat_type, errp); |
| 435 break; | |
| 0 | 436 case DM_BUS: |
| 767 | 437 stats = bus_get_stats(dp, stat_type, errp); |
| 438 break; | |
| 0 | 439 case DM_CONTROLLER: |
| 767 | 440 stats = controller_get_stats(dp, stat_type, errp); |
| 441 break; | |
| 0 | 442 case DM_MEDIA: |
| 767 | 443 stats = media_get_stats(dp, stat_type, errp); |
| 444 break; | |
| 0 | 445 case DM_SLICE: |
| 767 | 446 if (stat_type == DM_SLICE_STAT_USE) { |
| 447 /* | |
| 448 * If NOINUSE_CHECK is set, we do not perform | |
| 449 * the in use checking if the user has set stat_type | |
| 450 * DM_SLICE_STAT_USE | |
| 451 */ | |
|
1107
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
452 if (NOINUSE_SET) { |
| 767 | 453 stats = NULL; |
| 454 break; | |
| 455 } | |
| 456 } | |
| 457 stats = slice_get_stats(dp, stat_type, errp); | |
| 458 break; | |
| 0 | 459 case DM_PARTITION: |
| 767 | 460 stats = partition_get_stats(dp, stat_type, errp); |
| 461 break; | |
| 0 | 462 case DM_PATH: |
| 767 | 463 stats = path_get_stats(dp, stat_type, errp); |
| 464 break; | |
| 0 | 465 case DM_ALIAS: |
| 767 | 466 stats = alias_get_stats(dp, stat_type, errp); |
| 467 break; | |
| 0 | 468 default: |
| 767 | 469 *errp = EINVAL; |
| 470 break; | |
| 0 | 471 } |
| 472 | |
| 473 cache_unlock(); | |
| 474 | |
| 475 return (stats); | |
| 476 } | |
| 477 | |
| 478 dm_desc_type_t | |
| 479 dm_get_type(dm_descriptor_t desc) | |
| 480 { | |
| 481 descriptor_t *dp; | |
| 482 | |
| 556 | 483 dp = (descriptor_t *)(uintptr_t)desc; |
| 0 | 484 |
| 485 cache_rlock(); | |
| 486 | |
| 487 if (!cache_is_valid_desc(dp)) { | |
| 488 cache_unlock(); | |
| 489 return (-1); | |
| 490 } | |
| 491 | |
| 492 cache_unlock(); | |
| 493 | |
| 494 return (dp->type); | |
| 495 } | |
| 767 | 496 /* |
| 497 * Returns, via slices paramater, a dm_descriptor_t list of | |
| 498 * slices for the named disk drive. | |
| 499 */ | |
| 500 void | |
| 501 dm_get_slices(char *drive, dm_descriptor_t **slices, int *errp) | |
| 502 { | |
| 503 dm_descriptor_t alias; | |
| 504 dm_descriptor_t *media; | |
| 505 dm_descriptor_t *disk; | |
| 0 | 506 |
| 767 | 507 *slices = NULL; |
| 508 *errp = 0; | |
| 509 | |
| 510 if (drive == NULL) { | |
| 511 return; | |
| 512 } | |
| 513 | |
| 514 alias = dm_get_descriptor_by_name(DM_ALIAS, drive, errp); | |
| 515 | |
| 516 /* | |
| 517 * Errors must be handled by the caller. The dm_descriptor_t * | |
| 518 * values will be NULL if an error occured in these calls. | |
| 519 */ | |
| 520 | |
| 521 if (alias != NULL) { | |
| 522 disk = dm_get_associated_descriptors(alias, DM_DRIVE, errp); | |
| 523 dm_free_descriptor(alias); | |
| 524 if (disk != NULL) { | |
| 525 media = dm_get_associated_descriptors(*disk, | |
| 526 DM_MEDIA, errp); | |
| 527 dm_free_descriptors(disk); | |
| 528 if (media != NULL) { | |
| 529 *slices = dm_get_associated_descriptors(*media, | |
| 530 DM_SLICE, errp); | |
| 531 dm_free_descriptors(media); | |
| 532 } | |
| 533 } | |
| 534 } | |
| 535 } | |
| 536 /* | |
| 537 * Convenience function to get slice stats | |
| 538 */ | |
| 539 void | |
| 540 dm_get_slice_stats(char *slice, nvlist_t **dev_stats, int *errp) | |
| 541 { | |
| 542 dm_descriptor_t devp; | |
| 543 | |
| 544 *dev_stats = NULL; | |
| 545 *errp = 0; | |
| 546 | |
| 547 if (slice == NULL) { | |
| 548 return; | |
| 549 } | |
| 550 | |
| 551 /* | |
| 552 * Errors must be handled by the caller. The dm_descriptor_t * | |
| 553 * values will be NULL if an error occured in these calls. | |
| 554 */ | |
| 555 devp = dm_get_descriptor_by_name(DM_SLICE, slice, errp); | |
| 556 if (devp != NULL) { | |
| 557 *dev_stats = dm_get_stats(devp, DM_SLICE_STAT_USE, | |
| 558 errp); | |
| 559 dm_free_descriptor(devp); | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 /* | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
564 * Checks for overlapping slices. If the given device is a slice, and it |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
565 * overlaps with any non-backup slice on the disk, return true with a detailed |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
566 * description similar to dm_inuse(). |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
567 */ |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
568 int |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
569 dm_isoverlapping(char *slicename, char **overlaps_with, int *errp) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
570 { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
571 dm_descriptor_t slice = NULL; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
572 dm_descriptor_t *media = NULL; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
573 dm_descriptor_t *slices = NULL; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
574 int i = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
575 uint32_t in_snum; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
576 uint64_t start_block = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
577 uint64_t end_block = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
578 uint64_t media_size = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
579 uint64_t size = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
580 nvlist_t *media_attrs = NULL; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
581 nvlist_t *slice_attrs = NULL; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
582 int ret = 0; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
583 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
584 slice = dm_get_descriptor_by_name(DM_SLICE, slicename, errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
585 if (slice == NULL) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
586 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
587 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
588 /* |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
589 * Get the list of slices be fetching the associated media, and then all |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
590 * associated slices. |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
591 */ |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
592 media = dm_get_associated_descriptors(slice, DM_MEDIA, errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
593 if (media == NULL || *media == NULL || *errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
594 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
595 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
596 slices = dm_get_associated_descriptors(*media, DM_SLICE, errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
597 if (slices == NULL || *slices == NULL || *errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
598 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
599 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
600 media_attrs = dm_get_attributes(*media, errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
601 if (media_attrs == NULL || *errp) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
602 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
603 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
604 *errp = nvlist_lookup_uint64(media_attrs, DM_NACCESSIBLE, &media_size); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
605 if (*errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
606 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
607 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
608 slice_attrs = dm_get_attributes(slice, errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
609 if (slice_attrs == NULL || *errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
610 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
611 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
612 *errp = nvlist_lookup_uint64(slice_attrs, DM_START, &start_block); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
613 if (*errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
614 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
615 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
616 *errp = nvlist_lookup_uint64(slice_attrs, DM_SIZE, &size); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
617 if (*errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
618 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
619 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
620 *errp = nvlist_lookup_uint32(slice_attrs, DM_INDEX, &in_snum); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
621 if (*errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
622 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
623 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
624 end_block = (start_block + size) - 1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
625 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
626 for (i = 0; slices[i]; i ++) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
627 uint64_t other_start; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
628 uint64_t other_end; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
629 uint64_t other_size; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
630 uint32_t snum; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
631 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
632 nvlist_t *other_attrs = dm_get_attributes(slices[i], errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
633 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
634 if (other_attrs == NULL) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
635 continue; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
636 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
637 if (*errp != 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
638 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
639 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
640 *errp = nvlist_lookup_uint64(other_attrs, DM_START, |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
641 &other_start); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
642 if (*errp) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
643 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
644 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
645 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
646 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
647 *errp = nvlist_lookup_uint64(other_attrs, DM_SIZE, |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
648 &other_size); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
649 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
650 if (*errp) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
651 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
652 ret = -1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
653 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
654 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
655 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
656 other_end = (other_size + other_start) - 1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
657 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
658 *errp = nvlist_lookup_uint32(other_attrs, DM_INDEX, |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
659 &snum); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
660 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
661 if (*errp) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
662 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
663 ret = -1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
664 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
665 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
666 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
667 /* |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
668 * Check to see if there are > 2 overlapping regions |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
669 * on this media in the same region as this slice. |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
670 * This is done by assuming the following: |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
671 * Slice 2 is the backup slice if it is the size |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
672 * of the whole disk |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
673 * If slice 2 is the overlap and slice 2 is the size of |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
674 * the whole disk, continue. If another slice is found |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
675 * that overlaps with our slice, return it. |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
676 * There is the potential that there is more than one slice |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
677 * that our slice overlaps with, however, we only return |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
678 * the first overlapping slice we find. |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
679 * |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
680 */ |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
681 if (start_block >= other_start && start_block <= other_end) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
682 if ((snum == 2 && (other_size == media_size)) || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
683 snum == in_snum) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
684 continue; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
685 } else { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
686 char *str = dm_get_name(slices[i], errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
687 if (*errp != 0) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
688 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
689 ret = -1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
690 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
691 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
692 *overlaps_with = strdup(str); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
693 dm_free_name(str); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
694 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
695 ret = 1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
696 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
697 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
698 } else if (other_start >= start_block && |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
699 other_start <= end_block) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
700 if ((snum == 2 && (other_size == media_size)) || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
701 snum == in_snum) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
702 continue; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
703 } else { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
704 char *str = dm_get_name(slices[i], errp); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
705 if (*errp != 0) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
706 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
707 ret = -1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
708 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
709 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
710 *overlaps_with = strdup(str); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
711 dm_free_name(str); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
712 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
713 ret = 1; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
714 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
715 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
716 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
717 nvlist_free(other_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
718 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
719 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
720 out: |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
721 if (media_attrs) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
722 nvlist_free(media_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
723 if (slice_attrs) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
724 nvlist_free(slice_attrs); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
725 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
726 if (slices) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
727 dm_free_descriptors(slices); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
728 if (media) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
729 dm_free_descriptors(media); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
730 if (slice) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
731 dm_free_descriptor(slice); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
732 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
733 return (ret); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
734 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
735 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
736 /* |
|
4082
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
737 * Get the full list of swap entries. Returns -1 on error, or >= 0 to |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
738 * indicate the number of entries in the list. Callers are responsible |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
739 * for calling dm_free_swapentries() to deallocate memory. If this |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
740 * returns 0, the swaptbl_t still needs to be freed. |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
741 */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
742 int |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
743 dm_get_swapentries(swaptbl_t **stp, int *errp) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
744 { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
745 int count, i; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
746 swaptbl_t *tbl; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
747 char *ptr; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
748 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
749 *stp = NULL; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
750 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
751 /* get number of swap entries */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
752 if ((count = swapctl(SC_GETNSWP, NULL)) < 0) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
753 *errp = errno; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
754 return (-1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
755 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
756 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
757 if (count == 0) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
758 return (0); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
759 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
760 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
761 /* allocate space */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
762 tbl = calloc(1, sizeof (int) + count * sizeof (swapent_t)); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
763 if (tbl == NULL) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
764 *errp = ENOMEM; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
765 return (-1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
766 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
767 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
768 ptr = calloc(1, count * MAXPATHLEN); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
769 if (ptr == NULL) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
770 *errp = ENOMEM; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
771 free(tbl); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
772 return (-1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
773 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
774 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
775 /* set up pointers to the pathnames */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
776 tbl->swt_n = count; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
777 for (i = 0; i < count; i++) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
778 tbl->swt_ent[i].ste_path = ptr; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
779 ptr += MAXPATHLEN; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
780 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
781 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
782 /* get list of swap paths */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
783 count = swapctl(SC_LIST, tbl); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
784 if (count < 0) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
785 *errp = errno; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
786 free(ptr); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
787 free(tbl); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
788 return (-1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
789 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
790 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
791 *stp = tbl; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
792 return (count); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
793 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
794 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
795 /* ARGSUSED */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
796 void |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
797 dm_free_swapentries(swaptbl_t *stp) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
798 { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
799 ASSERT(stp != NULL); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
800 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
801 free(stp->swt_ent[0].ste_path); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
802 free(stp); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
803 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
804 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
805 /* |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
806 * Check a slice to see if it's being used by swap. |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
807 */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
808 int |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
809 dm_inuse_swap(const char *dev_name, int *errp) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
810 { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
811 int count; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
812 int found; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
813 swaptbl_t *tbl = NULL; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
814 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
815 *errp = 0; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
816 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
817 count = dm_get_swapentries(&tbl, errp); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
818 if (count < 0 || *errp) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
819 if (tbl) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
820 dm_free_swapentries(tbl); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
821 return (-1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
822 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
823 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
824 /* if there are no swap entries, we're done */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
825 if (!count) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
826 return (0); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
827 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
828 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
829 ASSERT(tbl != NULL); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
830 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
831 found = 0; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
832 while (count--) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
833 if (strcmp(dev_name, tbl->swt_ent[count].ste_path) == 0) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
834 found = 1; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
835 break; |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
836 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
837 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
838 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
839 dm_free_swapentries(tbl); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
840 return (found); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
841 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
842 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
843 /* |
| 767 | 844 * Returns 'in use' details, if found, about a specific dev_name, |
| 845 * based on the caller(who). It is important to note that it is possible | |
| 846 * for there to be more than one 'in use' statistic regarding a dev_name. | |
| 847 * The **msg parameter returns a list of 'in use' details. This message | |
| 848 * is formatted via gettext(). | |
| 849 */ | |
| 850 int | |
| 851 dm_inuse(char *dev_name, char **msg, dm_who_type_t who, int *errp) | |
| 852 { | |
| 853 nvlist_t *dev_stats = NULL; | |
| 854 char *by, *data; | |
| 855 nvpair_t *nvwhat = NULL; | |
| 856 nvpair_t *nvdesc = NULL; | |
| 857 int found = 0; | |
|
4082
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
858 int err; |
| 767 | 859 char *dname = NULL; |
| 860 | |
| 861 *errp = 0; | |
| 862 *msg = NULL; | |
| 863 | |
|
1107
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
864 /* |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
865 * If the user doesn't want to do in use checking, return. |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
866 */ |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
867 |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
868 if (NOINUSE_SET) |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
869 return (0); |
|
1f78db36dee1
6349487 libdiskmgt should bypass all calls in dm_inuse when NOINUSE_CHECK is set
sjelinek
parents:
767
diff
changeset
|
870 |
| 767 | 871 dname = getfullblkname(dev_name); |
| 872 /* | |
| 873 * If we cannot find the block name, we cannot check the device | |
| 874 * for in use statistics. So, return found, which is == 0. | |
| 875 */ | |
| 876 if (dname == NULL || *dname == '\0') { | |
| 877 return (found); | |
| 878 } | |
| 879 | |
|
4082
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
880 /* |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
881 * Slice stats for swap devices are only returned if mounted |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
882 * (e.g. /tmp). Other devices or files being used for swap |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
883 * are ignored, so we add a special check here to use swapctl(2) |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
884 * to perform in-use checking. |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
885 */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
886 if (ANY_ZPOOL_USE(who) && (err = dm_inuse_swap(dname, errp))) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
887 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
888 /* on error, dm_inuse_swap sets errp */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
889 if (err < 0) { |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
890 free(dname); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
891 return (err); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
892 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
893 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
894 /* simulate a mounted swap device */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
895 (void) build_usage_string(dname, DM_USE_MOUNT, "swap", msg, |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
896 &found, errp); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
897 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
898 /* if this fails, dm_get_usage_string changed */ |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
899 ASSERT(found == 1); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
900 |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
901 free(dname); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
902 return (found); |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
903 } |
|
2e3825fd8bb5
6372011 libdiskmgt needs to build appropriate .po file
mmusante
parents:
3741
diff
changeset
|
904 |
| 767 | 905 dm_get_slice_stats(dname, &dev_stats, errp); |
| 906 if (dev_stats == NULL) { | |
| 907 /* | |
| 908 * If there is an error, but it isn't a no device found error | |
| 909 * return the error as recorded. Otherwise, with a full | |
| 910 * block name, we might not be able to get the slice | |
| 911 * associated, and will get an ENODEV error. For example, | |
| 912 * an SVM metadevice will return a value from getfullblkname() | |
| 913 * but libdiskmgt won't be able to find this device for | |
| 914 * statistics gathering. This is expected and we should not | |
| 915 * report errnoneous errors. | |
| 916 */ | |
| 917 if (*errp) { | |
| 918 if (*errp == ENODEV) { | |
| 919 *errp = 0; | |
| 920 } | |
| 921 } | |
| 922 free(dname); | |
| 923 return (found); | |
| 924 } | |
| 925 | |
| 926 for (;;) { | |
| 927 | |
| 928 nvwhat = nvlist_next_nvpair(dev_stats, nvdesc); | |
| 929 nvdesc = nvlist_next_nvpair(dev_stats, nvwhat); | |
| 930 | |
| 931 /* | |
| 932 * End of the list found. | |
| 933 */ | |
| 934 if (nvwhat == NULL || nvdesc == NULL) { | |
| 935 break; | |
| 936 } | |
| 937 /* | |
| 938 * Otherwise, we check to see if this client(who) cares | |
| 939 * about this in use scenario | |
| 940 */ | |
| 941 | |
| 942 ASSERT(strcmp(nvpair_name(nvwhat), DM_USED_BY) == 0); | |
| 943 ASSERT(strcmp(nvpair_name(nvdesc), DM_USED_NAME) == 0); | |
| 944 /* | |
| 945 * If we error getting the string value continue on | |
| 946 * to the next pair(if there is one) | |
| 947 */ | |
| 948 if (nvpair_value_string(nvwhat, &by)) { | |
| 949 continue; | |
| 950 } | |
| 951 if (nvpair_value_string(nvdesc, &data)) { | |
| 952 continue; | |
| 953 } | |
| 954 | |
| 955 switch (who) { | |
| 956 case DM_WHO_MKFS: | |
| 957 /* | |
| 958 * mkfs is not in use for these cases. | |
| 959 * All others are in use. | |
| 960 */ | |
| 961 if (strcmp(by, DM_USE_LU) == 0 || | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
962 strcmp(by, DM_USE_FS) == 0 || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
963 strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { |
| 767 | 964 break; |
| 965 } | |
| 966 if (build_usage_string(dname, | |
| 967 by, data, msg, &found, errp) != 0) { | |
| 968 if (*errp) { | |
| 969 goto out; | |
| 970 } | |
| 971 } | |
| 972 break; | |
| 973 case DM_WHO_SWAP: | |
| 974 /* | |
| 975 * Not in use for this. | |
| 976 */ | |
| 977 if (strcmp(by, DM_USE_DUMP) == 0 || | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
978 strcmp(by, DM_USE_FS) == 0 || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
979 strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { |
| 767 | 980 break; |
| 981 } | |
| 982 | |
| 983 if (build_usage_string(dname, | |
| 984 by, data, msg, &found, errp) != 0) { | |
| 985 if (*errp) { | |
| 986 goto out; | |
| 987 } | |
| 988 } | |
| 989 break; | |
| 990 case DM_WHO_DUMP: | |
| 991 /* | |
| 992 * Not in use for this. | |
| 993 */ | |
| 994 if ((strcmp(by, DM_USE_MOUNT) == 0 && | |
| 995 strcmp(data, "swap") == 0) || | |
| 996 strcmp(by, DM_USE_DUMP) == 0 || | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
997 strcmp(by, DM_USE_FS) == 0 || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
998 strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { |
| 767 | 999 break; |
| 1000 } | |
| 1001 if (build_usage_string(dname, | |
| 1002 by, data, msg, &found, errp)) { | |
| 1003 if (*errp) { | |
| 1004 goto out; | |
| 1005 } | |
| 1006 } | |
| 1007 break; | |
| 1008 | |
| 1009 case DM_WHO_FORMAT: | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1010 if (strcmp(by, DM_USE_FS) == 0 || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1011 strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) |
| 767 | 1012 break; |
| 1013 if (build_usage_string(dname, | |
| 1014 by, data, msg, &found, errp) != 0) { | |
| 1015 if (*errp) { | |
| 1016 goto out; | |
| 1017 } | |
| 1018 } | |
| 1019 break; | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1020 |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1021 case DM_WHO_ZPOOL_FORCE: |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1022 if (strcmp(by, DM_USE_FS) == 0 || |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1023 strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1024 break; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1025 /* FALLTHROUGH */ |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1026 case DM_WHO_ZPOOL: |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1027 if (build_usage_string(dname, |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1028 by, data, msg, &found, errp) != 0) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1029 if (*errp) |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1030 goto out; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1031 } |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1032 break; |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1033 |
|
3741
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1034 case DM_WHO_ZPOOL_SPARE: |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1035 if (strcmp(by, DM_USE_SPARE_ZPOOL) != 0) { |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1036 if (build_usage_string(dname, by, |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1037 data, msg, &found, errp) != 0) { |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1038 if (*errp) |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1039 goto out; |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1040 } |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1041 } |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1042 break; |
|
806e933bf124
6441384 zpool import action message is not correctly localized
mmusante
parents:
2082
diff
changeset
|
1043 |
| 767 | 1044 default: |
| 1045 /* | |
| 1046 * nothing found in use for this client | |
| 1047 * of libdiskmgt. Default is 'not in use'. | |
| 1048 */ | |
| 1049 break; | |
| 1050 } | |
| 1051 } | |
| 1052 out: | |
| 1053 if (dname != NULL) | |
| 1054 free(dname); | |
| 1055 if (dev_stats != NULL) | |
| 1056 nvlist_free(dev_stats); | |
| 1057 | |
| 1058 return (found); | |
| 1059 } | |
| 1060 | |
| 1061 void | |
| 1062 dm_get_usage_string(char *what, char *how, char **usage_string) | |
| 1063 { | |
| 1064 | |
| 1065 | |
| 1066 if (usage_string == NULL || what == NULL) { | |
| 1067 return; | |
| 1068 } | |
| 1069 *usage_string = NULL; | |
| 1070 | |
| 1071 if (strcmp(what, DM_USE_MOUNT) == 0) { | |
| 1072 if (strcmp(how, "swap") == 0) { | |
| 1073 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1074 "%s is currently used by swap. Please see swap(1M)." | |
| 1075 "\n"); | |
| 1076 } else { | |
| 1077 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1078 "%s is currently mounted on %s." | |
| 1079 " Please see umount(1M).\n"); | |
| 1080 } | |
| 1081 } else if (strcmp(what, DM_USE_VFSTAB) == 0) { | |
| 1082 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1083 "%s is normally mounted on %s according to /etc/vfstab. " | |
| 1084 "Please remove this entry to use this device.\n"); | |
| 1085 } else if (strcmp(what, DM_USE_FS) == 0) { | |
| 1086 *usage_string = dgettext(TEXT_DOMAIN, | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1087 "%s contains a %s filesystem.\n"); |
| 767 | 1088 } else if (strcmp(what, DM_USE_SVM) == 0) { |
| 1089 if (strcmp(how, "mdb") == 0) { | |
| 1090 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1091 "%s contains an SVM %s. Please see " | |
| 1092 "metadb(1M).\n"); | |
| 1093 } else { | |
| 1094 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1095 "%s is part of SVM volume %s. " | |
| 1096 "Please see metaclear(1M).\n"); | |
| 1097 } | |
| 1098 } else if (strcmp(what, DM_USE_VXVM) == 0) { | |
| 1099 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1100 "%s is part of VxVM volume %s.\n"); | |
| 1101 } else if (strcmp(what, DM_USE_LU) == 0) { | |
| 1102 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1103 "%s is in use for live upgrade %s. Please see ludelete(1M)." | |
| 1104 "\n"); | |
| 1105 } else if (strcmp(what, DM_USE_DUMP) == 0) { | |
| 1106 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1107 "%s is in use by %s. Please see dumpadm(1M)." | |
| 1108 "\n"); | |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1109 } else if (strcmp(what, DM_USE_EXPORTED_ZPOOL) == 0) { |
| 767 | 1110 *usage_string = dgettext(TEXT_DOMAIN, |
|
1352
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1111 "%s is part of exported or potentially active ZFS pool %s. " |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1112 "Please see zpool(1M).\n"); |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1113 } else if (strcmp(what, DM_USE_ACTIVE_ZPOOL) == 0) { |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1114 *usage_string = dgettext(TEXT_DOMAIN, |
|
b7039548de2f
6343802 zpool(1M) should make better use of libdiskmgt
eschrock
parents:
1107
diff
changeset
|
1115 "%s is part of active ZFS pool %s. Please see zpool(1M)." |
| 767 | 1116 "\n"); |
| 2082 | 1117 } else if (strcmp(what, DM_USE_SPARE_ZPOOL) == 0) { |
| 1118 *usage_string = dgettext(TEXT_DOMAIN, | |
| 1119 "%s is reserved as a hot spare for ZFS pool %s. Please " | |
| 1120 "see zpool(1M).\n"); | |
| 767 | 1121 } |
| 1122 } | |
| 0 | 1123 void |
| 1124 libdiskmgt_add_str(nvlist_t *attrs, char *name, char *val, int *errp) | |
| 1125 { | |
| 1126 if (*errp == 0) { | |
| 1127 *errp = nvlist_add_string(attrs, name, val); | |
| 1128 } | |
| 1129 } | |
| 1130 | |
| 1131 descriptor_t ** | |
| 1132 libdiskmgt_empty_desc_array(int *errp) | |
| 1133 { | |
| 1134 descriptor_t **empty; | |
| 1135 | |
| 1136 empty = (descriptor_t **)calloc(1, sizeof (descriptor_t *)); | |
| 1137 if (empty == NULL) { | |
| 1138 *errp = ENOMEM; | |
| 1139 return (NULL); | |
| 1140 } | |
| 1141 empty[0] = NULL; | |
| 1142 | |
| 1143 *errp = 0; | |
| 1144 return (empty); | |
| 1145 } | |
| 1146 | |
| 1147 void | |
| 1148 libdiskmgt_init_debug() | |
| 1149 { | |
| 1150 char *valp; | |
| 1151 | |
| 1152 if ((valp = getenv(DM_DEBUG)) != NULL) { | |
| 1153 dm_debug = atoi(valp); | |
| 1154 } | |
| 1155 } | |
| 1156 | |
| 1157 int | |
| 1158 libdiskmgt_str_eq(char *nm1, char *nm2) | |
| 1159 { | |
| 1160 if (nm1 == NULL) { | |
| 1161 if (dm_debug) { | |
| 1162 (void) fprintf(stderr, "WARNING: str_eq nm1 NULL\n"); | |
| 1163 } | |
| 1164 | |
| 1165 if (nm2 == NULL) { | |
| 1166 return (1); | |
| 1167 } else { | |
| 1168 return (0); | |
| 1169 } | |
| 1170 } | |
| 1171 | |
| 1172 /* nm1 != NULL */ | |
| 1173 | |
| 1174 if (nm2 == NULL) { | |
| 1175 if (dm_debug) { | |
| 1176 (void) fprintf(stderr, "WARNING: str_eq nm2 NULL\n"); | |
| 1177 } | |
| 1178 return (0); | |
| 1179 } | |
| 1180 | |
| 1181 if (strcmp(nm1, nm2) == 0) { | |
| 1182 return (1); | |
| 1183 } | |
| 1184 | |
| 1185 return (0); | |
| 1186 } | |
| 1187 | |
| 1188 /*ARGSUSED*/ | |
| 1189 static descriptor_t ** | |
| 1190 desc_array_to_ptr_array(dm_descriptor_t *descs, int *errp) | |
| 1191 { | |
| 1192 #ifdef _LP64 | |
| 1193 return ((descriptor_t **)descs); | |
| 1194 #else | |
| 1195 /* convert the 64 bit descriptors to 32 bit ptrs */ | |
| 1196 int cnt; | |
| 1197 int i; | |
| 1198 descriptor_t **da; | |
| 1199 | |
| 1200 for (cnt = 0; descs[cnt]; cnt++); | |
| 1201 | |
| 1202 da = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *)); | |
| 1203 if (da == NULL) { | |
| 1204 *errp = ENOMEM; | |
| 1205 return (NULL); | |
| 1206 } | |
| 1207 | |
| 1208 for (i = 0; descs[i]; i++) { | |
| 556 | 1209 da[i] = (descriptor_t *)(uintptr_t)descs[i]; |
| 0 | 1210 } |
| 1211 *errp = 0; | |
| 1212 free(descs); | |
| 1213 | |
| 1214 return (da); | |
| 1215 #endif | |
| 1216 } | |
| 1217 | |
| 1218 /*ARGSUSED*/ | |
| 1219 static dm_descriptor_t * | |
| 1220 ptr_array_to_desc_array(descriptor_t **ptrs, int *errp) | |
| 1221 { | |
| 1222 #ifdef _LP64 | |
| 1223 return ((dm_descriptor_t *)ptrs); | |
| 1224 #else | |
| 1225 /* convert the 32 bit ptrs to the 64 bit descriptors */ | |
| 1226 int cnt; | |
| 1227 int i; | |
| 1228 dm_descriptor_t *da; | |
| 1229 | |
| 1230 if (*errp != 0 || ptrs == NULL) { | |
| 1231 return (NULL); | |
| 1232 } | |
| 1233 | |
| 1234 for (cnt = 0; ptrs[cnt]; cnt++); | |
| 1235 | |
| 1236 da = (dm_descriptor_t *)calloc(cnt + 1, sizeof (dm_descriptor_t)); | |
| 1237 if (da == NULL) { | |
| 1238 *errp = ENOMEM; | |
| 1239 return (NULL); | |
| 1240 } | |
| 1241 | |
| 1242 for (i = 0; ptrs[i]; i++) { | |
| 1243 da[i] = (uintptr_t)ptrs[i]; | |
| 1244 } | |
| 1245 *errp = 0; | |
| 1246 free(ptrs); | |
| 1247 | |
| 1248 return (da); | |
| 1249 #endif | |
| 1250 } | |
| 767 | 1251 /* |
| 1252 * Build the usage string for the in use data. Return the build string in | |
| 1253 * the msg parameter. This function takes care of reallocing all the memory | |
| 1254 * for this usage string. Usage string is returned already formatted for | |
| 1255 * localization. | |
| 1256 */ | |
| 1257 static int | |
| 1258 build_usage_string(char *dname, char *by, char *data, char **msg, | |
| 1259 int *found, int *errp) | |
| 1260 { | |
| 1261 int len0; | |
| 1262 int len1; | |
| 1263 char *use; | |
| 1264 char *p; | |
| 1265 | |
| 1266 *errp = 0; | |
| 1267 | |
| 1268 dm_get_usage_string(by, data, &use); | |
| 1269 if (!use) { | |
| 1270 return (-1); | |
| 1271 } | |
| 1272 | |
| 1273 if (*msg) | |
| 1274 len0 = strlen(*msg); | |
| 1275 else | |
| 1276 len0 = 0; | |
| 1277 /* LINTED */ | |
| 1278 len1 = snprintf(NULL, 0, use, dname, data); | |
| 1279 | |
| 1280 /* | |
| 1281 * If multiple in use details they | |
| 1282 * are listed 1 per line for ease of | |
| 1283 * reading. dm_find_usage_string | |
| 1284 * formats these appropriately. | |
| 1285 */ | |
| 1286 if ((p = realloc(*msg, len0 + len1 + 1)) == NULL) { | |
| 1287 *errp = errno; | |
| 1288 free(*msg); | |
| 1289 return (-1); | |
| 1290 } | |
| 1291 *msg = p; | |
| 1292 | |
| 1293 /* LINTED */ | |
| 1294 (void) snprintf(*msg + len0, len1 + 1, use, dname, data); | |
| 1295 (*found)++; | |
| 1296 return (0); | |
| 1297 } |