aecb6e771e2ab3e0428354490f44a9d87e2517b2
[linux-2.6.git] / fs / sysfs / inode.c
1 /*
2  * inode.c - basic inode and dentry operations.
3  *
4  * sysfs is Copyright (c) 2001-3 Patrick Mochel
5  *
6  * Please see Documentation/filesystems/sysfs.txt for more information.
7  */
8
9 #undef DEBUG 
10
11 #include <linux/pagemap.h>
12 #include <linux/namei.h>
13 #include <linux/backing-dev.h>
14 #include <linux/capability.h>
15 #include <linux/errno.h>
16 #include <linux/sched.h>
17 #include "sysfs.h"
18
19 extern struct super_block * sysfs_sb;
20
21 static const struct address_space_operations sysfs_aops = {
22         .readpage       = simple_readpage,
23         .prepare_write  = simple_prepare_write,
24         .commit_write   = simple_commit_write
25 };
26
27 static struct backing_dev_info sysfs_backing_dev_info = {
28         .ra_pages       = 0,    /* No readahead */
29         .capabilities   = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
30 };
31
32 static const struct inode_operations sysfs_inode_operations ={
33         .setattr        = sysfs_setattr,
34 };
35
36 void sysfs_delete_inode(struct inode *inode)
37 {
38         /* Free the shadowed directory inode operations */
39         if (sysfs_is_shadowed_inode(inode)) {
40                 kfree(inode->i_op);
41                 inode->i_op = NULL;
42         }
43         return generic_delete_inode(inode);
44 }
45
46 int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
47 {
48         struct inode * inode = dentry->d_inode;
49         struct sysfs_dirent * sd = dentry->d_fsdata;
50         struct iattr * sd_iattr;
51         unsigned int ia_valid = iattr->ia_valid;
52         int error;
53
54         if (!sd)
55                 return -EINVAL;
56
57         sd_iattr = sd->s_iattr;
58
59         error = inode_change_ok(inode, iattr);
60         if (error)
61                 return error;
62
63         error = inode_setattr(inode, iattr);
64         if (error)
65                 return error;
66
67         if (!sd_iattr) {
68                 /* setting attributes for the first time, allocate now */
69                 sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
70                 if (!sd_iattr)
71                         return -ENOMEM;
72                 /* assign default attributes */
73                 sd_iattr->ia_mode = sd->s_mode;
74                 sd_iattr->ia_uid = 0;
75                 sd_iattr->ia_gid = 0;
76                 sd_iattr->ia_atime = sd_iattr->ia_mtime = sd_iattr->ia_ctime = CURRENT_TIME;
77                 sd->s_iattr = sd_iattr;
78         }
79
80         /* attributes were changed atleast once in past */
81
82         if (ia_valid & ATTR_UID)
83                 sd_iattr->ia_uid = iattr->ia_uid;
84         if (ia_valid & ATTR_GID)
85                 sd_iattr->ia_gid = iattr->ia_gid;
86         if (ia_valid & ATTR_ATIME)
87                 sd_iattr->ia_atime = timespec_trunc(iattr->ia_atime,
88                                                 inode->i_sb->s_time_gran);
89         if (ia_valid & ATTR_MTIME)
90                 sd_iattr->ia_mtime = timespec_trunc(iattr->ia_mtime,
91                                                 inode->i_sb->s_time_gran);
92         if (ia_valid & ATTR_CTIME)
93                 sd_iattr->ia_ctime = timespec_trunc(iattr->ia_ctime,
94                                                 inode->i_sb->s_time_gran);
95         if (ia_valid & ATTR_MODE) {
96                 umode_t mode = iattr->ia_mode;
97
98                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
99                         mode &= ~S_ISGID;
100                 sd_iattr->ia_mode = sd->s_mode = mode;
101         }
102
103         return error;
104 }
105
106 static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
107 {
108         inode->i_mode = mode;
109         inode->i_uid = 0;
110         inode->i_gid = 0;
111         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
112 }
113
114 static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
115 {
116         inode->i_mode = iattr->ia_mode;
117         inode->i_uid = iattr->ia_uid;
118         inode->i_gid = iattr->ia_gid;
119         inode->i_atime = iattr->ia_atime;
120         inode->i_mtime = iattr->ia_mtime;
121         inode->i_ctime = iattr->ia_ctime;
122 }
123
124
125 /*
126  * sysfs has a different i_mutex lock order behavior for i_mutex than other
127  * filesystems; sysfs i_mutex is called in many places with subsystem locks
128  * held. At the same time, many of the VFS locking rules do not apply to
129  * sysfs at all (cross directory rename for example). To untangle this mess
130  * (which gives false positives in lockdep), we're giving sysfs inodes their
131  * own class for i_mutex.
132  */
133 static struct lock_class_key sysfs_inode_imutex_key;
134
135 static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
136 {
137         inode->i_blocks = 0;
138         inode->i_mapping->a_ops = &sysfs_aops;
139         inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
140         inode->i_op = &sysfs_inode_operations;
141         inode->i_ino = sd->s_ino;
142         lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);
143
144         if (sd->s_iattr) {
145                 /* sysfs_dirent has non-default attributes
146                  * get them for the new inode from persistent copy
147                  * in sysfs_dirent
148                  */
149                 set_inode_attr(inode, sd->s_iattr);
150         } else
151                 set_default_inode_attr(inode, sd->s_mode);
152 }
153
154 /**
155  *      sysfs_get_inode - get inode for sysfs_dirent
156  *      @sd: sysfs_dirent to allocate inode for
157  *
158  *      Get inode for @sd.  If such inode doesn't exist, a new inode
159  *      is allocated and basics are initialized.  New inode is
160  *      returned locked.
161  *
162  *      LOCKING:
163  *      Kernel thread context (may sleep).
164  *
165  *      RETURNS:
166  *      Pointer to allocated inode on success, NULL on failure.
167  */
168 struct inode * sysfs_get_inode(struct sysfs_dirent *sd)
169 {
170         struct inode *inode;
171
172         inode = iget_locked(sysfs_sb, sd->s_ino);
173         if (inode && (inode->i_state & I_NEW))
174                 sysfs_init_inode(sd, inode);
175
176         return inode;
177 }
178
179 /**
180  *      sysfs_instantiate - instantiate dentry
181  *      @dentry: dentry to be instantiated
182  *      @inode: inode associated with @sd
183  *
184  *      Unlock @inode if locked and instantiate @dentry with @inode.
185  *
186  *      LOCKING:
187  *      None.
188  */
189 void sysfs_instantiate(struct dentry *dentry, struct inode *inode)
190 {
191         BUG_ON(!dentry || dentry->d_inode);
192
193         if (inode->i_state & I_NEW)
194                 unlock_new_inode(inode);
195
196         d_instantiate(dentry, inode);
197 }
198
199 int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const char *name)
200 {
201         struct sysfs_addrm_cxt acxt;
202         struct sysfs_dirent **pos, *sd;
203
204         if (!dir_sd)
205                 return -ENOENT;
206
207         sysfs_addrm_start(&acxt, dir_sd);
208
209         for (pos = &dir_sd->s_children; *pos; pos = &(*pos)->s_sibling) {
210                 sd = *pos;
211
212                 if (!sysfs_type(sd))
213                         continue;
214                 if (!strcmp(sd->s_name, name)) {
215                         *pos = sd->s_sibling;
216                         sd->s_sibling = NULL;
217                         sysfs_remove_one(&acxt, sd);
218                         break;
219                 }
220         }
221
222         if (sysfs_addrm_finish(&acxt))
223                 return 0;
224         return -ENOENT;
225 }