Print this page
5269 zfs: zpool import slow
While importing a pool all objsets are enumerated twice, once to check
the zil log chains and once to claim them. On pools with many datasets
this process might take a substantial amount of time.
Speed up the process by parallelizing it utilizing a taskq. The number
of parallel tasks is limited to 4 times the number of leaf vdevs.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/zfs/sys/dmu_objset.h
+++ new/usr/src/uts/common/fs/zfs/sys/dmu_objset.h
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.
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, 2014 by Delphix. All rights reserved.
24 24 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
25 25 */
26 26
27 27 /* Portions Copyright 2010 Robert Milkowski */
28 28
29 29 #ifndef _SYS_DMU_OBJSET_H
30 30 #define _SYS_DMU_OBJSET_H
31 31
32 32 #include <sys/spa.h>
33 33 #include <sys/arc.h>
34 34 #include <sys/txg.h>
35 35 #include <sys/zfs_context.h>
36 36 #include <sys/dnode.h>
37 37 #include <sys/zio.h>
38 38 #include <sys/zil.h>
39 39 #include <sys/sa.h>
40 40
41 41 #ifdef __cplusplus
42 42 extern "C" {
43 43 #endif
44 44
45 45 extern krwlock_t os_lock;
46 46
47 47 struct dsl_pool;
48 48 struct dsl_dataset;
49 49 struct dmu_tx;
50 50
51 51 #define OBJSET_PHYS_SIZE 2048
52 52 #define OBJSET_OLD_PHYS_SIZE 1024
53 53
54 54 #define OBJSET_BUF_HAS_USERUSED(buf) \
55 55 (arc_buf_size(buf) > OBJSET_OLD_PHYS_SIZE)
56 56
57 57 #define OBJSET_FLAG_USERACCOUNTING_COMPLETE (1ULL<<0)
58 58
59 59 typedef struct objset_phys {
60 60 dnode_phys_t os_meta_dnode;
61 61 zil_header_t os_zil_header;
62 62 uint64_t os_type;
63 63 uint64_t os_flags;
64 64 char os_pad[OBJSET_PHYS_SIZE - sizeof (dnode_phys_t)*3 -
65 65 sizeof (zil_header_t) - sizeof (uint64_t)*2];
66 66 dnode_phys_t os_userused_dnode;
67 67 dnode_phys_t os_groupused_dnode;
68 68 } objset_phys_t;
69 69
70 70 struct objset {
71 71 /* Immutable: */
72 72 struct dsl_dataset *os_dsl_dataset;
73 73 spa_t *os_spa;
74 74 arc_buf_t *os_phys_buf;
75 75 objset_phys_t *os_phys;
76 76 /*
77 77 * The following "special" dnodes have no parent and are exempt from
78 78 * dnode_move(), but they root their descendents in this objset using
79 79 * handles anyway, so that all access to dnodes from dbufs consistently
80 80 * uses handles.
81 81 */
82 82 dnode_handle_t os_meta_dnode;
83 83 dnode_handle_t os_userused_dnode;
84 84 dnode_handle_t os_groupused_dnode;
85 85 zilog_t *os_zil;
86 86
87 87 /* can change, under dsl_dir's locks: */
88 88 enum zio_checksum os_checksum;
89 89 enum zio_compress os_compress;
90 90 uint8_t os_copies;
91 91 enum zio_checksum os_dedup_checksum;
92 92 boolean_t os_dedup_verify;
93 93 zfs_logbias_op_t os_logbias;
94 94 zfs_cache_type_t os_primary_cache;
95 95 zfs_cache_type_t os_secondary_cache;
96 96 zfs_sync_type_t os_sync;
97 97 zfs_redundant_metadata_type_t os_redundant_metadata;
98 98
99 99 /* no lock needed: */
100 100 struct dmu_tx *os_synctx; /* XXX sketchy */
101 101 blkptr_t *os_rootbp;
102 102 zil_header_t os_zil_header;
103 103 list_t os_synced_dnodes;
104 104 uint64_t os_flags;
105 105
106 106 /* Protected by os_obj_lock */
107 107 kmutex_t os_obj_lock;
108 108 uint64_t os_obj_next;
109 109
110 110 /* Protected by os_lock */
111 111 kmutex_t os_lock;
112 112 list_t os_dirty_dnodes[TXG_SIZE];
113 113 list_t os_free_dnodes[TXG_SIZE];
114 114 list_t os_dnodes;
115 115 list_t os_downgraded_dbufs;
116 116
117 117 /* stuff we store for the user */
118 118 kmutex_t os_user_ptr_lock;
119 119 void *os_user_ptr;
120 120 sa_os_t *os_sa;
121 121 };
122 122
123 123 #define DMU_META_OBJSET 0
124 124 #define DMU_META_DNODE_OBJECT 0
125 125 #define DMU_OBJECT_IS_SPECIAL(obj) ((int64_t)(obj) <= 0)
126 126 #define DMU_META_DNODE(os) ((os)->os_meta_dnode.dnh_dnode)
127 127 #define DMU_USERUSED_DNODE(os) ((os)->os_userused_dnode.dnh_dnode)
128 128 #define DMU_GROUPUSED_DNODE(os) ((os)->os_groupused_dnode.dnh_dnode)
129 129
|
↓ open down ↓ |
129 lines elided |
↑ open up ↑ |
130 130 #define DMU_OS_IS_L2CACHEABLE(os) \
131 131 ((os)->os_secondary_cache == ZFS_CACHE_ALL || \
132 132 (os)->os_secondary_cache == ZFS_CACHE_METADATA)
133 133
134 134 #define DMU_OS_IS_L2COMPRESSIBLE(os) (zfs_mdcomp_disable == B_FALSE)
135 135
136 136 /* called from zpl */
137 137 int dmu_objset_hold(const char *name, void *tag, objset_t **osp);
138 138 int dmu_objset_own(const char *name, dmu_objset_type_t type,
139 139 boolean_t readonly, void *tag, objset_t **osp);
140 +int dmu_objset_own_obj(dsl_pool_t *dp, uint64_t obj, dmu_objset_type_t type,
141 + boolean_t readonly, void *tag, objset_t **osp);
140 142 void dmu_objset_refresh_ownership(objset_t *os, void *tag);
141 143 void dmu_objset_rele(objset_t *os, void *tag);
142 144 void dmu_objset_disown(objset_t *os, void *tag);
143 145 int dmu_objset_from_ds(struct dsl_dataset *ds, objset_t **osp);
144 146
145 147 void dmu_objset_stats(objset_t *os, nvlist_t *nv);
146 148 void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
147 149 void dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
148 150 uint64_t *usedobjsp, uint64_t *availobjsp);
149 151 uint64_t dmu_objset_fsid_guid(objset_t *os);
150 152 int dmu_objset_find_dp(struct dsl_pool *dp, uint64_t ddobj,
151 153 int func(struct dsl_pool *, struct dsl_dataset *, void *),
152 154 void *arg, int flags);
153 155 int dmu_objset_prefetch(const char *name, void *arg);
154 156 void dmu_objset_evict_dbufs(objset_t *os);
155 157 timestruc_t dmu_objset_snap_cmtime(objset_t *os);
156 158
157 159 /* called from dsl */
158 160 void dmu_objset_sync(objset_t *os, zio_t *zio, dmu_tx_t *tx);
159 161 boolean_t dmu_objset_is_dirty(objset_t *os, uint64_t txg);
160 162 objset_t *dmu_objset_create_impl(spa_t *spa, struct dsl_dataset *ds,
161 163 blkptr_t *bp, dmu_objset_type_t type, dmu_tx_t *tx);
162 164 int dmu_objset_open_impl(spa_t *spa, struct dsl_dataset *ds, blkptr_t *bp,
163 165 objset_t **osp);
164 166 void dmu_objset_evict(objset_t *os);
165 167 void dmu_objset_do_userquota_updates(objset_t *os, dmu_tx_t *tx);
166 168 void dmu_objset_userquota_get_ids(dnode_t *dn, boolean_t before, dmu_tx_t *tx);
167 169 boolean_t dmu_objset_userused_enabled(objset_t *os);
168 170 int dmu_objset_userspace_upgrade(objset_t *os);
169 171 boolean_t dmu_objset_userspace_present(objset_t *os);
170 172 int dmu_fsname(const char *snapname, char *buf);
171 173
172 174 void dmu_objset_init(void);
173 175 void dmu_objset_fini(void);
174 176
175 177 #ifdef __cplusplus
176 178 }
177 179 #endif
178 180
179 181 #endif /* _SYS_DMU_OBJSET_H */
|
↓ open down ↓ |
30 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX