1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <sys/fm/protocol.h>
30 #include <sys/types.h>
31 #include <sys/systeminfo.h>
32 #include <fm/fmd_snmp.h>
33 #include <fm/libtopo.h>
34 #include <net-snmp/net-snmp-config.h>
35 #include <net-snmp/net-snmp-includes.h>
36 #include <net-snmp/agent/net-snmp-agent-includes.h>
37 #include <libnvpair.h>
38 #include <limits.h>
39 #include <strings.h>
40 #include <stddef.h>
41 #include <unistd.h>
42 #include <dlfcn.h>
43 #include <errno.h>
44
45 #define SCHEMEDIR_BASE "/usr/lib/fm/fmd/schemes"
46
47 #if defined(__sparcv9)
48 #define DEFAULTSCHEMEDIR SCHEMEDIR_BASE "/sparcv9"
49 #elif defined(__amd64)
50 #define DEFAULTSCHEMEDIR SCHEMEDIR_BASE "/amd64"
51 #else
52 #define DEFAULTSCHEMEDIR SCHEMEDIR_BASE
53 #endif
54
55 typedef struct fmd_scheme_ops {
56 int (*sop_init)(void);
57 void (*sop_fini)(void);
58 ssize_t (*sop_nvl2str)(nvlist_t *, char *, size_t);
59 } fmd_scheme_ops_t;
60
61 typedef struct fmd_scheme_opd {
62 const char *opd_name; /* symbol name of scheme function */
63 size_t opd_off; /* offset within fmd_scheme_ops_t */
64 } fmd_scheme_opd_t;
65
66 typedef struct fmd_scheme {
67 struct fmd_scheme *sch_next; /* next scheme on list of schemes */
68 char *sch_name; /* name of this scheme (fmri prefix) */
69 void *sch_dlp; /* libdl(3DL) shared library handle */
70 int sch_err; /* if negative entry, errno to return */
71 fmd_scheme_ops_t sch_ops; /* scheme function pointers */
72 } fmd_scheme_t;
73
74 static fmd_scheme_t *sch_list; /* list of cached schemes */
75 static char *g_root; /* fmd root dir */
76 static struct topo_hdl *g_thp;
77
78 static long
79 fmd_scheme_notsup(void)
80 {
81 errno = ENOTSUP;
82 return (-1);
83 }
84
85 static int
86 fmd_scheme_nop(void)
87 {
88 return (0);
89 }
90
91 /*
92 * Default values for the scheme ops. If a scheme function is not defined in
93 * the module, then this operation is implemented using the default function.
94 */
95 static const fmd_scheme_ops_t _fmd_scheme_default_ops = {
96 (int (*)())fmd_scheme_nop, /* sop_init */
97 (void (*)())fmd_scheme_nop, /* sop_fini */
98 (ssize_t (*)())fmd_scheme_notsup, /* sop_nvl2str */
99 };
100
101 /*
102 * Scheme ops descriptions. These names and offsets are used by the function
103 * fmd_scheme_rtld_init(), defined below, to load up a fmd_scheme_ops_t.
104 */
105 static const fmd_scheme_opd_t _fmd_scheme_ops[] = {
106 { "fmd_fmri_init", offsetof(fmd_scheme_ops_t, sop_init) },
107 { "fmd_fmri_fini", offsetof(fmd_scheme_ops_t, sop_fini) },
108 { "fmd_fmri_nvl2str", offsetof(fmd_scheme_ops_t, sop_nvl2str) },
109 { NULL, 0 }
110 };
111
112 static fmd_scheme_t *
113 fmd_scheme_create(const char *name)
114 {
115 fmd_scheme_t *sp;
116
117 if ((sp = malloc(sizeof (fmd_scheme_t))) == NULL ||
118 (sp->sch_name = strdup(name)) == NULL) {
119 free(sp);
120 return (NULL);
121 }
122
123 sp->sch_next = sch_list;
124 sp->sch_dlp = NULL;
125 sp->sch_err = 0;
126 sp->sch_ops = _fmd_scheme_default_ops;
127
128 sch_list = sp;
129 return (sp);
130 }
131
132 static int
133 fmd_scheme_rtld_init(fmd_scheme_t *sp)
134 {
135 const fmd_scheme_opd_t *opd;
136 void *p;
137
138 for (opd = _fmd_scheme_ops; opd->opd_name != NULL; opd++) {
139 if ((p = dlsym(sp->sch_dlp, opd->opd_name)) != NULL)
140 *(void **)((uintptr_t)&sp->sch_ops + opd->opd_off) = p;
141 }
142
143 return (sp->sch_ops.sop_init());
144 }
145
146 static fmd_scheme_t *
147 fmd_scheme_lookup(const char *dir, const char *name)
148 {
149 fmd_scheme_t *sp;
150 char path[PATH_MAX];
151
152 for (sp = sch_list; sp != NULL; sp = sp->sch_next) {
153 if (strcmp(name, sp->sch_name) == 0)
154 return (sp);
155 }
156
157 if ((sp = fmd_scheme_create(name)) == NULL)
158 return (NULL); /* errno is set for us */
159
160 (void) snprintf(path, sizeof (path), "%s%s/%s.so",
161 g_root ? g_root : "", dir, name);
162
163 if (access(path, F_OK) != 0) {
164 sp->sch_err = errno;
165 return (sp);
166 }
167
168 if ((sp->sch_dlp = dlopen(path, RTLD_LOCAL | RTLD_NOW | RTLD_PARENT)) ==
169 NULL) {
170 sp->sch_err = ELIBACC;
171 return (sp);
172 }
173
174 if (fmd_scheme_rtld_init(sp) != 0) {
175 sp->sch_err = errno;
176 (void) dlclose(sp->sch_dlp);
177 sp->sch_dlp = NULL;
178 }
179
180 return (sp);
181 }
182
183 char *
184 sunFm_nvl2str(nvlist_t *nvl)
185 {
186 fmd_scheme_t *sp;
187 char c, *name, *s = NULL;
188 ssize_t len;
189
190 if (nvlist_lookup_string(nvl, FM_FMRI_SCHEME, &name) != 0) {
191 DEBUGMSGTL((MODNAME_STR, "fmri does not contain required "
192 "'%s' nvpair\n", FM_FMRI_SCHEME));
193 return (NULL);
194 }
195
196 if ((sp = fmd_scheme_lookup(DEFAULTSCHEMEDIR, name)) == NULL ||
197 sp->sch_dlp == NULL || sp->sch_err != 0) {
198 const char *msg =
199 sp->sch_err == ELIBACC ? dlerror() : strerror(sp->sch_err);
200 DEBUGMSGTL((MODNAME_STR, "cannot init '%s' scheme library to "
201 "format fmri: %s\n", name, msg ? msg : "unknown error"));
202 return (NULL);
203 }
204
205 if ((len = sp->sch_ops.sop_nvl2str(nvl, &c, sizeof (c))) == -1 ||
206 (s = malloc(len + 1)) == NULL ||
207 sp->sch_ops.sop_nvl2str(nvl, s, len + 1) == -1) {
208 DEBUGMSGTL((MODNAME_STR, "cannot format fmri using scheme '%s'",
209 name));
210 free(s);
211 return (NULL);
212 }
213
214 return (s);
215 }
216
217 void *
218 fmd_fmri_alloc(size_t size)
219 {
220 return (malloc(size));
221 }
222
223 void *
224 fmd_fmri_zalloc(size_t size)
225 {
226 void *data;
227
228 if ((data = malloc(size)) != NULL)
229 bzero(data, size);
230
231 return (data);
232 }
233
234 /*ARGSUSED*/
235 void
236 fmd_fmri_free(void *data, size_t size)
237 {
238 free(data);
239 }
240
241 int
242 fmd_fmri_error(int err)
243 {
244 errno = err;
245 return (-1);
246 }
247
248 char *
249 fmd_fmri_strescape(const char *s)
250 {
251 return (strdup(s));
252 }
253
254 char *
255 fmd_fmri_strdup(const char *s)
256 {
257 return (strdup(s));
258 }
259
260 void
261 fmd_fmri_strfree(char *s)
262 {
263 free(s);
264 }
265
266 const char *
267 fmd_fmri_get_rootdir(void)
268 {
269 return (g_root ? g_root : "");
270 }
271
272 const char *
273 fmd_fmri_get_platform(void)
274 {
275 static char platform[MAXNAMELEN];
276
277 if (platform[0] == '\0')
278 (void) sysinfo(SI_PLATFORM, platform, sizeof (platform));
279
280 return (platform);
281 }
282
283 uint64_t
284 fmd_fmri_get_drgen(void)
285 {
286 return (0);
287 }
288
289 int
290 fmd_fmri_set_errno(int err)
291 {
292 errno = err;
293 return (-1);
294 }
295
296 /*ARGSUSED*/
297 void
298 fmd_fmri_warn(const char *format, ...)
299 {
300 }
301
302 struct topo_hdl *
303 fmd_fmri_topo_hold(int version)
304 {
305 int err;
306
307 if (version != TOPO_VERSION)
308 return (NULL);
309
310 if (g_thp == NULL) {
311 if ((g_thp = topo_open(TOPO_VERSION, "/", &err)) == NULL) {
312 DEBUGMSGTL((MODNAME_STR, "topo_open failed: %s\n",
313 topo_strerror(err)));
314 return (NULL);
315 }
316 }
317
318 return (g_thp);
319 }
320
321 /*ARGSUSED*/
322 void
323 fmd_fmri_topo_rele(struct topo_hdl *thp)
324 {
325 /* nothing to do */
326 }