2 * drivers/base/devres.c - device resource management
4 * Copyright (c) 2006 SUSE Linux Products GmbH
5 * Copyright (c) 2006 Tejun Heo <teheo@suse.de>
7 * This file is released under the GPLv2.
10 #include <linux/device.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
17 struct list_head entry
;
19 #ifdef CONFIG_DEBUG_DEVRES
26 struct devres_node node
;
28 unsigned long long data
[]; /* guarantee ull alignment */
32 struct devres_node node
[2];
38 #ifdef CONFIG_DEBUG_DEVRES
39 static int log_devres
= 0;
40 module_param_named(log
, log_devres
, int, S_IRUGO
| S_IWUSR
);
42 static void set_node_dbginfo(struct devres_node
*node
, const char *name
,
49 static void devres_log(struct device
*dev
, struct devres_node
*node
,
52 if (unlikely(log_devres
))
53 dev_err(dev
, "DEVRES %3s %p %s (%lu bytes)\n",
54 op
, node
, node
->name
, (unsigned long)node
->size
);
56 #else /* CONFIG_DEBUG_DEVRES */
57 #define set_node_dbginfo(node, n, s) do {} while (0)
58 #define devres_log(dev, node, op) do {} while (0)
59 #endif /* CONFIG_DEBUG_DEVRES */
62 * Release functions for devres group. These callbacks are used only
65 static void group_open_release(struct device
*dev
, void *res
)
70 static void group_close_release(struct device
*dev
, void *res
)
75 static struct devres_group
* node_to_group(struct devres_node
*node
)
77 if (node
->release
== &group_open_release
)
78 return container_of(node
, struct devres_group
, node
[0]);
79 if (node
->release
== &group_close_release
)
80 return container_of(node
, struct devres_group
, node
[1]);
84 static __always_inline
struct devres
* alloc_dr(dr_release_t release
,
85 size_t size
, gfp_t gfp
)
87 size_t tot_size
= sizeof(struct devres
) + size
;
90 dr
= kmalloc_track_caller(tot_size
, gfp
);
94 memset(dr
, 0, offsetof(struct devres
, data
));
96 INIT_LIST_HEAD(&dr
->node
.entry
);
97 dr
->node
.release
= release
;
101 static void add_dr(struct device
*dev
, struct devres_node
*node
)
103 devres_log(dev
, node
, "ADD");
104 BUG_ON(!list_empty(&node
->entry
));
105 list_add_tail(&node
->entry
, &dev
->devres_head
);
108 #ifdef CONFIG_DEBUG_DEVRES
109 void * __devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
,
114 dr
= alloc_dr(release
, size
, gfp
| __GFP_ZERO
);
117 set_node_dbginfo(&dr
->node
, name
, size
);
120 EXPORT_SYMBOL_GPL(__devres_alloc
);
123 * devres_alloc - Allocate device resource data
124 * @release: Release function devres will be associated with
125 * @size: Allocation size
126 * @gfp: Allocation flags
128 * Allocate devres of @size bytes. The allocated area is zeroed, then
129 * associated with @release. The returned pointer can be passed to
130 * other devres_*() functions.
133 * Pointer to allocated devres on success, NULL on failure.
135 void * devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
)
139 dr
= alloc_dr(release
, size
, gfp
| __GFP_ZERO
);
144 EXPORT_SYMBOL_GPL(devres_alloc
);
148 * devres_for_each_res - Resource iterator
149 * @dev: Device to iterate resource from
150 * @release: Look for resources associated with this release function
151 * @match: Match function (optional)
152 * @match_data: Data for the match function
153 * @fn: Function to be called for each matched resource.
154 * @data: Data for @fn, the 3rd parameter of @fn
156 * Call @fn for each devres of @dev which is associated with @release
157 * and for which @match returns 1.
162 void devres_for_each_res(struct device
*dev
, dr_release_t release
,
163 dr_match_t match
, void *match_data
,
164 void (*fn
)(struct device
*, void *, void *),
167 struct devres_node
*node
;
168 struct devres_node
*tmp
;
174 spin_lock_irqsave(&dev
->devres_lock
, flags
);
175 list_for_each_entry_safe_reverse(node
, tmp
,
176 &dev
->devres_head
, entry
) {
177 struct devres
*dr
= container_of(node
, struct devres
, node
);
179 if (node
->release
!= release
)
181 if (match
&& !match(dev
, dr
->data
, match_data
))
183 fn(dev
, dr
->data
, data
);
185 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
187 EXPORT_SYMBOL_GPL(devres_for_each_res
);
190 * devres_free - Free device resource data
191 * @res: Pointer to devres data to free
193 * Free devres created with devres_alloc().
195 void devres_free(void *res
)
198 struct devres
*dr
= container_of(res
, struct devres
, data
);
200 BUG_ON(!list_empty(&dr
->node
.entry
));
204 EXPORT_SYMBOL_GPL(devres_free
);
207 * devres_add - Register device resource
208 * @dev: Device to add resource to
209 * @res: Resource to register
211 * Register devres @res to @dev. @res should have been allocated
212 * using devres_alloc(). On driver detach, the associated release
213 * function will be invoked and devres will be freed automatically.
215 void devres_add(struct device
*dev
, void *res
)
217 struct devres
*dr
= container_of(res
, struct devres
, data
);
220 spin_lock_irqsave(&dev
->devres_lock
, flags
);
221 add_dr(dev
, &dr
->node
);
222 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
224 EXPORT_SYMBOL_GPL(devres_add
);
226 static struct devres
*find_dr(struct device
*dev
, dr_release_t release
,
227 dr_match_t match
, void *match_data
)
229 struct devres_node
*node
;
231 list_for_each_entry_reverse(node
, &dev
->devres_head
, entry
) {
232 struct devres
*dr
= container_of(node
, struct devres
, node
);
234 if (node
->release
!= release
)
236 if (match
&& !match(dev
, dr
->data
, match_data
))
245 * devres_find - Find device resource
246 * @dev: Device to lookup resource from
247 * @release: Look for resources associated with this release function
248 * @match: Match function (optional)
249 * @match_data: Data for the match function
251 * Find the latest devres of @dev which is associated with @release
252 * and for which @match returns 1. If @match is NULL, it's considered
256 * Pointer to found devres, NULL if not found.
258 void * devres_find(struct device
*dev
, dr_release_t release
,
259 dr_match_t match
, void *match_data
)
264 spin_lock_irqsave(&dev
->devres_lock
, flags
);
265 dr
= find_dr(dev
, release
, match
, match_data
);
266 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
272 EXPORT_SYMBOL_GPL(devres_find
);
275 * devres_get - Find devres, if non-existent, add one atomically
276 * @dev: Device to lookup or add devres for
277 * @new_res: Pointer to new initialized devres to add if not found
278 * @match: Match function (optional)
279 * @match_data: Data for the match function
281 * Find the latest devres of @dev which has the same release function
282 * as @new_res and for which @match return 1. If found, @new_res is
283 * freed; otherwise, @new_res is added atomically.
286 * Pointer to found or added devres.
288 void * devres_get(struct device
*dev
, void *new_res
,
289 dr_match_t match
, void *match_data
)
291 struct devres
*new_dr
= container_of(new_res
, struct devres
, data
);
295 spin_lock_irqsave(&dev
->devres_lock
, flags
);
296 dr
= find_dr(dev
, new_dr
->node
.release
, match
, match_data
);
298 add_dr(dev
, &new_dr
->node
);
302 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
307 EXPORT_SYMBOL_GPL(devres_get
);
310 * devres_remove - Find a device resource and remove it
311 * @dev: Device to find resource from
312 * @release: Look for resources associated with this release function
313 * @match: Match function (optional)
314 * @match_data: Data for the match function
316 * Find the latest devres of @dev associated with @release and for
317 * which @match returns 1. If @match is NULL, it's considered to
318 * match all. If found, the resource is removed atomically and
322 * Pointer to removed devres on success, NULL if not found.
324 void * devres_remove(struct device
*dev
, dr_release_t release
,
325 dr_match_t match
, void *match_data
)
330 spin_lock_irqsave(&dev
->devres_lock
, flags
);
331 dr
= find_dr(dev
, release
, match
, match_data
);
333 list_del_init(&dr
->node
.entry
);
334 devres_log(dev
, &dr
->node
, "REM");
336 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
342 EXPORT_SYMBOL_GPL(devres_remove
);
345 * devres_destroy - Find a device resource and destroy it
346 * @dev: Device to find resource from
347 * @release: Look for resources associated with this release function
348 * @match: Match function (optional)
349 * @match_data: Data for the match function
351 * Find the latest devres of @dev associated with @release and for
352 * which @match returns 1. If @match is NULL, it's considered to
353 * match all. If found, the resource is removed atomically and freed.
355 * Note that the release function for the resource will not be called,
356 * only the devres-allocated data will be freed. The caller becomes
357 * responsible for freeing any other data.
360 * 0 if devres is found and freed, -ENOENT if not found.
362 int devres_destroy(struct device
*dev
, dr_release_t release
,
363 dr_match_t match
, void *match_data
)
367 res
= devres_remove(dev
, release
, match
, match_data
);
374 EXPORT_SYMBOL_GPL(devres_destroy
);
378 * devres_release - Find a device resource and destroy it, calling release
379 * @dev: Device to find resource from
380 * @release: Look for resources associated with this release function
381 * @match: Match function (optional)
382 * @match_data: Data for the match function
384 * Find the latest devres of @dev associated with @release and for
385 * which @match returns 1. If @match is NULL, it's considered to
386 * match all. If found, the resource is removed atomically, the
387 * release function called and the resource freed.
390 * 0 if devres is found and freed, -ENOENT if not found.
392 int devres_release(struct device
*dev
, dr_release_t release
,
393 dr_match_t match
, void *match_data
)
397 res
= devres_remove(dev
, release
, match
, match_data
);
401 (*release
)(dev
, res
);
405 EXPORT_SYMBOL_GPL(devres_release
);
407 static int remove_nodes(struct device
*dev
,
408 struct list_head
*first
, struct list_head
*end
,
409 struct list_head
*todo
)
411 int cnt
= 0, nr_groups
= 0;
412 struct list_head
*cur
;
414 /* First pass - move normal devres entries to @todo and clear
415 * devres_group colors.
419 struct devres_node
*node
;
420 struct devres_group
*grp
;
422 node
= list_entry(cur
, struct devres_node
, entry
);
425 grp
= node_to_group(node
);
427 /* clear color of group markers in the first pass */
431 /* regular devres entry */
432 if (&node
->entry
== first
)
434 list_move_tail(&node
->entry
, todo
);
442 /* Second pass - Scan groups and color them. A group gets
443 * color value of two iff the group is wholly contained in
444 * [cur, end). That is, for a closed group, both opening and
445 * closing markers should be in the range, while just the
446 * opening marker is enough for an open group.
450 struct devres_node
*node
;
451 struct devres_group
*grp
;
453 node
= list_entry(cur
, struct devres_node
, entry
);
456 grp
= node_to_group(node
);
457 BUG_ON(!grp
|| list_empty(&grp
->node
[0].entry
));
460 if (list_empty(&grp
->node
[1].entry
))
463 BUG_ON(grp
->color
<= 0 || grp
->color
> 2);
464 if (grp
->color
== 2) {
465 /* No need to update cur or end. The removed
466 * nodes are always before both.
468 list_move_tail(&grp
->node
[0].entry
, todo
);
469 list_del_init(&grp
->node
[1].entry
);
476 static int release_nodes(struct device
*dev
, struct list_head
*first
,
477 struct list_head
*end
, unsigned long flags
)
478 __releases(&dev
->devres_lock
)
482 struct devres
*dr
, *tmp
;
484 cnt
= remove_nodes(dev
, first
, end
, &todo
);
486 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
488 /* Release. Note that both devres and devres_group are
489 * handled as devres in the following loop. This is safe.
491 list_for_each_entry_safe_reverse(dr
, tmp
, &todo
, node
.entry
) {
492 devres_log(dev
, &dr
->node
, "REL");
493 dr
->node
.release(dev
, dr
->data
);
501 * devres_release_all - Release all managed resources
502 * @dev: Device to release resources for
504 * Release all resources associated with @dev. This function is
505 * called on driver detach.
507 int devres_release_all(struct device
*dev
)
511 /* Looks like an uninitialized device structure */
512 if (WARN_ON(dev
->devres_head
.next
== NULL
))
514 spin_lock_irqsave(&dev
->devres_lock
, flags
);
515 return release_nodes(dev
, dev
->devres_head
.next
, &dev
->devres_head
,
520 * devres_open_group - Open a new devres group
521 * @dev: Device to open devres group for
523 * @gfp: Allocation flags
525 * Open a new devres group for @dev with @id. For @id, using a
526 * pointer to an object which won't be used for another group is
527 * recommended. If @id is NULL, address-wise unique ID is created.
530 * ID of the new group, NULL on failure.
532 void * devres_open_group(struct device
*dev
, void *id
, gfp_t gfp
)
534 struct devres_group
*grp
;
537 grp
= kmalloc(sizeof(*grp
), gfp
);
541 grp
->node
[0].release
= &group_open_release
;
542 grp
->node
[1].release
= &group_close_release
;
543 INIT_LIST_HEAD(&grp
->node
[0].entry
);
544 INIT_LIST_HEAD(&grp
->node
[1].entry
);
545 set_node_dbginfo(&grp
->node
[0], "grp<", 0);
546 set_node_dbginfo(&grp
->node
[1], "grp>", 0);
551 spin_lock_irqsave(&dev
->devres_lock
, flags
);
552 add_dr(dev
, &grp
->node
[0]);
553 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
556 EXPORT_SYMBOL_GPL(devres_open_group
);
558 /* Find devres group with ID @id. If @id is NULL, look for the latest. */
559 static struct devres_group
* find_group(struct device
*dev
, void *id
)
561 struct devres_node
*node
;
563 list_for_each_entry_reverse(node
, &dev
->devres_head
, entry
) {
564 struct devres_group
*grp
;
566 if (node
->release
!= &group_open_release
)
569 grp
= container_of(node
, struct devres_group
, node
[0]);
574 } else if (list_empty(&grp
->node
[1].entry
))
582 * devres_close_group - Close a devres group
583 * @dev: Device to close devres group for
584 * @id: ID of target group, can be NULL
586 * Close the group identified by @id. If @id is NULL, the latest open
589 void devres_close_group(struct device
*dev
, void *id
)
591 struct devres_group
*grp
;
594 spin_lock_irqsave(&dev
->devres_lock
, flags
);
596 grp
= find_group(dev
, id
);
598 add_dr(dev
, &grp
->node
[1]);
602 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
604 EXPORT_SYMBOL_GPL(devres_close_group
);
607 * devres_remove_group - Remove a devres group
608 * @dev: Device to remove group for
609 * @id: ID of target group, can be NULL
611 * Remove the group identified by @id. If @id is NULL, the latest
612 * open group is selected. Note that removing a group doesn't affect
613 * any other resources.
615 void devres_remove_group(struct device
*dev
, void *id
)
617 struct devres_group
*grp
;
620 spin_lock_irqsave(&dev
->devres_lock
, flags
);
622 grp
= find_group(dev
, id
);
624 list_del_init(&grp
->node
[0].entry
);
625 list_del_init(&grp
->node
[1].entry
);
626 devres_log(dev
, &grp
->node
[0], "REM");
630 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
634 EXPORT_SYMBOL_GPL(devres_remove_group
);
637 * devres_release_group - Release resources in a devres group
638 * @dev: Device to release group for
639 * @id: ID of target group, can be NULL
641 * Release all resources in the group identified by @id. If @id is
642 * NULL, the latest open group is selected. The selected group and
643 * groups properly nested inside the selected group are removed.
646 * The number of released non-group resources.
648 int devres_release_group(struct device
*dev
, void *id
)
650 struct devres_group
*grp
;
654 spin_lock_irqsave(&dev
->devres_lock
, flags
);
656 grp
= find_group(dev
, id
);
658 struct list_head
*first
= &grp
->node
[0].entry
;
659 struct list_head
*end
= &dev
->devres_head
;
661 if (!list_empty(&grp
->node
[1].entry
))
662 end
= grp
->node
[1].entry
.next
;
664 cnt
= release_nodes(dev
, first
, end
, flags
);
667 spin_unlock_irqrestore(&dev
->devres_lock
, flags
);
672 EXPORT_SYMBOL_GPL(devres_release_group
);
675 * Custom devres actions allow inserting a simple function call
676 * into the teadown sequence.
679 struct action_devres
{
681 void (*action
)(void *);
684 static int devm_action_match(struct device
*dev
, void *res
, void *p
)
686 struct action_devres
*devres
= res
;
687 struct action_devres
*target
= p
;
689 return devres
->action
== target
->action
&&
690 devres
->data
== target
->data
;
693 static void devm_action_release(struct device
*dev
, void *res
)
695 struct action_devres
*devres
= res
;
697 devres
->action(devres
->data
);
701 * devm_add_action() - add a custom action to list of managed resources
702 * @dev: Device that owns the action
703 * @action: Function that should be called
704 * @data: Pointer to data passed to @action implementation
706 * This adds a custom action to the list of managed resources so that
707 * it gets executed as part of standard resource unwinding.
709 int devm_add_action(struct device
*dev
, void (*action
)(void *), void *data
)
711 struct action_devres
*devres
;
713 devres
= devres_alloc(devm_action_release
,
714 sizeof(struct action_devres
), GFP_KERNEL
);
719 devres
->action
= action
;
721 devres_add(dev
, devres
);
724 EXPORT_SYMBOL_GPL(devm_add_action
);
727 * devm_remove_action() - removes previously added custom action
728 * @dev: Device that owns the action
729 * @action: Function implementing the action
730 * @data: Pointer to data passed to @action implementation
732 * Removes instance of @action previously added by devm_add_action().
733 * Both action and data should match one of the existing entries.
735 void devm_remove_action(struct device
*dev
, void (*action
)(void *), void *data
)
737 struct action_devres devres
= {
742 WARN_ON(devres_destroy(dev
, devm_action_release
, devm_action_match
,
746 EXPORT_SYMBOL_GPL(devm_remove_action
);
749 * Managed kmalloc/kfree
751 static void devm_kmalloc_release(struct device
*dev
, void *res
)
756 static int devm_kmalloc_match(struct device
*dev
, void *res
, void *data
)
762 * devm_kmalloc - Resource-managed kmalloc
763 * @dev: Device to allocate memory for
764 * @size: Allocation size
765 * @gfp: Allocation gfp flags
767 * Managed kmalloc. Memory allocated with this function is
768 * automatically freed on driver detach. Like all other devres
769 * resources, guaranteed alignment is unsigned long long.
772 * Pointer to allocated memory on success, NULL on failure.
774 void * devm_kmalloc(struct device
*dev
, size_t size
, gfp_t gfp
)
778 /* use raw alloc_dr for kmalloc caller tracing */
779 dr
= alloc_dr(devm_kmalloc_release
, size
, gfp
);
784 * This is named devm_kzalloc_release for historical reasons
785 * The initial implementation did not support kmalloc, only kzalloc
787 set_node_dbginfo(&dr
->node
, "devm_kzalloc_release", size
);
788 devres_add(dev
, dr
->data
);
791 EXPORT_SYMBOL_GPL(devm_kmalloc
);
794 * devm_kstrdup - Allocate resource managed space and
795 * copy an existing string into that.
796 * @dev: Device to allocate memory for
797 * @s: the string to duplicate
798 * @gfp: the GFP mask used in the devm_kmalloc() call when
801 * Pointer to allocated string on success, NULL on failure.
803 char *devm_kstrdup(struct device
*dev
, const char *s
, gfp_t gfp
)
811 size
= strlen(s
) + 1;
812 buf
= devm_kmalloc(dev
, size
, gfp
);
814 memcpy(buf
, s
, size
);
817 EXPORT_SYMBOL_GPL(devm_kstrdup
);
820 * devm_kfree - Resource-managed kfree
821 * @dev: Device this memory belongs to
824 * Free memory allocated with devm_kmalloc().
826 void devm_kfree(struct device
*dev
, void *p
)
830 rc
= devres_destroy(dev
, devm_kmalloc_release
, devm_kmalloc_match
, p
);
833 EXPORT_SYMBOL_GPL(devm_kfree
);
836 * devm_kmemdup - Resource-managed kmemdup
837 * @dev: Device this memory belongs to
838 * @src: Memory region to duplicate
839 * @len: Memory region length
840 * @gfp: GFP mask to use
842 * Duplicate region of a memory using resource managed kmalloc
844 void *devm_kmemdup(struct device
*dev
, const void *src
, size_t len
, gfp_t gfp
)
848 p
= devm_kmalloc(dev
, len
, gfp
);
854 EXPORT_SYMBOL_GPL(devm_kmemdup
);
856 struct pages_devres
{
861 static int devm_pages_match(struct device
*dev
, void *res
, void *p
)
863 struct pages_devres
*devres
= res
;
864 struct pages_devres
*target
= p
;
866 return devres
->addr
== target
->addr
;
869 static void devm_pages_release(struct device
*dev
, void *res
)
871 struct pages_devres
*devres
= res
;
873 free_pages(devres
->addr
, devres
->order
);
877 * devm_get_free_pages - Resource-managed __get_free_pages
878 * @dev: Device to allocate memory for
879 * @gfp_mask: Allocation gfp flags
880 * @order: Allocation size is (1 << order) pages
882 * Managed get_free_pages. Memory allocated with this function is
883 * automatically freed on driver detach.
886 * Address of allocated memory on success, 0 on failure.
889 unsigned long devm_get_free_pages(struct device
*dev
,
890 gfp_t gfp_mask
, unsigned int order
)
892 struct pages_devres
*devres
;
895 addr
= __get_free_pages(gfp_mask
, order
);
900 devres
= devres_alloc(devm_pages_release
,
901 sizeof(struct pages_devres
), GFP_KERNEL
);
902 if (unlikely(!devres
)) {
903 free_pages(addr
, order
);
908 devres
->order
= order
;
910 devres_add(dev
, devres
);
913 EXPORT_SYMBOL_GPL(devm_get_free_pages
);
916 * devm_free_pages - Resource-managed free_pages
917 * @dev: Device this memory belongs to
918 * @addr: Memory to free
920 * Free memory allocated with devm_get_free_pages(). Unlike free_pages,
921 * there is no need to supply the @order.
923 void devm_free_pages(struct device
*dev
, unsigned long addr
)
925 struct pages_devres devres
= { .addr
= addr
};
927 WARN_ON(devres_release(dev
, devm_pages_release
, devm_pages_match
,
930 EXPORT_SYMBOL_GPL(devm_free_pages
);
This page took 0.0504250000000001 seconds and 5 git commands to generate.