]>
git.proxmox.com Git - mirror_zfs.git/blob - module/zfs/zfs_onexit.c
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2013 by Delphix. All rights reserved.
26 #include <sys/types.h>
27 #include <sys/param.h>
28 #include <sys/errno.h>
30 #include <sys/sunddi.h>
31 #include <sys/zfs_ioctl.h>
32 #include <sys/zfs_onexit.h>
36 * ZFS kernel routines may add/delete callback routines to be invoked
37 * upon process exit (triggered via the close operation from the /dev/zfs
40 * These cleanup callbacks are intended to allow for the accumulation
41 * of kernel state across multiple ioctls. User processes participate
42 * simply by opening ZFS_DEV. This causes the ZFS driver to do create
43 * some private data for the file descriptor and generating a unique
44 * minor number. The process then passes along that file descriptor to
45 * each ioctl that might have a cleanup operation.
47 * Consumers of the onexit routines should call zfs_onexit_fd_hold() early
48 * on to validate the given fd and add a reference to its file table entry.
49 * This allows the consumer to do its work and then add a callback, knowing
50 * that zfs_onexit_add_cb() won't fail with EBADF. When finished, consumers
51 * should call zfs_onexit_fd_rele().
53 * A simple example is zfs_ioc_recv(), where we might create an AVL tree
54 * with dataset/GUID mappings and then reuse that tree on subsequent
55 * zfs_ioc_recv() calls.
57 * On the first zfs_ioc_recv() call, dmu_recv_stream() will kmem_alloc()
58 * the AVL tree and pass it along with a callback function to
59 * zfs_onexit_add_cb(). The zfs_onexit_add_cb() routine will register the
60 * callback and return an action handle.
62 * The action handle is then passed from user space to subsequent
63 * zfs_ioc_recv() calls, so that dmu_recv_stream() can fetch its AVL tree
64 * by calling zfs_onexit_cb_data() with the device minor number and
67 * If the user process exits abnormally, the callback is invoked implicitly
68 * as part of the driver close operation. Once the user space process is
69 * finished with the accumulated kernel state, it can also just call close(2)
70 * on the cleanup fd to trigger the cleanup callback.
74 zfs_onexit_init(zfs_onexit_t
**zop
)
78 zo
= *zop
= kmem_zalloc(sizeof (zfs_onexit_t
), KM_SLEEP
);
79 mutex_init(&zo
->zo_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
80 list_create(&zo
->zo_actions
, sizeof (zfs_onexit_action_node_t
),
81 offsetof(zfs_onexit_action_node_t
, za_link
));
85 zfs_onexit_destroy(zfs_onexit_t
*zo
)
87 zfs_onexit_action_node_t
*ap
;
89 mutex_enter(&zo
->zo_lock
);
90 while ((ap
= list_head(&zo
->zo_actions
)) != NULL
) {
91 list_remove(&zo
->zo_actions
, ap
);
92 mutex_exit(&zo
->zo_lock
);
93 ap
->za_func(ap
->za_data
);
94 kmem_free(ap
, sizeof (zfs_onexit_action_node_t
));
95 mutex_enter(&zo
->zo_lock
);
97 mutex_exit(&zo
->zo_lock
);
99 list_destroy(&zo
->zo_actions
);
100 mutex_destroy(&zo
->zo_lock
);
101 kmem_free(zo
, sizeof (zfs_onexit_t
));
105 zfs_onexit_minor_to_state(minor_t minor
, zfs_onexit_t
**zo
)
107 *zo
= zfsdev_get_state(minor
, ZST_ONEXIT
);
109 return (SET_ERROR(EBADF
));
115 * Consumers might need to operate by minor number instead of fd, since
116 * they might be running in another thread (e.g. txg_sync_thread). Callers
117 * of this function must call zfs_onexit_fd_rele() when they're finished
118 * using the minor number.
121 zfs_onexit_fd_hold(int fd
, minor_t
*minorp
)
129 return (SET_ERROR(EBADF
));
131 error
= zfsdev_getminor(fp
->f_file
, minorp
);
133 error
= zfs_onexit_minor_to_state(*minorp
, &zo
);
136 zfs_onexit_fd_rele(fd
);
142 zfs_onexit_fd_rele(int fd
)
148 * Add a callback to be invoked when the calling process exits.
151 zfs_onexit_add_cb(minor_t minor
, void (*func
)(void *), void *data
,
152 uint64_t *action_handle
)
155 zfs_onexit_action_node_t
*ap
;
158 error
= zfs_onexit_minor_to_state(minor
, &zo
);
162 ap
= kmem_alloc(sizeof (zfs_onexit_action_node_t
), KM_SLEEP
);
163 list_link_init(&ap
->za_link
);
167 mutex_enter(&zo
->zo_lock
);
168 list_insert_tail(&zo
->zo_actions
, ap
);
169 mutex_exit(&zo
->zo_lock
);
171 *action_handle
= (uint64_t)(uintptr_t)ap
;
176 static zfs_onexit_action_node_t
*
177 zfs_onexit_find_cb(zfs_onexit_t
*zo
, uint64_t action_handle
)
179 zfs_onexit_action_node_t
*match
;
180 zfs_onexit_action_node_t
*ap
;
183 ASSERT(MUTEX_HELD(&zo
->zo_lock
));
185 match
= (zfs_onexit_action_node_t
*)(uintptr_t)action_handle
;
187 for (ap
= list_head(l
); ap
!= NULL
; ap
= list_next(l
, ap
)) {
195 * Delete the callback, triggering it first if 'fire' is set.
198 zfs_onexit_del_cb(minor_t minor
, uint64_t action_handle
, boolean_t fire
)
201 zfs_onexit_action_node_t
*ap
;
204 error
= zfs_onexit_minor_to_state(minor
, &zo
);
208 mutex_enter(&zo
->zo_lock
);
209 ap
= zfs_onexit_find_cb(zo
, action_handle
);
211 list_remove(&zo
->zo_actions
, ap
);
212 mutex_exit(&zo
->zo_lock
);
214 ap
->za_func(ap
->za_data
);
215 kmem_free(ap
, sizeof (zfs_onexit_action_node_t
));
217 mutex_exit(&zo
->zo_lock
);
218 error
= SET_ERROR(ENOENT
);
225 * Return the data associated with this callback. This allows consumers
226 * of the cleanup-on-exit interfaces to stash kernel data across system
227 * calls, knowing that it will be cleaned up if the calling process exits.
230 zfs_onexit_cb_data(minor_t minor
, uint64_t action_handle
, void **data
)
233 zfs_onexit_action_node_t
*ap
;
238 error
= zfs_onexit_minor_to_state(minor
, &zo
);
242 mutex_enter(&zo
->zo_lock
);
243 ap
= zfs_onexit_find_cb(zo
, action_handle
);
247 error
= SET_ERROR(ENOENT
);
248 mutex_exit(&zo
->zo_lock
);