forked from luck/tmp_suning_uos_patched
76f7ba35d4
I started playing with pahole today and decided to put it against the
selinux structures. Found we could save a little bit of space on x86_64
(and no harm on i686) just reorganizing some structs.
Object size changes:
av_inherit: 24 -> 16
selinux_class_perm: 48 -> 40
context: 80 -> 72
Admittedly there aren't many of av_inherit or selinux_class_perm's in
the kernel (33 and 1 respectively) But the change to the size of struct
context reverberate out a bit. I can get some hard number if they are
needed, but I don't see why they would be. We do change which cacheline
context->len and context->str would be on, but I don't see that as a
problem since we are clearly going to have to load both if the context
is to be of any value. I've run with the patch and don't seem to be
having any problems.
An example of what's going on using struct av_inherit would be:
form: to:
struct av_inherit { struct av_inherit {
u16 tclass; const char **common_pts;
const char **common_pts; u32 common_base;
u32 common_base; u16 tclass;
};
(notice all I did was move u16 tclass to the end of the struct instead
of the beginning)
Memory layout before the change:
struct av_inherit {
u16 tclass; /* 2 */
/* 6 bytes hole */
const char** common_pts; /* 8 */
u32 common_base; /* 4 */
/* 4 byes padding */
/* size: 24, cachelines: 1 */
/* sum members: 14, holes: 1, sum holes: 6 */
/* padding: 4 */
};
Memory layout after the change:
struct av_inherit {
const char ** common_pts; /* 8 */
u32 common_base; /* 4 */
u16 tclass; /* 2 */
/* 2 bytes padding */
/* size: 16, cachelines: 1 */
/* sum members: 14, holes: 0, sum holes: 0 */
/* padding: 2 */
};
Signed-off-by: Eric Paris <eparis@redhat.com>
Signed-off-by: James Morris <jmorris@namei.org>
156 lines
3.6 KiB
C
156 lines
3.6 KiB
C
/*
|
|
* A security context is a set of security attributes
|
|
* associated with each subject and object controlled
|
|
* by the security policy. Security contexts are
|
|
* externally represented as variable-length strings
|
|
* that can be interpreted by a user or application
|
|
* with an understanding of the security policy.
|
|
* Internally, the security server uses a simple
|
|
* structure. This structure is private to the
|
|
* security server and can be changed without affecting
|
|
* clients of the security server.
|
|
*
|
|
* Author : Stephen Smalley, <sds@epoch.ncsc.mil>
|
|
*/
|
|
#ifndef _SS_CONTEXT_H_
|
|
#define _SS_CONTEXT_H_
|
|
|
|
#include "ebitmap.h"
|
|
#include "mls_types.h"
|
|
#include "security.h"
|
|
|
|
/*
|
|
* A security context consists of an authenticated user
|
|
* identity, a role, a type and a MLS range.
|
|
*/
|
|
struct context {
|
|
u32 user;
|
|
u32 role;
|
|
u32 type;
|
|
u32 len; /* length of string in bytes */
|
|
struct mls_range range;
|
|
char *str; /* string representation if context cannot be mapped. */
|
|
};
|
|
|
|
static inline void mls_context_init(struct context *c)
|
|
{
|
|
memset(&c->range, 0, sizeof(c->range));
|
|
}
|
|
|
|
static inline int mls_context_cpy(struct context *dst, struct context *src)
|
|
{
|
|
int rc;
|
|
|
|
if (!selinux_mls_enabled)
|
|
return 0;
|
|
|
|
dst->range.level[0].sens = src->range.level[0].sens;
|
|
rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);
|
|
if (rc)
|
|
goto out;
|
|
|
|
dst->range.level[1].sens = src->range.level[1].sens;
|
|
rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[1].cat);
|
|
if (rc)
|
|
ebitmap_destroy(&dst->range.level[0].cat);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Sets both levels in the MLS range of 'dst' to the low level of 'src'.
|
|
*/
|
|
static inline int mls_context_cpy_low(struct context *dst, struct context *src)
|
|
{
|
|
int rc;
|
|
|
|
if (!selinux_mls_enabled)
|
|
return 0;
|
|
|
|
dst->range.level[0].sens = src->range.level[0].sens;
|
|
rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);
|
|
if (rc)
|
|
goto out;
|
|
|
|
dst->range.level[1].sens = src->range.level[0].sens;
|
|
rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[0].cat);
|
|
if (rc)
|
|
ebitmap_destroy(&dst->range.level[0].cat);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static inline int mls_context_cmp(struct context *c1, struct context *c2)
|
|
{
|
|
if (!selinux_mls_enabled)
|
|
return 1;
|
|
|
|
return ((c1->range.level[0].sens == c2->range.level[0].sens) &&
|
|
ebitmap_cmp(&c1->range.level[0].cat, &c2->range.level[0].cat) &&
|
|
(c1->range.level[1].sens == c2->range.level[1].sens) &&
|
|
ebitmap_cmp(&c1->range.level[1].cat, &c2->range.level[1].cat));
|
|
}
|
|
|
|
static inline void mls_context_destroy(struct context *c)
|
|
{
|
|
if (!selinux_mls_enabled)
|
|
return;
|
|
|
|
ebitmap_destroy(&c->range.level[0].cat);
|
|
ebitmap_destroy(&c->range.level[1].cat);
|
|
mls_context_init(c);
|
|
}
|
|
|
|
static inline void context_init(struct context *c)
|
|
{
|
|
memset(c, 0, sizeof(*c));
|
|
}
|
|
|
|
static inline int context_cpy(struct context *dst, struct context *src)
|
|
{
|
|
int rc;
|
|
|
|
dst->user = src->user;
|
|
dst->role = src->role;
|
|
dst->type = src->type;
|
|
if (src->str) {
|
|
dst->str = kstrdup(src->str, GFP_ATOMIC);
|
|
if (!dst->str)
|
|
return -ENOMEM;
|
|
dst->len = src->len;
|
|
} else {
|
|
dst->str = NULL;
|
|
dst->len = 0;
|
|
}
|
|
rc = mls_context_cpy(dst, src);
|
|
if (rc) {
|
|
kfree(dst->str);
|
|
return rc;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline void context_destroy(struct context *c)
|
|
{
|
|
c->user = c->role = c->type = 0;
|
|
kfree(c->str);
|
|
c->str = NULL;
|
|
c->len = 0;
|
|
mls_context_destroy(c);
|
|
}
|
|
|
|
static inline int context_cmp(struct context *c1, struct context *c2)
|
|
{
|
|
if (c1->len && c2->len)
|
|
return (c1->len == c2->len && !strcmp(c1->str, c2->str));
|
|
if (c1->len || c2->len)
|
|
return 0;
|
|
return ((c1->user == c2->user) &&
|
|
(c1->role == c2->role) &&
|
|
(c1->type == c2->type) &&
|
|
mls_context_cmp(c1, c2));
|
|
}
|
|
|
|
#endif /* _SS_CONTEXT_H_ */
|
|
|