Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/livepatching (41e3bef5) · Commits · 戴 / test

Documentation/livepatch/shadow-vars.txt

+29 −12

Original line number	Original line	Diff line number	Diff line
	@@ -34,9 +34,13 @@ meta-data and shadow-data:
	- data[] - storage for shadow data		- data[] - storage for shadow data

	It is important to note that the klp_shadow_alloc() and		It is important to note that the klp_shadow_alloc() and
	klp_shadow_get_or_alloc() calls, described below, store a copy of the		klp_shadow_get_or_alloc() are zeroing the variable by default.
	data that the functions are provided. Callers should provide whatever		They also allow to call a custom constructor function when a non-zero
	mutual exclusion is required of the shadow data.		value is needed. Callers should provide whatever mutual exclusion
			is required.

			Note that the constructor is called under klp_shadow_lock spinlock. It allows
			to do actions that can be done only once when a new variable is allocated.

	* klp_shadow_get() - retrieve a shadow variable data pointer		* klp_shadow_get() - retrieve a shadow variable data pointer
	- search hashtable for <obj, id> pair		- search hashtable for <obj, id> pair
	@@ -47,7 +51,7 @@ mutual exclusion is required of the shadow data.
	- WARN and return NULL		- WARN and return NULL
	- if <obj, id> doesn't already exist		- if <obj, id> doesn't already exist
	- allocate a new shadow variable		- allocate a new shadow variable
	- copy data into the new shadow variable		- initialize the variable using a custom constructor and data when provided
	- add <obj, id> to the global hashtable		- add <obj, id> to the global hashtable

	* klp_shadow_get_or_alloc() - get existing or alloc a new shadow variable		* klp_shadow_get_or_alloc() - get existing or alloc a new shadow variable
	@@ -56,16 +60,20 @@ mutual exclusion is required of the shadow data.
	- return existing shadow variable		- return existing shadow variable
	- if <obj, id> doesn't already exist		- if <obj, id> doesn't already exist
	- allocate a new shadow variable		- allocate a new shadow variable
	- copy data into the new shadow variable		- initialize the variable using a custom constructor and data when provided
	- add <obj, id> pair to the global hashtable		- add <obj, id> pair to the global hashtable

	* klp_shadow_free() - detach and free a <obj, id> shadow variable		* klp_shadow_free() - detach and free a <obj, id> shadow variable
	- find and remove a <obj, id> reference from global hashtable		- find and remove a <obj, id> reference from global hashtable
	- if found, free shadow variable		- if found
			- call destructor function if defined
			- free shadow variable

	* klp_shadow_free_all() - detach and free all <*, id> shadow variables		* klp_shadow_free_all() - detach and free all <*, id> shadow variables
	- find and remove any <*, id> references from global hashtable		- find and remove any <*, id> references from global hashtable
	- if found, free shadow variable		- if found
			- call destructor function if defined
			- free shadow variable


	2. Use cases		2. Use cases
	@@ -107,7 +115,8 @@ struct sta_info sta_info_alloc(struct ieee80211_sub_if_data sdata,
	sta = kzalloc(sizeof(*sta) + hw->sta_data_size, gfp);		sta = kzalloc(sizeof(*sta) + hw->sta_data_size, gfp);

	/* Attach a corresponding shadow variable, then initialize it */		/* Attach a corresponding shadow variable, then initialize it */
	ps_lock = klp_shadow_alloc(sta, PS_LOCK, NULL, sizeof(*ps_lock), gfp);		ps_lock = klp_shadow_alloc(sta, PS_LOCK, sizeof(*ps_lock), gfp,
			NULL, NULL);
	if (!ps_lock)		if (!ps_lock)
	goto shadow_fail;		goto shadow_fail;
	spin_lock_init(ps_lock);		spin_lock_init(ps_lock);
	@@ -131,7 +140,7 @@ variable:

	void sta_info_free(struct ieee80211_local local, struct sta_info sta)		void sta_info_free(struct ieee80211_local local, struct sta_info sta)
	{		{
	klp_shadow_free(sta, PS_LOCK);		klp_shadow_free(sta, PS_LOCK, NULL);
	kfree(sta);		kfree(sta);
	...		...

	@@ -148,16 +157,24 @@ shadow variables to parents already in-flight.
	For commit 1d147bfa6429, a good spot to allocate a shadow spinlock is		For commit 1d147bfa6429, a good spot to allocate a shadow spinlock is
	inside ieee80211_sta_ps_deliver_wakeup():		inside ieee80211_sta_ps_deliver_wakeup():

			int ps_lock_shadow_ctor(void obj, void shadow_data, void *ctor_data)
			{
			spinlock_t *lock = shadow_data;

			spin_lock_init(lock);
			return 0;
			}

	#define PS_LOCK 1		#define PS_LOCK 1
	void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)		void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
	{		{
	DEFINE_SPINLOCK(ps_lock_fallback);
	spinlock_t *ps_lock;		spinlock_t *ps_lock;

	/* sync with ieee80211_tx_h_unicast_ps_buf */		/* sync with ieee80211_tx_h_unicast_ps_buf */
	ps_lock = klp_shadow_get_or_alloc(sta, PS_LOCK,		ps_lock = klp_shadow_get_or_alloc(sta, PS_LOCK,
	&ps_lock_fallback, sizeof(ps_lock_fallback),		sizeof(*ps_lock), GFP_ATOMIC,
	GFP_ATOMIC);		ps_lock_shadow_ctor, NULL);

	if (ps_lock)		if (ps_lock)
	spin_lock(ps_lock);		spin_lock(ps_lock);
	...		...

include/linux/livepatch.h

+13 −6

Original line number	Original line	Diff line number	Diff line
	@@ -186,13 +186,20 @@ static inline bool klp_have_reliable_stack(void)
	IS_ENABLED(CONFIG_HAVE_RELIABLE_STACKTRACE);		IS_ENABLED(CONFIG_HAVE_RELIABLE_STACKTRACE);
	}		}

			typedef int (klp_shadow_ctor_t)(void obj,
			void *shadow_data,
			void *ctor_data);
			typedef void (klp_shadow_dtor_t)(void obj, void *shadow_data);

	void klp_shadow_get(void obj, unsigned long id);		void klp_shadow_get(void obj, unsigned long id);
	void klp_shadow_alloc(void obj, unsigned long id, void *data,		void klp_shadow_alloc(void obj, unsigned long id,
	size_t size, gfp_t gfp_flags);		size_t size, gfp_t gfp_flags,
	void klp_shadow_get_or_alloc(void obj, unsigned long id, void *data,		klp_shadow_ctor_t ctor, void *ctor_data);
	size_t size, gfp_t gfp_flags);		void klp_shadow_get_or_alloc(void obj, unsigned long id,
	void klp_shadow_free(void *obj, unsigned long id);		size_t size, gfp_t gfp_flags,
	void klp_shadow_free_all(unsigned long id);		klp_shadow_ctor_t ctor, void *ctor_data);
			void klp_shadow_free(void *obj, unsigned long id, klp_shadow_dtor_t dtor);
			void klp_shadow_free_all(unsigned long id, klp_shadow_dtor_t dtor);

	#else /* !CONFIG_LIVEPATCH */		#else /* !CONFIG_LIVEPATCH */

kernel/livepatch/shadow.c

+71 −37

Original line number	Original line	Diff line number	Diff line
	@@ -113,8 +113,10 @@ void klp_shadow_get(void obj, unsigned long id)
	}		}
	EXPORT_SYMBOL_GPL(klp_shadow_get);		EXPORT_SYMBOL_GPL(klp_shadow_get);

	static void __klp_shadow_get_or_alloc(void obj, unsigned long id, void *data,		static void __klp_shadow_get_or_alloc(void obj, unsigned long id,
	size_t size, gfp_t gfp_flags, bool warn_on_exist)		size_t size, gfp_t gfp_flags,
			klp_shadow_ctor_t ctor, void *ctor_data,
			bool warn_on_exist)
	{		{
	struct klp_shadow *new_shadow;		struct klp_shadow *new_shadow;
	void *shadow_data;		void *shadow_data;
	@@ -125,18 +127,15 @@ static void __klp_shadow_get_or_alloc(void obj, unsigned long id, void *data,
	if (shadow_data)		if (shadow_data)
	goto exists;		goto exists;

	/* Allocate a new shadow variable for use inside the lock below */		/*
			* Allocate a new shadow variable. Fill it with zeroes by default.
			* More complex setting can be done by @ctor function. But it is
			* called only when the buffer is really used (under klp_shadow_lock).
			*/
	new_shadow = kzalloc(size + sizeof(*new_shadow), gfp_flags);		new_shadow = kzalloc(size + sizeof(*new_shadow), gfp_flags);
	if (!new_shadow)		if (!new_shadow)
	return NULL;		return NULL;

	new_shadow->obj = obj;
	new_shadow->id = id;

	/* Initialize the shadow variable if data provided */
	if (data)
	memcpy(new_shadow->data, data, size);

	/* Look for <obj, id> again under the lock */		/* Look for <obj, id> again under the lock */
	spin_lock_irqsave(&klp_shadow_lock, flags);		spin_lock_irqsave(&klp_shadow_lock, flags);
	shadow_data = klp_shadow_get(obj, id);		shadow_data = klp_shadow_get(obj, id);
	@@ -150,6 +149,22 @@ static void __klp_shadow_get_or_alloc(void obj, unsigned long id, void *data,
	goto exists;		goto exists;
	}		}

			new_shadow->obj = obj;
			new_shadow->id = id;

			if (ctor) {
			int err;

			err = ctor(obj, new_shadow->data, ctor_data);
			if (err) {
			spin_unlock_irqrestore(&klp_shadow_lock, flags);
			kfree(new_shadow);
			pr_err("Failed to construct shadow variable <%p, %lx> (%d)\n",
			obj, id, err);
			return NULL;
			}
			}

	/* No <obj, id> found, so attach the newly allocated one */		/* No <obj, id> found, so attach the newly allocated one */
	hash_add_rcu(klp_shadow_hash, &new_shadow->node,		hash_add_rcu(klp_shadow_hash, &new_shadow->node,
	(unsigned long)new_shadow->obj);		(unsigned long)new_shadow->obj);
	@@ -170,26 +185,32 @@ exists:
	* klp_shadow_alloc() - allocate and add a new shadow variable		* klp_shadow_alloc() - allocate and add a new shadow variable
	* @obj: pointer to parent object		* @obj: pointer to parent object
	* @id: data identifier		* @id: data identifier
	* @data: pointer to data to attach to parent
	* @size: size of attached data		* @size: size of attached data
	* @gfp_flags: GFP mask for allocation		* @gfp_flags: GFP mask for allocation
			* @ctor: custom constructor to initialize the shadow data (optional)
			* @ctor_data: pointer to any data needed by @ctor (optional)
	*		*
	* Allocates @size bytes for new shadow variable data using @gfp_flags		* Allocates @size bytes for new shadow variable data using @gfp_flags.
	* and copies @size bytes from @data into the new shadow variable's own		* The data are zeroed by default. They are further initialized by @ctor
	* data space. If @data is NULL, @size bytes are still allocated, but		* function if it is not NULL. The new shadow variable is then added
	* no copy is performed. The new shadow variable is then added to the		* to the global hashtable.
	* global hashtable.
	*		*
	* If an existing <obj, id> shadow variable can be found, this routine		* If an existing <obj, id> shadow variable can be found, this routine will
	* will issue a WARN, exit early and return NULL.		* issue a WARN, exit early and return NULL.
			*
			* This function guarantees that the constructor function is called only when
			* the variable did not exist before. The cost is that @ctor is called
			* in atomic context under a spin lock.
	*		*
	* Return: the shadow variable data element, NULL on duplicate or		* Return: the shadow variable data element, NULL on duplicate or
	* failure.		* failure.
	*/		*/
	void klp_shadow_alloc(void obj, unsigned long id, void *data,		void klp_shadow_alloc(void obj, unsigned long id,
	size_t size, gfp_t gfp_flags)		size_t size, gfp_t gfp_flags,
			klp_shadow_ctor_t ctor, void *ctor_data)
	{		{
	return __klp_shadow_get_or_alloc(obj, id, data, size, gfp_flags, true);		return __klp_shadow_get_or_alloc(obj, id, size, gfp_flags,
			ctor, ctor_data, true);
	}		}
	EXPORT_SYMBOL_GPL(klp_shadow_alloc);		EXPORT_SYMBOL_GPL(klp_shadow_alloc);

	@@ -197,37 +218,51 @@ EXPORT_SYMBOL_GPL(klp_shadow_alloc);
	* klp_shadow_get_or_alloc() - get existing or allocate a new shadow variable		* klp_shadow_get_or_alloc() - get existing or allocate a new shadow variable
	* @obj: pointer to parent object		* @obj: pointer to parent object
	* @id: data identifier		* @id: data identifier
	* @data: pointer to data to attach to parent
	* @size: size of attached data		* @size: size of attached data
	* @gfp_flags: GFP mask for allocation		* @gfp_flags: GFP mask for allocation
			* @ctor: custom constructor to initialize the shadow data (optional)
			* @ctor_data: pointer to any data needed by @ctor (optional)
	*		*
	* Returns a pointer to existing shadow data if an <obj, id> shadow		* Returns a pointer to existing shadow data if an <obj, id> shadow
	* variable is already present. Otherwise, it creates a new shadow		* variable is already present. Otherwise, it creates a new shadow
	* variable like klp_shadow_alloc().		* variable like klp_shadow_alloc().
	*		*
	* This function guarantees that only one shadow variable exists with		* This function guarantees that only one shadow variable exists with the given
	* the given @id for the given @obj. It also guarantees that the shadow		* @id for the given @obj. It also guarantees that the constructor function
	* variable will be initialized by the given @data only when it did not		* will be called only when the variable did not exist before. The cost is
	* exist before.		* that @ctor is called in atomic context under a spin lock.
	*		*
	* Return: the shadow variable data element, NULL on failure.		* Return: the shadow variable data element, NULL on failure.
	*/		*/
	void klp_shadow_get_or_alloc(void obj, unsigned long id, void *data,		void klp_shadow_get_or_alloc(void obj, unsigned long id,
	size_t size, gfp_t gfp_flags)		size_t size, gfp_t gfp_flags,
			klp_shadow_ctor_t ctor, void *ctor_data)
	{		{
	return __klp_shadow_get_or_alloc(obj, id, data, size, gfp_flags, false);		return __klp_shadow_get_or_alloc(obj, id, size, gfp_flags,
			ctor, ctor_data, false);
	}		}
	EXPORT_SYMBOL_GPL(klp_shadow_get_or_alloc);		EXPORT_SYMBOL_GPL(klp_shadow_get_or_alloc);

			static void klp_shadow_free_struct(struct klp_shadow *shadow,
			klp_shadow_dtor_t dtor)
			{
			hash_del_rcu(&shadow->node);
			if (dtor)
			dtor(shadow->obj, shadow->data);
			kfree_rcu(shadow, rcu_head);
			}

	/**		/**
	* klp_shadow_free() - detach and free a <obj, id> shadow variable		* klp_shadow_free() - detach and free a <obj, id> shadow variable
	* @obj: pointer to parent object		* @obj: pointer to parent object
	* @id: data identifier		* @id: data identifier
			* @dtor: custom callback that can be used to unregister the variable
			* and/or free data that the shadow variable points to (optional)
	*		*
	* This function releases the memory for this <obj, id> shadow variable		* This function releases the memory for this <obj, id> shadow variable
	* instance, callers should stop referencing it accordingly.		* instance, callers should stop referencing it accordingly.
	*/		*/
	void klp_shadow_free(void *obj, unsigned long id)		void klp_shadow_free(void *obj, unsigned long id, klp_shadow_dtor_t dtor)
	{		{
	struct klp_shadow *shadow;		struct klp_shadow *shadow;
	unsigned long flags;		unsigned long flags;
	@@ -239,8 +274,7 @@ void klp_shadow_free(void *obj, unsigned long id)
	(unsigned long)obj) {		(unsigned long)obj) {

	if (klp_shadow_match(shadow, obj, id)) {		if (klp_shadow_match(shadow, obj, id)) {
	hash_del_rcu(&shadow->node);		klp_shadow_free_struct(shadow, dtor);
	kfree_rcu(shadow, rcu_head);
	break;		break;
	}		}
	}		}
	@@ -252,11 +286,13 @@ EXPORT_SYMBOL_GPL(klp_shadow_free);
	/**		/**
	* klp_shadow_free_all() - detach and free all <*, id> shadow variables		* klp_shadow_free_all() - detach and free all <*, id> shadow variables
	* @id: data identifier		* @id: data identifier
			* @dtor: custom callback that can be used to unregister the variable
			* and/or free data that the shadow variable points to (optional)
	*		*
	* This function releases the memory for all <*, id> shadow variable		* This function releases the memory for all <*, id> shadow variable
	* instances, callers should stop referencing them accordingly.		* instances, callers should stop referencing them accordingly.
	*/		*/
	void klp_shadow_free_all(unsigned long id)		void klp_shadow_free_all(unsigned long id, klp_shadow_dtor_t dtor)
	{		{
	struct klp_shadow *shadow;		struct klp_shadow *shadow;
	unsigned long flags;		unsigned long flags;
	@@ -266,10 +302,8 @@ void klp_shadow_free_all(unsigned long id)

	/* Delete all <, id> from hash /		/* Delete all <, id> from hash /
	hash_for_each(klp_shadow_hash, i, shadow, node) {		hash_for_each(klp_shadow_hash, i, shadow, node) {
	if (klp_shadow_match(shadow, shadow->obj, id)) {		if (klp_shadow_match(shadow, shadow->obj, id))
	hash_del_rcu(&shadow->node);		klp_shadow_free_struct(shadow, dtor);
	kfree_rcu(shadow, rcu_head);
	}
	}		}

	spin_unlock_irqrestore(&klp_shadow_lock, flags);		spin_unlock_irqrestore(&klp_shadow_lock, flags);

samples/livepatch/livepatch-shadow-fix1.c

+32 −11

Original line number	Original line	Diff line number	Diff line
	@@ -56,6 +56,21 @@ struct dummy {
	unsigned long jiffies_expire;		unsigned long jiffies_expire;
	};		};

			/*
			* The constructor makes more sense together with klp_shadow_get_or_alloc().
			* In this example, it would be safe to assign the pointer also to the shadow
			* variable returned by klp_shadow_alloc(). But we wanted to show the more
			* complicated use of the API.
			*/
			static int shadow_leak_ctor(void obj, void shadow_data, void *ctor_data)
			{
			void **shadow_leak = shadow_data;
			void *leak = ctor_data;

			*shadow_leak = leak;
			return 0;
			}

	struct dummy *livepatch_fix1_dummy_alloc(void)		struct dummy *livepatch_fix1_dummy_alloc(void)
	{		{
	struct dummy *d;		struct dummy *d;
	@@ -74,7 +89,8 @@ struct dummy *livepatch_fix1_dummy_alloc(void)
	* pointer to handle resource release.		* pointer to handle resource release.
	*/		*/
	leak = kzalloc(sizeof(int), GFP_KERNEL);		leak = kzalloc(sizeof(int), GFP_KERNEL);
	klp_shadow_alloc(d, SV_LEAK, &leak, sizeof(leak), GFP_KERNEL);		klp_shadow_alloc(d, SV_LEAK, sizeof(leak), GFP_KERNEL,
			shadow_leak_ctor, leak);

	pr_info("%s: dummy @ %p, expires @ %lx\n",		pr_info("%s: dummy @ %p, expires @ %lx\n",
	__func__, d, d->jiffies_expire);		__func__, d, d->jiffies_expire);
	@@ -82,9 +98,19 @@ struct dummy *livepatch_fix1_dummy_alloc(void)
	return d;		return d;
	}		}

			static void livepatch_fix1_dummy_leak_dtor(void obj, void shadow_data)
			{
			void *d = obj;
			void **shadow_leak = shadow_data;

			kfree(*shadow_leak);
			pr_info("%s: dummy @ %p, prevented leak @ %p\n",
			__func__, d, *shadow_leak);
			}

	void livepatch_fix1_dummy_free(struct dummy *d)		void livepatch_fix1_dummy_free(struct dummy *d)
	{		{
	void *shadow_leak, leak;		void **shadow_leak;

	/*		/*
	* Patch: fetch the saved SV_LEAK shadow variable, detach and		* Patch: fetch the saved SV_LEAK shadow variable, detach and
	@@ -93,15 +119,10 @@ void livepatch_fix1_dummy_free(struct dummy *d)
	* was loaded.)		* was loaded.)
	*/		*/
	shadow_leak = klp_shadow_get(d, SV_LEAK);		shadow_leak = klp_shadow_get(d, SV_LEAK);
	if (shadow_leak) {		if (shadow_leak)
	leak = *shadow_leak;		klp_shadow_free(d, SV_LEAK, livepatch_fix1_dummy_leak_dtor);
	klp_shadow_free(d, SV_LEAK);		else
	kfree(leak);
	pr_info("%s: dummy @ %p, prevented leak @ %p\n",
	__func__, d, leak);
	} else {
	pr_info("%s: dummy @ %p leaked!\n", __func__, d);		pr_info("%s: dummy @ %p leaked!\n", __func__, d);
	}

	kfree(d);		kfree(d);
	}		}
	@@ -147,7 +168,7 @@ static int livepatch_shadow_fix1_init(void)
	static void livepatch_shadow_fix1_exit(void)		static void livepatch_shadow_fix1_exit(void)
	{		{
	/* Cleanup any existing SV_LEAK shadow variables */		/* Cleanup any existing SV_LEAK shadow variables */
	klp_shadow_free_all(SV_LEAK);		klp_shadow_free_all(SV_LEAK, livepatch_fix1_dummy_leak_dtor);

	WARN_ON(klp_unregister_patch(&patch));		WARN_ON(klp_unregister_patch(&patch));
	}		}

samples/livepatch/livepatch-shadow-fix2.c

+18 −15

Original line number	Original line	Diff line number	Diff line
	@@ -53,39 +53,42 @@ struct dummy {
	bool livepatch_fix2_dummy_check(struct dummy *d, unsigned long jiffies)		bool livepatch_fix2_dummy_check(struct dummy *d, unsigned long jiffies)
	{		{
	int *shadow_count;		int *shadow_count;
	int count;

	/*		/*
	* Patch: handle in-flight dummy structures, if they do not		* Patch: handle in-flight dummy structures, if they do not
	* already have a SV_COUNTER shadow variable, then attach a		* already have a SV_COUNTER shadow variable, then attach a
	* new one.		* new one.
	*/		*/
	count = 0;
	shadow_count = klp_shadow_get_or_alloc(d, SV_COUNTER,		shadow_count = klp_shadow_get_or_alloc(d, SV_COUNTER,
	&count, sizeof(count),		sizeof(*shadow_count), GFP_NOWAIT,
	GFP_NOWAIT);		NULL, NULL);
	if (shadow_count)		if (shadow_count)
	*shadow_count += 1;		*shadow_count += 1;

	return time_after(jiffies, d->jiffies_expire);		return time_after(jiffies, d->jiffies_expire);
	}		}

			static void livepatch_fix2_dummy_leak_dtor(void obj, void shadow_data)
			{
			void *d = obj;
			void **shadow_leak = shadow_data;

			kfree(*shadow_leak);
			pr_info("%s: dummy @ %p, prevented leak @ %p\n",
			__func__, d, *shadow_leak);
			}

	void livepatch_fix2_dummy_free(struct dummy *d)		void livepatch_fix2_dummy_free(struct dummy *d)
	{		{
	void *shadow_leak, leak;		void **shadow_leak;
	int *shadow_count;		int *shadow_count;

	/* Patch: copy the memory leak patch from the fix1 module. */		/* Patch: copy the memory leak patch from the fix1 module. */
	shadow_leak = klp_shadow_get(d, SV_LEAK);		shadow_leak = klp_shadow_get(d, SV_LEAK);
	if (shadow_leak) {		if (shadow_leak)
	leak = *shadow_leak;		klp_shadow_free(d, SV_LEAK, livepatch_fix2_dummy_leak_dtor);
	klp_shadow_free(d, SV_LEAK);		else
	kfree(leak);
	pr_info("%s: dummy @ %p, prevented leak @ %p\n",
	__func__, d, leak);
	} else {
	pr_info("%s: dummy @ %p leaked!\n", __func__, d);		pr_info("%s: dummy @ %p leaked!\n", __func__, d);
	}

	/*		/*
	* Patch: fetch the SV_COUNTER shadow variable and display		* Patch: fetch the SV_COUNTER shadow variable and display
	@@ -95,7 +98,7 @@ void livepatch_fix2_dummy_free(struct dummy *d)
	if (shadow_count) {		if (shadow_count) {
	pr_info("%s: dummy @ %p, check counter = %d\n",		pr_info("%s: dummy @ %p, check counter = %d\n",
	__func__, d, *shadow_count);		__func__, d, *shadow_count);
	klp_shadow_free(d, SV_COUNTER);		klp_shadow_free(d, SV_COUNTER, NULL);
	}		}

	kfree(d);		kfree(d);
	@@ -142,7 +145,7 @@ static int livepatch_shadow_fix2_init(void)
	static void livepatch_shadow_fix2_exit(void)		static void livepatch_shadow_fix2_exit(void)
	{		{
	/* Cleanup any existing SV_COUNTER shadow variables */		/* Cleanup any existing SV_COUNTER shadow variables */
	klp_shadow_free_all(SV_COUNTER);		klp_shadow_free_all(SV_COUNTER, NULL);

	WARN_ON(klp_unregister_patch(&patch));		WARN_ON(klp_unregister_patch(&patch));
	}		}

Admin message