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 = timestamp_truncate(iattr->ia_atime, 80 inode); 81 if (ia_valid & ATTR_MTIME) 82 sd_iattr->ia_mtime = timestamp_truncate(iattr->ia_mtime, 83 inode); 84 if (ia_valid & ATTR_CTIME) 85 sd_iattr->ia_ctime = timestamp_truncate(iattr->ia_ctime, 86 inode); 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 struct inode *configfs_create(struct dentry *dentry, umode_t mode) 168 { 169 struct inode *inode = NULL; 170 struct configfs_dirent *sd; 171 struct inode *p_inode; 172 173 if (!dentry) 174 return ERR_PTR(-ENOENT); 175 176 if (d_really_is_positive(dentry)) 177 return ERR_PTR(-EEXIST); 178 179 sd = dentry->d_fsdata; 180 inode = configfs_new_inode(mode, sd, dentry->d_sb); 181 if (!inode) 182 return ERR_PTR(-ENOMEM); 183 184 p_inode = d_inode(dentry->d_parent); 185 p_inode->i_mtime = p_inode->i_ctime = current_time(p_inode); 186 configfs_set_inode_lock_class(sd, inode); 187 return inode; 188 } 189 190 /* 191 * Get the name for corresponding element represented by the given configfs_dirent 192 */ 193 const unsigned char * configfs_get_name(struct configfs_dirent *sd) 194 { 195 struct configfs_attribute *attr; 196 197 BUG_ON(!sd || !sd->s_element); 198 199 /* These always have a dentry, so use that */ 200 if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK)) 201 return sd->s_dentry->d_name.name; 202 203 if (sd->s_type & (CONFIGFS_ITEM_ATTR | CONFIGFS_ITEM_BIN_ATTR)) { 204 attr = sd->s_element; 205 return attr->ca_name; 206 } 207 return NULL; 208 } 209 210 211 /* 212 * Unhashes the dentry corresponding to given configfs_dirent 213 * Called with parent inode's i_mutex held. 214 */ 215 void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) 216 { 217 struct dentry * dentry = sd->s_dentry; 218 219 if (dentry) { 220 spin_lock(&dentry->d_lock); 221 if (simple_positive(dentry)) { 222 dget_dlock(dentry); 223 __d_drop(dentry); 224 spin_unlock(&dentry->d_lock); 225 simple_unlink(d_inode(parent), dentry); 226 } else 227 spin_unlock(&dentry->d_lock); 228 } 229 } 230 231 void configfs_hash_and_remove(struct dentry * dir, const char * name) 232 { 233 struct configfs_dirent * sd; 234 struct configfs_dirent * parent_sd = dir->d_fsdata; 235 236 if (d_really_is_negative(dir)) 237 /* no inode means this hasn't been made visible yet */ 238 return; 239 240 inode_lock(d_inode(dir)); 241 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 242 if (!sd->s_element) 243 continue; 244 if (!strcmp(configfs_get_name(sd), name)) { 245 spin_lock(&configfs_dirent_lock); 246 list_del_init(&sd->s_sibling); 247 spin_unlock(&configfs_dirent_lock); 248 configfs_drop_dentry(sd, dir); 249 configfs_put(sd); 250 break; 251 } 252 } 253 inode_unlock(d_inode(dir)); 254 } 255