xref: /illumos-gate/usr/src/lib/libzpool/common/kernel.c (revision 95173954d2b811ceb583a9012c3b16e1d0dd6438)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
2244cb6abcSbmc  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <assert.h>
29c9431fa1Sahl #include <fcntl.h>
30fa9e4066Sahrens #include <poll.h>
31fa9e4066Sahrens #include <stdio.h>
32fa9e4066Sahrens #include <stdlib.h>
33c9431fa1Sahl #include <string.h>
34c9431fa1Sahl #include <zlib.h>
35fa9e4066Sahrens #include <sys/spa.h>
36c9431fa1Sahl #include <sys/stat.h>
37fa9e4066Sahrens #include <sys/processor.h>
38c9431fa1Sahl #include <sys/zfs_context.h>
39c9431fa1Sahl #include <sys/zmod.h>
40*95173954Sek #include <sys/utsname.h>
415ad82045Snd 
42fa9e4066Sahrens /*
43fa9e4066Sahrens  * Emulation of kernel services in userland.
44fa9e4066Sahrens  */
45fa9e4066Sahrens 
46fa9e4066Sahrens uint64_t physmem;
47fa9e4066Sahrens vnode_t *rootdir = (vnode_t *)0xabcd1234;
48*95173954Sek char hw_serial[11];
49*95173954Sek 
50*95173954Sek struct utsname utsname = {
51*95173954Sek 	"userland", "libzpool", "1", "1", "na"
52*95173954Sek };
53fa9e4066Sahrens 
54fa9e4066Sahrens /*
55fa9e4066Sahrens  * =========================================================================
56fa9e4066Sahrens  * threads
57fa9e4066Sahrens  * =========================================================================
58fa9e4066Sahrens  */
59fa9e4066Sahrens /*ARGSUSED*/
60fa9e4066Sahrens kthread_t *
61fa9e4066Sahrens zk_thread_create(void (*func)(), void *arg)
62fa9e4066Sahrens {
63fa9e4066Sahrens 	thread_t tid;
64fa9e4066Sahrens 
65fa9e4066Sahrens 	VERIFY(thr_create(0, 0, (void *(*)(void *))func, arg, THR_DETACHED,
66fa9e4066Sahrens 	    &tid) == 0);
67fa9e4066Sahrens 
68fa9e4066Sahrens 	return ((void *)(uintptr_t)tid);
69fa9e4066Sahrens }
70fa9e4066Sahrens 
7144cb6abcSbmc /*
7244cb6abcSbmc  * =========================================================================
7344cb6abcSbmc  * kstats
7444cb6abcSbmc  * =========================================================================
7544cb6abcSbmc  */
7644cb6abcSbmc /*ARGSUSED*/
7744cb6abcSbmc kstat_t *
7844cb6abcSbmc kstat_create(char *module, int instance, char *name, char *class,
7944cb6abcSbmc     uchar_t type, ulong_t ndata, uchar_t ks_flag)
8044cb6abcSbmc {
8144cb6abcSbmc 	return (NULL);
8244cb6abcSbmc }
8344cb6abcSbmc 
8444cb6abcSbmc /*ARGSUSED*/
8544cb6abcSbmc void
8644cb6abcSbmc kstat_install(kstat_t *ksp)
8744cb6abcSbmc {}
8844cb6abcSbmc 
8944cb6abcSbmc /*ARGSUSED*/
9044cb6abcSbmc void
9144cb6abcSbmc kstat_delete(kstat_t *ksp)
9244cb6abcSbmc {}
9344cb6abcSbmc 
94fa9e4066Sahrens /*
95fa9e4066Sahrens  * =========================================================================
96fa9e4066Sahrens  * mutexes
97fa9e4066Sahrens  * =========================================================================
98fa9e4066Sahrens  */
99fa9e4066Sahrens void
100fa9e4066Sahrens zmutex_init(kmutex_t *mp)
101fa9e4066Sahrens {
102fa9e4066Sahrens 	mp->m_owner = NULL;
103fa9e4066Sahrens 	(void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL);
104fa9e4066Sahrens }
105fa9e4066Sahrens 
106fa9e4066Sahrens void
107fa9e4066Sahrens zmutex_destroy(kmutex_t *mp)
108fa9e4066Sahrens {
109fa9e4066Sahrens 	ASSERT(mp->m_owner == NULL);
110fa9e4066Sahrens 	(void) _mutex_destroy(&(mp)->m_lock);
111fa9e4066Sahrens 	mp->m_owner = (void *)-1UL;
112fa9e4066Sahrens }
113fa9e4066Sahrens 
114fa9e4066Sahrens void
115fa9e4066Sahrens mutex_enter(kmutex_t *mp)
116fa9e4066Sahrens {
117fa9e4066Sahrens 	ASSERT(mp->m_owner != (void *)-1UL);
118fa9e4066Sahrens 	ASSERT(mp->m_owner != curthread);
1195ad82045Snd 	VERIFY(mutex_lock(&mp->m_lock) == 0);
120fa9e4066Sahrens 	ASSERT(mp->m_owner == NULL);
121fa9e4066Sahrens 	mp->m_owner = curthread;
122fa9e4066Sahrens }
123fa9e4066Sahrens 
124fa9e4066Sahrens int
125fa9e4066Sahrens mutex_tryenter(kmutex_t *mp)
126fa9e4066Sahrens {
127fa9e4066Sahrens 	ASSERT(mp->m_owner != (void *)-1UL);
128fa9e4066Sahrens 	if (0 == mutex_trylock(&mp->m_lock)) {
129fa9e4066Sahrens 		ASSERT(mp->m_owner == NULL);
130fa9e4066Sahrens 		mp->m_owner = curthread;
131fa9e4066Sahrens 		return (1);
132fa9e4066Sahrens 	} else {
133fa9e4066Sahrens 		return (0);
134fa9e4066Sahrens 	}
135fa9e4066Sahrens }
136fa9e4066Sahrens 
137fa9e4066Sahrens void
138fa9e4066Sahrens mutex_exit(kmutex_t *mp)
139fa9e4066Sahrens {
140fa9e4066Sahrens 	ASSERT(mutex_owner(mp) == curthread);
141fa9e4066Sahrens 	mp->m_owner = NULL;
1425ad82045Snd 	VERIFY(mutex_unlock(&mp->m_lock) == 0);
143fa9e4066Sahrens }
144fa9e4066Sahrens 
145fa9e4066Sahrens void *
146fa9e4066Sahrens mutex_owner(kmutex_t *mp)
147fa9e4066Sahrens {
148fa9e4066Sahrens 	return (mp->m_owner);
149fa9e4066Sahrens }
150fa9e4066Sahrens 
151fa9e4066Sahrens /*
152fa9e4066Sahrens  * =========================================================================
153fa9e4066Sahrens  * rwlocks
154fa9e4066Sahrens  * =========================================================================
155fa9e4066Sahrens  */
156fa9e4066Sahrens /*ARGSUSED*/
157fa9e4066Sahrens void
158fa9e4066Sahrens rw_init(krwlock_t *rwlp, char *name, int type, void *arg)
159fa9e4066Sahrens {
160fa9e4066Sahrens 	rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL);
161fa9e4066Sahrens 	rwlp->rw_owner = NULL;
162fa9e4066Sahrens }
163fa9e4066Sahrens 
164fa9e4066Sahrens void
165fa9e4066Sahrens rw_destroy(krwlock_t *rwlp)
166fa9e4066Sahrens {
167fa9e4066Sahrens 	rwlock_destroy(&rwlp->rw_lock);
168fa9e4066Sahrens 	rwlp->rw_owner = (void *)-1UL;
169fa9e4066Sahrens }
170fa9e4066Sahrens 
171fa9e4066Sahrens void
172fa9e4066Sahrens rw_enter(krwlock_t *rwlp, krw_t rw)
173fa9e4066Sahrens {
174fa9e4066Sahrens 	ASSERT(!RW_LOCK_HELD(rwlp));
175fa9e4066Sahrens 	ASSERT(rwlp->rw_owner != (void *)-1UL);
176fa9e4066Sahrens 	ASSERT(rwlp->rw_owner != curthread);
177fa9e4066Sahrens 
178fa9e4066Sahrens 	if (rw == RW_READER)
179fa9e4066Sahrens 		(void) rw_rdlock(&rwlp->rw_lock);
180fa9e4066Sahrens 	else
181fa9e4066Sahrens 		(void) rw_wrlock(&rwlp->rw_lock);
182fa9e4066Sahrens 
183fa9e4066Sahrens 	rwlp->rw_owner = curthread;
184fa9e4066Sahrens }
185fa9e4066Sahrens 
186fa9e4066Sahrens void
187fa9e4066Sahrens rw_exit(krwlock_t *rwlp)
188fa9e4066Sahrens {
189fa9e4066Sahrens 	ASSERT(rwlp->rw_owner != (void *)-1UL);
190fa9e4066Sahrens 
191fa9e4066Sahrens 	rwlp->rw_owner = NULL;
192fa9e4066Sahrens 	(void) rw_unlock(&rwlp->rw_lock);
193fa9e4066Sahrens }
194fa9e4066Sahrens 
195fa9e4066Sahrens int
196fa9e4066Sahrens rw_tryenter(krwlock_t *rwlp, krw_t rw)
197fa9e4066Sahrens {
198fa9e4066Sahrens 	int rv;
199fa9e4066Sahrens 
200fa9e4066Sahrens 	ASSERT(rwlp->rw_owner != (void *)-1UL);
201fa9e4066Sahrens 
202fa9e4066Sahrens 	if (rw == RW_READER)
203fa9e4066Sahrens 		rv = rw_tryrdlock(&rwlp->rw_lock);
204fa9e4066Sahrens 	else
205fa9e4066Sahrens 		rv = rw_trywrlock(&rwlp->rw_lock);
206fa9e4066Sahrens 
207fa9e4066Sahrens 	if (rv == 0) {
208fa9e4066Sahrens 		rwlp->rw_owner = curthread;
209fa9e4066Sahrens 		return (1);
210fa9e4066Sahrens 	}
211fa9e4066Sahrens 
212fa9e4066Sahrens 	return (0);
213fa9e4066Sahrens }
214fa9e4066Sahrens 
215fa9e4066Sahrens /*ARGSUSED*/
216fa9e4066Sahrens int
217fa9e4066Sahrens rw_tryupgrade(krwlock_t *rwlp)
218fa9e4066Sahrens {
219fa9e4066Sahrens 	ASSERT(rwlp->rw_owner != (void *)-1UL);
220fa9e4066Sahrens 
221fa9e4066Sahrens 	return (0);
222fa9e4066Sahrens }
223fa9e4066Sahrens 
224fa9e4066Sahrens /*
225fa9e4066Sahrens  * =========================================================================
226fa9e4066Sahrens  * condition variables
227fa9e4066Sahrens  * =========================================================================
228fa9e4066Sahrens  */
229fa9e4066Sahrens /*ARGSUSED*/
230fa9e4066Sahrens void
231fa9e4066Sahrens cv_init(kcondvar_t *cv, char *name, int type, void *arg)
232fa9e4066Sahrens {
2335ad82045Snd 	VERIFY(cond_init(cv, type, NULL) == 0);
234fa9e4066Sahrens }
235fa9e4066Sahrens 
236fa9e4066Sahrens void
237fa9e4066Sahrens cv_destroy(kcondvar_t *cv)
238fa9e4066Sahrens {
2395ad82045Snd 	VERIFY(cond_destroy(cv) == 0);
240fa9e4066Sahrens }
241fa9e4066Sahrens 
242fa9e4066Sahrens void
243fa9e4066Sahrens cv_wait(kcondvar_t *cv, kmutex_t *mp)
244fa9e4066Sahrens {
245fa9e4066Sahrens 	ASSERT(mutex_owner(mp) == curthread);
246fa9e4066Sahrens 	mp->m_owner = NULL;
2475ad82045Snd 	int ret = cond_wait(cv, &mp->m_lock);
2485ad82045Snd 	VERIFY(ret == 0 || ret == EINTR);
249fa9e4066Sahrens 	mp->m_owner = curthread;
250fa9e4066Sahrens }
251fa9e4066Sahrens 
252fa9e4066Sahrens clock_t
253fa9e4066Sahrens cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime)
254fa9e4066Sahrens {
255fa9e4066Sahrens 	int error;
256fa9e4066Sahrens 	timestruc_t ts;
257fa9e4066Sahrens 	clock_t delta;
258fa9e4066Sahrens 
259fa9e4066Sahrens top:
260fa9e4066Sahrens 	delta = abstime - lbolt;
261fa9e4066Sahrens 	if (delta <= 0)
262fa9e4066Sahrens 		return (-1);
263fa9e4066Sahrens 
264fa9e4066Sahrens 	ts.tv_sec = delta / hz;
265fa9e4066Sahrens 	ts.tv_nsec = (delta % hz) * (NANOSEC / hz);
266fa9e4066Sahrens 
267fa9e4066Sahrens 	ASSERT(mutex_owner(mp) == curthread);
268fa9e4066Sahrens 	mp->m_owner = NULL;
269fa9e4066Sahrens 	error = cond_reltimedwait(cv, &mp->m_lock, &ts);
270fa9e4066Sahrens 	mp->m_owner = curthread;
271fa9e4066Sahrens 
272fa9e4066Sahrens 	if (error == ETIME)
273fa9e4066Sahrens 		return (-1);
274fa9e4066Sahrens 
275fa9e4066Sahrens 	if (error == EINTR)
276fa9e4066Sahrens 		goto top;
277fa9e4066Sahrens 
278fa9e4066Sahrens 	ASSERT(error == 0);
279fa9e4066Sahrens 
280fa9e4066Sahrens 	return (1);
281fa9e4066Sahrens }
282fa9e4066Sahrens 
283fa9e4066Sahrens void
284fa9e4066Sahrens cv_signal(kcondvar_t *cv)
285fa9e4066Sahrens {
2865ad82045Snd 	VERIFY(cond_signal(cv) == 0);
287fa9e4066Sahrens }
288fa9e4066Sahrens 
289fa9e4066Sahrens void
290fa9e4066Sahrens cv_broadcast(kcondvar_t *cv)
291fa9e4066Sahrens {
2925ad82045Snd 	VERIFY(cond_broadcast(cv) == 0);
293fa9e4066Sahrens }
294fa9e4066Sahrens 
295fa9e4066Sahrens /*
296fa9e4066Sahrens  * =========================================================================
297fa9e4066Sahrens  * vnode operations
298fa9e4066Sahrens  * =========================================================================
299fa9e4066Sahrens  */
300fa9e4066Sahrens /*
301fa9e4066Sahrens  * Note: for the xxxat() versions of these functions, we assume that the
302fa9e4066Sahrens  * starting vp is always rootdir (which is true for spa_directory.c, the only
303fa9e4066Sahrens  * ZFS consumer of these interfaces).  We assert this is true, and then emulate
304fa9e4066Sahrens  * them by adding '/' in front of the path.
305fa9e4066Sahrens  */
306fa9e4066Sahrens 
307fa9e4066Sahrens /*ARGSUSED*/
308fa9e4066Sahrens int
309fa9e4066Sahrens vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3)
310fa9e4066Sahrens {
311fa9e4066Sahrens 	int fd;
312fa9e4066Sahrens 	vnode_t *vp;
313fa9e4066Sahrens 	int old_umask;
314fa9e4066Sahrens 	char realpath[MAXPATHLEN];
315fa9e4066Sahrens 	struct stat64 st;
316fa9e4066Sahrens 
317fa9e4066Sahrens 	/*
318fa9e4066Sahrens 	 * If we're accessing a real disk from userland, we need to use
319fa9e4066Sahrens 	 * the character interface to avoid caching.  This is particularly
320fa9e4066Sahrens 	 * important if we're trying to look at a real in-kernel storage
321fa9e4066Sahrens 	 * pool from userland, e.g. via zdb, because otherwise we won't
322fa9e4066Sahrens 	 * see the changes occurring under the segmap cache.
323fa9e4066Sahrens 	 * On the other hand, the stupid character device returns zero
324fa9e4066Sahrens 	 * for its size.  So -- gag -- we open the block device to get
325fa9e4066Sahrens 	 * its size, and remember it for subsequent VOP_GETATTR().
326fa9e4066Sahrens 	 */
327fa9e4066Sahrens 	if (strncmp(path, "/dev/", 5) == 0) {
328fa9e4066Sahrens 		char *dsk;
329fa9e4066Sahrens 		fd = open64(path, O_RDONLY);
330fa9e4066Sahrens 		if (fd == -1)
331fa9e4066Sahrens 			return (errno);
332fa9e4066Sahrens 		if (fstat64(fd, &st) == -1) {
333fa9e4066Sahrens 			close(fd);
334fa9e4066Sahrens 			return (errno);
335fa9e4066Sahrens 		}
336fa9e4066Sahrens 		close(fd);
337fa9e4066Sahrens 		(void) sprintf(realpath, "%s", path);
338fa9e4066Sahrens 		dsk = strstr(path, "/dsk/");
339fa9e4066Sahrens 		if (dsk != NULL)
340fa9e4066Sahrens 			(void) sprintf(realpath + (dsk - path) + 1, "r%s",
341fa9e4066Sahrens 			    dsk + 1);
342fa9e4066Sahrens 	} else {
343fa9e4066Sahrens 		(void) sprintf(realpath, "%s", path);
344fa9e4066Sahrens 		if (!(flags & FCREAT) && stat64(realpath, &st) == -1)
345fa9e4066Sahrens 			return (errno);
346fa9e4066Sahrens 	}
347fa9e4066Sahrens 
348fa9e4066Sahrens 	if (flags & FCREAT)
349fa9e4066Sahrens 		old_umask = umask(0);
350fa9e4066Sahrens 
351fa9e4066Sahrens 	/*
352fa9e4066Sahrens 	 * The construct 'flags - FREAD' conveniently maps combinations of
353fa9e4066Sahrens 	 * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.
354fa9e4066Sahrens 	 */
355fa9e4066Sahrens 	fd = open64(realpath, flags - FREAD, mode);
356fa9e4066Sahrens 
357fa9e4066Sahrens 	if (flags & FCREAT)
358fa9e4066Sahrens 		(void) umask(old_umask);
359fa9e4066Sahrens 
360fa9e4066Sahrens 	if (fd == -1)
361fa9e4066Sahrens 		return (errno);
362fa9e4066Sahrens 
363fa9e4066Sahrens 	if (fstat64(fd, &st) == -1) {
364fa9e4066Sahrens 		close(fd);
365fa9e4066Sahrens 		return (errno);
366fa9e4066Sahrens 	}
367fa9e4066Sahrens 
368fa9e4066Sahrens 	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
369fa9e4066Sahrens 
370fa9e4066Sahrens 	*vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);
371fa9e4066Sahrens 
372fa9e4066Sahrens 	vp->v_fd = fd;
373fa9e4066Sahrens 	vp->v_size = st.st_size;
374fa9e4066Sahrens 	vp->v_path = spa_strdup(path);
375fa9e4066Sahrens 
376fa9e4066Sahrens 	return (0);
377fa9e4066Sahrens }
378fa9e4066Sahrens 
379fa9e4066Sahrens int
380fa9e4066Sahrens vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,
381fa9e4066Sahrens     int x3, vnode_t *startvp)
382fa9e4066Sahrens {
383fa9e4066Sahrens 	char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);
384fa9e4066Sahrens 	int ret;
385fa9e4066Sahrens 
386fa9e4066Sahrens 	ASSERT(startvp == rootdir);
387fa9e4066Sahrens 	(void) sprintf(realpath, "/%s", path);
388fa9e4066Sahrens 
389fa9e4066Sahrens 	ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);
390fa9e4066Sahrens 
391fa9e4066Sahrens 	umem_free(realpath, strlen(path) + 2);
392fa9e4066Sahrens 
393fa9e4066Sahrens 	return (ret);
394fa9e4066Sahrens }
395fa9e4066Sahrens 
396fa9e4066Sahrens /*ARGSUSED*/
397fa9e4066Sahrens int
398fa9e4066Sahrens vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len, offset_t offset,
399fa9e4066Sahrens 	int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp)
400fa9e4066Sahrens {
401fa9e4066Sahrens 	ssize_t iolen, split;
402fa9e4066Sahrens 
403fa9e4066Sahrens 	if (uio == UIO_READ) {
404fa9e4066Sahrens 		iolen = pread64(vp->v_fd, addr, len, offset);
405fa9e4066Sahrens 	} else {
406fa9e4066Sahrens 		/*
407fa9e4066Sahrens 		 * To simulate partial disk writes, we split writes into two
408fa9e4066Sahrens 		 * system calls so that the process can be killed in between.
409fa9e4066Sahrens 		 */
410fa9e4066Sahrens 		split = (len > 0 ? rand() % len : 0);
411fa9e4066Sahrens 		iolen = pwrite64(vp->v_fd, addr, split, offset);
412fa9e4066Sahrens 		iolen += pwrite64(vp->v_fd, (char *)addr + split,
413fa9e4066Sahrens 		    len - split, offset + split);
414fa9e4066Sahrens 	}
415fa9e4066Sahrens 
416fa9e4066Sahrens 	if (iolen == -1)
417fa9e4066Sahrens 		return (errno);
418fa9e4066Sahrens 	if (residp)
419fa9e4066Sahrens 		*residp = len - iolen;
420fa9e4066Sahrens 	else if (iolen != len)
421fa9e4066Sahrens 		return (EIO);
422fa9e4066Sahrens 	return (0);
423fa9e4066Sahrens }
424fa9e4066Sahrens 
425fa9e4066Sahrens void
426fa9e4066Sahrens vn_close(vnode_t *vp)
427fa9e4066Sahrens {
428fa9e4066Sahrens 	close(vp->v_fd);
429fa9e4066Sahrens 	spa_strfree(vp->v_path);
430fa9e4066Sahrens 	umem_free(vp, sizeof (vnode_t));
431fa9e4066Sahrens }
432fa9e4066Sahrens 
433fa9e4066Sahrens #ifdef ZFS_DEBUG
434fa9e4066Sahrens 
435fa9e4066Sahrens /*
436fa9e4066Sahrens  * =========================================================================
437fa9e4066Sahrens  * Figure out which debugging statements to print
438fa9e4066Sahrens  * =========================================================================
439fa9e4066Sahrens  */
440fa9e4066Sahrens 
441fa9e4066Sahrens static char *dprintf_string;
442fa9e4066Sahrens static int dprintf_print_all;
443fa9e4066Sahrens 
444fa9e4066Sahrens int
445fa9e4066Sahrens dprintf_find_string(const char *string)
446fa9e4066Sahrens {
447fa9e4066Sahrens 	char *tmp_str = dprintf_string;
448fa9e4066Sahrens 	int len = strlen(string);
449fa9e4066Sahrens 
450fa9e4066Sahrens 	/*
451fa9e4066Sahrens 	 * Find out if this is a string we want to print.
452fa9e4066Sahrens 	 * String format: file1.c,function_name1,file2.c,file3.c
453fa9e4066Sahrens 	 */
454fa9e4066Sahrens 
455fa9e4066Sahrens 	while (tmp_str != NULL) {
456fa9e4066Sahrens 		if (strncmp(tmp_str, string, len) == 0 &&
457fa9e4066Sahrens 		    (tmp_str[len] == ',' || tmp_str[len] == '\0'))
458fa9e4066Sahrens 			return (1);
459fa9e4066Sahrens 		tmp_str = strchr(tmp_str, ',');
460fa9e4066Sahrens 		if (tmp_str != NULL)
461fa9e4066Sahrens 			tmp_str++; /* Get rid of , */
462fa9e4066Sahrens 	}
463fa9e4066Sahrens 	return (0);
464fa9e4066Sahrens }
465fa9e4066Sahrens 
466fa9e4066Sahrens void
467fa9e4066Sahrens dprintf_setup(int *argc, char **argv)
468fa9e4066Sahrens {
469fa9e4066Sahrens 	int i, j;
470fa9e4066Sahrens 
471fa9e4066Sahrens 	/*
472fa9e4066Sahrens 	 * Debugging can be specified two ways: by setting the
473fa9e4066Sahrens 	 * environment variable ZFS_DEBUG, or by including a
474fa9e4066Sahrens 	 * "debug=..."  argument on the command line.  The command
475fa9e4066Sahrens 	 * line setting overrides the environment variable.
476fa9e4066Sahrens 	 */
477fa9e4066Sahrens 
478fa9e4066Sahrens 	for (i = 1; i < *argc; i++) {
479fa9e4066Sahrens 		int len = strlen("debug=");
480fa9e4066Sahrens 		/* First look for a command line argument */
481fa9e4066Sahrens 		if (strncmp("debug=", argv[i], len) == 0) {
482fa9e4066Sahrens 			dprintf_string = argv[i] + len;
483fa9e4066Sahrens 			/* Remove from args */
484fa9e4066Sahrens 			for (j = i; j < *argc; j++)
485fa9e4066Sahrens 				argv[j] = argv[j+1];
486fa9e4066Sahrens 			argv[j] = NULL;
487fa9e4066Sahrens 			(*argc)--;
488fa9e4066Sahrens 		}
489fa9e4066Sahrens 	}
490fa9e4066Sahrens 
491fa9e4066Sahrens 	if (dprintf_string == NULL) {
492fa9e4066Sahrens 		/* Look for ZFS_DEBUG environment variable */
493fa9e4066Sahrens 		dprintf_string = getenv("ZFS_DEBUG");
494fa9e4066Sahrens 	}
495fa9e4066Sahrens 
496fa9e4066Sahrens 	/*
497fa9e4066Sahrens 	 * Are we just turning on all debugging?
498fa9e4066Sahrens 	 */
499fa9e4066Sahrens 	if (dprintf_find_string("on"))
500fa9e4066Sahrens 		dprintf_print_all = 1;
501fa9e4066Sahrens }
502fa9e4066Sahrens 
503fa9e4066Sahrens /*
504fa9e4066Sahrens  * =========================================================================
505fa9e4066Sahrens  * debug printfs
506fa9e4066Sahrens  * =========================================================================
507fa9e4066Sahrens  */
508fa9e4066Sahrens void
509fa9e4066Sahrens __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
510fa9e4066Sahrens {
511fa9e4066Sahrens 	const char *newfile;
512fa9e4066Sahrens 	va_list adx;
513fa9e4066Sahrens 
514fa9e4066Sahrens 	/*
515fa9e4066Sahrens 	 * Get rid of annoying "../common/" prefix to filename.
516fa9e4066Sahrens 	 */
517fa9e4066Sahrens 	newfile = strrchr(file, '/');
518fa9e4066Sahrens 	if (newfile != NULL) {
519fa9e4066Sahrens 		newfile = newfile + 1; /* Get rid of leading / */
520fa9e4066Sahrens 	} else {
521fa9e4066Sahrens 		newfile = file;
522fa9e4066Sahrens 	}
523fa9e4066Sahrens 
524fa9e4066Sahrens 	if (dprintf_print_all ||
525fa9e4066Sahrens 	    dprintf_find_string(newfile) ||
526fa9e4066Sahrens 	    dprintf_find_string(func)) {
527fa9e4066Sahrens 		/* Print out just the function name if requested */
528fa9e4066Sahrens 		flockfile(stdout);
529fa9e4066Sahrens 		if (dprintf_find_string("pid"))
530fa9e4066Sahrens 			(void) printf("%d ", getpid());
531fa9e4066Sahrens 		if (dprintf_find_string("tid"))
532fa9e4066Sahrens 			(void) printf("%u ", thr_self());
533fa9e4066Sahrens 		if (dprintf_find_string("cpu"))
534fa9e4066Sahrens 			(void) printf("%u ", getcpuid());
535fa9e4066Sahrens 		if (dprintf_find_string("time"))
536fa9e4066Sahrens 			(void) printf("%llu ", gethrtime());
537fa9e4066Sahrens 		if (dprintf_find_string("long"))
538fa9e4066Sahrens 			(void) printf("%s, line %d: ", newfile, line);
539fa9e4066Sahrens 		(void) printf("%s: ", func);
540fa9e4066Sahrens 		va_start(adx, fmt);
541fa9e4066Sahrens 		(void) vprintf(fmt, adx);
542fa9e4066Sahrens 		va_end(adx);
543fa9e4066Sahrens 		funlockfile(stdout);
544fa9e4066Sahrens 	}
545fa9e4066Sahrens }
546fa9e4066Sahrens 
547fa9e4066Sahrens #endif /* ZFS_DEBUG */
548fa9e4066Sahrens 
549fa9e4066Sahrens /*
550fa9e4066Sahrens  * =========================================================================
551fa9e4066Sahrens  * cmn_err() and panic()
552fa9e4066Sahrens  * =========================================================================
553fa9e4066Sahrens  */
554fa9e4066Sahrens static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" };
555fa9e4066Sahrens static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" };
556fa9e4066Sahrens 
557fa9e4066Sahrens void
558fa9e4066Sahrens vpanic(const char *fmt, va_list adx)
559fa9e4066Sahrens {
560fa9e4066Sahrens 	(void) fprintf(stderr, "error: ");
561fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, adx);
562fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
563fa9e4066Sahrens 
564fa9e4066Sahrens 	abort();	/* think of it as a "user-level crash dump" */
565fa9e4066Sahrens }
566fa9e4066Sahrens 
567fa9e4066Sahrens void
568fa9e4066Sahrens panic(const char *fmt, ...)
569fa9e4066Sahrens {
570fa9e4066Sahrens 	va_list adx;
571fa9e4066Sahrens 
572fa9e4066Sahrens 	va_start(adx, fmt);
573fa9e4066Sahrens 	vpanic(fmt, adx);
574fa9e4066Sahrens 	va_end(adx);
575fa9e4066Sahrens }
576fa9e4066Sahrens 
577fa9e4066Sahrens void
5780125049cSahrens vcmn_err(int ce, const char *fmt, va_list adx)
579fa9e4066Sahrens {
580fa9e4066Sahrens 	if (ce == CE_PANIC)
581fa9e4066Sahrens 		vpanic(fmt, adx);
582fa9e4066Sahrens 	if (ce != CE_NOTE) {	/* suppress noise in userland stress testing */
583fa9e4066Sahrens 		(void) fprintf(stderr, "%s", ce_prefix[ce]);
584fa9e4066Sahrens 		(void) vfprintf(stderr, fmt, adx);
585fa9e4066Sahrens 		(void) fprintf(stderr, "%s", ce_suffix[ce]);
586fa9e4066Sahrens 	}
5870125049cSahrens }
5880125049cSahrens 
5890125049cSahrens /*PRINTFLIKE2*/
5900125049cSahrens void
5910125049cSahrens cmn_err(int ce, const char *fmt, ...)
5920125049cSahrens {
5930125049cSahrens 	va_list adx;
5940125049cSahrens 
5950125049cSahrens 	va_start(adx, fmt);
5960125049cSahrens 	vcmn_err(ce, fmt, adx);
597fa9e4066Sahrens 	va_end(adx);
598fa9e4066Sahrens }
599fa9e4066Sahrens 
600ea8dc4b6Seschrock /*
601ea8dc4b6Seschrock  * =========================================================================
602ea8dc4b6Seschrock  * kobj interfaces
603ea8dc4b6Seschrock  * =========================================================================
604ea8dc4b6Seschrock  */
605ea8dc4b6Seschrock struct _buf *
606ea8dc4b6Seschrock kobj_open_file(char *name)
607ea8dc4b6Seschrock {
608ea8dc4b6Seschrock 	struct _buf *file;
609ea8dc4b6Seschrock 	vnode_t *vp;
610ea8dc4b6Seschrock 
611ea8dc4b6Seschrock 	/* set vp as the _fd field of the file */
612ea8dc4b6Seschrock 	if (vn_openat(name, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0, rootdir) != 0)
613ea8dc4b6Seschrock 		return ((void *)-1UL);
614ea8dc4b6Seschrock 
615ea8dc4b6Seschrock 	file = umem_zalloc(sizeof (struct _buf), UMEM_NOFAIL);
616ea8dc4b6Seschrock 	file->_fd = (intptr_t)vp;
617ea8dc4b6Seschrock 	return (file);
618ea8dc4b6Seschrock }
619ea8dc4b6Seschrock 
620ea8dc4b6Seschrock int
621ea8dc4b6Seschrock kobj_read_file(struct _buf *file, char *buf, unsigned size, unsigned off)
622ea8dc4b6Seschrock {
623ea8dc4b6Seschrock 	ssize_t resid;
624ea8dc4b6Seschrock 
625ea8dc4b6Seschrock 	vn_rdwr(UIO_READ, (vnode_t *)file->_fd, buf, size, (offset_t)off,
626ea8dc4b6Seschrock 	    UIO_SYSSPACE, 0, 0, 0, &resid);
627ea8dc4b6Seschrock 
628b1b8ab34Slling 	return (size - resid);
629ea8dc4b6Seschrock }
630ea8dc4b6Seschrock 
631ea8dc4b6Seschrock void
632ea8dc4b6Seschrock kobj_close_file(struct _buf *file)
633ea8dc4b6Seschrock {
634ea8dc4b6Seschrock 	vn_close((vnode_t *)file->_fd);
635ea8dc4b6Seschrock 	umem_free(file, sizeof (struct _buf));
636ea8dc4b6Seschrock }
637ea8dc4b6Seschrock 
638ea8dc4b6Seschrock int
639b1b8ab34Slling kobj_get_filesize(struct _buf *file, uint64_t *size)
640ea8dc4b6Seschrock {
641ea8dc4b6Seschrock 	struct stat64 st;
642b1b8ab34Slling 	vnode_t *vp = (vnode_t *)file->_fd;
643b1b8ab34Slling 
644ea8dc4b6Seschrock 	if (fstat64(vp->v_fd, &st) == -1) {
645ea8dc4b6Seschrock 		vn_close(vp);
646ea8dc4b6Seschrock 		return (errno);
647ea8dc4b6Seschrock 	}
648b1b8ab34Slling 	*size = st.st_size;
649ea8dc4b6Seschrock 	return (0);
650ea8dc4b6Seschrock }
651ea8dc4b6Seschrock 
652fa9e4066Sahrens /*
653fa9e4066Sahrens  * =========================================================================
654fa9e4066Sahrens  * misc routines
655fa9e4066Sahrens  * =========================================================================
656fa9e4066Sahrens  */
657fa9e4066Sahrens 
658fa9e4066Sahrens void
659fa9e4066Sahrens delay(clock_t ticks)
660fa9e4066Sahrens {
661fa9e4066Sahrens 	poll(0, 0, ticks * (1000 / hz));
662fa9e4066Sahrens }
663fa9e4066Sahrens 
664fa9e4066Sahrens /*
665fa9e4066Sahrens  * Find highest one bit set.
666fa9e4066Sahrens  *	Returns bit number + 1 of highest bit that is set, otherwise returns 0.
667fa9e4066Sahrens  * High order bit is 31 (or 63 in _LP64 kernel).
668fa9e4066Sahrens  */
669fa9e4066Sahrens int
670fa9e4066Sahrens highbit(ulong_t i)
671fa9e4066Sahrens {
672fa9e4066Sahrens 	register int h = 1;
673fa9e4066Sahrens 
674fa9e4066Sahrens 	if (i == 0)
675fa9e4066Sahrens 		return (0);
676fa9e4066Sahrens #ifdef _LP64
677fa9e4066Sahrens 	if (i & 0xffffffff00000000ul) {
678fa9e4066Sahrens 		h += 32; i >>= 32;
679fa9e4066Sahrens 	}
680fa9e4066Sahrens #endif
681fa9e4066Sahrens 	if (i & 0xffff0000) {
682fa9e4066Sahrens 		h += 16; i >>= 16;
683fa9e4066Sahrens 	}
684fa9e4066Sahrens 	if (i & 0xff00) {
685fa9e4066Sahrens 		h += 8; i >>= 8;
686fa9e4066Sahrens 	}
687fa9e4066Sahrens 	if (i & 0xf0) {
688fa9e4066Sahrens 		h += 4; i >>= 4;
689fa9e4066Sahrens 	}
690fa9e4066Sahrens 	if (i & 0xc) {
691fa9e4066Sahrens 		h += 2; i >>= 2;
692fa9e4066Sahrens 	}
693fa9e4066Sahrens 	if (i & 0x2) {
694fa9e4066Sahrens 		h += 1;
695fa9e4066Sahrens 	}
696fa9e4066Sahrens 	return (h);
697fa9e4066Sahrens }
698fa9e4066Sahrens 
699fa9e4066Sahrens static int
700fa9e4066Sahrens random_get_bytes_common(uint8_t *ptr, size_t len, char *devname)
701fa9e4066Sahrens {
702fa9e4066Sahrens 	int fd = open(devname, O_RDONLY);
703fa9e4066Sahrens 	size_t resid = len;
704fa9e4066Sahrens 	ssize_t bytes;
705fa9e4066Sahrens 
706fa9e4066Sahrens 	ASSERT(fd != -1);
707fa9e4066Sahrens 
708fa9e4066Sahrens 	while (resid != 0) {
709fa9e4066Sahrens 		bytes = read(fd, ptr, resid);
710fa9e4066Sahrens 		ASSERT(bytes >= 0);
711fa9e4066Sahrens 		ptr += bytes;
712fa9e4066Sahrens 		resid -= bytes;
713fa9e4066Sahrens 	}
714fa9e4066Sahrens 
715fa9e4066Sahrens 	close(fd);
716fa9e4066Sahrens 
717fa9e4066Sahrens 	return (0);
718fa9e4066Sahrens }
719fa9e4066Sahrens 
720fa9e4066Sahrens int
721fa9e4066Sahrens random_get_bytes(uint8_t *ptr, size_t len)
722fa9e4066Sahrens {
723fa9e4066Sahrens 	return (random_get_bytes_common(ptr, len, "/dev/random"));
724fa9e4066Sahrens }
725fa9e4066Sahrens 
726fa9e4066Sahrens int
727fa9e4066Sahrens random_get_pseudo_bytes(uint8_t *ptr, size_t len)
728fa9e4066Sahrens {
729fa9e4066Sahrens 	return (random_get_bytes_common(ptr, len, "/dev/urandom"));
730fa9e4066Sahrens }
731fa9e4066Sahrens 
732*95173954Sek int
733*95173954Sek ddi_strtoul(const char *hw_serial, char **nptr, int base, unsigned long *result)
734*95173954Sek {
735*95173954Sek 	char *end;
736*95173954Sek 
737*95173954Sek 	*result = strtoul(hw_serial, &end, base);
738*95173954Sek 	if (*result == 0)
739*95173954Sek 		return (errno);
740*95173954Sek 	return (0);
741*95173954Sek }
742*95173954Sek 
743fa9e4066Sahrens /*
744fa9e4066Sahrens  * =========================================================================
745fa9e4066Sahrens  * kernel emulation setup & teardown
746fa9e4066Sahrens  * =========================================================================
747fa9e4066Sahrens  */
748fa9e4066Sahrens static int
749fa9e4066Sahrens umem_out_of_memory(void)
750fa9e4066Sahrens {
751fa9e4066Sahrens 	char errmsg[] = "out of memory -- generating core dump\n";
752fa9e4066Sahrens 
753fa9e4066Sahrens 	write(fileno(stderr), errmsg, sizeof (errmsg));
754fa9e4066Sahrens 	abort();
755fa9e4066Sahrens 	return (0);
756fa9e4066Sahrens }
757fa9e4066Sahrens 
758fa9e4066Sahrens void
759fa9e4066Sahrens kernel_init(int mode)
760fa9e4066Sahrens {
761fa9e4066Sahrens 	umem_nofail_callback(umem_out_of_memory);
762fa9e4066Sahrens 
763fa9e4066Sahrens 	physmem = sysconf(_SC_PHYS_PAGES);
764fa9e4066Sahrens 
765fa9e4066Sahrens 	dprintf("physmem = %llu pages (%.2f GB)\n", physmem,
766fa9e4066Sahrens 	    (double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30));
767fa9e4066Sahrens 
768*95173954Sek 	snprintf(hw_serial, sizeof (hw_serial), "%ld", gethostid());
769*95173954Sek 
770fa9e4066Sahrens 	spa_init(mode);
771fa9e4066Sahrens }
772fa9e4066Sahrens 
773fa9e4066Sahrens void
774fa9e4066Sahrens kernel_fini(void)
775fa9e4066Sahrens {
776fa9e4066Sahrens 	spa_fini();
777fa9e4066Sahrens }
778c9431fa1Sahl 
779c9431fa1Sahl int
780c9431fa1Sahl z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen)
781c9431fa1Sahl {
782c9431fa1Sahl 	int ret;
783c9431fa1Sahl 	uLongf len = *dstlen;
784c9431fa1Sahl 
785c9431fa1Sahl 	if ((ret = uncompress(dst, &len, src, srclen)) == Z_OK)
786c9431fa1Sahl 		*dstlen = (size_t)len;
787c9431fa1Sahl 
788c9431fa1Sahl 	return (ret);
789c9431fa1Sahl }
790c9431fa1Sahl 
791c9431fa1Sahl int
792c9431fa1Sahl z_compress_level(void *dst, size_t *dstlen, const void *src, size_t srclen,
793c9431fa1Sahl     int level)
794c9431fa1Sahl {
795c9431fa1Sahl 	int ret;
796c9431fa1Sahl 	uLongf len = *dstlen;
797c9431fa1Sahl 
798c9431fa1Sahl 	if ((ret = compress2(dst, &len, src, srclen, level)) == Z_OK)
799c9431fa1Sahl 		*dstlen = (size_t)len;
800c9431fa1Sahl 
801c9431fa1Sahl 	return (ret);
802c9431fa1Sahl }
803