2008-04-29 12:00:10 +04:00
/*
2008-10-19 07:28:07 +04:00
* device_cgroup . c - device cgroup subsystem
2008-04-29 12:00:10 +04:00
*
* Copyright 2007 IBM Corp
*/
# include <linux/device_cgroup.h>
# include <linux/cgroup.h>
# include <linux/ctype.h>
# include <linux/list.h>
# include <linux/uaccess.h>
2008-04-29 12:00:14 +04:00
# include <linux/seq_file.h>
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
# include <linux/slab.h>
2008-10-19 07:28:07 +04:00
# include <linux/rcupdate.h>
2009-04-03 03:57:32 +04:00
# include <linux/mutex.h>
2008-04-29 12:00:10 +04:00
# define ACC_MKNOD 1
# define ACC_READ 2
# define ACC_WRITE 4
# define ACC_MASK (ACC_MKNOD | ACC_READ | ACC_WRITE)
# define DEV_BLOCK 1
# define DEV_CHAR 2
# define DEV_ALL 4 /* this represents all devices */
2009-04-03 03:57:32 +04:00
static DEFINE_MUTEX ( devcgroup_mutex ) ;
2013-02-15 20:55:45 +04:00
enum devcg_behavior {
DEVCG_DEFAULT_NONE ,
DEVCG_DEFAULT_ALLOW ,
DEVCG_DEFAULT_DENY ,
} ;
2008-04-29 12:00:10 +04:00
/*
2012-10-05 04:15:20 +04:00
* exception list locking rules :
2009-04-03 03:57:32 +04:00
* hold devcgroup_mutex for update / read .
2008-10-19 07:28:07 +04:00
* hold rcu_read_lock ( ) for read .
2008-04-29 12:00:10 +04:00
*/
2012-10-05 04:15:20 +04:00
struct dev_exception_item {
2008-04-29 12:00:10 +04:00
u32 major , minor ;
short type ;
short access ;
struct list_head list ;
devcgroup: relax white-list protection down to RCU
Currently this list is protected with a simple spinlock, even for reading
from one. This is OK, but can be better.
Actually I want it to be better very much, since after replacing the
OpenVZ device permissions engine with the cgroup-based one I noticed, that
we set 12 default device permissions for each newly created container (for
/dev/null, full, terminals, ect devices), and people sometimes have up to
20 perms more, so traversing the ~30-40 elements list under a spinlock
doesn't seem very good.
Here's the RCU protection for white-list - dev_whitelist_item-s are added
and removed under the devcg->lock, but are looked up in permissions
checking under the rcu_read_lock.
Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Acked-by: Serge Hallyn <serue@us.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Paul Menage <menage@google.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 12:47:07 +04:00
struct rcu_head rcu ;
2008-04-29 12:00:10 +04:00
} ;
struct dev_cgroup {
struct cgroup_subsys_state css ;
2012-10-05 04:15:20 +04:00
struct list_head exceptions ;
2013-02-15 20:55:45 +04:00
enum devcg_behavior behavior ;
2008-04-29 12:00:10 +04:00
} ;
2008-06-06 09:46:24 +04:00
static inline struct dev_cgroup * css_to_devcgroup ( struct cgroup_subsys_state * s )
{
2013-08-09 04:11:23 +04:00
return s ? container_of ( s , struct dev_cgroup , css ) : NULL ;
2008-06-06 09:46:24 +04:00
}
2008-07-25 12:47:03 +04:00
static inline struct dev_cgroup * task_devcgroup ( struct task_struct * task )
{
2014-02-08 19:36:58 +04:00
return css_to_devcgroup ( task_css ( task , devices_cgrp_id ) ) ;
2008-07-25 12:47:03 +04:00
}
2008-04-29 12:00:10 +04:00
/*
2009-04-03 03:57:32 +04:00
* called under devcgroup_mutex
2008-04-29 12:00:10 +04:00
*/
2012-10-05 04:15:20 +04:00
static int dev_exceptions_copy ( struct list_head * dest , struct list_head * orig )
2008-04-29 12:00:10 +04:00
{
2012-10-05 04:15:20 +04:00
struct dev_exception_item * ex , * tmp , * new ;
2008-04-29 12:00:10 +04:00
2012-11-06 21:16:53 +04:00
lockdep_assert_held ( & devcgroup_mutex ) ;
2012-10-05 04:15:20 +04:00
list_for_each_entry ( ex , orig , list ) {
new = kmemdup ( ex , sizeof ( * ex ) , GFP_KERNEL ) ;
2008-04-29 12:00:10 +04:00
if ( ! new )
goto free_and_exit ;
list_add_tail ( & new - > list , dest ) ;
}
return 0 ;
free_and_exit :
2012-10-05 04:15:20 +04:00
list_for_each_entry_safe ( ex , tmp , dest , list ) {
list_del ( & ex - > list ) ;
kfree ( ex ) ;
2008-04-29 12:00:10 +04:00
}
return - ENOMEM ;
}
/*
2009-04-03 03:57:32 +04:00
* called under devcgroup_mutex
2008-04-29 12:00:10 +04:00
*/
2012-10-05 04:15:20 +04:00
static int dev_exception_add ( struct dev_cgroup * dev_cgroup ,
struct dev_exception_item * ex )
2008-04-29 12:00:10 +04:00
{
2012-10-05 04:15:20 +04:00
struct dev_exception_item * excopy , * walk ;
2008-04-29 12:00:10 +04:00
2012-11-06 21:16:53 +04:00
lockdep_assert_held ( & devcgroup_mutex ) ;
2012-10-05 04:15:20 +04:00
excopy = kmemdup ( ex , sizeof ( * ex ) , GFP_KERNEL ) ;
if ( ! excopy )
2008-04-29 12:00:10 +04:00
return - ENOMEM ;
2012-10-05 04:15:20 +04:00
list_for_each_entry ( walk , & dev_cgroup - > exceptions , list ) {
if ( walk - > type ! = ex - > type )
2008-06-06 09:46:28 +04:00
continue ;
2012-10-05 04:15:20 +04:00
if ( walk - > major ! = ex - > major )
2008-06-06 09:46:28 +04:00
continue ;
2012-10-05 04:15:20 +04:00
if ( walk - > minor ! = ex - > minor )
2008-06-06 09:46:28 +04:00
continue ;
2012-10-05 04:15:20 +04:00
walk - > access | = ex - > access ;
kfree ( excopy ) ;
excopy = NULL ;
2008-06-06 09:46:28 +04:00
}
2012-10-05 04:15:20 +04:00
if ( excopy ! = NULL )
list_add_tail_rcu ( & excopy - > list , & dev_cgroup - > exceptions ) ;
2008-04-29 12:00:10 +04:00
return 0 ;
}
/*
2009-04-03 03:57:32 +04:00
* called under devcgroup_mutex
2008-04-29 12:00:10 +04:00
*/
2012-10-05 04:15:20 +04:00
static void dev_exception_rm ( struct dev_cgroup * dev_cgroup ,
struct dev_exception_item * ex )
2008-04-29 12:00:10 +04:00
{
2012-10-05 04:15:20 +04:00
struct dev_exception_item * walk , * tmp ;
2008-04-29 12:00:10 +04:00
2012-11-06 21:16:53 +04:00
lockdep_assert_held ( & devcgroup_mutex ) ;
2012-10-05 04:15:20 +04:00
list_for_each_entry_safe ( walk , tmp , & dev_cgroup - > exceptions , list ) {
if ( walk - > type ! = ex - > type )
2008-04-29 12:00:10 +04:00
continue ;
2012-10-05 04:15:20 +04:00
if ( walk - > major ! = ex - > major )
2008-04-29 12:00:10 +04:00
continue ;
2012-10-05 04:15:20 +04:00
if ( walk - > minor ! = ex - > minor )
2008-04-29 12:00:10 +04:00
continue ;
2012-10-05 04:15:20 +04:00
walk - > access & = ~ ex - > access ;
2008-04-29 12:00:10 +04:00
if ( ! walk - > access ) {
devcgroup: relax white-list protection down to RCU
Currently this list is protected with a simple spinlock, even for reading
from one. This is OK, but can be better.
Actually I want it to be better very much, since after replacing the
OpenVZ device permissions engine with the cgroup-based one I noticed, that
we set 12 default device permissions for each newly created container (for
/dev/null, full, terminals, ect devices), and people sometimes have up to
20 perms more, so traversing the ~30-40 elements list under a spinlock
doesn't seem very good.
Here's the RCU protection for white-list - dev_whitelist_item-s are added
and removed under the devcg->lock, but are looked up in permissions
checking under the rcu_read_lock.
Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Acked-by: Serge Hallyn <serue@us.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Paul Menage <menage@google.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 12:47:07 +04:00
list_del_rcu ( & walk - > list ) ;
2011-03-15 13:07:57 +03:00
kfree_rcu ( walk , rcu ) ;
2008-04-29 12:00:10 +04:00
}
}
}
2013-02-22 04:41:31 +04:00
static void __dev_exception_clean ( struct dev_cgroup * dev_cgroup )
{
struct dev_exception_item * ex , * tmp ;
list_for_each_entry_safe ( ex , tmp , & dev_cgroup - > exceptions , list ) {
list_del_rcu ( & ex - > list ) ;
kfree_rcu ( ex , rcu ) ;
}
}
2012-10-05 04:15:15 +04:00
/**
2012-10-05 04:15:20 +04:00
* dev_exception_clean - frees all entries of the exception list
* @ dev_cgroup : dev_cgroup with the exception list to be cleaned
2012-10-05 04:15:15 +04:00
*
* called under devcgroup_mutex
*/
2012-10-05 04:15:20 +04:00
static void dev_exception_clean ( struct dev_cgroup * dev_cgroup )
2012-10-05 04:15:15 +04:00
{
2012-11-06 21:16:53 +04:00
lockdep_assert_held ( & devcgroup_mutex ) ;
2013-02-22 04:41:31 +04:00
__dev_exception_clean ( dev_cgroup ) ;
2012-10-05 04:15:15 +04:00
}
2013-02-15 20:55:47 +04:00
static inline bool is_devcg_online ( const struct dev_cgroup * devcg )
{
return ( devcg - > behavior ! = DEVCG_DEFAULT_NONE ) ;
}
2013-02-15 20:55:46 +04:00
/**
* devcgroup_online - initializes devcgroup ' s behavior and exceptions based on
* parent ' s
2013-08-09 04:11:23 +04:00
* @ css : css getting online
2013-02-15 20:55:46 +04:00
* returns 0 in case of success , error code otherwise
*/
2013-08-09 04:11:23 +04:00
static int devcgroup_online ( struct cgroup_subsys_state * css )
2013-02-15 20:55:46 +04:00
{
2013-08-09 04:11:23 +04:00
struct dev_cgroup * dev_cgroup = css_to_devcgroup ( css ) ;
2014-05-16 21:22:48 +04:00
struct dev_cgroup * parent_dev_cgroup = css_to_devcgroup ( css - > parent ) ;
2013-02-15 20:55:46 +04:00
int ret = 0 ;
mutex_lock ( & devcgroup_mutex ) ;
if ( parent_dev_cgroup = = NULL )
dev_cgroup - > behavior = DEVCG_DEFAULT_ALLOW ;
else {
ret = dev_exceptions_copy ( & dev_cgroup - > exceptions ,
& parent_dev_cgroup - > exceptions ) ;
if ( ! ret )
dev_cgroup - > behavior = parent_dev_cgroup - > behavior ;
}
mutex_unlock ( & devcgroup_mutex ) ;
return ret ;
}
2013-08-09 04:11:23 +04:00
static void devcgroup_offline ( struct cgroup_subsys_state * css )
2013-02-15 20:55:46 +04:00
{
2013-08-09 04:11:23 +04:00
struct dev_cgroup * dev_cgroup = css_to_devcgroup ( css ) ;
2013-02-15 20:55:46 +04:00
mutex_lock ( & devcgroup_mutex ) ;
dev_cgroup - > behavior = DEVCG_DEFAULT_NONE ;
mutex_unlock ( & devcgroup_mutex ) ;
}
2008-04-29 12:00:10 +04:00
/*
* called from kernel / cgroup . c with cgroup_lock ( ) held .
*/
2013-08-09 04:11:23 +04:00
static struct cgroup_subsys_state *
devcgroup_css_alloc ( struct cgroup_subsys_state * parent_css )
2008-04-29 12:00:10 +04:00
{
2013-02-15 20:55:46 +04:00
struct dev_cgroup * dev_cgroup ;
2008-04-29 12:00:10 +04:00
dev_cgroup = kzalloc ( sizeof ( * dev_cgroup ) , GFP_KERNEL ) ;
if ( ! dev_cgroup )
return ERR_PTR ( - ENOMEM ) ;
2012-10-05 04:15:20 +04:00
INIT_LIST_HEAD ( & dev_cgroup - > exceptions ) ;
2013-02-15 20:55:46 +04:00
dev_cgroup - > behavior = DEVCG_DEFAULT_NONE ;
2008-04-29 12:00:10 +04:00
return & dev_cgroup - > css ;
}
2013-08-09 04:11:23 +04:00
static void devcgroup_css_free ( struct cgroup_subsys_state * css )
2008-04-29 12:00:10 +04:00
{
2013-08-09 04:11:23 +04:00
struct dev_cgroup * dev_cgroup = css_to_devcgroup ( css ) ;
2008-04-29 12:00:10 +04:00
2013-02-22 04:41:31 +04:00
__dev_exception_clean ( dev_cgroup ) ;
2008-04-29 12:00:10 +04:00
kfree ( dev_cgroup ) ;
}
# define DEVCG_ALLOW 1
# define DEVCG_DENY 2
2008-04-29 12:00:14 +04:00
# define DEVCG_LIST 3
2008-07-13 23:14:02 +04:00
# define MAJMINLEN 13
2008-04-29 12:00:14 +04:00
# define ACCLEN 4
2008-04-29 12:00:10 +04:00
static void set_access ( char * acc , short access )
{
int idx = 0 ;
2008-04-29 12:00:14 +04:00
memset ( acc , 0 , ACCLEN ) ;
2008-04-29 12:00:10 +04:00
if ( access & ACC_READ )
acc [ idx + + ] = ' r ' ;
if ( access & ACC_WRITE )
acc [ idx + + ] = ' w ' ;
if ( access & ACC_MKNOD )
acc [ idx + + ] = ' m ' ;
}
static char type_to_char ( short type )
{
if ( type = = DEV_ALL )
return ' a ' ;
if ( type = = DEV_CHAR )
return ' c ' ;
if ( type = = DEV_BLOCK )
return ' b ' ;
return ' X ' ;
}
2008-04-29 12:00:14 +04:00
static void set_majmin ( char * str , unsigned m )
2008-04-29 12:00:10 +04:00
{
if ( m = = ~ 0 )
2008-07-25 12:47:08 +04:00
strcpy ( str , " * " ) ;
2008-04-29 12:00:10 +04:00
else
2008-07-25 12:47:08 +04:00
sprintf ( str , " %u " , m ) ;
2008-04-29 12:00:10 +04:00
}
2013-12-05 21:28:04 +04:00
static int devcgroup_seq_show ( struct seq_file * m , void * v )
2008-04-29 12:00:10 +04:00
{
2013-12-05 21:28:04 +04:00
struct dev_cgroup * devcgroup = css_to_devcgroup ( seq_css ( m ) ) ;
2012-10-05 04:15:20 +04:00
struct dev_exception_item * ex ;
2008-04-29 12:00:14 +04:00
char maj [ MAJMINLEN ] , min [ MAJMINLEN ] , acc [ ACCLEN ] ;
2008-04-29 12:00:10 +04:00
devcgroup: relax white-list protection down to RCU
Currently this list is protected with a simple spinlock, even for reading
from one. This is OK, but can be better.
Actually I want it to be better very much, since after replacing the
OpenVZ device permissions engine with the cgroup-based one I noticed, that
we set 12 default device permissions for each newly created container (for
/dev/null, full, terminals, ect devices), and people sometimes have up to
20 perms more, so traversing the ~30-40 elements list under a spinlock
doesn't seem very good.
Here's the RCU protection for white-list - dev_whitelist_item-s are added
and removed under the devcg->lock, but are looked up in permissions
checking under the rcu_read_lock.
Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Acked-by: Serge Hallyn <serue@us.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Paul Menage <menage@google.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 12:47:07 +04:00
rcu_read_lock ( ) ;
2012-10-05 04:15:17 +04:00
/*
* To preserve the compatibility :
* - Only show the " all devices " when the default policy is to allow
* - List the exceptions in case the default policy is to deny
* This way , the file remains as a " whitelist of devices "
*/
2012-10-26 00:37:38 +04:00
if ( devcgroup - > behavior = = DEVCG_DEFAULT_ALLOW ) {
2012-10-05 04:15:17 +04:00
set_access ( acc , ACC_MASK ) ;
set_majmin ( maj , ~ 0 ) ;
set_majmin ( min , ~ 0 ) ;
seq_printf ( m , " %c %s:%s %s \n " , type_to_char ( DEV_ALL ) ,
2008-04-29 12:00:14 +04:00
maj , min , acc ) ;
2012-10-05 04:15:17 +04:00
} else {
2012-10-05 04:15:20 +04:00
list_for_each_entry_rcu ( ex , & devcgroup - > exceptions , list ) {
set_access ( acc , ex - > access ) ;
set_majmin ( maj , ex - > major ) ;
set_majmin ( min , ex - > minor ) ;
seq_printf ( m , " %c %s:%s %s \n " , type_to_char ( ex - > type ) ,
2012-10-05 04:15:17 +04:00
maj , min , acc ) ;
}
2008-04-29 12:00:10 +04:00
}
devcgroup: relax white-list protection down to RCU
Currently this list is protected with a simple spinlock, even for reading
from one. This is OK, but can be better.
Actually I want it to be better very much, since after replacing the
OpenVZ device permissions engine with the cgroup-based one I noticed, that
we set 12 default device permissions for each newly created container (for
/dev/null, full, terminals, ect devices), and people sometimes have up to
20 perms more, so traversing the ~30-40 elements list under a spinlock
doesn't seem very good.
Here's the RCU protection for white-list - dev_whitelist_item-s are added
and removed under the devcg->lock, but are looked up in permissions
checking under the rcu_read_lock.
Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Acked-by: Serge Hallyn <serue@us.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Paul Menage <menage@google.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 12:47:07 +04:00
rcu_read_unlock ( ) ;
2008-04-29 12:00:10 +04:00
2008-04-29 12:00:14 +04:00
return 0 ;
2008-04-29 12:00:10 +04:00
}
2012-10-05 04:15:17 +04:00
/**
2014-04-24 23:33:21 +04:00
* match_exception - iterates the exception list trying to find a complete match
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
* @ exceptions : list of exceptions
* @ type : device type ( DEV_BLOCK or DEV_CHAR )
* @ major : device file major number , ~ 0 to match all
* @ minor : device file minor number , ~ 0 to match all
* @ access : permission mask ( ACC_READ , ACC_WRITE , ACC_MKNOD )
*
2014-04-24 23:33:21 +04:00
* It is considered a complete match if an exception is found that will
* contain the entire range of provided parameters .
*
* Return : true in case it matches an exception completely
2008-04-29 12:00:10 +04:00
*/
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
static bool match_exception ( struct list_head * exceptions , short type ,
u32 major , u32 minor , short access )
2008-04-29 12:00:10 +04:00
{
2012-10-05 04:15:20 +04:00
struct dev_exception_item * ex ;
2008-04-29 12:00:10 +04:00
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
list_for_each_entry_rcu ( ex , exceptions , list ) {
if ( ( type & DEV_BLOCK ) & & ! ( ex - > type & DEV_BLOCK ) )
continue ;
if ( ( type & DEV_CHAR ) & & ! ( ex - > type & DEV_CHAR ) )
continue ;
if ( ex - > major ! = ~ 0 & & ex - > major ! = major )
continue ;
if ( ex - > minor ! = ~ 0 & & ex - > minor ! = minor )
continue ;
/* provided access cannot have more than the exception rule */
if ( access & ( ~ ex - > access ) )
continue ;
return true ;
}
return false ;
}
/**
2014-04-24 23:33:21 +04:00
* match_exception_partial - iterates the exception list trying to find a partial match
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
* @ exceptions : list of exceptions
* @ type : device type ( DEV_BLOCK or DEV_CHAR )
* @ major : device file major number , ~ 0 to match all
* @ minor : device file minor number , ~ 0 to match all
* @ access : permission mask ( ACC_READ , ACC_WRITE , ACC_MKNOD )
*
2014-04-24 23:33:21 +04:00
* It is considered a partial match if an exception ' s range is found to
* contain * any * of the devices specified by provided parameters . This is
* used to make sure no extra access is being granted that is forbidden by
* any of the exception list .
*
* Return : true in case the provided range mat matches an exception completely
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
*/
static bool match_exception_partial ( struct list_head * exceptions , short type ,
u32 major , u32 minor , short access )
{
struct dev_exception_item * ex ;
2012-11-06 21:16:53 +04:00
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
list_for_each_entry_rcu ( ex , exceptions , list ) {
if ( ( type & DEV_BLOCK ) & & ! ( ex - > type & DEV_BLOCK ) )
2008-04-29 12:00:10 +04:00
continue ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
if ( ( type & DEV_CHAR ) & & ! ( ex - > type & DEV_CHAR ) )
2008-04-29 12:00:10 +04:00
continue ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
/*
* We must be sure that both the exception and the provided
* range aren ' t masking all devices
*/
if ( ex - > major ! = ~ 0 & & major ! = ~ 0 & & ex - > major ! = major )
2008-04-29 12:00:10 +04:00
continue ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
if ( ex - > minor ! = ~ 0 & & minor ! = ~ 0 & & ex - > minor ! = minor )
2008-04-29 12:00:10 +04:00
continue ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
/*
* In order to make sure the provided range isn ' t matching
* an exception , all its access bits shouldn ' t match the
* exception ' s access bits
*/
if ( ! ( access & ex - > access ) )
2008-04-29 12:00:10 +04:00
continue ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
return true ;
2008-04-29 12:00:10 +04:00
}
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
return false ;
}
/**
2014-04-24 23:33:21 +04:00
* verify_new_ex - verifies if a new exception is allowed by parent cgroup ' s permissions
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
* @ dev_cgroup : dev cgroup to be tested against
* @ refex : new exception
* @ behavior : behavior of the exception ' s dev_cgroup
2014-04-24 23:33:21 +04:00
*
* This is used to make sure a child cgroup won ' t have more privileges
* than its parent
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
*/
static bool verify_new_ex ( struct dev_cgroup * dev_cgroup ,
struct dev_exception_item * refex ,
enum devcg_behavior behavior )
{
bool match = false ;
rcu_lockdep_assert ( rcu_read_lock_held ( ) | |
lockdep_is_held ( & devcgroup_mutex ) ,
" device_cgroup:verify_new_ex called without proper synchronization " ) ;
2012-10-05 04:15:17 +04:00
2013-02-15 20:55:45 +04:00
if ( dev_cgroup - > behavior = = DEVCG_DEFAULT_ALLOW ) {
if ( behavior = = DEVCG_DEFAULT_ALLOW ) {
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
/*
* new exception in the child doesn ' t matter , only
* adding extra restrictions
*/
2013-02-15 20:55:45 +04:00
return true ;
} else {
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
/*
* new exception in the child will add more devices
* that can be acessed , so it can ' t match any of
* parent ' s exceptions , even slightly
*/
match = match_exception_partial ( & dev_cgroup - > exceptions ,
refex - > type ,
refex - > major ,
refex - > minor ,
refex - > access ) ;
2013-02-15 20:55:45 +04:00
if ( match )
return false ;
2013-02-15 20:55:44 +04:00
return true ;
2013-02-15 20:55:45 +04:00
}
2013-02-15 20:55:44 +04:00
} else {
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
/*
* Only behavior = = DEVCG_DEFAULT_DENY allowed here , therefore
* the new exception will add access to more devices and must
* be contained completely in an parent ' s exception to be
* allowed
*/
match = match_exception ( & dev_cgroup - > exceptions , refex - > type ,
refex - > major , refex - > minor ,
refex - > access ) ;
2013-02-15 20:55:45 +04:00
if ( match )
/* parent has an exception that matches the proposed */
2013-02-15 20:55:44 +04:00
return true ;
2013-02-15 20:55:45 +04:00
else
return false ;
2013-02-15 20:55:44 +04:00
}
return false ;
2008-04-29 12:00:10 +04:00
}
/*
* parent_has_perm :
2012-10-05 04:15:20 +04:00
* when adding a new allow rule to a device exception list , the rule
2008-04-29 12:00:10 +04:00
* must be allowed in the parent device
*/
2008-07-25 12:47:03 +04:00
static int parent_has_perm ( struct dev_cgroup * childcg ,
2012-10-05 04:15:20 +04:00
struct dev_exception_item * ex )
2008-04-29 12:00:10 +04:00
{
2014-05-16 21:22:48 +04:00
struct dev_cgroup * parent = css_to_devcgroup ( childcg - > css . parent ) ;
2008-04-29 12:00:10 +04:00
cgroup: add css_parent()
Currently, controllers have to explicitly follow the cgroup hierarchy
to find the parent of a given css. cgroup is moving towards using
cgroup_subsys_state as the main controller interface construct, so
let's provide a way to climb the hierarchy using just csses.
This patch implements css_parent() which, given a css, returns its
parent. The function is guarnateed to valid non-NULL parent css as
long as the target css is not at the top of the hierarchy.
freezer, cpuset, cpu, cpuacct, hugetlb, memory, net_cls and devices
are converted to use css_parent() instead of accessing cgroup->parent
directly.
* __parent_ca() is dropped from cpuacct and its usage is replaced with
parent_ca(). The only difference between the two was NULL test on
cgroup->parent which is now embedded in css_parent() making the
distinction moot. Note that eventually a css->parent field will be
added to css and the NULL check in css_parent() will go away.
This patch shouldn't cause any behavior differences.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Li Zefan <lizefan@huawei.com>
2013-08-09 04:11:23 +04:00
if ( ! parent )
2008-04-29 12:00:10 +04:00
return 1 ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
return verify_new_ex ( parent , ex , childcg - > behavior ) ;
2008-04-29 12:00:10 +04:00
}
2014-05-05 19:18:59 +04:00
/**
* parent_allows_removal - verify if it ' s ok to remove an exception
* @ childcg : child cgroup from where the exception will be removed
* @ ex : exception being removed
*
* When removing an exception in cgroups with default ALLOW policy , it must
* be checked if removing it will give the child cgroup more access than the
* parent .
*
* Return : true if it ' s ok to remove exception , false otherwise
*/
static bool parent_allows_removal ( struct dev_cgroup * childcg ,
struct dev_exception_item * ex )
{
2014-05-16 21:22:48 +04:00
struct dev_cgroup * parent = css_to_devcgroup ( childcg - > css . parent ) ;
2014-05-05 19:18:59 +04:00
if ( ! parent )
return true ;
/* It's always allowed to remove access to devices */
if ( childcg - > behavior = = DEVCG_DEFAULT_DENY )
return true ;
/*
* Make sure you ' re not removing part or a whole exception existing in
* the parent cgroup
*/
return ! match_exception_partial ( & parent - > exceptions , ex - > type ,
ex - > major , ex - > minor , ex - > access ) ;
}
2012-10-26 00:37:45 +04:00
/**
* may_allow_all - checks if it ' s possible to change the behavior to
* allow based on parent ' s rules .
* @ parent : device cgroup ' s parent
* returns : ! = 0 in case it ' s allowed , 0 otherwise
*/
static inline int may_allow_all ( struct dev_cgroup * parent )
{
2012-11-06 19:25:04 +04:00
if ( ! parent )
return 1 ;
2012-10-26 00:37:45 +04:00
return parent - > behavior = = DEVCG_DEFAULT_ALLOW ;
}
2013-02-15 20:55:47 +04:00
/**
* revalidate_active_exceptions - walks through the active exception list and
* revalidates the exceptions based on parent ' s
* behavior and exceptions . The exceptions that
* are no longer valid will be removed .
* Called with devcgroup_mutex held .
* @ devcg : cgroup which exceptions will be checked
*
* This is one of the three key functions for hierarchy implementation .
* This function is responsible for re - evaluating all the cgroup ' s active
* exceptions due to a parent ' s exception change .
* Refer to Documentation / cgroups / devices . txt for more details .
*/
static void revalidate_active_exceptions ( struct dev_cgroup * devcg )
{
struct dev_exception_item * ex ;
struct list_head * this , * tmp ;
list_for_each_safe ( this , tmp , & devcg - > exceptions ) {
ex = container_of ( this , struct dev_exception_item , list ) ;
if ( ! parent_has_perm ( devcg , ex ) )
dev_exception_rm ( devcg , ex ) ;
}
}
/**
* propagate_exception - propagates a new exception to the children
* @ devcg_root : device cgroup that added a new exception
* @ ex : new exception to be propagated
*
* returns : 0 in case of success , ! = 0 in case of error
*/
static int propagate_exception ( struct dev_cgroup * devcg_root ,
struct dev_exception_item * ex )
{
2013-08-09 04:11:25 +04:00
struct cgroup_subsys_state * pos ;
2013-02-15 20:55:47 +04:00
int rc = 0 ;
2013-05-24 05:55:38 +04:00
rcu_read_lock ( ) ;
2013-02-15 20:55:47 +04:00
2013-08-09 04:11:25 +04:00
css_for_each_descendant_pre ( pos , & devcg_root - > css ) {
struct dev_cgroup * devcg = css_to_devcgroup ( pos ) ;
2013-05-24 05:55:38 +04:00
/*
* Because devcgroup_mutex is held , no devcg will become
* online or offline during the tree walk ( see on / offline
* methods ) , and online ones are safe to access outside RCU
* read lock without bumping refcnt .
*/
2013-08-09 04:11:27 +04:00
if ( pos = = & devcg_root - > css | | ! is_devcg_online ( devcg ) )
2013-05-24 05:55:38 +04:00
continue ;
rcu_read_unlock ( ) ;
2013-02-15 20:55:47 +04:00
/*
* in case both root ' s behavior and devcg is allow , a new
* restriction means adding to the exception list
*/
if ( devcg_root - > behavior = = DEVCG_DEFAULT_ALLOW & &
devcg - > behavior = = DEVCG_DEFAULT_ALLOW ) {
rc = dev_exception_add ( devcg , ex ) ;
if ( rc )
break ;
} else {
/*
* in the other possible cases :
* root ' s behavior : allow , devcg ' s : deny
* root ' s behavior : deny , devcg ' s : deny
* the exception will be removed
*/
dev_exception_rm ( devcg , ex ) ;
}
revalidate_active_exceptions ( devcg ) ;
2013-05-24 05:55:38 +04:00
rcu_read_lock ( ) ;
2013-02-15 20:55:47 +04:00
}
2013-05-24 05:55:38 +04:00
rcu_read_unlock ( ) ;
2013-02-15 20:55:47 +04:00
return rc ;
}
2008-04-29 12:00:10 +04:00
/*
2012-10-05 04:15:20 +04:00
* Modify the exception list using allow / deny rules .
2008-04-29 12:00:10 +04:00
* CAP_SYS_ADMIN is needed for this . It ' s at least separate from CAP_MKNOD
* so we can give a container CAP_MKNOD to let it create devices but not
2012-10-05 04:15:20 +04:00
* modify the exception list .
2008-04-29 12:00:10 +04:00
* It seems likely we ' ll want to add a CAP_CONTAINER capability to allow
* us to also grant CAP_SYS_ADMIN to containers without giving away the
2012-10-05 04:15:20 +04:00
* device exception list controls , but for now we ' ll stick with CAP_SYS_ADMIN
2008-04-29 12:00:10 +04:00
*
* Taking rules away is always allowed ( given CAP_SYS_ADMIN ) . Granting
* new access is only allowed if you ' re in the top - level cgroup , or your
* parent cgroup has the access you ' re asking for .
*/
2008-07-25 12:47:03 +04:00
static int devcgroup_update_access ( struct dev_cgroup * devcgroup ,
2014-03-19 18:23:54 +04:00
int filetype , char * buffer )
2008-04-29 12:00:10 +04:00
{
2008-07-25 12:47:03 +04:00
const char * b ;
2012-10-26 00:37:41 +04:00
char temp [ 12 ] ; /* 11 + 1 characters needed for a u32 */
2013-02-15 20:55:45 +04:00
int count , rc = 0 ;
2012-10-05 04:15:20 +04:00
struct dev_exception_item ex ;
2014-05-16 21:22:48 +04:00
struct dev_cgroup * parent = css_to_devcgroup ( devcgroup - > css . parent ) ;
2008-04-29 12:00:10 +04:00
if ( ! capable ( CAP_SYS_ADMIN ) )
return - EPERM ;
2012-10-05 04:15:20 +04:00
memset ( & ex , 0 , sizeof ( ex ) ) ;
2008-04-29 12:00:10 +04:00
b = buffer ;
switch ( * b ) {
case ' a ' :
2012-10-05 04:15:17 +04:00
switch ( filetype ) {
case DEVCG_ALLOW :
2014-05-16 21:22:52 +04:00
if ( css_has_online_children ( & devcgroup - > css ) )
2013-02-15 20:55:47 +04:00
return - EINVAL ;
2012-10-26 00:37:45 +04:00
if ( ! may_allow_all ( parent ) )
2012-10-05 04:15:17 +04:00
return - EPERM ;
2012-10-05 04:15:20 +04:00
dev_exception_clean ( devcgroup ) ;
2012-11-06 19:25:04 +04:00
devcgroup - > behavior = DEVCG_DEFAULT_ALLOW ;
if ( ! parent )
break ;
2012-10-26 00:37:45 +04:00
rc = dev_exceptions_copy ( & devcgroup - > exceptions ,
& parent - > exceptions ) ;
if ( rc )
return rc ;
2012-10-05 04:15:17 +04:00
break ;
case DEVCG_DENY :
2014-05-16 21:22:52 +04:00
if ( css_has_online_children ( & devcgroup - > css ) )
2013-02-15 20:55:47 +04:00
return - EINVAL ;
2012-10-05 04:15:20 +04:00
dev_exception_clean ( devcgroup ) ;
2012-10-26 00:37:38 +04:00
devcgroup - > behavior = DEVCG_DEFAULT_DENY ;
2012-10-05 04:15:17 +04:00
break ;
default :
return - EINVAL ;
}
return 0 ;
2008-04-29 12:00:10 +04:00
case ' b ' :
2012-10-05 04:15:20 +04:00
ex . type = DEV_BLOCK ;
2008-04-29 12:00:10 +04:00
break ;
case ' c ' :
2012-10-05 04:15:20 +04:00
ex . type = DEV_CHAR ;
2008-04-29 12:00:10 +04:00
break ;
default :
2008-07-25 12:47:03 +04:00
return - EINVAL ;
2008-04-29 12:00:10 +04:00
}
b + + ;
2008-07-25 12:47:03 +04:00
if ( ! isspace ( * b ) )
return - EINVAL ;
2008-04-29 12:00:10 +04:00
b + + ;
if ( * b = = ' * ' ) {
2012-10-05 04:15:20 +04:00
ex . major = ~ 0 ;
2008-04-29 12:00:10 +04:00
b + + ;
} else if ( isdigit ( * b ) ) {
2012-10-26 00:37:41 +04:00
memset ( temp , 0 , sizeof ( temp ) ) ;
for ( count = 0 ; count < sizeof ( temp ) - 1 ; count + + ) {
temp [ count ] = * b ;
b + + ;
if ( ! isdigit ( * b ) )
break ;
}
rc = kstrtou32 ( temp , 10 , & ex . major ) ;
if ( rc )
return - EINVAL ;
2008-04-29 12:00:10 +04:00
} else {
2008-07-25 12:47:03 +04:00
return - EINVAL ;
2008-04-29 12:00:10 +04:00
}
2008-07-25 12:47:03 +04:00
if ( * b ! = ' : ' )
return - EINVAL ;
2008-04-29 12:00:10 +04:00
b + + ;
/* read minor */
if ( * b = = ' * ' ) {
2012-10-05 04:15:20 +04:00
ex . minor = ~ 0 ;
2008-04-29 12:00:10 +04:00
b + + ;
} else if ( isdigit ( * b ) ) {
2012-10-26 00:37:41 +04:00
memset ( temp , 0 , sizeof ( temp ) ) ;
for ( count = 0 ; count < sizeof ( temp ) - 1 ; count + + ) {
temp [ count ] = * b ;
b + + ;
if ( ! isdigit ( * b ) )
break ;
}
rc = kstrtou32 ( temp , 10 , & ex . minor ) ;
if ( rc )
return - EINVAL ;
2008-04-29 12:00:10 +04:00
} else {
2008-07-25 12:47:03 +04:00
return - EINVAL ;
2008-04-29 12:00:10 +04:00
}
2008-07-25 12:47:03 +04:00
if ( ! isspace ( * b ) )
return - EINVAL ;
2008-04-29 12:00:10 +04:00
for ( b + + , count = 0 ; count < 3 ; count + + , b + + ) {
switch ( * b ) {
case ' r ' :
2012-10-05 04:15:20 +04:00
ex . access | = ACC_READ ;
2008-04-29 12:00:10 +04:00
break ;
case ' w ' :
2012-10-05 04:15:20 +04:00
ex . access | = ACC_WRITE ;
2008-04-29 12:00:10 +04:00
break ;
case ' m ' :
2012-10-05 04:15:20 +04:00
ex . access | = ACC_MKNOD ;
2008-04-29 12:00:10 +04:00
break ;
case ' \n ' :
case ' \0 ' :
count = 3 ;
break ;
default :
2008-07-25 12:47:03 +04:00
return - EINVAL ;
2008-04-29 12:00:10 +04:00
}
}
switch ( filetype ) {
case DEVCG_ALLOW :
2012-10-05 04:15:17 +04:00
/*
* If the default policy is to allow by default , try to remove
* an matching exception instead . And be silent about it : we
* don ' t want to break compatibility
*/
2012-10-26 00:37:38 +04:00
if ( devcgroup - > behavior = = DEVCG_DEFAULT_ALLOW ) {
2014-05-05 19:18:59 +04:00
/* Check if the parent allows removing it first */
if ( ! parent_allows_removal ( devcgroup , & ex ) )
return - EPERM ;
2012-10-05 04:15:20 +04:00
dev_exception_rm ( devcgroup , & ex ) ;
2014-05-05 19:18:59 +04:00
break ;
2012-10-05 04:15:17 +04:00
}
2014-05-05 19:18:59 +04:00
if ( ! parent_has_perm ( devcgroup , & ex ) )
return - EPERM ;
2013-02-15 20:55:47 +04:00
rc = dev_exception_add ( devcgroup , & ex ) ;
break ;
2008-04-29 12:00:10 +04:00
case DEVCG_DENY :
2012-10-05 04:15:17 +04:00
/*
* If the default policy is to deny by default , try to remove
* an matching exception instead . And be silent about it : we
* don ' t want to break compatibility
*/
2013-02-15 20:55:47 +04:00
if ( devcgroup - > behavior = = DEVCG_DEFAULT_DENY )
2012-10-05 04:15:20 +04:00
dev_exception_rm ( devcgroup , & ex ) ;
2013-02-15 20:55:47 +04:00
else
rc = dev_exception_add ( devcgroup , & ex ) ;
if ( rc )
break ;
/* we only propagate new restrictions */
rc = propagate_exception ( devcgroup , & ex ) ;
break ;
2008-04-29 12:00:10 +04:00
default :
2013-02-15 20:55:47 +04:00
rc = - EINVAL ;
2008-04-29 12:00:10 +04:00
}
2013-02-15 20:55:47 +04:00
return rc ;
2008-07-25 12:47:03 +04:00
}
2008-04-29 12:00:10 +04:00
2014-05-13 20:16:21 +04:00
static ssize_t devcgroup_access_write ( struct kernfs_open_file * of ,
char * buf , size_t nbytes , loff_t off )
2008-07-25 12:47:03 +04:00
{
int retval ;
2009-04-03 03:57:32 +04:00
mutex_lock ( & devcgroup_mutex ) ;
2014-05-13 20:16:21 +04:00
retval = devcgroup_update_access ( css_to_devcgroup ( of_css ( of ) ) ,
of_cft ( of ) - > private , strstrip ( buf ) ) ;
2009-04-03 03:57:32 +04:00
mutex_unlock ( & devcgroup_mutex ) ;
2014-05-13 20:16:21 +04:00
return retval ? : nbytes ;
2008-04-29 12:00:10 +04:00
}
static struct cftype dev_cgroup_files [ ] = {
{
. name = " allow " ,
2014-05-13 20:16:21 +04:00
. write = devcgroup_access_write ,
2008-04-29 12:00:10 +04:00
. private = DEVCG_ALLOW ,
} ,
{
. name = " deny " ,
2014-05-13 20:16:21 +04:00
. write = devcgroup_access_write ,
2008-04-29 12:00:10 +04:00
. private = DEVCG_DENY ,
} ,
2008-04-29 12:00:14 +04:00
{
. name = " list " ,
2013-12-05 21:28:04 +04:00
. seq_show = devcgroup_seq_show ,
2008-04-29 12:00:14 +04:00
. private = DEVCG_LIST ,
} ,
2012-04-01 23:09:55 +04:00
{ } /* terminate */
2008-04-29 12:00:10 +04:00
} ;
2014-02-08 19:36:58 +04:00
struct cgroup_subsys devices_cgrp_subsys = {
2012-11-19 20:13:38 +04:00
. css_alloc = devcgroup_css_alloc ,
. css_free = devcgroup_css_free ,
2013-02-15 20:55:46 +04:00
. css_online = devcgroup_online ,
. css_offline = devcgroup_offline ,
2012-04-01 23:09:55 +04:00
. base_cftypes = dev_cgroup_files ,
2008-04-29 12:00:10 +04:00
} ;
2012-10-05 04:15:17 +04:00
/**
* __devcgroup_check_permission - checks if an inode operation is permitted
* @ dev_cgroup : the dev cgroup to be tested against
* @ type : device type
* @ major : device major number
* @ minor : device minor number
* @ access : combination of ACC_WRITE , ACC_READ and ACC_MKNOD
*
* returns 0 on success , - EPERM case the operation is not permitted
*/
2012-10-26 00:37:34 +04:00
static int __devcgroup_check_permission ( short type , u32 major , u32 minor ,
2012-10-05 04:15:17 +04:00
short access )
2008-04-29 12:00:10 +04:00
{
2012-10-26 00:37:34 +04:00
struct dev_cgroup * dev_cgroup ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
bool rc ;
2008-09-03 01:35:52 +04:00
2012-10-05 04:15:17 +04:00
rcu_read_lock ( ) ;
2012-10-26 00:37:34 +04:00
dev_cgroup = task_devcgroup ( current ) ;
device_cgroup: rework device access check and exception checking
Whenever a device file is opened and checked against current device
cgroup rules, it uses the same function (may_access()) as when a new
exception rule is added by writing devices.{allow,deny}. And in both
cases, the algorithm is the same, doesn't matter the behavior.
First problem is having device access to be considered the same as rule
checking. Consider the following structure:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: allow, exceptions disallow access)
A new exception is added to B by writing devices.deny:
c 12:34 rw
When checking if that exception is allowed in may_access():
if (dev_cgroup->behavior == DEVCG_DEFAULT_ALLOW) {
if (behavior == DEVCG_DEFAULT_ALLOW) {
/* the exception will deny access to certain devices */
return true;
Which is ok, since B is not getting more privileges than A, it doesn't
matter and the rule is accepted
Now, consider it's a device file open check and the process belongs to
cgroup B. The access will be generated as:
behavior: allow
exception: c 12:34 rw
The very same chunk of code will allow it, even if there's an explicit
exception telling to do otherwise.
A simple test case:
# mkdir new_group
# cd new_group
# echo $$ >tasks
# echo "c 1:3 w" >devices.deny
# echo >/dev/null
# echo $?
0
This is a serious bug and was introduced on
c39a2a3018f8 devcg: prepare may_access() for hierarchy support
To solve this problem, the device file open function was split from the
new exception check.
Second problem is how exceptions are processed by may_access(). The
first part of the said function tries to match fully with an existing
exception:
list_for_each_entry_rcu(ex, &dev_cgroup->exceptions, list) {
if ((refex->type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
continue;
if ((refex->type & DEV_CHAR) && !(ex->type & DEV_CHAR))
continue;
if (ex->major != ~0 && ex->major != refex->major)
continue;
if (ex->minor != ~0 && ex->minor != refex->minor)
continue;
if (refex->access & (~ex->access))
continue;
match = true;
break;
}
That means the new exception should be contained into an existing one to
be considered a match:
New exception Existing match? notes
b 12:34 rwm b 12:34 rwm yes
b 12:34 r b *:34 rw yes
b 12:34 rw b 12:34 w no extra "r"
b *:34 rw b 12:34 rw no too broad "*"
b *:34 rw b *:34 rwm yes
Which is fine in some cases. Consider:
A (default behavior: deny, exceptions allow access)
\
B (default behavior: deny, exceptions allow access)
In this case the full match makes sense, the new exception cannot add
more access than the parent allows
But this doesn't always work, consider:
A (default behavior: allow, exceptions disallow access)
\
B (default behavior: deny, exceptions allow access)
In this case, a new exception in B shouldn't match any of the exceptions
in A, after all you can't allow something that was forbidden by A. But
consider this scenario:
New exception Existing in A match? outcome
b 12:34 rw b 12:34 r no exception is accepted
Because the new exception has "w" as extra, it doesn't match, so it'll
be added to B's exception list.
The same problem can happen during a file access check. Consider a
cgroup with allow as default behavior:
Access Exception match?
b 12:34 rw b 12:34 r no
In this case, the access didn't match any of the exceptions in the
cgroup, which is required since exceptions will disallow access.
To solve this problem, two new functions were created to match an
exception either fully or partially. In the example above, a partial
check will be performed and it'll produce a match since at least
"b 12:34 r" from "b 12:34 rw" access matches.
Cc: cgroups@vger.kernel.org
Cc: Tejun Heo <tj@kernel.org>
Cc: Serge Hallyn <serge.hallyn@canonical.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: stable@vger.kernel.org
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-04-21 20:13:03 +04:00
if ( dev_cgroup - > behavior = = DEVCG_DEFAULT_ALLOW )
/* Can't match any of the exceptions, even partially */
rc = ! match_exception_partial ( & dev_cgroup - > exceptions ,
type , major , minor , access ) ;
else
/* Need to match completely one exception to be allowed */
rc = match_exception ( & dev_cgroup - > exceptions , type , major ,
minor , access ) ;
2012-10-05 04:15:17 +04:00
rcu_read_unlock ( ) ;
2009-06-18 03:26:33 +04:00
2012-10-05 04:15:17 +04:00
if ( ! rc )
return - EPERM ;
2008-09-03 01:35:52 +04:00
2012-10-05 04:15:17 +04:00
return 0 ;
}
2008-04-29 12:00:10 +04:00
2012-10-05 04:15:17 +04:00
int __devcgroup_inode_permission ( struct inode * inode , int mask )
{
short type , access = 0 ;
if ( S_ISBLK ( inode - > i_mode ) )
type = DEV_BLOCK ;
if ( S_ISCHR ( inode - > i_mode ) )
type = DEV_CHAR ;
if ( mask & MAY_WRITE )
access | = ACC_WRITE ;
if ( mask & MAY_READ )
access | = ACC_READ ;
2012-10-26 00:37:34 +04:00
return __devcgroup_check_permission ( type , imajor ( inode ) , iminor ( inode ) ,
access ) ;
2008-04-29 12:00:10 +04:00
}
int devcgroup_inode_mknod ( int mode , dev_t dev )
{
2012-10-05 04:15:17 +04:00
short type ;
2008-04-29 12:00:10 +04:00
2009-01-08 05:07:46 +03:00
if ( ! S_ISBLK ( mode ) & & ! S_ISCHR ( mode ) )
return 0 ;
2012-10-05 04:15:17 +04:00
if ( S_ISBLK ( mode ) )
type = DEV_BLOCK ;
else
type = DEV_CHAR ;
2008-09-03 01:35:52 +04:00
2012-10-26 00:37:34 +04:00
return __devcgroup_check_permission ( type , MAJOR ( dev ) , MINOR ( dev ) ,
ACC_MKNOD ) ;
2008-09-03 01:35:52 +04:00
2008-04-29 12:00:10 +04:00
}