inode.c 6.85 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * inode.c - basic inode and dentry operations.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 *
 * Based on sysfs:
 * 	sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
 *
 * configfs Copyright (C) 2005 Oracle.  All rights reserved.
 *
 * Please see Documentation/filesystems/configfs.txt for more information.
 */

#undef DEBUG

#include <linux/pagemap.h>
#include <linux/namei.h>
#include <linux/backing-dev.h>
34
#include <linux/capability.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
35
#include <linux/sched.h>
36 37 38 39 40 41

#include <linux/configfs.h>
#include "configfs_internal.h"

extern struct super_block * configfs_sb;

42
static const struct address_space_operations configfs_aops = {
43
	.readpage	= simple_readpage,
Nick Piggin's avatar
Nick Piggin committed
44 45
	.write_begin	= simple_write_begin,
	.write_end	= simple_write_end,
46 47 48 49
};

static struct backing_dev_info configfs_backing_dev_info = {
	.ra_pages	= 0,	/* No readahead */
50
	.capabilities	= BDI_CAP_NO_ACCT_AND_WRITEBACK,
51 52
};

53
static const struct inode_operations configfs_inode_operations ={
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
	.setattr	= configfs_setattr,
};

int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
{
	struct inode * inode = dentry->d_inode;
	struct configfs_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 */
80
		sd_iattr = kzalloc(sizeof(struct iattr), GFP_KERNEL);
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
		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;
		sd_iattr->ia_mode = sd->s_mode = mode;
	}

	return error;
}

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_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;
}

struct inode * configfs_new_inode(mode_t mode, struct configfs_dirent * sd)
134 135 136 137 138
{
	struct inode * inode = new_inode(configfs_sb);
	if (inode) {
		inode->i_mapping->a_ops = &configfs_aops;
		inode->i_mapping->backing_dev_info = &configfs_backing_dev_info;
139 140 141 142 143 144 145 146 147 148
		inode->i_op = &configfs_inode_operations;

		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);
149 150 151 152 153 154 155 156 157 158
	}
	return inode;
}

int configfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
{
	int error = 0;
	struct inode * inode = NULL;
	if (dentry) {
		if (!dentry->d_inode) {
159 160
			struct configfs_dirent *sd = dentry->d_fsdata;
			if ((inode = configfs_new_inode(mode, sd))) {
161 162 163 164 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
				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) || S_ISLNK(mode))
			dget(dentry);  /* pin link and directory dentries in core */
	} else
		iput(inode);
 Done:
	return error;
}

/*
 * Get the name for corresponding element represented by the given configfs_dirent
 */
const unsigned char * configfs_get_name(struct configfs_dirent *sd)
{
193
	struct configfs_attribute *attr;
194

195
	BUG_ON(!sd || !sd->s_element);
196 197 198 199 200 201 202

	/* These always have a dentry, so use that */
	if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK))
		return sd->s_dentry->d_name.name;

	if (sd->s_type & CONFIGFS_ITEM_ATTR) {
		attr = sd->s_element;
203
		return attr->ca_name;
204 205 206 207 208 209 210
	}
	return NULL;
}


/*
 * Unhashes the dentry corresponding to given configfs_dirent
211
 * Called with parent inode's i_mutex held.
212 213 214 215 216 217 218
 */
void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
{
	struct dentry * dentry = sd->s_dentry;

	if (dentry) {
		spin_lock(&dcache_lock);
219
		spin_lock(&dentry->d_lock);
220 221 222
		if (!(d_unhashed(dentry) && dentry->d_inode)) {
			dget_locked(dentry);
			__d_drop(dentry);
223
			spin_unlock(&dentry->d_lock);
224 225
			spin_unlock(&dcache_lock);
			simple_unlink(parent->d_inode, dentry);
226 227
		} else {
			spin_unlock(&dentry->d_lock);
228
			spin_unlock(&dcache_lock);
229
		}
230 231 232 233 234 235 236 237
	}
}

void configfs_hash_and_remove(struct dentry * dir, const char * name)
{
	struct configfs_dirent * sd;
	struct configfs_dirent * parent_sd = dir->d_fsdata;

238 239 240 241
	if (dir->d_inode == NULL)
		/* no inode means this hasn't been made visible yet */
		return;

242
	mutex_lock(&dir->d_inode->i_mutex);
243 244 245 246
	list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
		if (!sd->s_element)
			continue;
		if (!strcmp(configfs_get_name(sd), name)) {
247
			spin_lock(&configfs_dirent_lock);
248
			list_del_init(&sd->s_sibling);
249
			spin_unlock(&configfs_dirent_lock);
250 251 252 253 254
			configfs_drop_dentry(sd, dir);
			configfs_put(sd);
			break;
		}
	}
255
	mutex_unlock(&dir->d_inode->i_mutex);
256 257
}

Peter Zijlstra's avatar
Peter Zijlstra committed
258 259 260 261
int __init configfs_inode_init(void)
{
	return bdi_init(&configfs_backing_dev_info);
}
262

Peter Zijlstra's avatar
Peter Zijlstra committed
263 264 265 266
void __exit configfs_inode_exit(void)
{
	bdi_destroy(&configfs_backing_dev_info);
}