diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-16 15:40:26 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-16 15:40:26 -0400 |
commit | c813b4e16ead3c3df98ac84419d4df2adf33fe01 (patch) | |
tree | 2ca4a5b6966d833b6149e3dda7a4e85d1255779c /lib | |
parent | c8d8a2321f9c4ee18fbcc399fdc2a77e580a03b9 (diff) | |
parent | 02683ffdf655b4ae15245376ba6fea6d9e5829a6 (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6: (46 commits)
UIO: Fix mapping of logical and virtual memory
UIO: add automata sercos3 pci card support
UIO: Change driver name of uio_pdrv
UIO: Add alignment warnings for uio-mem
Driver core: add bus_sort_breadthfirst() function
NET: convert the phy_device file to use bus_find_device_by_name
kobject: Cleanup kobject_rename and !CONFIG_SYSFS
kobject: Fix kobject_rename and !CONFIG_SYSFS
sysfs: Make dir and name args to sysfs_notify() const
platform: add new device registration helper
sysfs: use ilookup5() instead of ilookup5_nowait()
PNP: create device attributes via default device attributes
Driver core: make bus_find_device_by_name() more robust
usb: turn dev_warn+WARN_ON combos into dev_WARN
debug: use dev_WARN() rather than WARN_ON() in device_pm_add()
debug: Introduce a dev_WARN() function
sysfs: fix deadlock
device model: Do a quickcheck for driver binding before doing an expensive check
Driver core: Fix cleanup in device_create_vargs().
Driver core: Clarify device cleanup.
...
Diffstat (limited to 'lib')
-rw-r--r-- | lib/Kconfig.debug | 55 | ||||
-rw-r--r-- | lib/Makefile | 2 | ||||
-rw-r--r-- | lib/dynamic_printk.c | 418 | ||||
-rw-r--r-- | lib/kobject.c | 35 |
4 files changed, 495 insertions, 15 deletions
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index aa81d2848448..31d784dd80d0 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug | |||
@@ -807,6 +807,61 @@ menuconfig BUILD_DOCSRC | |||
807 | 807 | ||
808 | Say N if you are unsure. | 808 | Say N if you are unsure. |
809 | 809 | ||
810 | config DYNAMIC_PRINTK_DEBUG | ||
811 | bool "Enable dynamic printk() call support" | ||
812 | default n | ||
813 | depends on PRINTK | ||
814 | select PRINTK_DEBUG | ||
815 | help | ||
816 | |||
817 | Compiles debug level messages into the kernel, which would not | ||
818 | otherwise be available at runtime. These messages can then be | ||
819 | enabled/disabled on a per module basis. This mechanism implicitly | ||
820 | enables all pr_debug() and dev_dbg() calls. The impact of this | ||
821 | compile option is a larger kernel text size of about 2%. | ||
822 | |||
823 | Usage: | ||
824 | |||
825 | Dynamic debugging is controlled by the debugfs file, | ||
826 | dynamic_printk/modules. This file contains a list of the modules that | ||
827 | can be enabled. The format of the file is the module name, followed | ||
828 | by a set of flags that can be enabled. The first flag is always the | ||
829 | 'enabled' flag. For example: | ||
830 | |||
831 | <module_name> <enabled=0/1> | ||
832 | . | ||
833 | . | ||
834 | . | ||
835 | |||
836 | <module_name> : Name of the module in which the debug call resides | ||
837 | <enabled=0/1> : whether the messages are enabled or not | ||
838 | |||
839 | From a live system: | ||
840 | |||
841 | snd_hda_intel enabled=0 | ||
842 | fixup enabled=0 | ||
843 | driver enabled=0 | ||
844 | |||
845 | Enable a module: | ||
846 | |||
847 | $echo "set enabled=1 <module_name>" > dynamic_printk/modules | ||
848 | |||
849 | Disable a module: | ||
850 | |||
851 | $echo "set enabled=0 <module_name>" > dynamic_printk/modules | ||
852 | |||
853 | Enable all modules: | ||
854 | |||
855 | $echo "set enabled=1 all" > dynamic_printk/modules | ||
856 | |||
857 | Disable all modules: | ||
858 | |||
859 | $echo "set enabled=0 all" > dynamic_printk/modules | ||
860 | |||
861 | Finally, passing "dynamic_printk" at the command line enables | ||
862 | debugging for all modules. This mode can be turned off via the above | ||
863 | disable command. | ||
864 | |||
810 | source "samples/Kconfig" | 865 | source "samples/Kconfig" |
811 | 866 | ||
812 | source "lib/Kconfig.kgdb" | 867 | source "lib/Kconfig.kgdb" |
diff --git a/lib/Makefile b/lib/Makefile index 44001af76a7d..16feaab057b2 100644 --- a/lib/Makefile +++ b/lib/Makefile | |||
@@ -81,6 +81,8 @@ obj-$(CONFIG_HAVE_LMB) += lmb.o | |||
81 | 81 | ||
82 | obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o | 82 | obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o |
83 | 83 | ||
84 | obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o | ||
85 | |||
84 | hostprogs-y := gen_crc32table | 86 | hostprogs-y := gen_crc32table |
85 | clean-files := crc32table.h | 87 | clean-files := crc32table.h |
86 | 88 | ||
diff --git a/lib/dynamic_printk.c b/lib/dynamic_printk.c new file mode 100644 index 000000000000..d640f87bdc9e --- /dev/null +++ b/lib/dynamic_printk.c | |||
@@ -0,0 +1,418 @@ | |||
1 | /* | ||
2 | * lib/dynamic_printk.c | ||
3 | * | ||
4 | * make pr_debug()/dev_dbg() calls runtime configurable based upon their | ||
5 | * their source module. | ||
6 | * | ||
7 | * Copyright (C) 2008 Red Hat, Inc., Jason Baron <jbaron@redhat.com> | ||
8 | */ | ||
9 | |||
10 | #include <linux/kernel.h> | ||
11 | #include <linux/module.h> | ||
12 | #include <linux/uaccess.h> | ||
13 | #include <linux/seq_file.h> | ||
14 | #include <linux/debugfs.h> | ||
15 | #include <linux/fs.h> | ||
16 | |||
17 | extern struct mod_debug __start___verbose[]; | ||
18 | extern struct mod_debug __stop___verbose[]; | ||
19 | |||
20 | struct debug_name { | ||
21 | struct hlist_node hlist; | ||
22 | struct hlist_node hlist2; | ||
23 | int hash1; | ||
24 | int hash2; | ||
25 | char *name; | ||
26 | int enable; | ||
27 | int type; | ||
28 | }; | ||
29 | |||
30 | static int nr_entries; | ||
31 | static int num_enabled; | ||
32 | int dynamic_enabled = DYNAMIC_ENABLED_NONE; | ||
33 | static struct hlist_head module_table[DEBUG_HASH_TABLE_SIZE] = | ||
34 | { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT }; | ||
35 | static struct hlist_head module_table2[DEBUG_HASH_TABLE_SIZE] = | ||
36 | { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT }; | ||
37 | static DECLARE_MUTEX(debug_list_mutex); | ||
38 | |||
39 | /* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which | ||
40 | * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They | ||
41 | * use independent hash functions, to reduce the chance of false positives. | ||
42 | */ | ||
43 | long long dynamic_printk_enabled; | ||
44 | EXPORT_SYMBOL_GPL(dynamic_printk_enabled); | ||
45 | long long dynamic_printk_enabled2; | ||
46 | EXPORT_SYMBOL_GPL(dynamic_printk_enabled2); | ||
47 | |||
48 | /* returns the debug module pointer. */ | ||
49 | static struct debug_name *find_debug_module(char *module_name) | ||
50 | { | ||
51 | int i; | ||
52 | struct hlist_head *head; | ||
53 | struct hlist_node *node; | ||
54 | struct debug_name *element; | ||
55 | |||
56 | element = NULL; | ||
57 | for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) { | ||
58 | head = &module_table[i]; | ||
59 | hlist_for_each_entry_rcu(element, node, head, hlist) | ||
60 | if (!strcmp(element->name, module_name)) | ||
61 | return element; | ||
62 | } | ||
63 | return NULL; | ||
64 | } | ||
65 | |||
66 | /* returns the debug module pointer. */ | ||
67 | static struct debug_name *find_debug_module_hash(char *module_name, int hash) | ||
68 | { | ||
69 | struct hlist_head *head; | ||
70 | struct hlist_node *node; | ||
71 | struct debug_name *element; | ||
72 | |||
73 | element = NULL; | ||
74 | head = &module_table[hash]; | ||
75 | hlist_for_each_entry_rcu(element, node, head, hlist) | ||
76 | if (!strcmp(element->name, module_name)) | ||
77 | return element; | ||
78 | return NULL; | ||
79 | } | ||
80 | |||
81 | /* caller must hold mutex*/ | ||
82 | static int __add_debug_module(char *mod_name, int hash, int hash2) | ||
83 | { | ||
84 | struct debug_name *new; | ||
85 | char *module_name; | ||
86 | int ret = 0; | ||
87 | |||
88 | if (find_debug_module(mod_name)) { | ||
89 | ret = -EINVAL; | ||
90 | goto out; | ||
91 | } | ||
92 | module_name = kmalloc(strlen(mod_name) + 1, GFP_KERNEL); | ||
93 | if (!module_name) { | ||
94 | ret = -ENOMEM; | ||
95 | goto out; | ||
96 | } | ||
97 | module_name = strcpy(module_name, mod_name); | ||
98 | module_name[strlen(mod_name)] = '\0'; | ||
99 | new = kzalloc(sizeof(struct debug_name), GFP_KERNEL); | ||
100 | if (!new) { | ||
101 | kfree(module_name); | ||
102 | ret = -ENOMEM; | ||
103 | goto out; | ||
104 | } | ||
105 | INIT_HLIST_NODE(&new->hlist); | ||
106 | INIT_HLIST_NODE(&new->hlist2); | ||
107 | new->name = module_name; | ||
108 | new->hash1 = hash; | ||
109 | new->hash2 = hash2; | ||
110 | hlist_add_head_rcu(&new->hlist, &module_table[hash]); | ||
111 | hlist_add_head_rcu(&new->hlist2, &module_table2[hash2]); | ||
112 | nr_entries++; | ||
113 | out: | ||
114 | return ret; | ||
115 | } | ||
116 | |||
117 | int unregister_dynamic_debug_module(char *mod_name) | ||
118 | { | ||
119 | struct debug_name *element; | ||
120 | int ret = 0; | ||
121 | |||
122 | down(&debug_list_mutex); | ||
123 | element = find_debug_module(mod_name); | ||
124 | if (!element) { | ||
125 | ret = -EINVAL; | ||
126 | goto out; | ||
127 | } | ||
128 | hlist_del_rcu(&element->hlist); | ||
129 | hlist_del_rcu(&element->hlist2); | ||
130 | synchronize_rcu(); | ||
131 | kfree(element->name); | ||
132 | if (element->enable) | ||
133 | num_enabled--; | ||
134 | kfree(element); | ||
135 | nr_entries--; | ||
136 | out: | ||
137 | up(&debug_list_mutex); | ||
138 | return 0; | ||
139 | } | ||
140 | EXPORT_SYMBOL_GPL(unregister_dynamic_debug_module); | ||
141 | |||
142 | int register_dynamic_debug_module(char *mod_name, int type, char *share_name, | ||
143 | char *flags, int hash, int hash2) | ||
144 | { | ||
145 | struct debug_name *elem; | ||
146 | int ret = 0; | ||
147 | |||
148 | down(&debug_list_mutex); | ||
149 | elem = find_debug_module(mod_name); | ||
150 | if (!elem) { | ||
151 | if (__add_debug_module(mod_name, hash, hash2)) | ||
152 | goto out; | ||
153 | elem = find_debug_module(mod_name); | ||
154 | if (dynamic_enabled == DYNAMIC_ENABLED_ALL && | ||
155 | !strcmp(mod_name, share_name)) { | ||
156 | elem->enable = true; | ||
157 | num_enabled++; | ||
158 | } | ||
159 | } | ||
160 | elem->type |= type; | ||
161 | out: | ||
162 | up(&debug_list_mutex); | ||
163 | return ret; | ||
164 | } | ||
165 | EXPORT_SYMBOL_GPL(register_dynamic_debug_module); | ||
166 | |||
167 | int __dynamic_dbg_enabled_helper(char *mod_name, int type, int value, int hash) | ||
168 | { | ||
169 | struct debug_name *elem; | ||
170 | int ret = 0; | ||
171 | |||
172 | if (dynamic_enabled == DYNAMIC_ENABLED_ALL) | ||
173 | return 1; | ||
174 | rcu_read_lock(); | ||
175 | elem = find_debug_module_hash(mod_name, hash); | ||
176 | if (elem && elem->enable) | ||
177 | ret = 1; | ||
178 | rcu_read_unlock(); | ||
179 | return ret; | ||
180 | } | ||
181 | EXPORT_SYMBOL_GPL(__dynamic_dbg_enabled_helper); | ||
182 | |||
183 | static void set_all(bool enable) | ||
184 | { | ||
185 | struct debug_name *e; | ||
186 | struct hlist_node *node; | ||
187 | int i; | ||
188 | long long enable_mask; | ||
189 | |||
190 | for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) { | ||
191 | if (module_table[i].first != NULL) { | ||
192 | hlist_for_each_entry(e, node, &module_table[i], hlist) { | ||
193 | e->enable = enable; | ||
194 | } | ||
195 | } | ||
196 | } | ||
197 | if (enable) | ||
198 | enable_mask = ULLONG_MAX; | ||
199 | else | ||
200 | enable_mask = 0; | ||
201 | dynamic_printk_enabled = enable_mask; | ||
202 | dynamic_printk_enabled2 = enable_mask; | ||
203 | } | ||
204 | |||
205 | static int disabled_hash(int i, bool first_table) | ||
206 | { | ||
207 | struct debug_name *e; | ||
208 | struct hlist_node *node; | ||
209 | |||
210 | if (first_table) { | ||
211 | hlist_for_each_entry(e, node, &module_table[i], hlist) { | ||
212 | if (e->enable) | ||
213 | return 0; | ||
214 | } | ||
215 | } else { | ||
216 | hlist_for_each_entry(e, node, &module_table2[i], hlist2) { | ||
217 | if (e->enable) | ||
218 | return 0; | ||
219 | } | ||
220 | } | ||
221 | return 1; | ||
222 | } | ||
223 | |||
224 | static ssize_t pr_debug_write(struct file *file, const char __user *buf, | ||
225 | size_t length, loff_t *ppos) | ||
226 | { | ||
227 | char *buffer, *s, *value_str, *setting_str; | ||
228 | int err, value; | ||
229 | struct debug_name *elem = NULL; | ||
230 | int all = 0; | ||
231 | |||
232 | if (length > PAGE_SIZE || length < 0) | ||
233 | return -EINVAL; | ||
234 | |||
235 | buffer = (char *)__get_free_page(GFP_KERNEL); | ||
236 | if (!buffer) | ||
237 | return -ENOMEM; | ||
238 | |||
239 | err = -EFAULT; | ||
240 | if (copy_from_user(buffer, buf, length)) | ||
241 | goto out; | ||
242 | |||
243 | err = -EINVAL; | ||
244 | if (length < PAGE_SIZE) | ||
245 | buffer[length] = '\0'; | ||
246 | else if (buffer[PAGE_SIZE-1]) | ||
247 | goto out; | ||
248 | |||
249 | err = -EINVAL; | ||
250 | down(&debug_list_mutex); | ||
251 | |||
252 | if (strncmp("set", buffer, 3)) | ||
253 | goto out_up; | ||
254 | s = buffer + 3; | ||
255 | setting_str = strsep(&s, "="); | ||
256 | if (s == NULL) | ||
257 | goto out_up; | ||
258 | setting_str = strstrip(setting_str); | ||
259 | value_str = strsep(&s, " "); | ||
260 | if (s == NULL) | ||
261 | goto out_up; | ||
262 | s = strstrip(s); | ||
263 | if (!strncmp(s, "all", 3)) | ||
264 | all = 1; | ||
265 | else | ||
266 | elem = find_debug_module(s); | ||
267 | if (!strncmp(setting_str, "enable", 6)) { | ||
268 | value = !!simple_strtol(value_str, NULL, 10); | ||
269 | if (all) { | ||
270 | if (value) { | ||
271 | set_all(true); | ||
272 | num_enabled = nr_entries; | ||
273 | dynamic_enabled = DYNAMIC_ENABLED_ALL; | ||
274 | } else { | ||
275 | set_all(false); | ||
276 | num_enabled = 0; | ||
277 | dynamic_enabled = DYNAMIC_ENABLED_NONE; | ||
278 | } | ||
279 | err = 0; | ||
280 | } else { | ||
281 | if (elem) { | ||
282 | if (value && (elem->enable == 0)) { | ||
283 | dynamic_printk_enabled |= | ||
284 | (1LL << elem->hash1); | ||
285 | dynamic_printk_enabled2 |= | ||
286 | (1LL << elem->hash2); | ||
287 | elem->enable = 1; | ||
288 | num_enabled++; | ||
289 | dynamic_enabled = DYNAMIC_ENABLED_SOME; | ||
290 | err = 0; | ||
291 | printk(KERN_DEBUG | ||
292 | "debugging enabled for module %s", | ||
293 | elem->name); | ||
294 | } else if (!value && (elem->enable == 1)) { | ||
295 | elem->enable = 0; | ||
296 | num_enabled--; | ||
297 | if (disabled_hash(elem->hash1, true)) | ||
298 | dynamic_printk_enabled &= | ||
299 | ~(1LL << elem->hash1); | ||
300 | if (disabled_hash(elem->hash2, false)) | ||
301 | dynamic_printk_enabled2 &= | ||
302 | ~(1LL << elem->hash2); | ||
303 | if (num_enabled) | ||
304 | dynamic_enabled = | ||
305 | DYNAMIC_ENABLED_SOME; | ||
306 | else | ||
307 | dynamic_enabled = | ||
308 | DYNAMIC_ENABLED_NONE; | ||
309 | err = 0; | ||
310 | printk(KERN_DEBUG | ||
311 | "debugging disabled for module " | ||
312 | "%s", elem->name); | ||
313 | } | ||
314 | } | ||
315 | } | ||
316 | } | ||
317 | if (!err) | ||
318 | err = length; | ||
319 | out_up: | ||
320 | up(&debug_list_mutex); | ||
321 | out: | ||
322 | free_page((unsigned long)buffer); | ||
323 | return err; | ||
324 | } | ||
325 | |||
326 | static void *pr_debug_seq_start(struct seq_file *f, loff_t *pos) | ||
327 | { | ||
328 | return (*pos < DEBUG_HASH_TABLE_SIZE) ? pos : NULL; | ||
329 | } | ||
330 | |||
331 | static void *pr_debug_seq_next(struct seq_file *s, void *v, loff_t *pos) | ||
332 | { | ||
333 | (*pos)++; | ||
334 | if (*pos >= DEBUG_HASH_TABLE_SIZE) | ||
335 | return NULL; | ||
336 | return pos; | ||
337 | } | ||
338 | |||
339 | static void pr_debug_seq_stop(struct seq_file *s, void *v) | ||
340 | { | ||
341 | /* Nothing to do */ | ||
342 | } | ||
343 | |||
344 | static int pr_debug_seq_show(struct seq_file *s, void *v) | ||
345 | { | ||
346 | struct hlist_head *head; | ||
347 | struct hlist_node *node; | ||
348 | struct debug_name *elem; | ||
349 | unsigned int i = *(loff_t *) v; | ||
350 | |||
351 | rcu_read_lock(); | ||
352 | head = &module_table[i]; | ||
353 | hlist_for_each_entry_rcu(elem, node, head, hlist) { | ||
354 | seq_printf(s, "%s enabled=%d", elem->name, elem->enable); | ||
355 | seq_printf(s, "\n"); | ||
356 | } | ||
357 | rcu_read_unlock(); | ||
358 | return 0; | ||
359 | } | ||
360 | |||
361 | static struct seq_operations pr_debug_seq_ops = { | ||
362 | .start = pr_debug_seq_start, | ||
363 | .next = pr_debug_seq_next, | ||
364 | .stop = pr_debug_seq_stop, | ||
365 | .show = pr_debug_seq_show | ||
366 | }; | ||
367 | |||
368 | static int pr_debug_open(struct inode *inode, struct file *filp) | ||
369 | { | ||
370 | return seq_open(filp, &pr_debug_seq_ops); | ||
371 | } | ||
372 | |||
373 | static const struct file_operations pr_debug_operations = { | ||
374 | .open = pr_debug_open, | ||
375 | .read = seq_read, | ||
376 | .write = pr_debug_write, | ||
377 | .llseek = seq_lseek, | ||
378 | .release = seq_release, | ||
379 | }; | ||
380 | |||
381 | static int __init dynamic_printk_init(void) | ||
382 | { | ||
383 | struct dentry *dir, *file; | ||
384 | struct mod_debug *iter; | ||
385 | unsigned long value; | ||
386 | |||
387 | dir = debugfs_create_dir("dynamic_printk", NULL); | ||
388 | if (!dir) | ||
389 | return -ENOMEM; | ||
390 | file = debugfs_create_file("modules", 0644, dir, NULL, | ||
391 | &pr_debug_operations); | ||
392 | if (!file) { | ||
393 | debugfs_remove(dir); | ||
394 | return -ENOMEM; | ||
395 | } | ||
396 | for (value = (unsigned long)__start___verbose; | ||
397 | value < (unsigned long)__stop___verbose; | ||
398 | value += sizeof(struct mod_debug)) { | ||
399 | iter = (struct mod_debug *)value; | ||
400 | register_dynamic_debug_module(iter->modname, | ||
401 | iter->type, | ||
402 | iter->logical_modname, | ||
403 | iter->flag_names, iter->hash, iter->hash2); | ||
404 | } | ||
405 | return 0; | ||
406 | } | ||
407 | module_init(dynamic_printk_init); | ||
408 | /* may want to move this earlier so we can get traces as early as possible */ | ||
409 | |||
410 | static int __init dynamic_printk_setup(char *str) | ||
411 | { | ||
412 | if (str) | ||
413 | return -ENOENT; | ||
414 | set_all(true); | ||
415 | return 0; | ||
416 | } | ||
417 | /* Use early_param(), so we can get debug output as early as possible */ | ||
418 | early_param("dynamic_printk", dynamic_printk_setup); | ||
diff --git a/lib/kobject.c b/lib/kobject.c index fbf0ae282376..0487d1f64806 100644 --- a/lib/kobject.c +++ b/lib/kobject.c | |||
@@ -387,11 +387,17 @@ EXPORT_SYMBOL_GPL(kobject_init_and_add); | |||
387 | * kobject_rename - change the name of an object | 387 | * kobject_rename - change the name of an object |
388 | * @kobj: object in question. | 388 | * @kobj: object in question. |
389 | * @new_name: object's new name | 389 | * @new_name: object's new name |
390 | * | ||
391 | * It is the responsibility of the caller to provide mutual | ||
392 | * exclusion between two different calls of kobject_rename | ||
393 | * on the same kobject and to ensure that new_name is valid and | ||
394 | * won't conflict with other kobjects. | ||
390 | */ | 395 | */ |
391 | int kobject_rename(struct kobject *kobj, const char *new_name) | 396 | int kobject_rename(struct kobject *kobj, const char *new_name) |
392 | { | 397 | { |
393 | int error = 0; | 398 | int error = 0; |
394 | const char *devpath = NULL; | 399 | const char *devpath = NULL; |
400 | const char *dup_name = NULL, *name; | ||
395 | char *devpath_string = NULL; | 401 | char *devpath_string = NULL; |
396 | char *envp[2]; | 402 | char *envp[2]; |
397 | 403 | ||
@@ -401,19 +407,6 @@ int kobject_rename(struct kobject *kobj, const char *new_name) | |||
401 | if (!kobj->parent) | 407 | if (!kobj->parent) |
402 | return -EINVAL; | 408 | return -EINVAL; |
403 | 409 | ||
404 | /* see if this name is already in use */ | ||
405 | if (kobj->kset) { | ||
406 | struct kobject *temp_kobj; | ||
407 | temp_kobj = kset_find_obj(kobj->kset, new_name); | ||
408 | if (temp_kobj) { | ||
409 | printk(KERN_WARNING "kobject '%s' cannot be renamed " | ||
410 | "to '%s' as '%s' is already in existence.\n", | ||
411 | kobject_name(kobj), new_name, new_name); | ||
412 | kobject_put(temp_kobj); | ||
413 | return -EINVAL; | ||
414 | } | ||
415 | } | ||
416 | |||
417 | devpath = kobject_get_path(kobj, GFP_KERNEL); | 410 | devpath = kobject_get_path(kobj, GFP_KERNEL); |
418 | if (!devpath) { | 411 | if (!devpath) { |
419 | error = -ENOMEM; | 412 | error = -ENOMEM; |
@@ -428,15 +421,27 @@ int kobject_rename(struct kobject *kobj, const char *new_name) | |||
428 | envp[0] = devpath_string; | 421 | envp[0] = devpath_string; |
429 | envp[1] = NULL; | 422 | envp[1] = NULL; |
430 | 423 | ||
424 | name = dup_name = kstrdup(new_name, GFP_KERNEL); | ||
425 | if (!name) { | ||
426 | error = -ENOMEM; | ||
427 | goto out; | ||
428 | } | ||
429 | |||
431 | error = sysfs_rename_dir(kobj, new_name); | 430 | error = sysfs_rename_dir(kobj, new_name); |
431 | if (error) | ||
432 | goto out; | ||
433 | |||
434 | /* Install the new kobject name */ | ||
435 | dup_name = kobj->name; | ||
436 | kobj->name = name; | ||
432 | 437 | ||
433 | /* This function is mostly/only used for network interface. | 438 | /* This function is mostly/only used for network interface. |
434 | * Some hotplug package track interfaces by their name and | 439 | * Some hotplug package track interfaces by their name and |
435 | * therefore want to know when the name is changed by the user. */ | 440 | * therefore want to know when the name is changed by the user. */ |
436 | if (!error) | 441 | kobject_uevent_env(kobj, KOBJ_MOVE, envp); |
437 | kobject_uevent_env(kobj, KOBJ_MOVE, envp); | ||
438 | 442 | ||
439 | out: | 443 | out: |
444 | kfree(dup_name); | ||
440 | kfree(devpath_string); | 445 | kfree(devpath_string); |
441 | kfree(devpath); | 446 | kfree(devpath); |
442 | kobject_put(kobj); | 447 | kobject_put(kobj); |