mm/kmemleak: turn kmemleak_lock and object->lock to raw_spinlock_t

 *

 * The following locks and mutexes are used by kmemleak:

 *

 * - kmemleak_lock (rwlock): protects the object_list modifications and

 * - kmemleak_lock (raw_spinlock_t): protects the object_list modifications and

 *   accesses to the object_tree_root. The object_list is the main list

 *   holding the metadata (struct kmemleak_object) for the allocated memory

 *   blocks. The object_tree_root is a red black tree used to look-up

 *   object_tree_root in the create_object() function called from the

 *   kmemleak_alloc() callback and removed in delete_object() called from the

 *   kmemleak_free() callback

 * - kmemleak_object.lock (spinlock): protects a kmemleak_object. Accesses to

 *   the metadata (e.g. count) are protected by this lock. Note that some

 *   members of this structure may be protected by other means (atomic or

 *   kmemleak_lock). This lock is also held when scanning the corresponding

 *   memory block to avoid the kernel freeing it via the kmemleak_free()

 *   callback. This is less heavyweight than holding a global lock like

 *   kmemleak_lock during scanning

 * - kmemleak_object.lock (raw_spinlock_t): protects a kmemleak_object.

 *   Accesses to the metadata (e.g. count) are protected by this lock. Note

 *   that some members of this structure may be protected by other means

 *   (atomic or kmemleak_lock). This lock is also held when scanning the

 *   corresponding memory block to avoid the kernel freeing it via the

 *   kmemleak_free() callback. This is less heavyweight than holding a global

 *   lock like kmemleak_lock during scanning.

 * - scan_mutex (mutex): ensures that only one thread may scan the memory for

 *   unreferenced objects at a time. The gray_list contains the objects which

 *   are already referenced or marked as false positives and need to be

 * (use_count) and freed using the RCU mechanism.

 */

struct kmemleak_object {

	spinlock_t lock;

	raw_spinlock_t lock;

	unsigned int flags;		/* object status flags */

	struct list_head object_list;

	struct list_head gray_list;

static LIST_HEAD(mem_pool_free_list);

/* search tree for object boundaries */

static struct rb_root object_tree_root = RB_ROOT;

/* rw_lock protecting the access to object_list and object_tree_root */

static DEFINE_RWLOCK(kmemleak_lock);

/* protecting the access to object_list and object_tree_root */

static DEFINE_RAW_SPINLOCK(kmemleak_lock);

/* allocation caches for kmemleak internal data */

static struct kmem_cache *object_cache;

	}

	/* slab allocation failed, try the memory pool */

	write_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	object = list_first_entry_or_null(&mem_pool_free_list,

					  typeof(*object), object_list);

	if (object)

		object = &mem_pool[--mem_pool_free_count];

	else

		pr_warn_once("Memory pool empty, consider increasing CONFIG_DEBUG_KMEMLEAK_MEM_POOL_SIZE\n");

	write_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

	return object;

}

	}

	/* add the object to the memory pool free list */

	write_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	list_add(&object->object_list, &mem_pool_free_list);

	write_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

}

/*

	struct kmemleak_object *object;

	rcu_read_lock();

	read_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	object = lookup_object(ptr, alias);

	read_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

	/* check whether the object is still available */

	if (object && !get_object(object))

	unsigned long flags;

	struct kmemleak_object *object;

	write_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	object = lookup_object(ptr, alias);

	if (object)

		__remove_object(object);

	write_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

	return object;

}

	INIT_LIST_HEAD(&object->object_list);

	INIT_LIST_HEAD(&object->gray_list);

	INIT_HLIST_HEAD(&object->area_list);

	spin_lock_init(&object->lock);

	raw_spin_lock_init(&object->lock);

	atomic_set(&object->use_count, 1);

	object->flags = OBJECT_ALLOCATED;

	object->pointer = ptr;

	/* kernel backtrace */

	object->trace_len = __save_stack_trace(object->trace);

	write_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	untagged_ptr = (unsigned long)kasan_reset_tag((void *)ptr);

	min_addr = min(min_addr, untagged_ptr);

	list_add_tail_rcu(&object->object_list, &object_list);

out:

	write_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

	return object;

}

	 * Locking here also ensures that the corresponding memory block

	 * cannot be freed when it is being scanned.

	 */

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	object->flags &= ~OBJECT_ALLOCATED;

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

}

{

	unsigned long flags;

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	__paint_it(object, color);

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

}

