driver core: Fix possible use after free on name
PATCH 1/1 driver core: Fix possible use after free on name
From: PengfeiZhang <[email protected]>
__class_create() copies the pointer to the name passed as an argument only to be used later. But there's a chance the caller could immediately free the passed string(e.g., local variable). This could trigger a use after free when we use class name(e.g., dev_uevent_name()called by device_destroy(),class_create_release()).
To be on the safe side: duplicate the string with kstrdup_const() so that if an unaware user passes an address to a stack-allocated buffer, we won't get the arbitrary name and crash.
--- drivers/base/class.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)
drivers/base/class.c +15 -2
@@ -206,6 +206,7 @@ void class_unregister(struct class *cls)static void class_create_release (struct class *cls) {pr_debug ("%s called for %s\n" , __func__, cls->name); +kfree_const (cls->name);kfree (cls); }
@@ -227,7 +228,10 @@ struct class *__class_create(struct module *owner, const char *name, struct lock_class_key *key) {struct class *cls; -int retval; +int retval = -EINVAL ; + +if (!name) + goto done; cls =kzalloc (sizeof (*cls),GFP_KERNEL );if (!cls) {
@@ -235,18 +239,27 @@ struct class *__class_create(struct module *owner, const char *name, goto error; } + name =kstrdup_const (name,GFP_KERNEL ); +if (!name) { + retval = -ENOMEM ; + goto error; + } + cls->name = name; cls->owner = owner; cls->class_release = class_create_release; retval =__class_register (cls, key);if (retval) - goto error; + goto error_class_register;return cls; +error_class_register: +kfree (cls->name); error:kfree (cls); +done:return ERR_PTR (retval); }EXPORT_SYMBOL_GPL (__class_create);
Signature · 1 line
2.7.4
Greg KH
maintainerQuoted 11 lines · On Sun, Apr 05, 2020 at 09:05:49AM -0700, [email protected] wrote:
From: PengfeiZhang <[email protected]>
__class_create()copies the pointer to the name passed as an argument only to be used later. But there's a chance the caller could immediately free the passedstring(e.g., local variable). This could trigger a use after free when we use classname(e.g., dev_uevent_name()called by device_destroy(),class_create_release()).To be on the safe side: duplicate the string with
kstrdup_const()so that if an unaware user passes an address to a stack-allocated buffer, we won't get the arbitrary name and crash.
Where are you seeing this happen?
Quoted 19 lines
Signed-off-by PengfeiZhang <[email protected]>--- drivers/base/class.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)drivers/base/class.c +1
-0@@ -206,6 +206,7 @@ void class_unregister(struct class *cls)static void class_create_release (struct class *cls) {pr_debug ("%s called for %s\n" , __func__, cls->name); +kfree_const (cls->name);kfree (cls); }
drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 234
Quoted 8 lines
drivers/base/class.c +4
-1@@ -227,7 +228,10 @@ struct class *__class_create(struct module *owner, const char *name, struct lock_class_key *key) {struct class *cls; -int retval; +int retval = -EINVAL ; + +if (!name) + goto done;
This is a new change, who calls this function with name not being set?
drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 246
Quoted 12 lines
drivers/base/class.c +5
-0cls =kzalloc (sizeof (*cls),GFP_KERNEL );if (!cls) {@@ -235,18 +239,27 @@ struct class *__class_create(struct module *owner, const char *name, goto error; } + name =kstrdup_const (name,GFP_KERNEL ); +if (!name) { + retval = -ENOMEM ; + goto error; + }
and overwriting the pointer like that is bad-form, try doing something else here instead.
Quoted 4 lines
drivers/base/class.c +1
-0+ cls->name = name; cls->owner = owner; cls->class_release = class_create_release;
drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 259
Quoted 10 lines
drivers/base/class.c +3
-1retval =__class_register (cls, key);if (retval) - goto error; + goto error_class_register;return cls; +error_class_register: +kfree (cls->name);
kfree_const()?
thanks,
greg k-h
Dear Greg,
Please refer to below for the crash. If you are fine with it, I will submit another patch with correcting the error mentioned.
When writing a kernel driver module, we may use it like this:
static int frv_init(int index)
{
...
char name [128]={0};
sprintf(name,"test_%d",index);
mount_dev_p->pci_class =class_create(THIS_MODULE,name);
classdev = device_create(mount_dev_p->pci_class, NULL, devno,
NULL, "PCIE_%x",index);...
}
static void frv_exit(void)
{
...
device_destroy(mount_dev_p->pci_class,mount_dev_p->devno); class_destroy(mount_dev_p->pci_class );
...
}
But when we remove the module, a crash occurres when calling device_destroy.
Call Trace: vsnprintf+0x2b2/0x4e0 add_uevent_var+0x7d/0x110 kobject_uevent_env+0x23f/0x770 kobject_uevent+0xb/0x10 device_del+0x23b/0x360 device_unregister+0x1a/0x60 device_destroy+0x3c/0x50
I traced the code and found that an invalid local variable was called in "kobject_uevent_env()", and triggered further crash as followed:
kobject_uevent_env(...)
{
...
struct kset_uevent_ops *uevent_ops;uevent_ops = kset->uevent_ops;
subsystem = uevent_ops->name(kset, kobj);add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
...
}
What is the "subsystem" value, continue to track.
static const struct kset_uevent_ops device_uevent_ops = {
.name = dev_uevent_name,
};static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
{
struct device *dev = kobj_to_dev(kobj);
if (dev->class)
return dev->class->name;
return NULL;
}Everything becomes clear: "class->name" and "subsystem" value is local variable array address of start module function inside "char name [128]". Used released local variable in device_destroy's kobject_uevent_env, an error occurred.
Thanks,
Fei
2020-04-06 0:40 GMT+08:00, Greg KH <[email protected]>:
Quoted 85 lines · On Sun, Apr 05, 2020 at 09:05:49AM -0700, [email protected] wrote:
Quoted 11 lines
From: PengfeiZhang <[email protected]>
__class_create()copies the pointer to the name passed as an argument only to be used later. But there's a chance the caller could immediately free the passedstring(e.g., local variable). This could trigger a use after free when we use classname(e.g., dev_uevent_name()called by device_destroy(),class_create_release()).To be on the safe side: duplicate the string with
kstrdup_const()so that if an unaware user passes an address to a stack-allocated buffer, we won't get the arbitrary name and crash.Where are you seeing this happen?
Quoted 19 lines
Signed-off-by PengfeiZhang <[email protected]>--- drivers/base/class.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)drivers/base/class.c +1
-0@@ -206,6 +206,7 @@ void class_unregister(struct class *cls)static void class_create_release (struct class *cls) {pr_debug ("%s called for %s\n" , __func__, cls->name); +kfree_const (cls->name);kfree (cls); }drivers/base/class.c struct class *__class_create(struct module *owner, · line 235
Quoted 9 lines
drivers/base/class.c +4
-1@@ -227,7 +228,10 @@ struct class *__class_create(struct module *owner,const char *name, struct lock_class_key *key) { struct class *cls; -int retval; +int retval = -EINVAL ; + +if (!name) + goto done;This is a new change, who calls this function with name not being set?
drivers/base/class.c struct class *__class_create(struct module *owner, · line 247
Quoted 13 lines
drivers/base/class.c +5
-0cls =kzalloc (sizeof (*cls),GFP_KERNEL );if (!cls) {@@ -235,18 +239,27 @@ struct class *__class_create(struct module *owner,const char *name, goto error; } + name =kstrdup_const (name,GFP_KERNEL ); +if (!name) { + retval = -ENOMEM ; + goto error; + }and overwriting the pointer like that is bad-form, try doing something else here instead.
Quoted 4 lines
drivers/base/class.c +1
-0+ cls->name = name; cls->owner = owner; cls->class_release = class_create_release;drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 259
Quoted 10 lines
drivers/base/class.c +3
-1retval =__class_register (cls, key);if (retval) - goto error; + goto error_class_register;return cls; +error_class_register: +kfree (cls->name);
kfree_const()?thanks,
greg k-h
Greg KH
maintainerQuoted 65 lines · Fei Zhang
Dear Greg,
Please refer to below for the crash. If you are fine with it, I will submit another patch with correcting the error mentioned.
When writing a kernel driver module, we may use it like this:
static int
frv_init(int index)
{
...char name [128]={0}; sprintf(name,"test_%d",index); mount_dev_p->pci_class =class_create(THIS_MODULE,name); classdev = device_create(mount_dev_p->pci_class, NULL, devno, NULL, "PCIE_%x",index);...
}static void
frv_exit(void)
{
...device_destroy(mount_dev_p->pci_class,mount_dev_p->devno); class_destroy(mount_dev_p->pci_class );...
}But when we remove the module, a crash occurres when calling
device_destroy.Call Trace: vsnprintf+0x2b2/0x4e0 add_uevent_var+0x7d/0x110 kobject_uevent_env+0x23f/0x770 kobject_uevent+0xb/0x10 device_del+0x23b/0x360 device_unregister+0x1a/0x60 device_destroy+0x3c/0x50I traced the code and found that an invalid local variable was called in "
kobject_uevent_env()", and triggered further crash as followed:
kobject_uevent_env(...)
{
...
structkset_uevent_ops*uevent_ops;uevent_ops=kset->uevent_ops;
subsystem =uevent_ops->name(kset, kobj);add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
...
}What is the "subsystem" value, continue to track.
static const struct kset_uevent_ops device_uevent_ops = { .name = dev_uevent_name, };static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
{ struct device *dev = kobj_to_dev(kobj); if (dev->class) return dev->class->name; return NULL; }
Quoted 4 lines
Everything becomes clear: "
class->name" and "subsystem" value is local variable array address of start module function inside "char name [128]". Used released local variable in device_destroy'skobject_uevent_env, an error occurred.
Please do not top-post.
Anyway, yes, that does seem to be a semi-valid way of creating a class, does anyone currently do that in the kernel tree today? Typically creating classes is rare, and do not have a "dynamic name" like your example above, because that is not what a class is for.
So while the idea is good to solve this, I would like to go back to your example to find out why you are doing this in the first place, as that does not seem to be the way to use the driver model correctly.
thanks,
greg k-h
Dear Greg,
Mostly, "class_creat" is used in kernel driver module, basically read-only strings,
but it is easier to use a local variable string. When writing drive module, it fails to judge the local variable string which cannot be passed in only via interface.
I found that someone else may also face the same problem.
If we have 2 identical hardwares with different internal logic(fpga), it may be more
appropriate to create dynamic classes according to the logical functions.
Thanks,
Fei
2020-04-06 13:41 GMT+08:00, Greg KH <[email protected]>:
Quoted 87 lines · Fei Zhang
Quoted 66 lines
Dear Greg,
Please refer to below for the crash. If you are fine with it, I will submit another patch with correcting the error mentioned.
When writing a kernel driver module, we may use it like this:
static int
frv_init(int index)
{
...char name [128]={0}; sprintf(name,"test_%d",index); mount_dev_p->pci_class =class_create(THIS_MODULE,name); classdev = device_create(mount_dev_p->pci_class, NULL, devno, NULL, "PCIE_%x",index);...
}static void
frv_exit(void)
{
...device_destroy(mount_dev_p->pci_class,mount_dev_p->devno); class_destroy(mount_dev_p->pci_class );...
}But when we remove the module, a crash occurres when calling
device_destroy.Call Trace: vsnprintf+0x2b2/0x4e0 add_uevent_var+0x7d/0x110 kobject_uevent_env+0x23f/0x770 kobject_uevent+0xb/0x10 device_del+0x23b/0x360 device_unregister+0x1a/0x60 device_destroy+0x3c/0x50I traced the code and found that an invalid local variable was called in "
kobject_uevent_env()", and triggered further crash as followed:
kobject_uevent_env(...)
{
...
structkset_uevent_ops*uevent_ops;uevent_ops=kset->uevent_ops;
subsystem =uevent_ops->name(kset, kobj);add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
...
}What is the "subsystem" value, continue to track.
static const struct kset_uevent_ops device_uevent_ops = { .name = dev_uevent_name, };static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
{ struct device *dev = kobj_to_dev(kobj); if (dev->class) return dev->class->name; return NULL; }Quoted 4 lines
Everything becomes clear: "
class->name" and "subsystem" value is local variable array address of start module function inside "char name [128]". Used released local variable in device_destroy'skobject_uevent_env, an error occurred.Please do not top-post.
Anyway, yes, that does seem to be a semi-valid way of creating a class, does anyone currently do that in the kernel tree today? Typically creating classes is rare, and do not have a "dynamic name" like your example above, because that is not what a class is for.
So while the idea is good to solve this, I would like to go back to your example to find out why you are doing this in the first place, as that does not seem to be the way to use the driver model correctly.
thanks,
greg k-h
Greg KH
maintainerA: http://en.wikipedia.org/wiki/Top_post
Q: Were do I find info about this thing called top-posting?
A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing in e-mail?
A: No.
Q: Should I include quotations after my reply?
http://daringfireball.net/2007/07/on_top
Quoted 8 lines · Fei Zhang
Dear Greg,
Mostly, "
class_creat" is used in kernel driver module, basically read-only strings,
but it is easier to use a local variable string. When writing drive module, it fails to judge the local variable string which cannot be passed in only via interface.
I found that someone else may also face the same problem.
An individual driver should NOT be creating a class, that is not what it is there for.
Class names are very "rare" and should not be dynamically created at all.
Quoted 3 lines
If we have 2 identical hardwares with different internal logic(fpga), it may be more
appropriate to create dynamic classes according to the logical functions.
No it is not appropriate at all to do that.
So, I'll ignore this patch as this is not something that you all should do. If an in-kernel user needs this, I will be glad to revisit this issue, so I strongly suggest you work to get your code merged upstream properly, so we can review it and suggest what you should be doing instead.
thanks,
greg k-h
Hi Greg,
Quoted 23 lines · Greg KH <[email protected]> 于2020年4月6日周一 下午4:29写道:
A: http://en.wikipedia.org/wiki/Top_post
Q: Were do I find info about this thing called top-posting?
A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing in e-mail?A: No.
Q: Should I include quotations after my reply?http://daringfireball.net/2007/07/on_top
Quoted 8 lines · Fei Zhang
Dear Greg,
Mostly, "
class_creat" is used in kernel driver module, basically read-only strings,
but it is easier to use a local variable string. When writing drive module, it fails to judge the local variable string which cannot be passed in only via interface.
I found that someone else may also face the same problem.
Quoted 2 lines
An individual driver should NOT be creating a class, that is not what it is there for.
If someone want to create a virtual device, someone can call device_create(). But the first argument is type of 'struct class *class', so we have to call class_create()
before create device. So an individual driver may be creating a class, right?
Quoted 3 lines
Class names are very "rare" and should not be dynamically created at all.
I have reviewed the code of the kstrdup_const() which is just below.
const char *kstrdup_const(const char *s, gfp_t gfp)
{
if (is_kernel_rodata((unsigned long)s))
return s;
return kstrdup(s, gfp);
}A readonly string which is in the kernel rodata, so we do not need to dynamically allocate
memory to store the name. So with this patch applied, there is nothing changed which
means that we did not waste memory. But it can prevent someone from reading stale name
if an unaware user passes an address to a stack-allocated buffer.
So I think it is worth fixing, right?
Signature · 2 lines
Yours, Muchun
Greg KH
maintainerQuoted 26 lines · 宋牧春
Hi Greg,
Quoted 23 lines · Greg KH <[email protected]> 于2020年4月6日周一 下午4:29写道:
A: http://en.wikipedia.org/wiki/Top_post
Q: Were do I find info about this thing called top-posting?
A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing in e-mail?A: No.
Q: Should I include quotations after my reply?http://daringfireball.net/2007/07/on_top
Quoted 8 lines · Fei Zhang
Dear Greg,
Mostly, "
class_creat" is used in kernel driver module, basically read-only strings,
but it is easier to use a local variable string. When writing drive module, it fails to judge the local variable string which cannot be passed in only via interface.
I found that someone else may also face the same problem.
Quoted 7 lines
Quoted 2 lines
An individual driver should NOT be creating a class, that is not what it is there for.
If someone want to create a virtual device, someone can call
device_create(). But the first argument is type of 'struct class *class', so we have to callclass_create()
before create device. So an individual driver may be creating a class, right?
Again, they should not be, as classes are not what a driver creates. It is what a subsystem creates, as a class is a type of common devices that all talk to userspace in the same way.
Quoted 21 lines
Quoted 2 lines
Class names are very "rare" and should not be dynamically created at all.
I have reviewed the code of the
kstrdup_const()which is just below.const char *kstrdup_const(const char *s,
gfp_tgfp){ if (is_kernel_rodata((unsigned long)s)) return s; return kstrdup(s, gfp); }A readonly string which is in the kernel rodata, so we do not need to dynamically allocate
memory to store the name. So with this patch applied, there is nothing changed which
means that we did not waste memory. But it can prevent someone from reading stale name
if an unaware user passes an address to a stack-allocated buffer.
Quoted 1 line
So I think it is worth fixing, right?
Again, there is nothing to "fix" here as there is no code in the kernel tree today calling this api with a class name that is not static.
If we have code that does need to do this, and it is submitted for merging, and I agree with how it is creating the class names, I will be glad to take a patch at that time to make this change. Until then, this is just added complexity for no benefit at all.
thanks,
greg k-h
A message that is not in the archive (sent off-list or not yet received): CAC_bin+tzPeHX2bAz+0hY+qKsBn4-vMuqFvYvW05bDGv32SzEw@mail.gmail.com
Greg KH
maintainerQuoted 85 lines · Fei Zhang
Dear Greg
Quoted 69 lines · Greg KH < [email protected] >于2020年4月6日周一下午7:16写道:
Quoted 5 lines · On Mon, Apr 06, 2020 at 06:42:46PM +0800,宋牧春wrote:
Hi Greg,
Quoted 2 lines · Greg KH < [email protected] >于2020年4月6日周一下午4:29写道:
A: http://en.wikipedia.org/wiki/
Top_post<http://en.wikipedia.org/wiki/Top_post>
Quoted 10 lines
Quoted 10 lines
Q: Were do I find info about this thing called top-posting?
A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing in e-mail?A: No.
Q : Should I include quotations after my reply?http://daringfireball.net/ 2007/07/on_top
<http://daringfireball.net/2007/07/on_top>
Quoted 7 lines
Quoted 7 lines · Fei Zhang
Quoted 5 lines
Dear Greg,
Mostly, "
class_creat" is used in kernel driver module, basically read-only strings,
but it is easier to use a local variable string. When writing drivemodule,
Quoted 1 line
Quoted 1 line
Quoted 1 line
it fails to judge the local variable string which cannot be passed
in
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
only via interface.
I found that someone else may also face the same problem.An individual driver should NOT be creating a class, that is not what
it
Quoted 3 lines
Quoted 1 line
is there for.
If someone want to create a virtual device,someone can call
device_create().Quoted 3 lines
But the first argument is type of 'struct class *class', so we have to call
class_create()
before create device. So an individual driver may be creating a class,right?
Again, they should not be, as classes are not what a driver creates. It is what a subsystem creates, as a class is a type of common devices that all talk to userspace in the same way.
Quoted 21 lines
Quoted 2 lines
Class names are very "rare" and should not be dynamically created at all.
I have reviewed the code of the
kstrdup_const()which is just below.const char *kstrdup_const(const char *s,
gfp_tgfp) {
if (is_kernel_rodata((unsigned long)s)) return s;return
kstrdup(s, gfp);
}A readonly string which is in the kernel rodata, so we do not need to dynamically allocate
memory to store the name. So with this patch applied, there is nothing changed which
means that we did not waste memory. But it can prevent someone from reading stale name
if an unaware user passes an address to a stack-allocated buffer.Quoted 1 line
So I think it is worth fixing, right?
Quoted 7 lines
Again, there is nothing to "fix" here as there is no code in the kernel tree today calling this api with a class name that is not static.
If we have code that does need to do this,and it is submitted for merging, and I agree with how it is creating the class names, I will be glad to take a patch at that time to make this change. Until then, this is just added complexity for no benefit at all.
Quoted 3 lines
The interface was used by many drivers. Please refer to below link.
https://elixir.bootlin.com/linux/latest/source/drivers/char/dsp56k.c#L507
That should just be fixed up to use the misc device interface, I'll put it on my list of things to fix...
Quoted 1 line
Does anyone still care/use pcmcia drivers? I doubt you will ever run this code :)
Quoted 1 line
TPM is a valid class, nothing is wrong with that.
Quoted 7 lines
...
Quoted 1 line
Normally, class shall be created before creating the virtual device.
https://elixir.bootlin.com/linux/latest/source/fs/pstore/pmsg.c#L66
Those too are fine, nothing broken with them.
Quoted 3 lines
...
Quoted 1 line
I think it is worth fixing, it will make the code more stable.
The code is working just fine as-is, nothing is broken. By adding unneeded complexity, it will be more unstable.
Not to mention the first attempt didn't even get it correct, which if I had accepted, would have _introduced_ a bug for no reason at all.
Again, if you have an in-kernel user that wants to somehow create a class dynamically off of the stack like your example showed, I will be glad to revisit this, after I review that driver's code.
thanks,
greg k-h
Hi PengfeiZhang,
Quoted 75 lines · Greg KH <[email protected]> 于2020年4月6日周一 上午12:40写道:
Quoted 11 lines · On Sun, Apr 05, 2020 at 09:05:49AM -0700, [email protected] wrote:
From: PengfeiZhang <[email protected]>
__class_create()copies the pointer to the name passed as an argument only to be used later. But there's a chance the caller could immediately free the passedstring(e.g., local variable). This could trigger a use after free when we use classname(e.g., dev_uevent_name()called by device_destroy(),class_create_release()).To be on the safe side: duplicate the string with
kstrdup_const()so that if an unaware user passes an address to a stack-allocated buffer, we won't get the arbitrary name and crash.Where are you seeing this happen?
Quoted 19 lines
Signed-off-by PengfeiZhang <[email protected]>--- drivers/base/class.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)drivers/base/class.c +1
-0@@ -206,6 +206,7 @@ void class_unregister(struct class *cls)static void class_create_release (struct class *cls) {pr_debug ("%s called for %s\n" , __func__, cls->name); +kfree_const (cls->name);kfree (cls); }drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 234
Quoted 8 lines
drivers/base/class.c +4
-1@@ -227,7 +228,10 @@ struct class *__class_create(struct module *owner, const char *name, struct lock_class_key *key) {struct class *cls; -int retval; +int retval = -EINVAL ; + +if (!name) + goto done;This is a new change, who calls this function with name not being set?
drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 246
Quoted 12 lines
drivers/base/class.c +5
-0cls =kzalloc (sizeof (*cls),GFP_KERNEL );if (!cls) {@@ -235,18 +239,27 @@ struct class *__class_create(struct module *owner, const char *name, goto error; } + name =kstrdup_const (name,GFP_KERNEL ); +if (!name) { + retval = -ENOMEM ; + goto error; + }and overwriting the pointer like that is bad-form, try doing something else here instead.
Quoted 12 lines
drivers/base/class.c +2
-1+ cls->name = name; cls->owner = owner; cls->class_release = class_create_release; retval =__class_register (cls, key);if (retval) - goto error; + goto error_class_register;return cls;
Quoted 8 lines
drivers/base/class.c struct class *__class_create(struct module *owner, const char *name, · line 259
Quoted 2 lines
drivers/base/class.c +2
-0+error_class_register: +kfree (cls->name);
kfree_const()?thanks,
greg k-h
Yeah, you have some problem with this fix patch which Greg mentioned. Can you fix it? And
send the fix patch v2 to Greg?
Signature · 2 lines
Yours, Muchun