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.rst 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 user_namespace *mnt_userns, struct dentry *dentry, 44 struct iattr *iattr) 45 { 46 struct inode * inode = d_inode(dentry); 47 struct configfs_dirent * sd = dentry->d_fsdata; 48 struct iattr * sd_iattr; 49 unsigned int ia_valid = iattr->ia_valid; 50 int error; 51 52 if (!sd) 53 return -EINVAL; 54 55 sd_iattr = sd->s_iattr; 56 if (!sd_iattr) { 57 /* setting attributes for the first time, allocate now */ 58 sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL); 59 if (!sd_iattr) 60 return -ENOMEM; 61 /* assign default attributes */ 62 sd_iattr->ia_mode = sd->s_mode; 63 sd_iattr->ia_uid = GLOBAL_ROOT_UID; 64 sd_iattr->ia_gid = GLOBAL_ROOT_GID; 65 sd_iattr->ia_atime = sd_iattr->ia_mtime = 66 sd_iattr->ia_ctime = current_time(inode); 67 sd->s_iattr = sd_iattr; 68 } 69 /* attributes were changed atleast once in past */ 70 71 error = simple_setattr(mnt_userns, dentry, iattr); 72 if (error) 73 return error; 74 75 if (ia_valid & ATTR_UID) 76 sd_iattr->ia_uid = iattr->ia_uid; 77 if (ia_valid & ATTR_GID) 78 sd_iattr->ia_gid = iattr->ia_gid; 79 if (ia_valid & ATTR_ATIME) 80 sd_iattr->ia_atime = iattr->ia_atime; 81 if (ia_valid & ATTR_MTIME) 82 sd_iattr->ia_mtime = iattr->ia_mtime; 83 if (ia_valid & ATTR_CTIME) 84 sd_iattr->ia_ctime = iattr->ia_ctime; 85 if (ia_valid & ATTR_MODE) { 86 umode_t mode = iattr->ia_mode; 87 88 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 89 mode &= ~S_ISGID; 90 sd_iattr->ia_mode = sd->s_mode = mode; 91 } 92 93 return error; 94 } 95 96 static inline void set_default_inode_attr(struct inode * inode, umode_t mode) 97 { 98 inode->i_mode = mode; 99 inode->i_atime = inode->i_mtime = 100 inode->i_ctime = current_time(inode); 101 } 102 103 static inline void set_inode_attr(struct inode * inode, struct iattr * iattr) 104 { 105 inode->i_mode = iattr->ia_mode; 106 inode->i_uid = iattr->ia_uid; 107 inode->i_gid = iattr->ia_gid; 108 inode->i_atime = iattr->ia_atime; 109 inode->i_mtime = iattr->ia_mtime; 110 inode->i_ctime = iattr->ia_ctime; 111 } 112 113 struct inode *configfs_new_inode(umode_t mode, struct configfs_dirent *sd, 114 struct super_block *s) 115 { 116 struct inode * inode = new_inode(s); 117 if (inode) { 118 inode->i_ino = get_next_ino(); 119 inode->i_mapping->a_ops = &configfs_aops; 120 inode->i_op = &configfs_inode_operations; 121 122 if (sd->s_iattr) { 123 /* sysfs_dirent has non-default attributes 124 * get them for the new inode from persistent copy 125 * in sysfs_dirent 126 */ 127 set_inode_attr(inode, sd->s_iattr); 128 } else 129 set_default_inode_attr(inode, mode); 130 } 131 return inode; 132 } 133 134 #ifdef CONFIG_LOCKDEP 135 136 static void configfs_set_inode_lock_class(struct configfs_dirent *sd, 137 struct inode *inode) 138 { 139 int depth = sd->s_depth; 140 141 if (depth > 0) { 142 if (depth <= ARRAY_SIZE(default_group_class)) { 143 lockdep_set_class(&inode->i_rwsem, 144 &default_group_class[depth - 1]); 145 } else { 146 /* 147 * In practice the maximum level of locking depth is 148 * already reached. Just inform about possible reasons. 149 */ 150 pr_info("Too many levels of inodes for the locking correctness validator.\n"); 151 pr_info("Spurious warnings may appear.\n"); 152 } 153 } 154 } 155 156 #else /* CONFIG_LOCKDEP */ 157 158 static void configfs_set_inode_lock_class(struct configfs_dirent *sd, 159 struct inode *inode) 160 { 161 } 162 163 #endif /* CONFIG_LOCKDEP */ 164 165 struct inode *configfs_create(struct dentry *dentry, umode_t mode) 166 { 167 struct inode *inode = NULL; 168 struct configfs_dirent *sd; 169 struct inode *p_inode; 170 171 if (!dentry) 172 return ERR_PTR(-ENOENT); 173 174 if (d_really_is_positive(dentry)) 175 return ERR_PTR(-EEXIST); 176 177 sd = dentry->d_fsdata; 178 inode = configfs_new_inode(mode, sd, dentry->d_sb); 179 if (!inode) 180 return ERR_PTR(-ENOMEM); 181 182 p_inode = d_inode(dentry->d_parent); 183 p_inode->i_mtime = p_inode->i_ctime = current_time(p_inode); 184 configfs_set_inode_lock_class(sd, inode); 185 return inode; 186 } 187 188 /* 189 * Get the name for corresponding element represented by the given configfs_dirent 190 */ 191 const unsigned char * configfs_get_name(struct configfs_dirent *sd) 192 { 193 struct configfs_attribute *attr; 194 195 BUG_ON(!sd || !sd->s_element); 196 197 /* These always have a dentry, so use that */ 198 if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK)) 199 return sd->s_dentry->d_name.name; 200 201 if (sd->s_type & (CONFIGFS_ITEM_ATTR | CONFIGFS_ITEM_BIN_ATTR)) { 202 attr = sd->s_element; 203 return attr->ca_name; 204 } 205 return NULL; 206 } 207 208 209 /* 210 * Unhashes the dentry corresponding to given configfs_dirent 211 * Called with parent inode's i_mutex held. 212 */ 213 void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) 214 { 215 struct dentry * dentry = sd->s_dentry; 216 217 if (dentry) { 218 spin_lock(&dentry->d_lock); 219 if (simple_positive(dentry)) { 220 dget_dlock(dentry); 221 __d_drop(dentry); 222 spin_unlock(&dentry->d_lock); 223 simple_unlink(d_inode(parent), dentry); 224 } else 225 spin_unlock(&dentry->d_lock); 226 } 227 } 228 229 void configfs_hash_and_remove(struct dentry * dir, const char * name) 230 { 231 struct configfs_dirent * sd; 232 struct configfs_dirent * parent_sd = dir->d_fsdata; 233 234 if (d_really_is_negative(dir)) 235 /* no inode means this hasn't been made visible yet */ 236 return; 237 238 inode_lock(d_inode(dir)); 239 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 240 if (!sd->s_element) 241 continue; 242 if (!strcmp(configfs_get_name(sd), name)) { 243 spin_lock(&configfs_dirent_lock); 244 list_del_init(&sd->s_sibling); 245 spin_unlock(&configfs_dirent_lock); 246 configfs_drop_dentry(sd, dir); 247 configfs_put(sd); 248 break; 249 } 250 } 251 inode_unlock(d_inode(dir)); 252 } 253