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