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