Hi list,
Preface:
--------
This is RFC v3 to modernize procfs and make it able to support multiple
private instances per the same pid namespace.
I have been working on this with Alexey Gladkov and Andy Lutomirski.
RFC v1 is here:
https://lkml.org/lkml/2017/3/30/670
RFC v2 is here:
https://lkml.org/lkml/2017/4/25/282
This RFC v3 can be applied on top of next-20171109
This RFC was tested on Ubuntu/Debian and Alexey tested it on altlinux.
It does not work on Fedora due to a bug during boot with dracut, I did
not have time to investigate it more. I will make sure to fix it next
iteration. We decided to send it to get more feedback on the direction,
we will continue to improve it.
RFC v3 handles all previous comments from Andy Lutomirski, thank you for
all the feedback.
Procfs modernization:
---------------------
Historically procfs was always tied to pid namespaces, during pid
namespace creation we internally create a procfs mount for it. However,
this has the effect that all new procfs mounts are just a mirror of the
internal one, any change, any mount option update, any new future
introduction will propagate to all other procfs mounts that are in the
same pid namespace.
This may have solved several use cases in that time. However today we
face new requirements, and making procfs able to support new private
instances inside same pid namespace seems a major point. If we want to
to introduce new features and security mechanisms we have to make sure
first that we do not break existing usecases. Supporting private procfs
instances wil allow to support new features and behaviour without
propagating it to all other procfs mounts.
Today procfs is more of a burden especially to some Embedded, IoT,
sandbox, container use cases. In user space we are over-mounting null
or inaccessible files on top to hide files and information. If we want
to hide pids we have to create PID namespaces otherwise mount options
propagate to all other proc mounts, changing a mount option value in one
mount will propagate to all other proc mounts. If we want to introduce
new features, then they will propagate to all other mounts too, resulting
either maybe new useful functionality or maybe breaking stuff. We have
also to note that userspace should not workaround procfs, the kernel
should just provide a sane simple interface.
In this regard several developers and maintainers pointed out that
there are problems with procfs and it has to be modernized:
"Here's another one: split up and modernize /proc." by Andy Lutomirski [1]
Discussion about kernel pointer leaks:
"And yes, as Kees and Daniel mentioned, it's definitely not just dmesg.
In fact, the primary things tend to be /proc and /sys, not dmesg
itself." By Linus Torvalds [2]
Lot of other areas in the kernel and filesystems have been updated to be
able to support private instances, devpts is one major example [3]. The aim
here is to modernize procfs without breaking userspace, or without affecting
the shared procfs mount. Later new features will apply on the private
instances, and after more testing, months, maybe it can be made the default
especially for IoT.
We want the possibility to do:
mount -t proc -onewinstance,newfeature none /proc
newfeature: we are planning new features later for procfs, for now in
this RFC we only introduce "pids=all|ptraceable" mount option.
This allows to absorbe changes, make improvments without breaking use
cases.
Which will be used for:
1) Embedded systems and IoT: usually we have one supervisor for
apps, we have some lightweight sandbox support, however if we create
pid namespaces we have to manage all the processes inside too,
where our goal is to be able to run a bunch of apps each one inside
its own mount namespace, maybe use network namespaces for vlans
setups, but right now we only want mount namespaces, without all the
other complexity. we want procfs to behave more like a real file system,
and block access to inodes that belong to other users. 'hidepid=' will
not work since it is a shared mount option.
2) Containers, sandboxes and Private instances of file systems - devpts case
Historically, lot of file systems inside Linux kernel view when instantiated
were just a mirror of an already created and mounted filesystem. This was the
case of devpts filesystem, it seems at that time the requirements were to
optimize things and reuse the same memory, etc. This design used to work but not
anymore with today’s containers, IoT, hostile environments and all the privacy
challenges that Linux faces.
In that regards, devpts was updated so that each new mounts is a total
independent file system by the following patches:
“devpts: Make each mount of devpts an independent filesystem” by
Eric W. Biederman [3] [4]
3) Linux Security Modules have multiple ptrace paths inside some
subsystems, however inside procfs, the implementation does not guarantee
that the ptrace() check which triggers the security_ptrace_check() hook
will always run. We have the 'hidepid' mount option that can be used to
force the ptrace_may_access() check inside has_pid_permissions() to run.
The problem is that 'hidepid' is per pid namespace and not attached to
the mount point, any remount or modification of 'hidepid' will propagate
to all other procfs mounts.
This also does not allow to support Yama LSM easily in desktop and user
sessions. Yama ptrace scope which restricts ptrace and some other
syscalls to be allowed only on inferiors, can be updated to have a
per-task context, where the context will be inherited during fork(),
clone() and preserved across execve(). If we support multiple private
procfs instances, then we may force the ptrace_may_access() on
/proc/<pids>/ to always run inside that new procfs instances. This will
allow to specifiy on user sessions if we should populate procfs with
pids that the user can ptrace or not.
By using Yama ptrace scope, some restricted users will only be able to see
inferiors inside /proc, they won't even be able to see their other
processes. Some software like Chromium, Firefox's crash handler, Wine
and others are already using Yama to restrict which processes can be
ptracable. With this change this will give the possibility to restrict
/proc/<pids>/ but more importantly this will give desktop users a
generic and usuable way to specifiy which users should see all processes
and which user can not.
Side notes:
* This covers the lack of seccomp where it is not able to parse
arguments, it is easy to install a seccomp filter on direct syscalls
that operate on pids, however /proc/<pid>/ is a Linux ABI using
filesystem syscalls. With this change all LSMs should be able to analyze
open/read/write/close... on /proc/<pid>/
4) This will allow to implement new features either in kernel or
userspace without having to worry about procfs.
In containers, sandboxes, etc we have workarounds to hide some /proc
inodes, this should be supported natively without doing extra complex
work, the kernel should be able to support sane options that work with
today and future Linux use cases.
Alexey Gladkov has on top a patch [7] that allows to hide non-pid
inodes from procfs, we are improving that patch and with 'newinstance'
option it can be used in containers and sandboxes, as these are already
trying to hide and block access to procfs inodes anyway.
https://github.com/legionus/linux/commit/993a2a5b9af95b0ac901ff41d32124b72ed676e3
Introduced changes:
-------------------
This series adds two new mount options:
* 'newinstance' mount option, it was also suggesed by Andy Lutomirski [5].
When this option is passed we automatically create a private procfs instance.
This is not the default behaviour since we do not want to break userspace
and we do not want to provide different devices IDs by default when
stat()ing inodes, I am not sure about all the use cases there [6].
* 'pids' mount option, as discussed with Andy Lutomirski.
If 'pids=' is passed without 'newinstance' then it has no effect.
If 'newinstance,pids=all' then processes will be show inside the proc
mount.
If 'newinstance,pids=ptraceable' then only ptraceable processes will be
shown.
This allows to support lightweight sandboxes in Embedded Linux, also
solves the case for LSM where now with this mount option, we make sure
that they have a ptrace path in procfs.
Use cases of 'newinstance' mount option:
* We create a private procfs instance that it is disconnected from the
shared or other procfs instances.
* "hidepid" instead of chaning all other mirrored procfs mounts, now
it will work only on the new private instance.
* "gid" instead of chaning all other mirrored procfs mounts, now it will
work only on the new private instance.
* "pids=ptraceable" mount option which will take precendence over
"hidepid" will only work when 'newinstance' is set. Otherwise it is ignored.
This should allow later after real testing to have a smooth transition
to a procfs with default private instances.
How to test:
$ sudo mount -t proc -onewinstance,pids=ptraceable none /test
Note for userspace that should be documented:
If you are over mounting /proc, then make sure you are in a new mount
namespace where propagation to master is disconnected. This will avoid
to pin that new /proc mount.
References:
-----------
[1] https://lists.linuxfoundation.org/pipermail/ksummit-discuss/2017-January/004215.html
[2] http://www.openwall.com/lists/kernel-hardening/2017/10/05/5
[3] https://lwn.net/Articles/689539/
[4] http://lxr.free-electrons.com/source/Documentation/filesystems/devpts.txt?v=3.14
[5] https://lkml.org/lkml/2017/5/2/407
[6] https://lkml.org/lkml/2017/5/3/357
# Changes since RFC v2:
*) Renamed mount options to 'newinstance' and 'pids='
Suggested-by: Andy Lutomirski <[email protected]>
*) Fixed order of commit, Suggested-by: Andy Lutomirski <[email protected]>
*) Many bug fixes.
# Changes since RFC v1:
*) Removed 'unshared' mount option and replaced it with 'limit_pids'
which is attached to the current procfs mount.
Suggested-by Andy Lutomirski <[email protected]>
*) Do not fill dcache with pid entries that we can not ptrace.
*) Many bug fixes.
Djalal Harouni (7):
[PATCH 1/7] proc: add proc_fs_info struct to store proc information
[PATCH 2/7] proc: move /proc/{self|thread-self} dentries to proc_fs_info
[PATCH 3/7] proc: add helpers to set and get proc hidepid and gid mount options
[PATCH 4/7] proc: support mounting private procfs instances inside same pid namespace
[PATCH 5/7] proc: move hidepid definitions to proc files
[PATCH 6/7] proc: support new 'pids=all|ptraceable' mount option
[patch 7/7] proc: flush dcache entries from all procfs instances
fs/locks.c | 6 +-
fs/proc/base.c | 103 ++++++++++++++++-------
fs/proc/inode.c | 34 ++++++--
fs/proc/internal.h | 2 +-
fs/proc/root.c | 188 +++++++++++
From 1583644766822074328@xxx Fri Nov 10 02:35:40 +0000 2017
X-GM-THRID: 1583325808595528330
X-Gmail-Labels: Inbox,Category Forums,HistoricalUnread
This moves the 'hidepid' definitions to proc files. The 'hidepid' is a
proc mount option, not really a per pid namespace value. It was there
since it was used inside PID namespaces, however now we have improved
proc logic and reduce the complexity and ties with PID namespaces lets
move this last bit to where it really belongs.
Cc: Kees Cook <[email protected]>
Cc: Greg Kroah-Hartman <[email protected]>
Cc: Andy Lutomirski <[email protected]>
Signed-off-by: Alexey Gladkov <[email protected]>
Signed-off-by: Djalal Harouni <[email protected]>
---
include/linux/pid_namespace.h | 6 ------
include/linux/proc_fs.h | 6 ++++++
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index 786ea04..66f47f1 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -15,12 +15,6 @@
struct fs_pin;
-enum { /* definitions for pid_namespace's hide_pid field */
- HIDEPID_OFF = 0,
- HIDEPID_NO_ACCESS = 1,
- HIDEPID_INVISIBLE = 2,
-};
-
struct pid_namespace {
struct kref kref;
struct idr idr;
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 408b51d..c123e5ec 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -12,6 +12,12 @@
struct proc_dir_entry;
struct pid_namespace;
+enum { /* definitions for 'hidepid' mount option */
+ HIDEPID_OFF = 0,
+ HIDEPID_NO_ACCESS = 1,
+ HIDEPID_INVISIBLE = 2,
+};
+
struct proc_fs_info {
struct pid_namespace *pid_ns;
struct dentry *proc_self; /* For /proc/self/ */
--
2.7.4
From 1583636414523876133@xxx Fri Nov 10 00:22:55 +0000 2017
X-GM-THRID: 1583630322258862530
X-Gmail-Labels: Inbox,Category Forums,HistoricalUnread
Flush dcache entries of a task when it terminates. The task may have
showed up in multiple procfs mounts per pid namespace, and we need to
walk the mounts and invalidate any left entires.
Cc: Kees Cook <[email protected]>
Cc: Greg Kroah-Hartman <[email protected]>
Cc: Andy Lutomirski <[email protected]>
Cc: Alexey Gladkov <[email protected]>
Signed-off-by: Djalal Harouni <[email protected]>
---
fs/proc/base.c | 27 +++++++++++++++++++-----
fs/proc/inode.c | 9 +++++++-
fs/proc/root.c | 10 +++++++++
include/linux/pid_namespace.h | 49 +++++++++++++++++++++++++++++++++++++++++++
include/linux/proc_fs.h | 2 ++
5 files changed, 91 insertions(+), 6 deletions(-)
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 88b92bc..27e52aa 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -3034,7 +3034,8 @@ static const struct inode_operations proc_tgid_base_inode_operations = {
.permission = proc_pid_permission,
};
-static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
+static void proc_flush_task_mnt_root(struct dentry *mnt_root,
+ pid_t pid, pid_t tgid)
{
struct dentry *dentry, *leader, *dir;
char buf[PROC_NUMBUF];
@@ -3043,7 +3044,7 @@ static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
name.name = buf;
name.len = snprintf(buf, sizeof(buf), "%d", pid);
/* no ->d_hash() rejects on procfs */
- dentry = d_hash_and_lookup(mnt->mnt_root, &name);
+ dentry = d_hash_and_lookup(mnt_root, &name);
if (dentry) {
d_invalidate(dentry);
dput(dentry);
@@ -3054,7 +3055,7 @@ static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
name.name = buf;
name.len = snprintf(buf, sizeof(buf), "%d", tgid);
- leader = d_hash_and_lookup(mnt->mnt_root, &name);
+ leader = d_hash_and_lookup(mnt_root, &name);
if (!leader)
goto out;
@@ -3109,14 +3110,30 @@ void proc_flush_task(struct task_struct *task)
int i;
struct pid *pid, *tgid;
struct upid *upid;
+ struct proc_fs_info *fs_info_entry;
+ struct pid_namespace *pid_ns;
+ struct dentry *mnt_root;
pid = task_pid(task);
tgid = task_tgid(task);
for (i = 0; i <= pid->level; i++) {
upid = &pid->numbers[i];
- proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
- tgid->numbers[i].nr);
+ pid_ns = upid->ns;
+
+ pidns_proc_lock_shared(pid_ns);
+ list_for_each_entry(fs_info_entry, &pid_ns->procfs_mounts,
+ pidns_entry) {
+ if (proc_fs_newinstance(fs_info_entry)) {
+ mnt_root = fs_info_entry->sb->s_root;
+ proc_flush_task_mnt_root(mnt_root, upid->nr,
+ tgid->numbers[i].nr);
+ }
+ }
+ pidns_proc_unlock_shared(pid_ns);
+
+ mnt_root = pid_ns->proc_mnt->mnt_root;
+ proc_flush_task_mnt_root(mnt_root, upid->nr, tgid->numbers[i].nr);
}
}
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 2707d5f..8fcf0d7 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -484,10 +484,17 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
int proc_fill_super(struct super_block *s, void *data, int silent)
{
struct proc_fs_info *fs_info = proc_sb(s);
+ struct pid_namespace *ns = get_pid_ns(fs_info->pid_ns);
struct inode *root_inode;
int ret;
- get_pid_ns(fs_info->pid_ns);
+ fs_info->sb = s;
+
+ if (proc_fs_newinstance(fs_info)) {
+ pidns_proc_lock(ns);
+ list_add_tail(&fs_info->pidns_entry, &ns->procfs_mounts);
+ pidns_proc_unlock(ns);
+ }
if (!proc_parse_options(data, fs_info))
return -EINVAL;
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 5cdff69..5503799 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -259,6 +259,13 @@ static void proc_kill_sb(struct super_block *sb)
dput(fs_info->proc_self);
if (fs_info->proc_thread_self)
dput(fs_info->proc_thread_self);
+
+ if (proc_fs_newinstance(fs_info)) {
+ pidns_proc_lock(ns);
+ list_del(&fs_info->pidns_entry);
+ pidns_proc_unlock(ns);
+ }
+
kill_anon_super(sb);
put_pid_ns(ns);
kfree(fs_info);
@@ -374,6 +381,9 @@ int pid_ns_prepare_proc(struct pid_namespace *ns)
return PTR_ERR(mnt);
ns->proc_mnt = mnt;
+ init_rwsem(&ns->rw_procfs_mnts);
+ INIT_LIST_HEAD(&ns->procfs_mounts);
+
return 0;
}
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index 66f47f1..9a7a28d 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -26,6 +26,15 @@ struct pid_namespace {
struct pid_namespace *parent;
#ifdef CONFIG_PROC_FS
struct vfsmount *proc_mnt; /* Internal proc mounted during each new pidns */
+
+ /* Serialize separated procfs access from super block create/destory */
+ struct rw_semaphore rw_procfs_mnts;
+
+ /*
+ * List of separated procfs mounts, used to invalidate task dentry
+ * from all the related procfs mounts.
+ */
+ struct list_head procfs_mounts;
#endif
#ifdef CONFIG_BSD_PROCESS_ACCT
struct fs_pin *bacct;
@@ -90,4 +99,44 @@ extern struct pid_namespace *task_active_pid_ns(struct task_struct *tsk);
void pidhash_init(void);
void pid_idr_init(void);
+#ifdef CONFIG_PROC_FS
+static inline void pidns_proc_lock(struct pid_namespace *pid_ns)
+{
+ down_write(&pid_ns->rw_procfs_mnts);
+}
+
+static inline void pidns_proc_unlock(struct pid_namespace *pid_ns)
+{
+ up_write(&pid_ns->rw_procfs_mnts);
+}
+
+static inline void pidns_proc_lock_shared(struct pid_namespace *pid_ns)
+{
+ down_read(&pid_ns->rw_procfs_mnts);
+}
+
+static inline void pidns_proc_unlock_shared(struct pid_namespace *pid_ns)
+{
+ up_read(&pid_ns->rw_procfs_mnts);
+}
+#else /* !CONFIG_PROC_FS */
+
+static inline void pidns_proc_lock(struct pid_namespace *pid_ns)
+{
+}
+
+static inline void pidns_proc_unlock(struct pid_namespace *pid_ns)
+{
+}
+
+static inline void pidns_proc_lock_shared(struct pid_namespace *pid_ns)
+{
+}
+
+static inline void pidns_proc_unlock_shared(struct pid_namespace *pid_ns)
+{
+}
+
+#endif /* CONFIG_PROC_FS */
+
#endif /* _LINUX_PID_NS_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 0730f52..e56fbab 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -24,7 +24,9 @@ enum { /* definitions for 'pids' mount option */
};
struct proc_fs_info {
+ struct super_block *sb;
struct pid_namespace *pid_ns;
+ struct list_head pidns_entry; /* Node in procfs_mounts of pidns */
struct dentry *proc_self; /* For /proc/self/ */
struct dentry *proc_thread_self; /* For /proc/thread-self/ */
bool newinstance; /* Flag for new separated instances */
--
2.7.4
From 1583609994214865009@xxx Thu Nov 09 17:22:58 +0000 2017
X-GM-THRID: 1583526398755359813
X-Gmail-Labels: Inbox,Category Forums,HistoricalUnread
This patch introduces the new 'pids' mount option, as it was discussed
and suggested by Andy Lutomirski [1].
* If 'pids=' is passed without 'newinstance' then it has no effect.
* If 'newinstance,pids=all' then all processes will be shown in proc.
* If 'newinstance,pids=ptraceable' then only ptraceable processes will be
shown.
* 'pids=' takes precendence over 'hidepid=' since 'hidepid=' can be
ignored if "gid=" was set and caller has the "gid=" set in its groups.
We want to guarantee that LSM have a security path there that can not
be disabled with "gid=".
This allows to support lightweight sandboxes in Embedded Linux.
Later Yama LSM can be updated to check that processes are able only
able to see their children inside /proc/, allowing to support more tight
cases.
[1] https://lkml.org/lkml/2017/4/26/646
Cc: Kees Cook <[email protected]>
Cc: Greg Kroah-Hartman <[email protected]>
Suggested-by: Andy Lutomirski <[email protected]>
Signed-off-by: Alexey Gladkov <[email protected]>
Signed-off-by: Djalal Harouni <[email protected]>
---
fs/proc/base.c | 36 +++++++++++++++++++++++++++++-------
fs/proc/inode.c | 6 +++++-
fs/proc/root.c | 20 ++++++++++++++++++--
include/linux/proc_fs.h | 30 ++++++++++++++++++++++++++++++
4 files changed, 82 insertions(+), 10 deletions(-)
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 54b527c..88b92bc 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -686,13 +686,24 @@ static bool has_pid_permissions(struct proc_fs_info *fs_info,
struct task_struct *task,
int hide_pid_min)
{
- int hide_pid = proc_fs_hide_pid(fs_info);
- kgid_t gid = proc_fs_pid_gid(fs_info);
+ int pids = proc_fs_pids(fs_info);
+
+ /*
+ * If 'pids=all' or if it was not set then lets fallback
+ * to 'hidepid' and 'gid', if those are not enforced too, then
+ * ptrace checks are skipped. Otherwise ptrace permission is
+ * required for all other cases.
+ */
+ if (pids == PIDS_ALL) {
+ int hide_pid = proc_fs_hide_pid(fs_info);
+ kgid_t gid = proc_fs_pid_gid(fs_info);
+
+ if (hide_pid < hide_pid_min)
+ return true;
- if (hide_pid < hide_pid_min)
- return true;
- if (in_group_p(gid))
- return true;
+ if (in_group_p(gid))
+ return true;
+ }
return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
}
@@ -701,6 +712,7 @@ static int proc_pid_permission(struct inode *inode, int mask)
{
struct proc_fs_info *fs_info = proc_sb(inode->i_sb);
int hide_pid = proc_fs_hide_pid(fs_info);
+ int pids = proc_fs_pids(fs_info);
struct task_struct *task;
bool has_perms;
@@ -711,7 +723,8 @@ static int proc_pid_permission(struct inode *inode, int mask)
put_task_struct(task);
if (!has_perms) {
- if (hide_pid == HIDEPID_INVISIBLE) {
+ if (pids == PIDS_PTRACEABLE ||
+ hide_pid == HIDEPID_INVISIBLE) {
/*
* Let's make getdents(), stat(), and open()
* consistent with each other. If a process
@@ -3140,6 +3153,7 @@ struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsign
unsigned tgid;
struct proc_fs_info *fs_info = proc_sb(dir->i_sb);
struct pid_namespace *ns = fs_info->pid_ns;
+ int pids = proc_fs_pids(fs_info);
tgid = name_to_int(&dentry->d_name);
if (tgid == ~0U)
@@ -3153,7 +3167,15 @@ struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsign
if (!task)
goto out;
+ /* Limit procfs to only ptraceable tasks */
+ if (pids != PIDS_ALL) {
+ cond_resched();
+ if (!has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS))
+ goto out_put_task;
+ }
+
result = proc_pid_instantiate(dir, dentry, task, NULL);
+out_put_task:
put_task_struct(task);
out:
return ERR_PTR(result);
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index faec32a..2707d5f 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -108,8 +108,12 @@ static int proc_show_options(struct seq_file *seq, struct dentry *root)
int hide_pid = proc_fs_hide_pid(fs_info);
kgid_t pid_gid = proc_fs_pid_gid(fs_info);
- if (proc_fs_newinstance(fs_info))
+ if (proc_fs_newinstance(fs_info)) {
+ int pids = proc_fs_pids(fs_info);
+
seq_printf(seq, ",newinstance");
+ seq_printf(seq, ",pids=%s", pids == PIDS_ALL ? "all" : "ptraceable");
+ }
if (!gid_eq(pid_gid, GLOBAL_ROOT_GID))
seq_printf(seq, ",gid=%u", from_kgid_munged(current_user_ns(),pid_gid));
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 33ab965..5cdff69 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -28,13 +28,14 @@
#include "internal.h"
enum {
- Opt_gid, Opt_hidepid, Opt_newinstance, Opt_err,
+ Opt_gid, Opt_hidepid, Opt_newinstance, Opt_pids, Opt_err,
};
static const match_table_t tokens = {
{Opt_hidepid, "hidepid=%u"},
{Opt_gid, "gid=%u"},
{Opt_newinstance, "newinstance"},
+ {Opt_pids, "pids=%s"},
{Opt_err, NULL},
};
@@ -67,6 +68,7 @@ int proc_parse_early_options(char *options, struct proc_fs_info *fs_info)
break;
case Opt_gid:
case Opt_hidepid:
+ case Opt_pids:
break;
default:
pr_err("proc: unrecognized mount option \"%s\" "
@@ -83,7 +85,7 @@ int proc_parse_options(char *options, struct proc_fs_info *fs_info)
{
char *p;
substring_t args[MAX_OPT_ARGS];
- int option;
+ int option, ret = 0;
kgid_t gid;
if (!options)
@@ -119,6 +121,19 @@ int proc_parse_options(char *options, struct proc_fs_info *fs_info)
break;
case Opt_newinstance:
break;
+ case Opt_pids:
+ if (strcmp(args[0].from, "all") == 0)
+ ret = proc_fs_set_pids(fs_info, PIDS_ALL);
+ else if (strcmp(args[0].from, "ptraceable") == 0)
+ ret = proc_fs_set_pids(fs_info, PIDS_PTRACEABLE);
+ else
+ ret = -EINVAL;
+
+ if (ret < 0) {
+ pr_err("proc: invalid 'pids' mount option.\n");
+ return 0;
+ }
+ break;
default:
pr_err("proc: unrecognized mount option \"%s\" "
"or missing value\n", p);
@@ -188,6 +203,7 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
/* Set it as early as possible */
proc_fs_set_newinstance(fs_info, false);
+ proc_fs_set_pids(fs_info, PIDS_ALL);
if (flags & SB_KERNMOUNT) {
ns = data;
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index c123e5ec..0730f52 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -18,6 +18,11 @@ enum { /* definitions for 'hidepid' mount option */
HIDEPID_INVISIBLE = 2,
};
+enum { /* definitions for 'pids' mount option */
+ PIDS_ALL = 0,
+ PIDS_PTRACEABLE = 1,
+};
+
struct proc_fs_info {
struct pid_namespace *pid_ns;
struct dentry *proc_self; /* For /proc/self/ */
@@ -25,6 +30,7 @@ struct proc_fs_info {
bool newinstance; /* Flag for new separated instances */
kgid_t pid_gid;
int hide_pid;
+ int pids;
};
#ifdef CONFIG_PROC_FS
@@ -49,6 +55,16 @@ static inline void proc_fs_set_newinstance(struct proc_fs_info *fs_info, bool va
fs_info->newinstance = value;
}
+static inline int proc_fs_set_pids(struct proc_fs_info *fs_info, int value)
+{
+ if (value != PIDS_ALL &&
+ (value != PIDS_PTRACEABLE || !fs_info->newinstance))
+ return -EINVAL;
+
+ fs_info->pids = value;
+ return 0;
+}
+
static inline int proc_fs_hide_pid(struct proc_fs_info *fs_info)
{
return fs_info->hide_pid;
@@ -64,6 +80,11 @@ static inline bool proc_fs_newinstance(struct proc_fs_info *fs_info)
return fs_info->newinstance;
}
+static inline int proc_fs_pids(struct proc_fs_info *fs_info)
+{
+ return fs_info->pids;
+}
+
extern void proc_root_init(void);
extern void proc_flush_task(struct task_struct *);
@@ -112,6 +133,10 @@ static inline void proc_fs_set_newinstance(struct proc_fs_info *fs_info, bool va
{
}
+static inline int proc_fs_set_pids(struct proc_fs_info *fs_info, int value)
+{
+}
+
static inline int proc_fs_hide_pid(struct proc_fs_info *fs_info)
{
return 0;
@@ -127,6 +152,11 @@ static inline bool proc_fs_newinstance(struct proc_fs_info *fs_info)
return false;
}
+static inline int proc_fs_pids(struct proc_fs_info *fs_info)
+{
+ return 0;
+}
+
extern inline struct proc_fs_info *proc_sb(struct super_block *sb) { return NULL;}
static inline struct proc_dir_entry *proc_symlink(const char *name,
struct proc_dir_entry *parent,const char *dest) { return NULL;}
--
2.7.4
From 1583510750213851116@xxx Wed Nov 08 15:05:32 +0000 2017
X-GM-THRID: 1583510750213851116
X-Gmail-Labels: Inbox,Category Forums,HistoricalUnread