?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / usb / core / inode.c
blobc3e3a95d3804ff8e48dd308f4272fdf2e9072a0a
1 /*****************************************************************************/
2
3 /*
4 * inode.c -- Inode/Dentry functions for the USB device file system.
5 *
6 * Copyright (C) 2000 Thomas Sailer (sailer@ife.ee.ethz.ch)
7 * Copyright (C) 2001,2002,2004 Greg Kroah-Hartman (greg@kroah.com)
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 * History:
24 * 0.1 04.01.2000 Created
25 * 0.2 10.12.2001 converted to use the vfs layer better
26 */
27
28 /*****************************************************************************/
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/fs.h>
33 #include <linux/mount.h>
34 #include <linux/pagemap.h>
35 #include <linux/init.h>
36 #include <linux/proc_fs.h>
37 #include <linux/usb.h>
38 #include <linux/namei.h>
39 #include <linux/usbdevice_fs.h>
40 #include <linux/smp_lock.h>
41 #include <linux/parser.h>
42 #include <asm/byteorder.h>
43 #include "usb.h"
44 #include "hcd.h"
45
46 static struct super_operations usbfs_ops;
47 static struct file_operations default_file_operations;
48 static struct inode_operations usbfs_dir_inode_operations;
49 static struct vfsmount *usbfs_mount;
50 static int usbfs_mount_count; /* = 0 */
51 static int ignore_mount = 0;
52
53 static struct dentry *devices_usbfs_dentry;
54 static int num_buses; /* = 0 */
55
56 static uid_t devuid; /* = 0 */
57 static uid_t busuid; /* = 0 */
58 static uid_t listuid; /* = 0 */
59 static gid_t devgid; /* = 0 */
60 static gid_t busgid; /* = 0 */
61 static gid_t listgid; /* = 0 */
62 static umode_t devmode = S_IWUSR | S_IRUGO;
63 static umode_t busmode = S_IXUGO | S_IRUGO;
64 static umode_t listmode = S_IRUGO;
65
66 enum {
67 Opt_devuid, Opt_devgid, Opt_devmode,
68 Opt_busuid, Opt_busgid, Opt_busmode,
69 Opt_listuid, Opt_listgid, Opt_listmode,
70 Opt_err,
71 };
72
73 static match_table_t tokens = {
74 {Opt_devuid, "devuid=%u"},
75 {Opt_devgid, "devgid=%u"},
76 {Opt_devmode, "devmode=%o"},
77 {Opt_busuid, "busuid=%u"},
78 {Opt_busgid, "busgid=%u"},
79 {Opt_busmode, "busmode=%o"},
80 {Opt_listuid, "listuid=%u"},
81 {Opt_listgid, "listgid=%u"},
82 {Opt_listmode, "listmode=%o"},
83 {Opt_err, NULL}
84 };
85
86 static int parse_options(struct super_block *s, char *data)
87 {
88 char *p;
89 int option;
90
91 /* (re)set to defaults. */
92 devuid = 0;
93 busuid = 0;
94 listuid = 0;
95 devgid = 0;
96 busgid = 0;
97 listgid = 0;
98 devmode = S_IWUSR | S_IRUGO;
99 busmode = S_IXUGO | S_IRUGO;
100 listmode = S_IRUGO;
101
102 while ((p = strsep(&data, ",")) != NULL) {
103 substring_t args[MAX_OPT_ARGS];
104 int token;
105 if (!*p)
106 continue;
107
108 token = match_token(p, tokens, args);
109 switch (token) {
110 case Opt_devuid:
111 if (match_int(&args[0], &option))
112 return -EINVAL;
113 devuid = option;
114 break;
115 case Opt_devgid:
116 if (match_int(&args[0], &option))
117 return -EINVAL;
118 devgid = option;
119 break;
120 case Opt_devmode:
121 if (match_octal(&args[0], &option))
122 return -EINVAL;
123 devmode = option & S_IRWXUGO;
124 break;
125 case Opt_busuid:
126 if (match_int(&args[0], &option))
127 return -EINVAL;
128 busuid = option;
129 break;
130 case Opt_busgid:
131 if (match_int(&args[0], &option))
132 return -EINVAL;
133 busgid = option;
134 break;
135 case Opt_busmode:
136 if (match_octal(&args[0], &option))
137 return -EINVAL;
138 busmode = option & S_IRWXUGO;
139 break;
140 case Opt_listuid:
141 if (match_int(&args[0], &option))
142 return -EINVAL;
143 listuid = option;
144 break;
145 case Opt_listgid:
146 if (match_int(&args[0], &option))
147 return -EINVAL;
148 listgid = option;
149 break;
150 case Opt_listmode:
151 if (match_octal(&args[0], &option))
152 return -EINVAL;
153 listmode = option & S_IRWXUGO;
154 break;
155 default:
156 err("usbfs: unrecognised mount option \"%s\" "
157 "or missing value\n", p);
158 return -EINVAL;
159 }
160 }
161
162 return 0;
163 }
164
165 static void update_special(struct dentry *special)
166 {
167 special->d_inode->i_uid = listuid;
168 special->d_inode->i_gid = listgid;
169 special->d_inode->i_mode = S_IFREG | listmode;
170 }
171
172 static void update_dev(struct dentry *dev)
173 {
174 dev->d_inode->i_uid = devuid;
175 dev->d_inode->i_gid = devgid;
176 dev->d_inode->i_mode = S_IFREG | devmode;
177 }
178
179 static void update_bus(struct dentry *bus)
180 {
181 struct dentry *dev = NULL;
182
183 bus->d_inode->i_uid = busuid;
184 bus->d_inode->i_gid = busgid;
185 bus->d_inode->i_mode = S_IFDIR | busmode;
186
187 down(&bus->d_inode->i_sem);
188
189 list_for_each_entry(dev, &bus->d_subdirs, d_child)
190 if (dev->d_inode)
191 update_dev(dev);
192
193 up(&bus->d_inode->i_sem);
194 }
195
196 static void update_sb(struct super_block *sb)
197 {
198 struct dentry *root = sb->s_root;
199 struct dentry *bus = NULL;
200
201 if (!root)
202 return;
203
204 down(&root->d_inode->i_sem);
205
206 list_for_each_entry(bus, &root->d_subdirs, d_child) {
207 if (bus->d_inode) {
208 switch (S_IFMT & bus->d_inode->i_mode) {
209 case S_IFDIR:
210 update_bus(bus);
211 break;
212 case S_IFREG:
213 update_special(bus);
214 break;
215 default:
216 warn("Unknown node %s mode %x found on remount!\n",bus->d_name.name,bus->d_inode->i_mode);
217 break;
218 }
219 }
220 }
221
222 up(&root->d_inode->i_sem);
223 }
224
225 static int remount(struct super_block *sb, int *flags, char *data)
226 {
227 /* If this is not a real mount,
228 * i.e. it's a simple_pin_fs from create_special_files,
229 * then ignore it.
230 */
231 if (ignore_mount)
232 return 0;
233
234 if (parse_options(sb, data)) {
235 warn("usbfs: mount parameter error:");
236 return -EINVAL;
237 }
238
239 if (usbfs_mount && usbfs_mount->mnt_sb)
240 update_sb(usbfs_mount->mnt_sb);
241
242 return 0;
243 }
244
245 static struct inode *usbfs_get_inode (struct super_block *sb, int mode, dev_t dev)
246 {
247 struct inode *inode = new_inode(sb);
248
249 if (inode) {
250 inode->i_mode = mode;
251 inode->i_uid = current->fsuid;
252 inode->i_gid = current->fsgid;
253 inode->i_blksize = PAGE_CACHE_SIZE;
254 inode->i_blocks = 0;
255 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
256 switch (mode & S_IFMT) {
257 default:
258 init_special_inode(inode, mode, dev);
259 break;
260 case S_IFREG:
261 inode->i_fop = &default_file_operations;
262 break;
263 case S_IFDIR:
264 inode->i_op = &usbfs_dir_inode_operations;
265 inode->i_fop = &simple_dir_operations;
266
267 /* directory inodes start off with i_nlink == 2 (for "." entry) */
268 inode->i_nlink++;
269 break;
270 }
271 }
272 return inode;
273 }
274
275 /* SMP-safe */
276 static int usbfs_mknod (struct inode *dir, struct dentry *dentry, int mode,
277 dev_t dev)
278 {
279 struct inode *inode = usbfs_get_inode(dir->i_sb, mode, dev);
280 int error = -EPERM;
281
282 if (dentry->d_inode)
283 return -EEXIST;
284
285 if (inode) {
286 d_instantiate(dentry, inode);
287 dget(dentry);
288 error = 0;
289 }
290 return error;
291 }
292
293 static int usbfs_mkdir (struct inode *dir, struct dentry *dentry, int mode)
294 {
295 int res;
296
297 mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
298 res = usbfs_mknod (dir, dentry, mode, 0);
299 if (!res)
300 dir->i_nlink++;
301 return res;
302 }
303
304 static int usbfs_create (struct inode *dir, struct dentry *dentry, int mode)
305 {
306 mode = (mode & S_IALLUGO) | S_IFREG;
307 return usbfs_mknod (dir, dentry, mode, 0);
308 }
309
310 static inline int usbfs_positive (struct dentry *dentry)
311 {
312 return dentry->d_inode && !d_unhashed(dentry);
313 }
314
315 static int usbfs_empty (struct dentry *dentry)
316 {
317 struct list_head *list;
318
319 spin_lock(&dcache_lock);
320
321 list_for_each(list, &dentry->d_subdirs) {
322 struct dentry *de = list_entry(list, struct dentry, d_child);
323 if (usbfs_positive(de)) {
324 spin_unlock(&dcache_lock);
325 return 0;
326 }
327 }
328
329 spin_unlock(&dcache_lock);
330 return 1;
331 }
332
333 static int usbfs_unlink (struct inode *dir, struct dentry *dentry)
334 {
335 struct inode *inode = dentry->d_inode;
336 down(&inode->i_sem);
337 dentry->d_inode->i_nlink--;
338 dput(dentry);
339 up(&inode->i_sem);
340 d_delete(dentry);
341 return 0;
342 }
343
344 static int usbfs_rmdir(struct inode *dir, struct dentry *dentry)
345 {
346 int error = -ENOTEMPTY;
347 struct inode * inode = dentry->d_inode;
348
349 down(&inode->i_sem);
350 dentry_unhash(dentry);
351 if (usbfs_empty(dentry)) {
352 dentry->d_inode->i_nlink -= 2;
353 dput(dentry);
354 inode->i_flags |= S_DEAD;
355 dir->i_nlink--;
356 error = 0;
357 }
358 up(&inode->i_sem);
359 if (!error)
360 d_delete(dentry);
361 dput(dentry);
362 return error;
363 }
364
365
366 /* default file operations */
367 static ssize_t default_read_file (struct file *file, char __user *buf,
368 size_t count, loff_t *ppos)
369 {
370 return 0;
371 }
372
373 static ssize_t default_write_file (struct file *file, const char __user *buf,
374 size_t count, loff_t *ppos)
375 {
376 return count;
377 }
378
379 static loff_t default_file_lseek (struct file *file, loff_t offset, int orig)
380 {
381 loff_t retval = -EINVAL;
382
383 down(&file->f_dentry->d_inode->i_sem);
384 switch(orig) {
385 case 0:
386 if (offset > 0) {
387 file->f_pos = offset;
388 retval = file->f_pos;
389 }
390 break;
391 case 1:
392 if ((offset + file->f_pos) > 0) {
393 file->f_pos += offset;
394 retval = file->f_pos;
395 }
396 break;
397 default:
398 break;
399 }
400 up(&file->f_dentry->d_inode->i_sem);
401 return retval;
402 }
403
404 static int default_open (struct inode *inode, struct file *file)
405 {
406 if (inode->u.generic_ip)
407 file->private_data = inode->u.generic_ip;
408
409 return 0;
410 }
411
412 static struct file_operations default_file_operations = {
413 .read = default_read_file,
414 .write = default_write_file,
415 .open = default_open,
416 .llseek = default_file_lseek,
417 };
418
419 static struct inode_operations usbfs_dir_inode_operations = {
420 .lookup = simple_lookup,
421 };
422
423 static struct super_operations usbfs_ops = {
424 .statfs = simple_statfs,
425 .drop_inode = generic_delete_inode,
426 .remount_fs = remount,
427 };
428
429 static int usbfs_fill_super(struct super_block *sb, void *data, int silent)
430 {
431 struct inode *inode;
432 struct dentry *root;
433
434 sb->s_blocksize = PAGE_CACHE_SIZE;
435 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
436 sb->s_magic = USBDEVICE_SUPER_MAGIC;
437 sb->s_op = &usbfs_ops;
438 sb->s_time_gran = 1;
439 inode = usbfs_get_inode(sb, S_IFDIR | 0755, 0);
440
441 if (!inode) {
442 dbg("%s: could not get inode!",__FUNCTION__);
443 return -ENOMEM;
444 }
445
446 root = d_alloc_root(inode);
447 if (!root) {
448 dbg("%s: could not get root dentry!",__FUNCTION__);
449 iput(inode);
450 return -ENOMEM;
451 }
452 sb->s_root = root;
453 return 0;
454 }
455
456 /*
457 * fs_create_by_name - create a file, given a name
458 * @name: name of file
459 * @mode: type of file
460 * @parent: dentry of directory to create it in
461 * @dentry: resulting dentry of file
462 *
463 * This function handles both regular files and directories.
464 */
465 static int fs_create_by_name (const char *name, mode_t mode,
466 struct dentry *parent, struct dentry **dentry)
467 {
468 int error = 0;
469
470 /* If the parent is not specified, we create it in the root.
471 * We need the root dentry to do this, which is in the super
472 * block. A pointer to that is in the struct vfsmount that we
473 * have around.
474 */
475 if (!parent ) {
476 if (usbfs_mount && usbfs_mount->mnt_sb) {
477 parent = usbfs_mount->mnt_sb->s_root;
478 }
479 }
480
481 if (!parent) {
482 dbg("Ah! can not find a parent!");
483 return -EFAULT;
484 }
485
486 *dentry = NULL;
487 down(&parent->d_inode->i_sem);
488 *dentry = lookup_one_len(name, parent, strlen(name));
489 if (!IS_ERR(dentry)) {
490 if ((mode & S_IFMT) == S_IFDIR)
491 error = usbfs_mkdir (parent->d_inode, *dentry, mode);
492 else
493 error = usbfs_create (parent->d_inode, *dentry, mode);
494 } else
495 error = PTR_ERR(dentry);
496 up(&parent->d_inode->i_sem);
497
498 return error;
499 }
500
501 static struct dentry *fs_create_file (const char *name, mode_t mode,
502 struct dentry *parent, void *data,
503 struct file_operations *fops,
504 uid_t uid, gid_t gid)
505 {
506 struct dentry *dentry;
507 int error;
508
509 dbg("creating file '%s'",name);
510
511 error = fs_create_by_name (name, mode, parent, &dentry);
512 if (error) {
513 dentry = NULL;
514 } else {
515 if (dentry->d_inode) {
516 if (data)
517 dentry->d_inode->u.generic_ip = data;
518 if (fops)
519 dentry->d_inode->i_fop = fops;
520 dentry->d_inode->i_uid = uid;
521 dentry->d_inode->i_gid = gid;
522 }
523 }
524
525 return dentry;
526 }
527
528 static void fs_remove_file (struct dentry *dentry)
529 {
530 struct dentry *parent = dentry->d_parent;
531
532 if (!parent || !parent->d_inode)
533 return;
534
535 down(&parent->d_inode->i_sem);
536 if (usbfs_positive(dentry)) {
537 if (dentry->d_inode) {
538 if (S_ISDIR(dentry->d_inode->i_mode))
539 usbfs_rmdir(parent->d_inode, dentry);
540 else
541 usbfs_unlink(parent->d_inode, dentry);
542 dput(dentry);
543 }
544 }
545 up(&parent->d_inode->i_sem);
546 }
547
548 /* --------------------------------------------------------------------- */
549
550 static struct super_block *usb_get_sb(struct file_system_type *fs_type,
551 int flags, const char *dev_name, void *data)
552 {
553 return get_sb_single(fs_type, flags, data, usbfs_fill_super);
554 }
555
556 static struct file_system_type usb_fs_type = {
557 .owner = THIS_MODULE,
558 .name = "usbfs",
559 .get_sb = usb_get_sb,
560 .kill_sb = kill_litter_super,
561 };
562
563 /* --------------------------------------------------------------------- */
564
565 static int create_special_files (void)
566 {
567 struct dentry *parent;
568 int retval;
569
570 /* the simple_pin_fs calls will call remount with no options
571 * without this flag that would overwrite the real mount options (if any)
572 */
573 ignore_mount = 1;
574
575 /* create the devices special file */
576 retval = simple_pin_fs("usbfs", &usbfs_mount, &usbfs_mount_count);
577 if (retval) {
578 err ("Unable to get usbfs mount");
579 goto exit;
580 }
581
582 ignore_mount = 0;
583
584 parent = usbfs_mount->mnt_sb->s_root;
585 devices_usbfs_dentry = fs_create_file ("devices",
586 listmode | S_IFREG, parent,
587 NULL, &usbfs_devices_fops,
588 listuid, listgid);
589 if (devices_usbfs_dentry == NULL) {
590 err ("Unable to create devices usbfs file");
591 retval = -ENODEV;
592 goto error_clean_mounts;
593 }
594
595 goto exit;
596
597 error_clean_mounts:
598 simple_release_fs(&usbfs_mount, &usbfs_mount_count);
599 exit:
600 return retval;
601 }
602
603 static void remove_special_files (void)
604 {
605 if (devices_usbfs_dentry)
606 fs_remove_file (devices_usbfs_dentry);
607 devices_usbfs_dentry = NULL;
608 simple_release_fs(&usbfs_mount, &usbfs_mount_count);
609 }
610
611 void usbfs_update_special (void)
612 {
613 struct inode *inode;
614
615 if (devices_usbfs_dentry) {
616 inode = devices_usbfs_dentry->d_inode;
617 if (inode)
618 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
619 }
620 }
621
622 void usbfs_add_bus(struct usb_bus *bus)
623 {
624 struct dentry *parent;
625 char name[8];
626 int retval;
627
628 /* create the special files if this is the first bus added */
629 if (num_buses == 0) {
630 retval = create_special_files();
631 if (retval)
632 return;
633 }
634 ++num_buses;
635
636 sprintf (name, "%03d", bus->busnum);
637
638 parent = usbfs_mount->mnt_sb->s_root;
639 bus->usbfs_dentry = fs_create_file (name, busmode | S_IFDIR, parent,
640 bus, NULL, busuid, busgid);
641 if (bus->usbfs_dentry == NULL) {
642 err ("error creating usbfs bus entry");
643 return;
644 }
645
646 usbfs_update_special();
647 usbfs_conn_disc_event();
648 }
649
650 void usbfs_remove_bus(struct usb_bus *bus)
651 {
652 if (bus->usbfs_dentry) {
653 fs_remove_file (bus->usbfs_dentry);
654 bus->usbfs_dentry = NULL;
655 }
656
657 --num_buses;
658 if (num_buses <= 0) {
659 remove_special_files();
660 num_buses = 0;
661 }
662
663 usbfs_update_special();
664 usbfs_conn_disc_event();
665 }
666
667 void usbfs_add_device(struct usb_device *dev)
668 {
669 char name[8];
670 int i;
671 int i_size;
672
673 sprintf (name, "%03d", dev->devnum);
674 dev->usbfs_dentry = fs_create_file (name, devmode | S_IFREG,
675 dev->bus->usbfs_dentry, dev,
676 &usbfs_device_file_operations,
677 devuid, devgid);
678 if (dev->usbfs_dentry == NULL) {
679 err ("error creating usbfs device entry");
680 return;
681 }
682
683 /* Set the size of the device's file to be
684 * equal to the size of the device descriptors. */
685 i_size = sizeof (struct usb_device_descriptor);
686 for (i = 0; i < dev->descriptor.bNumConfigurations; ++i) {
687 struct usb_config_descriptor *config =
688 (struct usb_config_descriptor *)dev->rawdescriptors[i];
689 i_size += le16_to_cpu(config->wTotalLength);
690 }
691 if (dev->usbfs_dentry->d_inode)
692 dev->usbfs_dentry->d_inode->i_size = i_size;
693
694 usbfs_update_special();
695 usbfs_conn_disc_event();
696 }
697
698 void usbfs_remove_device(struct usb_device *dev)
699 {
700 struct dev_state *ds;
701 struct siginfo sinfo;
702
703 if (dev->usbfs_dentry) {
704 fs_remove_file (dev->usbfs_dentry);
705 dev->usbfs_dentry = NULL;
706 }
707 while (!list_empty(&dev->filelist)) {
708 ds = list_entry(dev->filelist.next, struct dev_state, list);
709 wake_up_all(&ds->wait);
710 list_del_init(&ds->list);
711 if (ds->discsignr) {
712 sinfo.si_signo = SIGPIPE;
713 sinfo.si_errno = EPIPE;
714 sinfo.si_code = SI_ASYNCIO;
715 sinfo.si_addr = ds->disccontext;
716 send_sig_info(ds->discsignr, &sinfo, ds->disctask);
717 }
718 }
719 usbfs_update_special();
720 usbfs_conn_disc_event();
721 }
722
723 /* --------------------------------------------------------------------- */
724
725 static struct proc_dir_entry *usbdir = NULL;
726
727 int __init usbfs_init(void)
728 {
729 int retval;
730
731 retval = usb_register(&usbfs_driver);
732 if (retval)
733 return retval;
734
735 retval = register_filesystem(&usb_fs_type);
736 if (retval) {
737 usb_deregister(&usbfs_driver);
738 return retval;
739 }
740
741 /* create mount point for usbfs */
742 usbdir = proc_mkdir("usb", proc_bus);
743
744 return 0;
745 }
746
747 void usbfs_cleanup(void)
748 {
749 usb_deregister(&usbfs_driver);
750 unregister_filesystem(&usb_fs_type);
751 if (usbdir)
752 remove_proc_entry("usb", proc_bus);
753 }
754
linux-next