]>
git.proxmox.com Git - mirror_zfs.git/blob - lib/libzfs/libzfs_fru.c
78f2f9c371aea15d59ec5cfbf31154a852a3d704
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
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.
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]
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
37 #if defined(HAVE_LIBTOPO)
39 #include <fm/libtopo.h>
40 #include <sys/fm/protocol.h>
41 #include <sys/systeminfo.h>
43 #include "libzfs_impl.h"
46 * This file is responsible for determining the relationship between I/O
47 * devices paths and physical locations. In the world of MPxIO and external
48 * enclosures, the device path is not synonymous with the physical location.
49 * If you remove a drive and insert it into a different slot, it will end up
50 * with the same path under MPxIO. If you recable storage enclosures, the
51 * device paths may change. All of this makes it difficult to implement the
52 * 'autoreplace' property, which is supposed to automatically manage disk
53 * replacement based on physical slot.
55 * In order to work around these limitations, we have a per-vdev FRU property
56 * that is the libtopo path (minus disk-specific authority information) to the
57 * physical location of the device on the system. This is an optional
58 * property, and is only needed when using the 'autoreplace' property or when
59 * generating FMA faults against vdevs.
63 * Because the FMA packages depend on ZFS, we have to dlopen() libtopo in case
64 * it is not present. We only need this once per library instance, so it is
65 * not part of the libzfs handle.
67 static void *_topo_dlhandle
;
68 static topo_hdl_t
*(*_topo_open
)(int, const char *, int *);
69 static void (*_topo_close
)(topo_hdl_t
*);
70 static char *(*_topo_snap_hold
)(topo_hdl_t
*, const char *, int *);
71 static void (*_topo_snap_release
)(topo_hdl_t
*);
72 static topo_walk_t
*(*_topo_walk_init
)(topo_hdl_t
*, const char *,
73 topo_walk_cb_t
, void *, int *);
74 static int (*_topo_walk_step
)(topo_walk_t
*, int);
75 static void (*_topo_walk_fini
)(topo_walk_t
*);
76 static void (*_topo_hdl_strfree
)(topo_hdl_t
*, char *);
77 static char *(*_topo_node_name
)(tnode_t
*);
78 static int (*_topo_prop_get_string
)(tnode_t
*, const char *, const char *,
80 static int (*_topo_node_fru
)(tnode_t
*, nvlist_t
**, nvlist_t
*, int *);
81 static int (*_topo_fmri_nvl2str
)(topo_hdl_t
*, nvlist_t
*, char **, int *);
82 static int (*_topo_fmri_strcmp_noauth
)(topo_hdl_t
*, const char *,
85 #define ZFS_FRU_HASH_SIZE 257
88 fru_strhash(const char *key
)
93 for (p
= key
; *p
!= '\0'; p
++) {
96 if ((g
= (h
& 0xf0000000)) != 0) {
102 return (h
% ZFS_FRU_HASH_SIZE
);
106 libzfs_fru_gather(topo_hdl_t
*thp
, tnode_t
*tn
, void *arg
)
108 libzfs_handle_t
*hdl
= arg
;
110 char *devpath
, *frustr
;
116 * If this is the chassis node, and we don't yet have the system
117 * chassis ID, then fill in this value now.
119 if (hdl
->libzfs_chassis_id
[0] == '\0' &&
120 strcmp(_topo_node_name(tn
), "chassis") == 0) {
121 if (_topo_prop_get_string(tn
, FM_FMRI_AUTHORITY
,
122 FM_FMRI_AUTH_CHASSIS
, &devpath
, &err
) == 0)
123 (void) strlcpy(hdl
->libzfs_chassis_id
, devpath
,
124 sizeof (hdl
->libzfs_chassis_id
));
128 * Skip non-disk nodes.
130 if (strcmp(_topo_node_name(tn
), "disk") != 0)
131 return (TOPO_WALK_NEXT
);
134 * Get the devfs path and FRU.
136 if (_topo_prop_get_string(tn
, "io", "devfs-path", &devpath
, &err
) != 0)
137 return (TOPO_WALK_NEXT
);
139 if (libzfs_fru_lookup(hdl
, devpath
) != NULL
) {
140 _topo_hdl_strfree(thp
, devpath
);
141 return (TOPO_WALK_NEXT
);
144 if (_topo_node_fru(tn
, &fru
, NULL
, &err
) != 0) {
145 _topo_hdl_strfree(thp
, devpath
);
146 return (TOPO_WALK_NEXT
);
150 * Convert the FRU into a string.
152 if (_topo_fmri_nvl2str(thp
, fru
, &frustr
, &err
) != 0) {
154 _topo_hdl_strfree(thp
, devpath
);
155 return (TOPO_WALK_NEXT
);
161 * Finally, we have a FRU string and device path. Add it to the hash.
163 if ((frup
= calloc(sizeof (libzfs_fru_t
), 1)) == NULL
) {
164 _topo_hdl_strfree(thp
, devpath
);
165 _topo_hdl_strfree(thp
, frustr
);
166 return (TOPO_WALK_NEXT
);
169 if ((frup
->zf_device
= strdup(devpath
)) == NULL
||
170 (frup
->zf_fru
= strdup(frustr
)) == NULL
) {
171 free(frup
->zf_device
);
173 _topo_hdl_strfree(thp
, devpath
);
174 _topo_hdl_strfree(thp
, frustr
);
175 return (TOPO_WALK_NEXT
);
178 _topo_hdl_strfree(thp
, devpath
);
179 _topo_hdl_strfree(thp
, frustr
);
181 idx
= fru_strhash(frup
->zf_device
);
182 frup
->zf_chain
= hdl
->libzfs_fru_hash
[idx
];
183 hdl
->libzfs_fru_hash
[idx
] = frup
;
184 frup
->zf_next
= hdl
->libzfs_fru_list
;
185 hdl
->libzfs_fru_list
= frup
;
187 return (TOPO_WALK_NEXT
);
191 * Called during initialization to setup the dynamic libtopo connection.
193 #pragma init(libzfs_init_fru)
195 libzfs_init_fru(void)
197 char path
[MAXPATHLEN
];
201 if (sysinfo(SI_ARCHITECTURE_64
, isa
, sizeof (isa
)) < 0)
206 (void) snprintf(path
, sizeof (path
),
207 "/usr/lib/fm/%s/libtopo.so", isa
);
209 if ((_topo_dlhandle
= dlopen(path
, RTLD_LAZY
)) == NULL
)
212 _topo_open
= (topo_hdl_t
*(*)())
213 dlsym(_topo_dlhandle
, "topo_open");
214 _topo_close
= (void (*)())
215 dlsym(_topo_dlhandle
, "topo_close");
216 _topo_snap_hold
= (char *(*)())
217 dlsym(_topo_dlhandle
, "topo_snap_hold");
218 _topo_snap_release
= (void (*)())
219 dlsym(_topo_dlhandle
, "topo_snap_release");
220 _topo_walk_init
= (topo_walk_t
*(*)())
221 dlsym(_topo_dlhandle
, "topo_walk_init");
222 _topo_walk_step
= (int (*)())
223 dlsym(_topo_dlhandle
, "topo_walk_step");
224 _topo_walk_fini
= (void (*)())
225 dlsym(_topo_dlhandle
, "topo_walk_fini");
226 _topo_hdl_strfree
= (void (*)())
227 dlsym(_topo_dlhandle
, "topo_hdl_strfree");
228 _topo_node_name
= (char *(*)())
229 dlsym(_topo_dlhandle
, "topo_node_name");
230 _topo_prop_get_string
= (int (*)())
231 dlsym(_topo_dlhandle
, "topo_prop_get_string");
232 _topo_node_fru
= (int (*)())
233 dlsym(_topo_dlhandle
, "topo_node_fru");
234 _topo_fmri_nvl2str
= (int (*)())
235 dlsym(_topo_dlhandle
, "topo_fmri_nvl2str");
236 _topo_fmri_strcmp_noauth
= (int (*)())
237 dlsym(_topo_dlhandle
, "topo_fmri_strcmp_noauth");
239 if (_topo_open
== NULL
|| _topo_close
== NULL
||
240 _topo_snap_hold
== NULL
|| _topo_snap_release
== NULL
||
241 _topo_walk_init
== NULL
|| _topo_walk_step
== NULL
||
242 _topo_walk_fini
== NULL
|| _topo_hdl_strfree
== NULL
||
243 _topo_node_name
== NULL
|| _topo_prop_get_string
== NULL
||
244 _topo_node_fru
== NULL
|| _topo_fmri_nvl2str
== NULL
||
245 _topo_fmri_strcmp_noauth
== NULL
) {
246 (void) dlclose(_topo_dlhandle
);
247 _topo_dlhandle
= NULL
;
252 * Refresh the mappings from device path -> FMRI. We do this by walking the
253 * hc topology looking for disk nodes, and recording the io/devfs-path and FRU.
254 * Note that we strip out the disk-specific authority information (serial,
255 * part, revision, etc) so that we are left with only the identifying
256 * characteristics of the slot (hc path and chassis-id).
259 libzfs_fru_refresh(libzfs_handle_t
*hdl
)
266 if (_topo_dlhandle
== NULL
)
270 * Clear the FRU hash and initialize our basic structures.
272 libzfs_fru_clear(hdl
, B_FALSE
);
274 if ((hdl
->libzfs_topo_hdl
= _topo_open(TOPO_VERSION
,
275 NULL
, &err
)) == NULL
)
278 thp
= hdl
->libzfs_topo_hdl
;
280 if ((uuid
= _topo_snap_hold(thp
, NULL
, &err
)) == NULL
)
283 _topo_hdl_strfree(thp
, uuid
);
285 if (hdl
->libzfs_fru_hash
== NULL
&&
286 (hdl
->libzfs_fru_hash
=
287 calloc(ZFS_FRU_HASH_SIZE
* sizeof (void *), 1)) == NULL
)
291 * We now have a topo snapshot, so iterate over the hc topology looking
292 * for disks to add to the hash.
294 twp
= _topo_walk_init(thp
, FM_FMRI_SCHEME_HC
,
295 libzfs_fru_gather
, hdl
, &err
);
297 (void) _topo_walk_step(twp
, TOPO_WALK_CHILD
);
298 _topo_walk_fini(twp
);
303 * Given a devfs path, return the FRU for the device, if known. This will
304 * automatically call libzfs_fru_refresh() if it hasn't already been called by
305 * the consumer. The string returned is valid until the next call to
306 * libzfs_fru_refresh().
309 libzfs_fru_lookup(libzfs_handle_t
*hdl
, const char *devpath
)
311 size_t idx
= fru_strhash(devpath
);
314 if (hdl
->libzfs_fru_hash
== NULL
)
315 libzfs_fru_refresh(hdl
);
317 if (hdl
->libzfs_fru_hash
== NULL
)
320 for (frup
= hdl
->libzfs_fru_hash
[idx
]; frup
!= NULL
;
321 frup
= frup
->zf_chain
) {
322 if (strcmp(devpath
, frup
->zf_device
) == 0)
323 return (frup
->zf_fru
);
330 * Given a fru path, return the device path. This will automatically call
331 * libzfs_fru_refresh() if it hasn't already been called by the consumer. The
332 * string returned is valid until the next call to libzfs_fru_refresh().
335 libzfs_fru_devpath(libzfs_handle_t
*hdl
, const char *fru
)
340 if (hdl
->libzfs_fru_hash
== NULL
)
341 libzfs_fru_refresh(hdl
);
343 if (hdl
->libzfs_fru_hash
== NULL
)
346 for (idx
= 0; idx
< ZFS_FRU_HASH_SIZE
; idx
++) {
347 for (frup
= hdl
->libzfs_fru_hash
[idx
]; frup
!= NULL
;
348 frup
= frup
->zf_next
) {
349 if (_topo_fmri_strcmp_noauth(hdl
->libzfs_topo_hdl
,
351 return (frup
->zf_device
);
359 * Change the stored FRU for the given vdev.
362 zpool_fru_set(zpool_handle_t
*zhp
, uint64_t vdev_guid
, const char *fru
)
364 zfs_cmd_t zc
= { 0 };
366 (void) strncpy(zc
.zc_name
, zhp
->zpool_name
, sizeof (zc
.zc_name
));
367 (void) strncpy(zc
.zc_value
, fru
, sizeof (zc
.zc_value
));
368 zc
.zc_guid
= vdev_guid
;
370 if (zfs_ioctl(zhp
->zpool_hdl
, ZFS_IOC_VDEV_SETFRU
, &zc
) != 0)
371 return (zpool_standard_error_fmt(zhp
->zpool_hdl
, errno
,
372 dgettext(TEXT_DOMAIN
, "cannot set FRU")));
378 * Compare to two FRUs, ignoring any authority information.
381 libzfs_fru_compare(libzfs_handle_t
*hdl
, const char *a
, const char *b
)
383 if (hdl
->libzfs_fru_hash
== NULL
)
384 libzfs_fru_refresh(hdl
);
386 if (hdl
->libzfs_fru_hash
== NULL
)
387 return (strcmp(a
, b
) == 0);
389 return (_topo_fmri_strcmp_noauth(hdl
->libzfs_topo_hdl
, a
, b
));
393 * This special function checks to see whether the FRU indicates it's supposed
394 * to be in the system chassis, but the chassis-id doesn't match. This can
395 * happen in a clustered case, where both head nodes have the same logical
396 * disk, but opening the device on the other head node is meaningless.
399 libzfs_fru_notself(libzfs_handle_t
*hdl
, const char *fru
)
401 const char *chassisid
;
404 if (hdl
->libzfs_fru_hash
== NULL
)
405 libzfs_fru_refresh(hdl
);
407 if (hdl
->libzfs_chassis_id
[0] == '\0')
410 if (strstr(fru
, "/chassis=0/") == NULL
)
413 if ((chassisid
= strstr(fru
, ":chassis-id=")) == NULL
)
417 len
= strlen(hdl
->libzfs_chassis_id
);
418 if (strncmp(chassisid
, hdl
->libzfs_chassis_id
, len
) == 0 &&
419 (chassisid
[len
] == '/' || chassisid
[len
] == ':'))
426 * Clear memory associated with the FRU hash.
429 libzfs_fru_clear(libzfs_handle_t
*hdl
, boolean_t final
)
433 while ((frup
= hdl
->libzfs_fru_list
) != NULL
) {
434 hdl
->libzfs_fru_list
= frup
->zf_next
;
435 free(frup
->zf_device
);
440 hdl
->libzfs_fru_list
= NULL
;
442 if (hdl
->libzfs_topo_hdl
!= NULL
) {
443 _topo_snap_release(hdl
->libzfs_topo_hdl
);
444 _topo_close(hdl
->libzfs_topo_hdl
);
445 hdl
->libzfs_topo_hdl
= NULL
;
449 free(hdl
->libzfs_fru_hash
);
450 } else if (hdl
->libzfs_fru_hash
!= NULL
) {
451 bzero(hdl
->libzfs_fru_hash
,
452 ZFS_FRU_HASH_SIZE
* sizeof (void *));
456 #else /* HAVE_LIBTOPO */
459 * Clear memory associated with the FRU hash.
462 libzfs_fru_clear(libzfs_handle_t
*hdl
, boolean_t final
)
467 #endif /* HAVE_LIBTOPO */