2019-06-01 11:08:42 +03:00
// SPDX-License-Identifier: GPL-2.0-only
2013-11-24 18:54:58 +04:00
/*
* fs / kernfs / file . c - kernfs file implementation
*
* Copyright ( c ) 2001 - 3 Patrick Mochel
* Copyright ( c ) 2007 SUSE Linux Products GmbH
* Copyright ( c ) 2007 , 2013 Tejun Heo < tj @ kernel . org >
*/
2013-11-28 23:54:34 +04:00
# include <linux/fs.h>
# include <linux/seq_file.h>
# include <linux/slab.h>
# include <linux/poll.h>
# include <linux/pagemap.h>
2017-02-04 02:16:44 +03:00
# include <linux/sched/mm.h>
2014-04-09 19:07:31 +04:00
# include <linux/fsnotify.h>
2021-01-20 23:46:29 +03:00
# include <linux/uio.h>
2013-11-28 23:54:34 +04:00
# include "kernfs-internal.h"
2013-12-11 23:11:55 +04:00
struct kernfs_open_node {
2022-06-15 05:10:56 +03:00
struct rcu_head rcu_head ;
2013-11-28 23:54:34 +04:00
atomic_t event ;
wait_queue_head_t poll ;
2013-12-11 23:11:55 +04:00
struct list_head files ; /* goes through kernfs_open_file.list */
2022-08-28 08:04:35 +03:00
unsigned int nr_mmapped ;
unsigned int nr_to_release ;
2013-11-28 23:54:34 +04:00
} ;
2022-07-05 23:10:26 +03:00
/*
* kernfs_notify ( ) may be called from any context and bounces notifications
* through a work item . To minimize space overhead in kernfs_node , the
* pending queue is implemented as a singly linked list of kernfs_nodes .
* The list is terminated with the self pointer so that whether a
* kernfs_node is on the list or not can be determined by testing the next
2022-11-12 06:14:56 +03:00
* pointer for % NULL .
2014-07-02 00:41:03 +04:00
*/
2022-07-05 23:10:26 +03:00
# define KERNFS_NOTIFY_EOL ((void *)&kernfs_notify_list)
2014-07-02 00:41:03 +04:00
2022-07-05 23:10:26 +03:00
static DEFINE_SPINLOCK ( kernfs_notify_lock ) ;
static struct kernfs_node * kernfs_notify_list = KERNFS_NOTIFY_EOL ;
2014-07-02 00:41:03 +04:00
2022-06-15 05:10:58 +03:00
static inline struct mutex * kernfs_open_file_mutex_ptr ( struct kernfs_node * kn )
{
2022-06-15 05:10:59 +03:00
int idx = hash_ptr ( kn , NR_KERNFS_LOCK_BITS ) ;
return & kernfs_locks - > open_file_mutex [ idx ] ;
2022-06-15 05:10:58 +03:00
}
static inline struct mutex * kernfs_open_file_mutex_lock ( struct kernfs_node * kn )
{
struct mutex * lock ;
lock = kernfs_open_file_mutex_ptr ( kn ) ;
mutex_lock ( lock ) ;
return lock ;
}
2022-06-15 05:10:56 +03:00
/**
2022-11-12 06:14:56 +03:00
* of_on - Get the kernfs_open_node of the specified kernfs_open_file
* @ of : target kernfs_open_file
*
* Return : the kernfs_open_node of the kernfs_open_file
2022-06-15 05:10:56 +03:00
*/
2022-08-28 08:04:32 +03:00
static struct kernfs_open_node * of_on ( struct kernfs_open_file * of )
2022-06-15 05:10:56 +03:00
{
2022-08-28 08:04:32 +03:00
return rcu_dereference_protected ( of - > kn - > attr . open ,
! list_empty ( & of - > list ) ) ;
2022-06-15 05:10:56 +03:00
}
/**
2022-08-28 08:04:32 +03:00
* kernfs_deref_open_node_locked - Get kernfs_open_node corresponding to @ kn
2022-06-15 05:10:56 +03:00
*
* @ kn : target kernfs_node .
*
* Fetch and return - > attr . open of @ kn when caller holds the
2022-06-15 05:10:58 +03:00
* kernfs_open_file_mutex_ptr ( kn ) .
2022-06-15 05:10:56 +03:00
*
2022-06-15 05:10:58 +03:00
* Update of - > attr . open happens under kernfs_open_file_mutex_ptr ( kn ) . So when
2022-06-15 05:10:56 +03:00
* the caller guarantees that this mutex is being held , other updaters can ' t
* change - > attr . open and this means that we can safely deref - > attr . open
* outside RCU read - side critical section .
*
* The caller needs to make sure that kernfs_open_file_mutex is held .
2022-11-12 06:14:56 +03:00
*
* Return : @ kn - > attr . open when kernfs_open_file_mutex is held .
2022-06-15 05:10:56 +03:00
*/
static struct kernfs_open_node *
2022-08-28 08:04:32 +03:00
kernfs_deref_open_node_locked ( struct kernfs_node * kn )
2022-06-15 05:10:56 +03:00
{
return rcu_dereference_protected ( kn - > attr . open ,
2022-06-15 05:10:58 +03:00
lockdep_is_held ( kernfs_open_file_mutex_ptr ( kn ) ) ) ;
2022-06-15 05:10:56 +03:00
}
2013-12-11 23:11:55 +04:00
static struct kernfs_open_file * kernfs_of ( struct file * file )
2013-11-28 23:54:34 +04:00
{
return ( ( struct seq_file * ) file - > private_data ) - > private ;
}
/*
2013-12-11 23:11:53 +04:00
* Determine the kernfs_ops for the given kernfs_node . This function must
2013-11-28 23:54:34 +04:00
* be called while holding an active reference .
*/
2013-12-11 23:11:53 +04:00
static const struct kernfs_ops * kernfs_ops ( struct kernfs_node * kn )
2013-11-28 23:54:34 +04:00
{
2013-12-11 23:11:56 +04:00
if ( kn - > flags & KERNFS_LOCKDEP )
2013-12-11 23:11:53 +04:00
lockdep_assert_held ( kn ) ;
2013-12-11 23:11:54 +04:00
return kn - > attr . ops ;
2013-11-28 23:54:34 +04:00
}
2014-01-14 18:52:01 +04:00
/*
* As kernfs_seq_stop ( ) is also called after kernfs_seq_start ( ) or
* kernfs_seq_next ( ) failure , it needs to distinguish whether it ' s stopping
* a seq_file iteration which is fully initialized with an active reference
* or an aborted kernfs_seq_start ( ) due to get_active failure . The
* position pointer is the only context for each seq_file iteration and
* thus the stop condition should be encoded in it . As the return value is
* directly visible to userland , ERR_PTR ( - ENODEV ) is the only acceptable
* choice to indicate get_active failure .
*
* Unfortunately , this is complicated due to the optional custom seq_file
* operations which may return ERR_PTR ( - ENODEV ) too . kernfs_seq_stop ( )
* can ' t distinguish whether ERR_PTR ( - ENODEV ) is from get_active failure or
* custom seq_file operations and thus can ' t decide whether put_active
* should be performed or not only on ERR_PTR ( - ENODEV ) .
*
* This is worked around by factoring out the custom seq_stop ( ) and
* put_active part into kernfs_seq_stop_active ( ) , skipping it from
* kernfs_seq_stop ( ) if ERR_PTR ( - ENODEV ) while invoking it directly after
* custom seq_file operations fail with ERR_PTR ( - ENODEV ) - this ensures
* that kernfs_seq_stop_active ( ) is skipped only after get_active failure .
*/
static void kernfs_seq_stop_active ( struct seq_file * sf , void * v )
{
struct kernfs_open_file * of = sf - > private ;
const struct kernfs_ops * ops = kernfs_ops ( of - > kn ) ;
if ( ops - > seq_stop )
ops - > seq_stop ( sf , v ) ;
kernfs_put_active ( of - > kn ) ;
}
2013-11-28 23:54:34 +04:00
static void * kernfs_seq_start ( struct seq_file * sf , loff_t * ppos )
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = sf - > private ;
2013-11-28 23:54:34 +04:00
const struct kernfs_ops * ops ;
/*
2014-10-13 09:41:28 +04:00
* @ of - > mutex nests outside active ref and is primarily to ensure that
2013-11-28 23:54:34 +04:00
* the ops aren ' t called concurrently for the same open file .
*/
mutex_lock ( & of - > mutex ) ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
return ERR_PTR ( - ENODEV ) ;
2013-12-11 23:11:53 +04:00
ops = kernfs_ops ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
if ( ops - > seq_start ) {
2014-01-14 18:52:01 +04:00
void * next = ops - > seq_start ( sf , ppos ) ;
/* see the comment above kernfs_seq_stop_active() */
if ( next = = ERR_PTR ( - ENODEV ) )
kernfs_seq_stop_active ( sf , next ) ;
return next ;
2013-11-28 23:54:34 +04:00
}
2022-01-31 21:22:42 +03:00
return single_start ( sf , ppos ) ;
2013-11-28 23:54:34 +04:00
}
static void * kernfs_seq_next ( struct seq_file * sf , void * v , loff_t * ppos )
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = sf - > private ;
2013-12-11 23:11:53 +04:00
const struct kernfs_ops * ops = kernfs_ops ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
if ( ops - > seq_next ) {
2014-01-14 18:52:01 +04:00
void * next = ops - > seq_next ( sf , v , ppos ) ;
/* see the comment above kernfs_seq_stop_active() */
if ( next = = ERR_PTR ( - ENODEV ) )
kernfs_seq_stop_active ( sf , next ) ;
return next ;
2013-11-28 23:54:34 +04:00
} else {
/*
* The same behavior and code as single_open ( ) , always
* terminate after the initial read .
*/
+ + * ppos ;
return NULL ;
}
}
static void kernfs_seq_stop ( struct seq_file * sf , void * v )
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = sf - > private ;
2013-11-28 23:54:34 +04:00
2014-01-14 18:52:01 +04:00
if ( v ! = ERR_PTR ( - ENODEV ) )
kernfs_seq_stop_active ( sf , v ) ;
2013-11-28 23:54:34 +04:00
mutex_unlock ( & of - > mutex ) ;
}
static int kernfs_seq_show ( struct seq_file * sf , void * v )
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = sf - > private ;
2022-06-15 05:10:56 +03:00
2022-08-28 08:04:32 +03:00
of - > event = atomic_read ( & of_on ( of ) - > event ) ;
2013-11-28 23:54:34 +04:00
2013-12-11 23:11:54 +04:00
return of - > kn - > attr . ops - > seq_show ( sf , v ) ;
2013-11-28 23:54:34 +04:00
}
static const struct seq_operations kernfs_seq_ops = {
. start = kernfs_seq_start ,
. next = kernfs_seq_next ,
. stop = kernfs_seq_stop ,
. show = kernfs_seq_show ,
} ;
/*
* As reading a bin file can have side - effects , the exact offset and bytes
* specified in read ( 2 ) call should be passed to the read callback making
* it difficult to use seq_file . Implement simplistic custom buffering for
* bin files .
*/
2021-01-20 23:46:29 +03:00
static ssize_t kernfs_file_read_iter ( struct kiocb * iocb , struct iov_iter * iter )
2013-11-28 23:54:34 +04:00
{
2021-01-20 23:46:29 +03:00
struct kernfs_open_file * of = kernfs_of ( iocb - > ki_filp ) ;
ssize_t len = min_t ( size_t , iov_iter_count ( iter ) , PAGE_SIZE ) ;
2013-11-28 23:54:34 +04:00
const struct kernfs_ops * ops ;
char * buf ;
2014-10-14 09:57:26 +04:00
buf = of - > prealloc_buf ;
2016-03-31 13:45:06 +03:00
if ( buf )
mutex_lock ( & of - > prealloc_mutex ) ;
else
2014-10-14 09:57:26 +04:00
buf = kmalloc ( len , GFP_KERNEL ) ;
2013-11-28 23:54:34 +04:00
if ( ! buf )
return - ENOMEM ;
/*
2014-10-14 09:57:26 +04:00
* @ of - > mutex nests outside active ref and is used both to ensure that
2016-03-31 13:45:06 +03:00
* the ops aren ' t called concurrently for the same open file .
2013-11-28 23:54:34 +04:00
*/
mutex_lock ( & of - > mutex ) ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) ) {
2013-11-28 23:54:34 +04:00
len = - ENODEV ;
mutex_unlock ( & of - > mutex ) ;
goto out_free ;
}
2022-08-28 08:04:32 +03:00
of - > event = atomic_read ( & of_on ( of ) - > event ) ;
2022-06-15 05:10:56 +03:00
2013-12-11 23:11:53 +04:00
ops = kernfs_ops ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
if ( ops - > read )
2021-01-20 23:46:29 +03:00
len = ops - > read ( of , buf , len , iocb - > ki_pos ) ;
2013-11-28 23:54:34 +04:00
else
len = - EINVAL ;
2016-03-31 13:45:06 +03:00
kernfs_put_active ( of - > kn ) ;
mutex_unlock ( & of - > mutex ) ;
2013-11-28 23:54:34 +04:00
if ( len < 0 )
2016-03-31 13:45:06 +03:00
goto out_free ;
2013-11-28 23:54:34 +04:00
2021-01-20 23:46:29 +03:00
if ( copy_to_iter ( buf , len , iter ) ! = len ) {
2013-11-28 23:54:34 +04:00
len = - EFAULT ;
2016-03-31 13:45:06 +03:00
goto out_free ;
2013-11-28 23:54:34 +04:00
}
2021-01-20 23:46:29 +03:00
iocb - > ki_pos + = len ;
2013-11-28 23:54:34 +04:00
out_free :
2016-03-31 13:45:06 +03:00
if ( buf = = of - > prealloc_buf )
mutex_unlock ( & of - > prealloc_mutex ) ;
else
2014-10-14 09:57:26 +04:00
kfree ( buf ) ;
2013-11-28 23:54:34 +04:00
return len ;
}
2021-01-20 23:46:29 +03:00
static ssize_t kernfs_fop_read_iter ( struct kiocb * iocb , struct iov_iter * iter )
2013-11-28 23:54:34 +04:00
{
2021-01-20 23:46:29 +03:00
if ( kernfs_of ( iocb - > ki_filp ) - > kn - > flags & KERNFS_HAS_SEQ_SHOW )
return seq_read_iter ( iocb , iter ) ;
return kernfs_file_read_iter ( iocb , iter ) ;
2013-11-28 23:54:34 +04:00
}
2021-01-20 23:46:30 +03:00
/*
2013-11-28 23:54:34 +04:00
* Copy data in from userland and pass it to the matching kernfs write
* operation .
*
* There is no easy way for us to know if userspace is only doing a partial
* write , so we don ' t support them . We expect the entire buffer to come on
* the first write . Hint : if you ' re writing a value , first read the file ,
2022-07-22 13:05:18 +03:00
* modify only the value you ' re changing , then write entire buffer
2013-11-28 23:54:34 +04:00
* back .
*/
2021-01-20 23:46:30 +03:00
static ssize_t kernfs_fop_write_iter ( struct kiocb * iocb , struct iov_iter * iter )
2013-11-28 23:54:34 +04:00
{
2021-01-20 23:46:30 +03:00
struct kernfs_open_file * of = kernfs_of ( iocb - > ki_filp ) ;
ssize_t len = iov_iter_count ( iter ) ;
2013-11-28 23:54:34 +04:00
const struct kernfs_ops * ops ;
2014-03-05 00:38:46 +04:00
char * buf ;
2014-02-03 23:09:13 +04:00
2014-03-05 00:38:46 +04:00
if ( of - > atomic_write_len ) {
if ( len > of - > atomic_write_len )
return - E2BIG ;
2014-02-03 23:09:13 +04:00
} else {
2021-01-20 23:46:30 +03:00
len = min_t ( size_t , len , PAGE_SIZE ) ;
2014-02-03 23:09:13 +04:00
}
2014-10-13 09:41:28 +04:00
buf = of - > prealloc_buf ;
2016-03-31 13:45:06 +03:00
if ( buf )
mutex_lock ( & of - > prealloc_mutex ) ;
else
2014-10-13 09:41:28 +04:00
buf = kmalloc ( len + 1 , GFP_KERNEL ) ;
2014-03-05 00:38:46 +04:00
if ( ! buf )
return - ENOMEM ;
2013-11-28 23:54:34 +04:00
2021-01-20 23:46:30 +03:00
if ( copy_from_iter ( buf , len , iter ) ! = len ) {
2016-03-31 13:45:06 +03:00
len = - EFAULT ;
goto out_free ;
}
buf [ len ] = ' \0 ' ; /* guarantee string termination */
2014-03-05 00:38:46 +04:00
/*
2014-10-13 09:41:28 +04:00
* @ of - > mutex nests outside active ref and is used both to ensure that
2016-03-31 13:45:06 +03:00
* the ops aren ' t called concurrently for the same open file .
2014-03-05 00:38:46 +04:00
*/
mutex_lock ( & of - > mutex ) ;
if ( ! kernfs_get_active ( of - > kn ) ) {
mutex_unlock ( & of - > mutex ) ;
len = - ENODEV ;
goto out_free ;
}
ops = kernfs_ops ( of - > kn ) ;
if ( ops - > write )
2021-01-20 23:46:30 +03:00
len = ops - > write ( of , buf , len , iocb - > ki_pos ) ;
2014-03-05 00:38:46 +04:00
else
len = - EINVAL ;
2016-03-31 13:45:06 +03:00
kernfs_put_active ( of - > kn ) ;
mutex_unlock ( & of - > mutex ) ;
2013-11-28 23:54:34 +04:00
if ( len > 0 )
2021-01-20 23:46:30 +03:00
iocb - > ki_pos + = len ;
2014-10-13 09:41:28 +04:00
2014-03-05 00:38:46 +04:00
out_free :
2016-03-31 13:45:06 +03:00
if ( buf = = of - > prealloc_buf )
mutex_unlock ( & of - > prealloc_mutex ) ;
else
2014-10-13 09:41:28 +04:00
kfree ( buf ) ;
2013-11-28 23:54:34 +04:00
return len ;
}
static void kernfs_vma_open ( struct vm_area_struct * vma )
{
struct file * file = vma - > vm_file ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( file ) ;
2013-11-28 23:54:34 +04:00
if ( ! of - > vm_ops )
return ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
return ;
if ( of - > vm_ops - > open )
of - > vm_ops - > open ( vma ) ;
2013-12-11 23:11:58 +04:00
kernfs_put_active ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
}
2018-04-20 22:45:24 +03:00
static vm_fault_t kernfs_vma_fault ( struct vm_fault * vmf )
2013-11-28 23:54:34 +04:00
{
2017-02-25 01:56:41 +03:00
struct file * file = vmf - > vma - > vm_file ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( file ) ;
2018-04-20 22:45:24 +03:00
vm_fault_t ret ;
2013-11-28 23:54:34 +04:00
if ( ! of - > vm_ops )
return VM_FAULT_SIGBUS ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
return VM_FAULT_SIGBUS ;
ret = VM_FAULT_SIGBUS ;
if ( of - > vm_ops - > fault )
2017-02-25 01:56:41 +03:00
ret = of - > vm_ops - > fault ( vmf ) ;
2013-11-28 23:54:34 +04:00
2013-12-11 23:11:58 +04:00
kernfs_put_active ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
return ret ;
}
2018-04-20 22:45:24 +03:00
static vm_fault_t kernfs_vma_page_mkwrite ( struct vm_fault * vmf )
2013-11-28 23:54:34 +04:00
{
2017-02-25 01:56:41 +03:00
struct file * file = vmf - > vma - > vm_file ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( file ) ;
2018-04-20 22:45:24 +03:00
vm_fault_t ret ;
2013-11-28 23:54:34 +04:00
if ( ! of - > vm_ops )
return VM_FAULT_SIGBUS ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
return VM_FAULT_SIGBUS ;
ret = 0 ;
if ( of - > vm_ops - > page_mkwrite )
2017-02-25 01:56:41 +03:00
ret = of - > vm_ops - > page_mkwrite ( vmf ) ;
2013-11-28 23:54:34 +04:00
else
file_update_time ( file ) ;
2013-12-11 23:11:58 +04:00
kernfs_put_active ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
return ret ;
}
static int kernfs_vma_access ( struct vm_area_struct * vma , unsigned long addr ,
void * buf , int len , int write )
{
struct file * file = vma - > vm_file ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( file ) ;
2013-11-28 23:54:34 +04:00
int ret ;
if ( ! of - > vm_ops )
return - EINVAL ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
return - EINVAL ;
ret = - EINVAL ;
if ( of - > vm_ops - > access )
ret = of - > vm_ops - > access ( vma , addr , buf , len , write ) ;
2013-12-11 23:11:58 +04:00
kernfs_put_active ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
return ret ;
}
static const struct vm_operations_struct kernfs_vm_ops = {
. open = kernfs_vma_open ,
. fault = kernfs_vma_fault ,
. page_mkwrite = kernfs_vma_page_mkwrite ,
. access = kernfs_vma_access ,
} ;
2013-12-11 23:11:58 +04:00
static int kernfs_fop_mmap ( struct file * file , struct vm_area_struct * vma )
2013-11-28 23:54:34 +04:00
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( file ) ;
2013-11-28 23:54:34 +04:00
const struct kernfs_ops * ops ;
int rc ;
2013-12-10 18:29:17 +04:00
/*
* mmap path and of - > mutex are prone to triggering spurious lockdep
* warnings and we don ' t want to add spurious locking dependency
* between the two . Check whether mmap is actually implemented
* without grabbing @ of - > mutex by testing HAS_MMAP flag . See the
2023-12-21 17:15:42 +03:00
* comment in kernfs_fop_open ( ) for more details .
2013-12-10 18:29:17 +04:00
*/
2013-12-11 23:11:56 +04:00
if ( ! ( of - > kn - > flags & KERNFS_HAS_MMAP ) )
2013-12-10 18:29:17 +04:00
return - ENODEV ;
2013-11-28 23:54:34 +04:00
mutex_lock ( & of - > mutex ) ;
rc = - ENODEV ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( of - > kn ) )
2013-11-28 23:54:34 +04:00
goto out_unlock ;
2013-12-11 23:11:53 +04:00
ops = kernfs_ops ( of - > kn ) ;
2013-12-10 18:29:17 +04:00
rc = ops - > mmap ( of , vma ) ;
2014-04-20 16:29:21 +04:00
if ( rc )
goto out_put ;
2013-11-28 23:54:34 +04:00
/*
* PowerPC ' s pci_mmap of legacy_mem uses shmem_zero_setup ( )
* to satisfy versions of X which crash if the mmap fails : that
* substitutes a new vm_file , and we don ' t then want bin_vm_ops .
*/
if ( vma - > vm_file ! = file )
goto out_put ;
rc = - EINVAL ;
if ( of - > mmapped & & of - > vm_ops ! = vma - > vm_ops )
goto out_put ;
/*
* It is not possible to successfully wrap close .
* So error if someone is trying to use close .
*/
if ( vma - > vm_ops & & vma - > vm_ops - > close )
goto out_put ;
rc = 0 ;
2024-01-28 02:46:36 +03:00
if ( ! of - > mmapped ) {
of - > mmapped = true ;
of_on ( of ) - > nr_mmapped + + ;
of - > vm_ops = vma - > vm_ops ;
}
2013-11-28 23:54:34 +04:00
vma - > vm_ops = & kernfs_vm_ops ;
out_put :
2013-12-11 23:11:58 +04:00
kernfs_put_active ( of - > kn ) ;
2013-11-28 23:54:34 +04:00
out_unlock :
mutex_unlock ( & of - > mutex ) ;
return rc ;
}
/**
2013-12-11 23:11:58 +04:00
* kernfs_get_open_node - get or create kernfs_open_node
2013-12-11 23:11:53 +04:00
* @ kn : target kernfs_node
2013-12-11 23:11:55 +04:00
* @ of : kernfs_open_file for this instance of open
2013-11-28 23:54:34 +04:00
*
2013-12-11 23:11:54 +04:00
* If @ kn - > attr . open exists , increment its reference count ; otherwise ,
* create one . @ of is chained to the files list .
2013-11-28 23:54:34 +04:00
*
2022-11-12 06:14:56 +03:00
* Locking :
2013-11-28 23:54:34 +04:00
* Kernel thread context ( may sleep ) .
*
2022-11-12 06:14:56 +03:00
* Return :
* % 0 on success , - errno on failure .
2013-11-28 23:54:34 +04:00
*/
2013-12-11 23:11:58 +04:00
static int kernfs_get_open_node ( struct kernfs_node * kn ,
struct kernfs_open_file * of )
2013-11-28 23:54:34 +04:00
{
2022-08-28 08:04:34 +03:00
struct kernfs_open_node * on ;
2022-08-28 08:04:33 +03:00
struct mutex * mutex ;
2013-11-28 23:54:34 +04:00
2022-06-15 05:10:58 +03:00
mutex = kernfs_open_file_mutex_lock ( kn ) ;
2022-08-28 08:04:32 +03:00
on = kernfs_deref_open_node_locked ( kn ) ;
2013-11-28 23:54:34 +04:00
2022-08-28 08:04:34 +03:00
if ( ! on ) {
2022-06-15 05:10:56 +03:00
/* not there, initialize a new one */
2022-08-28 08:04:35 +03:00
on = kzalloc ( sizeof ( * on ) , GFP_KERNEL ) ;
2022-08-28 08:04:34 +03:00
if ( ! on ) {
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2022-06-15 05:10:56 +03:00
return - ENOMEM ;
}
2022-08-28 08:04:34 +03:00
atomic_set ( & on - > event , 1 ) ;
init_waitqueue_head ( & on - > poll ) ;
INIT_LIST_HEAD ( & on - > files ) ;
rcu_assign_pointer ( kn - > attr . open , on ) ;
2013-11-28 23:54:34 +04:00
}
2022-08-28 08:04:34 +03:00
list_add_tail ( & of - > list , & on - > files ) ;
2022-08-28 08:04:35 +03:00
if ( kn - > flags & KERNFS_HAS_RELEASE )
on - > nr_to_release + + ;
2022-08-28 08:04:34 +03:00
mutex_unlock ( mutex ) ;
2022-06-15 05:10:56 +03:00
return 0 ;
2013-11-28 23:54:34 +04:00
}
/**
2022-05-04 12:51:19 +03:00
* kernfs_unlink_open_file - Unlink @ of from @ kn .
*
2022-03-24 13:30:39 +03:00
* @ kn : target kernfs_node
2013-12-11 23:11:55 +04:00
* @ of : associated kernfs_open_file
2022-08-28 08:04:35 +03:00
* @ open_failed : - > open ( ) failed , cancel - > release ( )
2013-11-28 23:54:34 +04:00
*
2022-05-04 12:51:19 +03:00
* Unlink @ of from list of @ kn ' s associated open files . If list of
* associated open files becomes empty , disassociate and free
* kernfs_open_node .
2013-11-28 23:54:34 +04:00
*
* LOCKING :
* None .
*/
2022-05-04 12:51:19 +03:00
static void kernfs_unlink_open_file ( struct kernfs_node * kn ,
2022-08-28 08:04:35 +03:00
struct kernfs_open_file * of ,
bool open_failed )
2013-11-28 23:54:34 +04:00
{
2022-06-15 05:10:56 +03:00
struct kernfs_open_node * on ;
2022-08-28 08:04:33 +03:00
struct mutex * mutex ;
2013-11-28 23:54:34 +04:00
2022-06-15 05:10:58 +03:00
mutex = kernfs_open_file_mutex_lock ( kn ) ;
2022-06-15 05:10:56 +03:00
2022-08-28 08:04:32 +03:00
on = kernfs_deref_open_node_locked ( kn ) ;
2022-06-15 05:10:56 +03:00
if ( ! on ) {
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2022-06-15 05:10:56 +03:00
return ;
}
2013-11-28 23:54:34 +04:00
2022-08-28 08:04:35 +03:00
if ( of ) {
if ( kn - > flags & KERNFS_HAS_RELEASE ) {
WARN_ON_ONCE ( of - > released = = open_failed ) ;
if ( open_failed )
on - > nr_to_release - - ;
}
if ( of - > mmapped )
on - > nr_mmapped - - ;
2013-11-28 23:54:34 +04:00
list_del ( & of - > list ) ;
2022-08-28 08:04:35 +03:00
}
2013-11-28 23:54:34 +04:00
2022-06-15 05:10:56 +03:00
if ( list_empty ( & on - > files ) ) {
rcu_assign_pointer ( kn - > attr . open , NULL ) ;
kfree_rcu ( on , rcu_head ) ;
}
2013-11-28 23:54:34 +04:00
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2013-11-28 23:54:34 +04:00
}
2013-12-11 23:11:58 +04:00
static int kernfs_fop_open ( struct inode * inode , struct file * file )
2013-11-28 23:54:34 +04:00
{
2017-07-12 21:49:49 +03:00
struct kernfs_node * kn = inode - > i_private ;
2014-05-12 21:56:27 +04:00
struct kernfs_root * root = kernfs_root ( kn ) ;
2013-11-28 23:54:34 +04:00
const struct kernfs_ops * ops ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of ;
2013-11-28 23:54:34 +04:00
bool has_read , has_write , has_mmap ;
int error = - EACCES ;
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( kn ) )
2013-11-28 23:54:34 +04:00
return - ENODEV ;
2013-12-11 23:11:53 +04:00
ops = kernfs_ops ( kn ) ;
2013-11-28 23:54:34 +04:00
has_read = ops - > seq_show | | ops - > read | | ops - > mmap ;
has_write = ops - > write | | ops - > mmap ;
has_mmap = ops - > mmap ;
2014-05-12 21:56:27 +04:00
/* see the flag definition for details */
if ( root - > flags & KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK ) {
if ( ( file - > f_mode & FMODE_WRITE ) & &
( ! ( inode - > i_mode & S_IWUGO ) | | ! has_write ) )
goto err_out ;
2013-11-28 23:54:34 +04:00
2014-05-12 21:56:27 +04:00
if ( ( file - > f_mode & FMODE_READ ) & &
( ! ( inode - > i_mode & S_IRUGO ) | | ! has_read ) )
goto err_out ;
}
2013-11-28 23:54:34 +04:00
2013-12-11 23:11:55 +04:00
/* allocate a kernfs_open_file for the file */
2013-11-28 23:54:34 +04:00
error = - ENOMEM ;
2013-12-11 23:11:55 +04:00
of = kzalloc ( sizeof ( struct kernfs_open_file ) , GFP_KERNEL ) ;
2013-11-28 23:54:34 +04:00
if ( ! of )
goto err_out ;
/*
* The following is done to give a different lockdep key to
* @ of - > mutex for files which implement mmap . This is a rather
* crude way to avoid false positive lockdep warning around
2020-06-09 07:33:54 +03:00
* mm - > mmap_lock - mmap nests @ of - > mutex under mm - > mmap_lock and
2013-11-28 23:54:34 +04:00
* reading / sys / block / sda / trace / act_mask grabs sr_mutex , under
2020-06-09 07:33:54 +03:00
* which mm - > mmap_lock nests , while holding @ of - > mutex . As each
2013-11-28 23:54:34 +04:00
* open file has a separate mutex , it ' s okay as long as those don ' t
* happen on the same file . At this point , we can ' t easily give
* each file a separate locking class . Let ' s differentiate on
* whether the file has mmap or not for now .
2013-12-10 18:29:17 +04:00
*
* Both paths of the branch look the same . They ' re supposed to
* look that way and give @ of - > mutex different static lockdep keys .
2013-11-28 23:54:34 +04:00
*/
if ( has_mmap )
mutex_init ( & of - > mutex ) ;
else
mutex_init ( & of - > mutex ) ;
2013-12-11 23:11:53 +04:00
of - > kn = kn ;
2013-11-28 23:54:34 +04:00
of - > file = file ;
2014-03-05 00:38:46 +04:00
/*
* Write path needs to atomic_write_len outside active reference .
2021-01-20 23:46:30 +03:00
* Cache it in open_file . See kernfs_fop_write_iter ( ) for details .
2014-03-05 00:38:46 +04:00
*/
of - > atomic_write_len = ops - > atomic_write_len ;
2014-10-14 09:57:26 +04:00
error = - EINVAL ;
/*
* - > seq_show is incompatible with - > prealloc ,
* as seq_read does its own allocation .
* - > read must be used instead .
*/
if ( ops - > prealloc & & ops - > seq_show )
goto err_free ;
2014-10-13 09:41:28 +04:00
if ( ops - > prealloc ) {
int len = of - > atomic_write_len ? : PAGE_SIZE ;
of - > prealloc_buf = kmalloc ( len + 1 , GFP_KERNEL ) ;
error = - ENOMEM ;
if ( ! of - > prealloc_buf )
goto err_free ;
2016-03-31 13:45:06 +03:00
mutex_init ( & of - > prealloc_mutex ) ;
2014-10-13 09:41:28 +04:00
}
2013-11-28 23:54:34 +04:00
/*
* Always instantiate seq_file even if read access doesn ' t use
* seq_file or is not requested . This unifies private data access
* and readable regular files are the vast majority anyway .
*/
if ( ops - > seq_show )
error = seq_open ( file , & kernfs_seq_ops ) ;
else
error = seq_open ( file , NULL ) ;
if ( error )
goto err_free ;
2016-12-27 22:49:03 +03:00
of - > seq_file = file - > private_data ;
of - > seq_file - > private = of ;
2013-11-28 23:54:34 +04:00
/* seq_file clears PWRITE unconditionally, restore it if WRITE */
if ( file - > f_mode & FMODE_WRITE )
file - > f_mode | = FMODE_PWRITE ;
2013-12-11 23:11:58 +04:00
/* make sure we have open node struct */
error = kernfs_get_open_node ( kn , of ) ;
2013-11-28 23:54:34 +04:00
if ( error )
2016-12-27 22:49:03 +03:00
goto err_seq_release ;
if ( ops - > open ) {
/* nobody has access to @of yet, skip @of->mutex */
error = ops - > open ( of ) ;
if ( error )
goto err_put_node ;
}
2013-11-28 23:54:34 +04:00
/* open succeeded, put active references */
2013-12-11 23:11:58 +04:00
kernfs_put_active ( kn ) ;
2013-11-28 23:54:34 +04:00
return 0 ;
2016-12-27 22:49:03 +03:00
err_put_node :
2022-08-28 08:04:35 +03:00
kernfs_unlink_open_file ( kn , of , true ) ;
2016-12-27 22:49:03 +03:00
err_seq_release :
2013-11-28 23:54:34 +04:00
seq_release ( inode , file ) ;
err_free :
2014-10-13 09:41:28 +04:00
kfree ( of - > prealloc_buf ) ;
2013-11-28 23:54:34 +04:00
kfree ( of ) ;
err_out :
2013-12-11 23:11:58 +04:00
kernfs_put_active ( kn ) ;
2013-11-28 23:54:34 +04:00
return error ;
}
2016-12-27 22:49:03 +03:00
/* used from release/drain to ensure that ->release() is called exactly once */
static void kernfs_release_file ( struct kernfs_node * kn ,
struct kernfs_open_file * of )
{
2017-02-11 23:33:02 +03:00
/*
* @ of is guaranteed to have no other file operations in flight and
* we just want to synchronize release and drain paths .
2022-06-15 05:10:58 +03:00
* @ kernfs_open_file_mutex_ptr ( kn ) is enough . @ of - > mutex can ' t be used
2017-02-11 23:33:02 +03:00
* here because drain path may be called from places which can
* cause circular dependency .
*/
2022-06-15 05:10:58 +03:00
lockdep_assert_held ( kernfs_open_file_mutex_ptr ( kn ) ) ;
2016-12-27 22:49:03 +03:00
if ( ! of - > released ) {
/*
* A file is never detached without being released and we
* need to be able to release files which are deactivated
* and being drained . Don ' t use kernfs_ops ( ) .
*/
kn - > attr . ops - > release ( of ) ;
of - > released = true ;
2022-08-28 08:04:35 +03:00
of_on ( of ) - > nr_to_release - - ;
2016-12-27 22:49:03 +03:00
}
}
2013-12-11 23:11:58 +04:00
static int kernfs_fop_release ( struct inode * inode , struct file * filp )
2013-11-28 23:54:34 +04:00
{
2017-07-12 21:49:49 +03:00
struct kernfs_node * kn = inode - > i_private ;
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( filp ) ;
2013-11-28 23:54:34 +04:00
2017-02-11 23:33:02 +03:00
if ( kn - > flags & KERNFS_HAS_RELEASE ) {
2022-08-28 08:04:33 +03:00
struct mutex * mutex ;
2022-06-15 05:10:58 +03:00
mutex = kernfs_open_file_mutex_lock ( kn ) ;
2017-02-11 23:33:02 +03:00
kernfs_release_file ( kn , of ) ;
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2017-02-11 23:33:02 +03:00
}
2022-08-28 08:04:35 +03:00
kernfs_unlink_open_file ( kn , of , false ) ;
2013-11-28 23:54:34 +04:00
seq_release ( inode , filp ) ;
2014-10-13 09:41:28 +04:00
kfree ( of - > prealloc_buf ) ;
2013-11-28 23:54:34 +04:00
kfree ( of ) ;
return 0 ;
}
2022-08-28 08:04:35 +03:00
bool kernfs_should_drain_open_files ( struct kernfs_node * kn )
2013-11-28 23:54:34 +04:00
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_node * on ;
2022-08-28 08:04:35 +03:00
bool ret ;
2014-01-14 02:27:16 +04:00
2022-05-04 12:51:19 +03:00
/*
2022-08-28 08:04:35 +03:00
* @ kn being deactivated guarantees that @ kn - > attr . open can ' t change
* beneath us making the lockless test below safe .
2022-05-04 12:51:19 +03:00
*/
2022-08-28 08:04:35 +03:00
WARN_ON_ONCE ( atomic_read ( & kn - > active ) ! = KN_DEACTIVATED_BIAS ) ;
rcu_read_lock ( ) ;
on = rcu_dereference ( kn - > attr . open ) ;
ret = on & & ( on - > nr_mmapped | | on - > nr_to_release ) ;
rcu_read_unlock ( ) ;
return ret ;
}
void kernfs_drain_open_files ( struct kernfs_node * kn )
{
struct kernfs_open_node * on ;
struct kernfs_open_file * of ;
struct mutex * mutex ;
2013-11-28 23:54:34 +04:00
2022-06-15 05:10:58 +03:00
mutex = kernfs_open_file_mutex_lock ( kn ) ;
2022-08-28 08:04:32 +03:00
on = kernfs_deref_open_node_locked ( kn ) ;
2022-06-15 05:10:56 +03:00
if ( ! on ) {
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2022-03-24 13:30:39 +03:00
return ;
}
2016-12-27 22:49:03 +03:00
2013-12-11 23:11:55 +04:00
list_for_each_entry ( of , & on - > files , list ) {
2013-11-28 23:54:34 +04:00
struct inode * inode = file_inode ( of - > file ) ;
2016-12-27 22:49:03 +03:00
2022-08-28 08:04:35 +03:00
if ( of - > mmapped ) {
2016-12-27 22:49:03 +03:00
unmap_mapping_range ( inode - > i_mapping , 0 , 0 , 1 ) ;
2022-08-28 08:04:35 +03:00
of - > mmapped = false ;
on - > nr_mmapped - - ;
}
2016-12-27 22:49:03 +03:00
2017-03-14 05:47:00 +03:00
if ( kn - > flags & KERNFS_HAS_RELEASE )
kernfs_release_file ( kn , of ) ;
2013-11-28 23:54:34 +04:00
}
2016-12-27 22:49:03 +03:00
2022-08-28 08:04:35 +03:00
WARN_ON_ONCE ( on - > nr_mmapped | | on - > nr_to_release ) ;
2022-06-15 05:10:58 +03:00
mutex_unlock ( mutex ) ;
2013-11-28 23:54:34 +04:00
}
2013-12-11 23:11:58 +04:00
/*
* Kernfs attribute files are pollable . The idea is that you read
2013-11-28 23:54:34 +04:00
* the content and then you use ' poll ' or ' select ' to wait for
* the content to change . When the content changes ( assuming the
* manager for the kobject supports notification ) , poll will
2018-02-12 01:34:03 +03:00
* return EPOLLERR | EPOLLPRI , and select will return the fd whether
2013-11-28 23:54:34 +04:00
* it is waiting for read , write , or exceptions .
* Once poll / select indicates that the value has changed , you
* need to close and re - open the file , or seek to 0 and read again .
* Reminder : this only works for attributes which actively support
* it , and it is not possible to test an attribute from userspace
* to see if it supports poll ( Neither ' poll ' nor ' select ' return
* an appropriate error code ) . When in doubt , set a suitable timeout value .
*/
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
__poll_t kernfs_generic_poll ( struct kernfs_open_file * of , poll_table * wait )
{
2022-08-28 08:04:32 +03:00
struct kernfs_open_node * on = of_on ( of ) ;
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
poll_wait ( of - > file , & on - > poll , wait ) ;
if ( of - > event ! = atomic_read ( & on - > event ) )
return DEFAULT_POLLMASK | EPOLLERR | EPOLLPRI ;
return DEFAULT_POLLMASK ;
}
2017-07-03 08:02:18 +03:00
static __poll_t kernfs_fop_poll ( struct file * filp , poll_table * wait )
2013-11-28 23:54:34 +04:00
{
2013-12-11 23:11:55 +04:00
struct kernfs_open_file * of = kernfs_of ( filp ) ;
2017-07-12 21:49:49 +03:00
struct kernfs_node * kn = kernfs_dentry_node ( filp - > f_path . dentry ) ;
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
__poll_t ret ;
2013-11-28 23:54:34 +04:00
2013-12-11 23:11:58 +04:00
if ( ! kernfs_get_active ( kn ) )
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
return DEFAULT_POLLMASK | EPOLLERR | EPOLLPRI ;
2013-11-28 23:54:34 +04:00
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
if ( kn - > attr . ops - > poll )
ret = kn - > attr . ops - > poll ( of , wait ) ;
else
ret = kernfs_generic_poll ( of , wait ) ;
2013-11-28 23:54:34 +04:00
2013-12-11 23:11:58 +04:00
kernfs_put_active ( kn ) ;
fs: kernfs: add poll file operation
Patch series "psi: pressure stall monitors", v3.
Android is adopting psi to detect and remedy memory pressure that
results in stuttering and decreased responsiveness on mobile devices.
Psi gives us the stall information, but because we're dealing with
latencies in the millisecond range, periodically reading the pressure
files to detect stalls in a timely fashion is not feasible. Psi also
doesn't aggregate its averages at a high enough frequency right now.
This patch series extends the psi interface such that users can
configure sensitive latency thresholds and use poll() and friends to be
notified when these are breached.
As high-frequency aggregation is costly, it implements an aggregation
method that is optimized for fast, short-interval averaging, and makes
the aggregation frequency adaptive, such that high-frequency updates
only happen while monitored stall events are actively occurring.
With these patches applied, Android can monitor for, and ward off,
mounting memory shortages before they cause problems for the user. For
example, using memory stall monitors in userspace low memory killer
daemon (lmkd) we can detect mounting pressure and kill less important
processes before device becomes visibly sluggish.
In our memory stress testing psi memory monitors produce roughly 10x
less false positives compared to vmpressure signals. Having ability to
specify multiple triggers for the same psi metric allows other parts of
Android framework to monitor memory state of the device and act
accordingly.
The new interface is straightforward. The user opens one of the
pressure files for writing and writes a trigger description into the
file descriptor that defines the stall state - some or full, and the
maximum stall time over a given window of time. E.g.:
/* Signal when stall time exceeds 100ms of a 1s window */
char trigger[] = "full 100000 1000000";
fd = open("/proc/pressure/memory");
write(fd, trigger, sizeof(trigger));
while (poll() >= 0) {
...
}
close(fd);
When the monitored stall state is entered, psi adapts its aggregation
frequency according to what the configured time window requires in order
to emit event signals in a timely fashion. Once the stalling subsides,
aggregation reverts back to normal.
The trigger is associated with the open file descriptor. To stop
monitoring, the user only needs to close the file descriptor and the
trigger is discarded.
Patches 1-4 prepare the psi code for polling support. Patch 5
implements the adaptive polling logic, the pressure growth detection
optimized for short intervals, and hooks up write() and poll() on the
pressure files.
The patches were developed in collaboration with Johannes Weiner.
This patch (of 5):
Kernfs has a standardized poll/notification mechanism for waking all
pollers on all fds when a filesystem node changes. To allow polling for
custom events, add a .poll callback that can override the default.
This is in preparation for pollable cgroup pressure files which have
per-fd trigger configurations.
Link: http://lkml.kernel.org/r/20190124211518.244221-2-surenb@google.com
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-03-06 02:45:45 +03:00
return ret ;
2013-11-28 23:54:34 +04:00
}
2023-09-25 11:40:12 +03:00
static loff_t kernfs_fop_llseek ( struct file * file , loff_t offset , int whence )
{
struct kernfs_open_file * of = kernfs_of ( file ) ;
const struct kernfs_ops * ops ;
loff_t ret ;
/*
* @ of - > mutex nests outside active ref and is primarily to ensure that
* the ops aren ' t called concurrently for the same open file .
*/
mutex_lock ( & of - > mutex ) ;
if ( ! kernfs_get_active ( of - > kn ) ) {
mutex_unlock ( & of - > mutex ) ;
return - ENODEV ;
}
ops = kernfs_ops ( of - > kn ) ;
if ( ops - > llseek )
ret = ops - > llseek ( of , offset , whence ) ;
else
ret = generic_file_llseek ( file , offset , whence ) ;
kernfs_put_active ( of - > kn ) ;
mutex_unlock ( & of - > mutex ) ;
return ret ;
}
2014-07-02 00:41:03 +04:00
static void kernfs_notify_workfn ( struct work_struct * work )
2013-11-28 23:54:34 +04:00
{
2014-07-02 00:41:03 +04:00
struct kernfs_node * kn ;
2014-04-09 19:07:31 +04:00
struct kernfs_super_info * info ;
2021-11-19 02:00:08 +03:00
struct kernfs_root * root ;
2014-07-02 00:41:03 +04:00
repeat :
/* pop one off the notify_list */
2022-07-05 23:10:26 +03:00
spin_lock_irq ( & kernfs_notify_lock ) ;
kn = kernfs_notify_list ;
if ( kn = = KERNFS_NOTIFY_EOL ) {
spin_unlock_irq ( & kernfs_notify_lock ) ;
2014-04-09 19:07:31 +04:00
return ;
2022-07-05 23:10:26 +03:00
}
kernfs_notify_list = kn - > attr . notify_next ;
kn - > attr . notify_next = NULL ;
spin_unlock_irq ( & kernfs_notify_lock ) ;
2014-04-09 19:07:31 +04:00
2021-11-19 02:00:08 +03:00
root = kernfs_root ( kn ) ;
2014-04-09 19:07:31 +04:00
/* kick fsnotify */
2023-03-09 14:09:31 +03:00
down_read ( & root - > kernfs_supers_rwsem ) ;
2014-07-02 00:41:03 +04:00
list_for_each_entry ( info , & kernfs_root ( kn ) - > supers , node ) {
2016-06-18 00:51:17 +03:00
struct kernfs_node * parent ;
fsnotify: send event to parent and child with single callback
Instead of calling fsnotify() twice, once with parent inode and once
with child inode, if event should be sent to parent inode, send it
with both parent and child inodes marks in object type iterator and call
the backend handle_event() callback only once.
The parent inode is assigned to the standard "inode" iterator type and
the child inode is assigned to the special "child" iterator type.
In that case, the bit FS_EVENT_ON_CHILD will be set in the event mask,
the dir argument to handle_event will be the parent inode, the file_name
argument to handle_event is non NULL and refers to the name of the child
and the child inode can be accessed with fsnotify_data_inode().
This will allow fanotify to make decisions based on child or parent's
ignored mask. For example, when a parent is interested in a specific
event on its children, but a specific child wishes to ignore this event,
the event will not be reported. This is not what happens with current
code, but according to man page, it is the expected behavior.
Link: https://lore.kernel.org/r/20200716084230.30611-15-amir73il@gmail.com
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2020-07-16 11:42:22 +03:00
struct inode * p_inode = NULL ;
2014-04-09 19:07:31 +04:00
struct inode * inode ;
2019-04-26 20:37:25 +03:00
struct qstr name ;
2014-04-09 19:07:31 +04:00
2016-06-18 00:51:17 +03:00
/*
* We want fsnotify_modify ( ) on @ kn but as the
* modifications aren ' t originating from userland don ' t
* have the matching @ file available . Look up the inodes
* and generate the events manually .
*/
2019-11-05 02:54:30 +03:00
inode = ilookup ( info - > sb , kernfs_ino ( kn ) ) ;
2014-04-09 19:07:31 +04:00
if ( ! inode )
continue ;
2019-04-26 20:37:25 +03:00
name = ( struct qstr ) QSTR_INIT ( kn - > name , strlen ( kn - > name ) ) ;
2016-06-18 00:51:17 +03:00
parent = kernfs_get_parent ( kn ) ;
if ( parent ) {
2019-11-05 02:54:30 +03:00
p_inode = ilookup ( info - > sb , kernfs_ino ( parent ) ) ;
2016-06-18 00:51:17 +03:00
if ( p_inode ) {
2020-07-22 15:58:46 +03:00
fsnotify ( FS_MODIFY | FS_EVENT_ON_CHILD ,
inode , FSNOTIFY_EVENT_INODE ,
p_inode , & name , inode , 0 ) ;
2016-06-18 00:51:17 +03:00
iput ( p_inode ) ;
}
kernfs_put ( parent ) ;
2014-04-09 19:07:31 +04:00
}
2020-07-22 15:58:44 +03:00
if ( ! p_inode )
fsnotify_inode ( inode , FS_MODIFY ) ;
fsnotify: send event to parent and child with single callback
Instead of calling fsnotify() twice, once with parent inode and once
with child inode, if event should be sent to parent inode, send it
with both parent and child inodes marks in object type iterator and call
the backend handle_event() callback only once.
The parent inode is assigned to the standard "inode" iterator type and
the child inode is assigned to the special "child" iterator type.
In that case, the bit FS_EVENT_ON_CHILD will be set in the event mask,
the dir argument to handle_event will be the parent inode, the file_name
argument to handle_event is non NULL and refers to the name of the child
and the child inode can be accessed with fsnotify_data_inode().
This will allow fanotify to make decisions based on child or parent's
ignored mask. For example, when a parent is interested in a specific
event on its children, but a specific child wishes to ignore this event,
the event will not be reported. This is not what happens with current
code, but according to man page, it is the expected behavior.
Link: https://lore.kernel.org/r/20200716084230.30611-15-amir73il@gmail.com
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2020-07-16 11:42:22 +03:00
2014-04-09 19:07:31 +04:00
iput ( inode ) ;
}
2023-03-09 14:09:31 +03:00
up_read ( & root - > kernfs_supers_rwsem ) ;
2014-07-02 00:41:03 +04:00
kernfs_put ( kn ) ;
goto repeat ;
}
/**
* kernfs_notify - notify a kernfs file
* @ kn : file to notify
*
* Notify @ kn such that poll ( 2 ) on @ kn wakes up . Maybe be called from any
* context .
*/
void kernfs_notify ( struct kernfs_node * kn )
{
static DECLARE_WORK ( kernfs_notify_work , kernfs_notify_workfn ) ;
2022-07-05 23:10:26 +03:00
unsigned long flags ;
2018-11-16 05:09:54 +03:00
struct kernfs_open_node * on ;
2014-07-02 00:41:03 +04:00
if ( WARN_ON ( kernfs_type ( kn ) ! = KERNFS_FILE ) )
return ;
2018-11-16 05:09:54 +03:00
/* kick poll immediately */
2022-06-15 05:10:56 +03:00
rcu_read_lock ( ) ;
on = rcu_dereference ( kn - > attr . open ) ;
2018-11-16 05:09:54 +03:00
if ( on ) {
atomic_inc ( & on - > event ) ;
wake_up_interruptible ( & on - > poll ) ;
}
2022-06-15 05:10:56 +03:00
rcu_read_unlock ( ) ;
2018-11-16 05:09:54 +03:00
/* schedule work to kick fsnotify */
2022-07-05 23:10:26 +03:00
spin_lock_irqsave ( & kernfs_notify_lock , flags ) ;
if ( ! kn - > attr . notify_next ) {
kernfs_get ( kn ) ;
kn - > attr . notify_next = kernfs_notify_list ;
kernfs_notify_list = kn ;
schedule_work ( & kernfs_notify_work ) ;
}
spin_unlock_irqrestore ( & kernfs_notify_lock , flags ) ;
2013-11-28 23:54:34 +04:00
}
EXPORT_SYMBOL_GPL ( kernfs_notify ) ;
2013-12-11 23:11:57 +04:00
const struct file_operations kernfs_file_fops = {
2021-01-20 23:46:29 +03:00
. read_iter = kernfs_fop_read_iter ,
2021-01-20 23:46:30 +03:00
. write_iter = kernfs_fop_write_iter ,
2023-09-25 11:40:12 +03:00
. llseek = kernfs_fop_llseek ,
2013-12-11 23:11:58 +04:00
. mmap = kernfs_fop_mmap ,
. open = kernfs_fop_open ,
. release = kernfs_fop_release ,
. poll = kernfs_fop_poll ,
2016-10-14 20:56:42 +03:00
. fsync = noop_fsync ,
2023-05-22 16:49:59 +03:00
. splice_read = copy_splice_read ,
2021-01-20 23:46:31 +03:00
. splice_write = iter_file_splice_write ,
2013-11-28 23:54:34 +04:00
} ;
/**
2013-12-12 01:02:57 +04:00
* __kernfs_create_file - kernfs internal function to create a file
2013-11-28 23:54:34 +04:00
* @ parent : directory to create the file in
* @ name : name of the file
* @ mode : mode of the file
2018-07-21 00:56:47 +03:00
* @ uid : uid of the file
* @ gid : gid of the file
2013-11-28 23:54:34 +04:00
* @ size : size of the file
* @ ops : kernfs operations for the file
* @ priv : private data for the file
* @ ns : optional namespace tag of the file
* @ key : lockdep key for the file ' s active_ref , % NULL to disable lockdep
*
2022-11-12 06:14:56 +03:00
* Return : the created node on success , ERR_PTR ( ) value on error .
2013-11-28 23:54:34 +04:00
*/
2013-12-12 01:02:57 +04:00
struct kernfs_node * __kernfs_create_file ( struct kernfs_node * parent ,
const char * name ,
2018-07-21 00:56:47 +03:00
umode_t mode , kuid_t uid , kgid_t gid ,
loff_t size ,
2013-12-12 01:02:57 +04:00
const struct kernfs_ops * ops ,
void * priv , const void * ns ,
struct lock_class_key * key )
2013-11-28 23:54:34 +04:00
{
2013-12-11 23:11:53 +04:00
struct kernfs_node * kn ;
2013-12-12 01:02:57 +04:00
unsigned flags ;
2013-11-28 23:54:34 +04:00
int rc ;
2013-12-12 01:02:57 +04:00
flags = KERNFS_FILE ;
2018-07-21 00:56:47 +03:00
kn = kernfs_new_node ( parent , name , ( mode & S_IALLUGO ) | S_IFREG ,
uid , gid , flags ) ;
2013-12-11 23:11:53 +04:00
if ( ! kn )
2013-11-28 23:54:34 +04:00
return ERR_PTR ( - ENOMEM ) ;
2013-12-11 23:11:54 +04:00
kn - > attr . ops = ops ;
kn - > attr . size = size ;
kn - > ns = ns ;
2013-12-11 23:11:53 +04:00
kn - > priv = priv ;
2013-11-28 23:54:34 +04:00
# ifdef CONFIG_DEBUG_LOCK_ALLOC
if ( key ) {
2020-04-02 20:10:56 +03:00
lockdep_init_map ( & kn - > dep_map , " kn->active " , key , 0 ) ;
2013-12-11 23:11:56 +04:00
kn - > flags | = KERNFS_LOCKDEP ;
2013-11-28 23:54:34 +04:00
}
# endif
/*
2022-03-14 14:53:28 +03:00
* kn - > attr . ops is accessible only while holding active ref . We
2013-11-28 23:54:34 +04:00
* need to know whether some ops are implemented outside active
* ref . Cache their existence in flags .
*/
if ( ops - > seq_show )
2013-12-11 23:11:56 +04:00
kn - > flags | = KERNFS_HAS_SEQ_SHOW ;
2013-11-28 23:54:34 +04:00
if ( ops - > mmap )
2013-12-11 23:11:56 +04:00
kn - > flags | = KERNFS_HAS_MMAP ;
2016-12-27 22:49:03 +03:00
if ( ops - > release )
kn - > flags | = KERNFS_HAS_RELEASE ;
2013-11-28 23:54:34 +04:00
2014-02-03 23:02:58 +04:00
rc = kernfs_add_one ( kn ) ;
2013-11-28 23:54:34 +04:00
if ( rc ) {
2013-12-11 23:11:53 +04:00
kernfs_put ( kn ) ;
2013-11-28 23:54:34 +04:00
return ERR_PTR ( rc ) ;
}
2013-12-11 23:11:53 +04:00
return kn ;
2013-11-28 23:54:34 +04:00
}