inode.c 7.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * inode.c - basic inode and dentry operations.
 *
 * sysfs is Copyright (c) 2001-3 Patrick Mochel
 *
 * Please see Documentation/filesystems/sysfs.txt for more information.
 */

#undef DEBUG 

#include <linux/pagemap.h>
#include <linux/namei.h>
#include <linux/backing-dev.h>
14
#include <linux/capability.h>
15
#include <linux/errno.h>
16
#include <asm/semaphore.h>
L
Linus Torvalds 已提交
17 18 19 20
#include "sysfs.h"

extern struct super_block * sysfs_sb;

21
static const struct address_space_operations sysfs_aops = {
L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31
	.readpage	= simple_readpage,
	.prepare_write	= simple_prepare_write,
	.commit_write	= simple_commit_write
};

static struct backing_dev_info sysfs_backing_dev_info = {
	.ra_pages	= 0,	/* No readahead */
	.capabilities	= BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
};

32 33 34 35
static struct inode_operations sysfs_inode_operations ={
	.setattr	= sysfs_setattr,
};

36 37 38 39 40 41 42 43 44 45
void sysfs_delete_inode(struct inode *inode)
{
	/* Free the shadowed directory inode operations */
	if (sysfs_is_shadowed_inode(inode)) {
		kfree(inode->i_op);
		inode->i_op = NULL;
	}
	return generic_delete_inode(inode);
}

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
int sysfs_setattr(struct dentry * dentry, struct iattr * iattr)
{
	struct inode * inode = dentry->d_inode;
	struct sysfs_dirent * sd = dentry->d_fsdata;
	struct iattr * sd_iattr;
	unsigned int ia_valid = iattr->ia_valid;
	int error;

	if (!sd)
		return -EINVAL;

	sd_iattr = sd->s_iattr;

	error = inode_change_ok(inode, iattr);
	if (error)
		return error;

	error = inode_setattr(inode, iattr);
	if (error)
		return error;

	if (!sd_iattr) {
		/* setting attributes for the first time, allocate now */
69
		sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
		if (!sd_iattr)
			return -ENOMEM;
		/* assign default attributes */
		sd_iattr->ia_mode = sd->s_mode;
		sd_iattr->ia_uid = 0;
		sd_iattr->ia_gid = 0;
		sd_iattr->ia_atime = sd_iattr->ia_mtime = sd_iattr->ia_ctime = CURRENT_TIME;
		sd->s_iattr = sd_iattr;
	}

	/* attributes were changed atleast once in past */

	if (ia_valid & ATTR_UID)
		sd_iattr->ia_uid = iattr->ia_uid;
	if (ia_valid & ATTR_GID)
		sd_iattr->ia_gid = iattr->ia_gid;
	if (ia_valid & ATTR_ATIME)
		sd_iattr->ia_atime = timespec_trunc(iattr->ia_atime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MTIME)
		sd_iattr->ia_mtime = timespec_trunc(iattr->ia_mtime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_CTIME)
		sd_iattr->ia_ctime = timespec_trunc(iattr->ia_ctime,
						inode->i_sb->s_time_gran);
	if (ia_valid & ATTR_MODE) {
		umode_t mode = iattr->ia_mode;

		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
			mode &= ~S_ISGID;
M
Maneesh Soni 已提交
100
		sd_iattr->ia_mode = sd->s_mode = mode;
101 102 103 104 105
	}

	return error;
}

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
{
	inode->i_mode = mode;
	inode->i_uid = 0;
	inode->i_gid = 0;
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
}

static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
{
	inode->i_mode = iattr->ia_mode;
	inode->i_uid = iattr->ia_uid;
	inode->i_gid = iattr->ia_gid;
	inode->i_atime = iattr->ia_atime;
	inode->i_mtime = iattr->ia_mtime;
	inode->i_ctime = iattr->ia_ctime;
}

124 125 126 127 128 129 130 131 132 133 134

/*
 * sysfs has a different i_mutex lock order behavior for i_mutex than other
 * filesystems; sysfs i_mutex is called in many places with subsystem locks
 * held. At the same time, many of the VFS locking rules do not apply to
 * sysfs at all (cross directory rename for example). To untangle this mess
 * (which gives false positives in lockdep), we're giving sysfs inodes their
 * own class for i_mutex.
 */
static struct lock_class_key sysfs_inode_imutex_key;

135
struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent * sd)
L
Linus Torvalds 已提交
136 137 138 139 140 141
{
	struct inode * inode = new_inode(sysfs_sb);
	if (inode) {
		inode->i_blocks = 0;
		inode->i_mapping->a_ops = &sysfs_aops;
		inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
142
		inode->i_op = &sysfs_inode_operations;
143
		lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);
144 145 146 147 148 149 150 151 152

		if (sd->s_iattr) {
			/* sysfs_dirent has non-default attributes
			 * get them for the new inode from persistent copy
			 * in sysfs_dirent
			 */
			set_inode_attr(inode, sd->s_iattr);
		} else
			set_default_inode_attr(inode, mode);
L
Linus Torvalds 已提交
153 154 155 156 157 158 159 160 161 162
	}
	return inode;
}

int sysfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
{
	int error = 0;
	struct inode * inode = NULL;
	if (dentry) {
		if (!dentry->d_inode) {
163 164
			struct sysfs_dirent * sd = dentry->d_fsdata;
			if ((inode = sysfs_new_inode(mode, sd))) {
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
				if (dentry->d_parent && dentry->d_parent->d_inode) {
					struct inode *p_inode = dentry->d_parent->d_inode;
					p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
				}
				goto Proceed;
			}
			else 
				error = -ENOMEM;
		} else
			error = -EEXIST;
	} else 
		error = -ENOENT;
	goto Done;

 Proceed:
	if (init)
		error = init(inode);
	if (!error) {
		d_instantiate(dentry, inode);
		if (S_ISDIR(mode))
			dget(dentry);  /* pin only directory dentry in core */
	} else
		iput(inode);
 Done:
	return error;
}

/*
 * Get the name for corresponding element represented by the given sysfs_dirent
 */
const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
{
	struct attribute * attr;
	struct bin_attribute * bin_attr;
	struct sysfs_symlink  * sl;

201
	BUG_ON(!sd || !sd->s_element);
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222

	switch (sd->s_type) {
		case SYSFS_DIR:
			/* Always have a dentry so use that */
			return sd->s_dentry->d_name.name;

		case SYSFS_KOBJ_ATTR:
			attr = sd->s_element;
			return attr->name;

		case SYSFS_KOBJ_BIN_ATTR:
			bin_attr = sd->s_element;
			return bin_attr->attr.name;

		case SYSFS_KOBJ_LINK:
			sl = sd->s_element;
			return sl->link_name;
	}
	return NULL;
}

223 224 225 226 227
static inline void orphan_all_buffers(struct inode *node)
{
	struct sysfs_buffer_collection *set = node->i_private;
	struct sysfs_buffer *buf;

228
	mutex_lock_nested(&node->i_mutex, I_MUTEX_CHILD);
229 230 231 232 233 234 235 236 237 238
	if (node->i_private) {
		list_for_each_entry(buf, &set->associates, associates) {
			down(&buf->sem);
			buf->orphaned = 1;
			up(&buf->sem);
		}
	}
	mutex_unlock(&node->i_mutex);
}

L
Linus Torvalds 已提交
239 240 241

/*
 * Unhashes the dentry corresponding to given sysfs_dirent
242
 * Called with parent inode's i_mutex held.
L
Linus Torvalds 已提交
243 244 245 246
 */
void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
{
	struct dentry * dentry = sd->s_dentry;
247
	struct inode *inode;
L
Linus Torvalds 已提交
248 249 250 251 252

	if (dentry) {
		spin_lock(&dcache_lock);
		spin_lock(&dentry->d_lock);
		if (!(d_unhashed(dentry) && dentry->d_inode)) {
253 254 255 256
			inode = dentry->d_inode;
			spin_lock(&inode->i_lock);
			__iget(inode);
			spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
257 258 259 260 261
			dget_locked(dentry);
			__d_drop(dentry);
			spin_unlock(&dentry->d_lock);
			spin_unlock(&dcache_lock);
			simple_unlink(parent->d_inode, dentry);
262 263
			orphan_all_buffers(inode);
			iput(inode);
L
Linus Torvalds 已提交
264 265 266 267 268 269 270
		} else {
			spin_unlock(&dentry->d_lock);
			spin_unlock(&dcache_lock);
		}
	}
}

271
int sysfs_hash_and_remove(struct dentry * dir, const char * name)
L
Linus Torvalds 已提交
272 273
{
	struct sysfs_dirent * sd;
274
	struct sysfs_dirent * parent_sd;
275
	int found = 0;
276 277

	if (!dir)
278
		return -ENOENT;
L
Linus Torvalds 已提交
279

280 281
	if (dir->d_inode == NULL)
		/* no inode means this hasn't been made visible yet */
282
		return -ENOENT;
283

284
	parent_sd = dir->d_fsdata;
285
	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
L
Linus Torvalds 已提交
286 287 288 289 290 291 292
	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
		if (!sd->s_element)
			continue;
		if (!strcmp(sysfs_get_name(sd), name)) {
			list_del_init(&sd->s_sibling);
			sysfs_drop_dentry(sd, dir);
			sysfs_put(sd);
293
			found = 1;
L
Linus Torvalds 已提交
294 295 296
			break;
		}
	}
297
	mutex_unlock(&dir->d_inode->i_mutex);
298 299

	return found ? 0 : -ENOENT;
L
Linus Torvalds 已提交
300
}