static void paint_ptr(unsigned long ptr, int color)

	if (scan_area_cache)

		area = kmem_cache_alloc(scan_area_cache, gfp_kmemleak_mask(gfp));

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	if (!area) {

		pr_warn_once("Cannot allocate a scan area, scanning the full object\n");

		/* mark the object for full scan to avoid false positives */

	hlist_add_head(&area->node, &object->area_list);

out_unlock:

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

}

		return;

	}

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	object->excess_ref = excess_ref;

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

}

		return;

	}

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	object->flags |= OBJECT_NO_SCAN;

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

}

		return;

	}

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	object->trace_len = __save_stack_trace(object->trace);

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

}

	unsigned long flags;

	unsigned long untagged_ptr;

	read_lock_irqsave(&kmemleak_lock, flags);

	raw_spin_lock_irqsave(&kmemleak_lock, flags);

	for (ptr = start; ptr < end; ptr++) {

		struct kmemleak_object *object;

		unsigned long pointer;

		 * previously acquired in scan_object(). These locks are

		 * enclosed by scan_mutex.

		 */

		spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);

		raw_spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);

		/* only pass surplus references (object already gray) */

		if (color_gray(object)) {

			excess_ref = object->excess_ref;

			excess_ref = 0;

			update_refs(object);

		}

		spin_unlock(&object->lock);

		raw_spin_unlock(&object->lock);

		if (excess_ref) {

			object = lookup_object(excess_ref, 0);

			if (object == scanned)

				/* circular reference, ignore */

				continue;

			spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);

			raw_spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);

			update_refs(object);

			spin_unlock(&object->lock);

			raw_spin_unlock(&object->lock);

		}

	}

	read_unlock_irqrestore(&kmemleak_lock, flags);

	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);

}

/*

	 * Once the object->lock is acquired, the corresponding memory block

	 * cannot be freed (the same lock is acquired in delete_object).

	 */

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	if (object->flags & OBJECT_NO_SCAN)

		goto out;

	if (!(object->flags & OBJECT_ALLOCATED))

			if (start >= end)

				break;

			spin_unlock_irqrestore(&object->lock, flags);

			raw_spin_unlock_irqrestore(&object->lock, flags);

			cond_resched();

			spin_lock_irqsave(&object->lock, flags);

			raw_spin_lock_irqsave(&object->lock, flags);

		} while (object->flags & OBJECT_ALLOCATED);

	} else

		hlist_for_each_entry(area, &object->area_list, node)

				   (void *)(area->start + area->size),

				   object);

out:

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

}

/*

	/* prepare the kmemleak_object's */

	rcu_read_lock();

	list_for_each_entry_rcu(object, &object_list, object_list) {

		spin_lock_irqsave(&object->lock, flags);

		raw_spin_lock_irqsave(&object->lock, flags);

#ifdef DEBUG

		/*

		 * With a few exceptions there should be a maximum of

		if (color_gray(object) && get_object(object))

			list_add_tail(&object->gray_list, &gray_list);

		spin_unlock_irqrestore(&object->lock, flags);

		raw_spin_unlock_irqrestore(&object->lock, flags);

	}

	rcu_read_unlock();

	 */

	rcu_read_lock();

	list_for_each_entry_rcu(object, &object_list, object_list) {

		spin_lock_irqsave(&object->lock, flags);

		raw_spin_lock_irqsave(&object->lock, flags);

		if (color_white(object) && (object->flags & OBJECT_ALLOCATED)

		    && update_checksum(object) && get_object(object)) {

			/* color it gray temporarily */

			object->count = object->min_count;

			list_add_tail(&object->gray_list, &gray_list);

		}

		spin_unlock_irqrestore(&object->lock, flags);

		raw_spin_unlock_irqrestore(&object->lock, flags);

	}

	rcu_read_unlock();

	 */

	rcu_read_lock();

	list_for_each_entry_rcu(object, &object_list, object_list) {

		spin_lock_irqsave(&object->lock, flags);

		raw_spin_lock_irqsave(&object->lock, flags);

		if (unreferenced_object(object) &&

		    !(object->flags & OBJECT_REPORTED)) {

			object->flags |= OBJECT_REPORTED;

			new_leaks++;

		}

		spin_unlock_irqrestore(&object->lock, flags);

		raw_spin_unlock_irqrestore(&object->lock, flags);

	}

	rcu_read_unlock();

	struct kmemleak_object *object = v;

	unsigned long flags;

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	if ((object->flags & OBJECT_REPORTED) && unreferenced_object(object))

		print_unreferenced(seq, object);

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	return 0;

}

		return -EINVAL;

	}

	spin_lock_irqsave(&object->lock, flags);

	raw_spin_lock_irqsave(&object->lock, flags);

	dump_object_info(object);

	spin_unlock_irqrestore(&object->lock, flags);

	raw_spin_unlock_irqrestore(&object->lock, flags);

	put_object(object);

	return 0;

	rcu_read_lock();

	list_for_each_entry_rcu(object, &object_list, object_list) {

		spin_lock_irqsave(&object->lock, flags);

		raw_spin_lock_irqsave(&object->lock, flags);

		if ((object->flags & OBJECT_REPORTED) &&

		    unreferenced_object(object))

			__paint_it(object, KMEMLEAK_GREY);

		spin_unlock_irqrestore(&object->lock, flags);

		raw_spin_unlock_irqrestore(&object->lock, flags);

	}

	rcu_read_unlock();