linux/drivers/base/devres.c
<<
>>
Prefs
   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
  16struct 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
  25struct devres {
  26        struct devres_node              node;
  27        /* -- 3 pointers */
  28        unsigned long long              data[]; /* guarantee ull alignment */
  29};
  30
  31struct devres_group {
  32        struct devres_node              node[2];
  33        void                            *id;
  34        int                             color;
  35        /* -- 8 pointers */
  36};
  37
  38#ifdef CONFIG_DEBUG_DEVRES
  39static int log_devres = 0;
  40module_param_named(log, log_devres, int, S_IRUGO | S_IWUSR);
  41
  42static 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
  49static 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 */
  65static void group_open_release(struct device *dev, void *res)
  66{
  67        /* noop */
  68}
  69
  70static void group_close_release(struct device *dev, void *res)
  71{
  72        /* noop */
  73}
  74
  75static 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
  84static __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
 101static 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
 109void * __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}
 120EXPORT_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 */
 136void * 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}
 145EXPORT_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 */
 163void 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}
 188EXPORT_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 */
 196void 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}
 205EXPORT_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 */
 216void 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}
 225EXPORT_SYMBOL_GPL(devres_add);
 226
 227static 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 */
 259void * 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}
 273EXPORT_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 */
 289void * 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_dr = NULL;
 302        }
 303        spin_unlock_irqrestore(&dev->devres_lock, flags);
 304        devres_free(new_dr);
 305
 306        return dr->data;
 307}
 308EXPORT_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 */
 325void * 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}
 343EXPORT_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 */
 363int 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}
 375EXPORT_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 */
 393int 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}
 406EXPORT_SYMBOL_GPL(devres_release);
 407
 408static 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
 477static 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 */
 508int 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 */
 533void * 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}
 557EXPORT_SYMBOL_GPL(devres_open_group);
 558
 559/* Find devres group with ID @id.  If @id is NULL, look for the latest. */
 560static 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 */
 590void 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}
 605EXPORT_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 */
 616void 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}
 635EXPORT_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 */
 649int 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}
 673EXPORT_SYMBOL_GPL(devres_release_group);
 674
 675/*
 676 * Custom devres actions allow inserting a simple function call
 677 * into the teadown sequence.
 678 */
 679
 680struct action_devres {
 681        void *data;
 682        void (*action)(void *);
 683};
 684
 685static 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
 694static 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 */
 710int 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}
 725EXPORT_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 */
 736void 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}
 747EXPORT_SYMBOL_GPL(devm_remove_action);
 748
 749/*
 750 * Managed kmalloc/kfree
 751 */
 752static void devm_kmalloc_release(struct device *dev, void *res)
 753{
 754        /* noop */
 755}
 756
 757static 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 */
 775void * 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}
 792EXPORT_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 */
 804char *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}
 818EXPORT_SYMBOL_GPL(devm_kstrdup);
 819
 820/**
 821 * devm_kvasprintf - Allocate resource managed space
 822 *                      for the formatted string.
 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 formatted string to duplicate
 827 * @ap: the list of tokens to be placed in the formatted string
 828 * RETURNS:
 829 * Pointer to allocated string on success, NULL on failure.
 830 */
 831char *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}
 850EXPORT_SYMBOL(devm_kvasprintf);
 851
 852/**
 853 * devm_kasprintf - Allocate resource managed space
 854 *              and copy an existing formatted string 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 string to duplicate
 859 * RETURNS:
 860 * Pointer to allocated string on success, NULL on failure.
 861 */
 862char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)
 863{
 864        va_list ap;
 865        char *p;
 866
 867        va_start(ap, fmt);
 868        p = devm_kvasprintf(dev, gfp, fmt, ap);
 869        va_end(ap);
 870
 871        return p;
 872}
 873EXPORT_SYMBOL_GPL(devm_kasprintf);
 874
 875/**
 876 * devm_kfree - Resource-managed kfree
 877 * @dev: Device this memory belongs to
 878 * @p: Memory to free
 879 *
 880 * Free memory allocated with devm_kmalloc().
 881 */
 882void devm_kfree(struct device *dev, void *p)
 883{
 884        int rc;
 885
 886        rc = devres_destroy(dev, devm_kmalloc_release, devm_kmalloc_match, p);
 887        WARN_ON(rc);
 888}
 889EXPORT_SYMBOL_GPL(devm_kfree);
 890
 891/**
 892 * devm_kmemdup - Resource-managed kmemdup
 893 * @dev: Device this memory belongs to
 894 * @src: Memory region to duplicate
 895 * @len: Memory region length
 896 * @gfp: GFP mask to use
 897 *
 898 * Duplicate region of a memory using resource managed kmalloc
 899 */
 900void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp)
 901{
 902        void *p;
 903
 904        p = devm_kmalloc(dev, len, gfp);
 905        if (p)
 906                memcpy(p, src, len);
 907
 908        return p;
 909}
 910EXPORT_SYMBOL_GPL(devm_kmemdup);
 911