?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] aic7xxx_osm build fix
[cris-mirror.git] / drivers / usb / core / inode.c
blobf9f9561c6bad3fa611e410af62aaffae92771335
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 static struct dentry * get_dentry(struct dentry *parent, const char *name)
457 {
458 struct qstr qstr;
459
460 qstr.name = name;
461 qstr.len = strlen(name);
462 qstr.hash = full_name_hash(name,qstr.len);
463 return lookup_hash(&qstr,parent);
464 }
465
466
467 /*
468 * fs_create_by_name - create a file, given a name
469 * @name: name of file
470 * @mode: type of file
471 * @parent: dentry of directory to create it in
472 * @dentry: resulting dentry of file
473 *
474 * This function handles both regular files and directories.
475 */
476 static int fs_create_by_name (const char *name, mode_t mode,
477 struct dentry *parent, struct dentry **dentry)
478 {
479 int error = 0;
480
481 /* If the parent is not specified, we create it in the root.
482 * We need the root dentry to do this, which is in the super
483 * block. A pointer to that is in the struct vfsmount that we
484 * have around.
485 */
486 if (!parent ) {
487 if (usbfs_mount && usbfs_mount->mnt_sb) {
488 parent = usbfs_mount->mnt_sb->s_root;
489 }
490 }
491
492 if (!parent) {
493 dbg("Ah! can not find a parent!");
494 return -EFAULT;
495 }
496
497 *dentry = NULL;
498 down(&parent->d_inode->i_sem);
499 *dentry = get_dentry (parent, name);
500 if (!IS_ERR(dentry)) {
501 if ((mode & S_IFMT) == S_IFDIR)
502 error = usbfs_mkdir (parent->d_inode, *dentry, mode);
503 else
504 error = usbfs_create (parent->d_inode, *dentry, mode);
505 } else
506 error = PTR_ERR(dentry);
507 up(&parent->d_inode->i_sem);
508
509 return error;
510 }
511
512 static struct dentry *fs_create_file (const char *name, mode_t mode,
513 struct dentry *parent, void *data,
514 struct file_operations *fops,
515 uid_t uid, gid_t gid)
516 {
517 struct dentry *dentry;
518 int error;
519
520 dbg("creating file '%s'",name);
521
522 error = fs_create_by_name (name, mode, parent, &dentry);
523 if (error) {
524 dentry = NULL;
525 } else {
526 if (dentry->d_inode) {
527 if (data)
528 dentry->d_inode->u.generic_ip = data;
529 if (fops)
530 dentry->d_inode->i_fop = fops;
531 dentry->d_inode->i_uid = uid;
532 dentry->d_inode->i_gid = gid;
533 }
534 }
535
536 return dentry;
537 }
538
539 static void fs_remove_file (struct dentry *dentry)
540 {
541 struct dentry *parent = dentry->d_parent;
542
543 if (!parent || !parent->d_inode)
544 return;
545
546 down(&parent->d_inode->i_sem);
547 if (usbfs_positive(dentry)) {
548 if (dentry->d_inode) {
549 if (S_ISDIR(dentry->d_inode->i_mode))
550 usbfs_rmdir(parent->d_inode, dentry);
551 else
552 usbfs_unlink(parent->d_inode, dentry);
553 dput(dentry);
554 }
555 }
556 up(&parent->d_inode->i_sem);
557 }
558
559 /* --------------------------------------------------------------------- */
560
561 static struct super_block *usb_get_sb(struct file_system_type *fs_type,
562 int flags, const char *dev_name, void *data)
563 {
564 return get_sb_single(fs_type, flags, data, usbfs_fill_super);
565 }
566
567 static struct file_system_type usb_fs_type = {
568 .owner = THIS_MODULE,
569 .name = "usbfs",
570 .get_sb = usb_get_sb,
571 .kill_sb = kill_litter_super,
572 };
573
574 /* --------------------------------------------------------------------- */
575
576 static int create_special_files (void)
577 {
578 struct dentry *parent;
579 int retval;
580
581 /* the simple_pin_fs calls will call remount with no options
582 * without this flag that would overwrite the real mount options (if any)
583 */
584 ignore_mount = 1;
585
586 /* create the devices special file */
587 retval = simple_pin_fs("usbfs", &usbfs_mount, &usbfs_mount_count);
588 if (retval) {
589 err ("Unable to get usbfs mount");
590 goto exit;
591 }
592
593 ignore_mount = 0;
594
595 parent = usbfs_mount->mnt_sb->s_root;
596 devices_usbfs_dentry = fs_create_file ("devices",
597 listmode | S_IFREG, parent,
598 NULL, &usbfs_devices_fops,
599 listuid, listgid);
600 if (devices_usbfs_dentry == NULL) {
601 err ("Unable to create devices usbfs file");
602 retval = -ENODEV;
603 goto error_clean_mounts;
604 }
605
606 goto exit;
607
608 error_clean_mounts:
609 simple_release_fs(&usbfs_mount, &usbfs_mount_count);
610 exit:
611 return retval;
612 }
613
614 static void remove_special_files (void)
615 {
616 if (devices_usbfs_dentry)
617 fs_remove_file (devices_usbfs_dentry);
618 devices_usbfs_dentry = NULL;
619 simple_release_fs(&usbfs_mount, &usbfs_mount_count);
620 }
621
622 void usbfs_update_special (void)
623 {
624 struct inode *inode;
625
626 if (devices_usbfs_dentry) {
627 inode = devices_usbfs_dentry->d_inode;
628 if (inode)
629 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
630 }
631 }
632
633 void usbfs_add_bus(struct usb_bus *bus)
634 {
635 struct dentry *parent;
636 char name[8];
637 int retval;
638
639 /* create the special files if this is the first bus added */
640 if (num_buses == 0) {
641 retval = create_special_files();
642 if (retval)
643 return;
644 }
645 ++num_buses;
646
647 sprintf (name, "%03d", bus->busnum);
648
649 parent = usbfs_mount->mnt_sb->s_root;
650 bus->usbfs_dentry = fs_create_file (name, busmode | S_IFDIR, parent,
651 bus, NULL, busuid, busgid);
652 if (bus->usbfs_dentry == NULL) {
653 err ("error creating usbfs bus entry");
654 return;
655 }
656
657 usbfs_update_special();
658 usbfs_conn_disc_event();
659 }
660
661 void usbfs_remove_bus(struct usb_bus *bus)
662 {
663 if (bus->usbfs_dentry) {
664 fs_remove_file (bus->usbfs_dentry);
665 bus->usbfs_dentry = NULL;
666 }
667
668 --num_buses;
669 if (num_buses <= 0) {
670 remove_special_files();
671 num_buses = 0;
672 }
673
674 usbfs_update_special();
675 usbfs_conn_disc_event();
676 }
677
678 void usbfs_add_device(struct usb_device *dev)
679 {
680 char name[8];
681 int i;
682 int i_size;
683
684 sprintf (name, "%03d", dev->devnum);
685 dev->usbfs_dentry = fs_create_file (name, devmode | S_IFREG,
686 dev->bus->usbfs_dentry, dev,
687 &usbfs_device_file_operations,
688 devuid, devgid);
689 if (dev->usbfs_dentry == NULL) {
690 err ("error creating usbfs device entry");
691 return;
692 }
693
694 /* Set the size of the device's file to be
695 * equal to the size of the device descriptors. */
696 i_size = sizeof (struct usb_device_descriptor);
697 for (i = 0; i < dev->descriptor.bNumConfigurations; ++i) {
698 struct usb_config_descriptor *config =
699 (struct usb_config_descriptor *)dev->rawdescriptors[i];
700 i_size += le16_to_cpu(config->wTotalLength);
701 }
702 if (dev->usbfs_dentry->d_inode)
703 dev->usbfs_dentry->d_inode->i_size = i_size;
704
705 usbfs_update_special();
706 usbfs_conn_disc_event();
707 }
708
709 void usbfs_remove_device(struct usb_device *dev)
710 {
711 struct dev_state *ds;
712 struct siginfo sinfo;
713
714 if (dev->usbfs_dentry) {
715 fs_remove_file (dev->usbfs_dentry);
716 dev->usbfs_dentry = NULL;
717 }
718 while (!list_empty(&dev->filelist)) {
719 ds = list_entry(dev->filelist.next, struct dev_state, list);
720 wake_up_all(&ds->wait);
721 list_del_init(&ds->list);
722 if (ds->discsignr) {
723 sinfo.si_signo = SIGPIPE;
724 sinfo.si_errno = EPIPE;
725 sinfo.si_code = SI_ASYNCIO;
726 sinfo.si_addr = ds->disccontext;
727 send_sig_info(ds->discsignr, &sinfo, ds->disctask);
728 }
729 }
730 usbfs_update_special();
731 usbfs_conn_disc_event();
732 }
733
734 /* --------------------------------------------------------------------- */
735
736 static struct proc_dir_entry *usbdir = NULL;
737
738 int __init usbfs_init(void)
739 {
740 int retval;
741
742 retval = usb_register(&usbfs_driver);
743 if (retval)
744 return retval;
745
746 retval = register_filesystem(&usb_fs_type);
747 if (retval) {
748 usb_deregister(&usbfs_driver);
749 return retval;
750 }
751
752 /* create mount point for usbfs */
753 usbdir = proc_mkdir("usb", proc_bus);
754
755 return 0;
756 }
757
758 void usbfs_cleanup(void)
759 {
760 usb_deregister(&usbfs_driver);
761 unregister_filesystem(&usb_fs_type);
762 if (usbdir)
763 remove_proc_entry("usb", proc_bus);
764 }
765
CRIS linux kernel tree