livepatch: add locking to force and signal functions
Miroslav Benes
maintainerPATCH v2 1/1 livepatch: add locking to force and signal functions
klp_send_signals() and klp_force_transition() do not acquire klp_mutex, because it seemed to be superfluous. A potential race in klp_send_signals() was harmless and there was nothing in klp_force_transition() which needed to be synchronized. That changed with the addition of klp_forced variable during the review process.
There is a small window now, when klp_complete_transition() does not see klp_forced set to true while all tasks have been already transitioned to the target state. module_put() is called and the module can be removed.
Acquire klp_mutex in sysfs callback to prevent it. Do the same for the signal sending just to be sure. There is no real downside to that.
---
Changes v1->v2:
- Add (patch != klp_transition_patch) check to critical sections and move the locking to sysfs callbacks (Petr)
kernel/livepatch/core.c | 52 ++++++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 24 deletions(-)
kernel/livepatch/core.c +28 -24
@@ -537,22 +537,24 @@ static ssize_t signal_store(struct kobject *kobj, struct kobj_attribute *attr,int ret;bool val; - patch = container_of(kobj, struct klp_patch, kobj); - -/* -* klp_mutex lock is not grabbed here intentionally. It is not really -* needed. The race window is harmless and grabbing the lock would only -* hold the action back. -*/ -if (patch != klp_transition_patch) -return -EINVAL ; - ret =kstrtobool (buf, &val);if (ret)return ret; -if (val) -klp_send_signals (); +if (!val) +return count; + +mutex_lock (&klp_mutex); + + patch = container_of(kobj, struct klp_patch, kobj); +if (patch != klp_transition_patch) { +mutex_unlock (&klp_mutex); +return -EINVAL ; + } + +klp_send_signals (); + +mutex_unlock (&klp_mutex);return count; }
@@ -564,22 +566,24 @@ static ssize_t force_store(struct kobject *kobj, struct kobj_attribute *attr,int ret;bool val; - patch = container_of(kobj, struct klp_patch, kobj); - -/* -* klp_mutex lock is not grabbed here intentionally. It is not really -* needed. The race window is harmless and grabbing the lock would only -* hold the action back. -*/ -if (patch != klp_transition_patch) -return -EINVAL ; - ret =kstrtobool (buf, &val);if (ret)return ret; -if (val) -klp_force_transition (); +if (!val) +return count; + +mutex_lock (&klp_mutex); + + patch = container_of(kobj, struct klp_patch, kobj); +if (patch != klp_transition_patch) { +mutex_unlock (&klp_mutex); +return -EINVAL ; + } + +klp_force_transition (); + +mutex_unlock (&klp_mutex);return count; }
Signature · 1 line
2.15.1
Quoted 10 lines · Miroslav Benes
klp_send_signals()andklp_force_transition()do not acquireklp_mutex, because it seemed to be superfluous. A potential race inklp_send_signals()was harmless and there was nothing inklp_force_transition()which needed to be synchronized. That changed with the addition ofklp_forcedvariable during the review process.There is a small window now, when
klp_complete_transition()does not seeklp_forcedset to true while all tasks have been already transitioned to the target state.module_put()is called and the module can be removed.
Quoted 5 lines
Acquire
klp_mutexin sysfs callback to prevent it. Do the same for the signal sending just to be sure. There is no real downside to that.Reported-by Jason Baron <[email protected]>Signed-off-by Miroslav Benes <[email protected]>
Looks good to me.
Best Regards,
Petr
Quoted 10 lines · Miroslav Benes
klp_send_signals()andklp_force_transition()do not acquireklp_mutex, because it seemed to be superfluous. A potential race inklp_send_signals()was harmless and there was nothing inklp_force_transition()which needed to be synchronized. That changed with the addition ofklp_forcedvariable during the review process.There is a small window now, when
klp_complete_transition()does not seeklp_forcedset to true while all tasks have been already transitioned to the target state.module_put()is called and the module can be removed.
Quoted 5 lines
Acquire
klp_mutexin sysfs callback to prevent it. Do the same for the signal sending just to be sure. There is no real downside to that.Reported-by Jason Baron <[email protected]>Signed-off-by Miroslav Benes <[email protected]>
Signature · 1 line
Josh
Quoted 10 lines · Miroslav Benes
klp_send_signals()andklp_force_transition()do not acquireklp_mutex, because it seemed to be superfluous. A potential race inklp_send_signals()was harmless and there was nothing inklp_force_transition()which needed to be synchronized. That changed with the addition ofklp_forcedvariable during the review process.There is a small window now, when
klp_complete_transition()does not seeklp_forcedset to true while all tasks have been already transitioned to the target state.module_put()is called and the module can be removed.
Quoted 5 lines
Acquire
klp_mutexin sysfs callback to prevent it. Do the same for the signal sending just to be sure. There is no real downside to that.Reported-by Jason Baron <[email protected]>Signed-off-by Miroslav Benes <[email protected]>
I've added two Fixes: tags and applied to for-4.16/signal-sysfs-force-v2.
Thanks,
Signature · 2 lines
Jiri Kosina SUSE Labs