Print this page
8115 parallel zfs mount
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libzpool/common/kernel.c
+++ new/usr/src/lib/libzpool/common/kernel.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.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
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 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
24 24 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
25 + * Copyright 2017 RackTop Systems.
25 26 */
26 27
27 28 #include <assert.h>
28 29 #include <fcntl.h>
29 30 #include <poll.h>
30 31 #include <stdio.h>
31 32 #include <stdlib.h>
32 33 #include <string.h>
33 34 #include <zlib.h>
34 35 #include <libgen.h>
35 36 #include <sys/spa.h>
36 37 #include <sys/stat.h>
37 38 #include <sys/processor.h>
38 39 #include <sys/zfs_context.h>
39 40 #include <sys/rrwlock.h>
40 41 #include <sys/zmod.h>
41 42 #include <sys/utsname.h>
42 43 #include <sys/systeminfo.h>
43 44
45 +extern void system_taskq_init(void);
46 +extern void system_taskq_fini(void);
47 +
44 48 /*
45 49 * Emulation of kernel services in userland.
46 50 */
47 51
48 -int aok;
49 -uint64_t physmem;
52 +pgcnt_t physmem;
50 53 vnode_t *rootdir = (vnode_t *)0xabcd1234;
51 54 char hw_serial[HW_HOSTID_LEN];
52 55 kmutex_t cpu_lock;
53 56 vmem_t *zio_arena = NULL;
54 57
55 58 /* If set, all blocks read will be copied to the specified directory. */
56 59 char *vn_dumpdir = NULL;
57 60
58 61 struct utsname utsname = {
59 62 "userland", "libzpool", "1", "1", "na"
60 63 };
61 64
62 -/* this only exists to have its address taken */
63 -struct proc p0;
64 -
65 65 /*
66 66 * =========================================================================
67 - * threads
68 - * =========================================================================
69 - */
70 -/*ARGSUSED*/
71 -kthread_t *
72 -zk_thread_create(void (*func)(), void *arg, uint64_t len)
73 -{
74 - thread_t tid;
75 -
76 - ASSERT0(len);
77 - VERIFY(thr_create(0, 0, (void *(*)(void *))func, arg, THR_DETACHED,
78 - &tid) == 0);
79 -
80 - return ((void *)(uintptr_t)tid);
81 -}
82 -
83 -/*
84 - * =========================================================================
85 - * kstats
86 - * =========================================================================
87 - */
88 -/*ARGSUSED*/
89 -kstat_t *
90 -kstat_create(const char *module, int instance, const char *name,
91 - const char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag)
92 -{
93 - return (NULL);
94 -}
95 -
96 -/*ARGSUSED*/
97 -void
98 -kstat_named_init(kstat_named_t *knp, const char *name, uchar_t type)
99 -{}
100 -
101 -/*ARGSUSED*/
102 -void
103 -kstat_install(kstat_t *ksp)
104 -{}
105 -
106 -/*ARGSUSED*/
107 -void
108 -kstat_delete(kstat_t *ksp)
109 -{}
110 -
111 -/*ARGSUSED*/
112 -void
113 -kstat_waitq_enter(kstat_io_t *kiop)
114 -{}
115 -
116 -/*ARGSUSED*/
117 -void
118 -kstat_waitq_exit(kstat_io_t *kiop)
119 -{}
120 -
121 -/*ARGSUSED*/
122 -void
123 -kstat_runq_enter(kstat_io_t *kiop)
124 -{}
125 -
126 -/*ARGSUSED*/
127 -void
128 -kstat_runq_exit(kstat_io_t *kiop)
129 -{}
130 -
131 -/*ARGSUSED*/
132 -void
133 -kstat_waitq_to_runq(kstat_io_t *kiop)
134 -{}
135 -
136 -/*ARGSUSED*/
137 -void
138 -kstat_runq_back_to_waitq(kstat_io_t *kiop)
139 -{}
140 -
141 -/*
142 - * =========================================================================
143 - * mutexes
144 - * =========================================================================
145 - */
146 -void
147 -zmutex_init(kmutex_t *mp)
148 -{
149 - mp->m_owner = NULL;
150 - mp->initialized = B_TRUE;
151 - (void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL);
152 -}
153 -
154 -void
155 -zmutex_destroy(kmutex_t *mp)
156 -{
157 - ASSERT(mp->initialized == B_TRUE);
158 - ASSERT(mp->m_owner == NULL);
159 - (void) _mutex_destroy(&(mp)->m_lock);
160 - mp->m_owner = (void *)-1UL;
161 - mp->initialized = B_FALSE;
162 -}
163 -
164 -void
165 -zmutex_enter(kmutex_t *mp)
166 -{
167 - ASSERT(mp->initialized == B_TRUE);
168 - ASSERT(mp->m_owner != (void *)-1UL);
169 - ASSERT(mp->m_owner != curthread);
170 - VERIFY(mutex_lock(&mp->m_lock) == 0);
171 - ASSERT(mp->m_owner == NULL);
172 - mp->m_owner = curthread;
173 -}
174 -
175 -int
176 -mutex_tryenter(kmutex_t *mp)
177 -{
178 - ASSERT(mp->initialized == B_TRUE);
179 - ASSERT(mp->m_owner != (void *)-1UL);
180 - if (0 == mutex_trylock(&mp->m_lock)) {
181 - ASSERT(mp->m_owner == NULL);
182 - mp->m_owner = curthread;
183 - return (1);
184 - } else {
185 - return (0);
186 - }
187 -}
188 -
189 -void
190 -zmutex_exit(kmutex_t *mp)
191 -{
192 - ASSERT(mp->initialized == B_TRUE);
193 - ASSERT(mutex_owner(mp) == curthread);
194 - mp->m_owner = NULL;
195 - VERIFY(mutex_unlock(&mp->m_lock) == 0);
196 -}
197 -
198 -void *
199 -mutex_owner(kmutex_t *mp)
200 -{
201 - ASSERT(mp->initialized == B_TRUE);
202 - return (mp->m_owner);
203 -}
204 -
205 -/*
206 - * =========================================================================
207 - * rwlocks
208 - * =========================================================================
209 - */
210 -/*ARGSUSED*/
211 -void
212 -rw_init(krwlock_t *rwlp, char *name, int type, void *arg)
213 -{
214 - rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL);
215 - rwlp->rw_owner = NULL;
216 - rwlp->initialized = B_TRUE;
217 -}
218 -
219 -void
220 -rw_destroy(krwlock_t *rwlp)
221 -{
222 - rwlock_destroy(&rwlp->rw_lock);
223 - rwlp->rw_owner = (void *)-1UL;
224 - rwlp->initialized = B_FALSE;
225 -}
226 -
227 -void
228 -rw_enter(krwlock_t *rwlp, krw_t rw)
229 -{
230 - ASSERT(!RW_LOCK_HELD(rwlp));
231 - ASSERT(rwlp->initialized == B_TRUE);
232 - ASSERT(rwlp->rw_owner != (void *)-1UL);
233 - ASSERT(rwlp->rw_owner != curthread);
234 -
235 - if (rw == RW_WRITER)
236 - VERIFY(rw_wrlock(&rwlp->rw_lock) == 0);
237 - else
238 - VERIFY(rw_rdlock(&rwlp->rw_lock) == 0);
239 -
240 - rwlp->rw_owner = curthread;
241 -}
242 -
243 -void
244 -rw_exit(krwlock_t *rwlp)
245 -{
246 - ASSERT(rwlp->initialized == B_TRUE);
247 - ASSERT(rwlp->rw_owner != (void *)-1UL);
248 -
249 - rwlp->rw_owner = NULL;
250 - VERIFY(rw_unlock(&rwlp->rw_lock) == 0);
251 -}
252 -
253 -int
254 -rw_tryenter(krwlock_t *rwlp, krw_t rw)
255 -{
256 - int rv;
257 -
258 - ASSERT(rwlp->initialized == B_TRUE);
259 - ASSERT(rwlp->rw_owner != (void *)-1UL);
260 -
261 - if (rw == RW_WRITER)
262 - rv = rw_trywrlock(&rwlp->rw_lock);
263 - else
264 - rv = rw_tryrdlock(&rwlp->rw_lock);
265 -
266 - if (rv == 0) {
267 - rwlp->rw_owner = curthread;
268 - return (1);
269 - }
270 -
271 - return (0);
272 -}
273 -
274 -/*ARGSUSED*/
275 -int
276 -rw_tryupgrade(krwlock_t *rwlp)
277 -{
278 - ASSERT(rwlp->initialized == B_TRUE);
279 - ASSERT(rwlp->rw_owner != (void *)-1UL);
280 -
281 - return (0);
282 -}
283 -
284 -/*
285 - * =========================================================================
286 - * condition variables
287 - * =========================================================================
288 - */
289 -/*ARGSUSED*/
290 -void
291 -cv_init(kcondvar_t *cv, char *name, int type, void *arg)
292 -{
293 - VERIFY(cond_init(cv, type, NULL) == 0);
294 -}
295 -
296 -void
297 -cv_destroy(kcondvar_t *cv)
298 -{
299 - VERIFY(cond_destroy(cv) == 0);
300 -}
301 -
302 -void
303 -cv_wait(kcondvar_t *cv, kmutex_t *mp)
304 -{
305 - ASSERT(mutex_owner(mp) == curthread);
306 - mp->m_owner = NULL;
307 - int ret = cond_wait(cv, &mp->m_lock);
308 - VERIFY(ret == 0 || ret == EINTR);
309 - mp->m_owner = curthread;
310 -}
311 -
312 -clock_t
313 -cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime)
314 -{
315 - int error;
316 - timestruc_t ts;
317 - clock_t delta;
318 -
319 -top:
320 - delta = abstime - ddi_get_lbolt();
321 - if (delta <= 0)
322 - return (-1);
323 -
324 - ts.tv_sec = delta / hz;
325 - ts.tv_nsec = (delta % hz) * (NANOSEC / hz);
326 -
327 - ASSERT(mutex_owner(mp) == curthread);
328 - mp->m_owner = NULL;
329 - error = cond_reltimedwait(cv, &mp->m_lock, &ts);
330 - mp->m_owner = curthread;
331 -
332 - if (error == ETIME)
333 - return (-1);
334 -
335 - if (error == EINTR)
336 - goto top;
337 -
338 - ASSERT(error == 0);
339 -
340 - return (1);
341 -}
342 -
343 -/*ARGSUSED*/
344 -clock_t
345 -cv_timedwait_hires(kcondvar_t *cv, kmutex_t *mp, hrtime_t tim, hrtime_t res,
346 - int flag)
347 -{
348 - int error;
349 - timestruc_t ts;
350 - hrtime_t delta;
351 -
352 - ASSERT(flag == 0 || flag == CALLOUT_FLAG_ABSOLUTE);
353 -
354 -top:
355 - delta = tim;
356 - if (flag & CALLOUT_FLAG_ABSOLUTE)
357 - delta -= gethrtime();
358 -
359 - if (delta <= 0)
360 - return (-1);
361 -
362 - ts.tv_sec = delta / NANOSEC;
363 - ts.tv_nsec = delta % NANOSEC;
364 -
365 - ASSERT(mutex_owner(mp) == curthread);
366 - mp->m_owner = NULL;
367 - error = cond_reltimedwait(cv, &mp->m_lock, &ts);
368 - mp->m_owner = curthread;
369 -
370 - if (error == ETIME)
371 - return (-1);
372 -
373 - if (error == EINTR)
374 - goto top;
375 -
376 - ASSERT(error == 0);
377 -
378 - return (1);
379 -}
380 -
381 -void
382 -cv_signal(kcondvar_t *cv)
383 -{
384 - VERIFY(cond_signal(cv) == 0);
385 -}
386 -
387 -void
388 -cv_broadcast(kcondvar_t *cv)
389 -{
390 - VERIFY(cond_broadcast(cv) == 0);
391 -}
392 -
393 -/*
394 - * =========================================================================
395 67 * vnode operations
396 68 * =========================================================================
397 69 */
398 70 /*
399 71 * Note: for the xxxat() versions of these functions, we assume that the
400 72 * starting vp is always rootdir (which is true for spa_directory.c, the only
401 73 * ZFS consumer of these interfaces). We assert this is true, and then emulate
402 74 * them by adding '/' in front of the path.
403 75 */
404 76
405 77 /*ARGSUSED*/
406 78 int
407 79 vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3)
408 80 {
409 81 int fd;
410 82 int dump_fd;
411 83 vnode_t *vp;
412 84 int old_umask;
413 85 char realpath[MAXPATHLEN];
414 86 struct stat64 st;
415 87
416 88 /*
417 89 * If we're accessing a real disk from userland, we need to use
418 90 * the character interface to avoid caching. This is particularly
419 91 * important if we're trying to look at a real in-kernel storage
420 92 * pool from userland, e.g. via zdb, because otherwise we won't
421 93 * see the changes occurring under the segmap cache.
422 94 * On the other hand, the stupid character device returns zero
423 95 * for its size. So -- gag -- we open the block device to get
424 96 * its size, and remember it for subsequent VOP_GETATTR().
425 97 */
426 98 if (strncmp(path, "/dev/", 5) == 0) {
427 99 char *dsk;
428 100 fd = open64(path, O_RDONLY);
429 101 if (fd == -1)
430 102 return (errno);
431 103 if (fstat64(fd, &st) == -1) {
432 104 close(fd);
433 105 return (errno);
434 106 }
435 107 close(fd);
436 108 (void) sprintf(realpath, "%s", path);
437 109 dsk = strstr(path, "/dsk/");
438 110 if (dsk != NULL)
439 111 (void) sprintf(realpath + (dsk - path) + 1, "r%s",
440 112 dsk + 1);
441 113 } else {
442 114 (void) sprintf(realpath, "%s", path);
443 115 if (!(flags & FCREAT) && stat64(realpath, &st) == -1)
444 116 return (errno);
445 117 }
446 118
447 119 if (flags & FCREAT)
448 120 old_umask = umask(0);
449 121
450 122 /*
451 123 * The construct 'flags - FREAD' conveniently maps combinations of
452 124 * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.
453 125 */
454 126 fd = open64(realpath, flags - FREAD, mode);
455 127
456 128 if (flags & FCREAT)
457 129 (void) umask(old_umask);
458 130
459 131 if (vn_dumpdir != NULL) {
460 132 char dumppath[MAXPATHLEN];
461 133 (void) snprintf(dumppath, sizeof (dumppath),
462 134 "%s/%s", vn_dumpdir, basename(realpath));
463 135 dump_fd = open64(dumppath, O_CREAT | O_WRONLY, 0666);
464 136 if (dump_fd == -1)
465 137 return (errno);
466 138 } else {
467 139 dump_fd = -1;
468 140 }
469 141
470 142 if (fd == -1)
471 143 return (errno);
472 144
473 145 if (fstat64(fd, &st) == -1) {
474 146 close(fd);
475 147 return (errno);
476 148 }
477 149
478 150 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
479 151
480 152 *vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);
481 153
482 154 vp->v_fd = fd;
483 155 vp->v_size = st.st_size;
484 156 vp->v_path = spa_strdup(path);
485 157 vp->v_dump_fd = dump_fd;
486 158
487 159 return (0);
488 160 }
489 161
490 162 /*ARGSUSED*/
491 163 int
492 164 vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,
493 165 int x3, vnode_t *startvp, int fd)
494 166 {
495 167 char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);
496 168 int ret;
497 169
498 170 ASSERT(startvp == rootdir);
499 171 (void) sprintf(realpath, "/%s", path);
500 172
501 173 /* fd ignored for now, need if want to simulate nbmand support */
502 174 ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);
503 175
504 176 umem_free(realpath, strlen(path) + 2);
505 177
506 178 return (ret);
507 179 }
508 180
509 181 /*ARGSUSED*/
510 182 int
511 183 vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len, offset_t offset,
512 184 int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp)
513 185 {
514 186 ssize_t iolen, split;
515 187
516 188 if (uio == UIO_READ) {
517 189 iolen = pread64(vp->v_fd, addr, len, offset);
518 190 if (vp->v_dump_fd != -1) {
519 191 int status =
520 192 pwrite64(vp->v_dump_fd, addr, iolen, offset);
521 193 ASSERT(status != -1);
522 194 }
523 195 } else {
524 196 /*
525 197 * To simulate partial disk writes, we split writes into two
526 198 * system calls so that the process can be killed in between.
527 199 */
528 200 int sectors = len >> SPA_MINBLOCKSHIFT;
529 201 split = (sectors > 0 ? rand() % sectors : 0) <<
530 202 SPA_MINBLOCKSHIFT;
531 203 iolen = pwrite64(vp->v_fd, addr, split, offset);
532 204 iolen += pwrite64(vp->v_fd, (char *)addr + split,
533 205 len - split, offset + split);
534 206 }
535 207
536 208 if (iolen == -1)
537 209 return (errno);
538 210 if (residp)
539 211 *residp = len - iolen;
540 212 else if (iolen != len)
541 213 return (EIO);
542 214 return (0);
543 215 }
544 216
545 217 void
546 218 vn_close(vnode_t *vp)
547 219 {
548 220 close(vp->v_fd);
549 221 if (vp->v_dump_fd != -1)
550 222 close(vp->v_dump_fd);
551 223 spa_strfree(vp->v_path);
552 224 umem_free(vp, sizeof (vnode_t));
553 225 }
554 226
555 227 /*
556 228 * At a minimum we need to update the size since vdev_reopen()
557 229 * will no longer call vn_openat().
558 230 */
559 231 int
560 232 fop_getattr(vnode_t *vp, vattr_t *vap)
561 233 {
562 234 struct stat64 st;
563 235
564 236 if (fstat64(vp->v_fd, &st) == -1) {
565 237 close(vp->v_fd);
566 238 return (errno);
567 239 }
568 240
569 241 vap->va_size = st.st_size;
570 242 return (0);
571 243 }
572 244
573 245 #ifdef ZFS_DEBUG
574 246
575 247 /*
576 248 * =========================================================================
577 249 * Figure out which debugging statements to print
578 250 * =========================================================================
579 251 */
580 252
581 253 static char *dprintf_string;
582 254 static int dprintf_print_all;
583 255
584 256 int
585 257 dprintf_find_string(const char *string)
586 258 {
587 259 char *tmp_str = dprintf_string;
588 260 int len = strlen(string);
589 261
590 262 /*
591 263 * Find out if this is a string we want to print.
592 264 * String format: file1.c,function_name1,file2.c,file3.c
593 265 */
594 266
595 267 while (tmp_str != NULL) {
596 268 if (strncmp(tmp_str, string, len) == 0 &&
597 269 (tmp_str[len] == ',' || tmp_str[len] == '\0'))
598 270 return (1);
599 271 tmp_str = strchr(tmp_str, ',');
600 272 if (tmp_str != NULL)
601 273 tmp_str++; /* Get rid of , */
602 274 }
603 275 return (0);
604 276 }
605 277
606 278 void
607 279 dprintf_setup(int *argc, char **argv)
608 280 {
609 281 int i, j;
610 282
611 283 /*
612 284 * Debugging can be specified two ways: by setting the
613 285 * environment variable ZFS_DEBUG, or by including a
614 286 * "debug=..." argument on the command line. The command
615 287 * line setting overrides the environment variable.
616 288 */
617 289
618 290 for (i = 1; i < *argc; i++) {
619 291 int len = strlen("debug=");
620 292 /* First look for a command line argument */
621 293 if (strncmp("debug=", argv[i], len) == 0) {
622 294 dprintf_string = argv[i] + len;
623 295 /* Remove from args */
624 296 for (j = i; j < *argc; j++)
625 297 argv[j] = argv[j+1];
626 298 argv[j] = NULL;
627 299 (*argc)--;
628 300 }
629 301 }
630 302
631 303 if (dprintf_string == NULL) {
632 304 /* Look for ZFS_DEBUG environment variable */
633 305 dprintf_string = getenv("ZFS_DEBUG");
634 306 }
635 307
636 308 /*
637 309 * Are we just turning on all debugging?
638 310 */
639 311 if (dprintf_find_string("on"))
640 312 dprintf_print_all = 1;
641 313
642 314 if (dprintf_string != NULL)
643 315 zfs_flags |= ZFS_DEBUG_DPRINTF;
644 316 }
645 317
646 318 /*
647 319 * =========================================================================
648 320 * debug printfs
649 321 * =========================================================================
650 322 */
651 323 void
652 324 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
653 325 {
654 326 const char *newfile;
655 327 va_list adx;
656 328
657 329 /*
658 330 * Get rid of annoying "../common/" prefix to filename.
659 331 */
660 332 newfile = strrchr(file, '/');
661 333 if (newfile != NULL) {
662 334 newfile = newfile + 1; /* Get rid of leading / */
663 335 } else {
664 336 newfile = file;
665 337 }
666 338
667 339 if (dprintf_print_all ||
668 340 dprintf_find_string(newfile) ||
669 341 dprintf_find_string(func)) {
670 342 /* Print out just the function name if requested */
671 343 flockfile(stdout);
672 344 if (dprintf_find_string("pid"))
673 345 (void) printf("%d ", getpid());
674 346 if (dprintf_find_string("tid"))
675 347 (void) printf("%u ", thr_self());
676 348 if (dprintf_find_string("cpu"))
677 349 (void) printf("%u ", getcpuid());
678 350 if (dprintf_find_string("time"))
679 351 (void) printf("%llu ", gethrtime());
680 352 if (dprintf_find_string("long"))
681 353 (void) printf("%s, line %d: ", newfile, line);
682 354 (void) printf("%s: ", func);
683 355 va_start(adx, fmt);
|
↓ open down ↓ |
279 lines elided |
↑ open up ↑ |
684 356 (void) vprintf(fmt, adx);
685 357 va_end(adx);
686 358 funlockfile(stdout);
687 359 }
688 360 }
689 361
690 362 #endif /* ZFS_DEBUG */
691 363
692 364 /*
693 365 * =========================================================================
694 - * cmn_err() and panic()
695 - * =========================================================================
696 - */
697 -static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" };
698 -static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" };
699 -
700 -void
701 -vpanic(const char *fmt, va_list adx)
702 -{
703 - char buf[512];
704 - (void) vsnprintf(buf, 512, fmt, adx);
705 - assfail(buf, NULL, 0);
706 - abort(); /* necessary to make vpanic meet noreturn requirements */
707 -}
708 -
709 -void
710 -panic(const char *fmt, ...)
711 -{
712 - va_list adx;
713 -
714 - va_start(adx, fmt);
715 - vpanic(fmt, adx);
716 - va_end(adx);
717 -}
718 -
719 -void
720 -vcmn_err(int ce, const char *fmt, va_list adx)
721 -{
722 - if (ce == CE_PANIC)
723 - vpanic(fmt, adx);
724 - if (ce != CE_NOTE) { /* suppress noise in userland stress testing */
725 - (void) fprintf(stderr, "%s", ce_prefix[ce]);
726 - (void) vfprintf(stderr, fmt, adx);
727 - (void) fprintf(stderr, "%s", ce_suffix[ce]);
728 - }
729 -}
730 -
731 -/*PRINTFLIKE2*/
732 -void
733 -cmn_err(int ce, const char *fmt, ...)
734 -{
735 - va_list adx;
736 -
737 - va_start(adx, fmt);
738 - vcmn_err(ce, fmt, adx);
739 - va_end(adx);
740 -}
741 -
742 -/*
743 - * =========================================================================
744 366 * kobj interfaces
745 367 * =========================================================================
746 368 */
747 369 struct _buf *
748 370 kobj_open_file(char *name)
749 371 {
750 372 struct _buf *file;
751 373 vnode_t *vp;
752 374
753 375 /* set vp as the _fd field of the file */
754 376 if (vn_openat(name, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0, rootdir,
755 377 -1) != 0)
756 378 return ((void *)-1UL);
757 379
758 380 file = umem_zalloc(sizeof (struct _buf), UMEM_NOFAIL);
759 381 file->_fd = (intptr_t)vp;
760 382 return (file);
761 383 }
762 384
763 385 int
764 386 kobj_read_file(struct _buf *file, char *buf, unsigned size, unsigned off)
765 387 {
766 388 ssize_t resid;
767 389
768 390 vn_rdwr(UIO_READ, (vnode_t *)file->_fd, buf, size, (offset_t)off,
769 391 UIO_SYSSPACE, 0, 0, 0, &resid);
770 392
771 393 return (size - resid);
772 394 }
773 395
774 396 void
775 397 kobj_close_file(struct _buf *file)
776 398 {
777 399 vn_close((vnode_t *)file->_fd);
778 400 umem_free(file, sizeof (struct _buf));
779 401 }
780 402
781 403 int
782 404 kobj_get_filesize(struct _buf *file, uint64_t *size)
783 405 {
784 406 struct stat64 st;
785 407 vnode_t *vp = (vnode_t *)file->_fd;
786 408
|
↓ open down ↓ |
33 lines elided |
↑ open up ↑ |
787 409 if (fstat64(vp->v_fd, &st) == -1) {
788 410 vn_close(vp);
789 411 return (errno);
790 412 }
791 413 *size = st.st_size;
792 414 return (0);
793 415 }
794 416
795 417 /*
796 418 * =========================================================================
797 - * misc routines
798 - * =========================================================================
799 - */
800 -
801 -void
802 -delay(clock_t ticks)
803 -{
804 - poll(0, 0, ticks * (1000 / hz));
805 -}
806 -
807 -/*
808 - * Find highest one bit set.
809 - * Returns bit number + 1 of highest bit that is set, otherwise returns 0.
810 - */
811 -int
812 -highbit64(uint64_t i)
813 -{
814 - int h = 1;
815 -
816 - if (i == 0)
817 - return (0);
818 - if (i & 0xffffffff00000000ULL) {
819 - h += 32; i >>= 32;
820 - }
821 - if (i & 0xffff0000) {
822 - h += 16; i >>= 16;
823 - }
824 - if (i & 0xff00) {
825 - h += 8; i >>= 8;
826 - }
827 - if (i & 0xf0) {
828 - h += 4; i >>= 4;
829 - }
830 - if (i & 0xc) {
831 - h += 2; i >>= 2;
832 - }
833 - if (i & 0x2) {
834 - h += 1;
835 - }
836 - return (h);
837 -}
838 -
839 -static int random_fd = -1, urandom_fd = -1;
840 -
841 -static int
842 -random_get_bytes_common(uint8_t *ptr, size_t len, int fd)
843 -{
844 - size_t resid = len;
845 - ssize_t bytes;
846 -
847 - ASSERT(fd != -1);
848 -
849 - while (resid != 0) {
850 - bytes = read(fd, ptr, resid);
851 - ASSERT3S(bytes, >=, 0);
852 - ptr += bytes;
853 - resid -= bytes;
854 - }
855 -
856 - return (0);
857 -}
858 -
859 -int
860 -random_get_bytes(uint8_t *ptr, size_t len)
861 -{
862 - return (random_get_bytes_common(ptr, len, random_fd));
863 -}
864 -
865 -int
866 -random_get_pseudo_bytes(uint8_t *ptr, size_t len)
867 -{
868 - return (random_get_bytes_common(ptr, len, urandom_fd));
869 -}
870 -
871 -int
872 -ddi_strtoul(const char *hw_serial, char **nptr, int base, unsigned long *result)
873 -{
874 - char *end;
875 -
876 - *result = strtoul(hw_serial, &end, base);
877 - if (*result == 0)
878 - return (errno);
879 - return (0);
880 -}
881 -
882 -int
883 -ddi_strtoull(const char *str, char **nptr, int base, u_longlong_t *result)
884 -{
885 - char *end;
886 -
887 - *result = strtoull(str, &end, base);
888 - if (*result == 0)
889 - return (errno);
890 - return (0);
891 -}
892 -
893 -/* ARGSUSED */
894 -cyclic_id_t
895 -cyclic_add(cyc_handler_t *hdlr, cyc_time_t *when)
896 -{
897 - return (1);
898 -}
899 -
900 -/* ARGSUSED */
901 -void
902 -cyclic_remove(cyclic_id_t id)
903 -{
904 -}
905 -
906 -/* ARGSUSED */
907 -int
908 -cyclic_reprogram(cyclic_id_t id, hrtime_t expiration)
909 -{
910 - return (1);
911 -}
912 -
913 -/*
914 - * =========================================================================
915 419 * kernel emulation setup & teardown
916 420 * =========================================================================
917 421 */
918 422 static int
919 423 umem_out_of_memory(void)
920 424 {
921 425 char errmsg[] = "out of memory -- generating core dump\n";
922 426
923 427 write(fileno(stderr), errmsg, sizeof (errmsg));
924 428 abort();
925 429 return (0);
926 430 }
927 431
928 432 void
929 433 kernel_init(int mode)
930 434 {
931 435 extern uint_t rrw_tsd_key;
932 436
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
933 437 umem_nofail_callback(umem_out_of_memory);
934 438
935 439 physmem = sysconf(_SC_PHYS_PAGES);
936 440
937 441 dprintf("physmem = %llu pages (%.2f GB)\n", physmem,
938 442 (double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30));
939 443
940 444 (void) snprintf(hw_serial, sizeof (hw_serial), "%ld",
941 445 (mode & FWRITE) ? gethostid() : 0);
942 446
943 - VERIFY((random_fd = open("/dev/random", O_RDONLY)) != -1);
944 - VERIFY((urandom_fd = open("/dev/urandom", O_RDONLY)) != -1);
945 -
946 447 system_taskq_init();
947 448
948 449 mutex_init(&cpu_lock, NULL, MUTEX_DEFAULT, NULL);
949 450
950 451 spa_init(mode);
951 452
952 453 tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
953 454 }
954 455
955 456 void
956 457 kernel_fini(void)
957 458 {
958 459 spa_fini();
959 460
960 461 system_taskq_fini();
961 -
962 - close(random_fd);
963 - close(urandom_fd);
964 -
965 - random_fd = -1;
966 - urandom_fd = -1;
967 462 }
968 463
969 464 int
970 465 z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen)
971 466 {
972 467 int ret;
973 468 uLongf len = *dstlen;
974 469
975 470 if ((ret = uncompress(dst, &len, src, srclen)) == Z_OK)
976 471 *dstlen = (size_t)len;
977 472
978 473 return (ret);
979 474 }
980 475
981 476 int
982 477 z_compress_level(void *dst, size_t *dstlen, const void *src, size_t srclen,
983 478 int level)
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
984 479 {
985 480 int ret;
986 481 uLongf len = *dstlen;
987 482
988 483 if ((ret = compress2(dst, &len, src, srclen, level)) == Z_OK)
989 484 *dstlen = (size_t)len;
990 485
991 486 return (ret);
992 487 }
993 488
994 -uid_t
995 -crgetuid(cred_t *cr)
996 -{
997 - return (0);
998 -}
999 -
1000 -uid_t
1001 -crgetruid(cred_t *cr)
1002 -{
1003 - return (0);
1004 -}
1005 -
1006 -gid_t
1007 -crgetgid(cred_t *cr)
1008 -{
1009 - return (0);
1010 -}
1011 -
1012 489 int
1013 -crgetngroups(cred_t *cr)
1014 -{
1015 - return (0);
1016 -}
1017 -
1018 -gid_t *
1019 -crgetgroups(cred_t *cr)
1020 -{
1021 - return (NULL);
1022 -}
1023 -
1024 -int
1025 490 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
1026 491 {
1027 492 return (0);
1028 493 }
1029 494
1030 495 int
1031 496 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
1032 497 {
1033 498 return (0);
1034 499 }
1035 500
1036 501 int
1037 502 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
1038 503 {
1039 504 return (0);
1040 505 }
1041 506
1042 -ksiddomain_t *
1043 -ksid_lookupdomain(const char *dom)
1044 -{
1045 - ksiddomain_t *kd;
1046 -
1047 - kd = umem_zalloc(sizeof (ksiddomain_t), UMEM_NOFAIL);
1048 - kd->kd_name = spa_strdup(dom);
1049 - return (kd);
1050 -}
1051 -
1052 -void
1053 -ksiddomain_rele(ksiddomain_t *ksid)
1054 -{
1055 - spa_strfree(ksid->kd_name);
1056 - umem_free(ksid, sizeof (ksiddomain_t));
1057 -}
1058 -
1059 -/*
1060 - * Do not change the length of the returned string; it must be freed
1061 - * with strfree().
1062 - */
1063 -char *
1064 -kmem_asprintf(const char *fmt, ...)
1065 -{
1066 - int size;
1067 - va_list adx;
1068 - char *buf;
1069 -
1070 - va_start(adx, fmt);
1071 - size = vsnprintf(NULL, 0, fmt, adx) + 1;
1072 - va_end(adx);
1073 -
1074 - buf = kmem_alloc(size, KM_SLEEP);
1075 -
1076 - va_start(adx, fmt);
1077 - size = vsnprintf(buf, size, fmt, adx);
1078 - va_end(adx);
1079 -
1080 - return (buf);
1081 -}
1082 -
1083 507 /* ARGSUSED */
1084 508 int
1085 509 zfs_onexit_fd_hold(int fd, minor_t *minorp)
1086 510 {
1087 511 *minorp = 0;
1088 512 return (0);
1089 513 }
1090 514
1091 515 /* ARGSUSED */
1092 516 void
1093 517 zfs_onexit_fd_rele(int fd)
1094 518 {
1095 519 }
1096 520
1097 521 /* ARGSUSED */
1098 522 int
1099 523 zfs_onexit_add_cb(minor_t minor, void (*func)(void *), void *data,
1100 524 uint64_t *action_handle)
1101 525 {
1102 526 return (0);
1103 527 }
1104 528
1105 529 /* ARGSUSED */
1106 530 int
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
1107 531 zfs_onexit_del_cb(minor_t minor, uint64_t action_handle, boolean_t fire)
1108 532 {
1109 533 return (0);
1110 534 }
1111 535
1112 536 /* ARGSUSED */
1113 537 int
1114 538 zfs_onexit_cb_data(minor_t minor, uint64_t action_handle, void **data)
1115 539 {
1116 540 return (0);
1117 -}
1118 -
1119 -void
1120 -bioinit(buf_t *bp)
1121 -{
1122 - bzero(bp, sizeof (buf_t));
1123 -}
1124 -
1125 -void
1126 -biodone(buf_t *bp)
1127 -{
1128 - if (bp->b_iodone != NULL) {
1129 - (*(bp->b_iodone))(bp);
1130 - return;
1131 - }
1132 - ASSERT((bp->b_flags & B_DONE) == 0);
1133 - bp->b_flags |= B_DONE;
1134 -}
1135 -
1136 -void
1137 -bioerror(buf_t *bp, int error)
1138 -{
1139 - ASSERT(bp != NULL);
1140 - ASSERT(error >= 0);
1141 -
1142 - if (error != 0) {
1143 - bp->b_flags |= B_ERROR;
1144 - } else {
1145 - bp->b_flags &= ~B_ERROR;
1146 - }
1147 - bp->b_error = error;
1148 -}
1149 -
1150 -
1151 -int
1152 -geterror(struct buf *bp)
1153 -{
1154 - int error = 0;
1155 -
1156 - if (bp->b_flags & B_ERROR) {
1157 - error = bp->b_error;
1158 - if (!error)
1159 - error = EIO;
1160 - }
1161 - return (error);
1162 541 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX