inode.c 8.35 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
Tejun Heo's avatar
Tejun Heo committed
2
 * fs/sysfs/inode.c - basic sysfs inode and dentry operations
Linus Torvalds's avatar
Linus Torvalds committed
3
 *
Tejun Heo's avatar
Tejun Heo committed
4 5 6 7 8
 * Copyright (c) 2001-3 Patrick Mochel
 * Copyright (c) 2007 SUSE Linux Products GmbH
 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
 *
 * This file is released under the GPLv2.
Linus Torvalds's avatar
Linus Torvalds committed
9 10 11 12 13 14 15 16 17
 *
 * Please see Documentation/filesystems/sysfs.txt for more information.
 */

#undef DEBUG 

#include <linux/pagemap.h>
#include <linux/namei.h>
#include <linux/backing-dev.h>
18
#include <linux/capability.h>
19
#include <linux/errno.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
20
#include <linux/sched.h>
21
#include <linux/slab.h>
22 23
#include <linux/xattr.h>
#include <linux/security.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26 27
#include "sysfs.h"

extern struct super_block * sysfs_sb;

28
static const struct address_space_operations sysfs_aops = {
Linus Torvalds's avatar
Linus Torvalds committed
29
	.readpage	= simple_readpage,
Nick Piggin's avatar
Nick Piggin committed
30 31
	.write_begin	= simple_write_begin,
	.write_end	= simple_write_end,
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34
};

static struct backing_dev_info sysfs_backing_dev_info = {
35
	.name		= "sysfs",
Linus Torvalds's avatar
Linus Torvalds committed
36
	.ra_pages	= 0,	/* No readahead */
37
	.capabilities	= BDI_CAP_NO_ACCT_AND_WRITEBACK,
Linus Torvalds's avatar
Linus Torvalds committed
38 39
};

40
static const struct inode_operations sysfs_inode_operations ={
41
	.permission	= sysfs_permission,
42
	.setattr	= sysfs_setattr,
43
	.getattr	= sysfs_getattr,
44
	.setxattr	= sysfs_setxattr,
45 46
};

Peter Zijlstra's avatar
Peter Zijlstra committed
47 48 49 50 51
int __init sysfs_inode_init(void)
{
	return bdi_init(&sysfs_backing_dev_info);
}

52
static struct sysfs_inode_attrs *sysfs_init_inode_attrs(struct sysfs_dirent *sd)
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
{
	struct sysfs_inode_attrs *attrs;
	struct iattr *iattrs;

	attrs = kzalloc(sizeof(struct sysfs_inode_attrs), GFP_KERNEL);
	if (!attrs)
		return NULL;
	iattrs = &attrs->ia_iattr;

	/* assign default attributes */
	iattrs->ia_mode = sd->s_mode;
	iattrs->ia_uid = 0;
	iattrs->ia_gid = 0;
	iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME;

	return attrs;
}
70

71
int sysfs_sd_setattr(struct sysfs_dirent *sd, struct iattr * iattr)
72
{
73 74
	struct sysfs_inode_attrs *sd_attrs;
	struct iattr *iattrs;
75 76
	unsigned int ia_valid = iattr->ia_valid;

77
	sd_attrs = sd->s_iattr;
78

79
	if (!sd_attrs) {
80
		/* setting attributes for the first time, allocate now */
81 82
		sd_attrs = sysfs_init_inode_attrs(sd);
		if (!sd_attrs)
83
			return -ENOMEM;
84
		sd->s_iattr = sd_attrs;
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
	}
	/* attributes were changed at least once in past */
	iattrs = &sd_attrs->ia_iattr;

	if (ia_valid & ATTR_UID)
		iattrs->ia_uid = iattr->ia_uid;
	if (ia_valid & ATTR_GID)
		iattrs->ia_gid = iattr->ia_gid;
	if (ia_valid & ATTR_ATIME)
		iattrs->ia_atime = iattr->ia_atime;
	if (ia_valid & ATTR_MTIME)
		iattrs->ia_mtime = iattr->ia_mtime;
	if (ia_valid & ATTR_CTIME)
		iattrs->ia_ctime = iattr->ia_ctime;
	if (ia_valid & ATTR_MODE) {
		umode_t mode = iattr->ia_mode;
		iattrs->ia_mode = sd->s_mode = mode;
102
	}
103 104 105 106 107 108 109 110 111 112 113 114
	return 0;
}

int sysfs_setattr(struct dentry *dentry, struct iattr *iattr)
{
	struct inode *inode = dentry->d_inode;
	struct sysfs_dirent *sd = dentry->d_fsdata;
	int error;

	if (!sd)
		return -EINVAL;

115
	mutex_lock(&sysfs_mutex);
116 117
	error = inode_change_ok(inode, iattr);
	if (error)
118
		goto out;
119

120 121 122 123
	error = sysfs_sd_setattr(sd, iattr);
	if (error)
		goto out;

124
	/* this ignores size changes */
Christoph Hellwig's avatar
Christoph Hellwig committed
125
	setattr_copy(inode, iattr);
126

127
out:
128
	mutex_unlock(&sysfs_mutex);
129 130
	return error;
}
131

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
static int sysfs_sd_setsecdata(struct sysfs_dirent *sd, void **secdata, u32 *secdata_len)
{
	struct sysfs_inode_attrs *iattrs;
	void *old_secdata;
	size_t old_secdata_len;

	iattrs = sd->s_iattr;
	if (!iattrs)
		iattrs = sysfs_init_inode_attrs(sd);
	if (!iattrs)
		return -ENOMEM;

	old_secdata = iattrs->ia_secdata;
	old_secdata_len = iattrs->ia_secdata_len;

	iattrs->ia_secdata = *secdata;
	iattrs->ia_secdata_len = *secdata_len;

	*secdata = old_secdata;
	*secdata_len = old_secdata_len;
	return 0;
}

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
		size_t size, int flags)
{
	struct sysfs_dirent *sd = dentry->d_fsdata;
	void *secdata;
	int error;
	u32 secdata_len = 0;

	if (!sd)
		return -EINVAL;

	if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) {
		const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
		error = security_inode_setsecurity(dentry->d_inode, suffix,
						value, size, flags);
		if (error)
			goto out;
		error = security_inode_getsecctx(dentry->d_inode,
						&secdata, &secdata_len);
		if (error)
			goto out;
176

177 178 179 180 181 182
		mutex_lock(&sysfs_mutex);
		error = sysfs_sd_setsecdata(sd, &secdata, &secdata_len);
		mutex_unlock(&sysfs_mutex);

		if (secdata)
			security_release_secctx(secdata, secdata_len);
183 184 185
	} else
		return -EINVAL;
out:
186 187 188
	return error;
}

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
{
	inode->i_mode = mode;
	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_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;
}

204 205 206 207 208
static int sysfs_count_nlink(struct sysfs_dirent *sd)
{
	struct sysfs_dirent *child;
	int nr = 0;

209
	for (child = sd->s_dir.children; child; child = child->s_sibling)
210 211 212 213 214 215
		if (sysfs_type(child) == SYSFS_DIR)
			nr++;

	return nr + 2;
}

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
static void sysfs_refresh_inode(struct sysfs_dirent *sd, struct inode *inode)
{
	struct sysfs_inode_attrs *iattrs = sd->s_iattr;

	inode->i_mode = sd->s_mode;
	if (iattrs) {
		/* sysfs_dirent has non-default attributes
		 * get them from persistent copy in sysfs_dirent
		 */
		set_inode_attr(inode, &iattrs->ia_iattr);
		security_inode_notifysecctx(inode,
					    iattrs->ia_secdata,
					    iattrs->ia_secdata_len);
	}

	if (sysfs_type(sd) == SYSFS_DIR)
		inode->i_nlink = sysfs_count_nlink(sd);
}

