Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/base/devres.c

  1 /*
  2  * drivers/base/devres.c - device resource management
  3  *
  4  * Copyright (c) 2006  SUSE Linux Products GmbH
  5  * Copyright (c) 2006  Tejun Heo <teheo@suse.de>
  6  *
  7  * This file is released under the GPLv2.
  8  */
  9 
 10 #include <linux/device.h>
 11 #include <linux/module.h>
 12 #include <linux/slab.h>
 13 #include <linux/percpu.h>
 14 
 15 #include "base.h"
 16 
 17 struct devres_node {
 18         struct list_head                entry;
 19         dr_release_t                    release;
 20 #ifdef CONFIG_DEBUG_DEVRES
 21         const char                      *name;
 22         size_t                          size;
 23 #endif
 24 };
 25 
 26 struct devres {
 27         struct devres_node              node;
 28         /* -- 3 pointers */
 29         unsigned long long              data[]; /* guarantee ull alignment */
 30 };
 31 
 32 struct devres_group {
 33         struct devres_node              node[2];
 34         void                            *id;
 35         int                             color;
 36         /* -- 8 pointers */
 37 };
 38 
 39 #ifdef CONFIG_DEBUG_DEVRES
 40 static int log_devres = 0;
 41 module_param_named(log, log_devres, int, S_IRUGO | S_IWUSR);
 42 
 43 static void set_node_dbginfo(struct devres_node *node, const char *name,
 44                              size_t size)
 45 {
 46         node->name = name;
 47         node->size = size;
 48 }
 49 
 50 static void devres_log(struct device *dev, struct devres_node *node,
 51                        const char *op)
 52 {
 53         if (unlikely(log_devres))
 54                 dev_err(dev, "DEVRES %3s %p %s (%lu bytes)\n",
 55                         op, node, node->name, (unsigned long)node->size);
 56 }
 57 #else /* CONFIG_DEBUG_DEVRES */
 58 #define set_node_dbginfo(node, n, s)    do {} while (0)
 59 #define devres_log(dev, node, op)       do {} while (0)
 60 #endif /* CONFIG_DEBUG_DEVRES */
 61 
 62 /*
 63  * Release functions for devres group.  These callbacks are used only
 64  * for identification.
 65  */
 66 static void group_open_release(struct device *dev, void *res)
 67 {
 68         /* noop */
 69 }
 70 
 71 static void group_close_release(struct device *dev, void *res)
 72 {
 73         /* noop */
 74 }
 75 
 76 static struct devres_group * node_to_group(struct devres_node *node)
 77 {
 78         if (node->release == &group_open_release)
 79                 return container_of(node, struct devres_group, node[0]);
 80         if (node->release == &group_close_release)
 81                 return container_of(node, struct devres_group, node[1]);
 82         return NULL;
 83 }
 84 
 85 static __always_inline struct devres * alloc_dr(dr_release_t release,
 86                                                 size_t size, gfp_t gfp, int nid)
 87 {
 88         size_t tot_size = sizeof(struct devres) + size;
 89         struct devres *dr;
 90 
 91         dr = kmalloc_node_track_caller(tot_size, gfp, nid);
 92         if (unlikely(!dr))
 93                 return NULL;
 94 
 95         memset(dr, 0, offsetof(struct devres, data));
 96 
 97         INIT_LIST_HEAD(&dr->node.entry);
 98         dr->node.release = release;
 99         return dr;
100 }
101 
102 static void add_dr(struct device *dev, struct devres_node *node)
103 {
104         devres_log(dev, node, "ADD");
105         BUG_ON(!list_empty(&node->entry));
106         list_add_tail(&node->entry, &dev->devres_head);
107 }
108 
109 #ifdef CONFIG_DEBUG_DEVRES
110 void * __devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid,
111                       const char *name)
112 {
113         struct devres *dr;
114 
115         dr = alloc_dr(release, size, gfp | __GFP_ZERO, nid);
116         if (unlikely(!dr))
117                 return NULL;
118         set_node_dbginfo(&dr->node, name, size);
119         return dr->data;
120 }
121 EXPORT_SYMBOL_GPL(__devres_alloc_node);
122 #else
123 /**
124  * devres_alloc - Allocate device resource data
125  * @release: Release function devres will be associated with
126  * @size: Allocation size
127  * @gfp: Allocation flags
128  * @nid: NUMA node
129  *
130  * Allocate devres of @size bytes.  The allocated area is zeroed, then
131  * associated with @release.  The returned pointer can be passed to
132  * other devres_*() functions.
133  *
134  * RETURNS:
135  * Pointer to allocated devres on success, NULL on failure.
136  */
137 void * devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid)
138 {
139         struct devres *dr;
140 
141         dr = alloc_dr(release, size, gfp | __GFP_ZERO, nid);
142         if (unlikely(!dr))
143                 return NULL;
144         return dr->data;
145 }
146 EXPORT_SYMBOL_GPL(devres_alloc_node);
147 #endif
148 
149 /**
150  * devres_for_each_res - Resource iterator
151  * @dev: Device to iterate resource from
152  * @release: Look for resources associated with this release function
153  * @match: Match function (optional)
154  * @match_data: Data for the match function
155  * @fn: Function to be called for each matched resource.
156  * @data: Data for @fn, the 3rd parameter of @fn
157  *
158  * Call @fn for each devres of @dev which is associated with @release
159  * and for which @match returns 1.
160  *
161  * RETURNS:
162  *      void
163  */
164 void devres_for_each_res(struct device *dev, dr_release_t release,
165                         dr_match_t match, void *match_data,
166                         void (*fn)(struct device *, void *, void *),
167                         void *data)
168 {
169         struct devres_node *node;
170         struct devres_node *tmp;
171         unsigned long flags;
172 
173         if (!fn)
174                 return;
175 
176         spin_lock_irqsave(&dev->devres_lock, flags);
177         list_for_each_entry_safe_reverse(node, tmp,
178                         &dev->devres_head, entry) {
179                 struct devres *dr = container_of(node, struct devres, node);
180 
181                 if (node->release != release)
182                         continue;
183                 if (match && !match(dev, dr->data, match_data))
184                         continue;
185                 fn(dev, dr->data, data);
186         }
187         spin_unlock_irqrestore(&dev->devres_lock, flags);
188 }
189 EXPORT_SYMBOL_GPL(devres_for_each_res);
190 
191 /**
192  * devres_free - Free device resource data
193  * @res: Pointer to devres data to free
194  *
195  * Free devres created with devres_alloc().
196  */
197 void devres_free(void *res)
198 {
199         if (res) {
200                 struct devres *dr = container_of(res, struct devres, data);
201 
202                 BUG_ON(!list_empty(&dr->node.entry));
203                 kfree(dr);
204         }
205 }
206 EXPORT_SYMBOL_GPL(devres_free);
207 
208 /**
209  * devres_add - Register device resource
210  * @dev: Device to add resource to
211  * @res: Resource to register
212  *
213  * Register devres @res to @dev.  @res should have been allocated
214  * using devres_alloc().  On driver detach, the associated release
215  * function will be invoked and devres will be freed automatically.
216  */
217 void devres_add(struct device *dev, void *res)
218 {
219         struct devres *dr = container_of(res, struct devres, data);
220         unsigned long flags;
221 
222         spin_lock_irqsave(&dev->devres_lock, flags);
223         add_dr(dev, &dr->node);
224         spin_unlock_irqrestore(&dev->devres_lock, flags);
225 }
226 EXPORT_SYMBOL_GPL(devres_add);
227 
228 static struct devres *find_dr(struct device *dev, dr_release_t release,
229                               dr_match_t match, void *match_data)
230 {
231         struct devres_node *node;
232 
233         list_for_each_entry_reverse(node, &dev->devres_head, entry) {
234                 struct devres *dr = container_of(node, struct devres, node);
235 
236                 if (node->release != release)
237                         continue;
238                 if (match && !match(dev, dr->data, match_data))
239                         continue;
240                 return dr;
241         }
242 
243         return NULL;
244 }
245 
246 /**
247  * devres_find - Find device resource
248  * @dev: Device to lookup resource from
249  * @release: Look for resources associated with this release function
250  * @match: Match function (optional)
251  * @match_data: Data for the match function
252  *
253  * Find the latest devres of @dev which is associated with @release
254  * and for which @match returns 1.  If @match is NULL, it's considered
255  * to match all.
256  *
257  * RETURNS:
258  * Pointer to found devres, NULL if not found.
259  */
260 void * devres_find(struct device *dev, dr_release_t release,
261                    dr_match_t match, void *match_data)
262 {
263         struct devres *dr;
264         unsigned long flags;
265 
266         spin_lock_irqsave(&dev->devres_lock, flags);
267         dr = find_dr(dev, release, match, match_data);
268         spin_unlock_irqrestore(&dev->devres_lock, flags);
269 
270         if (dr)
271                 return dr->data;
272         return NULL;
273 }
274 EXPORT_SYMBOL_GPL(devres_find);
275 
276 /**
277  * devres_get - Find devres, if non-existent, add one atomically
278  * @dev: Device to lookup or add devres for
279  * @new_res: Pointer to new initialized devres to add if not found
280  * @match: Match function (optional)
281  * @match_data: Data for the match function
282  *
283  * Find the latest devres of @dev which has the same release function
284  * as @new_res and for which @match return 1.  If found, @new_res is
285  * freed; otherwise, @new_res is added atomically.
286  *
287  * RETURNS:
288  * Pointer to found or added devres.
289  */
290 void * devres_get(struct device *dev, void *new_res,
291                   dr_match_t match, void *match_data)
292 {
293         struct devres *new_dr = container_of(new_res, struct devres, data);
294         struct devres *dr;
295         unsigned long flags;
296 
297         spin_lock_irqsave(&dev->devres_lock, flags);
298         dr = find_dr(dev, new_dr->node.release, match, match_data);
299         if (!dr) {
300                 add_dr(dev, &new_dr->node);
301                 dr = new_dr;
302                 new_res = NULL;
303         }
304         spin_unlock_irqrestore(&dev->devres_lock, flags);
305         devres_free(new_res);
306 
307         return dr->data;
308 }
309 EXPORT_SYMBOL_GPL(devres_get);
310 
311 /**
312  * devres_remove - Find a device resource and remove it
313  * @dev: Device to find resource from
314  * @release: Look for resources associated with this release function
315  * @match: Match function (optional)
316  * @match_data: Data for the match function
317  *
318  * Find the latest devres of @dev associated with @release and for
319  * which @match returns 1.  If @match is NULL, it's considered to
320  * match all.  If found, the resource is removed atomically and
321  * returned.
322  *
323  * RETURNS:
324  * Pointer to removed devres on success, NULL if not found.
325  */
326 void * devres_remove(struct device *dev, dr_release_t release,
327                      dr_match_t match, void *match_data)
328 {
329         struct devres *dr;
330         unsigned long flags;
331 
332         spin_lock_irqsave(&dev->devres_lock, flags);
333         dr = find_dr(dev, release, match, match_data);
334         if (dr) {
335                 list_del_init(&dr->node.entry);
336                 devres_log(dev, &dr->node, "REM");
337         }
338         spin_unlock_irqrestore(&dev->devres_lock, flags);
339 
340         if (dr)
341                 return dr->data;
342         return NULL;
343 }
344 EXPORT_SYMBOL_GPL(devres_remove);
345 
346 /**
347  * devres_destroy - Find a device resource and destroy it
348  * @dev: Device to find resource from
349  * @release: Look for resources associated with this release function
350  * @match: Match function (optional)
351  * @match_data: Data for the match function
352  *
353  * Find the latest devres of @dev associated with @release and for
354  * which @match returns 1.  If @match is NULL, it's considered to
355  * match all.  If found, the resource is removed atomically and freed.
356  *
357  * Note that the release function for the resource will not be called,
358  * only the devres-allocated data will be freed.  The caller becomes
359  * responsible for freeing any other data.
360  *
361  * RETURNS:
362  * 0 if devres is found and freed, -ENOENT if not found.
363  */
364 int devres_destroy(struct device *dev, dr_release_t release,
365                    dr_match_t match, void *match_data)
366 {
367         void *res;
368 
369         res = devres_remove(dev, release, match, match_data);
370         if (unlikely(!res))
371                 return -ENOENT;
372 
373         devres_free(res);
374         return 0;
375 }
376 EXPORT_SYMBOL_GPL(devres_destroy);
377 
378 
379 /**
380  * devres_release - Find a device resource and destroy it, calling release
381  * @dev: Device to find resource from
382  * @release: Look for resources associated with this release function
383  * @match: Match function (optional)
384  * @match_data: Data for the match function
385  *
386  * Find the latest devres of @dev associated with @release and for
387  * which @match returns 1.  If @match is NULL, it's considered to
388  * match all.  If found, the resource is removed atomically, the
389  * release function called and the resource freed.
390  *
391  * RETURNS:
392  * 0 if devres is found and freed, -ENOENT if not found.
393  */
394 int devres_release(struct device *dev, dr_release_t release,
395                    dr_match_t match, void *match_data)
396 {
397         void *res;
398 
399         res = devres_remove(dev, release, match, match_data);
400         if (unlikely(!res))
401                 return -ENOENT;
402 
403         (*release)(dev, res);
404         devres_free(res);
405         return 0;
406 }
407 EXPORT_SYMBOL_GPL(devres_release);
408 
409 static int remove_nodes(struct device *dev,
410                         struct list_head *first, struct list_head *end,
411                         struct list_head *todo)
412 {
413         int cnt = 0, nr_groups = 0;
414         struct list_head *cur;
415 
416         /* First pass - move normal devres entries to @todo and clear
417          * devres_group colors.
418          */
419         cur = first;
420         while (cur != end) {
421                 struct devres_node *node;
422                 struct devres_group *grp;
423 
424                 node = list_entry(cur, struct devres_node, entry);
425                 cur = cur->next;
426 
427                 grp = node_to_group(node);
428                 if (grp) {
429                         /* clear color of group markers in the first pass */
430                         grp->color = 0;
431                         nr_groups++;
432                 } else {
433                         /* regular devres entry */
434                         if (&node->entry == first)
435                                 first = first->next;
436                         list_move_tail(&node->entry, todo);
437                         cnt++;
438                 }
439         }
440 
441         if (!nr_groups)
442                 return cnt;
443 
444         /* Second pass - Scan groups and color them.  A group gets
445          * color value of two iff the group is wholly contained in
446          * [cur, end).  That is, for a closed group, both opening and
447          * closing markers should be in the range, while just the
448          * opening marker is enough for an open group.
449          */
450         cur = first;
451         while (cur != end) {
452                 struct devres_node *node;
453                 struct devres_group *grp;
454 
455                 node = list_entry(cur, struct devres_node, entry);
456                 cur = cur->next;
457 
458                 grp = node_to_group(node);
459                 BUG_ON(!grp || list_empty(&grp->node[0].entry));
460 
461                 grp->color++;
462                 if (list_empty(&grp->node[1].entry))
463                         grp->color++;
464 
465                 BUG_ON(grp->color <= 0 || grp->color > 2);
466                 if (grp->color == 2) {
467                         /* No need to update cur or end.  The removed
468                          * nodes are always before both.
469                          */
470                         list_move_tail(&grp->node[0].entry, todo);
471                         list_del_init(&grp->node[1].entry);
472                 }
473         }
474 
475         return cnt;
476 }
477 
478 static int release_nodes(struct device *dev, struct list_head *first,
479                          struct list_head *end, unsigned long flags)
480         __releases(&dev->devres_lock)
481 {
482         LIST_HEAD(todo);
483         int cnt;
484         struct devres *dr, *tmp;
485 
486         cnt = remove_nodes(dev, first, end, &todo);
487 
488         spin_unlock_irqrestore(&dev->devres_lock, flags);
489 
490         /* Release.  Note that both devres and devres_group are
491          * handled as devres in the following loop.  This is safe.
492          */
493         list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry) {
494                 devres_log(dev, &dr->node, "REL");
495                 dr->node.release(dev, dr->data);
496                 kfree(dr);
497         }
498 
499         return cnt;
500 }
501 
502 /**
503  * devres_release_all - Release all managed resources
504  * @dev: Device to release resources for
505  *
506  * Release all resources associated with @dev.  This function is
507  * called on driver detach.
508  */
509 int devres_release_all(struct device *dev)
510 {
511         unsigned long flags;
512 
513         /* Looks like an uninitialized device structure */
514         if (WARN_ON(dev->devres_head.next == NULL))
515                 return -ENODEV;
516         spin_lock_irqsave(&dev->devres_lock, flags);
517         return release_nodes(dev, dev->devres_head.next, &dev->devres_head,
518                              flags);
519 }
520 
521 /**
522  * devres_open_group - Open a new devres group
523  * @dev: Device to open devres group for
524  * @id: Separator ID
525  * @gfp: Allocation flags
526  *
527  * Open a new devres group for @dev with @id.  For @id, using a
528  * pointer to an object which won't be used for another group is
529  * recommended.  If @id is NULL, address-wise unique ID is created.
530  *
531  * RETURNS:
532  * ID of the new group, NULL on failure.
533  */
534 void * devres_open_group(struct device *dev, void *id, gfp_t gfp)
535 {
536         struct devres_group *grp;
537         unsigned long flags;
538 
539         grp = kmalloc(sizeof(*grp), gfp);
540         if (unlikely(!grp))
541                 return NULL;
542 
543         grp->node[0].release = &group_open_release;
544         grp->node[1].release = &group_close_release;
545         INIT_LIST_HEAD(&grp->node[0].entry);
546         INIT_LIST_HEAD(&grp->node[1].entry);
547         set_node_dbginfo(&grp->node[0], "grp<", 0);
548         set_node_dbginfo(&grp->node[1], "grp>", 0);
549         grp->id = grp;
550         if (id)
551                 grp->id = id;
552 
553         spin_lock_irqsave(&dev->devres_lock, flags);
554         add_dr(dev, &grp->node[0]);
555         spin_unlock_irqrestore(&dev->devres_lock, flags);
556         return grp->id;
557 }
558 EXPORT_SYMBOL_GPL(devres_open_group);
559 
560 /* Find devres group with ID @id.  If @id is NULL, look for the latest. */
561 static struct devres_group * find_group(struct device *dev, void *id)
562 {
563         struct devres_node *node;
564 
565         list_for_each_entry_reverse(node, &dev->devres_head, entry) {
566                 struct devres_group *grp;
567 
568                 if (node->release != &group_open_release)
569                         continue;
570 
571                 grp = container_of(node, struct devres_group, node[0]);
572 
573                 if (id) {
574                         if (grp->id == id)
575                                 return grp;
576                 } else if (list_empty(&grp->node[1].entry))
577                         return grp;
578         }
579 
580         return NULL;
581 }
582 
583 /**
584  * devres_close_group - Close a devres group
585  * @dev: Device to close devres group for
586  * @id: ID of target group, can be NULL
587  *
588  * Close the group identified by @id.  If @id is NULL, the latest open
589  * group is selected.
590  */
591 void devres_close_group(struct device *dev, void *id)
592 {
593         struct devres_group *grp;
594         unsigned long flags;
595 
596         spin_lock_irqsave(&dev->devres_lock, flags);
597 
598         grp = find_group(dev, id);
599         if (grp)
600                 add_dr(dev, &grp->node[1]);
601         else
602                 WARN_ON(1);
603 
604         spin_unlock_irqrestore(&dev->devres_lock, flags);
605 }
606 EXPORT_SYMBOL_GPL(devres_close_group);
607 
608 /**
609  * devres_remove_group - Remove a devres group
610  * @dev: Device to remove group for
611  * @id: ID of target group, can be NULL
612  *
613  * Remove the group identified by @id.  If @id is NULL, the latest
614  * open group is selected.  Note that removing a group doesn't affect
615  * any other resources.
616  */
617 void devres_remove_group(struct device *dev, void *id)
618 {
619         struct devres_group *grp;
620         unsigned long flags;
621 
622         spin_lock_irqsave(&dev->devres_lock, flags);
623 
624         grp = find_group(dev, id);
625         if (grp) {
626                 list_del_init(&grp->node[0].entry);
627                 list_del_init(&grp->node[1].entry);
628                 devres_log(dev, &grp->node[0], "REM");
629         } else
630                 WARN_ON(1);
631 
632         spin_unlock_irqrestore(&dev->devres_lock, flags);
633 
634         kfree(grp);
635 }
636 EXPORT_SYMBOL_GPL(devres_remove_group);
637 
638 /**
639  * devres_release_group - Release resources in a devres group
640  * @dev: Device to release group for
641  * @id: ID of target group, can be NULL
642  *
643  * Release all resources in the group identified by @id.  If @id is
644  * NULL, the latest open group is selected.  The selected group and
645  * groups properly nested inside the selected group are removed.
646  *
647  * RETURNS:
648  * The number of released non-group resources.
649  */
650 int devres_release_group(struct device *dev, void *id)
651 {
652         struct devres_group *grp;
653         unsigned long flags;
654         int cnt = 0;
655 
656         spin_lock_irqsave(&dev->devres_lock, flags);
657 
658         grp = find_group(dev, id);
659         if (grp) {
660                 struct list_head *first = &grp->node[0].entry;
661                 struct list_head *end = &dev->devres_head;
662 
663                 if (!list_empty(&grp->node[1].entry))
664                         end = grp->node[1].entry.next;
665 
666                 cnt = release_nodes(dev, first, end, flags);
667         } else {
668                 WARN_ON(1);
669                 spin_unlock_irqrestore(&dev->devres_lock, flags);
670         }
671 
672         return cnt;
673 }
674 EXPORT_SYMBOL_GPL(devres_release_group);
675 
676 /*
677  * Custom devres actions allow inserting a simple function call
678  * into the teadown sequence.
679  */
680 
681 struct action_devres {
682         void *data;
683         void (*action)(void *);
684 };
685 
686 static int devm_action_match(struct device *dev, void *res, void *p)
687 {
688         struct action_devres *devres = res;
689         struct action_devres *target = p;
690 
691         return devres->action == target->action &&
692                devres->data == target->data;
693 }
694 
695 static void devm_action_release(struct device *dev, void *res)
696 {
697         struct action_devres *devres = res;
698 
699         devres->action(devres->data);
700 }
701 
702 /**
703  * devm_add_action() - add a custom action to list of managed resources
704  * @dev: Device that owns the action
705  * @action: Function that should be called
706  * @data: Pointer to data passed to @action implementation
707  *
708  * This adds a custom action to the list of managed resources so that
709  * it gets executed as part of standard resource unwinding.
710  */
711 int devm_add_action(struct device *dev, void (*action)(void *), void *data)
712 {
713         struct action_devres *devres;
714 
715         devres = devres_alloc(devm_action_release,
716                               sizeof(struct action_devres), GFP_KERNEL);
717         if (!devres)
718                 return -ENOMEM;
719 
720         devres->data = data;
721         devres->action = action;
722 
723         devres_add(dev, devres);
724         return 0;
725 }
726 EXPORT_SYMBOL_GPL(devm_add_action);
727 
728 /**
729  * devm_remove_action() - removes previously added custom action
730  * @dev: Device that owns the action
731  * @action: Function implementing the action
732  * @data: Pointer to data passed to @action implementation
733  *
734  * Removes instance of @action previously added by devm_add_action().
735  * Both action and data should match one of the existing entries.
736  */
737 void devm_remove_action(struct device *dev, void (*action)(void *), void *data)
738 {
739         struct action_devres devres = {
740                 .data = data,
741                 .action = action,
742         };
743 
744         WARN_ON(devres_destroy(dev, devm_action_release, devm_action_match,
745                                &devres));
746 
747 }
748 EXPORT_SYMBOL_GPL(devm_remove_action);
749 
750 /*
751  * Managed kmalloc/kfree
752  */
753 static void devm_kmalloc_release(struct device *dev, void *res)
754 {
755         /* noop */
756 }
757 
758 static int devm_kmalloc_match(struct device *dev, void *res, void *data)
759 {
760         return res == data;
761 }
762 
763 /**
764  * devm_kmalloc - Resource-managed kmalloc
765  * @dev: Device to allocate memory for
766  * @size: Allocation size
767  * @gfp: Allocation gfp flags
768  *
769  * Managed kmalloc.  Memory allocated with this function is
770  * automatically freed on driver detach.  Like all other devres
771  * resources, guaranteed alignment is unsigned long long.
772  *
773  * RETURNS:
774  * Pointer to allocated memory on success, NULL on failure.
775  */
776 void * devm_kmalloc(struct device *dev, size_t size, gfp_t gfp)
777 {
778         struct devres *dr;
779 
780         /* use raw alloc_dr for kmalloc caller tracing */
781         dr = alloc_dr(devm_kmalloc_release, size, gfp, dev_to_node(dev));
782         if (unlikely(!dr))
783                 return NULL;
784 
785         /*
786          * This is named devm_kzalloc_release for historical reasons
787          * The initial implementation did not support kmalloc, only kzalloc
788          */
789         set_node_dbginfo(&dr->node, "devm_kzalloc_release", size);
790         devres_add(dev, dr->data);
791         return dr->data;
792 }
793 EXPORT_SYMBOL_GPL(devm_kmalloc);
794 
795 /**
796  * devm_kstrdup - Allocate resource managed space and
797  *                copy an existing string into that.
798  * @dev: Device to allocate memory for
799  * @s: the string to duplicate
800  * @gfp: the GFP mask used in the devm_kmalloc() call when
801  *       allocating memory
802  * RETURNS:
803  * Pointer to allocated string on success, NULL on failure.
804  */
805 char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp)
806 {
807         size_t size;
808         char *buf;
809 
810         if (!s)
811                 return NULL;
812 
813         size = strlen(s) + 1;
814         buf = devm_kmalloc(dev, size, gfp);
815         if (buf)
816                 memcpy(buf, s, size);
817         return buf;
818 }
819 EXPORT_SYMBOL_GPL(devm_kstrdup);
820 
821 /**
822  * devm_kvasprintf - Allocate resource managed space and format a string
823  *                   into that.
824  * @dev: Device to allocate memory for
825  * @gfp: the GFP mask used in the devm_kmalloc() call when
826  *       allocating memory
827  * @fmt: The printf()-style format string
828  * @ap: Arguments for the format string
829  * RETURNS:
830  * Pointer to allocated string on success, NULL on failure.
831  */
832 char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
833                       va_list ap)
834 {
835         unsigned int len;
836         char *p;
837         va_list aq;
838 
839         va_copy(aq, ap);
840         len = vsnprintf(NULL, 0, fmt, aq);
841         va_end(aq);
842 
843         p = devm_kmalloc(dev, len+1, gfp);
844         if (!p)
845                 return NULL;
846 
847         vsnprintf(p, len+1, fmt, ap);
848 
849         return p;
850 }
851 EXPORT_SYMBOL(devm_kvasprintf);
852 
853 /**
854  * devm_kasprintf - Allocate resource managed space and format a string
855  *                  into that.
856  * @dev: Device to allocate memory for
857  * @gfp: the GFP mask used in the devm_kmalloc() call when
858  *       allocating memory
859  * @fmt: The printf()-style format string
860  * @...: Arguments for the format string
861  * RETURNS:
862  * Pointer to allocated string on success, NULL on failure.
863  */
864 char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)
865 {
866         va_list ap;
867         char *p;
868 
869         va_start(ap, fmt);
870         p = devm_kvasprintf(dev, gfp, fmt, ap);
871         va_end(ap);
872 
873         return p;
874 }
875 EXPORT_SYMBOL_GPL(devm_kasprintf);
876 
877 /**
878  * devm_kfree - Resource-managed kfree
879  * @dev: Device this memory belongs to
880  * @p: Memory to free
881  *
882  * Free memory allocated with devm_kmalloc().
883  */
884 void devm_kfree(struct device *dev, void *p)
885 {
886         int rc;
887 
888         rc = devres_destroy(dev, devm_kmalloc_release, devm_kmalloc_match, p);
889         WARN_ON(rc);
890 }
891 EXPORT_SYMBOL_GPL(devm_kfree);
892 
893 /**
894  * devm_kmemdup - Resource-managed kmemdup
895  * @dev: Device this memory belongs to
896  * @src: Memory region to duplicate
897  * @len: Memory region length
898  * @gfp: GFP mask to use
899  *
900  * Duplicate region of a memory using resource managed kmalloc
901  */
902 void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp)
903 {
904         void *p;
905 
906         p = devm_kmalloc(dev, len, gfp);
907         if (p)
908                 memcpy(p, src, len);
909 
910         return p;
911 }
912 EXPORT_SYMBOL_GPL(devm_kmemdup);
913 
914 struct pages_devres {
915         unsigned long addr;
916         unsigned int order;
917 };
918 
919 static int devm_pages_match(struct device *dev, void *res, void *p)
920 {
921         struct pages_devres *devres = res;
922         struct pages_devres *target = p;
923 
924         return devres->addr == target->addr;
925 }
926 
927 static void devm_pages_release(struct device *dev, void *res)
928 {
929         struct pages_devres *devres = res;
930 
931         free_pages(devres->addr, devres->order);
932 }
933 
934 /**
935  * devm_get_free_pages - Resource-managed __get_free_pages
936  * @dev: Device to allocate memory for
937  * @gfp_mask: Allocation gfp flags
938  * @order: Allocation size is (1 << order) pages
939  *
940  * Managed get_free_pages.  Memory allocated with this function is
941  * automatically freed on driver detach.
942  *
943  * RETURNS:
944  * Address of allocated memory on success, 0 on failure.
945  */
946 
947 unsigned long devm_get_free_pages(struct device *dev,
948                                   gfp_t gfp_mask, unsigned int order)
949 {
950         struct pages_devres *devres;
951         unsigned long addr;
952 
953         addr = __get_free_pages(gfp_mask, order);
954 
955         if (unlikely(!addr))
956                 return 0;
957 
958         devres = devres_alloc(devm_pages_release,
959                               sizeof(struct pages_devres), GFP_KERNEL);
960         if (unlikely(!devres)) {
961                 free_pages(addr, order);
962                 return 0;
963         }
964 
965         devres->addr = addr;
966         devres->order = order;
967 
968         devres_add(dev, devres);
969         return addr;
970 }
971 EXPORT_SYMBOL_GPL(devm_get_free_pages);
972 
973 /**
974  * devm_free_pages - Resource-managed free_pages
975  * @dev: Device this memory belongs to
976  * @addr: Memory to free
977  *
978  * Free memory allocated with devm_get_free_pages(). Unlike free_pages,
979  * there is no need to supply the @order.
980  */
981 void devm_free_pages(struct device *dev, unsigned long addr)
982 {
983         struct pages_devres devres = { .addr = addr };
984 
985         WARN_ON(devres_release(dev, devm_pages_release, devm_pages_match,
986                                &devres));
987 }
988 EXPORT_SYMBOL_GPL(devm_free_pages);
989 
990 static void devm_percpu_release(struct device *dev, void *pdata)
991 {
992         void __percpu *p;
993 
994         p = *(void __percpu **)pdata;
995         free_percpu(p);
996 }
997 
998 static int devm_percpu_match(struct device *dev, void *data, void *p)
999 {
1000         struct devres *devr = container_of(data, struct devres, data);
1001 
1002         return *(void **)devr->data == p;
1003 }
1004 
1005 /**
1006  * __devm_alloc_percpu - Resource-managed alloc_percpu
1007  * @dev: Device to allocate per-cpu memory for
1008  * @size: Size of per-cpu memory to allocate
1009  * @align: Alignment of per-cpu memory to allocate
1010  *
1011  * Managed alloc_percpu. Per-cpu memory allocated with this function is
1012  * automatically freed on driver detach.
1013  *
1014  * RETURNS:
1015  * Pointer to allocated memory on success, NULL on failure.
1016  */
1017 void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
1018                 size_t align)
1019 {
1020         void *p;
1021         void __percpu *pcpu;
1022 
1023         pcpu = __alloc_percpu(size, align);
1024         if (!pcpu)
1025                 return NULL;
1026 
1027         p = devres_alloc(devm_percpu_release, sizeof(void *), GFP_KERNEL);
1028         if (!p) {
1029                 free_percpu(pcpu);
1030                 return NULL;
1031         }
1032 
1033         *(void __percpu **)p = pcpu;
1034 
1035         devres_add(dev, p);
1036 
1037         return pcpu;
1038 }
1039 EXPORT_SYMBOL_GPL(__devm_alloc_percpu);
1040 
1041 /**
1042  * devm_free_percpu - Resource-managed free_percpu
1043  * @dev: Device this memory belongs to
1044  * @pdata: Per-cpu memory to free
1045  *
1046  * Free memory allocated with devm_alloc_percpu().
1047  */
1048 void devm_free_percpu(struct device *dev, void __percpu *pdata)
1049 {
1050         WARN_ON(devres_destroy(dev, devm_percpu_release, devm_percpu_match,
1051                                (void *)pdata));
1052 }
1053 EXPORT_SYMBOL_GPL(devm_free_percpu);
1054 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us