Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4

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

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