2010-07-29 23:48:03 +02:00
|
|
|
/*
|
|
|
|
* AppArmor security module
|
|
|
|
*
|
|
|
|
* This file contains AppArmor /sys/kernel/security/apparmor interface functions
|
|
|
|
*
|
|
|
|
* Copyright (C) 1998-2008 Novell/SUSE
|
|
|
|
* Copyright 2009-2010 Canonical Ltd.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation, version 2 of the
|
|
|
|
* License.
|
|
|
|
*/
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
#include <linux/ctype.h>
|
2010-07-29 23:48:03 +02:00
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/uaccess.h>
|
2017-01-16 09:42:45 +01:00
|
|
|
#include <linux/mount.h>
|
2010-07-29 23:48:03 +02:00
|
|
|
#include <linux/namei.h>
|
2012-01-27 01:29:21 +01:00
|
|
|
#include <linux/capability.h>
|
2013-07-11 06:18:43 +02:00
|
|
|
#include <linux/rcupdate.h>
|
2017-01-16 09:42:45 +01:00
|
|
|
#include <uapi/linux/major.h>
|
|
|
|
#include <linux/fs.h>
|
2010-07-29 23:48:03 +02:00
|
|
|
|
|
|
|
#include "include/apparmor.h"
|
|
|
|
#include "include/apparmorfs.h"
|
|
|
|
#include "include/audit.h"
|
|
|
|
#include "include/context.h"
|
2013-08-14 20:27:36 +02:00
|
|
|
#include "include/crypto.h"
|
2010-07-29 23:48:03 +02:00
|
|
|
#include "include/policy.h"
|
2017-01-16 09:42:15 +01:00
|
|
|
#include "include/policy_ns.h"
|
2012-01-27 01:29:23 +01:00
|
|
|
#include "include/resource.h"
|
2017-01-16 09:42:55 +01:00
|
|
|
#include "include/policy_unpack.h"
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
/**
|
|
|
|
* aa_mangle_name - mangle a profile name to std profile layout form
|
|
|
|
* @name: profile name to mangle (NOT NULL)
|
|
|
|
* @target: buffer to store mangled name, same length as @name (MAYBE NULL)
|
|
|
|
*
|
|
|
|
* Returns: length of mangled name
|
|
|
|
*/
|
2017-01-16 09:42:30 +01:00
|
|
|
static int mangle_name(const char *name, char *target)
|
2013-07-11 06:13:43 +02:00
|
|
|
{
|
|
|
|
char *t = target;
|
|
|
|
|
|
|
|
while (*name == '/' || *name == '.')
|
|
|
|
name++;
|
|
|
|
|
|
|
|
if (target) {
|
|
|
|
for (; *name; name++) {
|
|
|
|
if (*name == '/')
|
|
|
|
*(t)++ = '.';
|
|
|
|
else if (isspace(*name))
|
|
|
|
*(t)++ = '_';
|
|
|
|
else if (isalnum(*name) || strchr("._-", *name))
|
|
|
|
*(t)++ = *name;
|
|
|
|
}
|
|
|
|
|
|
|
|
*t = 0;
|
|
|
|
} else {
|
|
|
|
int len = 0;
|
|
|
|
for (; *name; name++) {
|
|
|
|
if (isalnum(*name) || isspace(*name) ||
|
|
|
|
strchr("/._-", *name))
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return t - target;
|
|
|
|
}
|
|
|
|
|
2010-07-29 23:48:03 +02:00
|
|
|
/**
|
|
|
|
* aa_simple_write_to_buffer - common routine for getting policy from user
|
|
|
|
* @userbuf: user buffer to copy data from (NOT NULL)
|
2010-10-09 09:47:53 +02:00
|
|
|
* @alloc_size: size of user buffer (REQUIRES: @alloc_size >= @copy_size)
|
2010-07-29 23:48:03 +02:00
|
|
|
* @copy_size: size of data to copy from user buffer
|
|
|
|
* @pos: position write is at in the file (NOT NULL)
|
|
|
|
*
|
|
|
|
* Returns: kernel buffer containing copy of user buffer data or an
|
|
|
|
* ERR_PTR on failure.
|
|
|
|
*/
|
2017-01-16 09:43:03 +01:00
|
|
|
static struct aa_loaddata *aa_simple_write_to_buffer(const char __user *userbuf,
|
2017-01-16 09:42:55 +01:00
|
|
|
size_t alloc_size,
|
|
|
|
size_t copy_size,
|
|
|
|
loff_t *pos)
|
2010-07-29 23:48:03 +02:00
|
|
|
{
|
2017-01-16 09:42:55 +01:00
|
|
|
struct aa_loaddata *data;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2010-10-09 09:47:53 +02:00
|
|
|
BUG_ON(copy_size > alloc_size);
|
|
|
|
|
2010-07-29 23:48:03 +02:00
|
|
|
if (*pos != 0)
|
|
|
|
/* only writes from pos 0, that is complete writes */
|
|
|
|
return ERR_PTR(-ESPIPE);
|
|
|
|
|
|
|
|
/* freed by caller to simple_write_to_buffer */
|
2017-01-16 09:42:55 +01:00
|
|
|
data = kvmalloc(sizeof(*data) + alloc_size);
|
2010-07-29 23:48:03 +02:00
|
|
|
if (data == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2017-01-16 09:42:55 +01:00
|
|
|
kref_init(&data->count);
|
|
|
|
data->size = copy_size;
|
|
|
|
data->hash = NULL;
|
|
|
|
data->abi = 0;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2017-01-16 09:42:55 +01:00
|
|
|
if (copy_from_user(data->data, userbuf, copy_size)) {
|
2010-07-29 23:48:03 +02:00
|
|
|
kvfree(data);
|
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
}
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:55 +01:00
|
|
|
static ssize_t policy_update(int binop, const char __user *buf, size_t size,
|
2017-01-16 09:42:58 +01:00
|
|
|
loff_t *pos, struct aa_ns *ns)
|
2010-07-29 23:48:03 +02:00
|
|
|
{
|
|
|
|
ssize_t error;
|
2017-01-16 09:42:55 +01:00
|
|
|
struct aa_loaddata *data;
|
|
|
|
struct aa_profile *profile = aa_current_profile();
|
2017-01-16 09:43:01 +01:00
|
|
|
const char *op = binop == PROF_ADD ? OP_PROF_LOAD : OP_PROF_REPL;
|
2017-01-16 09:42:55 +01:00
|
|
|
/* high level check about policy management - fine grained in
|
|
|
|
* below after unpack
|
|
|
|
*/
|
2017-01-16 09:42:58 +01:00
|
|
|
error = aa_may_manage_policy(profile, ns, op);
|
2017-01-16 09:42:55 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2017-01-16 09:43:03 +01:00
|
|
|
data = aa_simple_write_to_buffer(buf, size, size, pos);
|
2010-07-29 23:48:03 +02:00
|
|
|
error = PTR_ERR(data);
|
|
|
|
if (!IS_ERR(data)) {
|
2017-01-16 09:42:58 +01:00
|
|
|
error = aa_replace_profiles(ns ? ns : profile->ns, profile,
|
|
|
|
binop, data);
|
2017-01-16 09:42:55 +01:00
|
|
|
aa_put_loaddata(data);
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* .load file hook fn to load policy */
|
2017-01-16 09:42:55 +01:00
|
|
|
static ssize_t profile_load(struct file *f, const char __user *buf, size_t size,
|
|
|
|
loff_t *pos)
|
|
|
|
{
|
2017-01-16 09:42:58 +01:00
|
|
|
struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
|
|
|
|
int error = policy_update(PROF_ADD, buf, size, pos, ns);
|
|
|
|
|
|
|
|
aa_put_ns(ns);
|
2017-01-16 09:42:55 +01:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-07-29 23:48:03 +02:00
|
|
|
static const struct file_operations aa_fs_profile_load = {
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 18:52:59 +02:00
|
|
|
.write = profile_load,
|
|
|
|
.llseek = default_llseek,
|
2010-07-29 23:48:03 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* .replace file hook fn to load and/or replace policy */
|
|
|
|
static ssize_t profile_replace(struct file *f, const char __user *buf,
|
|
|
|
size_t size, loff_t *pos)
|
|
|
|
{
|
2017-01-16 09:42:58 +01:00
|
|
|
struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
|
|
|
|
int error = policy_update(PROF_REPLACE, buf, size, pos, ns);
|
|
|
|
|
|
|
|
aa_put_ns(ns);
|
2010-07-29 23:48:03 +02:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profile_replace = {
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 18:52:59 +02:00
|
|
|
.write = profile_replace,
|
|
|
|
.llseek = default_llseek,
|
2010-07-29 23:48:03 +02:00
|
|
|
};
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* .remove file hook fn to remove loaded policy */
|
2010-07-29 23:48:03 +02:00
|
|
|
static ssize_t profile_remove(struct file *f, const char __user *buf,
|
|
|
|
size_t size, loff_t *pos)
|
|
|
|
{
|
2017-01-16 09:42:55 +01:00
|
|
|
struct aa_loaddata *data;
|
|
|
|
struct aa_profile *profile;
|
2010-07-29 23:48:03 +02:00
|
|
|
ssize_t error;
|
2017-01-16 09:42:58 +01:00
|
|
|
struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2017-01-16 09:42:55 +01:00
|
|
|
profile = aa_current_profile();
|
|
|
|
/* high level check about policy management - fine grained in
|
|
|
|
* below after unpack
|
|
|
|
*/
|
2017-01-16 09:42:58 +01:00
|
|
|
error = aa_may_manage_policy(profile, ns, OP_PROF_RM);
|
2017-01-16 09:42:55 +01:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2010-07-29 23:48:03 +02:00
|
|
|
/*
|
|
|
|
* aa_remove_profile needs a null terminated string so 1 extra
|
|
|
|
* byte is allocated and the copied data is null terminated.
|
|
|
|
*/
|
2017-01-16 09:43:03 +01:00
|
|
|
data = aa_simple_write_to_buffer(buf, size + 1, size, pos);
|
2010-07-29 23:48:03 +02:00
|
|
|
|
|
|
|
error = PTR_ERR(data);
|
|
|
|
if (!IS_ERR(data)) {
|
2017-01-16 09:42:55 +01:00
|
|
|
data->data[size] = 0;
|
2017-01-16 09:42:58 +01:00
|
|
|
error = aa_remove_profiles(ns ? ns : profile->ns, profile,
|
|
|
|
data->data, size);
|
2017-01-16 09:42:55 +01:00
|
|
|
aa_put_loaddata(data);
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
2017-01-16 09:42:55 +01:00
|
|
|
out:
|
2017-01-16 09:42:58 +01:00
|
|
|
aa_put_ns(ns);
|
2010-07-29 23:48:03 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profile_remove = {
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 18:52:59 +02:00
|
|
|
.write = profile_remove,
|
|
|
|
.llseek = default_llseek,
|
2010-07-29 23:48:03 +02:00
|
|
|
};
|
|
|
|
|
2012-01-27 01:29:21 +01:00
|
|
|
static int aa_fs_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct aa_fs_entry *fs_file = seq->private;
|
|
|
|
|
|
|
|
if (!fs_file)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (fs_file->v_type) {
|
|
|
|
case AA_FS_TYPE_BOOLEAN:
|
|
|
|
seq_printf(seq, "%s\n", fs_file->v.boolean ? "yes" : "no");
|
|
|
|
break;
|
2012-01-27 01:29:22 +01:00
|
|
|
case AA_FS_TYPE_STRING:
|
|
|
|
seq_printf(seq, "%s\n", fs_file->v.string);
|
|
|
|
break;
|
2012-01-27 01:29:21 +01:00
|
|
|
case AA_FS_TYPE_U64:
|
|
|
|
seq_printf(seq, "%#08lx\n", fs_file->v.u64);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Ignore unpritable entry types. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, aa_fs_seq_show, inode->i_private);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct file_operations aa_fs_seq_file_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
static int aa_fs_seq_profile_open(struct inode *inode, struct file *file,
|
|
|
|
int (*show)(struct seq_file *, void *))
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = aa_get_proxy(inode->i_private);
|
|
|
|
int error = single_open(file, show, proxy);
|
2013-07-11 06:13:43 +02:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
file->private_data = NULL;
|
2017-01-16 09:42:19 +01:00
|
|
|
aa_put_proxy(proxy);
|
2013-07-11 06:13:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_profile_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct seq_file *seq = (struct seq_file *) file->private_data;
|
|
|
|
if (seq)
|
2017-01-16 09:42:19 +01:00
|
|
|
aa_put_proxy(seq->private);
|
2013-07-11 06:13:43 +02:00
|
|
|
return single_release(inode, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_profname_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
2013-07-11 06:13:43 +02:00
|
|
|
seq_printf(seq, "%s\n", profile->base.name);
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_profname_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profname_show);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profname_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_profname_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = aa_fs_seq_profile_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int aa_fs_seq_profmode_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
2013-07-11 06:13:43 +02:00
|
|
|
seq_printf(seq, "%s\n", aa_profile_mode_names[profile->mode]);
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_profmode_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profmode_show);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profmode_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_profmode_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = aa_fs_seq_profile_release,
|
|
|
|
};
|
|
|
|
|
2013-07-11 06:17:43 +02:00
|
|
|
static int aa_fs_seq_profattach_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
2013-07-11 06:17:43 +02:00
|
|
|
if (profile->attach)
|
|
|
|
seq_printf(seq, "%s\n", profile->attach);
|
|
|
|
else if (profile->xmatch)
|
|
|
|
seq_puts(seq, "<unknown>\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "%s\n", profile->base.name);
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_profattach_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profattach_show);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profattach_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_profattach_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = aa_fs_seq_profile_release,
|
|
|
|
};
|
|
|
|
|
2013-08-14 20:27:36 +02:00
|
|
|
static int aa_fs_seq_hash_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
2013-08-14 20:27:36 +02:00
|
|
|
unsigned int i, size = aa_hash_size();
|
|
|
|
|
|
|
|
if (profile->hash) {
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
seq_printf(seq, "%.2x", profile->hash[i]);
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
2015-11-18 20:41:05 +01:00
|
|
|
aa_put_profile(profile);
|
2013-08-14 20:27:36 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_hash_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, aa_fs_seq_hash_show, inode->i_private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_seq_hash_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_hash_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2017-01-16 09:42:48 +01:00
|
|
|
|
2017-01-16 09:42:45 +01:00
|
|
|
static int aa_fs_seq_show_ns_level(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct aa_ns *ns = aa_current_profile()->ns;
|
|
|
|
|
|
|
|
seq_printf(seq, "%d\n", ns->level);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_open_ns_level(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, aa_fs_seq_show_ns_level, inode->i_private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_ns_level = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_open_ns_level,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2017-01-16 09:42:48 +01:00
|
|
|
static int aa_fs_seq_show_ns_name(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct aa_ns *ns = aa_current_profile()->ns;
|
|
|
|
|
|
|
|
seq_printf(seq, "%s\n", ns->base.name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_open_ns_name(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, aa_fs_seq_show_ns_name, inode->i_private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_ns_name = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_open_ns_name,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2017-01-16 09:42:55 +01:00
|
|
|
static int rawdata_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
/* TODO: switch to loaddata when profile switched to symlink */
|
|
|
|
aa_put_loaddata(file->private_data);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_raw_abi_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
|
|
|
|
|
|
|
if (profile->rawdata->abi) {
|
|
|
|
seq_printf(seq, "v%d", profile->rawdata->abi);
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_raw_abi_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return aa_fs_seq_profile_open(inode, file, aa_fs_seq_raw_abi_show);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_seq_raw_abi_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_raw_abi_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = aa_fs_seq_profile_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int aa_fs_seq_raw_hash_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct aa_proxy *proxy = seq->private;
|
|
|
|
struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
|
|
|
|
unsigned int i, size = aa_hash_size();
|
|
|
|
|
|
|
|
if (profile->rawdata->hash) {
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
seq_printf(seq, "%.2x", profile->rawdata->hash[i]);
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_fs_seq_raw_hash_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return aa_fs_seq_profile_open(inode, file, aa_fs_seq_raw_hash_show);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_seq_raw_hash_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = aa_fs_seq_raw_hash_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = aa_fs_seq_profile_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t rawdata_read(struct file *file, char __user *buf, size_t size,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct aa_loaddata *rawdata = file->private_data;
|
|
|
|
|
|
|
|
return simple_read_from_buffer(buf, size, ppos, rawdata->data,
|
|
|
|
rawdata->size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rawdata_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct aa_proxy *proxy = inode->i_private;
|
|
|
|
struct aa_profile *profile;
|
|
|
|
|
|
|
|
if (!policy_view_capable(NULL))
|
|
|
|
return -EACCES;
|
|
|
|
profile = aa_get_profile_rcu(&proxy->profile);
|
|
|
|
file->private_data = aa_get_loaddata(profile->rawdata);
|
|
|
|
aa_put_profile(profile);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_rawdata_fops = {
|
|
|
|
.open = rawdata_open,
|
|
|
|
.read = rawdata_read,
|
|
|
|
.llseek = generic_file_llseek,
|
|
|
|
.release = rawdata_release,
|
|
|
|
};
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
/** fns to setup dynamic per profile/namespace files **/
|
|
|
|
void __aa_fs_profile_rmdir(struct aa_profile *profile)
|
|
|
|
{
|
|
|
|
struct aa_profile *child;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!profile)
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(child, &profile->base.profiles, base.list)
|
|
|
|
__aa_fs_profile_rmdir(child);
|
|
|
|
|
|
|
|
for (i = AAFS_PROF_SIZEOF - 1; i >= 0; --i) {
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy;
|
2013-07-11 06:13:43 +02:00
|
|
|
if (!profile->dents[i])
|
|
|
|
continue;
|
|
|
|
|
2017-01-16 09:42:19 +01:00
|
|
|
proxy = d_inode(profile->dents[i])->i_private;
|
2013-07-11 06:13:43 +02:00
|
|
|
securityfs_remove(profile->dents[i]);
|
2017-01-16 09:42:19 +01:00
|
|
|
aa_put_proxy(proxy);
|
2013-07-11 06:13:43 +02:00
|
|
|
profile->dents[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void __aa_fs_profile_migrate_dents(struct aa_profile *old,
|
|
|
|
struct aa_profile *new)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < AAFS_PROF_SIZEOF; i++) {
|
|
|
|
new->dents[i] = old->dents[i];
|
2014-07-25 13:01:56 +02:00
|
|
|
if (new->dents[i])
|
2016-09-14 16:48:04 +02:00
|
|
|
new->dents[i]->d_inode->i_mtime = current_time(new->dents[i]->d_inode);
|
2013-07-11 06:13:43 +02:00
|
|
|
old->dents[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *create_profile_file(struct dentry *dir, const char *name,
|
|
|
|
struct aa_profile *profile,
|
|
|
|
const struct file_operations *fops)
|
|
|
|
{
|
2017-01-16 09:42:19 +01:00
|
|
|
struct aa_proxy *proxy = aa_get_proxy(profile->proxy);
|
2013-07-11 06:13:43 +02:00
|
|
|
struct dentry *dent;
|
|
|
|
|
2017-01-16 09:42:19 +01:00
|
|
|
dent = securityfs_create_file(name, S_IFREG | 0444, dir, proxy, fops);
|
2013-07-11 06:13:43 +02:00
|
|
|
if (IS_ERR(dent))
|
2017-01-16 09:42:19 +01:00
|
|
|
aa_put_proxy(proxy);
|
2013-07-11 06:13:43 +02:00
|
|
|
|
|
|
|
return dent;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* requires lock be held */
|
|
|
|
int __aa_fs_profile_mkdir(struct aa_profile *profile, struct dentry *parent)
|
|
|
|
{
|
|
|
|
struct aa_profile *child;
|
|
|
|
struct dentry *dent = NULL, *dir;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!parent) {
|
|
|
|
struct aa_profile *p;
|
|
|
|
p = aa_deref_parent(profile);
|
|
|
|
dent = prof_dir(p);
|
|
|
|
/* adding to parent that previously didn't have children */
|
|
|
|
dent = securityfs_create_dir("profiles", dent);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
prof_child_dir(p) = parent = dent;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!profile->dirname) {
|
|
|
|
int len, id_len;
|
|
|
|
len = mangle_name(profile->base.name, NULL);
|
|
|
|
id_len = snprintf(NULL, 0, ".%ld", profile->ns->uniq_id);
|
|
|
|
|
|
|
|
profile->dirname = kmalloc(len + id_len + 1, GFP_KERNEL);
|
|
|
|
if (!profile->dirname)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
mangle_name(profile->base.name, profile->dirname);
|
|
|
|
sprintf(profile->dirname + len, ".%ld", profile->ns->uniq_id++);
|
|
|
|
}
|
|
|
|
|
|
|
|
dent = securityfs_create_dir(profile->dirname, parent);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
prof_dir(profile) = dir = dent;
|
|
|
|
|
|
|
|
dent = create_profile_file(dir, "name", profile, &aa_fs_profname_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_NAME] = dent;
|
|
|
|
|
|
|
|
dent = create_profile_file(dir, "mode", profile, &aa_fs_profmode_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_MODE] = dent;
|
|
|
|
|
2013-07-11 06:17:43 +02:00
|
|
|
dent = create_profile_file(dir, "attach", profile,
|
|
|
|
&aa_fs_profattach_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_ATTACH] = dent;
|
|
|
|
|
2013-08-14 20:27:36 +02:00
|
|
|
if (profile->hash) {
|
|
|
|
dent = create_profile_file(dir, "sha1", profile,
|
|
|
|
&aa_fs_seq_hash_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_HASH] = dent;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:55 +01:00
|
|
|
if (profile->rawdata) {
|
|
|
|
dent = create_profile_file(dir, "raw_sha1", profile,
|
|
|
|
&aa_fs_seq_raw_hash_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_RAW_HASH] = dent;
|
|
|
|
|
|
|
|
dent = create_profile_file(dir, "raw_abi", profile,
|
|
|
|
&aa_fs_seq_raw_abi_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_RAW_ABI] = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file("raw_data", S_IFREG | 0444, dir,
|
|
|
|
profile->proxy,
|
|
|
|
&aa_fs_rawdata_fops);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
|
|
|
profile->dents[AAFS_PROF_RAW_DATA] = dent;
|
|
|
|
d_inode(dent)->i_size = profile->rawdata->size;
|
|
|
|
aa_get_proxy(profile->proxy);
|
|
|
|
}
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
list_for_each_entry(child, &profile->base.profiles, base.list) {
|
|
|
|
error = __aa_fs_profile_mkdir(child, prof_child_dir(profile));
|
|
|
|
if (error)
|
|
|
|
goto fail2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
|
|
|
|
fail2:
|
|
|
|
__aa_fs_profile_rmdir(profile);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:16 +01:00
|
|
|
void __aa_fs_ns_rmdir(struct aa_ns *ns)
|
2013-07-11 06:13:43 +02:00
|
|
|
{
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *sub;
|
2013-07-11 06:13:43 +02:00
|
|
|
struct aa_profile *child;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!ns)
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(child, &ns->base.profiles, base.list)
|
|
|
|
__aa_fs_profile_rmdir(child);
|
|
|
|
|
|
|
|
list_for_each_entry(sub, &ns->sub_ns, base.list) {
|
|
|
|
mutex_lock(&sub->lock);
|
2017-01-16 09:42:16 +01:00
|
|
|
__aa_fs_ns_rmdir(sub);
|
2013-07-11 06:13:43 +02:00
|
|
|
mutex_unlock(&sub->lock);
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
if (ns_subns_dir(ns)) {
|
|
|
|
sub = d_inode(ns_subns_dir(ns))->i_private;
|
|
|
|
aa_put_ns(sub);
|
|
|
|
}
|
|
|
|
if (ns_subload(ns)) {
|
|
|
|
sub = d_inode(ns_subload(ns))->i_private;
|
|
|
|
aa_put_ns(sub);
|
|
|
|
}
|
|
|
|
if (ns_subreplace(ns)) {
|
|
|
|
sub = d_inode(ns_subreplace(ns))->i_private;
|
|
|
|
aa_put_ns(sub);
|
|
|
|
}
|
|
|
|
if (ns_subremove(ns)) {
|
|
|
|
sub = d_inode(ns_subremove(ns))->i_private;
|
|
|
|
aa_put_ns(sub);
|
|
|
|
}
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
for (i = AAFS_NS_SIZEOF - 1; i >= 0; --i) {
|
|
|
|
securityfs_remove(ns->dents[i]);
|
|
|
|
ns->dents[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* assumes cleanup in caller */
|
|
|
|
static int __aa_fs_ns_mkdir_entries(struct aa_ns *ns, struct dentry *dir)
|
|
|
|
{
|
|
|
|
struct dentry *dent;
|
|
|
|
|
|
|
|
AA_BUG(!ns);
|
|
|
|
AA_BUG(!dir);
|
|
|
|
|
|
|
|
dent = securityfs_create_dir("profiles", dir);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
ns_subprofs_dir(ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_dir("raw_data", dir);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
ns_subdata_dir(ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file(".load", 0640, dir, ns,
|
|
|
|
&aa_fs_profile_load);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
aa_get_ns(ns);
|
|
|
|
ns_subload(ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file(".replace", 0640, dir, ns,
|
|
|
|
&aa_fs_profile_replace);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
aa_get_ns(ns);
|
|
|
|
ns_subreplace(ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file(".remove", 0640, dir, ns,
|
|
|
|
&aa_fs_profile_remove);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
aa_get_ns(ns);
|
|
|
|
ns_subremove(ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_dir("namespaces", dir);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
return PTR_ERR(dent);
|
|
|
|
aa_get_ns(ns);
|
|
|
|
ns_subns_dir(ns) = dent;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:16 +01:00
|
|
|
int __aa_fs_ns_mkdir(struct aa_ns *ns, struct dentry *parent, const char *name)
|
2013-07-11 06:13:43 +02:00
|
|
|
{
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *sub;
|
2013-07-11 06:13:43 +02:00
|
|
|
struct aa_profile *child;
|
|
|
|
struct dentry *dent, *dir;
|
|
|
|
int error;
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
AA_BUG(!ns);
|
|
|
|
AA_BUG(!parent);
|
|
|
|
AA_BUG(!mutex_is_locked(&ns->lock));
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
if (!name)
|
|
|
|
name = ns->base.name;
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* create ns dir if it doesn't already exist */
|
2013-07-11 06:13:43 +02:00
|
|
|
dent = securityfs_create_dir(name, parent);
|
|
|
|
if (IS_ERR(dent))
|
|
|
|
goto fail;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
ns_dir(ns) = dir = dent;
|
|
|
|
error = __aa_fs_ns_mkdir_entries(ns, dir);
|
|
|
|
if (error)
|
|
|
|
goto fail2;
|
2013-07-11 06:13:43 +02:00
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* profiles */
|
2013-07-11 06:13:43 +02:00
|
|
|
list_for_each_entry(child, &ns->base.profiles, base.list) {
|
|
|
|
error = __aa_fs_profile_mkdir(child, ns_subprofs_dir(ns));
|
|
|
|
if (error)
|
|
|
|
goto fail2;
|
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
/* subnamespaces */
|
2013-07-11 06:13:43 +02:00
|
|
|
list_for_each_entry(sub, &ns->sub_ns, base.list) {
|
|
|
|
mutex_lock(&sub->lock);
|
2017-01-16 09:42:16 +01:00
|
|
|
error = __aa_fs_ns_mkdir(sub, ns_subns_dir(ns), NULL);
|
2013-07-11 06:13:43 +02:00
|
|
|
mutex_unlock(&sub->lock);
|
|
|
|
if (error)
|
|
|
|
goto fail2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
|
|
|
|
fail2:
|
2017-01-16 09:42:16 +01:00
|
|
|
__aa_fs_ns_rmdir(ns);
|
2013-07-11 06:13:43 +02:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-11 06:18:43 +02:00
|
|
|
#define list_entry_is_head(pos, head, member) (&pos->member == (head))
|
|
|
|
|
|
|
|
/**
|
2017-01-16 09:42:16 +01:00
|
|
|
* __next_ns - find the next namespace to list
|
2013-07-11 06:18:43 +02:00
|
|
|
* @root: root namespace to stop search at (NOT NULL)
|
|
|
|
* @ns: current ns position (NOT NULL)
|
|
|
|
*
|
|
|
|
* Find the next namespace from @ns under @root and handle all locking needed
|
|
|
|
* while switching current namespace.
|
|
|
|
*
|
|
|
|
* Returns: next namespace or NULL if at last namespace under @root
|
|
|
|
* Requires: ns->parent->lock to be held
|
|
|
|
* NOTE: will not unlock root->lock
|
|
|
|
*/
|
2017-01-16 09:42:16 +01:00
|
|
|
static struct aa_ns *__next_ns(struct aa_ns *root, struct aa_ns *ns)
|
2013-07-11 06:18:43 +02:00
|
|
|
{
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *parent, *next;
|
2013-07-11 06:18:43 +02:00
|
|
|
|
|
|
|
/* is next namespace a child */
|
|
|
|
if (!list_empty(&ns->sub_ns)) {
|
|
|
|
next = list_first_entry(&ns->sub_ns, typeof(*ns), base.list);
|
|
|
|
mutex_lock(&next->lock);
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if the next ns is a sibling, parent, gp, .. */
|
|
|
|
parent = ns->parent;
|
2013-10-14 20:46:27 +02:00
|
|
|
while (ns != root) {
|
2013-07-11 06:18:43 +02:00
|
|
|
mutex_unlock(&ns->lock);
|
2015-11-16 14:46:33 +01:00
|
|
|
next = list_next_entry(ns, base.list);
|
2013-07-11 06:18:43 +02:00
|
|
|
if (!list_entry_is_head(next, &parent->sub_ns, base.list)) {
|
|
|
|
mutex_lock(&next->lock);
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
ns = parent;
|
|
|
|
parent = parent->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __first_profile - find the first profile in a namespace
|
|
|
|
* @root: namespace that is root of profiles being displayed (NOT NULL)
|
|
|
|
* @ns: namespace to start in (NOT NULL)
|
|
|
|
*
|
|
|
|
* Returns: unrefcounted profile or NULL if no profile
|
|
|
|
* Requires: profile->ns.lock to be held
|
|
|
|
*/
|
2017-01-16 09:42:16 +01:00
|
|
|
static struct aa_profile *__first_profile(struct aa_ns *root,
|
|
|
|
struct aa_ns *ns)
|
2013-07-11 06:18:43 +02:00
|
|
|
{
|
2017-01-16 09:42:16 +01:00
|
|
|
for (; ns; ns = __next_ns(root, ns)) {
|
2013-07-11 06:18:43 +02:00
|
|
|
if (!list_empty(&ns->base.profiles))
|
|
|
|
return list_first_entry(&ns->base.profiles,
|
|
|
|
struct aa_profile, base.list);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __next_profile - step to the next profile in a profile tree
|
|
|
|
* @profile: current profile in tree (NOT NULL)
|
|
|
|
*
|
|
|
|
* Perform a depth first traversal on the profile tree in a namespace
|
|
|
|
*
|
|
|
|
* Returns: next profile or NULL if done
|
|
|
|
* Requires: profile->ns.lock to be held
|
|
|
|
*/
|
|
|
|
static struct aa_profile *__next_profile(struct aa_profile *p)
|
|
|
|
{
|
|
|
|
struct aa_profile *parent;
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *ns = p->ns;
|
2013-07-11 06:18:43 +02:00
|
|
|
|
|
|
|
/* is next profile a child */
|
|
|
|
if (!list_empty(&p->base.profiles))
|
|
|
|
return list_first_entry(&p->base.profiles, typeof(*p),
|
|
|
|
base.list);
|
|
|
|
|
|
|
|
/* is next profile a sibling, parent sibling, gp, sibling, .. */
|
|
|
|
parent = rcu_dereference_protected(p->parent,
|
|
|
|
mutex_is_locked(&p->ns->lock));
|
|
|
|
while (parent) {
|
2015-11-16 14:46:33 +01:00
|
|
|
p = list_next_entry(p, base.list);
|
2013-07-11 06:18:43 +02:00
|
|
|
if (!list_entry_is_head(p, &parent->base.profiles, base.list))
|
|
|
|
return p;
|
|
|
|
p = parent;
|
|
|
|
parent = rcu_dereference_protected(parent->parent,
|
|
|
|
mutex_is_locked(&parent->ns->lock));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* is next another profile in the namespace */
|
2015-11-16 14:46:33 +01:00
|
|
|
p = list_next_entry(p, base.list);
|
2013-07-11 06:18:43 +02:00
|
|
|
if (!list_entry_is_head(p, &ns->base.profiles, base.list))
|
|
|
|
return p;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* next_profile - step to the next profile in where ever it may be
|
|
|
|
* @root: root namespace (NOT NULL)
|
|
|
|
* @profile: current profile (NOT NULL)
|
|
|
|
*
|
|
|
|
* Returns: next profile or NULL if there isn't one
|
|
|
|
*/
|
2017-01-16 09:42:16 +01:00
|
|
|
static struct aa_profile *next_profile(struct aa_ns *root,
|
2013-07-11 06:18:43 +02:00
|
|
|
struct aa_profile *profile)
|
|
|
|
{
|
|
|
|
struct aa_profile *next = __next_profile(profile);
|
|
|
|
if (next)
|
|
|
|
return next;
|
|
|
|
|
|
|
|
/* finished all profiles in namespace move to next namespace */
|
2017-01-16 09:42:16 +01:00
|
|
|
return __first_profile(root, __next_ns(root, profile->ns));
|
2013-07-11 06:18:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p_start - start a depth first traversal of profile tree
|
|
|
|
* @f: seq_file to fill
|
|
|
|
* @pos: current position
|
|
|
|
*
|
|
|
|
* Returns: first profile under current namespace or NULL if none found
|
|
|
|
*
|
|
|
|
* acquires first ns->lock
|
|
|
|
*/
|
|
|
|
static void *p_start(struct seq_file *f, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct aa_profile *profile = NULL;
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *root = aa_current_profile()->ns;
|
2013-07-11 06:18:43 +02:00
|
|
|
loff_t l = *pos;
|
2017-01-16 09:42:16 +01:00
|
|
|
f->private = aa_get_ns(root);
|
2013-07-11 06:18:43 +02:00
|
|
|
|
|
|
|
|
|
|
|
/* find the first profile */
|
|
|
|
mutex_lock(&root->lock);
|
|
|
|
profile = __first_profile(root, root);
|
|
|
|
|
|
|
|
/* skip to position */
|
|
|
|
for (; profile && l > 0; l--)
|
|
|
|
profile = next_profile(root, profile);
|
|
|
|
|
|
|
|
return profile;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p_next - read the next profile entry
|
|
|
|
* @f: seq_file to fill
|
|
|
|
* @p: profile previously returned
|
|
|
|
* @pos: current position
|
|
|
|
*
|
|
|
|
* Returns: next profile after @p or NULL if none
|
|
|
|
*
|
|
|
|
* may acquire/release locks in namespace tree as necessary
|
|
|
|
*/
|
|
|
|
static void *p_next(struct seq_file *f, void *p, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct aa_profile *profile = p;
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *ns = f->private;
|
2013-07-11 06:18:43 +02:00
|
|
|
(*pos)++;
|
|
|
|
|
|
|
|
return next_profile(ns, profile);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p_stop - stop depth first traversal
|
|
|
|
* @f: seq_file we are filling
|
|
|
|
* @p: the last profile writen
|
|
|
|
*
|
|
|
|
* Release all locking done by p_start/p_next on namespace tree
|
|
|
|
*/
|
|
|
|
static void p_stop(struct seq_file *f, void *p)
|
|
|
|
{
|
|
|
|
struct aa_profile *profile = p;
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *root = f->private, *ns;
|
2013-07-11 06:18:43 +02:00
|
|
|
|
|
|
|
if (profile) {
|
|
|
|
for (ns = profile->ns; ns && ns != root; ns = ns->parent)
|
|
|
|
mutex_unlock(&ns->lock);
|
|
|
|
}
|
|
|
|
mutex_unlock(&root->lock);
|
2017-01-16 09:42:16 +01:00
|
|
|
aa_put_ns(root);
|
2013-07-11 06:18:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* seq_show_profile - show a profile entry
|
|
|
|
* @f: seq_file to file
|
|
|
|
* @p: current position (profile) (NOT NULL)
|
|
|
|
*
|
|
|
|
* Returns: error on failure
|
|
|
|
*/
|
|
|
|
static int seq_show_profile(struct seq_file *f, void *p)
|
|
|
|
{
|
|
|
|
struct aa_profile *profile = (struct aa_profile *)p;
|
2017-01-16 09:42:16 +01:00
|
|
|
struct aa_ns *root = f->private;
|
2013-07-11 06:18:43 +02:00
|
|
|
|
|
|
|
if (profile->ns != root)
|
2017-01-16 09:42:25 +01:00
|
|
|
seq_printf(f, ":%s://", aa_ns_name(root, profile->ns, true));
|
2013-07-11 06:18:43 +02:00
|
|
|
seq_printf(f, "%s (%s)\n", profile->base.hname,
|
|
|
|
aa_profile_mode_names[profile->mode]);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations aa_fs_profiles_op = {
|
|
|
|
.start = p_start,
|
|
|
|
.next = p_next,
|
|
|
|
.stop = p_stop,
|
|
|
|
.show = seq_show_profile,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int profiles_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2017-01-16 09:42:55 +01:00
|
|
|
if (!policy_view_capable(NULL))
|
|
|
|
return -EACCES;
|
|
|
|
|
2013-07-11 06:18:43 +02:00
|
|
|
return seq_open(file, &aa_fs_profiles_op);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int profiles_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return seq_release(inode, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations aa_fs_profiles_fops = {
|
|
|
|
.open = profiles_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = profiles_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
/** Base file system setup **/
|
2012-01-27 01:29:22 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry_file[] = {
|
|
|
|
AA_FS_FILE_STRING("mask", "create read write exec append mmap_exec " \
|
|
|
|
"link lock"),
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2012-01-27 01:29:21 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry_domain[] = {
|
|
|
|
AA_FS_FILE_BOOLEAN("change_hat", 1),
|
|
|
|
AA_FS_FILE_BOOLEAN("change_hatv", 1),
|
|
|
|
AA_FS_FILE_BOOLEAN("change_onexec", 1),
|
|
|
|
AA_FS_FILE_BOOLEAN("change_profile", 1),
|
2017-01-16 09:42:43 +01:00
|
|
|
AA_FS_FILE_BOOLEAN("fix_binfmt_elf_mmap", 1),
|
2017-01-16 09:43:06 +01:00
|
|
|
AA_FS_FILE_STRING("version", "1.2"),
|
2012-01-27 01:29:21 +01:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2017-01-16 09:42:39 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry_versions[] = {
|
|
|
|
AA_FS_FILE_BOOLEAN("v5", 1),
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2013-07-11 06:04:43 +02:00
|
|
|
static struct aa_fs_entry aa_fs_entry_policy[] = {
|
2017-01-16 09:42:39 +01:00
|
|
|
AA_FS_DIR("versions", aa_fs_entry_versions),
|
|
|
|
AA_FS_FILE_BOOLEAN("set_load", 1),
|
|
|
|
{ }
|
2013-07-11 06:04:43 +02:00
|
|
|
};
|
|
|
|
|
2012-01-27 01:29:21 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry_features[] = {
|
2013-07-11 06:04:43 +02:00
|
|
|
AA_FS_DIR("policy", aa_fs_entry_policy),
|
2012-01-27 01:29:21 +01:00
|
|
|
AA_FS_DIR("domain", aa_fs_entry_domain),
|
2012-01-27 01:29:22 +01:00
|
|
|
AA_FS_DIR("file", aa_fs_entry_file),
|
2012-01-27 01:29:21 +01:00
|
|
|
AA_FS_FILE_U64("capability", VFS_CAP_FLAGS_MASK),
|
2012-01-27 01:29:23 +01:00
|
|
|
AA_FS_DIR("rlimit", aa_fs_entry_rlimit),
|
2013-08-14 20:27:32 +02:00
|
|
|
AA_FS_DIR("caps", aa_fs_entry_caps),
|
2012-01-27 01:29:21 +01:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry_apparmor[] = {
|
2017-01-16 09:42:45 +01:00
|
|
|
AA_FS_FILE_FOPS(".ns_level", 0666, &aa_fs_ns_level),
|
2017-01-16 09:42:48 +01:00
|
|
|
AA_FS_FILE_FOPS(".ns_name", 0640, &aa_fs_ns_name),
|
2017-01-16 09:42:58 +01:00
|
|
|
AA_FS_FILE_FOPS("profiles", 0440, &aa_fs_profiles_fops),
|
2012-01-27 01:29:21 +01:00
|
|
|
AA_FS_DIR("features", aa_fs_entry_features),
|
2012-01-27 01:29:20 +01:00
|
|
|
{ }
|
|
|
|
};
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
static struct aa_fs_entry aa_fs_entry =
|
|
|
|
AA_FS_DIR("apparmor", aa_fs_entry_apparmor);
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
/**
|
|
|
|
* aafs_create_file - create a file entry in the apparmor securityfs
|
|
|
|
* @fs_file: aa_fs_entry to build an entry for (NOT NULL)
|
|
|
|
* @parent: the parent dentry in the securityfs
|
|
|
|
*
|
|
|
|
* Use aafs_remove_file to remove entries created with this fn.
|
|
|
|
*/
|
|
|
|
static int __init aafs_create_file(struct aa_fs_entry *fs_file,
|
|
|
|
struct dentry *parent)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
fs_file->dentry = securityfs_create_file(fs_file->name,
|
|
|
|
S_IFREG | fs_file->mode,
|
|
|
|
parent, fs_file,
|
|
|
|
fs_file->file_ops);
|
|
|
|
if (IS_ERR(fs_file->dentry)) {
|
|
|
|
error = PTR_ERR(fs_file->dentry);
|
|
|
|
fs_file->dentry = NULL;
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
2012-01-27 01:29:20 +01:00
|
|
|
return error;
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir);
|
2010-07-29 23:48:03 +02:00
|
|
|
/**
|
2012-01-27 01:29:20 +01:00
|
|
|
* aafs_create_dir - recursively create a directory entry in the securityfs
|
|
|
|
* @fs_dir: aa_fs_entry (and all child entries) to build (NOT NULL)
|
|
|
|
* @parent: the parent dentry in the securityfs
|
2010-07-29 23:48:03 +02:00
|
|
|
*
|
2012-01-27 01:29:20 +01:00
|
|
|
* Use aafs_remove_dir to remove entries created with this fn.
|
2010-07-29 23:48:03 +02:00
|
|
|
*/
|
2012-01-27 01:29:20 +01:00
|
|
|
static int __init aafs_create_dir(struct aa_fs_entry *fs_dir,
|
|
|
|
struct dentry *parent)
|
2010-07-29 23:48:03 +02:00
|
|
|
{
|
2012-01-27 01:29:20 +01:00
|
|
|
struct aa_fs_entry *fs_file;
|
2013-07-11 06:13:43 +02:00
|
|
|
struct dentry *dir;
|
|
|
|
int error;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
dir = securityfs_create_dir(fs_dir->name, parent);
|
|
|
|
if (IS_ERR(dir))
|
|
|
|
return PTR_ERR(dir);
|
|
|
|
fs_dir->dentry = dir;
|
2010-07-29 23:48:03 +02:00
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
|
2012-01-27 01:29:20 +01:00
|
|
|
if (fs_file->v_type == AA_FS_TYPE_DIR)
|
|
|
|
error = aafs_create_dir(fs_file, fs_dir->dentry);
|
|
|
|
else
|
|
|
|
error = aafs_create_file(fs_file, fs_dir->dentry);
|
|
|
|
if (error)
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
failed:
|
2013-07-11 06:13:43 +02:00
|
|
|
aafs_remove_dir(fs_dir);
|
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* aafs_remove_file - drop a single file entry in the apparmor securityfs
|
|
|
|
* @fs_file: aa_fs_entry to detach from the securityfs (NOT NULL)
|
|
|
|
*/
|
|
|
|
static void __init aafs_remove_file(struct aa_fs_entry *fs_file)
|
|
|
|
{
|
|
|
|
if (!fs_file->dentry)
|
|
|
|
return;
|
|
|
|
|
|
|
|
securityfs_remove(fs_file->dentry);
|
|
|
|
fs_file->dentry = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* aafs_remove_dir - recursively drop a directory entry from the securityfs
|
|
|
|
* @fs_dir: aa_fs_entry (and all child entries) to detach (NOT NULL)
|
|
|
|
*/
|
|
|
|
static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir)
|
|
|
|
{
|
|
|
|
struct aa_fs_entry *fs_file;
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
|
2012-01-27 01:29:20 +01:00
|
|
|
if (fs_file->v_type == AA_FS_TYPE_DIR)
|
|
|
|
aafs_remove_dir(fs_file);
|
|
|
|
else
|
|
|
|
aafs_remove_file(fs_file);
|
|
|
|
}
|
|
|
|
|
|
|
|
aafs_remove_file(fs_dir);
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* aa_destroy_aafs - cleanup and free aafs
|
|
|
|
*
|
|
|
|
* releases dentries allocated by aa_create_aafs
|
|
|
|
*/
|
|
|
|
void __init aa_destroy_aafs(void)
|
|
|
|
{
|
2012-01-27 01:29:20 +01:00
|
|
|
aafs_remove_dir(&aa_fs_entry);
|
2010-07-29 23:48:03 +02:00
|
|
|
}
|
|
|
|
|
2017-01-16 09:42:45 +01:00
|
|
|
|
|
|
|
#define NULL_FILE_NAME ".null"
|
|
|
|
struct path aa_null;
|
|
|
|
|
|
|
|
static int aa_mk_null_file(struct dentry *parent)
|
|
|
|
{
|
|
|
|
struct vfsmount *mount = NULL;
|
|
|
|
struct dentry *dentry;
|
|
|
|
struct inode *inode;
|
|
|
|
int count = 0;
|
|
|
|
int error = simple_pin_fs(parent->d_sb->s_type, &mount, &count);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
inode_lock(d_inode(parent));
|
|
|
|
dentry = lookup_one_len(NULL_FILE_NAME, parent, strlen(NULL_FILE_NAME));
|
|
|
|
if (IS_ERR(dentry)) {
|
|
|
|
error = PTR_ERR(dentry);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
inode = new_inode(parent->d_inode->i_sb);
|
|
|
|
if (!inode) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto out1;
|
|
|
|
}
|
|
|
|
|
|
|
|
inode->i_ino = get_next_ino();
|
|
|
|
inode->i_mode = S_IFCHR | S_IRUGO | S_IWUGO;
|
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
|
|
init_special_inode(inode, S_IFCHR | S_IRUGO | S_IWUGO,
|
|
|
|
MKDEV(MEM_MAJOR, 3));
|
|
|
|
d_instantiate(dentry, inode);
|
|
|
|
aa_null.dentry = dget(dentry);
|
|
|
|
aa_null.mnt = mntget(mount);
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out1:
|
|
|
|
dput(dentry);
|
|
|
|
out:
|
|
|
|
inode_unlock(d_inode(parent));
|
|
|
|
simple_release_fs(&mount, &count);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-07-29 23:48:03 +02:00
|
|
|
/**
|
|
|
|
* aa_create_aafs - create the apparmor security filesystem
|
|
|
|
*
|
|
|
|
* dentries created here are released by aa_destroy_aafs
|
|
|
|
*
|
|
|
|
* Returns: error on failure
|
|
|
|
*/
|
2011-08-17 03:05:21 +02:00
|
|
|
static int __init aa_create_aafs(void)
|
2010-07-29 23:48:03 +02:00
|
|
|
{
|
2017-01-16 09:42:58 +01:00
|
|
|
struct dentry *dent;
|
2010-07-29 23:48:03 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!apparmor_initialized)
|
|
|
|
return 0;
|
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
if (aa_fs_entry.dentry) {
|
2010-07-29 23:48:03 +02:00
|
|
|
AA_ERROR("%s: AppArmor securityfs already exists\n", __func__);
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
|
|
|
|
2012-01-27 01:29:20 +01:00
|
|
|
/* Populate fs tree. */
|
|
|
|
error = aafs_create_dir(&aa_fs_entry, NULL);
|
2010-07-29 23:48:03 +02:00
|
|
|
if (error)
|
|
|
|
goto error;
|
|
|
|
|
2017-01-16 09:42:58 +01:00
|
|
|
dent = securityfs_create_file(".load", 0666, aa_fs_entry.dentry,
|
|
|
|
NULL, &aa_fs_profile_load);
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ns_subload(root_ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file(".replace", 0666, aa_fs_entry.dentry,
|
|
|
|
NULL, &aa_fs_profile_replace);
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ns_subreplace(root_ns) = dent;
|
|
|
|
|
|
|
|
dent = securityfs_create_file(".remove", 0666, aa_fs_entry.dentry,
|
|
|
|
NULL, &aa_fs_profile_remove);
|
|
|
|
if (IS_ERR(dent)) {
|
|
|
|
error = PTR_ERR(dent);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ns_subremove(root_ns) = dent;
|
|
|
|
|
|
|
|
mutex_lock(&root_ns->lock);
|
2017-01-16 09:42:16 +01:00
|
|
|
error = __aa_fs_ns_mkdir(root_ns, aa_fs_entry.dentry, "policy");
|
2017-01-16 09:42:58 +01:00
|
|
|
mutex_unlock(&root_ns->lock);
|
|
|
|
|
2013-07-11 06:13:43 +02:00
|
|
|
if (error)
|
|
|
|
goto error;
|
|
|
|
|
2017-01-16 09:42:45 +01:00
|
|
|
error = aa_mk_null_file(aa_fs_entry.dentry);
|
|
|
|
if (error)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* TODO: add default profile to apparmorfs */
|
2010-07-29 23:48:03 +02:00
|
|
|
|
|
|
|
/* Report that AppArmor fs is enabled */
|
|
|
|
aa_info_message("AppArmor Filesystem Enabled");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
aa_destroy_aafs();
|
|
|
|
AA_ERROR("Error creating AppArmor securityfs\n");
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_initcall(aa_create_aafs);
|