2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Implementation of the kernel access vector cache (AVC).
|
|
|
|
*
|
2017-08-18 00:32:36 +07:00
|
|
|
* Authors: Stephen Smalley, <sds@tycho.nsa.gov>
|
2008-04-18 01:42:10 +07:00
|
|
|
* James Morris <jmorris@redhat.com>
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Update: KaiGai, Kohei <kaigai@ak.jp.nec.com>
|
2008-04-18 01:42:10 +07:00
|
|
|
* Replaced the avc_lock spinlock by RCU.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2,
|
2008-04-18 01:42:10 +07:00
|
|
|
* as published by the Free Software Foundation.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/dcache.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/percpu.h>
|
2015-07-11 04:19:56 +07:00
|
|
|
#include <linux/list.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <net/sock.h>
|
|
|
|
#include <linux/un.h>
|
|
|
|
#include <net/af_unix.h>
|
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/audit.h>
|
|
|
|
#include <linux/ipv6.h>
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include "avc.h"
|
|
|
|
#include "avc_ss.h"
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
#include "classmap.h"
|
2006-11-07 00:38:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define AVC_CACHE_SLOTS 512
|
|
|
|
#define AVC_DEF_CACHE_THRESHOLD 512
|
|
|
|
#define AVC_CACHE_RECLAIM 16
|
|
|
|
|
|
|
|
#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
|
2011-05-20 08:59:47 +07:00
|
|
|
#define avc_cache_stats_incr(field) this_cpu_inc(avc_cache_stats.field)
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
|
|
|
#define avc_cache_stats_incr(field) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct avc_entry {
|
|
|
|
u32 ssid;
|
|
|
|
u32 tsid;
|
|
|
|
u16 tclass;
|
|
|
|
struct av_decision avd;
|
2015-07-11 04:19:56 +07:00
|
|
|
struct avc_xperms_node *xp_node;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct avc_node {
|
|
|
|
struct avc_entry ae;
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_node list; /* anchored in avc_cache->slots[i] */
|
2008-04-18 01:42:10 +07:00
|
|
|
struct rcu_head rhead;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2015-07-11 04:19:56 +07:00
|
|
|
struct avc_xperms_decision_node {
|
|
|
|
struct extended_perms_decision xpd;
|
|
|
|
struct list_head xpd_list; /* list of extended_perms_decision */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct avc_xperms_node {
|
|
|
|
struct extended_perms xp;
|
|
|
|
struct list_head xpd_head; /* list head of extended_perms_decision */
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
struct avc_cache {
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head slots[AVC_CACHE_SLOTS]; /* head for avc_node->list */
|
2005-04-17 05:20:36 +07:00
|
|
|
spinlock_t slots_lock[AVC_CACHE_SLOTS]; /* lock for writes */
|
|
|
|
atomic_t lru_hint; /* LRU hint for reclaim scan */
|
|
|
|
atomic_t active_nodes;
|
|
|
|
u32 latest_notif; /* latest revocation notification */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct avc_callback_node {
|
2012-03-07 21:17:14 +07:00
|
|
|
int (*callback) (u32 event);
|
2005-04-17 05:20:36 +07:00
|
|
|
u32 events;
|
|
|
|
struct avc_callback_node *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
|
|
|
|
DEFINE_PER_CPU(struct avc_cache_stats, avc_cache_stats) = { 0 };
|
|
|
|
#endif
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
struct selinux_avc {
|
|
|
|
unsigned int avc_cache_threshold;
|
|
|
|
struct avc_cache avc_cache;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct selinux_avc selinux_avc;
|
|
|
|
|
|
|
|
void selinux_avc_init(struct selinux_avc **avc)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
selinux_avc.avc_cache_threshold = AVC_DEF_CACHE_THRESHOLD;
|
|
|
|
for (i = 0; i < AVC_CACHE_SLOTS; i++) {
|
|
|
|
INIT_HLIST_HEAD(&selinux_avc.avc_cache.slots[i]);
|
|
|
|
spin_lock_init(&selinux_avc.avc_cache.slots_lock[i]);
|
|
|
|
}
|
|
|
|
atomic_set(&selinux_avc.avc_cache.active_nodes, 0);
|
|
|
|
atomic_set(&selinux_avc.avc_cache.lru_hint, 0);
|
|
|
|
*avc = &selinux_avc;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int avc_get_cache_threshold(struct selinux_avc *avc)
|
|
|
|
{
|
|
|
|
return avc->avc_cache_threshold;
|
|
|
|
}
|
|
|
|
|
|
|
|
void avc_set_cache_threshold(struct selinux_avc *avc,
|
|
|
|
unsigned int cache_threshold)
|
|
|
|
{
|
|
|
|
avc->avc_cache_threshold = cache_threshold;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static struct avc_callback_node *avc_callbacks;
|
2006-12-07 11:33:20 +07:00
|
|
|
static struct kmem_cache *avc_node_cachep;
|
2015-07-11 04:19:56 +07:00
|
|
|
static struct kmem_cache *avc_xperms_data_cachep;
|
|
|
|
static struct kmem_cache *avc_xperms_decision_cachep;
|
|
|
|
static struct kmem_cache *avc_xperms_cachep;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static inline int avc_hash(u32 ssid, u32 tsid, u16 tclass)
|
|
|
|
{
|
|
|
|
return (ssid ^ (tsid<<2) ^ (tclass<<4)) & (AVC_CACHE_SLOTS - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_dump_av - Display an access vector in human-readable form.
|
|
|
|
* @tclass: target security class
|
|
|
|
* @av: access vector
|
|
|
|
*/
|
2009-06-18 15:26:13 +07:00
|
|
|
static void avc_dump_av(struct audit_buffer *ab, u16 tclass, u32 av)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
const char **perms;
|
|
|
|
int i, perm;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (av == 0) {
|
|
|
|
audit_log_format(ab, " null");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-07-11 04:19:57 +07:00
|
|
|
BUG_ON(!tclass || tclass >= ARRAY_SIZE(secclass_map));
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
perms = secclass_map[tclass-1].perms;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
audit_log_format(ab, " {");
|
|
|
|
i = 0;
|
|
|
|
perm = 1;
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
while (i < (sizeof(av) * 8)) {
|
2009-11-24 04:47:23 +07:00
|
|
|
if ((perm & av) && perms[i]) {
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
audit_log_format(ab, " %s", perms[i]);
|
2005-04-17 05:20:36 +07:00
|
|
|
av &= ~perm;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
perm <<= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (av)
|
|
|
|
audit_log_format(ab, " 0x%x", av);
|
|
|
|
|
|
|
|
audit_log_format(ab, " }");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_dump_query - Display a SID pair and a class in human-readable form.
|
|
|
|
* @ssid: source security identifier
|
|
|
|
* @tsid: target security identifier
|
|
|
|
* @tclass: target security class
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static void avc_dump_query(struct audit_buffer *ab, struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
char *scontext;
|
|
|
|
u32 scontext_len;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = security_sid_to_context(state, ssid, &scontext, &scontext_len);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc)
|
|
|
|
audit_log_format(ab, "ssid=%d", ssid);
|
|
|
|
else {
|
|
|
|
audit_log_format(ab, "scontext=%s", scontext);
|
|
|
|
kfree(scontext);
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = security_sid_to_context(state, tsid, &scontext, &scontext_len);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc)
|
|
|
|
audit_log_format(ab, " tsid=%d", tsid);
|
|
|
|
else {
|
|
|
|
audit_log_format(ab, " tcontext=%s", scontext);
|
|
|
|
kfree(scontext);
|
|
|
|
}
|
2007-03-27 00:36:26 +07:00
|
|
|
|
2015-07-11 04:19:57 +07:00
|
|
|
BUG_ON(!tclass || tclass >= ARRAY_SIZE(secclass_map));
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-10-01 00:37:50 +07:00
|
|
|
audit_log_format(ab, " tclass=%s", secclass_map[tclass-1].name);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_init - Initialize the AVC.
|
|
|
|
*
|
|
|
|
* Initialize the access vector cache.
|
|
|
|
*/
|
|
|
|
void __init avc_init(void)
|
|
|
|
{
|
|
|
|
avc_node_cachep = kmem_cache_create("avc_node", sizeof(struct avc_node),
|
2015-07-11 04:19:56 +07:00
|
|
|
0, SLAB_PANIC, NULL);
|
|
|
|
avc_xperms_cachep = kmem_cache_create("avc_xperms_node",
|
|
|
|
sizeof(struct avc_xperms_node),
|
|
|
|
0, SLAB_PANIC, NULL);
|
|
|
|
avc_xperms_decision_cachep = kmem_cache_create(
|
|
|
|
"avc_xperms_decision_node",
|
|
|
|
sizeof(struct avc_xperms_decision_node),
|
|
|
|
0, SLAB_PANIC, NULL);
|
|
|
|
avc_xperms_data_cachep = kmem_cache_create("avc_xperms_data",
|
|
|
|
sizeof(struct extended_perms_data),
|
|
|
|
0, SLAB_PANIC, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
int avc_get_hash_stats(struct selinux_avc *avc, char *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int i, chain_len, max_chain_len, slots_used;
|
|
|
|
struct avc_node *node;
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
slots_used = 0;
|
|
|
|
max_chain_len = 0;
|
|
|
|
for (i = 0; i < AVC_CACHE_SLOTS; i++) {
|
2018-03-05 23:47:56 +07:00
|
|
|
head = &avc->avc_cache.slots[i];
|
2009-02-13 02:51:04 +07:00
|
|
|
if (!hlist_empty(head)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
slots_used++;
|
|
|
|
chain_len = 0;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry_rcu(node, head, list)
|
2005-04-17 05:20:36 +07:00
|
|
|
chain_len++;
|
|
|
|
if (chain_len > max_chain_len)
|
|
|
|
max_chain_len = chain_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return scnprintf(page, PAGE_SIZE, "entries: %d\nbuckets used: %d/%d\n"
|
|
|
|
"longest chain: %d\n",
|
2018-03-05 23:47:56 +07:00
|
|
|
atomic_read(&avc->avc_cache.active_nodes),
|
2005-04-17 05:20:36 +07:00
|
|
|
slots_used, AVC_CACHE_SLOTS, max_chain_len);
|
|
|
|
}
|
|
|
|
|
2015-07-11 04:19:56 +07:00
|
|
|
/*
|
|
|
|
* using a linked list for extended_perms_decision lookup because the list is
|
|
|
|
* always small. i.e. less than 5, typically 1
|
|
|
|
*/
|
|
|
|
static struct extended_perms_decision *avc_xperms_decision_lookup(u8 driver,
|
|
|
|
struct avc_xperms_node *xp_node)
|
|
|
|
{
|
|
|
|
struct avc_xperms_decision_node *xpd_node;
|
|
|
|
|
|
|
|
list_for_each_entry(xpd_node, &xp_node->xpd_head, xpd_list) {
|
|
|
|
if (xpd_node->xpd.driver == driver)
|
|
|
|
return &xpd_node->xpd;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int
|
|
|
|
avc_xperms_has_perm(struct extended_perms_decision *xpd,
|
|
|
|
u8 perm, u8 which)
|
|
|
|
{
|
|
|
|
unsigned int rc = 0;
|
|
|
|
|
|
|
|
if ((which == XPERMS_ALLOWED) &&
|
|
|
|
(xpd->used & XPERMS_ALLOWED))
|
|
|
|
rc = security_xperm_test(xpd->allowed->p, perm);
|
|
|
|
else if ((which == XPERMS_AUDITALLOW) &&
|
|
|
|
(xpd->used & XPERMS_AUDITALLOW))
|
|
|
|
rc = security_xperm_test(xpd->auditallow->p, perm);
|
|
|
|
else if ((which == XPERMS_DONTAUDIT) &&
|
|
|
|
(xpd->used & XPERMS_DONTAUDIT))
|
|
|
|
rc = security_xperm_test(xpd->dontaudit->p, perm);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void avc_xperms_allow_perm(struct avc_xperms_node *xp_node,
|
|
|
|
u8 driver, u8 perm)
|
|
|
|
{
|
|
|
|
struct extended_perms_decision *xpd;
|
|
|
|
security_xperm_set(xp_node->xp.drivers.p, driver);
|
|
|
|
xpd = avc_xperms_decision_lookup(driver, xp_node);
|
|
|
|
if (xpd && xpd->allowed)
|
|
|
|
security_xperm_set(xpd->allowed->p, perm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void avc_xperms_decision_free(struct avc_xperms_decision_node *xpd_node)
|
|
|
|
{
|
|
|
|
struct extended_perms_decision *xpd;
|
|
|
|
|
|
|
|
xpd = &xpd_node->xpd;
|
|
|
|
if (xpd->allowed)
|
|
|
|
kmem_cache_free(avc_xperms_data_cachep, xpd->allowed);
|
|
|
|
if (xpd->auditallow)
|
|
|
|
kmem_cache_free(avc_xperms_data_cachep, xpd->auditallow);
|
|
|
|
if (xpd->dontaudit)
|
|
|
|
kmem_cache_free(avc_xperms_data_cachep, xpd->dontaudit);
|
|
|
|
kmem_cache_free(avc_xperms_decision_cachep, xpd_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void avc_xperms_free(struct avc_xperms_node *xp_node)
|
|
|
|
{
|
|
|
|
struct avc_xperms_decision_node *xpd_node, *tmp;
|
|
|
|
|
|
|
|
if (!xp_node)
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(xpd_node, tmp, &xp_node->xpd_head, xpd_list) {
|
|
|
|
list_del(&xpd_node->xpd_list);
|
|
|
|
avc_xperms_decision_free(xpd_node);
|
|
|
|
}
|
|
|
|
kmem_cache_free(avc_xperms_cachep, xp_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void avc_copy_xperms_decision(struct extended_perms_decision *dest,
|
|
|
|
struct extended_perms_decision *src)
|
|
|
|
{
|
|
|
|
dest->driver = src->driver;
|
|
|
|
dest->used = src->used;
|
|
|
|
if (dest->used & XPERMS_ALLOWED)
|
|
|
|
memcpy(dest->allowed->p, src->allowed->p,
|
|
|
|
sizeof(src->allowed->p));
|
|
|
|
if (dest->used & XPERMS_AUDITALLOW)
|
|
|
|
memcpy(dest->auditallow->p, src->auditallow->p,
|
|
|
|
sizeof(src->auditallow->p));
|
|
|
|
if (dest->used & XPERMS_DONTAUDIT)
|
|
|
|
memcpy(dest->dontaudit->p, src->dontaudit->p,
|
|
|
|
sizeof(src->dontaudit->p));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* similar to avc_copy_xperms_decision, but only copy decision
|
|
|
|
* information relevant to this perm
|
|
|
|
*/
|
|
|
|
static inline void avc_quick_copy_xperms_decision(u8 perm,
|
|
|
|
struct extended_perms_decision *dest,
|
|
|
|
struct extended_perms_decision *src)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* compute index of the u32 of the 256 bits (8 u32s) that contain this
|
|
|
|
* command permission
|
|
|
|
*/
|
|
|
|
u8 i = perm >> 5;
|
|
|
|
|
|
|
|
dest->used = src->used;
|
|
|
|
if (dest->used & XPERMS_ALLOWED)
|
|
|
|
dest->allowed->p[i] = src->allowed->p[i];
|
|
|
|
if (dest->used & XPERMS_AUDITALLOW)
|
|
|
|
dest->auditallow->p[i] = src->auditallow->p[i];
|
|
|
|
if (dest->used & XPERMS_DONTAUDIT)
|
|
|
|
dest->dontaudit->p[i] = src->dontaudit->p[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct avc_xperms_decision_node
|
|
|
|
*avc_xperms_decision_alloc(u8 which)
|
|
|
|
{
|
|
|
|
struct avc_xperms_decision_node *xpd_node;
|
|
|
|
struct extended_perms_decision *xpd;
|
|
|
|
|
2017-08-03 15:11:52 +07:00
|
|
|
xpd_node = kmem_cache_zalloc(avc_xperms_decision_cachep, GFP_NOWAIT);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (!xpd_node)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
xpd = &xpd_node->xpd;
|
|
|
|
if (which & XPERMS_ALLOWED) {
|
|
|
|
xpd->allowed = kmem_cache_zalloc(avc_xperms_data_cachep,
|
2017-08-03 15:11:52 +07:00
|
|
|
GFP_NOWAIT);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (!xpd->allowed)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (which & XPERMS_AUDITALLOW) {
|
|
|
|
xpd->auditallow = kmem_cache_zalloc(avc_xperms_data_cachep,
|
2017-08-03 15:11:52 +07:00
|
|
|
GFP_NOWAIT);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (!xpd->auditallow)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (which & XPERMS_DONTAUDIT) {
|
|
|
|
xpd->dontaudit = kmem_cache_zalloc(avc_xperms_data_cachep,
|
2017-08-03 15:11:52 +07:00
|
|
|
GFP_NOWAIT);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (!xpd->dontaudit)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
return xpd_node;
|
|
|
|
error:
|
|
|
|
avc_xperms_decision_free(xpd_node);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int avc_add_xperms_decision(struct avc_node *node,
|
|
|
|
struct extended_perms_decision *src)
|
|
|
|
{
|
|
|
|
struct avc_xperms_decision_node *dest_xpd;
|
|
|
|
|
|
|
|
node->ae.xp_node->xp.len++;
|
|
|
|
dest_xpd = avc_xperms_decision_alloc(src->used);
|
|
|
|
if (!dest_xpd)
|
|
|
|
return -ENOMEM;
|
|
|
|
avc_copy_xperms_decision(&dest_xpd->xpd, src);
|
|
|
|
list_add(&dest_xpd->xpd_list, &node->ae.xp_node->xpd_head);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct avc_xperms_node *avc_xperms_alloc(void)
|
|
|
|
{
|
|
|
|
struct avc_xperms_node *xp_node;
|
|
|
|
|
2017-08-03 15:11:52 +07:00
|
|
|
xp_node = kmem_cache_zalloc(avc_xperms_cachep, GFP_NOWAIT);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (!xp_node)
|
|
|
|
return xp_node;
|
|
|
|
INIT_LIST_HEAD(&xp_node->xpd_head);
|
|
|
|
return xp_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int avc_xperms_populate(struct avc_node *node,
|
|
|
|
struct avc_xperms_node *src)
|
|
|
|
{
|
|
|
|
struct avc_xperms_node *dest;
|
|
|
|
struct avc_xperms_decision_node *dest_xpd;
|
|
|
|
struct avc_xperms_decision_node *src_xpd;
|
|
|
|
|
|
|
|
if (src->xp.len == 0)
|
|
|
|
return 0;
|
|
|
|
dest = avc_xperms_alloc();
|
|
|
|
if (!dest)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memcpy(dest->xp.drivers.p, src->xp.drivers.p, sizeof(dest->xp.drivers.p));
|
|
|
|
dest->xp.len = src->xp.len;
|
|
|
|
|
|
|
|
/* for each source xpd allocate a destination xpd and copy */
|
|
|
|
list_for_each_entry(src_xpd, &src->xpd_head, xpd_list) {
|
|
|
|
dest_xpd = avc_xperms_decision_alloc(src_xpd->xpd.used);
|
|
|
|
if (!dest_xpd)
|
|
|
|
goto error;
|
|
|
|
avc_copy_xperms_decision(&dest_xpd->xpd, &src_xpd->xpd);
|
|
|
|
list_add(&dest_xpd->xpd_list, &dest->xpd_head);
|
|
|
|
}
|
|
|
|
node->ae.xp_node = dest;
|
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
avc_xperms_free(dest);
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 avc_xperms_audit_required(u32 requested,
|
|
|
|
struct av_decision *avd,
|
|
|
|
struct extended_perms_decision *xpd,
|
|
|
|
u8 perm,
|
|
|
|
int result,
|
|
|
|
u32 *deniedp)
|
|
|
|
{
|
|
|
|
u32 denied, audited;
|
|
|
|
|
|
|
|
denied = requested & ~avd->allowed;
|
|
|
|
if (unlikely(denied)) {
|
|
|
|
audited = denied & avd->auditdeny;
|
|
|
|
if (audited && xpd) {
|
|
|
|
if (avc_xperms_has_perm(xpd, perm, XPERMS_DONTAUDIT))
|
|
|
|
audited &= ~requested;
|
|
|
|
}
|
|
|
|
} else if (result) {
|
|
|
|
audited = denied = requested;
|
|
|
|
} else {
|
|
|
|
audited = requested & avd->auditallow;
|
|
|
|
if (audited && xpd) {
|
|
|
|
if (!avc_xperms_has_perm(xpd, perm, XPERMS_AUDITALLOW))
|
|
|
|
audited &= ~requested;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*deniedp = denied;
|
|
|
|
return audited;
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static inline int avc_xperms_audit(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass,
|
|
|
|
u32 requested, struct av_decision *avd,
|
|
|
|
struct extended_perms_decision *xpd,
|
|
|
|
u8 perm, int result,
|
|
|
|
struct common_audit_data *ad)
|
2015-07-11 04:19:56 +07:00
|
|
|
{
|
|
|
|
u32 audited, denied;
|
|
|
|
|
|
|
|
audited = avc_xperms_audit_required(
|
|
|
|
requested, avd, xpd, perm, result, &denied);
|
|
|
|
if (likely(!audited))
|
|
|
|
return 0;
|
2018-03-05 23:47:56 +07:00
|
|
|
return slow_avc_audit(state, ssid, tsid, tclass, requested,
|
2015-07-11 04:19:56 +07:00
|
|
|
audited, denied, result, ad, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void avc_node_free(struct rcu_head *rhead)
|
|
|
|
{
|
|
|
|
struct avc_node *node = container_of(rhead, struct avc_node, rhead);
|
2015-07-11 04:19:56 +07:00
|
|
|
avc_xperms_free(node->ae.xp_node);
|
2005-04-17 05:20:36 +07:00
|
|
|
kmem_cache_free(avc_node_cachep, node);
|
|
|
|
avc_cache_stats_incr(frees);
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static void avc_node_delete(struct selinux_avc *avc, struct avc_node *node)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-02-13 02:51:04 +07:00
|
|
|
hlist_del_rcu(&node->list);
|
2005-04-17 05:20:36 +07:00
|
|
|
call_rcu(&node->rhead, avc_node_free);
|
2018-03-05 23:47:56 +07:00
|
|
|
atomic_dec(&avc->avc_cache.active_nodes);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static void avc_node_kill(struct selinux_avc *avc, struct avc_node *node)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2015-07-11 04:19:56 +07:00
|
|
|
avc_xperms_free(node->ae.xp_node);
|
2005-04-17 05:20:36 +07:00
|
|
|
kmem_cache_free(avc_node_cachep, node);
|
|
|
|
avc_cache_stats_incr(frees);
|
2018-03-05 23:47:56 +07:00
|
|
|
atomic_dec(&avc->avc_cache.active_nodes);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static void avc_node_replace(struct selinux_avc *avc,
|
|
|
|
struct avc_node *new, struct avc_node *old)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-02-13 02:51:04 +07:00
|
|
|
hlist_replace_rcu(&old->list, &new->list);
|
2005-04-17 05:20:36 +07:00
|
|
|
call_rcu(&old->rhead, avc_node_free);
|
2018-03-05 23:47:56 +07:00
|
|
|
atomic_dec(&avc->avc_cache.active_nodes);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static inline int avc_reclaim_node(struct selinux_avc *avc)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node;
|
|
|
|
int hvalue, try, ecx;
|
|
|
|
unsigned long flags;
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2009-02-13 02:50:59 +07:00
|
|
|
spinlock_t *lock;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-18 01:42:10 +07:00
|
|
|
for (try = 0, ecx = 0; try < AVC_CACHE_SLOTS; try++) {
|
2018-03-05 23:47:56 +07:00
|
|
|
hvalue = atomic_inc_return(&avc->avc_cache.lru_hint) &
|
|
|
|
(AVC_CACHE_SLOTS - 1);
|
|
|
|
head = &avc->avc_cache.slots[hvalue];
|
|
|
|
lock = &avc->avc_cache.slots_lock[hvalue];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-02-13 02:50:59 +07:00
|
|
|
if (!spin_trylock_irqsave(lock, flags))
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
2008-04-22 08:12:33 +07:00
|
|
|
rcu_read_lock();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry(node, head, list) {
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_node_delete(avc, node);
|
2009-02-13 02:50:43 +07:00
|
|
|
avc_cache_stats_incr(reclaims);
|
|
|
|
ecx++;
|
|
|
|
if (ecx >= AVC_CACHE_RECLAIM) {
|
|
|
|
rcu_read_unlock();
|
2009-02-13 02:50:59 +07:00
|
|
|
spin_unlock_irqrestore(lock, flags);
|
2009-02-13 02:50:43 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2008-04-22 08:12:33 +07:00
|
|
|
rcu_read_unlock();
|
2009-02-13 02:50:59 +07:00
|
|
|
spin_unlock_irqrestore(lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ecx;
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static struct avc_node *avc_alloc_node(struct selinux_avc *avc)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node;
|
|
|
|
|
2017-08-03 15:11:52 +07:00
|
|
|
node = kmem_cache_zalloc(avc_node_cachep, GFP_NOWAIT);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!node)
|
|
|
|
goto out;
|
|
|
|
|
2009-02-13 02:51:04 +07:00
|
|
|
INIT_HLIST_NODE(&node->list);
|
2005-04-17 05:20:36 +07:00
|
|
|
avc_cache_stats_incr(allocations);
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
if (atomic_inc_return(&avc->avc_cache.active_nodes) >
|
|
|
|
avc->avc_cache_threshold)
|
|
|
|
avc_reclaim_node(avc);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
2009-02-13 02:50:49 +07:00
|
|
|
static void avc_node_populate(struct avc_node *node, u32 ssid, u32 tsid, u16 tclass, struct av_decision *avd)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
node->ae.ssid = ssid;
|
|
|
|
node->ae.tsid = tsid;
|
|
|
|
node->ae.tclass = tclass;
|
2009-02-13 02:50:49 +07:00
|
|
|
memcpy(&node->ae.avd, avd, sizeof(node->ae.avd));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static inline struct avc_node *avc_search_node(struct selinux_avc *avc,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node, *ret = NULL;
|
|
|
|
int hvalue;
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
hvalue = avc_hash(ssid, tsid, tclass);
|
2018-03-05 23:47:56 +07:00
|
|
|
head = &avc->avc_cache.slots[hvalue];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry_rcu(node, head, list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ssid == node->ae.ssid &&
|
|
|
|
tclass == node->ae.tclass &&
|
|
|
|
tsid == node->ae.tsid) {
|
|
|
|
ret = node;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_lookup - Look up an AVC entry.
|
|
|
|
* @ssid: source security identifier
|
|
|
|
* @tsid: target security identifier
|
|
|
|
* @tclass: target security class
|
|
|
|
*
|
|
|
|
* Look up an AVC entry that is valid for the
|
|
|
|
* (@ssid, @tsid), interpreting the permissions
|
|
|
|
* based on @tclass. If a valid AVC entry exists,
|
2010-01-15 14:03:18 +07:00
|
|
|
* then this function returns the avc_node.
|
2005-04-17 05:20:36 +07:00
|
|
|
* Otherwise, this function returns NULL.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static struct avc_node *avc_lookup(struct selinux_avc *avc,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node;
|
|
|
|
|
|
|
|
avc_cache_stats_incr(lookups);
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_search_node(avc, ssid, tsid, tclass);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-02-13 02:50:54 +07:00
|
|
|
if (node)
|
2011-05-20 11:22:53 +07:00
|
|
|
return node;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-20 11:22:53 +07:00
|
|
|
avc_cache_stats_incr(misses);
|
|
|
|
return NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static int avc_latest_notif_update(struct selinux_avc *avc,
|
|
|
|
int seqno, int is_insert)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
static DEFINE_SPINLOCK(notif_lock);
|
|
|
|
unsigned long flag;
|
|
|
|
|
|
|
|
spin_lock_irqsave(¬if_lock, flag);
|
|
|
|
if (is_insert) {
|
2018-03-05 23:47:56 +07:00
|
|
|
if (seqno < avc->avc_cache.latest_notif) {
|
2008-04-17 22:52:44 +07:00
|
|
|
printk(KERN_WARNING "SELinux: avc: seqno %d < latest_notif %d\n",
|
2018-03-05 23:47:56 +07:00
|
|
|
seqno, avc->avc_cache.latest_notif);
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = -EAGAIN;
|
|
|
|
}
|
|
|
|
} else {
|
2018-03-05 23:47:56 +07:00
|
|
|
if (seqno > avc->avc_cache.latest_notif)
|
|
|
|
avc->avc_cache.latest_notif = seqno;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(¬if_lock, flag);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_insert - Insert an AVC entry.
|
|
|
|
* @ssid: source security identifier
|
|
|
|
* @tsid: target security identifier
|
|
|
|
* @tclass: target security class
|
2009-02-13 02:50:49 +07:00
|
|
|
* @avd: resulting av decision
|
2015-07-11 04:19:56 +07:00
|
|
|
* @xp_node: resulting extended permissions
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Insert an AVC entry for the SID pair
|
|
|
|
* (@ssid, @tsid) and class @tclass.
|
|
|
|
* The access vectors and the sequence number are
|
|
|
|
* normally provided by the security server in
|
|
|
|
* response to a security_compute_av() call. If the
|
2009-02-13 02:50:49 +07:00
|
|
|
* sequence number @avd->seqno is not less than the latest
|
2005-04-17 05:20:36 +07:00
|
|
|
* revocation notification, then the function copies
|
|
|
|
* the access vectors into a cache entry, returns
|
|
|
|
* avc_node inserted. Otherwise, this function returns NULL.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static struct avc_node *avc_insert(struct selinux_avc *avc,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass,
|
|
|
|
struct av_decision *avd,
|
|
|
|
struct avc_xperms_node *xp_node)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *pos, *node = NULL;
|
|
|
|
int hvalue;
|
|
|
|
unsigned long flag;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
if (avc_latest_notif_update(avc, avd->seqno, 1))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_alloc_node(avc);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (node) {
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2009-02-13 02:50:59 +07:00
|
|
|
spinlock_t *lock;
|
2015-07-11 04:19:56 +07:00
|
|
|
int rc = 0;
|
2009-02-13 02:50:59 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
hvalue = avc_hash(ssid, tsid, tclass);
|
2009-02-13 02:50:49 +07:00
|
|
|
avc_node_populate(node, ssid, tsid, tclass, avd);
|
2015-07-11 04:19:56 +07:00
|
|
|
rc = avc_xperms_populate(node, xp_node);
|
|
|
|
if (rc) {
|
|
|
|
kmem_cache_free(avc_node_cachep, node);
|
|
|
|
return NULL;
|
|
|
|
}
|
2018-03-05 23:47:56 +07:00
|
|
|
head = &avc->avc_cache.slots[hvalue];
|
|
|
|
lock = &avc->avc_cache.slots_lock[hvalue];
|
2009-02-13 02:50:59 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(lock, flag);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry(pos, head, list) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (pos->ae.ssid == ssid &&
|
|
|
|
pos->ae.tsid == tsid &&
|
|
|
|
pos->ae.tclass == tclass) {
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_node_replace(avc, node, pos);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
2009-02-13 02:51:04 +07:00
|
|
|
hlist_add_head_rcu(&node->list, head);
|
2005-04-17 05:20:36 +07:00
|
|
|
found:
|
2009-02-13 02:50:59 +07:00
|
|
|
spin_unlock_irqrestore(lock, flag);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
2009-07-14 23:14:09 +07:00
|
|
|
/**
|
|
|
|
* avc_audit_pre_callback - SELinux specific information
|
|
|
|
* will be called by generic audit code
|
|
|
|
* @ab: the audit buffer
|
|
|
|
* @a: audit_data
|
|
|
|
*/
|
|
|
|
static void avc_audit_pre_callback(struct audit_buffer *ab, void *a)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-07-14 23:14:09 +07:00
|
|
|
struct common_audit_data *ad = a;
|
|
|
|
audit_log_format(ab, "avc: %s ",
|
2012-04-05 02:01:43 +07:00
|
|
|
ad->selinux_audit_data->denied ? "denied" : "granted");
|
|
|
|
avc_dump_av(ab, ad->selinux_audit_data->tclass,
|
|
|
|
ad->selinux_audit_data->audited);
|
2009-07-14 23:14:09 +07:00
|
|
|
audit_log_format(ab, " for ");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-07-14 23:14:09 +07:00
|
|
|
/**
|
|
|
|
* avc_audit_post_callback - SELinux specific information
|
|
|
|
* will be called by generic audit code
|
|
|
|
* @ab: the audit buffer
|
|
|
|
* @a: audit_data
|
|
|
|
*/
|
|
|
|
static void avc_audit_post_callback(struct audit_buffer *ab, void *a)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-07-14 23:14:09 +07:00
|
|
|
struct common_audit_data *ad = a;
|
|
|
|
audit_log_format(ab, " ");
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_dump_query(ab, ad->selinux_audit_data->state,
|
|
|
|
ad->selinux_audit_data->ssid,
|
|
|
|
ad->selinux_audit_data->tsid,
|
|
|
|
ad->selinux_audit_data->tclass);
|
2014-04-30 01:29:04 +07:00
|
|
|
if (ad->selinux_audit_data->denied) {
|
|
|
|
audit_log_format(ab, " permissive=%u",
|
|
|
|
ad->selinux_audit_data->result ? 0 : 1);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-03-23 07:01:41 +07:00
|
|
|
/* This is the slow part of avc audit with big stack footprint */
|
2018-03-05 23:47:56 +07:00
|
|
|
noinline int slow_avc_audit(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass,
|
|
|
|
u32 requested, u32 audited, u32 denied, int result,
|
|
|
|
struct common_audit_data *a,
|
|
|
|
unsigned int flags)
|
2012-03-23 07:01:41 +07:00
|
|
|
{
|
|
|
|
struct common_audit_data stack_data;
|
2012-04-05 02:01:43 +07:00
|
|
|
struct selinux_audit_data sad;
|
2012-03-23 07:01:41 +07:00
|
|
|
|
|
|
|
if (!a) {
|
|
|
|
a = &stack_data;
|
2012-04-05 02:01:43 +07:00
|
|
|
a->type = LSM_AUDIT_DATA_NONE;
|
2012-03-23 07:01:41 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When in a RCU walk do the audit on the RCU retry. This is because
|
|
|
|
* the collection of the dname in an inode audit message is not RCU
|
|
|
|
* safe. Note this may drop some audits when the situation changes
|
|
|
|
* during retry. However this is logically just as if the operation
|
|
|
|
* happened a little later.
|
|
|
|
*/
|
|
|
|
if ((a->type == LSM_AUDIT_DATA_INODE) &&
|
|
|
|
(flags & MAY_NOT_BLOCK))
|
|
|
|
return -ECHILD;
|
|
|
|
|
2012-04-05 02:01:43 +07:00
|
|
|
sad.tclass = tclass;
|
|
|
|
sad.requested = requested;
|
|
|
|
sad.ssid = ssid;
|
|
|
|
sad.tsid = tsid;
|
|
|
|
sad.audited = audited;
|
|
|
|
sad.denied = denied;
|
2014-04-30 01:29:04 +07:00
|
|
|
sad.result = result;
|
2018-03-05 23:47:56 +07:00
|
|
|
sad.state = state;
|
2012-04-05 02:01:43 +07:00
|
|
|
|
|
|
|
a->selinux_audit_data = &sad;
|
2012-04-03 23:38:00 +07:00
|
|
|
|
2012-04-03 05:48:12 +07:00
|
|
|
common_lsm_audit(a, avc_audit_pre_callback, avc_audit_post_callback);
|
2012-03-23 07:01:41 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* avc_add_callback - Register a callback for security events.
|
|
|
|
* @callback: callback function
|
|
|
|
* @events: security events
|
|
|
|
*
|
2012-03-07 21:17:14 +07:00
|
|
|
* Register a callback function for events in the set @events.
|
|
|
|
* Returns %0 on success or -%ENOMEM if insufficient memory
|
|
|
|
* exists to add the callback.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2012-03-07 21:17:14 +07:00
|
|
|
int __init avc_add_callback(int (*callback)(u32 event), u32 events)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_callback_node *c;
|
|
|
|
int rc = 0;
|
|
|
|
|
2012-03-07 21:17:13 +07:00
|
|
|
c = kmalloc(sizeof(*c), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!c) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
c->callback = callback;
|
|
|
|
c->events = events;
|
|
|
|
c->next = avc_callbacks;
|
|
|
|
avc_callbacks = c;
|
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_update_node Update an AVC entry
|
|
|
|
* @event : Updating event
|
|
|
|
* @perms : Permission mask bits
|
|
|
|
* @ssid,@tsid,@tclass : identifier of an AVC entry
|
2009-02-13 02:50:11 +07:00
|
|
|
* @seqno : sequence number when decision was made
|
2015-07-11 04:19:56 +07:00
|
|
|
* @xpd: extended_perms_decision to be added to the node
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* if a valid AVC entry doesn't exist,this function returns -ENOENT.
|
|
|
|
* if kmalloc() called internal returns NULL, this function returns -ENOMEM.
|
2010-01-15 14:03:18 +07:00
|
|
|
* otherwise, this function updates the AVC entry. The original AVC-entry object
|
2005-04-17 05:20:36 +07:00
|
|
|
* will release later by RCU.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static int avc_update_node(struct selinux_avc *avc,
|
|
|
|
u32 event, u32 perms, u8 driver, u8 xperm, u32 ssid,
|
|
|
|
u32 tsid, u16 tclass, u32 seqno,
|
|
|
|
struct extended_perms_decision *xpd,
|
|
|
|
u32 flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int hvalue, rc = 0;
|
|
|
|
unsigned long flag;
|
|
|
|
struct avc_node *pos, *node, *orig = NULL;
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2009-02-13 02:50:59 +07:00
|
|
|
spinlock_t *lock;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_alloc_node(avc);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!node) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lock the target slot */
|
|
|
|
hvalue = avc_hash(ssid, tsid, tclass);
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
head = &avc->avc_cache.slots[hvalue];
|
|
|
|
lock = &avc->avc_cache.slots_lock[hvalue];
|
2009-02-13 02:50:59 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(lock, flag);
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry(pos, head, list) {
|
2008-04-18 01:42:10 +07:00
|
|
|
if (ssid == pos->ae.ssid &&
|
|
|
|
tsid == pos->ae.tsid &&
|
2009-02-13 02:50:11 +07:00
|
|
|
tclass == pos->ae.tclass &&
|
|
|
|
seqno == pos->ae.avd.seqno){
|
2005-04-17 05:20:36 +07:00
|
|
|
orig = pos;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!orig) {
|
|
|
|
rc = -ENOENT;
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_node_kill(avc, node);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy and replace original node.
|
|
|
|
*/
|
|
|
|
|
2009-02-13 02:50:49 +07:00
|
|
|
avc_node_populate(node, ssid, tsid, tclass, &orig->ae.avd);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2015-07-11 04:19:56 +07:00
|
|
|
if (orig->ae.xp_node) {
|
|
|
|
rc = avc_xperms_populate(node, orig->ae.xp_node);
|
|
|
|
if (rc) {
|
|
|
|
kmem_cache_free(avc_node_cachep, node);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
switch (event) {
|
|
|
|
case AVC_CALLBACK_GRANT:
|
|
|
|
node->ae.avd.allowed |= perms;
|
2015-07-11 04:19:56 +07:00
|
|
|
if (node->ae.xp_node && (flags & AVC_EXTENDED_PERMS))
|
|
|
|
avc_xperms_allow_perm(node->ae.xp_node, driver, xperm);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case AVC_CALLBACK_TRY_REVOKE:
|
|
|
|
case AVC_CALLBACK_REVOKE:
|
|
|
|
node->ae.avd.allowed &= ~perms;
|
|
|
|
break;
|
|
|
|
case AVC_CALLBACK_AUDITALLOW_ENABLE:
|
|
|
|
node->ae.avd.auditallow |= perms;
|
|
|
|
break;
|
|
|
|
case AVC_CALLBACK_AUDITALLOW_DISABLE:
|
|
|
|
node->ae.avd.auditallow &= ~perms;
|
|
|
|
break;
|
|
|
|
case AVC_CALLBACK_AUDITDENY_ENABLE:
|
|
|
|
node->ae.avd.auditdeny |= perms;
|
|
|
|
break;
|
|
|
|
case AVC_CALLBACK_AUDITDENY_DISABLE:
|
|
|
|
node->ae.avd.auditdeny &= ~perms;
|
|
|
|
break;
|
2015-07-11 04:19:56 +07:00
|
|
|
case AVC_CALLBACK_ADD_XPERMS:
|
|
|
|
avc_add_xperms_decision(node, xpd);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_node_replace(avc, node, orig);
|
2005-04-17 05:20:36 +07:00
|
|
|
out_unlock:
|
2009-02-13 02:50:59 +07:00
|
|
|
spin_unlock_irqrestore(lock, flag);
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-13 09:54:17 +07:00
|
|
|
* avc_flush - Flush the cache
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static void avc_flush(struct selinux_avc *avc)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-02-13 02:51:04 +07:00
|
|
|
struct hlist_head *head;
|
2009-09-13 09:54:17 +07:00
|
|
|
struct avc_node *node;
|
2009-02-13 02:50:59 +07:00
|
|
|
spinlock_t *lock;
|
2009-09-13 09:54:17 +07:00
|
|
|
unsigned long flag;
|
|
|
|
int i;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (i = 0; i < AVC_CACHE_SLOTS; i++) {
|
2018-03-05 23:47:56 +07:00
|
|
|
head = &avc->avc_cache.slots[i];
|
|
|
|
lock = &avc->avc_cache.slots_lock[i];
|
2009-02-13 02:50:59 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(lock, flag);
|
2008-04-22 08:12:33 +07:00
|
|
|
/*
|
|
|
|
* With preemptable RCU, the outer spinlock does not
|
|
|
|
* prevent RCU grace periods from ending.
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry(node, head, list)
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_node_delete(avc, node);
|
2008-04-22 08:12:33 +07:00
|
|
|
rcu_read_unlock();
|
2009-02-13 02:50:59 +07:00
|
|
|
spin_unlock_irqrestore(lock, flag);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-09-13 09:54:17 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_ss_reset - Flush the cache and revalidate migrated permissions.
|
|
|
|
* @seqno: policy sequence number
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
int avc_ss_reset(struct selinux_avc *avc, u32 seqno)
|
2009-09-13 09:54:17 +07:00
|
|
|
{
|
|
|
|
struct avc_callback_node *c;
|
|
|
|
int rc = 0, tmprc;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_flush(avc);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (c = avc_callbacks; c; c = c->next) {
|
|
|
|
if (c->events & AVC_CALLBACK_RESET) {
|
2012-03-07 21:17:14 +07:00
|
|
|
tmprc = c->callback(AVC_CALLBACK_RESET);
|
2006-02-25 04:44:05 +07:00
|
|
|
/* save the first error encountered for the return
|
|
|
|
value and continue processing the callbacks */
|
|
|
|
if (!rc)
|
|
|
|
rc = tmprc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_latest_notif_update(avc, seqno, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2012-04-01 00:58:08 +07:00
|
|
|
/*
|
|
|
|
* Slow-path helper function for avc_has_perm_noaudit,
|
|
|
|
* when the avc_node lookup fails. We get called with
|
|
|
|
* the RCU read lock held, and need to return with it
|
|
|
|
* still held, but drop if for the security compute.
|
|
|
|
*
|
|
|
|
* Don't inline this, since it's the slow-path and just
|
|
|
|
* results in a bigger stack frame.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
static noinline
|
|
|
|
struct avc_node *avc_compute_av(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid,
|
|
|
|
u16 tclass, struct av_decision *avd,
|
|
|
|
struct avc_xperms_node *xp_node)
|
2012-04-01 00:58:08 +07:00
|
|
|
{
|
|
|
|
rcu_read_unlock();
|
2015-07-11 04:19:56 +07:00
|
|
|
INIT_LIST_HEAD(&xp_node->xpd_head);
|
2018-03-05 23:47:56 +07:00
|
|
|
security_compute_av(state, ssid, tsid, tclass, avd, &xp_node->xp);
|
2012-04-01 00:58:08 +07:00
|
|
|
rcu_read_lock();
|
2018-03-05 23:47:56 +07:00
|
|
|
return avc_insert(state->avc, ssid, tsid, tclass, avd, xp_node);
|
2012-04-01 00:58:08 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
static noinline int avc_denied(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid,
|
|
|
|
u16 tclass, u32 requested,
|
|
|
|
u8 driver, u8 xperm, unsigned int flags,
|
|
|
|
struct av_decision *avd)
|
2012-04-01 00:58:08 +07:00
|
|
|
{
|
|
|
|
if (flags & AVC_STRICT)
|
|
|
|
return -EACCES;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
if (enforcing_enabled(state) &&
|
2018-03-02 06:48:02 +07:00
|
|
|
!(avd->flags & AVD_FLAGS_PERMISSIVE))
|
2012-04-01 00:58:08 +07:00
|
|
|
return -EACCES;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_update_node(state->avc, AVC_CALLBACK_GRANT, requested, driver,
|
|
|
|
xperm, ssid, tsid, tclass, avd->seqno, NULL, flags);
|
2012-04-01 00:58:08 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-11 04:19:56 +07:00
|
|
|
/*
|
|
|
|
* The avc extended permissions logic adds an additional 256 bits of
|
|
|
|
* permissions to an avc node when extended permissions for that node are
|
|
|
|
* specified in the avtab. If the additional 256 permissions is not adequate,
|
|
|
|
* as-is the case with ioctls, then multiple may be chained together and the
|
|
|
|
* driver field is used to specify which set contains the permission.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
int avc_has_extended_perms(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass, u32 requested,
|
|
|
|
u8 driver, u8 xperm, struct common_audit_data *ad)
|
2015-07-11 04:19:56 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node;
|
|
|
|
struct av_decision avd;
|
|
|
|
u32 denied;
|
|
|
|
struct extended_perms_decision local_xpd;
|
|
|
|
struct extended_perms_decision *xpd = NULL;
|
|
|
|
struct extended_perms_data allowed;
|
|
|
|
struct extended_perms_data auditallow;
|
|
|
|
struct extended_perms_data dontaudit;
|
|
|
|
struct avc_xperms_node local_xp_node;
|
|
|
|
struct avc_xperms_node *xp_node;
|
|
|
|
int rc = 0, rc2;
|
|
|
|
|
|
|
|
xp_node = &local_xp_node;
|
|
|
|
BUG_ON(!requested);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_lookup(state->avc, ssid, tsid, tclass);
|
2015-07-11 04:19:56 +07:00
|
|
|
if (unlikely(!node)) {
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_compute_av(state, ssid, tsid, tclass, &avd, xp_node);
|
2015-07-11 04:19:56 +07:00
|
|
|
} else {
|
|
|
|
memcpy(&avd, &node->ae.avd, sizeof(avd));
|
|
|
|
xp_node = node->ae.xp_node;
|
|
|
|
}
|
|
|
|
/* if extended permissions are not defined, only consider av_decision */
|
|
|
|
if (!xp_node || !xp_node->xp.len)
|
|
|
|
goto decision;
|
|
|
|
|
|
|
|
local_xpd.allowed = &allowed;
|
|
|
|
local_xpd.auditallow = &auditallow;
|
|
|
|
local_xpd.dontaudit = &dontaudit;
|
|
|
|
|
|
|
|
xpd = avc_xperms_decision_lookup(driver, xp_node);
|
|
|
|
if (unlikely(!xpd)) {
|
|
|
|
/*
|
|
|
|
* Compute the extended_perms_decision only if the driver
|
|
|
|
* is flagged
|
|
|
|
*/
|
|
|
|
if (!security_xperm_test(xp_node->xp.drivers.p, driver)) {
|
|
|
|
avd.allowed &= ~requested;
|
|
|
|
goto decision;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2018-03-05 23:47:56 +07:00
|
|
|
security_compute_xperms_decision(state, ssid, tsid, tclass,
|
|
|
|
driver, &local_xpd);
|
2015-07-11 04:19:56 +07:00
|
|
|
rcu_read_lock();
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_update_node(state->avc, AVC_CALLBACK_ADD_XPERMS, requested,
|
|
|
|
driver, xperm, ssid, tsid, tclass, avd.seqno,
|
|
|
|
&local_xpd, 0);
|
2015-07-11 04:19:56 +07:00
|
|
|
} else {
|
|
|
|
avc_quick_copy_xperms_decision(xperm, &local_xpd, xpd);
|
|
|
|
}
|
|
|
|
xpd = &local_xpd;
|
|
|
|
|
|
|
|
if (!avc_xperms_has_perm(xpd, xperm, XPERMS_ALLOWED))
|
|
|
|
avd.allowed &= ~requested;
|
|
|
|
|
|
|
|
decision:
|
|
|
|
denied = requested & ~(avd.allowed);
|
|
|
|
if (unlikely(denied))
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = avc_denied(state, ssid, tsid, tclass, requested,
|
|
|
|
driver, xperm, AVC_EXTENDED_PERMS, &avd);
|
2015-07-11 04:19:56 +07:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc2 = avc_xperms_audit(state, ssid, tsid, tclass, requested,
|
2015-07-11 04:19:56 +07:00
|
|
|
&avd, xpd, xperm, rc, ad);
|
|
|
|
if (rc2)
|
|
|
|
return rc2;
|
|
|
|
return rc;
|
|
|
|
}
|
2012-04-01 00:58:08 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* avc_has_perm_noaudit - Check permissions but perform no auditing.
|
|
|
|
* @ssid: source security identifier
|
|
|
|
* @tsid: target security identifier
|
|
|
|
* @tclass: target security class
|
|
|
|
* @requested: requested permissions, interpreted based on @tclass
|
2007-06-08 02:34:10 +07:00
|
|
|
* @flags: AVC_STRICT or 0
|
2005-04-17 05:20:36 +07:00
|
|
|
* @avd: access vector decisions
|
|
|
|
*
|
|
|
|
* Check the AVC to determine whether the @requested permissions are granted
|
|
|
|
* for the SID pair (@ssid, @tsid), interpreting the permissions
|
|
|
|
* based on @tclass, and call the security server on a cache miss to obtain
|
|
|
|
* a new decision and add it to the cache. Return a copy of the decisions
|
|
|
|
* in @avd. Return %0 if all @requested permissions are granted,
|
|
|
|
* -%EACCES if any permissions are denied, or another -errno upon
|
|
|
|
* other errors. This function is typically called by avc_has_perm(),
|
|
|
|
* but may also be called directly to separate permission checking from
|
|
|
|
* auditing, e.g. in cases where a lock must be held for the check but
|
|
|
|
* should be released for the auditing.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
inline int avc_has_perm_noaudit(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid,
|
|
|
|
u16 tclass, u32 requested,
|
|
|
|
unsigned int flags,
|
|
|
|
struct av_decision *avd)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct avc_node *node;
|
2015-07-11 04:19:56 +07:00
|
|
|
struct avc_xperms_node xp_node;
|
2005-04-17 05:20:36 +07:00
|
|
|
int rc = 0;
|
|
|
|
u32 denied;
|
|
|
|
|
2008-03-12 01:19:34 +07:00
|
|
|
BUG_ON(!requested);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
rcu_read_lock();
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_lookup(state->avc, ssid, tsid, tclass);
|
2015-02-27 04:54:17 +07:00
|
|
|
if (unlikely(!node))
|
2018-03-05 23:47:56 +07:00
|
|
|
node = avc_compute_av(state, ssid, tsid, tclass, avd, &xp_node);
|
2015-02-27 04:54:17 +07:00
|
|
|
else
|
2011-05-25 03:48:51 +07:00
|
|
|
memcpy(avd, &node->ae.avd, sizeof(*avd));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-02-13 02:50:49 +07:00
|
|
|
denied = requested & ~(avd->allowed);
|
2012-04-01 00:58:08 +07:00
|
|
|
if (unlikely(denied))
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = avc_denied(state, ssid, tsid, tclass, requested, 0, 0,
|
|
|
|
flags, avd);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* avc_has_perm - Check permissions and perform any appropriate auditing.
|
|
|
|
* @ssid: source security identifier
|
|
|
|
* @tsid: target security identifier
|
|
|
|
* @tclass: target security class
|
|
|
|
* @requested: requested permissions, interpreted based on @tclass
|
|
|
|
* @auditdata: auxiliary audit data
|
|
|
|
*
|
|
|
|
* Check the AVC to determine whether the @requested permissions are granted
|
|
|
|
* for the SID pair (@ssid, @tsid), interpreting the permissions
|
|
|
|
* based on @tclass, and call the security server on a cache miss to obtain
|
|
|
|
* a new decision and add it to the cache. Audit the granting or denial of
|
|
|
|
* permissions in accordance with the policy. Return %0 if all @requested
|
|
|
|
* permissions are granted, -%EACCES if any permissions are denied, or
|
|
|
|
* another -errno upon other errors.
|
|
|
|
*/
|
2018-03-05 23:47:56 +07:00
|
|
|
int avc_has_perm(struct selinux_state *state, u32 ssid, u32 tsid, u16 tclass,
|
2013-10-05 02:57:22 +07:00
|
|
|
u32 requested, struct common_audit_data *auditdata)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct av_decision avd;
|
2011-04-26 03:26:29 +07:00
|
|
|
int rc, rc2;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = avc_has_perm_noaudit(state, ssid, tsid, tclass, requested, 0,
|
|
|
|
&avd);
|
2011-04-26 03:26:29 +07:00
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc2 = avc_audit(state, ssid, tsid, tclass, requested, &avd, rc,
|
|
|
|
auditdata, 0);
|
2015-03-23 09:37:39 +07:00
|
|
|
if (rc2)
|
|
|
|
return rc2;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
int avc_has_perm_flags(struct selinux_state *state,
|
|
|
|
u32 ssid, u32 tsid, u16 tclass, u32 requested,
|
|
|
|
struct common_audit_data *auditdata,
|
2015-03-23 09:37:39 +07:00
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct av_decision avd;
|
|
|
|
int rc, rc2;
|
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc = avc_has_perm_noaudit(state, ssid, tsid, tclass, requested, 0,
|
|
|
|
&avd);
|
2015-03-23 09:37:39 +07:00
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
rc2 = avc_audit(state, ssid, tsid, tclass, requested, &avd, rc,
|
2015-03-23 09:37:39 +07:00
|
|
|
auditdata, flags);
|
2011-04-26 03:26:29 +07:00
|
|
|
if (rc2)
|
|
|
|
return rc2;
|
2005-04-17 05:20:36 +07:00
|
|
|
return rc;
|
|
|
|
}
|
2007-09-14 07:27:07 +07:00
|
|
|
|
2018-03-05 23:47:56 +07:00
|
|
|
u32 avc_policy_seqno(struct selinux_state *state)
|
2007-09-14 07:27:07 +07:00
|
|
|
{
|
2018-03-05 23:47:56 +07:00
|
|
|
return state->avc->avc_cache.latest_notif;
|
2007-09-14 07:27:07 +07:00
|
|
|
}
|
2009-06-25 04:58:05 +07:00
|
|
|
|
|
|
|
void avc_disable(void)
|
|
|
|
{
|
2009-09-21 08:21:10 +07:00
|
|
|
/*
|
|
|
|
* If you are looking at this because you have realized that we are
|
|
|
|
* not destroying the avc_node_cachep it might be easy to fix, but
|
|
|
|
* I don't know the memory barrier semantics well enough to know. It's
|
|
|
|
* possible that some other task dereferenced security_ops when
|
|
|
|
* it still pointed to selinux operations. If that is the case it's
|
|
|
|
* possible that it is about to use the avc and is about to need the
|
|
|
|
* avc_node_cachep. I know I could wrap the security.c security_ops call
|
|
|
|
* in an rcu_lock, but seriously, it's not worth it. Instead I just flush
|
|
|
|
* the cache and get that memory back.
|
|
|
|
*/
|
|
|
|
if (avc_node_cachep) {
|
2018-03-05 23:47:56 +07:00
|
|
|
avc_flush(selinux_state.avc);
|
2009-09-21 08:21:10 +07:00
|
|
|
/* kmem_cache_destroy(avc_node_cachep); */
|
|
|
|
}
|
2009-06-25 04:58:05 +07:00
|
|
|
}
|