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_printk(KERN_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)
  86{
  87        size_t tot_size = sizeof(struct devres) + size;
  88        struct devres *dr;
  89
  90        dr = kmalloc_track_caller(tot_size, gfp);
  91        if (unlikely(!dr))
  92                return NULL;
  93
  94        memset(dr, 0, tot_size);
  95        INIT_LIST_HEAD(&dr->node.entry);
  96        dr->node.release = release;
  97        return dr;
  98}
  99
 100static void add_dr(struct device *dev, struct devres_node *node)
 101{
 102        devres_log(dev, node, "ADD");
 103        BUG_ON(!list_empty(&node->entry));
 104        list_add_tail(&node->entry, &dev->devres_head);
 105}
 106
 107#ifdef CONFIG_DEBUG_DEVRES
 108void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
 109                      const char *name)
 110{
 111        struct devres *dr;
 112
 113        dr = alloc_dr(release, size, gfp);
 114        if (unlikely(!dr))
 115                return NULL;
 116        set_node_dbginfo(&dr->node, name, size);
 117        return dr->data;
 118}
 119EXPORT_SYMBOL_GPL(__devres_alloc);
 120#else
 121/**
 122 * devres_alloc - Allocate device resource data
 123 * @release: Release function devres will be associated with
 124 * @size: Allocation size
 125 * @gfp: Allocation flags
 126 *
 127 * Allocate devres of @size bytes.  The allocated area is zeroed, then
 128 * associated with @release.  The returned pointer can be passed to
 129 * other devres_*() functions.
 130 *
 131 * RETURNS:
 132 * Pointer to allocated devres on success, NULL on failure.
 133 */
 134void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
 135{
 136        struct devres *dr;
 137
 138        dr = alloc_dr(release, size, gfp);
 139        if (unlikely(!dr))
 140                return NULL;
 141        return dr->data;
 142}
 143EXPORT_SYMBOL_GPL(devres_alloc);
 144#endif
 145
 146/**
 147 * devres_free - Free device resource data
 148 * @res: Pointer to devres data to free
 149 *
 150 * Free devres created with devres_alloc().
 151 */
 152void devres_free(void *res)
 153{
 154        if (res) {
 155                struct devres *dr = container_of(res, struct devres, data);
 156
 157                BUG_ON(!list_empty(&dr->node.entry));
 158                kfree(dr);
 159        }
 160}
 161EXPORT_SYMBOL_GPL(devres_free);
 162
 163/**
 164 * devres_add - Register device resource
 165 * @dev: Device to add resource to
 166 * @res: Resource to register
 167 *
 168 * Register devres @res to @dev.  @res should have been allocated
 169 * using devres_alloc().  On driver detach, the associated release
 170 * function will be invoked and devres will be freed automatically.
 171 */
 172void devres_add(struct device *dev, void *res)
 173{
 174        struct devres *dr = container_of(res, struct devres, data);
 175        unsigned long flags;
 176
 177        spin_lock_irqsave(&dev->devres_lock, flags);
 178        add_dr(dev, &dr->node);
 179        spin_unlock_irqrestore(&dev->devres_lock, flags);
 180}
 181EXPORT_SYMBOL_GPL(devres_add);
 182
 183static struct devres *find_dr(struct device *dev, dr_release_t release,
 184                              dr_match_t match, void *match_data)
 185{
 186        struct devres_node *node;
 187
 188        list_for_each_entry_reverse(node, &dev->devres_head, entry) {
 189                struct devres *dr = container_of(node, struct devres, node);
 190
 191                if (node->release != release)
 192                        continue;
 193                if (match && !match(dev, dr->data, match_data))
 194                        continue;
 195                return dr;
 196        }
 197
 198        return NULL;
 199}
 200
 201/**
 202 * devres_find - Find device resource
 203 * @dev: Device to lookup resource from
 204 * @release: Look for resources associated with this release function
 205 * @match: Match function (optional)
 206 * @match_data: Data for the match function
 207 *
 208 * Find the latest devres of @dev which is associated with @release
 209 * and for which @match returns 1.  If @match is NULL, it's considered
 210 * to match all.
 211 *
 212 * RETURNS:
 213 * Pointer to found devres, NULL if not found.
 214 */
 215void * devres_find(struct device *dev, dr_release_t release,
 216                   dr_match_t match, void *match_data)
 217{
 218        struct devres *dr;
 219        unsigned long flags;
 220
 221        spin_lock_irqsave(&dev->devres_lock, flags);
 222        dr = find_dr(dev, release, match, match_data);
 223        spin_unlock_irqrestore(&dev->devres_lock, flags);
 224
 225        if (dr)
 226                return dr->data;
 227        return NULL;
 228}
 229EXPORT_SYMBOL_GPL(devres_find);
 230
 231/**
 232 * devres_get - Find devres, if non-existent, add one atomically
 233 * @dev: Device to lookup or add devres for
 234 * @new_res: Pointer to new initialized devres to add if not found
 235 * @match: Match function (optional)
 236 * @match_data: Data for the match function
 237 *
 238 * Find the latest devres of @dev which has the same release function
 239 * as @new_res and for which @match return 1.  If found, @new_res is
 240 * freed; otherwise, @new_res is added atomically.
 241 *
 242 * RETURNS:
 243 * Pointer to found or added devres.
 244 */
 245void * devres_get(struct device *dev, void *new_res,
 246                  dr_match_t match, void *match_data)
 247{
 248        struct devres *new_dr = container_of(new_res, struct devres, data);
 249        struct devres *dr;
 250        unsigned long flags;
 251
 252        spin_lock_irqsave(&dev->devres_lock, flags);
 253        dr = find_dr(dev, new_dr->node.release, match, match_data);
 254        if (!dr) {
 255                add_dr(dev, &new_dr->node);
 256                dr = new_dr;
 257                new_dr = NULL;
 258        }
 259        spin_unlock_irqrestore(&dev->devres_lock, flags);
 260        devres_free(new_dr);
 261
 262        return dr->data;
 263}
 264EXPORT_SYMBOL_GPL(devres_get);
 265
 266/**
 267 * devres_remove - Find a device resource and remove it
 268 * @dev: Device to find resource from
 269 * @release: Look for resources associated with this release function
 270 * @match: Match function (optional)
 271 * @match_data: Data for the match function
 272 *
 273 * Find the latest devres of @dev associated with @release and for
 274 * which @match returns 1.  If @match is NULL, it's considered to
 275 * match all.  If found, the resource is removed atomically and
 276 * returned.
 277 *
 278 * RETURNS:
 279 * Pointer to removed devres on success, NULL if not found.
 280 */
 281void * devres_remove(struct device *dev, dr_release_t release,
 282                     dr_match_t match, void *match_data)
 283{
 284        struct devres *dr;
 285        unsigned long flags;
 286
 287        spin_lock_irqsave(&dev->devres_lock, flags);
 288        dr = find_dr(dev, release, match, match_data);
 289        if (dr) {
 290                list_del_init(&dr->node.entry);
 291                devres_log(dev, &dr->node, "REM");
 292        }
 293        spin_unlock_irqrestore(&dev->devres_lock, flags);
 294
 295        if (dr)
 296                return dr->data;
 297        return NULL;
 298}
 299EXPORT_SYMBOL_GPL(devres_remove);
 300
 301/**
 302 * devres_destroy - Find a device resource and destroy it
 303 * @dev: Device to find resource from
 304 * @release: Look for resources associated with this release function
 305 * @match: Match function (optional)
 306 * @match_data: Data for the match function
 307 *
 308 * Find the latest devres of @dev associated with @release and for
 309 * which @match returns 1.  If @match is NULL, it's considered to
 310 * match all.  If found, the resource is removed atomically and freed.
 311 *
 312 * Note that the release function for the resource will not be called,
 313 * only the devres-allocated data will be freed.  The caller becomes
 314 * responsible for freeing any other data.
 315 *
 316 * RETURNS:
 317 * 0 if devres is found and freed, -ENOENT if not found.
 318 */
 319int devres_destroy(struct device *dev, dr_release_t release,
 320                   dr_match_t match, void *match_data)
 321{
 322        void *res;
 323
 324        res = devres_remove(dev, release, match, match_data);
 325        if (unlikely(!res))
 326                return -ENOENT;
 327
 328        devres_free(res);
 329        return 0;
 330}
 331EXPORT_SYMBOL_GPL(devres_destroy);
 332
 333
 334/**
 335 * devres_release - Find a device resource and destroy it, calling release
 336 * @dev: Device to find resource from
 337 * @release: Look for resources associated with this release function
 338 * @match: Match function (optional)
 339 * @match_data: Data for the match function
 340 *
 341 * Find the latest devres of @dev associated with @release and for
 342 * which @match returns 1.  If @match is NULL, it's considered to
 343 * match all.  If found, the resource is removed atomically, the
 344 * release function called and the resource freed.
 345 *
 346 * RETURNS:
 347 * 0 if devres is found and freed, -ENOENT if not found.
 348 */
 349int devres_release(struct device *dev, dr_release_t release,
 350                   dr_match_t match, void *match_data)
 351{
 352        void *res;
 353
 354        res = devres_remove(dev, release, match, match_data);
 355        if (unlikely(!res))
 356                return -ENOENT;
 357
 358        (*release)(dev, res);
 359        devres_free(res);
 360        return 0;
 361}
 362EXPORT_SYMBOL_GPL(devres_release);
 363
 364static int remove_nodes(struct device *dev,
 365                        struct list_head *first, struct list_head *end,
 366                        struct list_head *todo)
 367{
 368        int cnt = 0, nr_groups = 0;
 369        struct list_head *cur;
 370
 371        /* First pass - move normal devres entries to @todo and clear
 372         * devres_group colors.
 373         */
 374        cur = first;
 375        while (cur != end) {
 376                struct devres_node *node;
 377                struct devres_group *grp;
 378
 379                node = list_entry(cur, struct devres_node, entry);
 380                cur = cur->next;
 381
 382                grp = node_to_group(node);
 383                if (grp) {
 384                        /* clear color of group markers in the first pass */
 385                        grp->color = 0;
 386                        nr_groups++;
 387                } else {
 388                        /* regular devres entry */
 389                        if (&node->entry == first)
 390                                first = first->next;
 391                        list_move_tail(&node->entry, todo);
 392                        cnt++;
 393                }
 394        }
 395
 396        if (!nr_groups)
 397                return cnt;
 398
 399        /* Second pass - Scan groups and color them.  A group gets
 400         * color value of two iff the group is wholly contained in
 401         * [cur, end).  That is, for a closed group, both opening and
 402         * closing markers should be in the range, while just the
 403         * opening marker is enough for an open group.
 404         */
 405        cur = first;
 406        while (cur != end) {
 407                struct devres_node *node;
 408                struct devres_group *grp;
 409
 410                node = list_entry(cur, struct devres_node, entry);
 411                cur = cur->next;
 412
 413                grp = node_to_group(node);
 414                BUG_ON(!grp || list_empty(&grp->node[0].entry));
 415
 416                grp->color++;
 417                if (list_empty(&grp->node[1].entry))
 418                        grp->color++;
 419
 420                BUG_ON(grp->color <= 0 || grp->color > 2);
 421                if (grp->color == 2) {
 422                        /* No need to update cur or end.  The removed
 423                         * nodes are always before both.
 424                         */
 425                        list_move_tail(&grp->node[0].entry, todo);
 426                        list_del_init(&grp->node[1].entry);
 427                }
 428        }
 429
 430        return cnt;
 431}
 432
 433static int release_nodes(struct device *dev, struct list_head *first,
 434                         struct list_head *end, unsigned long flags)
 435        __releases(&dev->devres_lock)
 436{
 437        LIST_HEAD(todo);
 438        int cnt;
 439        struct devres *dr, *tmp;
 440
 441        cnt = remove_nodes(dev, first, end, &todo);
 442
 443        spin_unlock_irqrestore(&dev->devres_lock, flags);
 444
 445        /* Release.  Note that both devres and devres_group are
 446         * handled as devres in the following loop.  This is safe.
 447         */
 448        list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry) {
 449                devres_log(dev, &dr->node, "REL");
 450                dr->node.release(dev, dr->data);
 451                kfree(dr);
 452        }
 453
 454        return cnt;
 455}
 456
 457/**
 458 * devres_release_all - Release all managed resources
 459 * @dev: Device to release resources for
 460 *
 461 * Release all resources associated with @dev.  This function is
 462 * called on driver detach.
 463 */
 464int devres_release_all(struct device *dev)
 465{
 466        unsigned long flags;
 467
 468        /* Looks like an uninitialized device structure */
 469        if (WARN_ON(dev->devres_head.next == NULL))
 470                return -ENODEV;
 471        spin_lock_irqsave(&dev->devres_lock, flags);
 472        return release_nodes(dev, dev->devres_head.next, &dev->devres_head,
 473                             flags);
 474}
 475
 476/**
 477 * devres_open_group - Open a new devres group
 478 * @dev: Device to open devres group for
 479 * @id: Separator ID
 480 * @gfp: Allocation flags
 481 *
 482 * Open a new devres group for @dev with @id.  For @id, using a
 483 * pointer to an object which won't be used for another group is
 484 * recommended.  If @id is NULL, address-wise unique ID is created.
 485 *
 486 * RETURNS:
 487 * ID of the new group, NULL on failure.
 488 */
 489void * devres_open_group(struct device *dev, void *id, gfp_t gfp)
 490{
 491        struct devres_group *grp;
 492        unsigned long flags;
 493
 494        grp = kmalloc(sizeof(*grp), gfp);
 495        if (unlikely(!grp))
 496                return NULL;
 497
 498        grp->node[0].release = &group_open_release;
 499        grp->node[1].release = &group_close_release;
 500        INIT_LIST_HEAD(&grp->node[0].entry);
 501        INIT_LIST_HEAD(&grp->node[1].entry);
 502        set_node_dbginfo(&grp->node[0], "grp<", 0);
 503        set_node_dbginfo(&grp->node[1], "grp>", 0);
 504        grp->id = grp;
 505        if (id)
 506                grp->id = id;
 507
 508        spin_lock_irqsave(&dev->devres_lock, flags);
 509        add_dr(dev, &grp->node[0]);
 510        spin_unlock_irqrestore(&dev->devres_lock, flags);
 511        return grp->id;
 512}
 513EXPORT_SYMBOL_GPL(devres_open_group);
 514
 515/* Find devres group with ID @id.  If @id is NULL, look for the latest. */
 516static struct devres_group * find_group(struct device *dev, void *id)
 517{
 518        struct devres_node *node;
 519
 520        list_for_each_entry_reverse(node, &dev->devres_head, entry) {
 521                struct devres_group *grp;
 522
 523                if (node->release != &group_open_release)
 524                        continue;
 525
 526                grp = container_of(node, struct devres_group, node[0]);
 527
 528                if (id) {
 529                        if (grp->id == id)
 530                                return grp;
 531                } else if (list_empty(&grp->node[1].entry))
 532                        return grp;
 533        }
 534
 535        return NULL;
 536}
 537
 538/**
 539 * devres_close_group - Close a devres group
 540 * @dev: Device to close devres group for
 541 * @id: ID of target group, can be NULL
 542 *
 543 * Close the group identified by @id.  If @id is NULL, the latest open
 544 * group is selected.
 545 */
 546void devres_close_group(struct device *dev, void *id)
 547{
 548        struct devres_group *grp;
 549        unsigned long flags;
 550
 551        spin_lock_irqsave(&dev->devres_lock, flags);
 552
 553        grp = find_group(dev, id);
 554        if (grp)
 555                add_dr(dev, &grp->node[1]);
 556        else
 557                WARN_ON(1);
 558
 559        spin_unlock_irqrestore(&dev->devres_lock, flags);
 560}
 561EXPORT_SYMBOL_GPL(devres_close_group);
 562
 563/**
 564 * devres_remove_group - Remove a devres group
 565 * @dev: Device to remove group for
 566 * @id: ID of target group, can be NULL
 567 *
 568 * Remove the group identified by @id.  If @id is NULL, the latest
 569 * open group is selected.  Note that removing a group doesn't affect
 570 * any other resources.
 571 */
 572void devres_remove_group(struct device *dev, void *id)
 573{
 574        struct devres_group *grp;
 575        unsigned long flags;
 576
 577        spin_lock_irqsave(&dev->devres_lock, flags);
 578
 579        grp = find_group(dev, id);
 580        if (grp) {
 581                list_del_init(&grp->node[0].entry);
 582                list_del_init(&grp->node[1].entry);
 583                devres_log(dev, &grp->node[0], "REM");
 584        } else
 585                WARN_ON(1);
 586
 587        spin_unlock_irqrestore(&dev->devres_lock, flags);
 588
 589        kfree(grp);
 590}
 591EXPORT_SYMBOL_GPL(devres_remove_group);
 592
 593/**
 594 * devres_release_group - Release resources in a devres group
 595 * @dev: Device to release group for
 596 * @id: ID of target group, can be NULL
 597 *
 598 * Release all resources in the group identified by @id.  If @id is
 599 * NULL, the latest open group is selected.  The selected group and
 600 * groups properly nested inside the selected group are removed.
 601 *
 602 * RETURNS:
 603 * The number of released non-group resources.
 604 */
 605int devres_release_group(struct device *dev, void *id)
 606{
 607        struct devres_group *grp;
 608        unsigned long flags;
 609        int cnt = 0;
 610
 611        spin_lock_irqsave(&dev->devres_lock, flags);
 612
 613        grp = find_group(dev, id);
 614        if (grp) {
 615                struct list_head *first = &grp->node[0].entry;
 616                struct list_head *end = &dev->devres_head;
 617
 618                if (!list_empty(&grp->node[1].entry))
 619                        end = grp->node[1].entry.next;
 620
 621                cnt = release_nodes(dev, first, end, flags);
 622        } else {
 623                WARN_ON(1);
 624                spin_unlock_irqrestore(&dev->devres_lock, flags);
 625        }
 626
 627        return cnt;
 628}
 629EXPORT_SYMBOL_GPL(devres_release_group);
 630
 631/*
 632 * Managed kzalloc/kfree
 633 */
 634static void devm_kzalloc_release(struct device *dev, void *res)
 635{
 636        /* noop */
 637}
 638
 639static int devm_kzalloc_match(struct device *dev, void *res, void *data)
 640{
 641        return res == data;
 642}
 643
 644/**
 645 * devm_kzalloc - Resource-managed kzalloc
 646 * @dev: Device to allocate memory for
 647 * @size: Allocation size
 648 * @gfp: Allocation gfp flags
 649 *
 650 * Managed kzalloc.  Memory allocated with this function is
 651 * automatically freed on driver detach.  Like all other devres
 652 * resources, guaranteed alignment is unsigned long long.
 653 *
 654 * RETURNS:
 655 * Pointer to allocated memory on success, NULL on failure.
 656 */
 657void * devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
 658{
 659        struct devres *dr;
 660
 661        /* use raw alloc_dr for kmalloc caller tracing */
 662        dr = alloc_dr(devm_kzalloc_release, size, gfp);
 663        if (unlikely(!dr))
 664                return NULL;
 665
 666        set_node_dbginfo(&dr->node, "devm_kzalloc_release", size);
 667        devres_add(dev, dr->data);
 668        return dr->data;
 669}
 670EXPORT_SYMBOL_GPL(devm_kzalloc);
 671
 672/**
 673 * devm_kfree - Resource-managed kfree
 674 * @dev: Device this memory belongs to
 675 * @p: Memory to free
 676 *
 677 * Free memory allocated with devm_kzalloc().
 678 */
 679void devm_kfree(struct device *dev, void *p)
 680{
 681        int rc;
 682
 683        rc = devres_destroy(dev, devm_kzalloc_release, devm_kzalloc_match, p);
 684        WARN_ON(rc);
 685}
 686EXPORT_SYMBOL_GPL(devm_kfree);
 687
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.