2013-11-24 18:54:58 +04:00
/*
* fs / kernfs / inode . c - kernfs inode implementation
*
* Copyright ( c ) 2001 - 3 Patrick Mochel
* Copyright ( c ) 2007 SUSE Linux Products GmbH
* Copyright ( c ) 2007 , 2013 Tejun Heo < tj @ kernel . org >
*
* This file is released under the GPLv2 .
*/
2013-11-28 23:54:32 +04:00
# include <linux/pagemap.h>
# include <linux/backing-dev.h>
# include <linux/capability.h>
# include <linux/errno.h>
# include <linux/slab.h>
# include <linux/xattr.h>
# include <linux/security.h>
# include "kernfs-internal.h"
static const struct address_space_operations sysfs_aops = {
. readpage = simple_readpage ,
. write_begin = simple_write_begin ,
. write_end = simple_write_end ,
} ;
static struct backing_dev_info sysfs_backing_dev_info = {
. name = " sysfs " ,
. ra_pages = 0 , /* No readahead */
. capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK ,
} ;
static const struct inode_operations sysfs_inode_operations = {
. permission = sysfs_permission ,
. setattr = sysfs_setattr ,
. getattr = sysfs_getattr ,
. setxattr = sysfs_setxattr ,
2013-11-24 02:40:02 +04:00
. removexattr = sysfs_removexattr ,
. getxattr = sysfs_getxattr ,
. listxattr = sysfs_listxattr ,
2013-11-28 23:54:32 +04:00
} ;
2013-11-28 23:54:43 +04:00
void __init sysfs_inode_init ( void )
2013-11-28 23:54:32 +04:00
{
2013-11-28 23:54:43 +04:00
if ( bdi_init ( & sysfs_backing_dev_info ) )
panic ( " failed to init sysfs_backing_dev_info " ) ;
2013-11-28 23:54:32 +04:00
}
2013-12-11 23:11:53 +04:00
static struct sysfs_inode_attrs * sysfs_inode_attrs ( struct kernfs_node * kn )
2013-11-28 23:54:32 +04:00
{
struct iattr * iattrs ;
2013-12-11 23:11:53 +04:00
if ( kn - > s_iattr )
return kn - > s_iattr ;
2013-11-24 02:40:01 +04:00
2013-12-11 23:11:53 +04:00
kn - > s_iattr = kzalloc ( sizeof ( struct sysfs_inode_attrs ) , GFP_KERNEL ) ;
if ( ! kn - > s_iattr )
2013-11-28 23:54:32 +04:00
return NULL ;
2013-12-11 23:11:53 +04:00
iattrs = & kn - > s_iattr - > ia_iattr ;
2013-11-28 23:54:32 +04:00
/* assign default attributes */
2013-12-11 23:11:53 +04:00
iattrs - > ia_mode = kn - > s_mode ;
2013-11-28 23:54:32 +04:00
iattrs - > ia_uid = GLOBAL_ROOT_UID ;
iattrs - > ia_gid = GLOBAL_ROOT_GID ;
iattrs - > ia_atime = iattrs - > ia_mtime = iattrs - > ia_ctime = CURRENT_TIME ;
2013-12-11 23:11:53 +04:00
simple_xattrs_init ( & kn - > s_iattr - > xattrs ) ;
2013-11-24 02:40:02 +04:00
2013-12-11 23:11:53 +04:00
return kn - > s_iattr ;
2013-11-28 23:54:32 +04:00
}
2013-12-11 23:11:53 +04:00
static int __kernfs_setattr ( struct kernfs_node * kn , const struct iattr * iattr )
2013-11-28 23:54:32 +04:00
{
2013-11-24 02:40:01 +04:00
struct sysfs_inode_attrs * attrs ;
2013-11-28 23:54:32 +04:00
struct iattr * iattrs ;
unsigned int ia_valid = iattr - > ia_valid ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:01 +04:00
if ( ! attrs )
return - ENOMEM ;
2013-11-28 23:54:32 +04:00
2013-11-24 02:40:01 +04:00
iattrs = & attrs - > ia_iattr ;
2013-11-28 23:54:32 +04:00
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 ;
2013-12-11 23:11:53 +04:00
iattrs - > ia_mode = kn - > s_mode = mode ;
2013-11-28 23:54:32 +04:00
}
return 0 ;
}
/**
* kernfs_setattr - set iattr on a node
2013-12-11 23:11:53 +04:00
* @ kn : target node
2013-11-28 23:54:32 +04:00
* @ iattr : iattr to set
*
* Returns 0 on success , - errno on failure .
*/
2013-12-11 23:11:53 +04:00
int kernfs_setattr ( struct kernfs_node * kn , const struct iattr * iattr )
2013-11-28 23:54:32 +04:00
{
int ret ;
mutex_lock ( & sysfs_mutex ) ;
2013-12-11 23:11:53 +04:00
ret = __kernfs_setattr ( kn , iattr ) ;
2013-11-28 23:54:32 +04:00
mutex_unlock ( & sysfs_mutex ) ;
return ret ;
}
int sysfs_setattr ( struct dentry * dentry , struct iattr * iattr )
{
struct inode * inode = dentry - > d_inode ;
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-28 23:54:32 +04:00
int error ;
2013-12-11 23:11:53 +04:00
if ( ! kn )
2013-11-28 23:54:32 +04:00
return - EINVAL ;
mutex_lock ( & sysfs_mutex ) ;
error = inode_change_ok ( inode , iattr ) ;
if ( error )
goto out ;
2013-12-11 23:11:53 +04:00
error = __kernfs_setattr ( kn , iattr ) ;
2013-11-28 23:54:32 +04:00
if ( error )
goto out ;
/* this ignores size changes */
setattr_copy ( inode , iattr ) ;
out :
mutex_unlock ( & sysfs_mutex ) ;
return error ;
}
2013-12-11 23:11:53 +04:00
static int sysfs_sd_setsecdata ( struct kernfs_node * kn , void * * secdata ,
2013-11-28 23:54:32 +04:00
u32 * secdata_len )
{
2013-11-24 02:40:01 +04:00
struct sysfs_inode_attrs * attrs ;
2013-11-28 23:54:32 +04:00
void * old_secdata ;
size_t old_secdata_len ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:01 +04:00
if ( ! attrs )
return - ENOMEM ;
2013-11-28 23:54:32 +04:00
2013-11-24 02:40:01 +04:00
old_secdata = attrs - > ia_secdata ;
old_secdata_len = attrs - > ia_secdata_len ;
2013-11-28 23:54:32 +04:00
2013-11-24 02:40:01 +04:00
attrs - > ia_secdata = * secdata ;
attrs - > ia_secdata_len = * secdata_len ;
2013-11-28 23:54:32 +04:00
* secdata = old_secdata ;
* secdata_len = old_secdata_len ;
return 0 ;
}
int sysfs_setxattr ( struct dentry * dentry , const char * name , const void * value ,
size_t size , int flags )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-24 02:40:02 +04:00
struct sysfs_inode_attrs * attrs ;
2013-11-28 23:54:32 +04:00
void * secdata ;
int error ;
u32 secdata_len = 0 ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:02 +04:00
if ( ! attrs )
return - ENOMEM ;
2013-11-28 23:54:32 +04:00
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 )
2013-11-24 02:40:02 +04:00
return error ;
2013-11-28 23:54:32 +04:00
error = security_inode_getsecctx ( dentry - > d_inode ,
& secdata , & secdata_len ) ;
if ( error )
2013-11-24 02:40:02 +04:00
return error ;
2013-11-28 23:54:32 +04:00
mutex_lock ( & sysfs_mutex ) ;
2013-12-11 23:11:53 +04:00
error = sysfs_sd_setsecdata ( kn , & secdata , & secdata_len ) ;
2013-11-28 23:54:32 +04:00
mutex_unlock ( & sysfs_mutex ) ;
if ( secdata )
security_release_secctx ( secdata , secdata_len ) ;
2013-11-24 02:40:02 +04:00
return error ;
} else if ( ! strncmp ( name , XATTR_TRUSTED_PREFIX , XATTR_TRUSTED_PREFIX_LEN ) ) {
return simple_xattr_set ( & attrs - > xattrs , name , value , size ,
flags ) ;
}
return - EINVAL ;
}
int sysfs_removexattr ( struct dentry * dentry , const char * name )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-24 02:40:02 +04:00
struct sysfs_inode_attrs * attrs ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:02 +04:00
if ( ! attrs )
return - ENOMEM ;
return simple_xattr_remove ( & attrs - > xattrs , name ) ;
}
ssize_t sysfs_getxattr ( struct dentry * dentry , const char * name , void * buf ,
size_t size )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-24 02:40:02 +04:00
struct sysfs_inode_attrs * attrs ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:02 +04:00
if ( ! attrs )
return - ENOMEM ;
return simple_xattr_get ( & attrs - > xattrs , name , buf , size ) ;
}
ssize_t sysfs_listxattr ( struct dentry * dentry , char * buf , size_t size )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-24 02:40:02 +04:00
struct sysfs_inode_attrs * attrs ;
2013-12-11 23:11:53 +04:00
attrs = sysfs_inode_attrs ( kn ) ;
2013-11-24 02:40:02 +04:00
if ( ! attrs )
return - ENOMEM ;
return simple_xattr_list ( & attrs - > xattrs , buf , size ) ;
2013-11-28 23:54:32 +04:00
}
static inline void set_default_inode_attr ( struct inode * inode , umode_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 ;
}
2013-12-11 23:11:53 +04:00
static void sysfs_refresh_inode ( struct kernfs_node * kn , struct inode * inode )
2013-11-28 23:54:32 +04:00
{
2013-12-11 23:11:53 +04:00
struct sysfs_inode_attrs * attrs = kn - > s_iattr ;
2013-11-28 23:54:32 +04:00
2013-12-11 23:11:53 +04:00
inode - > i_mode = kn - > s_mode ;
2013-11-24 02:40:01 +04:00
if ( attrs ) {
2013-12-11 23:11:53 +04:00
/*
* kernfs_node has non - default attributes get them from
* persistent copy in kernfs_node .
2013-11-28 23:54:32 +04:00
*/
2013-11-24 02:40:01 +04:00
set_inode_attr ( inode , & attrs - > ia_iattr ) ;
security_inode_notifysecctx ( inode , attrs - > ia_secdata ,
attrs - > ia_secdata_len ) ;
2013-11-28 23:54:32 +04:00
}
2013-12-11 23:11:53 +04:00
if ( sysfs_type ( kn ) = = SYSFS_DIR )
set_nlink ( inode , kn - > s_dir . subdirs + 2 ) ;
2013-11-28 23:54:32 +04:00
}
int sysfs_getattr ( struct vfsmount * mnt , struct dentry * dentry ,
struct kstat * stat )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = dentry - > d_fsdata ;
2013-11-28 23:54:32 +04:00
struct inode * inode = dentry - > d_inode ;
mutex_lock ( & sysfs_mutex ) ;
2013-12-11 23:11:53 +04:00
sysfs_refresh_inode ( kn , inode ) ;
2013-11-28 23:54:32 +04:00
mutex_unlock ( & sysfs_mutex ) ;
generic_fillattr ( inode , stat ) ;
return 0 ;
}
2013-12-11 23:11:53 +04:00
static void sysfs_init_inode ( struct kernfs_node * kn , struct inode * inode )
2013-11-28 23:54:32 +04:00
{
2013-12-11 23:11:53 +04:00
kernfs_get ( kn ) ;
inode - > i_private = kn ;
2013-11-28 23:54:32 +04:00
inode - > i_mapping - > a_ops = & sysfs_aops ;
inode - > i_mapping - > backing_dev_info = & sysfs_backing_dev_info ;
inode - > i_op = & sysfs_inode_operations ;
2013-12-11 23:11:53 +04:00
set_default_inode_attr ( inode , kn - > s_mode ) ;
sysfs_refresh_inode ( kn , inode ) ;
2013-11-28 23:54:32 +04:00
/* initialize inode according to type */
2013-12-11 23:11:53 +04:00
switch ( sysfs_type ( kn ) ) {
2013-11-28 23:54:32 +04:00
case SYSFS_DIR :
inode - > i_op = & sysfs_dir_inode_operations ;
inode - > i_fop = & sysfs_dir_operations ;
break ;
case SYSFS_KOBJ_ATTR :
2013-12-11 23:11:53 +04:00
inode - > i_size = kn - > s_attr . size ;
2013-11-28 23:54:32 +04:00
inode - > i_fop = & kernfs_file_operations ;
break ;
case SYSFS_KOBJ_LINK :
inode - > i_op = & sysfs_symlink_inode_operations ;
break ;
default :
BUG ( ) ;
}
unlock_new_inode ( inode ) ;
}
/**
2013-12-11 23:11:53 +04:00
* sysfs_get_inode - get inode for kernfs_node
2013-11-28 23:54:32 +04:00
* @ sb : super block
2013-12-11 23:11:53 +04:00
* @ kn : kernfs_node to allocate inode for
2013-11-28 23:54:32 +04:00
*
2013-12-11 23:11:53 +04:00
* Get inode for @ kn . If such inode doesn ' t exist , a new inode is
* allocated and basics are initialized . New inode is returned
* locked .
2013-11-28 23:54:32 +04:00
*
* LOCKING :
* Kernel thread context ( may sleep ) .
*
* RETURNS :
* Pointer to allocated inode on success , NULL on failure .
*/
2013-12-11 23:11:53 +04:00
struct inode * sysfs_get_inode ( struct super_block * sb , struct kernfs_node * kn )
2013-11-28 23:54:32 +04:00
{
struct inode * inode ;
2013-12-11 23:11:53 +04:00
inode = iget_locked ( sb , kn - > s_ino ) ;
2013-11-28 23:54:32 +04:00
if ( inode & & ( inode - > i_state & I_NEW ) )
2013-12-11 23:11:53 +04:00
sysfs_init_inode ( kn , inode ) ;
2013-11-28 23:54:32 +04:00
return inode ;
}
/*
2013-12-11 23:11:53 +04:00
* The kernfs_node 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 kernfs_node from the sysfs inode . A
2013-11-28 23:54:32 +04:00
* super_operations . evict_inode ( ) implementation is needed to drop that
* reference upon inode destruction .
*/
void sysfs_evict_inode ( struct inode * inode )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn = inode - > i_private ;
2013-11-28 23:54:32 +04:00
truncate_inode_pages ( & inode - > i_data , 0 ) ;
clear_inode ( inode ) ;
2013-12-11 23:11:53 +04:00
kernfs_put ( kn ) ;
2013-11-28 23:54:32 +04:00
}
int sysfs_permission ( struct inode * inode , int mask )
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn ;
2013-11-28 23:54:32 +04:00
if ( mask & MAY_NOT_BLOCK )
return - ECHILD ;
2013-12-11 23:11:53 +04:00
kn = inode - > i_private ;
2013-11-28 23:54:32 +04:00
mutex_lock ( & sysfs_mutex ) ;
2013-12-11 23:11:53 +04:00
sysfs_refresh_inode ( kn , inode ) ;
2013-11-28 23:54:32 +04:00
mutex_unlock ( & sysfs_mutex ) ;
return generic_permission ( inode , mask ) ;
}