1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * inode.c - basic inode and dentry operations. |
4 | * |
5 | * Based on sysfs: |
6 | * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel |
7 | * |
8 | * configfs Copyright (C) 2005 Oracle. All rights reserved. |
9 | * |
10 | * Please see Documentation/filesystems/configfs.rst for more |
11 | * information. |
12 | */ |
13 | |
14 | #undef DEBUG |
15 | |
16 | #include <linux/pagemap.h> |
17 | #include <linux/namei.h> |
18 | #include <linux/backing-dev.h> |
19 | #include <linux/capability.h> |
20 | #include <linux/sched.h> |
21 | #include <linux/lockdep.h> |
22 | #include <linux/slab.h> |
23 | |
24 | #include <linux/configfs.h> |
25 | #include "configfs_internal.h" |
26 | |
27 | #ifdef CONFIG_LOCKDEP |
28 | static struct lock_class_key default_group_class[MAX_LOCK_DEPTH]; |
29 | #endif |
30 | |
31 | static const struct inode_operations configfs_inode_operations ={ |
32 | .setattr = configfs_setattr, |
33 | }; |
34 | |
35 | int configfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, |
36 | struct iattr *iattr) |
37 | { |
38 | struct inode * inode = d_inode(dentry); |
39 | struct configfs_dirent * sd = dentry->d_fsdata; |
40 | struct iattr * sd_iattr; |
41 | unsigned int ia_valid = iattr->ia_valid; |
42 | int error; |
43 | |
44 | if (!sd) |
45 | return -EINVAL; |
46 | |
47 | sd_iattr = sd->s_iattr; |
48 | if (!sd_iattr) { |
49 | /* setting attributes for the first time, allocate now */ |
50 | sd_iattr = kzalloc(size: sizeof(struct iattr), GFP_KERNEL); |
51 | if (!sd_iattr) |
52 | return -ENOMEM; |
53 | /* assign default attributes */ |
54 | sd_iattr->ia_mode = sd->s_mode; |
55 | sd_iattr->ia_uid = GLOBAL_ROOT_UID; |
56 | sd_iattr->ia_gid = GLOBAL_ROOT_GID; |
57 | sd_iattr->ia_atime = sd_iattr->ia_mtime = |
58 | sd_iattr->ia_ctime = current_time(inode); |
59 | sd->s_iattr = sd_iattr; |
60 | } |
61 | /* attributes were changed atleast once in past */ |
62 | |
63 | error = simple_setattr(idmap, dentry, iattr); |
64 | if (error) |
65 | return error; |
66 | |
67 | if (ia_valid & ATTR_UID) |
68 | sd_iattr->ia_uid = iattr->ia_uid; |
69 | if (ia_valid & ATTR_GID) |
70 | sd_iattr->ia_gid = iattr->ia_gid; |
71 | if (ia_valid & ATTR_ATIME) |
72 | sd_iattr->ia_atime = iattr->ia_atime; |
73 | if (ia_valid & ATTR_MTIME) |
74 | sd_iattr->ia_mtime = iattr->ia_mtime; |
75 | if (ia_valid & ATTR_CTIME) |
76 | sd_iattr->ia_ctime = iattr->ia_ctime; |
77 | if (ia_valid & ATTR_MODE) { |
78 | umode_t mode = iattr->ia_mode; |
79 | |
80 | if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) |
81 | mode &= ~S_ISGID; |
82 | sd_iattr->ia_mode = sd->s_mode = mode; |
83 | } |
84 | |
85 | return error; |
86 | } |
87 | |
88 | static inline void set_default_inode_attr(struct inode * inode, umode_t mode) |
89 | { |
90 | inode->i_mode = mode; |
91 | simple_inode_init_ts(inode); |
92 | } |
93 | |
94 | static inline void set_inode_attr(struct inode * inode, struct iattr * iattr) |
95 | { |
96 | inode->i_mode = iattr->ia_mode; |
97 | inode->i_uid = iattr->ia_uid; |
98 | inode->i_gid = iattr->ia_gid; |
99 | inode_set_atime_to_ts(inode, ts: iattr->ia_atime); |
100 | inode_set_mtime_to_ts(inode, ts: iattr->ia_mtime); |
101 | inode_set_ctime_to_ts(inode, ts: iattr->ia_ctime); |
102 | } |
103 | |
104 | struct inode *configfs_new_inode(umode_t mode, struct configfs_dirent *sd, |
105 | struct super_block *s) |
106 | { |
107 | struct inode * inode = new_inode(sb: s); |
108 | if (inode) { |
109 | inode->i_ino = get_next_ino(); |
110 | inode->i_mapping->a_ops = &ram_aops; |
111 | inode->i_op = &configfs_inode_operations; |
112 | |
113 | if (sd->s_iattr) { |
114 | /* sysfs_dirent has non-default attributes |
115 | * get them for the new inode from persistent copy |
116 | * in sysfs_dirent |
117 | */ |
118 | set_inode_attr(inode, iattr: sd->s_iattr); |
119 | } else |
120 | set_default_inode_attr(inode, mode); |
121 | } |
122 | return inode; |
123 | } |
124 | |
125 | #ifdef CONFIG_LOCKDEP |
126 | |
127 | static void configfs_set_inode_lock_class(struct configfs_dirent *sd, |
128 | struct inode *inode) |
129 | { |
130 | int depth = sd->s_depth; |
131 | |
132 | if (depth > 0) { |
133 | if (depth <= ARRAY_SIZE(default_group_class)) { |
134 | lockdep_set_class(&inode->i_rwsem, |
135 | &default_group_class[depth - 1]); |
136 | } else { |
137 | /* |
138 | * In practice the maximum level of locking depth is |
139 | * already reached. Just inform about possible reasons. |
140 | */ |
141 | pr_info("Too many levels of inodes for the locking correctness validator.\n" ); |
142 | pr_info("Spurious warnings may appear.\n" ); |
143 | } |
144 | } |
145 | } |
146 | |
147 | #else /* CONFIG_LOCKDEP */ |
148 | |
149 | static void configfs_set_inode_lock_class(struct configfs_dirent *sd, |
150 | struct inode *inode) |
151 | { |
152 | } |
153 | |
154 | #endif /* CONFIG_LOCKDEP */ |
155 | |
156 | struct inode *configfs_create(struct dentry *dentry, umode_t mode) |
157 | { |
158 | struct inode *inode = NULL; |
159 | struct configfs_dirent *sd; |
160 | struct inode *p_inode; |
161 | |
162 | if (!dentry) |
163 | return ERR_PTR(error: -ENOENT); |
164 | |
165 | if (d_really_is_positive(dentry)) |
166 | return ERR_PTR(error: -EEXIST); |
167 | |
168 | sd = dentry->d_fsdata; |
169 | inode = configfs_new_inode(mode, sd, s: dentry->d_sb); |
170 | if (!inode) |
171 | return ERR_PTR(error: -ENOMEM); |
172 | |
173 | p_inode = d_inode(dentry: dentry->d_parent); |
174 | inode_set_mtime_to_ts(inode: p_inode, ts: inode_set_ctime_current(inode: p_inode)); |
175 | configfs_set_inode_lock_class(sd, inode); |
176 | return inode; |
177 | } |
178 | |
179 | /* |
180 | * Get the name for corresponding element represented by the given configfs_dirent |
181 | */ |
182 | const unsigned char * configfs_get_name(struct configfs_dirent *sd) |
183 | { |
184 | struct configfs_attribute *attr; |
185 | |
186 | BUG_ON(!sd || !sd->s_element); |
187 | |
188 | /* These always have a dentry, so use that */ |
189 | if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK)) |
190 | return sd->s_dentry->d_name.name; |
191 | |
192 | if (sd->s_type & (CONFIGFS_ITEM_ATTR | CONFIGFS_ITEM_BIN_ATTR)) { |
193 | attr = sd->s_element; |
194 | return attr->ca_name; |
195 | } |
196 | return NULL; |
197 | } |
198 | |
199 | |
200 | /* |
201 | * Unhashes the dentry corresponding to given configfs_dirent |
202 | * Called with parent inode's i_mutex held. |
203 | */ |
204 | void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) |
205 | { |
206 | struct dentry * dentry = sd->s_dentry; |
207 | |
208 | if (dentry) { |
209 | spin_lock(lock: &dentry->d_lock); |
210 | if (simple_positive(dentry)) { |
211 | dget_dlock(dentry); |
212 | __d_drop(dentry); |
213 | spin_unlock(lock: &dentry->d_lock); |
214 | simple_unlink(d_inode(dentry: parent), dentry); |
215 | } else |
216 | spin_unlock(lock: &dentry->d_lock); |
217 | } |
218 | } |
219 | |
220 | void configfs_hash_and_remove(struct dentry * dir, const char * name) |
221 | { |
222 | struct configfs_dirent * sd; |
223 | struct configfs_dirent * parent_sd = dir->d_fsdata; |
224 | |
225 | if (d_really_is_negative(dentry: dir)) |
226 | /* no inode means this hasn't been made visible yet */ |
227 | return; |
228 | |
229 | inode_lock(inode: d_inode(dentry: dir)); |
230 | list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { |
231 | if (!sd->s_element) |
232 | continue; |
233 | if (!strcmp(configfs_get_name(sd), name)) { |
234 | spin_lock(lock: &configfs_dirent_lock); |
235 | list_del_init(entry: &sd->s_sibling); |
236 | spin_unlock(lock: &configfs_dirent_lock); |
237 | configfs_drop_dentry(sd, parent: dir); |
238 | configfs_put(sd); |
239 | break; |
240 | } |
241 | } |
242 | inode_unlock(inode: d_inode(dentry: dir)); |
243 | } |
244 | |