xref: /illumos-gate/usr/src/lib/libsmbios/common/smb_lib.c (revision 3299f39fdcbdab4be7a9c70daa3873f2b78a398d)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 #include <sys/types.h>
29 #include <sys/smbios_impl.h>
30 #include <sys/sysmacros.h>
31 #include <sys/stat.h>
32 #include <sys/mman.h>
33 
34 #include <alloca.h>
35 #include <limits.h>
36 #include <unistd.h>
37 #include <strings.h>
38 #include <stdlib.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <libdevinfo.h>
42 
43 #pragma init(smb_init)
44 static void
45 smb_init(void)
46 {
47 	_smb_debug = getenv("SMB_DEBUG") != NULL;
48 }
49 
50 static smbios_hdl_t *
51 smb_fileopen(int fd, int version, int flags, int *errp)
52 {
53 	smbios_entry_t *ep = alloca(SMB_ENTRY_MAXLEN);
54 	smbios_entry_point_t ep_type;
55 	smbios_hdl_t *shp = NULL;
56 	uint32_t smbe_stlen;
57 	off64_t smbe_staddr;
58 	ssize_t n, elen;
59 	void *stbuf;
60 
61 	if ((n = pread64(fd, ep, sizeof (*ep), 0)) != sizeof (*ep))
62 		return (smb_open_error(shp, errp, n < 0 ? errno : ESMB_NOHDR));
63 
64 	if (strncmp(ep->ep21.smbe_eanchor, SMB_ENTRY_EANCHOR,
65 	    SMB_ENTRY_EANCHORLEN) == 0) {
66 		ep_type = SMBIOS_ENTRY_POINT_21;
67 		elen = MIN(ep->ep21.smbe_elen, SMB_ENTRY_MAXLEN);
68 	} else if (strncmp(ep->ep30.smbe_eanchor, SMB3_ENTRY_EANCHOR,
69 	    SMB3_ENTRY_EANCHORLEN) == 0) {
70 		ep_type = SMBIOS_ENTRY_POINT_30;
71 		elen = MIN(ep->ep30.smbe_elen, SMB_ENTRY_MAXLEN);
72 	} else {
73 		return (smb_open_error(shp, errp, ESMB_HEADER));
74 	}
75 
76 	if ((n = pread64(fd, ep, elen, 0)) != elen)
77 		return (smb_open_error(shp, errp, n < 0 ? errno : ESMB_NOHDR));
78 
79 	if (ep_type == SMBIOS_ENTRY_POINT_21) {
80 		smbe_stlen = ep->ep21.smbe_stlen;
81 		smbe_staddr = (off64_t)ep->ep21.smbe_staddr;
82 	} else {
83 		smbe_stlen = ep->ep30.smbe_stlen;
84 		smbe_staddr = (off64_t)ep->ep30.smbe_staddr;
85 	}
86 	stbuf = smb_alloc(smbe_stlen);
87 
88 	if (stbuf == NULL)
89 		return (smb_open_error(shp, errp, ESMB_NOMEM));
90 
91 	if ((n = pread64(fd, stbuf, smbe_stlen, smbe_staddr)) != smbe_stlen) {
92 		smb_free(stbuf, smbe_stlen);
93 		return (smb_open_error(shp, errp, n < 0 ? errno : ESMB_NOSTAB));
94 	}
95 
96 	shp = smbios_bufopen(ep, stbuf, smbe_stlen, version, flags, errp);
97 
98 	if (shp != NULL)
99 		shp->sh_flags |= SMB_FL_BUFALLOC;
100 	else
101 		smb_free(stbuf, smbe_stlen);
102 
103 	return (shp);
104 }
105 
106 static smbios_hdl_t *
107 smb_biosopen(int fd, int version, int flags, int *errp)
108 {
109 	smbios_entry_t *ep = alloca(SMB_ENTRY_MAXLEN);
110 	smbios_entry_point_t ep_type;
111 	smbios_hdl_t *shp = NULL;
112 	size_t elen, pgsize, pgmask, pgoff;
113 	void *stbuf, *bios, *p, *q;
114 	di_node_t root;
115 	int64_t *val64;
116 	uint32_t smbe_stlen;
117 	off64_t smbe_staddr;
118 
119 	bios = MAP_FAILED;
120 	if ((root = di_init("/", DINFOPROP)) != DI_NODE_NIL) {
121 		if (di_prop_lookup_int64(DDI_DEV_T_ANY, root,
122 		    "smbios-address", &val64) == 1) {
123 			bios = mmap(NULL, SMB_RANGE_LIMIT - SMB_RANGE_START + 1,
124 			    PROT_READ, MAP_SHARED, fd, (off_t)*val64);
125 		}
126 		di_fini(root);
127 	}
128 	if (bios == MAP_FAILED) {
129 		bios = mmap(NULL, SMB_RANGE_LIMIT - SMB_RANGE_START + 1,
130 		    PROT_READ, MAP_SHARED, fd, (uint32_t)SMB_RANGE_START);
131 	}
132 
133 	if (bios == MAP_FAILED)
134 		return (smb_open_error(shp, errp, ESMB_MAPDEV));
135 
136 	q = (void *)((uintptr_t)bios + SMB_RANGE_LIMIT - SMB_RANGE_START + 1);
137 
138 	for (p = bios; p < q; p = (void *)((uintptr_t)p + SMB_SCAN_STEP)) {
139 		if (strncmp(p, SMB_ENTRY_EANCHOR, SMB_ENTRY_EANCHORLEN) == 0) {
140 			ep_type = SMBIOS_ENTRY_POINT_21;
141 			elen = MIN(ep->ep21.smbe_elen, SMB_ENTRY_MAXLEN);
142 			break;
143 		}
144 		if (strncmp(p, SMB3_ENTRY_EANCHOR,
145 		    SMB3_ENTRY_EANCHORLEN) == 0) {
146 			ep_type = SMBIOS_ENTRY_POINT_30;
147 			elen = MIN(ep->ep30.smbe_elen, SMB_ENTRY_MAXLEN);
148 			break;
149 		}
150 	}
151 
152 	if (p >= q) {
153 		(void) munmap(bios, SMB_RANGE_LIMIT - SMB_RANGE_START + 1);
154 		return (smb_open_error(NULL, errp, ESMB_NOTFOUND));
155 	}
156 
157 	bcopy(p, ep, sizeof (smbios_entry_t));
158 	bcopy(p, ep, elen);
159 	(void) munmap(bios, SMB_RANGE_LIMIT - SMB_RANGE_START + 1);
160 
161 	switch (ep_type) {
162 	case SMBIOS_ENTRY_POINT_21:
163 		smbe_stlen = ep->ep21.smbe_stlen;
164 		smbe_staddr = ep->ep21.smbe_staddr;
165 		break;
166 	case SMBIOS_ENTRY_POINT_30:
167 		smbe_stlen = ep->ep30.smbe_stlen;
168 		smbe_staddr = ep->ep30.smbe_staddr;
169 		break;
170 	default:
171 		return (smb_open_error(NULL, errp, ESMB_VERSION));
172 	}
173 
174 	pgsize = getpagesize();
175 	pgmask = ~(pgsize - 1);
176 	pgoff = smbe_staddr & ~pgmask;
177 
178 	bios = mmap(NULL, smbe_stlen + pgoff,
179 	    PROT_READ, MAP_SHARED, fd, smbe_staddr & pgmask);
180 
181 	if (bios == MAP_FAILED)
182 		return (smb_open_error(shp, errp, ESMB_MAPDEV));
183 
184 	if ((stbuf = smb_alloc(smbe_stlen)) == NULL) {
185 		(void) munmap(bios, smbe_stlen + pgoff);
186 		return (smb_open_error(shp, errp, ESMB_NOMEM));
187 	}
188 
189 	bcopy((char *)bios + pgoff, stbuf, smbe_stlen);
190 	(void) munmap(bios, smbe_stlen + pgoff);
191 	shp = smbios_bufopen(ep, stbuf, smbe_stlen, version, flags, errp);
192 
193 	if (shp != NULL)
194 		shp->sh_flags |= SMB_FL_BUFALLOC;
195 	else
196 		smb_free(stbuf, smbe_stlen);
197 
198 	return (shp);
199 }
200 
201 smbios_hdl_t *
202 smbios_fdopen(int fd, int version, int flags, int *errp)
203 {
204 	struct stat64 st1, st2;
205 
206 	if (stat64(SMB_BIOS_DEVICE, &st1) == 0 && fstat64(fd, &st2) == 0 &&
207 	    S_ISCHR(st2.st_mode) && st1.st_rdev == st2.st_rdev)
208 		return (smb_biosopen(fd, version, flags, errp));
209 	else
210 		return (smb_fileopen(fd, version, flags, errp));
211 }
212 
213 smbios_hdl_t *
214 smbios_open(const char *file, int version, int flags, int *errp)
215 {
216 	smbios_hdl_t *shp;
217 	int fd;
218 
219 	if ((fd = open64(file ? file : SMB_SMBIOS_DEVICE, O_RDONLY)) == -1) {
220 		if ((errno == ENOENT || errno == ENXIO) &&
221 		    (file == NULL || strcmp(file, SMB_SMBIOS_DEVICE) == 0))
222 			errno = ESMB_NOTFOUND;
223 		return (smb_open_error(NULL, errp, errno));
224 	}
225 
226 	shp = smbios_fdopen(fd, version, flags, errp);
227 	(void) close(fd);
228 	return (shp);
229 }
230 
231 static int
232 smbios_xwrite(smbios_hdl_t *shp, int fd, const void *buf, size_t buflen)
233 {
234 	ssize_t resid = buflen;
235 	ssize_t len;
236 
237 	while (resid != 0) {
238 		if ((len = write(fd, buf, resid)) <= 0)
239 			return (smb_set_errno(shp, errno));
240 		resid -= len;
241 		buf = (uchar_t *)buf + len;
242 	}
243 
244 	return (0);
245 }
246 
247 int
248 smbios_write(smbios_hdl_t *shp, int fd)
249 {
250 	smbios_entry_t ep;
251 	off64_t off = lseek64(fd, 0, SEEK_CUR) + P2ROUNDUP(sizeof (ep), 16);
252 
253 	if (off > UINT32_MAX)
254 		return (smb_set_errno(shp, EOVERFLOW));
255 
256 	bcopy(&shp->sh_ent, &ep, sizeof (ep));
257 	if (shp->sh_ent_type == SMBIOS_ENTRY_POINT_21)
258 		ep.ep21.smbe_staddr = (uint32_t)off;
259 	else if (shp->sh_ent_type == SMBIOS_ENTRY_POINT_30)
260 		ep.ep30.smbe_staddr = (uint64_t)off;
261 	else
262 		return (-1);
263 
264 	smbios_checksum(shp, &ep);
265 
266 	if (smbios_xwrite(shp, fd, &ep, sizeof (ep)) == -1 ||
267 	    lseek64(fd, off, SEEK_SET) != off ||
268 	    smbios_xwrite(shp, fd, shp->sh_buf, shp->sh_buflen) == -1)
269 		return (-1);
270 
271 	return (0);
272 }
273