Print this page
5269 zfs: zpool import slow
PORTING: this code relies on the property of taskq_wait to wait
until no more tasks are queued and no more tasks are active. As
we always queue new tasks from within other tasks, task_wait
reliably waits for the full recursion to finish, even though we
enqueue new tasks after taskq_wait has been called.
On platforms other than illumos, taskq_wait may not have this
property.
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Dan McDonald <danmcd@omniti.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
| 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 * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
26 26 */
27 27
28 28 /* Portions Copyright 2010 Robert Milkowski */
29 29
30 30 #ifndef _SYS_DMU_OBJSET_H
31 31 #define _SYS_DMU_OBJSET_H
32 32
33 33 #include <sys/spa.h>
34 34 #include <sys/arc.h>
35 35 #include <sys/txg.h>
36 36 #include <sys/zfs_context.h>
37 37 #include <sys/dnode.h>
38 38 #include <sys/zio.h>
39 39 #include <sys/zil.h>
40 40 #include <sys/sa.h>
41 41
42 42 #ifdef __cplusplus
43 43 extern "C" {
44 44 #endif
45 45
46 46 extern krwlock_t os_lock;
47 47
48 48 struct dsl_pool;
49 49 struct dsl_dataset;
50 50 struct dmu_tx;
51 51
52 52 #define OBJSET_PHYS_SIZE 2048
53 53 #define OBJSET_OLD_PHYS_SIZE 1024
54 54
55 55 #define OBJSET_BUF_HAS_USERUSED(buf) \
56 56 (arc_buf_size(buf) > OBJSET_OLD_PHYS_SIZE)
57 57
58 58 #define OBJSET_FLAG_USERACCOUNTING_COMPLETE (1ULL<<0)
59 59
60 60 typedef struct objset_phys {
61 61 dnode_phys_t os_meta_dnode;
62 62 zil_header_t os_zil_header;
63 63 uint64_t os_type;
64 64 uint64_t os_flags;
65 65 char os_pad[OBJSET_PHYS_SIZE - sizeof (dnode_phys_t)*3 -
66 66 sizeof (zil_header_t) - sizeof (uint64_t)*2];
67 67 dnode_phys_t os_userused_dnode;
68 68 dnode_phys_t os_groupused_dnode;
69 69 } objset_phys_t;
70 70
71 71 struct objset {
72 72 /* Immutable: */
73 73 struct dsl_dataset *os_dsl_dataset;
74 74 spa_t *os_spa;
75 75 arc_buf_t *os_phys_buf;
76 76 objset_phys_t *os_phys;
77 77 /*
78 78 * The following "special" dnodes have no parent, are exempt
79 79 * from dnode_move(), and are not recorded in os_dnodes, but they
80 80 * root their descendents in this objset using handles anyway, so
81 81 * that all access to dnodes from dbufs consistently uses handles.
82 82 */
83 83 dnode_handle_t os_meta_dnode;
84 84 dnode_handle_t os_userused_dnode;
85 85 dnode_handle_t os_groupused_dnode;
86 86 zilog_t *os_zil;
87 87
88 88 list_node_t os_evicting_node;
89 89
90 90 /* can change, under dsl_dir's locks: */
91 91 enum zio_checksum os_checksum;
92 92 enum zio_compress os_compress;
93 93 uint8_t os_copies;
94 94 enum zio_checksum os_dedup_checksum;
95 95 boolean_t os_dedup_verify;
96 96 boolean_t os_evicting;
97 97 zfs_logbias_op_t os_logbias;
98 98 zfs_cache_type_t os_primary_cache;
99 99 zfs_cache_type_t os_secondary_cache;
100 100 zfs_sync_type_t os_sync;
101 101 zfs_redundant_metadata_type_t os_redundant_metadata;
102 102 int os_recordsize;
103 103
104 104 /* no lock needed: */
105 105 struct dmu_tx *os_synctx; /* XXX sketchy */
106 106 blkptr_t *os_rootbp;
107 107 zil_header_t os_zil_header;
108 108 list_t os_synced_dnodes;
109 109 uint64_t os_flags;
110 110
111 111 /* Protected by os_obj_lock */
112 112 kmutex_t os_obj_lock;
113 113 uint64_t os_obj_next;
114 114
115 115 /* Protected by os_lock */
116 116 kmutex_t os_lock;
117 117 list_t os_dirty_dnodes[TXG_SIZE];
118 118 list_t os_free_dnodes[TXG_SIZE];
119 119 list_t os_dnodes;
120 120 list_t os_downgraded_dbufs;
121 121
122 122 /* stuff we store for the user */
123 123 kmutex_t os_user_ptr_lock;
124 124 void *os_user_ptr;
125 125 sa_os_t *os_sa;
126 126 };
127 127
128 128 #define DMU_META_OBJSET 0
129 129 #define DMU_META_DNODE_OBJECT 0
130 130 #define DMU_OBJECT_IS_SPECIAL(obj) ((int64_t)(obj) <= 0)
131 131 #define DMU_META_DNODE(os) ((os)->os_meta_dnode.dnh_dnode)
132 132 #define DMU_USERUSED_DNODE(os) ((os)->os_userused_dnode.dnh_dnode)
133 133 #define DMU_GROUPUSED_DNODE(os) ((os)->os_groupused_dnode.dnh_dnode)
134 134
|
↓ open down ↓ |
134 lines elided |
↑ open up ↑ |
135 135 #define DMU_OS_IS_L2CACHEABLE(os) \
136 136 ((os)->os_secondary_cache == ZFS_CACHE_ALL || \
137 137 (os)->os_secondary_cache == ZFS_CACHE_METADATA)
138 138
139 139 #define DMU_OS_IS_L2COMPRESSIBLE(os) (zfs_mdcomp_disable == B_FALSE)
140 140
141 141 /* called from zpl */
142 142 int dmu_objset_hold(const char *name, void *tag, objset_t **osp);
143 143 int dmu_objset_own(const char *name, dmu_objset_type_t type,
144 144 boolean_t readonly, void *tag, objset_t **osp);
145 +int dmu_objset_own_obj(struct dsl_pool *dp, uint64_t obj,
146 + dmu_objset_type_t type, boolean_t readonly, void *tag, objset_t **osp);
145 147 void dmu_objset_refresh_ownership(objset_t *os, void *tag);
146 148 void dmu_objset_rele(objset_t *os, void *tag);
147 149 void dmu_objset_disown(objset_t *os, void *tag);
148 150 int dmu_objset_from_ds(struct dsl_dataset *ds, objset_t **osp);
149 151
150 152 void dmu_objset_stats(objset_t *os, nvlist_t *nv);
151 153 void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
152 154 void dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
153 155 uint64_t *usedobjsp, uint64_t *availobjsp);
154 156 uint64_t dmu_objset_fsid_guid(objset_t *os);
155 157 int dmu_objset_find_dp(struct dsl_pool *dp, uint64_t ddobj,
156 158 int func(struct dsl_pool *, struct dsl_dataset *, void *),
157 159 void *arg, int flags);
158 160 int dmu_objset_prefetch(const char *name, void *arg);
159 161 void dmu_objset_evict_dbufs(objset_t *os);
160 162 timestruc_t dmu_objset_snap_cmtime(objset_t *os);
161 163
162 164 /* called from dsl */
163 165 void dmu_objset_sync(objset_t *os, zio_t *zio, dmu_tx_t *tx);
164 166 boolean_t dmu_objset_is_dirty(objset_t *os, uint64_t txg);
165 167 objset_t *dmu_objset_create_impl(spa_t *spa, struct dsl_dataset *ds,
166 168 blkptr_t *bp, dmu_objset_type_t type, dmu_tx_t *tx);
167 169 int dmu_objset_open_impl(spa_t *spa, struct dsl_dataset *ds, blkptr_t *bp,
168 170 objset_t **osp);
169 171 void dmu_objset_evict(objset_t *os);
170 172 void dmu_objset_do_userquota_updates(objset_t *os, dmu_tx_t *tx);
171 173 void dmu_objset_userquota_get_ids(dnode_t *dn, boolean_t before, dmu_tx_t *tx);
172 174 boolean_t dmu_objset_userused_enabled(objset_t *os);
173 175 int dmu_objset_userspace_upgrade(objset_t *os);
174 176 boolean_t dmu_objset_userspace_present(objset_t *os);
175 177 int dmu_fsname(const char *snapname, char *buf);
176 178
177 179 void dmu_objset_evict_done(objset_t *os);
178 180
179 181 void dmu_objset_init(void);
180 182 void dmu_objset_fini(void);
181 183
182 184 #ifdef __cplusplus
183 185 }
184 186 #endif
185 187
186 188 #endif /* _SYS_DMU_OBJSET_H */
|
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX