thinkpad-acpi: Fix procfs hotkey reset command
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / proc / generic.c
blob60a359b355821a032c36d22beb4740fdc763075e
1 /*
2 * proc/fs/generic.c --- generic routines for the proc-fs
4 * This file contains generic proc-fs routines for handling
5 * directories and files.
6 *
7 * Copyright (C) 1991, 1992 Linus Torvalds.
8 * Copyright (C) 1997 Theodore Ts'o
9 */
11 #include <linux/errno.h>
12 #include <linux/time.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
15 #include <linux/module.h>
16 #include <linux/mount.h>
17 #include <linux/smp_lock.h>
18 #include <linux/init.h>
19 #include <linux/idr.h>
20 #include <linux/namei.h>
21 #include <linux/bitops.h>
22 #include <linux/spinlock.h>
23 #include <linux/completion.h>
24 #include <asm/uaccess.h>
26 #include "internal.h"
28 DEFINE_SPINLOCK(proc_subdir_lock);
30 static int proc_match(int len, const char *name, struct proc_dir_entry *de)
32 if (de->namelen != len)
33 return 0;
34 return !memcmp(name, de->name, len);
37 /* buffer size is one page but our output routines use some slack for overruns */
38 #define PROC_BLOCK_SIZE (PAGE_SIZE - 1024)
40 static ssize_t
41 proc_file_read(struct file *file, char __user *buf, size_t nbytes,
42 loff_t *ppos)
44 struct inode * inode = file->f_path.dentry->d_inode;
45 char *page;
46 ssize_t retval=0;
47 int eof=0;
48 ssize_t n, count;
49 char *start;
50 struct proc_dir_entry * dp;
51 unsigned long long pos;
54 * Gaah, please just use "seq_file" instead. The legacy /proc
55 * interfaces cut loff_t down to off_t for reads, and ignore
56 * the offset entirely for writes..
58 pos = *ppos;
59 if (pos > MAX_NON_LFS)
60 return 0;
61 if (nbytes > MAX_NON_LFS - pos)
62 nbytes = MAX_NON_LFS - pos;
64 dp = PDE(inode);
65 if (!(page = (char*) __get_free_page(GFP_TEMPORARY)))
66 return -ENOMEM;
68 while ((nbytes > 0) && !eof) {
69 count = min_t(size_t, PROC_BLOCK_SIZE, nbytes);
71 start = NULL;
72 if (dp->read_proc) {
74 * How to be a proc read function
75 * ------------------------------
76 * Prototype:
77 * int f(char *buffer, char **start, off_t offset,
78 * int count, int *peof, void *dat)
80 * Assume that the buffer is "count" bytes in size.
82 * If you know you have supplied all the data you
83 * have, set *peof.
85 * You have three ways to return data:
86 * 0) Leave *start = NULL. (This is the default.)
87 * Put the data of the requested offset at that
88 * offset within the buffer. Return the number (n)
89 * of bytes there are from the beginning of the
90 * buffer up to the last byte of data. If the
91 * number of supplied bytes (= n - offset) is
92 * greater than zero and you didn't signal eof
93 * and the reader is prepared to take more data
94 * you will be called again with the requested
95 * offset advanced by the number of bytes
96 * absorbed. This interface is useful for files
97 * no larger than the buffer.
98 * 1) Set *start = an unsigned long value less than
99 * the buffer address but greater than zero.
100 * Put the data of the requested offset at the
101 * beginning of the buffer. Return the number of
102 * bytes of data placed there. If this number is
103 * greater than zero and you didn't signal eof
104 * and the reader is prepared to take more data
105 * you will be called again with the requested
106 * offset advanced by *start. This interface is
107 * useful when you have a large file consisting
108 * of a series of blocks which you want to count
109 * and return as wholes.
110 * (Hack by Paul.Russell@rustcorp.com.au)
111 * 2) Set *start = an address within the buffer.
112 * Put the data of the requested offset at *start.
113 * Return the number of bytes of data placed there.
114 * If this number is greater than zero and you
115 * didn't signal eof and the reader is prepared to
116 * take more data you will be called again with the
117 * requested offset advanced by the number of bytes
118 * absorbed.
120 n = dp->read_proc(page, &start, *ppos,
121 count, &eof, dp->data);
122 } else
123 break;
125 if (n == 0) /* end of file */
126 break;
127 if (n < 0) { /* error */
128 if (retval == 0)
129 retval = n;
130 break;
133 if (start == NULL) {
134 if (n > PAGE_SIZE) {
135 printk(KERN_ERR
136 "proc_file_read: Apparent buffer overflow!\n");
137 n = PAGE_SIZE;
139 n -= *ppos;
140 if (n <= 0)
141 break;
142 if (n > count)
143 n = count;
144 start = page + *ppos;
145 } else if (start < page) {
146 if (n > PAGE_SIZE) {
147 printk(KERN_ERR
148 "proc_file_read: Apparent buffer overflow!\n");
149 n = PAGE_SIZE;
151 if (n > count) {
153 * Don't reduce n because doing so might
154 * cut off part of a data block.
156 printk(KERN_WARNING
157 "proc_file_read: Read count exceeded\n");
159 } else /* start >= page */ {
160 unsigned long startoff = (unsigned long)(start - page);
161 if (n > (PAGE_SIZE - startoff)) {
162 printk(KERN_ERR
163 "proc_file_read: Apparent buffer overflow!\n");
164 n = PAGE_SIZE - startoff;
166 if (n > count)
167 n = count;
170 n -= copy_to_user(buf, start < page ? page : start, n);
171 if (n == 0) {
172 if (retval == 0)
173 retval = -EFAULT;
174 break;
177 *ppos += start < page ? (unsigned long)start : n;
178 nbytes -= n;
179 buf += n;
180 retval += n;
182 free_page((unsigned long) page);
183 return retval;
186 static ssize_t
187 proc_file_write(struct file *file, const char __user *buffer,
188 size_t count, loff_t *ppos)
190 struct inode *inode = file->f_path.dentry->d_inode;
191 struct proc_dir_entry * dp;
193 dp = PDE(inode);
195 if (!dp->write_proc)
196 return -EIO;
198 /* FIXME: does this routine need ppos? probably... */
199 return dp->write_proc(file, buffer, count, dp->data);
203 static loff_t
204 proc_file_lseek(struct file *file, loff_t offset, int orig)
206 loff_t retval = -EINVAL;
207 switch (orig) {
208 case 1:
209 offset += file->f_pos;
210 /* fallthrough */
211 case 0:
212 if (offset < 0 || offset > MAX_NON_LFS)
213 break;
214 file->f_pos = retval = offset;
216 return retval;
219 static const struct file_operations proc_file_operations = {
220 .llseek = proc_file_lseek,
221 .read = proc_file_read,
222 .write = proc_file_write,
225 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
227 struct inode *inode = dentry->d_inode;
228 struct proc_dir_entry *de = PDE(inode);
229 int error;
231 error = inode_change_ok(inode, iattr);
232 if (error)
233 goto out;
235 error = inode_setattr(inode, iattr);
236 if (error)
237 goto out;
239 de->uid = inode->i_uid;
240 de->gid = inode->i_gid;
241 de->mode = inode->i_mode;
242 out:
243 return error;
246 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
247 struct kstat *stat)
249 struct inode *inode = dentry->d_inode;
250 struct proc_dir_entry *de = PROC_I(inode)->pde;
251 if (de && de->nlink)
252 inode->i_nlink = de->nlink;
254 generic_fillattr(inode, stat);
255 return 0;
258 static const struct inode_operations proc_file_inode_operations = {
259 .setattr = proc_notify_change,
263 * This function parses a name such as "tty/driver/serial", and
264 * returns the struct proc_dir_entry for "/proc/tty/driver", and
265 * returns "serial" in residual.
267 static int xlate_proc_name(const char *name,
268 struct proc_dir_entry **ret, const char **residual)
270 const char *cp = name, *next;
271 struct proc_dir_entry *de;
272 int len;
273 int rtn = 0;
275 de = *ret;
276 if (!de)
277 de = &proc_root;
279 spin_lock(&proc_subdir_lock);
280 while (1) {
281 next = strchr(cp, '/');
282 if (!next)
283 break;
285 len = next - cp;
286 for (de = de->subdir; de ; de = de->next) {
287 if (proc_match(len, cp, de))
288 break;
290 if (!de) {
291 rtn = -ENOENT;
292 goto out;
294 cp += len + 1;
296 *residual = cp;
297 *ret = de;
298 out:
299 spin_unlock(&proc_subdir_lock);
300 return rtn;
303 static DEFINE_IDA(proc_inum_ida);
304 static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */
306 #define PROC_DYNAMIC_FIRST 0xF0000000U
309 * Return an inode number between PROC_DYNAMIC_FIRST and
310 * 0xffffffff, or zero on failure.
312 static unsigned int get_inode_number(void)
314 unsigned int i;
315 int error;
317 retry:
318 if (ida_pre_get(&proc_inum_ida, GFP_KERNEL) == 0)
319 return 0;
321 spin_lock(&proc_inum_lock);
322 error = ida_get_new(&proc_inum_ida, &i);
323 spin_unlock(&proc_inum_lock);
324 if (error == -EAGAIN)
325 goto retry;
326 else if (error)
327 return 0;
329 if (i > UINT_MAX - PROC_DYNAMIC_FIRST) {
330 spin_lock(&proc_inum_lock);
331 ida_remove(&proc_inum_ida, i);
332 spin_unlock(&proc_inum_lock);
333 return 0;
335 return PROC_DYNAMIC_FIRST + i;
338 static void release_inode_number(unsigned int inum)
340 spin_lock(&proc_inum_lock);
341 ida_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
342 spin_unlock(&proc_inum_lock);
345 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd)
347 nd_set_link(nd, PDE(dentry->d_inode)->data);
348 return NULL;
351 static const struct inode_operations proc_link_inode_operations = {
352 .readlink = generic_readlink,
353 .follow_link = proc_follow_link,
357 * As some entries in /proc are volatile, we want to
358 * get rid of unused dentries. This could be made
359 * smarter: we could keep a "volatile" flag in the
360 * inode to indicate which ones to keep.
362 static int proc_delete_dentry(struct dentry * dentry)
364 return 1;
367 static struct dentry_operations proc_dentry_operations =
369 .d_delete = proc_delete_dentry,
373 * Don't create negative dentries here, return -ENOENT by hand
374 * instead.
376 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
377 struct dentry *dentry)
379 struct inode *inode = NULL;
380 int error = -ENOENT;
382 lock_kernel();
383 spin_lock(&proc_subdir_lock);
384 for (de = de->subdir; de ; de = de->next) {
385 if (de->namelen != dentry->d_name.len)
386 continue;
387 if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
388 unsigned int ino;
390 ino = de->low_ino;
391 de_get(de);
392 spin_unlock(&proc_subdir_lock);
393 error = -EINVAL;
394 inode = proc_get_inode(dir->i_sb, ino, de);
395 goto out_unlock;
398 spin_unlock(&proc_subdir_lock);
399 out_unlock:
400 unlock_kernel();
402 if (inode) {
403 dentry->d_op = &proc_dentry_operations;
404 d_add(dentry, inode);
405 return NULL;
407 if (de)
408 de_put(de);
409 return ERR_PTR(error);
412 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
413 struct nameidata *nd)
415 return proc_lookup_de(PDE(dir), dir, dentry);
419 * This returns non-zero if at EOF, so that the /proc
420 * root directory can use this and check if it should
421 * continue with the <pid> entries..
423 * Note that the VFS-layer doesn't care about the return
424 * value of the readdir() call, as long as it's non-negative
425 * for success..
427 int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
428 filldir_t filldir)
430 unsigned int ino;
431 int i;
432 struct inode *inode = filp->f_path.dentry->d_inode;
433 int ret = 0;
435 lock_kernel();
437 ino = inode->i_ino;
438 i = filp->f_pos;
439 switch (i) {
440 case 0:
441 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
442 goto out;
443 i++;
444 filp->f_pos++;
445 /* fall through */
446 case 1:
447 if (filldir(dirent, "..", 2, i,
448 parent_ino(filp->f_path.dentry),
449 DT_DIR) < 0)
450 goto out;
451 i++;
452 filp->f_pos++;
453 /* fall through */
454 default:
455 spin_lock(&proc_subdir_lock);
456 de = de->subdir;
457 i -= 2;
458 for (;;) {
459 if (!de) {
460 ret = 1;
461 spin_unlock(&proc_subdir_lock);
462 goto out;
464 if (!i)
465 break;
466 de = de->next;
467 i--;
470 do {
471 struct proc_dir_entry *next;
473 /* filldir passes info to user space */
474 de_get(de);
475 spin_unlock(&proc_subdir_lock);
476 if (filldir(dirent, de->name, de->namelen, filp->f_pos,
477 de->low_ino, de->mode >> 12) < 0) {
478 de_put(de);
479 goto out;
481 spin_lock(&proc_subdir_lock);
482 filp->f_pos++;
483 next = de->next;
484 de_put(de);
485 de = next;
486 } while (de);
487 spin_unlock(&proc_subdir_lock);
489 ret = 1;
490 out: unlock_kernel();
491 return ret;
494 int proc_readdir(struct file *filp, void *dirent, filldir_t filldir)
496 struct inode *inode = filp->f_path.dentry->d_inode;
498 return proc_readdir_de(PDE(inode), filp, dirent, filldir);
502 * These are the generic /proc directory operations. They
503 * use the in-memory "struct proc_dir_entry" tree to parse
504 * the /proc directory.
506 static const struct file_operations proc_dir_operations = {
507 .read = generic_read_dir,
508 .readdir = proc_readdir,
512 * proc directories can do almost nothing..
514 static const struct inode_operations proc_dir_inode_operations = {
515 .lookup = proc_lookup,
516 .getattr = proc_getattr,
517 .setattr = proc_notify_change,
520 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
522 unsigned int i;
523 struct proc_dir_entry *tmp;
525 i = get_inode_number();
526 if (i == 0)
527 return -EAGAIN;
528 dp->low_ino = i;
530 if (S_ISDIR(dp->mode)) {
531 if (dp->proc_iops == NULL) {
532 dp->proc_fops = &proc_dir_operations;
533 dp->proc_iops = &proc_dir_inode_operations;
535 dir->nlink++;
536 } else if (S_ISLNK(dp->mode)) {
537 if (dp->proc_iops == NULL)
538 dp->proc_iops = &proc_link_inode_operations;
539 } else if (S_ISREG(dp->mode)) {
540 if (dp->proc_fops == NULL)
541 dp->proc_fops = &proc_file_operations;
542 if (dp->proc_iops == NULL)
543 dp->proc_iops = &proc_file_inode_operations;
546 spin_lock(&proc_subdir_lock);
548 for (tmp = dir->subdir; tmp; tmp = tmp->next)
549 if (strcmp(tmp->name, dp->name) == 0) {
550 WARN(1, KERN_WARNING "proc_dir_entry '%s/%s' already registered\n",
551 dir->name, dp->name);
552 break;
555 dp->next = dir->subdir;
556 dp->parent = dir;
557 dir->subdir = dp;
558 spin_unlock(&proc_subdir_lock);
560 return 0;
563 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
564 const char *name,
565 mode_t mode,
566 nlink_t nlink)
568 struct proc_dir_entry *ent = NULL;
569 const char *fn = name;
570 int len;
572 /* make sure name is valid */
573 if (!name || !strlen(name)) goto out;
575 if (xlate_proc_name(name, parent, &fn) != 0)
576 goto out;
578 /* At this point there must not be any '/' characters beyond *fn */
579 if (strchr(fn, '/'))
580 goto out;
582 len = strlen(fn);
584 ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL);
585 if (!ent) goto out;
587 memset(ent, 0, sizeof(struct proc_dir_entry));
588 memcpy(((char *) ent) + sizeof(struct proc_dir_entry), fn, len + 1);
589 ent->name = ((char *) ent) + sizeof(*ent);
590 ent->namelen = len;
591 ent->mode = mode;
592 ent->nlink = nlink;
593 atomic_set(&ent->count, 1);
594 ent->pde_users = 0;
595 spin_lock_init(&ent->pde_unload_lock);
596 ent->pde_unload_completion = NULL;
597 INIT_LIST_HEAD(&ent->pde_openers);
598 out:
599 return ent;
602 struct proc_dir_entry *proc_symlink(const char *name,
603 struct proc_dir_entry *parent, const char *dest)
605 struct proc_dir_entry *ent;
607 ent = __proc_create(&parent, name,
608 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
610 if (ent) {
611 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
612 if (ent->data) {
613 strcpy((char*)ent->data,dest);
614 if (proc_register(parent, ent) < 0) {
615 kfree(ent->data);
616 kfree(ent);
617 ent = NULL;
619 } else {
620 kfree(ent);
621 ent = NULL;
624 return ent;
627 struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
628 struct proc_dir_entry *parent)
630 struct proc_dir_entry *ent;
632 ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
633 if (ent) {
634 if (proc_register(parent, ent) < 0) {
635 kfree(ent);
636 ent = NULL;
639 return ent;
642 struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
643 struct proc_dir_entry *parent)
645 struct proc_dir_entry *ent;
647 ent = __proc_create(&parent, name, S_IFDIR | S_IRUGO | S_IXUGO, 2);
648 if (ent) {
649 ent->data = net;
650 if (proc_register(parent, ent) < 0) {
651 kfree(ent);
652 ent = NULL;
655 return ent;
657 EXPORT_SYMBOL_GPL(proc_net_mkdir);
659 struct proc_dir_entry *proc_mkdir(const char *name,
660 struct proc_dir_entry *parent)
662 return proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent);
665 struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
666 struct proc_dir_entry *parent)
668 struct proc_dir_entry *ent;
669 nlink_t nlink;
671 if (S_ISDIR(mode)) {
672 if ((mode & S_IALLUGO) == 0)
673 mode |= S_IRUGO | S_IXUGO;
674 nlink = 2;
675 } else {
676 if ((mode & S_IFMT) == 0)
677 mode |= S_IFREG;
678 if ((mode & S_IALLUGO) == 0)
679 mode |= S_IRUGO;
680 nlink = 1;
683 ent = __proc_create(&parent, name, mode, nlink);
684 if (ent) {
685 if (proc_register(parent, ent) < 0) {
686 kfree(ent);
687 ent = NULL;
690 return ent;
693 struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
694 struct proc_dir_entry *parent,
695 const struct file_operations *proc_fops,
696 void *data)
698 struct proc_dir_entry *pde;
699 nlink_t nlink;
701 if (S_ISDIR(mode)) {
702 if ((mode & S_IALLUGO) == 0)
703 mode |= S_IRUGO | S_IXUGO;
704 nlink = 2;
705 } else {
706 if ((mode & S_IFMT) == 0)
707 mode |= S_IFREG;
708 if ((mode & S_IALLUGO) == 0)
709 mode |= S_IRUGO;
710 nlink = 1;
713 pde = __proc_create(&parent, name, mode, nlink);
714 if (!pde)
715 goto out;
716 pde->proc_fops = proc_fops;
717 pde->data = data;
718 if (proc_register(parent, pde) < 0)
719 goto out_free;
720 return pde;
721 out_free:
722 kfree(pde);
723 out:
724 return NULL;
727 void free_proc_entry(struct proc_dir_entry *de)
729 unsigned int ino = de->low_ino;
731 if (ino < PROC_DYNAMIC_FIRST)
732 return;
734 release_inode_number(ino);
736 if (S_ISLNK(de->mode))
737 kfree(de->data);
738 kfree(de);
742 * Remove a /proc entry and free it if it's not currently in use.
744 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
746 struct proc_dir_entry **p;
747 struct proc_dir_entry *de = NULL;
748 const char *fn = name;
749 int len;
751 if (xlate_proc_name(name, &parent, &fn) != 0)
752 return;
753 len = strlen(fn);
755 spin_lock(&proc_subdir_lock);
756 for (p = &parent->subdir; *p; p=&(*p)->next ) {
757 if (proc_match(len, fn, *p)) {
758 de = *p;
759 *p = de->next;
760 de->next = NULL;
761 break;
764 spin_unlock(&proc_subdir_lock);
765 if (!de)
766 return;
768 spin_lock(&de->pde_unload_lock);
770 * Stop accepting new callers into module. If you're
771 * dynamically allocating ->proc_fops, save a pointer somewhere.
773 de->proc_fops = NULL;
774 /* Wait until all existing callers into module are done. */
775 if (de->pde_users > 0) {
776 DECLARE_COMPLETION_ONSTACK(c);
778 if (!de->pde_unload_completion)
779 de->pde_unload_completion = &c;
781 spin_unlock(&de->pde_unload_lock);
783 wait_for_completion(de->pde_unload_completion);
785 goto continue_removing;
787 spin_unlock(&de->pde_unload_lock);
789 continue_removing:
790 spin_lock(&de->pde_unload_lock);
791 while (!list_empty(&de->pde_openers)) {
792 struct pde_opener *pdeo;
794 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh);
795 list_del(&pdeo->lh);
796 spin_unlock(&de->pde_unload_lock);
797 pdeo->release(pdeo->inode, pdeo->file);
798 kfree(pdeo);
799 spin_lock(&de->pde_unload_lock);
801 spin_unlock(&de->pde_unload_lock);
803 if (S_ISDIR(de->mode))
804 parent->nlink--;
805 de->nlink = 0;
806 WARN(de->subdir, KERN_WARNING "%s: removing non-empty directory "
807 "'%s/%s', leaking at least '%s'\n", __func__,
808 de->parent->name, de->name, de->subdir->name);
809 if (atomic_dec_and_test(&de->count))
810 free_proc_entry(de);