Print this page
NEX-16819 loader UEFI support
Includes work by Toomas Soome <tsoome@me.com>
Upstream commits:
loader: pxe receive cleanup
9475 libefi: Do not return only if ReceiveFilter
installboot: should support efi system partition
8931 boot1.efi: scan all display modes rather than
loader: spinconsole updates
loader: gfx experiment to try GOP Blt() function.
sha1 build test
loader: add sha1 hash calculation
common/sha1: update for loader build
loader: biosdisk rework
uts: 32-bit kernel FB needs mapping in low memory
uts: add diag-device
uts: boot console mirror with diag-device
uts: enable very early console on ttya
kmdb: add diag-device as input/output device
uts: test VGA memory exclusion from mapping
uts: clear boot mapping and protect boot pages test
uts: add dboot map debug printf
uts: need to release FB pages in release_bootstrap()
uts: add screenmap ioctl
uts: update sys/queue.h
loader: add illumos uts/common to include path
loader: tem/gfx font cleanup
loader: vbe checks
uts: gfx_private set KD_TEXT when KD_RESETTEXT is
uts: gfx 8-bit update
loader: gfx 8-bit fix
loader: always set media size from partition.
uts: MB2 support for 32-bit kernel
loader: x86 should have tem 80x25
uts: x86 should have tem 80x25
uts: font update
loader: font update
uts: tem attributes
loader: tem.c comment added
uts: use font module
loader: add font module
loader: build rules for new font setup
uts: gfx_private update for new font structure
uts: early boot update for new font structure
uts: font update
uts: font build rules update for new fonts
uts: tem update to new font structure
loader: module.c needs to include tem_impl.h
uts: gfx_private 8x16 font rework
uts: make font_lookup public
loader: font rework
uts: font rework
9259 libefi: efi_alloc_and_read should check for PMBR
uts: tem utf-8 support
loader: implement tem utf-8 support
loader: tem should be able to display UTF-8
7784 uts: console input should support utf-8
7796 uts: ldterm default to utf-8
uts: do not reset serial console
uts: set up colors even if tem is not console
uts: add type for early boot properties
uts: gfx_private experiment with drm and vga
uts: gfx_private should use setmode drm callback.
uts: identify FB types and set up gfx_private based
loader: replace gop and vesa with framebuffer
uts: boot needs simple tem to support mdb
uts: boot_keyboard should emit esc sequences for
uts: gfx_private FB showuld be written by line
kmdb: set terminal window size
uts: gfx_private needs to keep track of early boot FB
pnglite: move pnglite to usr/src/common
loader: gfx_fb
ficl-sys: add gfx primitives
loader: add illumos.png logo
ficl: add fb-putimage
loader: add png support
loader: add alpha blending for gfx_fb
loader: use term-drawrect for menu frame
ficl: add simple gfx words
uts: provide fb_info via fbgattr dev_specific array.
uts: gfx_private add alpha blending
uts: update sys/ascii.h
uts: tem OSC support (incomplete)
uts: implement env module support and use data from
uts: tem get colors from early boot data
loader: use crc32 from libstand (libz)
loader: optimize for size
loader: pass tem info to the environment
loader: import tem for loader console
loader: UEFI loader needs to set ISADIR based on
loader: need UEFI32 support
8918 loader.efi: add vesa edid support
uts: tem_safe_pix_clear_prom_output() should only
uts: tem_safe_pix_clear_entire_screen() should use
uts: tem_safe_check_first_time() should query cursor
uts: tem implement cls callback & visual_io v4
uts: gfx_vgatext use block cursor for vgatext
uts: gfx_private implement cls callback & visual_io
uts: gfx_private bitmap framebuffer implementation
uts: early start frame buffer console support
uts: font functions should check the input char
uts: font rendering should support 16/24/32bit depths
uts: use smallest font as fallback default.
uts: update terminal dimensions based on selected
7834 uts: vgatext should use gfx_private
uts: add spacing property to 8859-1.bdf
terminfo: add underline for sun-color
terminfo: sun-color has 16 colors
uts: add font load callback type
loader: do not repeat int13 calls with error 0x20 and
8905 loader: add skein/edonr support
8904 common/crypto: make skein and edonr loader
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-14951 teach libdiskmgt about nvme, sata and xen (lint)
NEX-14951 teach libdiskmgt about nvme, sata and xen
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
NEX-14023 cfgadm_plugins/shp: memory leak in cfga_get_condition()
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
NEX-14022 libdiskmgt: memory leak in slice_get_stats()
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libdiskmgt/common/slice.c
+++ new/usr/src/lib/libdiskmgt/common/slice.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 28 * Copyright 2017 Nexenta Systems, Inc.
29 29 */
30 30
31 31 #include <fcntl.h>
32 32 #include <libdevinfo.h>
33 33 #include <stdio.h>
34 34 #include <stdlib.h>
35 35 #include <string.h>
36 36 #include <dirent.h>
37 37 #include <sys/dkio.h>
38 38 #include <sys/stat.h>
39 39 #include <sys/sunddi.h>
40 40 #include <sys/types.h>
41 41 #include <sys/vtoc.h>
42 42 #include <unistd.h>
43 43 #include <devid.h>
44 44 #include <dirent.h>
45 45 #include <sys/dktp/fdisk.h>
46 46 #include <sys/efi_partition.h>
47 47
48 48 #include "libdiskmgt.h"
49 49 #include "disks_private.h"
50 50 #include "partition.h"
51 51 #ifndef VT_ENOTSUP
52 52 #define VT_ENOTSUP (-5)
53 53 #endif
54 54
55 55 #define FMT_UNKNOWN 0
56 56 #define FMT_VTOC 1
57 57 #define FMT_EFI 2
58 58
59 59 typedef int (*detectorp)(char *, nvlist_t *, int *);
60 60
61 61 static detectorp detectors[] = {
62 62 inuse_mnt,
63 63 inuse_active_zpool,
64 64 inuse_lu,
65 65 inuse_dump,
66 66 inuse_vxvm,
67 67 inuse_exported_zpool,
68 68 inuse_fs, /* fs should always be last */
69 69 NULL
70 70 };
71 71
72 72 static int add_inuse(char *name, nvlist_t *attrs);
73 73 static int desc_ok(descriptor_t *dp);
74 74 static void dsk2rdsk(char *dsk, char *rdsk, int size);
75 75 static int get_attrs(descriptor_t *dp, int fd, nvlist_t *attrs);
|
↓ open down ↓ |
75 lines elided |
↑ open up ↑ |
76 76 static descriptor_t **get_fixed_assocs(descriptor_t *desc, int *errp);
77 77 static int get_slice_num(slice_t *devp);
78 78 static int match_fixed_name(disk_t *dp, char *name, int *errp);
79 79 static int make_fixed_descriptors(disk_t *dp);
80 80
81 81 descriptor_t **
82 82 slice_get_assoc_descriptors(descriptor_t *desc, dm_desc_type_t type,
83 83 int *errp)
84 84 {
85 85 if (!desc_ok(desc)) {
86 - *errp = ENODEV;
87 - return (NULL);
86 + *errp = ENODEV;
87 + return (NULL);
88 88 }
89 89
90 90 switch (type) {
91 91 case DM_MEDIA:
92 - return (media_get_assocs(desc, errp));
92 + return (media_get_assocs(desc, errp));
93 93 case DM_PARTITION:
94 - return (partition_get_assocs(desc, errp));
94 + return (partition_get_assocs(desc, errp));
95 95 }
96 96
97 97 *errp = EINVAL;
98 98 return (NULL);
99 99 }
100 100
101 101 /*
102 102 * This is called by media/partition to get the slice descriptors for the given
103 103 * media/partition descriptor.
104 104 * For media, just get the slices, but for a partition, it must be a solaris
105 105 * partition and if there are active partitions, it must be the active one.
106 106 */
107 107 descriptor_t **
108 108 slice_get_assocs(descriptor_t *desc, int *errp)
109 109 {
110 110 /* Just check the first drive name. */
111 111 if (desc->p.disk->aliases == NULL) {
112 - *errp = 0;
113 - return (libdiskmgt_empty_desc_array(errp));
112 + *errp = 0;
113 + return (libdiskmgt_empty_desc_array(errp));
114 114 }
115 115
116 116 return (get_fixed_assocs(desc, errp));
117 117 }
118 118
119 119 nvlist_t *
120 120 slice_get_attributes(descriptor_t *dp, int *errp)
121 121 {
122 122 nvlist_t *attrs = NULL;
123 123 int fd;
124 124 char devpath[MAXPATHLEN];
125 125
126 126 if (!desc_ok(dp)) {
127 - *errp = ENODEV;
128 - return (NULL);
127 + *errp = ENODEV;
128 + return (NULL);
129 129 }
130 130
131 131 if (nvlist_alloc(&attrs, NVATTRS, 0) != 0) {
132 - *errp = ENOMEM;
133 - return (NULL);
132 + *errp = ENOMEM;
133 + return (NULL);
134 134 }
135 135
136 136 /* dp->name is /dev/dsk, need to convert back to /dev/rdsk */
137 137 dsk2rdsk(dp->name, devpath, sizeof (devpath));
138 138 fd = open(devpath, O_RDONLY|O_NDELAY);
139 139
140 140 if ((*errp = get_attrs(dp, fd, attrs)) != 0) {
141 - nvlist_free(attrs);
142 - attrs = NULL;
141 + nvlist_free(attrs);
142 + attrs = NULL;
143 143 }
144 144
145 145 if (fd >= 0) {
146 - (void) close(fd);
146 + (void) close(fd);
147 147 }
148 148
149 149 return (attrs);
150 150 }
151 151
152 152 /*
153 153 * Look for the slice by the slice devpath.
154 154 */
155 155 descriptor_t *
156 156 slice_get_descriptor_by_name(char *name, int *errp)
157 157 {
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
158 158 int found = 0;
159 159 disk_t *dp;
160 160
161 161 for (dp = cache_get_disklist(); dp != NULL; dp = dp->next) {
162 162 found = match_fixed_name(dp, name, errp);
163 163
164 164 if (found) {
165 165 char mname[MAXPATHLEN];
166 166
167 167 if (*errp != 0) {
168 - return (NULL);
168 + return (NULL);
169 169 }
170 170
171 171 mname[0] = 0;
172 172 (void) media_read_name(dp, mname, sizeof (mname));
173 173
174 174 return (cache_get_desc(DM_SLICE, dp, name, mname,
175 175 errp));
176 176 }
177 177 }
178 178
179 179 *errp = ENODEV;
180 180 return (NULL);
181 181 }
182 182
183 183 /* ARGSUSED */
184 184 descriptor_t **
185 185 slice_get_descriptors(int filter[], int *errp)
186 186 {
187 187 return (cache_get_descriptors(DM_SLICE, errp));
188 188 }
189 189
190 190 char *
191 191 slice_get_name(descriptor_t *desc)
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
192 192 {
193 193 return (desc->name);
194 194 }
195 195
196 196 nvlist_t *
197 197 slice_get_stats(descriptor_t *dp, int stat_type, int *errp)
198 198 {
199 199 nvlist_t *stats;
200 200
201 201 if (stat_type != DM_SLICE_STAT_USE) {
202 - *errp = EINVAL;
203 - return (NULL);
202 + *errp = EINVAL;
203 + return (NULL);
204 204 }
205 205
206 206 *errp = 0;
207 207
208 208 if (nvlist_alloc(&stats, NVATTRS_STAT, 0) != 0) {
209 - *errp = ENOMEM;
210 - return (NULL);
209 + *errp = ENOMEM;
210 + return (NULL);
211 211 }
212 212
213 213 if ((*errp = add_inuse(dp->name, stats)) != 0) {
214 214 nvlist_free(stats);
215 215 return (NULL);
216 216 }
217 217
218 218 return (stats);
219 219 }
220 220
221 221 /*
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
222 222 * A slice descriptor points to a disk, the name is the devpath and the
223 223 * secondary name is the media name.
224 224 */
225 225 int
226 226 slice_make_descriptors()
227 227 {
228 228 disk_t *dp;
229 229
230 230 dp = cache_get_disklist();
231 231 while (dp != NULL) {
232 - int error;
232 + int error;
233 233
234 - error = make_fixed_descriptors(dp);
235 - if (error != 0) {
236 - return (error);
237 - }
234 + error = make_fixed_descriptors(dp);
235 + if (error != 0) {
236 + return (error);
237 + }
238 238
239 - dp = dp->next;
239 + dp = dp->next;
240 240 }
241 241
242 242 return (0);
243 243 }
244 244
245 245 /* convert rdsk paths to dsk paths */
246 246 void
247 247 slice_rdsk2dsk(char *rdsk, char *dsk, int size)
248 248 {
249 249 char *strp;
250 250
251 251 (void) strlcpy(dsk, rdsk, size);
252 252
253 253 if ((strp = strstr(dsk, "/rdsk/")) == NULL) {
254 - /* not rdsk, check for floppy */
255 - strp = strstr(dsk, "/rdiskette");
254 + /* not rdsk, check for floppy */
255 + strp = strstr(dsk, "/rdiskette");
256 256 }
257 257
258 258 if (strp != NULL) {
259 - strp++; /* move ptr to the r in rdsk or rdiskette */
259 + strp++; /* move ptr to the r in rdsk or rdiskette */
260 260
261 - /* move the succeeding chars over by one */
262 - do {
263 - *strp = *(strp + 1);
264 - strp++;
265 - } while (*strp);
261 + /* move the succeeding chars over by one */
262 + do {
263 + *strp = *(strp + 1);
264 + strp++;
265 + } while (*strp);
266 266 }
267 267 }
268 268
269 269 /*
270 270 * Check if/how the slice is used.
271 271 */
272 272 static int
273 273 add_inuse(char *name, nvlist_t *attrs)
274 274 {
275 275 int i;
276 276 int error;
277 277
278 278 for (i = 0; detectors[i] != NULL; i ++) {
279 - if (detectors[i](name, attrs, &error) || error != 0) {
280 - if (error != 0) {
281 - return (error);
279 + if (detectors[i](name, attrs, &error) || error != 0) {
280 + if (error != 0) {
281 + return (error);
282 + }
283 + break;
282 284 }
283 - break;
284 - }
285 285 }
286 286
287 287 return (0);
288 288 }
289 289
290 290 /* return 1 if the slice descriptor is still valid, 0 if not. */
291 291 static int
292 292 desc_ok(descriptor_t *dp)
293 293 {
294 294 /* First verify the media name for removable media */
295 295 if (dp->p.disk->removable) {
296 - char mname[MAXPATHLEN];
296 + char mname[MAXPATHLEN];
297 297
298 - if (!media_read_name(dp->p.disk, mname, sizeof (mname))) {
299 - return (0);
300 - }
298 + if (!media_read_name(dp->p.disk, mname, sizeof (mname))) {
299 + return (0);
300 + }
301 301
302 - if (mname[0] == 0) {
303 - return (libdiskmgt_str_eq(dp->secondary_name, NULL));
304 - } else {
305 - return (libdiskmgt_str_eq(dp->secondary_name, mname));
306 - }
302 + if (mname[0] == 0) {
303 + return (libdiskmgt_str_eq(dp->secondary_name, NULL));
304 + } else {
305 + return (libdiskmgt_str_eq(dp->secondary_name, mname));
306 + }
307 307 }
308 308
309 309 /*
310 310 * We could verify the slice is still there, but other code down the
311 311 * line already does these checks (e.g. see get_attrs).
312 312 */
313 313
314 314 return (1);
315 315 }
316 316
317 317 /* convert dsk paths to rdsk paths */
318 318 static void
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
319 319 dsk2rdsk(char *dsk, char *rdsk, int size)
320 320 {
321 321 char *slashp;
322 322 size_t len;
323 323
324 324 (void) strlcpy(rdsk, dsk, size);
325 325
326 326 /* make sure there is enough room to add the r to dsk */
327 327 len = strlen(dsk);
328 328 if (len + 2 > size) {
329 - return;
329 + return;
330 330 }
331 331
332 332 if ((slashp = strstr(rdsk, "/dsk/")) == NULL) {
333 - /* not dsk, check for floppy */
334 - slashp = strstr(rdsk, "/diskette");
333 + /* not dsk, check for floppy */
334 + slashp = strstr(rdsk, "/diskette");
335 335 }
336 336
337 337 if (slashp != NULL) {
338 - char *endp;
338 + char *endp;
339 339
340 - endp = rdsk + len; /* point to terminating 0 */
341 - /* move the succeeding chars over by one */
342 - do {
343 - *(endp + 1) = *endp;
344 - endp--;
345 - } while (endp != slashp);
340 + endp = rdsk + len; /* point to terminating 0 */
341 + /* move the succeeding chars over by one */
342 + do {
343 + *(endp + 1) = *endp;
344 + endp--;
345 + } while (endp != slashp);
346 346
347 - *(endp + 1) = 'r';
347 + *(endp + 1) = 'r';
348 348 }
349 349 }
350 350
351 351 static int
352 352 get_attrs(descriptor_t *dp, int fd, nvlist_t *attrs)
353 353 {
354 354 struct dk_minfo minfo;
355 355 int status;
356 356 int data_format = FMT_UNKNOWN;
357 357 int snum = -1;
358 358 int error;
359 359 struct extvtoc vtoc;
360 360 struct dk_gpt *efip;
361 361 struct dk_cinfo dkinfo;
362 362 int cooked_fd;
363 363 struct stat buf;
364 364
365 365 if (fd < 0) {
366 - return (ENODEV);
366 + return (ENODEV);
367 367 }
368 368
369 369 /* First make sure media is inserted and spun up. */
370 370 if (!media_read_info(fd, &minfo)) {
371 - return (ENODEV);
371 + return (ENODEV);
372 372 }
373 373
374 374 if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
375 - data_format = FMT_VTOC;
375 + data_format = FMT_VTOC;
376 376 } else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
377 - data_format = FMT_EFI;
378 - if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
379 - efi_free(efip);
380 - return (ENOMEM);
381 - }
377 + data_format = FMT_EFI;
378 + if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
379 + efi_free(efip);
380 + return (ENOMEM);
381 + }
382 382 }
383 383
384 384 if (data_format == FMT_UNKNOWN) {
385 - return (ENODEV);
385 + return (ENODEV);
386 386 }
387 387
388 388 if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
389 - snum = dkinfo.dki_partition;
389 + snum = dkinfo.dki_partition;
390 390 }
391 391
392 392 /* check the slice */
393 393 if (data_format == FMT_VTOC) {
394 - if (snum < 0 || snum >= vtoc.v_nparts ||
395 - vtoc.v_part[snum].p_size == 0) {
396 - return (ENODEV);
397 - }
394 + if (snum < 0 || snum >= vtoc.v_nparts ||
395 + vtoc.v_part[snum].p_size == 0) {
396 + return (ENODEV);
397 + }
398 398 } else { /* data_format == FMT_EFI */
399 - if (snum < 0 || snum >= efip->efi_nparts ||
400 - efip->efi_parts[snum].p_size == 0) {
401 - efi_free(efip);
402 - return (ENODEV);
403 - }
399 + if (snum < 0 || snum >= efip->efi_nparts ||
400 + efip->efi_parts[snum].p_size == 0) {
401 + efi_free(efip);
402 + return (ENODEV);
403 + }
404 404 }
405 405
406 406 /* the slice exists */
407 407
408 408 if (nvlist_add_uint32(attrs, DM_INDEX, snum) != 0) {
409 - if (data_format == FMT_EFI) {
410 - efi_free(efip);
411 - }
412 - return (ENOMEM);
409 + if (data_format == FMT_EFI) {
410 + efi_free(efip);
411 + }
412 + return (ENOMEM);
413 413 }
414 414
415 415 if (data_format == FMT_VTOC) {
416 - if (nvlist_add_uint64(attrs, DM_START, vtoc.v_part[snum].p_start)
417 - != 0) {
418 - return (ENOMEM);
419 - }
416 + if (nvlist_add_uint64(attrs, DM_START,
417 + vtoc.v_part[snum].p_start) != 0) {
418 + return (ENOMEM);
419 + }
420 420
421 - if (nvlist_add_uint64(attrs, DM_SIZE, vtoc.v_part[snum].p_size)
422 - != 0) {
423 - return (ENOMEM);
424 - }
421 + if (nvlist_add_uint64(attrs, DM_SIZE,
422 + vtoc.v_part[snum].p_size) != 0) {
423 + return (ENOMEM);
424 + }
425 425
426 - if (nvlist_add_uint32(attrs, DM_TAG, vtoc.v_part[snum].p_tag)
427 - != 0) {
428 - return (ENOMEM);
429 - }
426 + if (nvlist_add_uint32(attrs, DM_TAG,
427 + vtoc.v_part[snum].p_tag) != 0) {
428 + return (ENOMEM);
429 + }
430 430
431 - if (nvlist_add_uint32(attrs, DM_FLAG, vtoc.v_part[snum].p_flag)
432 - != 0) {
433 - return (ENOMEM);
434 - }
435 -
431 + if (nvlist_add_uint32(attrs, DM_FLAG,
432 + vtoc.v_part[snum].p_flag) != 0) {
433 + return (ENOMEM);
434 + }
436 435 } else { /* data_format == FMT_EFI */
437 - if (nvlist_add_uint64(attrs, DM_START,
438 - efip->efi_parts[snum].p_start) != 0) {
439 - efi_free(efip);
440 - return (ENOMEM);
441 - }
436 + if (nvlist_add_uint64(attrs, DM_START,
437 + efip->efi_parts[snum].p_start) != 0) {
438 + efi_free(efip);
439 + return (ENOMEM);
440 + }
442 441
443 - if (nvlist_add_uint64(attrs, DM_SIZE, efip->efi_parts[snum].p_size)
444 - != 0) {
445 - efi_free(efip);
446 - return (ENOMEM);
447 - }
442 + if (nvlist_add_uint64(attrs, DM_SIZE,
443 + efip->efi_parts[snum].p_size) != 0) {
444 + efi_free(efip);
445 + return (ENOMEM);
446 + }
448 447
449 - if (efip->efi_parts[snum].p_name[0] != 0) {
450 - char label[EFI_PART_NAME_LEN + 1];
448 + if (efip->efi_parts[snum].p_name[0] != 0) {
449 + char label[EFI_PART_NAME_LEN + 1];
451 450
452 - (void) snprintf(label, sizeof (label), "%.*s",
453 - EFI_PART_NAME_LEN, efip->efi_parts[snum].p_name);
454 - if (nvlist_add_string(attrs, DM_EFI_NAME, label) != 0) {
455 - efi_free(efip);
456 - return (ENOMEM);
451 + (void) snprintf(label, sizeof (label), "%.*s",
452 + EFI_PART_NAME_LEN, efip->efi_parts[snum].p_name);
453 + if (nvlist_add_string(attrs, DM_EFI_NAME, label) != 0) {
454 + efi_free(efip);
455 + return (ENOMEM);
456 + }
457 457 }
458 - }
459 458 }
460 459
461 460 if (data_format == FMT_EFI) {
462 - efi_free(efip);
461 + efi_free(efip);
463 462 }
464 463
465 464 if (inuse_mnt(dp->name, attrs, &error)) {
466 - if (error != 0)
467 - return (error);
465 + if (error != 0)
466 + return (error);
468 467 }
469 468
470 469 if (fstat(fd, &buf) != -1) {
471 - if (nvlist_add_uint64(attrs, DM_DEVT, buf.st_rdev) != 0) {
472 - return (ENOMEM);
473 - }
470 + if (nvlist_add_uint64(attrs, DM_DEVT, buf.st_rdev) != 0) {
471 + return (ENOMEM);
472 + }
474 473 }
475 474
476 475 /*
477 476 * We need to open the cooked slice (not the raw one) to get the
478 477 * correct devid.
479 478 */
480 479 cooked_fd = open(dp->name, O_RDONLY|O_NDELAY);
481 480
482 481 if (cooked_fd >= 0) {
483 - int no_mem = 0;
484 - ddi_devid_t devid;
482 + int no_mem = 0;
483 + ddi_devid_t devid;
485 484
486 - if (devid_get(cooked_fd, &devid) == 0) {
487 - char *minor;
485 + if (devid_get(cooked_fd, &devid) == 0) {
486 + char *minor;
488 487
489 - if (devid_get_minor_name(cooked_fd, &minor) == 0) {
490 - char *devidstr;
488 + if (devid_get_minor_name(cooked_fd, &minor) == 0) {
489 + char *devidstr;
491 490
492 - if ((devidstr = devid_str_encode(devid, minor)) != 0) {
491 + devidstr = devid_str_encode(devid, minor);
492 + if (devidstr != NULL) {
493 493
494 - if (nvlist_add_string(attrs, DM_DEVICEID, devidstr)
495 - != 0) {
496 - no_mem = 1;
497 - }
494 + if (nvlist_add_string(attrs,
495 + DM_DEVICEID, devidstr) != 0) {
496 + no_mem = 1;
497 + }
498 498
499 - devid_str_free(devidstr);
500 - }
501 - devid_str_free(minor);
499 + devid_str_free(devidstr);
500 + }
501 + devid_str_free(minor);
502 + }
503 + devid_free(devid);
502 504 }
503 - devid_free(devid);
504 - }
505 - (void) close(cooked_fd);
505 + (void) close(cooked_fd);
506 506
507 - if (no_mem) {
508 - return (ENOMEM);
509 - }
507 + if (no_mem) {
508 + return (ENOMEM);
509 + }
510 510 }
511 511
512 512 return (0);
513 513 }
514 514
515 515 static descriptor_t **
516 516 get_fixed_assocs(descriptor_t *desc, int *errp)
517 517 {
518 518 int fd;
519 519 int status;
520 520 int data_format = FMT_UNKNOWN;
521 521 int cnt;
522 522 struct extvtoc vtoc;
523 523 struct dk_gpt *efip;
524 524 int pos;
525 525 char *media_name = NULL;
526 526 slice_t *devp;
527 527 descriptor_t **slices;
528 528
529 529 if ((fd = drive_open_disk(desc->p.disk, NULL, 0)) < 0) {
530 - *errp = ENODEV;
531 - return (NULL);
530 + *errp = ENODEV;
531 + return (NULL);
532 532 }
533 533
534 534 if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
535 - data_format = FMT_VTOC;
535 + data_format = FMT_VTOC;
536 536 } else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
537 - data_format = FMT_EFI;
537 + data_format = FMT_EFI;
538 538 } else {
539 - (void) close(fd);
540 - *errp = 0;
541 - return (libdiskmgt_empty_desc_array(errp));
539 + (void) close(fd);
540 + *errp = 0;
541 + return (libdiskmgt_empty_desc_array(errp));
542 542 }
543 543 (void) close(fd);
544 544
545 545 /* count the number of slices */
546 - for (cnt = 0, devp = desc->p.disk->aliases->devpaths; devp != NULL;
547 - devp = devp->next, cnt++);
546 + devp = desc->p.disk->aliases->devpaths;
547 + for (cnt = 0; devp != NULL; devp = devp->next)
548 + cnt++;
548 549
549 550 /* allocate the array for the descriptors */
550 551 slices = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *));
551 552 if (slices == NULL) {
552 - if (data_format == FMT_EFI) {
553 - efi_free(efip);
554 - }
555 - *errp = ENOMEM;
556 - return (NULL);
553 + if (data_format == FMT_EFI) {
554 + efi_free(efip);
555 + }
556 + *errp = ENOMEM;
557 + return (NULL);
557 558 }
558 559
559 560 /* get the media name from the descriptor */
560 561 if (desc->type == DM_MEDIA) {
561 - media_name = desc->name;
562 + media_name = desc->name;
562 563 } else {
563 - /* must be a DM_PARTITION */
564 - media_name = desc->secondary_name;
564 + /* must be a DM_PARTITION */
565 + media_name = desc->secondary_name;
565 566 }
566 567
567 568 pos = 0;
568 569 for (devp = desc->p.disk->aliases->devpaths; devp != NULL;
569 570 devp = devp->next) {
570 571
571 - int slice_num;
572 - char devpath[MAXPATHLEN];
572 + int slice_num;
573 + char devpath[MAXPATHLEN];
573 574
574 - slice_num = get_slice_num(devp);
575 - /* can't get slicenum, so no need to keep trying the drive */
576 - if (slice_num == -1) {
577 - break;
578 - }
575 + slice_num = get_slice_num(devp);
576 + /* can't get slicenum, so no need to keep trying the drive */
577 + if (slice_num == -1) {
578 + break;
579 + }
579 580
580 - if (data_format == FMT_VTOC) {
581 - if (slice_num >= vtoc.v_nparts ||
582 - vtoc.v_part[slice_num].p_size == 0) {
583 - continue;
581 + if (data_format == FMT_VTOC) {
582 + if (slice_num >= vtoc.v_nparts ||
583 + vtoc.v_part[slice_num].p_size == 0) {
584 + continue;
585 + }
586 + } else { /* data_format == FMT_EFI */
587 + if (slice_num >= efip->efi_nparts ||
588 + efip->efi_parts[slice_num].p_size == 0) {
589 + continue;
590 + }
584 591 }
585 - } else { /* data_format == FMT_EFI */
586 - if (slice_num >= efip->efi_nparts ||
587 - efip->efi_parts[slice_num].p_size == 0) {
588 - continue;
589 - }
590 - }
591 592
592 - slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
593 - slices[pos] = cache_get_desc(DM_SLICE, desc->p.disk, devpath,
594 - media_name, errp);
595 - if (*errp != 0) {
596 - cache_free_descriptors(slices);
597 - if (data_format == FMT_EFI) {
598 - efi_free(efip);
593 + slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
594 + slices[pos] = cache_get_desc(DM_SLICE, desc->p.disk, devpath,
595 + media_name, errp);
596 + if (*errp != 0) {
597 + cache_free_descriptors(slices);
598 + if (data_format == FMT_EFI) {
599 + efi_free(efip);
600 + }
601 + return (NULL);
599 602 }
600 - return (NULL);
601 - }
602 - pos++;
603 + pos++;
603 604 }
604 605 slices[pos] = NULL;
605 606
606 607 if (data_format == FMT_EFI) {
607 - efi_free(efip);
608 + efi_free(efip);
608 609 }
609 610
610 611 *errp = 0;
611 612 return (slices);
612 613 }
613 614
614 615 static int
615 616 get_slice_num(slice_t *devp)
616 617 {
617 618 /* check if we already determined the devpath slice number */
618 619 if (devp->slice_num == -1) {
619 - int fd;
620 + int fd;
620 621
621 - if ((fd = open(devp->devpath, O_RDONLY|O_NDELAY)) >= 0) {
622 - struct dk_cinfo dkinfo;
623 - if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
624 - devp->slice_num = dkinfo.dki_partition;
622 + if ((fd = open(devp->devpath, O_RDONLY|O_NDELAY)) >= 0) {
623 + struct dk_cinfo dkinfo;
624 + if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
625 + devp->slice_num = dkinfo.dki_partition;
626 + }
627 + (void) close(fd);
625 628 }
626 - (void) close(fd);
627 - }
628 629 }
629 630
630 631 return (devp->slice_num);
631 632 }
632 633
633 634 static int
634 635 make_fixed_descriptors(disk_t *dp)
635 636 {
636 637 int error = 0;
637 638 alias_t *ap;
638 639 slice_t *devp;
639 640 char mname[MAXPATHLEN];
640 641 int data_format = FMT_UNKNOWN;
641 642 struct extvtoc vtoc;
642 643 struct dk_gpt *efip;
643 644
644 645 /* Just check the first drive name. */
645 646 if ((ap = dp->aliases) == NULL) {
646 - return (0);
647 + return (0);
647 648 }
648 649
649 650 mname[0] = 0;
650 651 (void) media_read_name(dp, mname, sizeof (mname));
651 652
652 653 for (devp = ap->devpaths; devp != NULL; devp = devp->next) {
653 - int slice_num;
654 - char devpath[MAXPATHLEN];
654 + int slice_num;
655 + char devpath[MAXPATHLEN];
655 656
656 - slice_num = get_slice_num(devp);
657 - /* can't get slicenum, so no need to keep trying the drive */
658 - if (slice_num == -1) {
659 - break;
660 - }
657 + slice_num = get_slice_num(devp);
658 + /* can't get slicenum, so no need to keep trying the drive */
659 + if (slice_num == -1) {
660 + break;
661 + }
661 662
662 - if (data_format == FMT_UNKNOWN) {
663 - int fd;
664 - int status;
663 + if (data_format == FMT_UNKNOWN) {
664 + int fd;
665 + int status;
665 666
666 - if ((fd = drive_open_disk(dp, NULL, 0)) >= 0) {
667 - if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
668 - data_format = FMT_VTOC;
669 - } else if (status == VT_ENOTSUP &&
670 - efi_alloc_and_read(fd, &efip) >= 0) {
671 - data_format = FMT_EFI;
672 - }
673 - (void) close(fd);
667 + if ((fd = drive_open_disk(dp, NULL, 0)) >= 0) {
668 + if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
669 + data_format = FMT_VTOC;
670 + } else if (status == VT_ENOTSUP &&
671 + efi_alloc_and_read(fd, &efip) >= 0) {
672 + data_format = FMT_EFI;
673 + }
674 + (void) close(fd);
675 + }
674 676 }
675 - }
676 677
677 - /* can't get slice data, so no need to keep trying the drive */
678 - if (data_format == FMT_UNKNOWN) {
679 - break;
680 - }
678 + /* can't get slice data, so no need to keep trying the drive */
679 + if (data_format == FMT_UNKNOWN) {
680 + break;
681 + }
681 682
682 - if (data_format == FMT_VTOC) {
683 - if (slice_num >= vtoc.v_nparts ||
684 - vtoc.v_part[slice_num].p_size == 0) {
685 - continue;
683 + if (data_format == FMT_VTOC) {
684 + if (slice_num >= vtoc.v_nparts ||
685 + vtoc.v_part[slice_num].p_size == 0) {
686 + continue;
687 + }
688 + } else { /* data_format == FMT_EFI */
689 + if (slice_num >= efip->efi_nparts ||
690 + efip->efi_parts[slice_num].p_size == 0) {
691 + continue;
692 + }
686 693 }
687 - } else { /* data_format == FMT_EFI */
688 - if (slice_num >= efip->efi_nparts ||
689 - efip->efi_parts[slice_num].p_size == 0) {
690 - continue;
691 - }
692 - }
693 694
694 - slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
695 - cache_load_desc(DM_SLICE, dp, devpath, mname, &error);
696 - if (error != 0) {
697 - break;
698 - }
695 + slice_rdsk2dsk(devp->devpath, devpath, sizeof (devpath));
696 + cache_load_desc(DM_SLICE, dp, devpath, mname, &error);
697 + if (error != 0) {
698 + break;
699 + }
699 700 }
700 701
701 702 if (data_format == FMT_EFI) {
702 - efi_free(efip);
703 + efi_free(efip);
703 704 }
704 705
705 706 return (error);
706 707 }
707 708
708 709 /*
709 710 * Just look for the name on the devpaths we have cached. Return 1 if we
710 711 * find the name and the size of that slice is non-zero.
711 712 */
712 713 static int
713 714 match_fixed_name(disk_t *diskp, char *name, int *errp)
714 715 {
715 716 slice_t *dp = NULL;
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
716 717 alias_t *ap;
717 718 int slice_num;
718 719 int fd;
719 720 int status;
720 721 int data_format = FMT_UNKNOWN;
721 722 struct extvtoc vtoc;
722 723 struct dk_gpt *efip;
723 724
724 725 ap = diskp->aliases;
725 726 while (ap != NULL) {
726 - slice_t *devp;
727 + slice_t *devp;
727 728
728 - devp = ap->devpaths;
729 - while (devp != NULL) {
730 - char path[MAXPATHLEN];
729 + devp = ap->devpaths;
730 + while (devp != NULL) {
731 + char path[MAXPATHLEN];
731 732
732 - slice_rdsk2dsk(devp->devpath, path, sizeof (path));
733 - if (libdiskmgt_str_eq(path, name)) {
734 - /* found it */
735 - dp = devp;
736 - break;
733 + slice_rdsk2dsk(devp->devpath, path, sizeof (path));
734 + if (libdiskmgt_str_eq(path, name)) {
735 + /* found it */
736 + dp = devp;
737 + break;
738 + }
739 +
740 + devp = devp->next;
737 741 }
738 742
739 - devp = devp->next;
740 - }
743 + if (dp != NULL) {
744 + break;
745 + }
741 746
742 - if (dp != NULL) {
743 - break;
744 - }
745 -
746 - ap = ap->next;
747 + ap = ap->next;
747 748 }
748 749
749 750 if (dp == NULL) {
750 - *errp = 0;
751 - return (0);
751 + *errp = 0;
752 + return (0);
752 753 }
753 754
754 755 /*
755 756 * If we found a match on the name we now have to check that this
756 757 * slice really exists (non-0 size).
757 758 */
758 759
759 760 slice_num = get_slice_num(dp);
760 761 /* can't get slicenum, so no slice */
761 762 if (slice_num == -1) {
762 - *errp = ENODEV;
763 - return (1);
763 + *errp = ENODEV;
764 + return (1);
764 765 }
765 766
766 767 if ((fd = drive_open_disk(diskp, NULL, 0)) < 0) {
767 - *errp = ENODEV;
768 - return (1);
768 + *errp = ENODEV;
769 + return (1);
769 770 }
770 771
771 772 if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
772 - data_format = FMT_VTOC;
773 - } else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
774 - data_format = FMT_EFI;
773 + data_format = FMT_VTOC;
774 + } else if (status == VT_ENOTSUP) {
775 + status = efi_alloc_and_read(fd, &efip);
776 + if (status >= 0) {
777 + data_format = FMT_EFI;
778 + } else if (status == VT_ERROR && errno == ENOTTY) {
779 + *errp = 0;
780 + return (1);
781 + }
775 782 } else {
776 - (void) close(fd);
777 - *errp = ENODEV;
778 - return (1);
783 + (void) close(fd);
784 + *errp = ENODEV;
785 + return (1);
779 786 }
780 787 (void) close(fd);
781 788
782 789 if (data_format == FMT_VTOC) {
783 - if (slice_num < vtoc.v_nparts &&
784 - vtoc.v_part[slice_num].p_size > 0) {
785 - *errp = 0;
786 - return (1);
787 - }
790 + if (slice_num < vtoc.v_nparts &&
791 + vtoc.v_part[slice_num].p_size > 0) {
792 + *errp = 0;
793 + return (1);
794 + }
788 795 } else { /* data_format == FMT_EFI */
789 - if (slice_num < efip->efi_nparts &&
790 - efip->efi_parts[slice_num].p_size > 0) {
796 + if (slice_num < efip->efi_nparts &&
797 + efip->efi_parts[slice_num].p_size > 0) {
798 + efi_free(efip);
799 + *errp = 0;
800 + return (1);
801 + }
791 802 efi_free(efip);
792 - *errp = 0;
793 - return (1);
794 - }
795 - efi_free(efip);
796 803 }
797 804
798 805 *errp = ENODEV;
799 806 return (1);
800 807 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX