1 // SPDX-License-Identifier: CDDL-1.0
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or https://opensource.org/licenses/CDDL-1.0.
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 (c) 2016, 2024 by Delphix. All rights reserved.
25 * Copyright (c) 2019 by Lawrence Livermore National Security, LLC.
26 * Copyright (c) 2021 Hewlett Packard Enterprise Development LP
27 * Copyright 2023 RackTop Systems, Inc.
28 */
29
30 #include <sys/spa.h>
31 #include <sys/spa_impl.h>
32 #include <sys/txg.h>
33 #include <sys/vdev_impl.h>
34 #include <sys/vdev_trim.h>
35 #include <sys/metaslab_impl.h>
36 #include <sys/dsl_synctask.h>
37 #include <sys/zap.h>
38 #include <sys/dmu_tx.h>
39 #include <sys/arc_impl.h>
40
41 /*
42 * TRIM is a feature which is used to notify a SSD that some previously
43 * written space is no longer allocated by the pool. This is useful because
44 * writes to a SSD must be performed to blocks which have first been erased.
45 * Ensuring the SSD always has a supply of erased blocks for new writes
46 * helps prevent the performance from deteriorating.
47 *
48 * There are two supported TRIM methods; manual and automatic.
49 *
50 * Manual TRIM:
51 *
52 * A manual TRIM is initiated by running the 'zpool trim' command. A single
53 * 'vdev_trim' thread is created for each leaf vdev, and it is responsible for
54 * managing that vdev TRIM process. This involves iterating over all the
55 * metaslabs, calculating the unallocated space ranges, and then issuing the
56 * required TRIM I/Os.
57 *
58 * While a metaslab is being actively trimmed it is not eligible to perform
59 * new allocations. After traversing all of the metaslabs the thread is
60 * terminated. Finally, both the requested options and current progress of
61 * the TRIM are regularly written to the pool. This allows the TRIM to be
62 * suspended and resumed as needed.
63 *
64 * Automatic TRIM:
65 *
66 * An automatic TRIM is enabled by setting the 'autotrim' pool property
67 * to 'on'. When enabled, a `vdev_autotrim' thread is created for each
68 * top-level (not leaf) vdev in the pool. These threads perform the same
69 * core TRIM process as a manual TRIM, but with a few key differences.
70 *
71 * 1) Automatic TRIM happens continuously in the background and operates
72 * solely on recently freed blocks (ms_trim not ms_allocatable).
73 *
74 * 2) Each thread is associated with a top-level (not leaf) vdev. This has
75 * the benefit of simplifying the threading model, it makes it easier
76 * to coordinate administrative commands, and it ensures only a single
77 * metaslab is disabled at a time. Unlike manual TRIM, this means each
78 * 'vdev_autotrim' thread is responsible for issuing TRIM I/Os for its
79 * children.
80 *
81 * 3) There is no automatic TRIM progress information stored on disk, nor
82 * is it reported by 'zpool status'.
83 *
84 * While the automatic TRIM process is highly effective it is more likely
85 * than a manual TRIM to encounter tiny ranges. Ranges less than or equal to
86 * 'zfs_trim_extent_bytes_min' (32k) are considered too small to efficiently
87 * TRIM and are skipped. This means small amounts of freed space may not
88 * be automatically trimmed.
89 *
90 * Furthermore, devices with attached hot spares and devices being actively
91 * replaced are skipped. This is done to avoid adding additional stress to
92 * a potentially unhealthy device and to minimize the required rebuild time.
93 *
94 * For this reason it may be beneficial to occasionally manually TRIM a pool
95 * even when automatic TRIM is enabled.
96 */
97
98 /*
99 * Maximum size of TRIM I/O, ranges will be chunked in to 128MiB lengths.
100 */
101 static unsigned int zfs_trim_extent_bytes_max = 128 * 1024 * 1024;
102
103 /*
104 * Minimum size of TRIM I/O, extents smaller than 32Kib will be skipped.
105 */
106 static unsigned int zfs_trim_extent_bytes_min = 32 * 1024;
107
108 /*
109 * Skip uninitialized metaslabs during the TRIM process. This option is
110 * useful for pools constructed from large thinly-provisioned devices where
111 * TRIM operations are slow. As a pool ages an increasing fraction of
112 * the pools metaslabs will be initialized progressively degrading the
113 * usefulness of this option. This setting is stored when starting a
114 * manual TRIM and will persist for the duration of the requested TRIM.
115 */
116 unsigned int zfs_trim_metaslab_skip = 0;
117
118 /*
119 * Maximum number of queued TRIM I/Os per leaf vdev. The number of
120 * concurrent TRIM I/Os issued to the device is controlled by the
121 * zfs_vdev_trim_min_active and zfs_vdev_trim_max_active module options.
122 */
123 static unsigned int zfs_trim_queue_limit = 10;
124
125 /*
126 * The minimum number of transaction groups between automatic trims of a
127 * metaslab. This setting represents a trade-off between issuing more
128 * efficient TRIM operations, by allowing them to be aggregated longer,
129 * and issuing them promptly so the trimmed space is available. Note
130 * that this value is a minimum; metaslabs can be trimmed less frequently
131 * when there are a large number of ranges which need to be trimmed.
132 *
133 * Increasing this value will allow frees to be aggregated for a longer
134 * time. This can result is larger TRIM operations, and increased memory
135 * usage in order to track the ranges to be trimmed. Decreasing this value
136 * has the opposite effect. The default value of 32 was determined though
137 * testing to be a reasonable compromise.
138 */
139 static unsigned int zfs_trim_txg_batch = 32;
140
141 /*
142 * The trim_args are a control structure which describe how a leaf vdev
143 * should be trimmed. The core elements are the vdev, the metaslab being
144 * trimmed and a range tree containing the extents to TRIM. All provided
145 * ranges must be within the metaslab.
146 */
147 typedef struct trim_args {
148 /*
149 * These fields are set by the caller of vdev_trim_ranges().
150 */
151 vdev_t *trim_vdev; /* Leaf vdev to TRIM */
152 metaslab_t *trim_msp; /* Disabled metaslab */
153 zfs_range_tree_t *trim_tree; /* TRIM ranges (in metaslab) */
154 trim_type_t trim_type; /* Manual or auto TRIM */
155 uint64_t trim_extent_bytes_max; /* Maximum TRIM I/O size */
156 uint64_t trim_extent_bytes_min; /* Minimum TRIM I/O size */
157 enum trim_flag trim_flags; /* TRIM flags (secure) */
158
159 /*
160 * These fields are updated by vdev_trim_ranges().
161 */
162 hrtime_t trim_start_time; /* Start time */
163 uint64_t trim_bytes_done; /* Bytes trimmed */
164 } trim_args_t;
165
166 /*
167 * Determines whether a vdev_trim_thread() should be stopped.
168 */
169 static boolean_t
vdev_trim_should_stop(vdev_t * vd)170 vdev_trim_should_stop(vdev_t *vd)
171 {
172 return (vd->vdev_trim_exit_wanted || !vdev_writeable(vd) ||
173 vd->vdev_detached || vd->vdev_top->vdev_removing ||
174 vd->vdev_top->vdev_rz_expanding);
175 }
176
177 /*
178 * Determines whether a vdev_autotrim_thread() should be stopped.
179 */
180 static boolean_t
vdev_autotrim_should_stop(vdev_t * tvd)181 vdev_autotrim_should_stop(vdev_t *tvd)
182 {
183 return (tvd->vdev_autotrim_exit_wanted ||
184 !vdev_writeable(tvd) || tvd->vdev_removing ||
185 tvd->vdev_rz_expanding ||
186 spa_get_autotrim(tvd->vdev_spa) == SPA_AUTOTRIM_OFF);
187 }
188
189 /*
190 * Wait for given number of kicks, return true if the wait is aborted due to
191 * vdev_autotrim_exit_wanted.
192 */
193 static boolean_t
vdev_autotrim_wait_kick(vdev_t * vd,int num_of_kick)194 vdev_autotrim_wait_kick(vdev_t *vd, int num_of_kick)
195 {
196 mutex_enter(&vd->vdev_autotrim_lock);
197 for (int i = 0; i < num_of_kick; i++) {
198 if (vd->vdev_autotrim_exit_wanted)
199 break;
200 cv_wait_idle(&vd->vdev_autotrim_kick_cv,
201 &vd->vdev_autotrim_lock);
202 }
203 boolean_t exit_wanted = vd->vdev_autotrim_exit_wanted;
204 mutex_exit(&vd->vdev_autotrim_lock);
205
206 return (exit_wanted);
207 }
208
209 /*
210 * The sync task for updating the on-disk state of a manual TRIM. This
211 * is scheduled by vdev_trim_change_state().
212 */
213 static void
vdev_trim_zap_update_sync(void * arg,dmu_tx_t * tx)214 vdev_trim_zap_update_sync(void *arg, dmu_tx_t *tx)
215 {
216 /*
217 * We pass in the guid instead of the vdev_t since the vdev may
218 * have been freed prior to the sync task being processed. This
219 * happens when a vdev is detached as we call spa_config_vdev_exit(),
220 * stop the trimming thread, schedule the sync task, and free
221 * the vdev. Later when the scheduled sync task is invoked, it would
222 * find that the vdev has been freed.
223 */
224 uint64_t guid = *(uint64_t *)arg;
225 uint64_t txg = dmu_tx_get_txg(tx);
226 kmem_free(arg, sizeof (uint64_t));
227
228 vdev_t *vd = spa_lookup_by_guid(tx->tx_pool->dp_spa, guid, B_FALSE);
229 if (vd == NULL || vd->vdev_top->vdev_removing ||
230 !vdev_is_concrete(vd) || vd->vdev_top->vdev_rz_expanding)
231 return;
232
233 uint64_t last_offset = vd->vdev_trim_offset[txg & TXG_MASK];
234 vd->vdev_trim_offset[txg & TXG_MASK] = 0;
235
236 VERIFY3U(vd->vdev_leaf_zap, !=, 0);
237
238 objset_t *mos = vd->vdev_spa->spa_meta_objset;
239
240 if (last_offset > 0 || vd->vdev_trim_last_offset == UINT64_MAX) {
241
242 if (vd->vdev_trim_last_offset == UINT64_MAX)
243 last_offset = 0;
244
245 vd->vdev_trim_last_offset = last_offset;
246 VERIFY0(zap_update(mos, vd->vdev_leaf_zap,
247 VDEV_LEAF_ZAP_TRIM_LAST_OFFSET,
248 sizeof (last_offset), 1, &last_offset, tx));
249 }
250
251 if (vd->vdev_trim_action_time > 0) {
252 uint64_t val = (uint64_t)vd->vdev_trim_action_time;
253 VERIFY0(zap_update(mos, vd->vdev_leaf_zap,
254 VDEV_LEAF_ZAP_TRIM_ACTION_TIME, sizeof (val),
255 1, &val, tx));
256 }
257
258 if (vd->vdev_trim_rate > 0) {
259 uint64_t rate = (uint64_t)vd->vdev_trim_rate;
260
261 if (rate == UINT64_MAX)
262 rate = 0;
263
264 VERIFY0(zap_update(mos, vd->vdev_leaf_zap,
265 VDEV_LEAF_ZAP_TRIM_RATE, sizeof (rate), 1, &rate, tx));
266 }
267
268 uint64_t partial = vd->vdev_trim_partial;
269 if (partial == UINT64_MAX)
270 partial = 0;
271
272 VERIFY0(zap_update(mos, vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_PARTIAL,
273 sizeof (partial), 1, &partial, tx));
274
275 uint64_t secure = vd->vdev_trim_secure;
276 if (secure == UINT64_MAX)
277 secure = 0;
278
279 VERIFY0(zap_update(mos, vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_SECURE,
280 sizeof (secure), 1, &secure, tx));
281
282
283 uint64_t trim_state = vd->vdev_trim_state;
284 VERIFY0(zap_update(mos, vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_STATE,
285 sizeof (trim_state), 1, &trim_state, tx));
286 }
287
288 /*
289 * Update the on-disk state of a manual TRIM. This is called to request
290 * that a TRIM be started/suspended/canceled, or to change one of the
291 * TRIM options (partial, secure, rate).
292 */
293 static void
vdev_trim_change_state(vdev_t * vd,vdev_trim_state_t new_state,uint64_t rate,boolean_t partial,boolean_t secure)294 vdev_trim_change_state(vdev_t *vd, vdev_trim_state_t new_state,
295 uint64_t rate, boolean_t partial, boolean_t secure)
296 {
297 ASSERT(MUTEX_HELD(&vd->vdev_trim_lock));
298 spa_t *spa = vd->vdev_spa;
299
300 if (new_state == vd->vdev_trim_state)
301 return;
302
303 /*
304 * Copy the vd's guid, this will be freed by the sync task.
305 */
306 uint64_t *guid = kmem_zalloc(sizeof (uint64_t), KM_SLEEP);
307 *guid = vd->vdev_guid;
308
309 /*
310 * If we're suspending, then preserve the original start time.
311 */
312 if (vd->vdev_trim_state != VDEV_TRIM_SUSPENDED) {
313 vd->vdev_trim_action_time = gethrestime_sec();
314 }
315
316 /*
317 * If we're activating, then preserve the requested rate and trim
318 * method. Setting the last offset and rate to UINT64_MAX is used
319 * as a sentinel to indicate they should be reset to default values.
320 */
321 if (new_state == VDEV_TRIM_ACTIVE) {
322 if (vd->vdev_trim_state == VDEV_TRIM_COMPLETE ||
323 vd->vdev_trim_state == VDEV_TRIM_CANCELED) {
324 vd->vdev_trim_last_offset = UINT64_MAX;
325 vd->vdev_trim_rate = UINT64_MAX;
326 vd->vdev_trim_partial = UINT64_MAX;
327 vd->vdev_trim_secure = UINT64_MAX;
328 }
329
330 if (rate != 0)
331 vd->vdev_trim_rate = rate;
332
333 if (partial != 0)
334 vd->vdev_trim_partial = partial;
335
336 if (secure != 0)
337 vd->vdev_trim_secure = secure;
338 }
339
340 vdev_trim_state_t old_state = vd->vdev_trim_state;
341 boolean_t resumed = (old_state == VDEV_TRIM_SUSPENDED);
342 vd->vdev_trim_state = new_state;
343
344 dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
345 VERIFY0(dmu_tx_assign(tx, DMU_TX_WAIT));
346 dsl_sync_task_nowait(spa_get_dsl(spa), vdev_trim_zap_update_sync,
347 guid, tx);
348
349 switch (new_state) {
350 case VDEV_TRIM_ACTIVE:
351 spa_event_notify(spa, vd, NULL,
352 resumed ? ESC_ZFS_TRIM_RESUME : ESC_ZFS_TRIM_START);
353 spa_history_log_internal(spa, "trim", tx,
354 "vdev=%s activated", vd->vdev_path);
355 break;
356 case VDEV_TRIM_SUSPENDED:
357 spa_event_notify(spa, vd, NULL, ESC_ZFS_TRIM_SUSPEND);
358 spa_history_log_internal(spa, "trim", tx,
359 "vdev=%s suspended", vd->vdev_path);
360 break;
361 case VDEV_TRIM_CANCELED:
362 if (old_state == VDEV_TRIM_ACTIVE ||
363 old_state == VDEV_TRIM_SUSPENDED) {
364 spa_event_notify(spa, vd, NULL, ESC_ZFS_TRIM_CANCEL);
365 spa_history_log_internal(spa, "trim", tx,
366 "vdev=%s canceled", vd->vdev_path);
367 }
368 break;
369 case VDEV_TRIM_COMPLETE:
370 spa_event_notify(spa, vd, NULL, ESC_ZFS_TRIM_FINISH);
371 spa_history_log_internal(spa, "trim", tx,
372 "vdev=%s complete", vd->vdev_path);
373 break;
374 default:
375 panic("invalid state %llu", (unsigned long long)new_state);
376 }
377
378 dmu_tx_commit(tx);
379
380 if (new_state != VDEV_TRIM_ACTIVE)
381 spa_notify_waiters(spa);
382 }
383
384 /*
385 * The zio_done_func_t done callback for each manual TRIM issued. It is
386 * responsible for updating the TRIM stats, reissuing failed TRIM I/Os,
387 * and limiting the number of in flight TRIM I/Os.
388 */
389 static void
vdev_trim_cb(zio_t * zio)390 vdev_trim_cb(zio_t *zio)
391 {
392 vdev_t *vd = zio->io_vd;
393
394 mutex_enter(&vd->vdev_trim_io_lock);
395 if (zio->io_error == ENXIO && !vdev_writeable(vd)) {
396 /*
397 * The I/O failed because the vdev was unavailable; roll the
398 * last offset back. (This works because spa_sync waits on
399 * spa_txg_zio before it runs sync tasks.)
400 */
401 uint64_t *offset =
402 &vd->vdev_trim_offset[zio->io_txg & TXG_MASK];
403 *offset = MIN(*offset, zio->io_offset);
404 } else {
405 if (zio->io_error != 0) {
406 vd->vdev_stat.vs_trim_errors++;
407 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_MANUAL,
408 0, 0, 0, 0, 1, zio->io_orig_size);
409 } else {
410 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_MANUAL,
411 1, zio->io_orig_size, 0, 0, 0, 0);
412 }
413
414 vd->vdev_trim_bytes_done += zio->io_orig_size;
415 }
416
417 ASSERT3U(vd->vdev_trim_inflight[TRIM_TYPE_MANUAL], >, 0);
418 vd->vdev_trim_inflight[TRIM_TYPE_MANUAL]--;
419 cv_broadcast(&vd->vdev_trim_io_cv);
420 mutex_exit(&vd->vdev_trim_io_lock);
421
422 spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
423 }
424
425 /*
426 * The zio_done_func_t done callback for each automatic TRIM issued. It
427 * is responsible for updating the TRIM stats and limiting the number of
428 * in flight TRIM I/Os. Automatic TRIM I/Os are best effort and are
429 * never reissued on failure.
430 */
431 static void
vdev_autotrim_cb(zio_t * zio)432 vdev_autotrim_cb(zio_t *zio)
433 {
434 vdev_t *vd = zio->io_vd;
435
436 mutex_enter(&vd->vdev_trim_io_lock);
437
438 if (zio->io_error != 0) {
439 vd->vdev_stat.vs_trim_errors++;
440 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_AUTO,
441 0, 0, 0, 0, 1, zio->io_orig_size);
442 } else {
443 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_AUTO,
444 1, zio->io_orig_size, 0, 0, 0, 0);
445 }
446
447 ASSERT3U(vd->vdev_trim_inflight[TRIM_TYPE_AUTO], >, 0);
448 vd->vdev_trim_inflight[TRIM_TYPE_AUTO]--;
449 cv_broadcast(&vd->vdev_trim_io_cv);
450 mutex_exit(&vd->vdev_trim_io_lock);
451
452 spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
453 }
454
455 /*
456 * The zio_done_func_t done callback for each TRIM issued via
457 * vdev_trim_simple(). It is responsible for updating the TRIM stats and
458 * limiting the number of in flight TRIM I/Os. Simple TRIM I/Os are best
459 * effort and are never reissued on failure.
460 */
461 static void
vdev_trim_simple_cb(zio_t * zio)462 vdev_trim_simple_cb(zio_t *zio)
463 {
464 vdev_t *vd = zio->io_vd;
465
466 mutex_enter(&vd->vdev_trim_io_lock);
467
468 if (zio->io_error != 0) {
469 vd->vdev_stat.vs_trim_errors++;
470 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_SIMPLE,
471 0, 0, 0, 0, 1, zio->io_orig_size);
472 } else {
473 spa_iostats_trim_add(vd->vdev_spa, TRIM_TYPE_SIMPLE,
474 1, zio->io_orig_size, 0, 0, 0, 0);
475 }
476
477 ASSERT3U(vd->vdev_trim_inflight[TRIM_TYPE_SIMPLE], >, 0);
478 vd->vdev_trim_inflight[TRIM_TYPE_SIMPLE]--;
479 cv_broadcast(&vd->vdev_trim_io_cv);
480 mutex_exit(&vd->vdev_trim_io_lock);
481
482 spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
483 }
484 /*
485 * Returns the average trim rate in bytes/sec for the ta->trim_vdev.
486 */
487 static uint64_t
vdev_trim_calculate_rate(trim_args_t * ta)488 vdev_trim_calculate_rate(trim_args_t *ta)
489 {
490 return (ta->trim_bytes_done * 1000 /
491 (NSEC2MSEC(gethrtime() - ta->trim_start_time) + 1));
492 }
493
494 /*
495 * Issues a physical TRIM and takes care of rate limiting (bytes/sec)
496 * and number of concurrent TRIM I/Os.
497 */
498 static int
vdev_trim_range(trim_args_t * ta,uint64_t start,uint64_t size)499 vdev_trim_range(trim_args_t *ta, uint64_t start, uint64_t size)
500 {
501 vdev_t *vd = ta->trim_vdev;
502 spa_t *spa = vd->vdev_spa;
503 void *cb;
504
505 mutex_enter(&vd->vdev_trim_io_lock);
506
507 /*
508 * Limit manual TRIM I/Os to the requested rate. This does not
509 * apply to automatic TRIM since no per vdev rate can be specified.
510 */
511 if (ta->trim_type == TRIM_TYPE_MANUAL) {
512 while (vd->vdev_trim_rate != 0 && !vdev_trim_should_stop(vd) &&
513 vdev_trim_calculate_rate(ta) > vd->vdev_trim_rate) {
514 cv_timedwait_idle(&vd->vdev_trim_io_cv,
515 &vd->vdev_trim_io_lock, ddi_get_lbolt() +
516 MSEC_TO_TICK(10));
517 }
518 }
519 ta->trim_bytes_done += size;
520
521 /* Limit in flight trimming I/Os */
522 while (vd->vdev_trim_inflight[0] + vd->vdev_trim_inflight[1] +
523 vd->vdev_trim_inflight[2] >= zfs_trim_queue_limit) {
524 cv_wait(&vd->vdev_trim_io_cv, &vd->vdev_trim_io_lock);
525 }
526 vd->vdev_trim_inflight[ta->trim_type]++;
527 mutex_exit(&vd->vdev_trim_io_lock);
528
529 dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
530 VERIFY0(dmu_tx_assign(tx, DMU_TX_WAIT));
531 uint64_t txg = dmu_tx_get_txg(tx);
532
533 spa_config_enter(spa, SCL_STATE_ALL, vd, RW_READER);
534 mutex_enter(&vd->vdev_trim_lock);
535
536 if (ta->trim_type == TRIM_TYPE_MANUAL &&
537 vd->vdev_trim_offset[txg & TXG_MASK] == 0) {
538 uint64_t *guid = kmem_zalloc(sizeof (uint64_t), KM_SLEEP);
539 *guid = vd->vdev_guid;
540
541 /* This is the first write of this txg. */
542 dsl_sync_task_nowait(spa_get_dsl(spa),
543 vdev_trim_zap_update_sync, guid, tx);
544 }
545
546 /*
547 * We know the vdev_t will still be around since all consumers of
548 * vdev_free must stop the trimming first.
549 */
550 if ((ta->trim_type == TRIM_TYPE_MANUAL &&
551 vdev_trim_should_stop(vd)) ||
552 (ta->trim_type == TRIM_TYPE_AUTO &&
553 vdev_autotrim_should_stop(vd->vdev_top))) {
554 mutex_enter(&vd->vdev_trim_io_lock);
555 vd->vdev_trim_inflight[ta->trim_type]--;
556 mutex_exit(&vd->vdev_trim_io_lock);
557 spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
558 mutex_exit(&vd->vdev_trim_lock);
559 dmu_tx_commit(tx);
560 return (SET_ERROR(EINTR));
561 }
562 mutex_exit(&vd->vdev_trim_lock);
563
564 if (ta->trim_type == TRIM_TYPE_MANUAL)
565 vd->vdev_trim_offset[txg & TXG_MASK] = start + size;
566
567 if (ta->trim_type == TRIM_TYPE_MANUAL) {
568 cb = vdev_trim_cb;
569 } else if (ta->trim_type == TRIM_TYPE_AUTO) {
570 cb = vdev_autotrim_cb;
571 } else {
572 cb = vdev_trim_simple_cb;
573 }
574
575 zio_nowait(zio_trim(spa->spa_txg_zio[txg & TXG_MASK], vd,
576 start, size, cb, NULL, ZIO_PRIORITY_TRIM, ZIO_FLAG_CANFAIL,
577 ta->trim_flags));
578 /* vdev_trim_cb and vdev_autotrim_cb release SCL_STATE_ALL */
579
580 dmu_tx_commit(tx);
581
582 return (0);
583 }
584
585 /*
586 * Issues TRIM I/Os for all ranges in the provided ta->trim_tree range tree.
587 * Additional parameters describing how the TRIM should be performed must
588 * be set in the trim_args structure. See the trim_args definition for
589 * additional information.
590 */
591 static int
vdev_trim_ranges(trim_args_t * ta)592 vdev_trim_ranges(trim_args_t *ta)
593 {
594 vdev_t *vd = ta->trim_vdev;
595 zfs_btree_t *t = &ta->trim_tree->rt_root;
596 zfs_btree_index_t idx;
597 uint64_t extent_bytes_max = ta->trim_extent_bytes_max;
598 uint64_t extent_bytes_min = ta->trim_extent_bytes_min;
599 spa_t *spa = vd->vdev_spa;
600 int error = 0;
601
602 ta->trim_start_time = gethrtime();
603 ta->trim_bytes_done = 0;
604
605 for (zfs_range_seg_t *rs = zfs_btree_first(t, &idx); rs != NULL;
606 rs = zfs_btree_next(t, &idx, &idx)) {
607 uint64_t size = zfs_rs_get_end(rs, ta->trim_tree) -
608 zfs_rs_get_start(rs, ta->trim_tree);
609
610 if (extent_bytes_min && size < extent_bytes_min) {
611 spa_iostats_trim_add(spa, ta->trim_type,
612 0, 0, 1, size, 0, 0);
613 continue;
614 }
615
616 /* Split range into legally-sized physical chunks */
617 uint64_t writes_required = ((size - 1) / extent_bytes_max) + 1;
618
619 for (uint64_t w = 0; w < writes_required; w++) {
620 error = vdev_trim_range(ta, VDEV_LABEL_START_SIZE +
621 zfs_rs_get_start(rs, ta->trim_tree) +
622 (w *extent_bytes_max), MIN(size -
623 (w * extent_bytes_max), extent_bytes_max));
624 if (error != 0) {
625 goto done;
626 }
627 }
628 }
629
630 done:
631 /*
632 * Make sure all TRIMs for this metaslab have completed before
633 * returning. TRIM zios have lower priority over regular or syncing
634 * zios, so all TRIM zios for this metaslab must complete before the
635 * metaslab is re-enabled. Otherwise it's possible write zios to
636 * this metaslab could cut ahead of still queued TRIM zios for this
637 * metaslab causing corruption if the ranges overlap.
638 */
639 mutex_enter(&vd->vdev_trim_io_lock);
640 while (vd->vdev_trim_inflight[0] > 0) {
641 cv_wait(&vd->vdev_trim_io_cv, &vd->vdev_trim_io_lock);
642 }
643 mutex_exit(&vd->vdev_trim_io_lock);
644
645 return (error);
646 }
647
648 static void
vdev_trim_xlate_last_rs_end(void * arg,zfs_range_seg64_t * physical_rs)649 vdev_trim_xlate_last_rs_end(void *arg, zfs_range_seg64_t *physical_rs)
650 {
651 uint64_t *last_rs_end = (uint64_t *)arg;
652
653 if (physical_rs->rs_end > *last_rs_end)
654 *last_rs_end = physical_rs->rs_end;
655 }
656
657 static void
vdev_trim_xlate_progress(void * arg,zfs_range_seg64_t * physical_rs)658 vdev_trim_xlate_progress(void *arg, zfs_range_seg64_t *physical_rs)
659 {
660 vdev_t *vd = (vdev_t *)arg;
661
662 uint64_t size = physical_rs->rs_end - physical_rs->rs_start;
663 vd->vdev_trim_bytes_est += size;
664
665 if (vd->vdev_trim_last_offset >= physical_rs->rs_end) {
666 vd->vdev_trim_bytes_done += size;
667 } else if (vd->vdev_trim_last_offset > physical_rs->rs_start &&
668 vd->vdev_trim_last_offset <= physical_rs->rs_end) {
669 vd->vdev_trim_bytes_done +=
670 vd->vdev_trim_last_offset - physical_rs->rs_start;
671 }
672 }
673
674 /*
675 * Calculates the completion percentage of a manual TRIM.
676 */
677 static void
vdev_trim_calculate_progress(vdev_t * vd)678 vdev_trim_calculate_progress(vdev_t *vd)
679 {
680 ASSERT(spa_config_held(vd->vdev_spa, SCL_CONFIG, RW_READER) ||
681 spa_config_held(vd->vdev_spa, SCL_CONFIG, RW_WRITER));
682 ASSERT(vd->vdev_leaf_zap != 0);
683
684 vd->vdev_trim_bytes_est = 0;
685 vd->vdev_trim_bytes_done = 0;
686
687 for (uint64_t i = 0; i < vd->vdev_top->vdev_ms_count; i++) {
688 metaslab_t *msp = vd->vdev_top->vdev_ms[i];
689 mutex_enter(&msp->ms_lock);
690
691 uint64_t ms_free = (msp->ms_size -
692 metaslab_allocated_space(msp)) /
693 vdev_get_ndisks(vd->vdev_top);
694
695 /*
696 * Convert the metaslab range to a physical range
697 * on our vdev. We use this to determine if we are
698 * in the middle of this metaslab range.
699 */
700 zfs_range_seg64_t logical_rs, physical_rs, remain_rs;
701 logical_rs.rs_start = msp->ms_start;
702 logical_rs.rs_end = msp->ms_start + msp->ms_size;
703
704 /* Metaslab space after this offset has not been trimmed. */
705 vdev_xlate(vd, &logical_rs, &physical_rs, &remain_rs);
706 if (vd->vdev_trim_last_offset <= physical_rs.rs_start) {
707 vd->vdev_trim_bytes_est += ms_free;
708 mutex_exit(&msp->ms_lock);
709 continue;
710 }
711
712 /* Metaslab space before this offset has been trimmed */
713 uint64_t last_rs_end = physical_rs.rs_end;
714 if (!vdev_xlate_is_empty(&remain_rs)) {
715 vdev_xlate_walk(vd, &remain_rs,
716 vdev_trim_xlate_last_rs_end, &last_rs_end);
717 }
718
719 if (vd->vdev_trim_last_offset > last_rs_end) {
720 vd->vdev_trim_bytes_done += ms_free;
721 vd->vdev_trim_bytes_est += ms_free;
722 mutex_exit(&msp->ms_lock);
723 continue;
724 }
725
726 /*
727 * If we get here, we're in the middle of trimming this
728 * metaslab. Load it and walk the free tree for more
729 * accurate progress estimation.
730 */
731 VERIFY0(metaslab_load(msp));
732
733 zfs_range_tree_t *rt = msp->ms_allocatable;
734 zfs_btree_t *bt = &rt->rt_root;
735 zfs_btree_index_t idx;
736 for (zfs_range_seg_t *rs = zfs_btree_first(bt, &idx);
737 rs != NULL; rs = zfs_btree_next(bt, &idx, &idx)) {
738 logical_rs.rs_start = zfs_rs_get_start(rs, rt);
739 logical_rs.rs_end = zfs_rs_get_end(rs, rt);
740
741 vdev_xlate_walk(vd, &logical_rs,
742 vdev_trim_xlate_progress, vd);
743 }
744 mutex_exit(&msp->ms_lock);
745 }
746 }
747
748 /*
749 * Load from disk the vdev's manual TRIM information. This includes the
750 * state, progress, and options provided when initiating the manual TRIM.
751 */
752 static int
vdev_trim_load(vdev_t * vd)753 vdev_trim_load(vdev_t *vd)
754 {
755 int err = 0;
756 ASSERT(spa_config_held(vd->vdev_spa, SCL_CONFIG, RW_READER) ||
757 spa_config_held(vd->vdev_spa, SCL_CONFIG, RW_WRITER));
758 ASSERT(vd->vdev_leaf_zap != 0);
759
760 if (vd->vdev_trim_state == VDEV_TRIM_ACTIVE ||
761 vd->vdev_trim_state == VDEV_TRIM_SUSPENDED) {
762 err = zap_lookup(vd->vdev_spa->spa_meta_objset,
763 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_LAST_OFFSET,
764 sizeof (vd->vdev_trim_last_offset), 1,
765 &vd->vdev_trim_last_offset);
766 if (err == ENOENT) {
767 vd->vdev_trim_last_offset = 0;
768 err = 0;
769 }
770
771 if (err == 0) {
772 err = zap_lookup(vd->vdev_spa->spa_meta_objset,
773 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_RATE,
774 sizeof (vd->vdev_trim_rate), 1,
775 &vd->vdev_trim_rate);
776 if (err == ENOENT) {
777 vd->vdev_trim_rate = 0;
778 err = 0;
779 }
780 }
781
782 if (err == 0) {
783 err = zap_lookup(vd->vdev_spa->spa_meta_objset,
784 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_PARTIAL,
785 sizeof (vd->vdev_trim_partial), 1,
786 &vd->vdev_trim_partial);
787 if (err == ENOENT) {
788 vd->vdev_trim_partial = 0;
789 err = 0;
790 }
791 }
792
793 if (err == 0) {
794 err = zap_lookup(vd->vdev_spa->spa_meta_objset,
795 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_SECURE,
796 sizeof (vd->vdev_trim_secure), 1,
797 &vd->vdev_trim_secure);
798 if (err == ENOENT) {
799 vd->vdev_trim_secure = 0;
800 err = 0;
801 }
802 }
803 }
804
805 vdev_trim_calculate_progress(vd);
806
807 return (err);
808 }
809
810 static void
vdev_trim_xlate_range_add(void * arg,zfs_range_seg64_t * physical_rs)811 vdev_trim_xlate_range_add(void *arg, zfs_range_seg64_t *physical_rs)
812 {
813 trim_args_t *ta = arg;
814 vdev_t *vd = ta->trim_vdev;
815
816 /*
817 * Only a manual trim will be traversing the vdev sequentially.
818 * For an auto trim all valid ranges should be added.
819 */
820 if (ta->trim_type == TRIM_TYPE_MANUAL) {
821
822 /* Only add segments that we have not visited yet */
823 if (physical_rs->rs_end <= vd->vdev_trim_last_offset)
824 return;
825
826 /* Pick up where we left off mid-range. */
827 if (vd->vdev_trim_last_offset > physical_rs->rs_start) {
828 ASSERT3U(physical_rs->rs_end, >,
829 vd->vdev_trim_last_offset);
830 physical_rs->rs_start = vd->vdev_trim_last_offset;
831 }
832 }
833
834 ASSERT3U(physical_rs->rs_end, >, physical_rs->rs_start);
835
836 zfs_range_tree_add(ta->trim_tree, physical_rs->rs_start,
837 physical_rs->rs_end - physical_rs->rs_start);
838 }
839
840 /*
841 * Convert the logical range into physical ranges and add them to the
842 * range tree passed in the trim_args_t.
843 */
844 static void
vdev_trim_range_add(void * arg,uint64_t start,uint64_t size)845 vdev_trim_range_add(void *arg, uint64_t start, uint64_t size)
846 {
847 trim_args_t *ta = arg;
848 vdev_t *vd = ta->trim_vdev;
849 zfs_range_seg64_t logical_rs;
850 logical_rs.rs_start = start;
851 logical_rs.rs_end = start + size;
852
853 /*
854 * Every range to be trimmed must be part of ms_allocatable.
855 * When ZFS_DEBUG_TRIM is set load the metaslab to verify this
856 * is always the case.
857 */
858 if (zfs_flags & ZFS_DEBUG_TRIM) {
859 metaslab_t *msp = ta->trim_msp;
860 VERIFY0(metaslab_load(msp));
861 VERIFY3B(msp->ms_loaded, ==, B_TRUE);
862 VERIFY(zfs_range_tree_contains(msp->ms_allocatable, start,
863 size));
864 }
865
866 ASSERT(vd->vdev_ops->vdev_op_leaf);
867 vdev_xlate_walk(vd, &logical_rs, vdev_trim_xlate_range_add, arg);
868 }
869
870 /*
871 * Each manual TRIM thread is responsible for trimming the unallocated
872 * space for each leaf vdev. This is accomplished by sequentially iterating
873 * over its top-level metaslabs and issuing TRIM I/O for the space described
874 * by its ms_allocatable. While a metaslab is undergoing trimming it is
875 * not eligible for new allocations.
876 */
877 static __attribute__((noreturn)) void
vdev_trim_thread(void * arg)878 vdev_trim_thread(void *arg)
879 {
880 vdev_t *vd = arg;
881 spa_t *spa = vd->vdev_spa;
882 trim_args_t ta;
883 int error = 0;
884
885 /*
886 * The VDEV_LEAF_ZAP_TRIM_* entries may have been updated by
887 * vdev_trim(). Wait for the updated values to be reflected
888 * in the zap in order to start with the requested settings.
889 */
890 txg_wait_synced(spa_get_dsl(vd->vdev_spa), 0);
891
892 ASSERT(vdev_is_concrete(vd));
893 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
894
895 vd->vdev_trim_last_offset = 0;
896 vd->vdev_trim_rate = 0;
897 vd->vdev_trim_partial = 0;
898 vd->vdev_trim_secure = 0;
899
900 VERIFY0(vdev_trim_load(vd));
901
902 ta.trim_vdev = vd;
903 ta.trim_extent_bytes_max = zfs_trim_extent_bytes_max;
904 ta.trim_extent_bytes_min = zfs_trim_extent_bytes_min;
905 ta.trim_tree = zfs_range_tree_create(NULL, ZFS_RANGE_SEG64, NULL, 0, 0);
906 ta.trim_type = TRIM_TYPE_MANUAL;
907 ta.trim_flags = 0;
908
909 /*
910 * When a secure TRIM has been requested infer that the intent
911 * is that everything must be trimmed. Override the default
912 * minimum TRIM size to prevent ranges from being skipped.
913 */
914 if (vd->vdev_trim_secure) {
915 ta.trim_flags |= ZIO_TRIM_SECURE;
916 ta.trim_extent_bytes_min = SPA_MINBLOCKSIZE;
917 }
918
919 uint64_t ms_count = 0;
920 for (uint64_t i = 0; !vd->vdev_detached &&
921 i < vd->vdev_top->vdev_ms_count; i++) {
922 metaslab_t *msp = vd->vdev_top->vdev_ms[i];
923
924 /*
925 * If we've expanded the top-level vdev or it's our
926 * first pass, calculate our progress.
927 */
928 if (vd->vdev_top->vdev_ms_count != ms_count) {
929 vdev_trim_calculate_progress(vd);
930 ms_count = vd->vdev_top->vdev_ms_count;
931 }
932
933 spa_config_exit(spa, SCL_CONFIG, FTAG);
934 metaslab_disable(msp);
935 mutex_enter(&msp->ms_lock);
936 VERIFY0(metaslab_load(msp));
937
938 /*
939 * If a partial TRIM was requested skip metaslabs which have
940 * never been initialized and thus have never been written.
941 */
942 if (msp->ms_sm == NULL && vd->vdev_trim_partial) {
943 mutex_exit(&msp->ms_lock);
944 metaslab_enable(msp, B_FALSE, B_FALSE);
945 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
946 vdev_trim_calculate_progress(vd);
947 continue;
948 }
949
950 ta.trim_msp = msp;
951 zfs_range_tree_walk(msp->ms_allocatable, vdev_trim_range_add,
952 &ta);
953 zfs_range_tree_vacate(msp->ms_trim, NULL, NULL);
954 mutex_exit(&msp->ms_lock);
955
956 error = vdev_trim_ranges(&ta);
957 metaslab_enable(msp, B_TRUE, B_FALSE);
958 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
959
960 zfs_range_tree_vacate(ta.trim_tree, NULL, NULL);
961 if (error != 0)
962 break;
963 }
964
965 spa_config_exit(spa, SCL_CONFIG, FTAG);
966
967 zfs_range_tree_destroy(ta.trim_tree);
968
969 mutex_enter(&vd->vdev_trim_lock);
970 if (!vd->vdev_trim_exit_wanted) {
971 if (vdev_writeable(vd)) {
972 vdev_trim_change_state(vd, VDEV_TRIM_COMPLETE,
973 vd->vdev_trim_rate, vd->vdev_trim_partial,
974 vd->vdev_trim_secure);
975 } else if (vd->vdev_faulted) {
976 vdev_trim_change_state(vd, VDEV_TRIM_CANCELED,
977 vd->vdev_trim_rate, vd->vdev_trim_partial,
978 vd->vdev_trim_secure);
979 }
980 }
981 ASSERT(vd->vdev_trim_thread != NULL || vd->vdev_trim_inflight[0] == 0);
982
983 /*
984 * Drop the vdev_trim_lock while we sync out the txg since it's
985 * possible that a device might be trying to come online and must
986 * check to see if it needs to restart a trim. That thread will be
987 * holding the spa_config_lock which would prevent the txg_wait_synced
988 * from completing.
989 */
990 mutex_exit(&vd->vdev_trim_lock);
991 txg_wait_synced(spa_get_dsl(spa), 0);
992 mutex_enter(&vd->vdev_trim_lock);
993
994 vd->vdev_trim_thread = NULL;
995 cv_broadcast(&vd->vdev_trim_cv);
996 mutex_exit(&vd->vdev_trim_lock);
997
998 thread_exit();
999 }
1000
1001 /*
1002 * Initiates a manual TRIM for the vdev_t. Callers must hold vdev_trim_lock,
1003 * the vdev_t must be a leaf and cannot already be manually trimming.
1004 */
1005 void
vdev_trim(vdev_t * vd,uint64_t rate,boolean_t partial,boolean_t secure)1006 vdev_trim(vdev_t *vd, uint64_t rate, boolean_t partial, boolean_t secure)
1007 {
1008 ASSERT(MUTEX_HELD(&vd->vdev_trim_lock));
1009 ASSERT(vd->vdev_ops->vdev_op_leaf);
1010 ASSERT(vdev_is_concrete(vd));
1011 ASSERT3P(vd->vdev_trim_thread, ==, NULL);
1012 ASSERT(!vd->vdev_detached);
1013 ASSERT(!vd->vdev_trim_exit_wanted);
1014 ASSERT(!vd->vdev_top->vdev_removing);
1015 ASSERT(!vd->vdev_rz_expanding);
1016
1017 vdev_trim_change_state(vd, VDEV_TRIM_ACTIVE, rate, partial, secure);
1018 vd->vdev_trim_thread = thread_create(NULL, 0,
1019 vdev_trim_thread, vd, 0, &p0, TS_RUN, maxclsyspri);
1020 }
1021
1022 /*
1023 * Wait for the trimming thread to be terminated (canceled or stopped).
1024 */
1025 static void
vdev_trim_stop_wait_impl(vdev_t * vd)1026 vdev_trim_stop_wait_impl(vdev_t *vd)
1027 {
1028 ASSERT(MUTEX_HELD(&vd->vdev_trim_lock));
1029
1030 while (vd->vdev_trim_thread != NULL)
1031 cv_wait(&vd->vdev_trim_cv, &vd->vdev_trim_lock);
1032
1033 ASSERT3P(vd->vdev_trim_thread, ==, NULL);
1034 vd->vdev_trim_exit_wanted = B_FALSE;
1035 }
1036
1037 /*
1038 * Wait for vdev trim threads which were listed to cleanly exit.
1039 */
1040 void
vdev_trim_stop_wait(spa_t * spa,list_t * vd_list)1041 vdev_trim_stop_wait(spa_t *spa, list_t *vd_list)
1042 {
1043 (void) spa;
1044 vdev_t *vd;
1045
1046 ASSERT(MUTEX_HELD(&spa_namespace_lock) ||
1047 spa->spa_export_thread == curthread);
1048
1049 while ((vd = list_remove_head(vd_list)) != NULL) {
1050 mutex_enter(&vd->vdev_trim_lock);
1051 vdev_trim_stop_wait_impl(vd);
1052 mutex_exit(&vd->vdev_trim_lock);
1053 }
1054 }
1055
1056 /*
1057 * Stop trimming a device, with the resultant trimming state being tgt_state.
1058 * For blocking behavior pass NULL for vd_list. Otherwise, when a list_t is
1059 * provided the stopping vdev is inserted in to the list. Callers are then
1060 * required to call vdev_trim_stop_wait() to block for all the trim threads
1061 * to exit. The caller must hold vdev_trim_lock and must not be writing to
1062 * the spa config, as the trimming thread may try to enter the config as a
1063 * reader before exiting.
1064 */
1065 void
vdev_trim_stop(vdev_t * vd,vdev_trim_state_t tgt_state,list_t * vd_list)1066 vdev_trim_stop(vdev_t *vd, vdev_trim_state_t tgt_state, list_t *vd_list)
1067 {
1068 ASSERT(!spa_config_held(vd->vdev_spa, SCL_CONFIG|SCL_STATE, RW_WRITER));
1069 ASSERT(MUTEX_HELD(&vd->vdev_trim_lock));
1070 ASSERT(vd->vdev_ops->vdev_op_leaf);
1071 ASSERT(vdev_is_concrete(vd));
1072
1073 /*
1074 * Allow cancel requests to proceed even if the trim thread has
1075 * stopped.
1076 */
1077 if (vd->vdev_trim_thread == NULL && tgt_state != VDEV_TRIM_CANCELED)
1078 return;
1079
1080 vdev_trim_change_state(vd, tgt_state, 0, 0, 0);
1081 vd->vdev_trim_exit_wanted = B_TRUE;
1082
1083 if (vd_list == NULL) {
1084 vdev_trim_stop_wait_impl(vd);
1085 } else {
1086 ASSERT(MUTEX_HELD(&spa_namespace_lock) ||
1087 vd->vdev_spa->spa_export_thread == curthread);
1088 list_insert_tail(vd_list, vd);
1089 }
1090 }
1091
1092 /*
1093 * Requests that all listed vdevs stop trimming.
1094 */
1095 static void
vdev_trim_stop_all_impl(vdev_t * vd,vdev_trim_state_t tgt_state,list_t * vd_list)1096 vdev_trim_stop_all_impl(vdev_t *vd, vdev_trim_state_t tgt_state,
1097 list_t *vd_list)
1098 {
1099 if (vd->vdev_ops->vdev_op_leaf && vdev_is_concrete(vd)) {
1100 mutex_enter(&vd->vdev_trim_lock);
1101 vdev_trim_stop(vd, tgt_state, vd_list);
1102 mutex_exit(&vd->vdev_trim_lock);
1103 return;
1104 }
1105
1106 for (uint64_t i = 0; i < vd->vdev_children; i++) {
1107 vdev_trim_stop_all_impl(vd->vdev_child[i], tgt_state,
1108 vd_list);
1109 }
1110 }
1111
1112 /*
1113 * Convenience function to stop trimming of a vdev tree and set all trim
1114 * thread pointers to NULL.
1115 */
1116 void
vdev_trim_stop_all(vdev_t * vd,vdev_trim_state_t tgt_state)1117 vdev_trim_stop_all(vdev_t *vd, vdev_trim_state_t tgt_state)
1118 {
1119 spa_t *spa = vd->vdev_spa;
1120 list_t vd_list;
1121 vdev_t *vd_l2cache;
1122
1123 ASSERT(MUTEX_HELD(&spa_namespace_lock) ||
1124 spa->spa_export_thread == curthread);
1125
1126 list_create(&vd_list, sizeof (vdev_t),
1127 offsetof(vdev_t, vdev_trim_node));
1128
1129 vdev_trim_stop_all_impl(vd, tgt_state, &vd_list);
1130
1131 /*
1132 * Iterate over cache devices and request stop trimming the
1133 * whole device in case we export the pool or remove the cache
1134 * device prematurely.
1135 */
1136 for (int i = 0; i < spa->spa_l2cache.sav_count; i++) {
1137 vd_l2cache = spa->spa_l2cache.sav_vdevs[i];
1138 vdev_trim_stop_all_impl(vd_l2cache, tgt_state, &vd_list);
1139 }
1140
1141 vdev_trim_stop_wait(spa, &vd_list);
1142
1143 if (vd->vdev_spa->spa_sync_on) {
1144 /* Make sure that our state has been synced to disk */
1145 txg_wait_synced(spa_get_dsl(vd->vdev_spa), 0);
1146 }
1147
1148 list_destroy(&vd_list);
1149 }
1150
1151 /*
1152 * Conditionally restarts a manual TRIM given its on-disk state.
1153 */
1154 void
vdev_trim_restart(vdev_t * vd)1155 vdev_trim_restart(vdev_t *vd)
1156 {
1157 ASSERT(MUTEX_HELD(&spa_namespace_lock) ||
1158 vd->vdev_spa->spa_load_thread == curthread);
1159 ASSERT(!spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));
1160
1161 if (vd->vdev_leaf_zap != 0) {
1162 mutex_enter(&vd->vdev_trim_lock);
1163 uint64_t trim_state = VDEV_TRIM_NONE;
1164 int err = zap_lookup(vd->vdev_spa->spa_meta_objset,
1165 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_STATE,
1166 sizeof (trim_state), 1, &trim_state);
1167 ASSERT(err == 0 || err == ENOENT);
1168 vd->vdev_trim_state = trim_state;
1169
1170 uint64_t timestamp = 0;
1171 err = zap_lookup(vd->vdev_spa->spa_meta_objset,
1172 vd->vdev_leaf_zap, VDEV_LEAF_ZAP_TRIM_ACTION_TIME,
1173 sizeof (timestamp), 1, ×tamp);
1174 ASSERT(err == 0 || err == ENOENT);
1175 vd->vdev_trim_action_time = timestamp;
1176
1177 if ((vd->vdev_trim_state == VDEV_TRIM_SUSPENDED ||
1178 vd->vdev_offline) && !vd->vdev_top->vdev_rz_expanding) {
1179 /* load progress for reporting, but don't resume */
1180 VERIFY0(vdev_trim_load(vd));
1181 } else if (vd->vdev_trim_state == VDEV_TRIM_ACTIVE &&
1182 vdev_writeable(vd) && !vd->vdev_top->vdev_removing &&
1183 !vd->vdev_top->vdev_rz_expanding &&
1184 vd->vdev_trim_thread == NULL) {
1185 VERIFY0(vdev_trim_load(vd));
1186 vdev_trim(vd, vd->vdev_trim_rate,
1187 vd->vdev_trim_partial, vd->vdev_trim_secure);
1188 }
1189
1190 mutex_exit(&vd->vdev_trim_lock);
1191 }
1192
1193 for (uint64_t i = 0; i < vd->vdev_children; i++) {
1194 vdev_trim_restart(vd->vdev_child[i]);
1195 }
1196 }
1197
1198 /*
1199 * Used by the automatic TRIM when ZFS_DEBUG_TRIM is set to verify that
1200 * every TRIM range is contained within ms_allocatable.
1201 */
1202 static void
vdev_trim_range_verify(void * arg,uint64_t start,uint64_t size)1203 vdev_trim_range_verify(void *arg, uint64_t start, uint64_t size)
1204 {
1205 trim_args_t *ta = arg;
1206 metaslab_t *msp = ta->trim_msp;
1207
1208 VERIFY3B(msp->ms_loaded, ==, B_TRUE);
1209 VERIFY3U(msp->ms_disabled, >, 0);
1210 VERIFY(zfs_range_tree_contains(msp->ms_allocatable, start, size));
1211 }
1212
1213 /*
1214 * Each automatic TRIM thread is responsible for managing the trimming of a
1215 * top-level vdev in the pool. No automatic TRIM state is maintained on-disk.
1216 *
1217 * N.B. This behavior is different from a manual TRIM where a thread
1218 * is created for each leaf vdev, instead of each top-level vdev.
1219 */
1220 static __attribute__((noreturn)) void
vdev_autotrim_thread(void * arg)1221 vdev_autotrim_thread(void *arg)
1222 {
1223 vdev_t *vd = arg;
1224 spa_t *spa = vd->vdev_spa;
1225 int shift = 0;
1226
1227 mutex_enter(&vd->vdev_autotrim_lock);
1228 ASSERT3P(vd->vdev_top, ==, vd);
1229 ASSERT3P(vd->vdev_autotrim_thread, !=, NULL);
1230 mutex_exit(&vd->vdev_autotrim_lock);
1231 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1232
1233 while (!vdev_autotrim_should_stop(vd)) {
1234 int txgs_per_trim = MAX(zfs_trim_txg_batch, 1);
1235 uint64_t extent_bytes_max = zfs_trim_extent_bytes_max;
1236 uint64_t extent_bytes_min = zfs_trim_extent_bytes_min;
1237
1238 /*
1239 * All of the metaslabs are divided in to groups of size
1240 * num_metaslabs / zfs_trim_txg_batch. Each of these groups
1241 * is composed of metaslabs which are spread evenly over the
1242 * device.
1243 *
1244 * For example, when zfs_trim_txg_batch = 32 (default) then
1245 * group 0 will contain metaslabs 0, 32, 64, ...;
1246 * group 1 will contain metaslabs 1, 33, 65, ...;
1247 * group 2 will contain metaslabs 2, 34, 66, ...; and so on.
1248 *
1249 * On each pass through the while() loop one of these groups
1250 * is selected. This is accomplished by using a shift value
1251 * to select the starting metaslab, then striding over the
1252 * metaslabs using the zfs_trim_txg_batch size. This is
1253 * done to accomplish two things.
1254 *
1255 * 1) By dividing the metaslabs in to groups, and making sure
1256 * that each group takes a minimum of one txg to process.
1257 * Then zfs_trim_txg_batch controls the minimum number of
1258 * txgs which must occur before a metaslab is revisited.
1259 *
1260 * 2) Selecting non-consecutive metaslabs distributes the
1261 * TRIM commands for a group evenly over the entire device.
1262 * This can be advantageous for certain types of devices.
1263 */
1264 for (uint64_t i = shift % txgs_per_trim; i < vd->vdev_ms_count;
1265 i += txgs_per_trim) {
1266 metaslab_t *msp = vd->vdev_ms[i];
1267 zfs_range_tree_t *trim_tree;
1268 boolean_t issued_trim = B_FALSE;
1269 boolean_t wait_aborted = B_FALSE;
1270
1271 spa_config_exit(spa, SCL_CONFIG, FTAG);
1272 metaslab_disable(msp);
1273 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1274
1275 mutex_enter(&msp->ms_lock);
1276
1277 /*
1278 * Skip the metaslab when it has never been allocated
1279 * or when there are no recent frees to trim.
1280 */
1281 if (msp->ms_sm == NULL ||
1282 zfs_range_tree_is_empty(msp->ms_trim)) {
1283 mutex_exit(&msp->ms_lock);
1284 metaslab_enable(msp, B_FALSE, B_FALSE);
1285 continue;
1286 }
1287
1288 /*
1289 * Skip the metaslab when it has already been disabled.
1290 * This may happen when a manual TRIM or initialize
1291 * operation is running concurrently. In the case
1292 * of a manual TRIM, the ms_trim tree will have been
1293 * vacated. Only ranges added after the manual TRIM
1294 * disabled the metaslab will be included in the tree.
1295 * These will be processed when the automatic TRIM
1296 * next revisits this metaslab.
1297 */
1298 if (msp->ms_disabled > 1) {
1299 mutex_exit(&msp->ms_lock);
1300 metaslab_enable(msp, B_FALSE, B_FALSE);
1301 continue;
1302 }
1303
1304 /*
1305 * Allocate an empty range tree which is swapped in
1306 * for the existing ms_trim tree while it is processed.
1307 */
1308 trim_tree = zfs_range_tree_create(NULL, ZFS_RANGE_SEG64,
1309 NULL, 0, 0);
1310 zfs_range_tree_swap(&msp->ms_trim, &trim_tree);
1311 ASSERT(zfs_range_tree_is_empty(msp->ms_trim));
1312
1313 /*
1314 * There are two cases when constructing the per-vdev
1315 * trim trees for a metaslab. If the top-level vdev
1316 * has no children then it is also a leaf and should
1317 * be trimmed. Otherwise our children are the leaves
1318 * and a trim tree should be constructed for each.
1319 */
1320 trim_args_t *tap;
1321 uint64_t children = vd->vdev_children;
1322 if (children == 0) {
1323 children = 1;
1324 tap = kmem_zalloc(sizeof (trim_args_t) *
1325 children, KM_SLEEP);
1326 tap[0].trim_vdev = vd;
1327 } else {
1328 tap = kmem_zalloc(sizeof (trim_args_t) *
1329 children, KM_SLEEP);
1330
1331 for (uint64_t c = 0; c < children; c++) {
1332 tap[c].trim_vdev = vd->vdev_child[c];
1333 }
1334 }
1335
1336 for (uint64_t c = 0; c < children; c++) {
1337 trim_args_t *ta = &tap[c];
1338 vdev_t *cvd = ta->trim_vdev;
1339
1340 ta->trim_msp = msp;
1341 ta->trim_extent_bytes_max = extent_bytes_max;
1342 ta->trim_extent_bytes_min = extent_bytes_min;
1343 ta->trim_type = TRIM_TYPE_AUTO;
1344 ta->trim_flags = 0;
1345
1346 if (cvd->vdev_detached ||
1347 !vdev_writeable(cvd) ||
1348 !cvd->vdev_has_trim ||
1349 cvd->vdev_trim_thread != NULL) {
1350 continue;
1351 }
1352
1353 /*
1354 * When a device has an attached hot spare, or
1355 * is being replaced it will not be trimmed.
1356 * This is done to avoid adding additional
1357 * stress to a potentially unhealthy device,
1358 * and to minimize the required rebuild time.
1359 */
1360 if (!cvd->vdev_ops->vdev_op_leaf)
1361 continue;
1362
1363 ta->trim_tree = zfs_range_tree_create(NULL,
1364 ZFS_RANGE_SEG64, NULL, 0, 0);
1365 zfs_range_tree_walk(trim_tree,
1366 vdev_trim_range_add, ta);
1367 }
1368
1369 mutex_exit(&msp->ms_lock);
1370 spa_config_exit(spa, SCL_CONFIG, FTAG);
1371
1372 /*
1373 * Issue the TRIM I/Os for all ranges covered by the
1374 * TRIM trees. These ranges are safe to TRIM because
1375 * no new allocations will be performed until the call
1376 * to metaslab_enabled() below.
1377 */
1378 for (uint64_t c = 0; c < children; c++) {
1379 trim_args_t *ta = &tap[c];
1380
1381 /*
1382 * Always yield to a manual TRIM if one has
1383 * been started for the child vdev.
1384 */
1385 if (ta->trim_tree == NULL ||
1386 ta->trim_vdev->vdev_trim_thread != NULL) {
1387 continue;
1388 }
1389
1390 /*
1391 * After this point metaslab_enable() must be
1392 * called with the sync flag set. This is done
1393 * here because vdev_trim_ranges() is allowed
1394 * to be interrupted (EINTR) before issuing all
1395 * of the required TRIM I/Os.
1396 */
1397 issued_trim = B_TRUE;
1398
1399 int error = vdev_trim_ranges(ta);
1400 if (error)
1401 break;
1402 }
1403
1404 /*
1405 * Verify every range which was trimmed is still
1406 * contained within the ms_allocatable tree.
1407 */
1408 if (zfs_flags & ZFS_DEBUG_TRIM) {
1409 mutex_enter(&msp->ms_lock);
1410 VERIFY0(metaslab_load(msp));
1411 VERIFY3P(tap[0].trim_msp, ==, msp);
1412 zfs_range_tree_walk(trim_tree,
1413 vdev_trim_range_verify, &tap[0]);
1414 mutex_exit(&msp->ms_lock);
1415 }
1416
1417 zfs_range_tree_vacate(trim_tree, NULL, NULL);
1418 zfs_range_tree_destroy(trim_tree);
1419
1420 /*
1421 * Wait for couples of kicks, to ensure the trim io is
1422 * synced. If the wait is aborted due to
1423 * vdev_autotrim_exit_wanted, we need to signal
1424 * metaslab_enable() to wait for sync.
1425 */
1426 if (issued_trim) {
1427 wait_aborted = vdev_autotrim_wait_kick(vd,
1428 TXG_CONCURRENT_STATES + TXG_DEFER_SIZE);
1429 }
1430
1431 metaslab_enable(msp, wait_aborted, B_FALSE);
1432 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1433
1434 for (uint64_t c = 0; c < children; c++) {
1435 trim_args_t *ta = &tap[c];
1436
1437 if (ta->trim_tree == NULL)
1438 continue;
1439
1440 zfs_range_tree_vacate(ta->trim_tree, NULL,
1441 NULL);
1442 zfs_range_tree_destroy(ta->trim_tree);
1443 }
1444
1445 kmem_free(tap, sizeof (trim_args_t) * children);
1446
1447 if (vdev_autotrim_should_stop(vd))
1448 break;
1449 }
1450
1451 spa_config_exit(spa, SCL_CONFIG, FTAG);
1452
1453 vdev_autotrim_wait_kick(vd, 1);
1454
1455 shift++;
1456 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1457 }
1458
1459 for (uint64_t c = 0; c < vd->vdev_children; c++) {
1460 vdev_t *cvd = vd->vdev_child[c];
1461 mutex_enter(&cvd->vdev_trim_io_lock);
1462
1463 while (cvd->vdev_trim_inflight[1] > 0) {
1464 cv_wait(&cvd->vdev_trim_io_cv,
1465 &cvd->vdev_trim_io_lock);
1466 }
1467 mutex_exit(&cvd->vdev_trim_io_lock);
1468 }
1469
1470 spa_config_exit(spa, SCL_CONFIG, FTAG);
1471
1472 /*
1473 * When exiting because the autotrim property was set to off, then
1474 * abandon any unprocessed ms_trim ranges to reclaim the memory.
1475 */
1476 if (spa_get_autotrim(spa) == SPA_AUTOTRIM_OFF) {
1477 for (uint64_t i = 0; i < vd->vdev_ms_count; i++) {
1478 metaslab_t *msp = vd->vdev_ms[i];
1479
1480 mutex_enter(&msp->ms_lock);
1481 zfs_range_tree_vacate(msp->ms_trim, NULL, NULL);
1482 mutex_exit(&msp->ms_lock);
1483 }
1484 }
1485
1486 mutex_enter(&vd->vdev_autotrim_lock);
1487 ASSERT(vd->vdev_autotrim_thread != NULL);
1488 vd->vdev_autotrim_thread = NULL;
1489 cv_broadcast(&vd->vdev_autotrim_cv);
1490 mutex_exit(&vd->vdev_autotrim_lock);
1491
1492 thread_exit();
1493 }
1494
1495 /*
1496 * Starts an autotrim thread, if needed, for each top-level vdev which can be
1497 * trimmed. A top-level vdev which has been evacuated will never be trimmed.
1498 */
1499 void
vdev_autotrim(spa_t * spa)1500 vdev_autotrim(spa_t *spa)
1501 {
1502 vdev_t *root_vd = spa->spa_root_vdev;
1503
1504 for (uint64_t i = 0; i < root_vd->vdev_children; i++) {
1505 vdev_t *tvd = root_vd->vdev_child[i];
1506
1507 mutex_enter(&tvd->vdev_autotrim_lock);
1508 if (vdev_writeable(tvd) && !tvd->vdev_removing &&
1509 tvd->vdev_autotrim_thread == NULL &&
1510 !tvd->vdev_rz_expanding) {
1511 ASSERT3P(tvd->vdev_top, ==, tvd);
1512
1513 tvd->vdev_autotrim_thread = thread_create(NULL, 0,
1514 vdev_autotrim_thread, tvd, 0, &p0, TS_RUN,
1515 maxclsyspri);
1516 ASSERT(tvd->vdev_autotrim_thread != NULL);
1517 }
1518 mutex_exit(&tvd->vdev_autotrim_lock);
1519 }
1520 }
1521
1522 /*
1523 * Wait for the vdev_autotrim_thread associated with the passed top-level
1524 * vdev to be terminated (canceled or stopped).
1525 */
1526 void
vdev_autotrim_stop_wait(vdev_t * tvd)1527 vdev_autotrim_stop_wait(vdev_t *tvd)
1528 {
1529 mutex_enter(&tvd->vdev_autotrim_lock);
1530 if (tvd->vdev_autotrim_thread != NULL) {
1531 tvd->vdev_autotrim_exit_wanted = B_TRUE;
1532 cv_broadcast(&tvd->vdev_autotrim_kick_cv);
1533 cv_wait(&tvd->vdev_autotrim_cv,
1534 &tvd->vdev_autotrim_lock);
1535
1536 ASSERT3P(tvd->vdev_autotrim_thread, ==, NULL);
1537 tvd->vdev_autotrim_exit_wanted = B_FALSE;
1538 }
1539 mutex_exit(&tvd->vdev_autotrim_lock);
1540 }
1541
1542 void
vdev_autotrim_kick(spa_t * spa)1543 vdev_autotrim_kick(spa_t *spa)
1544 {
1545 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
1546
1547 vdev_t *root_vd = spa->spa_root_vdev;
1548 vdev_t *tvd;
1549
1550 for (uint64_t i = 0; i < root_vd->vdev_children; i++) {
1551 tvd = root_vd->vdev_child[i];
1552
1553 mutex_enter(&tvd->vdev_autotrim_lock);
1554 if (tvd->vdev_autotrim_thread != NULL)
1555 cv_broadcast(&tvd->vdev_autotrim_kick_cv);
1556 mutex_exit(&tvd->vdev_autotrim_lock);
1557 }
1558 }
1559
1560 /*
1561 * Wait for all of the vdev_autotrim_thread associated with the pool to
1562 * be terminated (canceled or stopped).
1563 */
1564 void
vdev_autotrim_stop_all(spa_t * spa)1565 vdev_autotrim_stop_all(spa_t *spa)
1566 {
1567 vdev_t *root_vd = spa->spa_root_vdev;
1568
1569 for (uint64_t i = 0; i < root_vd->vdev_children; i++)
1570 vdev_autotrim_stop_wait(root_vd->vdev_child[i]);
1571 }
1572
1573 /*
1574 * Conditionally restart all of the vdev_autotrim_thread's for the pool.
1575 */
1576 void
vdev_autotrim_restart(spa_t * spa)1577 vdev_autotrim_restart(spa_t *spa)
1578 {
1579 ASSERT(MUTEX_HELD(&spa_namespace_lock) ||
1580 spa->spa_load_thread == curthread);
1581 if (spa->spa_autotrim)
1582 vdev_autotrim(spa);
1583 }
1584
1585 static __attribute__((noreturn)) void
vdev_trim_l2arc_thread(void * arg)1586 vdev_trim_l2arc_thread(void *arg)
1587 {
1588 vdev_t *vd = arg;
1589 spa_t *spa = vd->vdev_spa;
1590 l2arc_dev_t *dev = l2arc_vdev_get(vd);
1591 trim_args_t ta = {0};
1592 zfs_range_seg64_t physical_rs;
1593
1594 ASSERT(vdev_is_concrete(vd));
1595 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1596
1597 vd->vdev_trim_last_offset = 0;
1598 vd->vdev_trim_rate = 0;
1599 vd->vdev_trim_partial = 0;
1600 vd->vdev_trim_secure = 0;
1601
1602 ta.trim_vdev = vd;
1603 ta.trim_tree = zfs_range_tree_create(NULL, ZFS_RANGE_SEG64, NULL, 0, 0);
1604 ta.trim_type = TRIM_TYPE_MANUAL;
1605 ta.trim_extent_bytes_max = zfs_trim_extent_bytes_max;
1606 ta.trim_extent_bytes_min = SPA_MINBLOCKSIZE;
1607 ta.trim_flags = 0;
1608
1609 physical_rs.rs_start = vd->vdev_trim_bytes_done = 0;
1610 physical_rs.rs_end = vd->vdev_trim_bytes_est =
1611 vdev_get_min_asize(vd);
1612
1613 zfs_range_tree_add(ta.trim_tree, physical_rs.rs_start,
1614 physical_rs.rs_end - physical_rs.rs_start);
1615
1616 mutex_enter(&vd->vdev_trim_lock);
1617 vdev_trim_change_state(vd, VDEV_TRIM_ACTIVE, 0, 0, 0);
1618 mutex_exit(&vd->vdev_trim_lock);
1619
1620 (void) vdev_trim_ranges(&ta);
1621
1622 spa_config_exit(spa, SCL_CONFIG, FTAG);
1623 mutex_enter(&vd->vdev_trim_io_lock);
1624 while (vd->vdev_trim_inflight[TRIM_TYPE_MANUAL] > 0) {
1625 cv_wait(&vd->vdev_trim_io_cv, &vd->vdev_trim_io_lock);
1626 }
1627 mutex_exit(&vd->vdev_trim_io_lock);
1628
1629 zfs_range_tree_vacate(ta.trim_tree, NULL, NULL);
1630 zfs_range_tree_destroy(ta.trim_tree);
1631
1632 mutex_enter(&vd->vdev_trim_lock);
1633 if (!vd->vdev_trim_exit_wanted && vdev_writeable(vd)) {
1634 vdev_trim_change_state(vd, VDEV_TRIM_COMPLETE,
1635 vd->vdev_trim_rate, vd->vdev_trim_partial,
1636 vd->vdev_trim_secure);
1637 }
1638 ASSERT(vd->vdev_trim_thread != NULL ||
1639 vd->vdev_trim_inflight[TRIM_TYPE_MANUAL] == 0);
1640
1641 /*
1642 * Drop the vdev_trim_lock while we sync out the txg since it's
1643 * possible that a device might be trying to come online and
1644 * must check to see if it needs to restart a trim. That thread
1645 * will be holding the spa_config_lock which would prevent the
1646 * txg_wait_synced from completing. Same strategy as in
1647 * vdev_trim_thread().
1648 */
1649 mutex_exit(&vd->vdev_trim_lock);
1650 txg_wait_synced(spa_get_dsl(vd->vdev_spa), 0);
1651 mutex_enter(&vd->vdev_trim_lock);
1652
1653 /*
1654 * Update the header of the cache device here, before
1655 * broadcasting vdev_trim_cv which may lead to the removal
1656 * of the device. The same applies for setting l2ad_trim_all to
1657 * false.
1658 */
1659 spa_config_enter(vd->vdev_spa, SCL_L2ARC, vd,
1660 RW_READER);
1661 memset(dev->l2ad_dev_hdr, 0, dev->l2ad_dev_hdr_asize);
1662 l2arc_dev_hdr_update(dev);
1663 spa_config_exit(vd->vdev_spa, SCL_L2ARC, vd);
1664
1665 vd->vdev_trim_thread = NULL;
1666 if (vd->vdev_trim_state == VDEV_TRIM_COMPLETE)
1667 dev->l2ad_trim_all = B_FALSE;
1668
1669 cv_broadcast(&vd->vdev_trim_cv);
1670 mutex_exit(&vd->vdev_trim_lock);
1671
1672 thread_exit();
1673 }
1674
1675 /*
1676 * Punches out TRIM threads for the L2ARC devices in a spa and assigns them
1677 * to vd->vdev_trim_thread variable. This facilitates the management of
1678 * trimming the whole cache device using TRIM_TYPE_MANUAL upon addition
1679 * to a pool or pool creation or when the header of the device is invalid.
1680 */
1681 void
vdev_trim_l2arc(spa_t * spa)1682 vdev_trim_l2arc(spa_t *spa)
1683 {
1684 ASSERT(MUTEX_HELD(&spa_namespace_lock));
1685
1686 /*
1687 * Locate the spa's l2arc devices and kick off TRIM threads.
1688 */
1689 for (int i = 0; i < spa->spa_l2cache.sav_count; i++) {
1690 vdev_t *vd = spa->spa_l2cache.sav_vdevs[i];
1691 l2arc_dev_t *dev = l2arc_vdev_get(vd);
1692
1693 if (dev == NULL || !dev->l2ad_trim_all) {
1694 /*
1695 * Don't attempt TRIM if the vdev is UNAVAIL or if the
1696 * cache device was not marked for whole device TRIM
1697 * (ie l2arc_trim_ahead = 0, or the L2ARC device header
1698 * is valid with trim_state = VDEV_TRIM_COMPLETE and
1699 * l2ad_log_entries > 0).
1700 */
1701 continue;
1702 }
1703
1704 mutex_enter(&vd->vdev_trim_lock);
1705 ASSERT(vd->vdev_ops->vdev_op_leaf);
1706 ASSERT(vdev_is_concrete(vd));
1707 ASSERT3P(vd->vdev_trim_thread, ==, NULL);
1708 ASSERT(!vd->vdev_detached);
1709 ASSERT(!vd->vdev_trim_exit_wanted);
1710 ASSERT(!vd->vdev_top->vdev_removing);
1711 vdev_trim_change_state(vd, VDEV_TRIM_ACTIVE, 0, 0, 0);
1712 vd->vdev_trim_thread = thread_create(NULL, 0,
1713 vdev_trim_l2arc_thread, vd, 0, &p0, TS_RUN, maxclsyspri);
1714 mutex_exit(&vd->vdev_trim_lock);
1715 }
1716 }
1717
1718 /*
1719 * A wrapper which calls vdev_trim_ranges(). It is intended to be called
1720 * on leaf vdevs.
1721 */
1722 int
vdev_trim_simple(vdev_t * vd,uint64_t start,uint64_t size)1723 vdev_trim_simple(vdev_t *vd, uint64_t start, uint64_t size)
1724 {
1725 trim_args_t ta = {0};
1726 zfs_range_seg64_t physical_rs;
1727 int error;
1728 physical_rs.rs_start = start;
1729 physical_rs.rs_end = start + size;
1730
1731 ASSERT(vdev_is_concrete(vd));
1732 ASSERT(vd->vdev_ops->vdev_op_leaf);
1733 ASSERT(!vd->vdev_detached);
1734 ASSERT(!vd->vdev_top->vdev_removing);
1735 ASSERT(!vd->vdev_top->vdev_rz_expanding);
1736
1737 ta.trim_vdev = vd;
1738 ta.trim_tree = zfs_range_tree_create(NULL, ZFS_RANGE_SEG64, NULL, 0, 0);
1739 ta.trim_type = TRIM_TYPE_SIMPLE;
1740 ta.trim_extent_bytes_max = zfs_trim_extent_bytes_max;
1741 ta.trim_extent_bytes_min = SPA_MINBLOCKSIZE;
1742 ta.trim_flags = 0;
1743
1744 ASSERT3U(physical_rs.rs_end, >=, physical_rs.rs_start);
1745
1746 if (physical_rs.rs_end > physical_rs.rs_start) {
1747 zfs_range_tree_add(ta.trim_tree, physical_rs.rs_start,
1748 physical_rs.rs_end - physical_rs.rs_start);
1749 } else {
1750 ASSERT3U(physical_rs.rs_end, ==, physical_rs.rs_start);
1751 }
1752
1753 error = vdev_trim_ranges(&ta);
1754
1755 mutex_enter(&vd->vdev_trim_io_lock);
1756 while (vd->vdev_trim_inflight[TRIM_TYPE_SIMPLE] > 0) {
1757 cv_wait(&vd->vdev_trim_io_cv, &vd->vdev_trim_io_lock);
1758 }
1759 mutex_exit(&vd->vdev_trim_io_lock);
1760
1761 zfs_range_tree_vacate(ta.trim_tree, NULL, NULL);
1762 zfs_range_tree_destroy(ta.trim_tree);
1763
1764 return (error);
1765 }
1766
1767 EXPORT_SYMBOL(vdev_trim);
1768 EXPORT_SYMBOL(vdev_trim_stop);
1769 EXPORT_SYMBOL(vdev_trim_stop_all);
1770 EXPORT_SYMBOL(vdev_trim_stop_wait);
1771 EXPORT_SYMBOL(vdev_trim_restart);
1772 EXPORT_SYMBOL(vdev_autotrim);
1773 EXPORT_SYMBOL(vdev_autotrim_stop_all);
1774 EXPORT_SYMBOL(vdev_autotrim_stop_wait);
1775 EXPORT_SYMBOL(vdev_autotrim_restart);
1776 EXPORT_SYMBOL(vdev_trim_l2arc);
1777 EXPORT_SYMBOL(vdev_trim_simple);
1778
1779 ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_max, UINT, ZMOD_RW,
1780 "Max size of TRIM commands, larger will be split");
1781
1782 ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_min, UINT, ZMOD_RW,
1783 "Min size of TRIM commands, smaller will be skipped");
1784
1785 ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, metaslab_skip, UINT, ZMOD_RW,
1786 "Skip metaslabs which have never been initialized");
1787
1788 ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, txg_batch, UINT, ZMOD_RW,
1789 "Min number of txgs to aggregate frees before issuing TRIM");
1790
1791 ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, queue_limit, UINT, ZMOD_RW,
1792 "Max queued TRIMs outstanding per leaf vdev");
1793