int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct sysfs_dirent *sd = dentry->d_fsdata;
	struct inode *inode = dentry->d_inode;

	mutex_lock(&sysfs_mutex);
	sysfs_refresh_inode(sd, inode);
	mutex_unlock(&sysfs_mutex);

	generic_fillattr(inode, stat);
	return 0;
}

248
static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
249
{
250 251
	struct bin_attribute *bin_attr;

252
	inode->i_private = sysfs_get(sd);
253 254 255 256
	inode->i_mapping->a_ops = &sysfs_aops;
	inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
	inode->i_op = &sysfs_inode_operations;

257 258
	set_default_inode_attr(inode, sd->s_mode);
	sysfs_refresh_inode(sd, inode);
259 260 261 262 263 264 265 266 267 268 269 270

	/* initialize inode according to type */
	switch (sysfs_type(sd)) {
	case SYSFS_DIR:
		inode->i_op = &sysfs_dir_inode_operations;
		inode->i_fop = &sysfs_dir_operations;
		break;
	case SYSFS_KOBJ_ATTR:
		inode->i_size = PAGE_SIZE;
		inode->i_fop = &sysfs_file_operations;
		break;
	case SYSFS_KOBJ_BIN_ATTR:
271
		bin_attr = sd->s_bin_attr.bin_attr;
272 273 274 275 276 277 278 279 280 281 282
		inode->i_size = bin_attr->size;
		inode->i_fop = &bin_fops;
		break;
	case SYSFS_KOBJ_LINK:
		inode->i_op = &sysfs_symlink_inode_operations;
		break;
	default:
		BUG();
	}

	unlock_new_inode(inode);
283 284 285
}

/**
286
 *	sysfs_get_inode - get inode for sysfs_dirent
287
 *	@sb: super block
288 289
 *	@sd: sysfs_dirent to allocate inode for
 *
290 291 292
 *	Get inode for @sd.  If such inode doesn't exist, a new inode
 *	is allocated and basics are initialized.  New inode is
 *	returned locked.
293 294 295 296 297 298 299
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	Pointer to allocated inode on success, NULL on failure.
 */
300
struct inode * sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd)
301 302 303
{
	struct inode *inode;

304
	inode = iget_locked(sb, sd->s_ino);
305
	if (inode && (inode->i_state & I_NEW))
306 307
		sysfs_init_inode(sd, inode);

Linus Torvalds's avatar
Linus Torvalds committed
308 309 310
	return inode;
}

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
/*
 * The sysfs_dirent serves as both an inode and a directory entry for sysfs.
 * To prevent the sysfs inode numbers from being freed prematurely we take a
 * reference to sysfs_dirent from the sysfs inode.  A
 * super_operations.delete_inode() implementation is needed to drop that
 * reference upon inode destruction.
 */
void sysfs_delete_inode(struct inode *inode)
{
	struct sysfs_dirent *sd  = inode->i_private;

	truncate_inode_pages(&inode->i_data, 0);
	clear_inode(inode);
	sysfs_put(sd);
}

327
int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const void *ns, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
328
{
329
	struct sysfs_addrm_cxt acxt;
330
	struct sysfs_dirent *sd;
331

332
	if (!dir_sd)
333
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
334

335
	sysfs_addrm_start(&acxt, dir_sd);
336

337
	sd = sysfs_find_dirent(dir_sd, ns, name);
338 339
	if (sd && (sd->s_ns != ns))
		sd = NULL;
340 341
	if (sd)
		sysfs_remove_one(&acxt, sd);
342

343 344 345
	sysfs_addrm_finish(&acxt);

	if (sd)
346
		return 0;
347 348
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
349
}
350 351 352 353 354 355 356 357 358 359 360

int sysfs_permission(struct inode *inode, int mask)
{
	struct sysfs_dirent *sd = inode->i_private;

	mutex_lock(&sysfs_mutex);
	sysfs_refresh_inode(sd, inode);
	mutex_unlock(&sysfs_mutex);

	return generic_permission(inode, mask, NULL);
}