]>
git.proxmox.com Git - mirror_zfs-debian.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>
33 #include <sys/sunddi.h>
34 #include <sys/zfs_ioctl.h>
35 #include <sys/mkdev.h>
36 #include <sys/zfs_onexit.h>
40 * ZFS kernel routines may add/delete callback routines to be invoked
41 * upon process exit (triggered via the close operation from the /dev/zfs
44 * These cleanup callbacks are intended to allow for the accumulation
45 * of kernel state across multiple ioctls. User processes participate
46 * simply by opening ZFS_DEV. This causes the ZFS driver to do create
47 * some private data for the file descriptor and generating a unique
48 * minor number. The process then passes along that file descriptor to
49 * each ioctl that might have a cleanup operation.
51 * Consumers of the onexit routines should call zfs_onexit_fd_hold() early
52 * on to validate the given fd and add a reference to its file table entry.
53 * This allows the consumer to do its work and then add a callback, knowing
54 * that zfs_onexit_add_cb() won't fail with EBADF. When finished, consumers
55 * should call zfs_onexit_fd_rele().
57 * A simple example is zfs_ioc_recv(), where we might create an AVL tree
58 * with dataset/GUID mappings and then reuse that tree on subsequent
59 * zfs_ioc_recv() calls.
61 * On the first zfs_ioc_recv() call, dmu_recv_stream() will kmem_alloc()
62 * the AVL tree and pass it along with a callback function to
63 * zfs_onexit_add_cb(). The zfs_onexit_add_cb() routine will register the
64 * callback and return an action handle.
66 * The action handle is then passed from user space to subsequent
67 * zfs_ioc_recv() calls, so that dmu_recv_stream() can fetch its AVL tree
68 * by calling zfs_onexit_cb_data() with the device minor number and
71 * If the user process exits abnormally, the callback is invoked implicitly
72 * as part of the driver close operation. Once the user space process is
73 * finished with the accumulated kernel state, it can also just call close(2)
74 * on the cleanup fd to trigger the cleanup callback.
78 zfs_onexit_init(zfs_onexit_t
**zop
)
82 zo
= *zop
= kmem_zalloc(sizeof (zfs_onexit_t
), KM_SLEEP
);
83 mutex_init(&zo
->zo_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
84 list_create(&zo
->zo_actions
, sizeof (zfs_onexit_action_node_t
),
85 offsetof(zfs_onexit_action_node_t
, za_link
));
89 zfs_onexit_destroy(zfs_onexit_t
*zo
)
91 zfs_onexit_action_node_t
*ap
;
93 mutex_enter(&zo
->zo_lock
);
94 while ((ap
= list_head(&zo
->zo_actions
)) != NULL
) {
95 list_remove(&zo
->zo_actions
, ap
);
96 mutex_exit(&zo
->zo_lock
);
97 ap
->za_func(ap
->za_data
);
98 kmem_free(ap
, sizeof (zfs_onexit_action_node_t
));
99 mutex_enter(&zo
->zo_lock
);
101 mutex_exit(&zo
->zo_lock
);
103 list_destroy(&zo
->zo_actions
);
104 mutex_destroy(&zo
->zo_lock
);
105 kmem_free(zo
, sizeof (zfs_onexit_t
));
109 zfs_onexit_minor_to_state(minor_t minor
, zfs_onexit_t
**zo
)
111 *zo
= zfsdev_get_state(minor
, ZST_ONEXIT
);
113 return (SET_ERROR(EBADF
));
119 * Consumers might need to operate by minor number instead of fd, since
120 * they might be running in another thread (e.g. txg_sync_thread). Callers
121 * of this function must call zfs_onexit_fd_rele() when they're finished
122 * using the minor number.
125 zfs_onexit_fd_hold(int fd
, minor_t
*minorp
)
132 return (SET_ERROR(EBADF
));
134 *minorp
= zfsdev_getminor(fp
->f_file
);
135 return (zfs_onexit_minor_to_state(*minorp
, &zo
));
139 zfs_onexit_fd_rele(int fd
)
145 * Add a callback to be invoked when the calling process exits.
148 zfs_onexit_add_cb(minor_t minor
, void (*func
)(void *), void *data
,
149 uint64_t *action_handle
)
152 zfs_onexit_action_node_t
*ap
;
155 error
= zfs_onexit_minor_to_state(minor
, &zo
);
159 ap
= kmem_alloc(sizeof (zfs_onexit_action_node_t
), KM_SLEEP
);
160 list_link_init(&ap
->za_link
);
164 mutex_enter(&zo
->zo_lock
);
165 list_insert_tail(&zo
->zo_actions
, ap
);
166 mutex_exit(&zo
->zo_lock
);
168 *action_handle
= (uint64_t)(uintptr_t)ap
;
173 static zfs_onexit_action_node_t
*
174 zfs_onexit_find_cb(zfs_onexit_t
*zo
, uint64_t action_handle
)
176 zfs_onexit_action_node_t
*match
;
177 zfs_onexit_action_node_t
*ap
;
180 ASSERT(MUTEX_HELD(&zo
->zo_lock
));
182 match
= (zfs_onexit_action_node_t
*)(uintptr_t)action_handle
;
184 for (ap
= list_head(l
); ap
!= NULL
; ap
= list_next(l
, ap
)) {
192 * Delete the callback, triggering it first if 'fire' is set.
195 zfs_onexit_del_cb(minor_t minor
, uint64_t action_handle
, boolean_t fire
)
198 zfs_onexit_action_node_t
*ap
;
201 error
= zfs_onexit_minor_to_state(minor
, &zo
);
205 mutex_enter(&zo
->zo_lock
);
206 ap
= zfs_onexit_find_cb(zo
, action_handle
);
208 list_remove(&zo
->zo_actions
, ap
);
209 mutex_exit(&zo
->zo_lock
);
211 ap
->za_func(ap
->za_data
);
212 kmem_free(ap
, sizeof (zfs_onexit_action_node_t
));
214 mutex_exit(&zo
->zo_lock
);
215 error
= SET_ERROR(ENOENT
);
222 * Return the data associated with this callback. This allows consumers
223 * of the cleanup-on-exit interfaces to stash kernel data across system
224 * calls, knowing that it will be cleaned up if the calling process exits.
227 zfs_onexit_cb_data(minor_t minor
, uint64_t action_handle
, void **data
)
230 zfs_onexit_action_node_t
*ap
;
235 error
= zfs_onexit_minor_to_state(minor
, &zo
);
239 mutex_enter(&zo
->zo_lock
);
240 ap
= zfs_onexit_find_cb(zo
, action_handle
);
244 error
= SET_ERROR(ENOENT
);
245 mutex_exit(&zo
->zo_lock
);