kernel_samsung_a34x-permissive/fs/proc/uid.c

305 lines
6.8 KiB
C
Raw Normal View History

/*
* /proc/uid support
*/
#include <linux/cpufreq_times.h>
#include <linux/fs.h>
#include <linux/hashtable.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/rtmutex.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include "internal.h"
static struct proc_dir_entry *proc_uid;
#define UID_HASH_BITS 10
static DECLARE_HASHTABLE(proc_uid_hash_table, UID_HASH_BITS);
/*
* use rt_mutex here to avoid priority inversion between high-priority readers
* of these files and tasks calling proc_register_uid().
*/
static DEFINE_RT_MUTEX(proc_uid_lock); /* proc_uid_hash_table */
struct uid_hash_entry {
uid_t uid;
struct hlist_node hash;
};
/* Caller must hold proc_uid_lock */
static bool uid_hash_entry_exists_locked(uid_t uid)
{
struct uid_hash_entry *entry;
hash_for_each_possible(proc_uid_hash_table, entry, hash, uid) {
if (entry->uid == uid)
return true;
}
return false;
}
void proc_register_uid(kuid_t kuid)
{
struct uid_hash_entry *entry;
bool exists;
uid_t uid = from_kuid_munged(current_user_ns(), kuid);
rt_mutex_lock(&proc_uid_lock);
exists = uid_hash_entry_exists_locked(uid);
rt_mutex_unlock(&proc_uid_lock);
if (exists)
return;
entry = kzalloc(sizeof(struct uid_hash_entry), GFP_KERNEL);
if (!entry)
return;
entry->uid = uid;
rt_mutex_lock(&proc_uid_lock);
if (uid_hash_entry_exists_locked(uid))
kfree(entry);
else
hash_add(proc_uid_hash_table, &entry->hash, uid);
rt_mutex_unlock(&proc_uid_lock);
}
struct uid_entry {
const char *name;
int len;
umode_t mode;
const struct inode_operations *iop;
const struct file_operations *fop;
};
#define NOD(NAME, MODE, IOP, FOP) { \
.name = (NAME), \
.len = sizeof(NAME) - 1, \
.mode = MODE, \
.iop = IOP, \
.fop = FOP, \
}
#ifdef CONFIG_CPU_FREQ_TIMES
static const struct file_operations proc_uid_time_in_state_operations = {
.open = single_uid_time_in_state_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
#endif
static const struct uid_entry uid_base_stuff[] = {
#ifdef CONFIG_CPU_FREQ_TIMES
NOD("time_in_state", 0444, NULL, &proc_uid_time_in_state_operations),
#endif
};
static const struct inode_operations proc_uid_def_inode_operations = {
.setattr = proc_setattr,
};
static struct inode *proc_uid_make_inode(struct super_block *sb, kuid_t kuid)
{
struct inode *inode;
inode = new_inode(sb);
if (!inode)
return NULL;
inode->i_ino = get_next_ino();
inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
inode->i_op = &proc_uid_def_inode_operations;
inode->i_uid = kuid;
return inode;
}
static struct dentry *proc_uident_instantiate(struct dentry *dentry,
struct task_struct *unused, const void *ptr)
{
const struct uid_entry *u = ptr;
struct inode *inode;
uid_t uid = name_to_int(&dentry->d_name);
kuid_t kuid;
bool uid_exists;
rt_mutex_lock(&proc_uid_lock);
uid_exists = uid_hash_entry_exists_locked(uid);
rt_mutex_unlock(&proc_uid_lock);
if (uid_exists) {
kuid = make_kuid(current_user_ns(), uid);
inode = proc_uid_make_inode(dentry->d_sb, kuid);
if (!inode)
return ERR_PTR(-ENOENT);
} else {
return ERR_PTR(-ENOENT);
}
inode->i_mode = u->mode;
if (S_ISDIR(inode->i_mode))
set_nlink(inode, 2);
if (u->iop)
inode->i_op = u->iop;
if (u->fop)
inode->i_fop = u->fop;
return d_splice_alias(inode, dentry);
}
static struct dentry *proc_uid_base_lookup(struct inode *dir,
struct dentry *dentry,
unsigned int flags)
{
const struct uid_entry *u, *last;
unsigned int nents = ARRAY_SIZE(uid_base_stuff);
if (nents == 0)
return ERR_PTR(-ENOENT);
last = &uid_base_stuff[nents - 1];
for (u = uid_base_stuff; u <= last; u++) {
if (u->len != dentry->d_name.len)
continue;
if (!memcmp(dentry->d_name.name, u->name, u->len))
break;
}
if (u > last)
return ERR_PTR(-ENOENT);
return proc_uident_instantiate(dentry, NULL, u);
}
static int proc_uid_base_readdir(struct file *file, struct dir_context *ctx)
{
unsigned int nents = ARRAY_SIZE(uid_base_stuff);
const struct uid_entry *u;
if (!dir_emit_dots(file, ctx))
return 0;
if (ctx->pos >= nents + 2)
return 0;
for (u = uid_base_stuff + (ctx->pos - 2);
u < uid_base_stuff + nents; u++) {
if (!proc_fill_cache(file, ctx, u->name, u->len,
proc_uident_instantiate, NULL, u))
break;
ctx->pos++;
}
return 0;
}
static const struct inode_operations proc_uid_base_inode_operations = {
.lookup = proc_uid_base_lookup,
.setattr = proc_setattr,
};
static const struct file_operations proc_uid_base_operations = {
.read = generic_read_dir,
.iterate = proc_uid_base_readdir,
.llseek = default_llseek,
};
static struct dentry *proc_uid_instantiate(struct dentry *dentry,
struct task_struct *unused, const void *ptr)
{
unsigned int i, len;
nlink_t nlinks;
kuid_t *kuid = (kuid_t *)ptr;
struct inode *inode = proc_uid_make_inode(dentry->d_sb, *kuid);
if (!inode)
return ERR_PTR(-ENOENT);
inode->i_mode = S_IFDIR | 0555;
inode->i_op = &proc_uid_base_inode_operations;
inode->i_fop = &proc_uid_base_operations;
inode->i_flags |= S_IMMUTABLE;
nlinks = 2;
len = ARRAY_SIZE(uid_base_stuff);
for (i = 0; i < len; ++i) {
if (S_ISDIR(uid_base_stuff[i].mode))
++nlinks;
}
set_nlink(inode, nlinks);
return d_splice_alias(inode, dentry);
}
static int proc_uid_readdir(struct file *file, struct dir_context *ctx)
{
int last_shown, i;
unsigned long bkt;
struct uid_hash_entry *entry;
if (!dir_emit_dots(file, ctx))
return 0;
i = 0;
last_shown = ctx->pos - 2;
rt_mutex_lock(&proc_uid_lock);
hash_for_each(proc_uid_hash_table, bkt, entry, hash) {
int len;
char buf[PROC_NUMBUF];
if (i < last_shown)
continue;
len = snprintf(buf, sizeof(buf), "%u", entry->uid);
if (!proc_fill_cache(file, ctx, buf, len,
proc_uid_instantiate, NULL, &entry->uid))
break;
i++;
ctx->pos++;
}
rt_mutex_unlock(&proc_uid_lock);
return 0;
}
static struct dentry *proc_uid_lookup(struct inode *dir, struct dentry *dentry,
unsigned int flags)
{
int result = -ENOENT;
uid_t uid = name_to_int(&dentry->d_name);
bool uid_exists;
rt_mutex_lock(&proc_uid_lock);
uid_exists = uid_hash_entry_exists_locked(uid);
rt_mutex_unlock(&proc_uid_lock);
if (uid_exists) {
kuid_t kuid = make_kuid(current_user_ns(), uid);
return proc_uid_instantiate(dentry, NULL, &kuid);
}
return ERR_PTR(result);
}
static const struct file_operations proc_uid_operations = {
.read = generic_read_dir,
.iterate = proc_uid_readdir,
.llseek = default_llseek,
};
static const struct inode_operations proc_uid_inode_operations = {
.lookup = proc_uid_lookup,
.setattr = proc_setattr,
};
int __init proc_uid_init(void)
{
proc_uid = proc_mkdir("uid", NULL);
if (!proc_uid)
return -ENOMEM;
proc_uid->proc_iops = &proc_uid_inode_operations;
proc_uid->proc_fops = &proc_uid_operations;
return 0;
}