mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Eric W. Biederman](/assets/img/avatar_default.png)
Simplifies the code, reduces the need for 4 pid hash tables, and makes the code more capable. In the discussions I had with Oleg it was felt that to a large extent the cleanup itself justified the work. With struct pid being dynamically allocated meant we could create the hash table entry when the pid was allocated and free the hash table entry when the pid was freed. Instead of playing with the hash lists when ever a process would attach or detach to a process. For myself the fact that it gave what my previous task_ref patch gave for free with simpler code was a big win. The problem is that if you hold a reference to struct task_struct you lock in 10K of low memory. If you do that in a user controllable way like /proc does, with an unprivileged but hostile user space application with typical resource limits of 1000 fds and 100 processes I can trigger the OOM killer by consuming all of low memory with task structs, on a machine wight 1GB of low memory. If I instead hold a reference to struct pid which holds a pointer to my task_struct, I don't suffer from that problem because struct pid is 2 orders of magnitude smaller. In fact struct pid is small enough that most other kernel data structures dwarf it, so simply limiting the number of referring data structures is enough to prevent exhaustion of low memory. This splits the current struct pid into two structures, struct pid and struct pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one. struct pid_link is the per process linkage into the hash tables and lives in struct task_struct. struct pid is given an indepedent lifetime, and holds pointers to each of the pid types. The independent life of struct pid simplifies attach_pid, and detach_pid, because we are always manipulating the list of pids and not the hash table. In addition in giving struct pid an indpendent life it makes the concept much more powerful. Kernel data structures can now embed a struct pid * instead of a pid_t and not suffer from pid wrap around problems or from keeping unnecessarily large amounts of memory allocated. Signed-off-by: Eric W. Biederman <ebiederm@xmission.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
334 lines
8.4 KiB
C
334 lines
8.4 KiB
C
/*
|
|
* Generic pidhash and scalable, time-bounded PID allocator
|
|
*
|
|
* (C) 2002-2003 William Irwin, IBM
|
|
* (C) 2004 William Irwin, Oracle
|
|
* (C) 2002-2004 Ingo Molnar, Red Hat
|
|
*
|
|
* pid-structures are backing objects for tasks sharing a given ID to chain
|
|
* against. There is very little to them aside from hashing them and
|
|
* parking tasks using given ID's on a list.
|
|
*
|
|
* The hash is always changed with the tasklist_lock write-acquired,
|
|
* and the hash is only accessed with the tasklist_lock at least
|
|
* read-acquired, so there's no additional SMP locking needed here.
|
|
*
|
|
* We have a list of bitmap pages, which bitmaps represent the PID space.
|
|
* Allocating and freeing PIDs is completely lockless. The worst-case
|
|
* allocation scenario when all but one out of 1 million PIDs possible are
|
|
* allocated already: the scanning of 32 list entries and at most PAGE_SIZE
|
|
* bytes. The typical fastpath is a single successful setbit. Freeing is O(1).
|
|
*/
|
|
|
|
#include <linux/mm.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/bootmem.h>
|
|
#include <linux/hash.h>
|
|
|
|
#define pid_hashfn(nr) hash_long((unsigned long)nr, pidhash_shift)
|
|
static struct hlist_head *pid_hash;
|
|
static int pidhash_shift;
|
|
static kmem_cache_t *pid_cachep;
|
|
|
|
int pid_max = PID_MAX_DEFAULT;
|
|
int last_pid;
|
|
|
|
#define RESERVED_PIDS 300
|
|
|
|
int pid_max_min = RESERVED_PIDS + 1;
|
|
int pid_max_max = PID_MAX_LIMIT;
|
|
|
|
#define PIDMAP_ENTRIES ((PID_MAX_LIMIT + 8*PAGE_SIZE - 1)/PAGE_SIZE/8)
|
|
#define BITS_PER_PAGE (PAGE_SIZE*8)
|
|
#define BITS_PER_PAGE_MASK (BITS_PER_PAGE-1)
|
|
#define mk_pid(map, off) (((map) - pidmap_array)*BITS_PER_PAGE + (off))
|
|
#define find_next_offset(map, off) \
|
|
find_next_zero_bit((map)->page, BITS_PER_PAGE, off)
|
|
|
|
/*
|
|
* PID-map pages start out as NULL, they get allocated upon
|
|
* first use and are never deallocated. This way a low pid_max
|
|
* value does not cause lots of bitmaps to be allocated, but
|
|
* the scheme scales to up to 4 million PIDs, runtime.
|
|
*/
|
|
typedef struct pidmap {
|
|
atomic_t nr_free;
|
|
void *page;
|
|
} pidmap_t;
|
|
|
|
static pidmap_t pidmap_array[PIDMAP_ENTRIES] =
|
|
{ [ 0 ... PIDMAP_ENTRIES-1 ] = { ATOMIC_INIT(BITS_PER_PAGE), NULL } };
|
|
|
|
/*
|
|
* Note: disable interrupts while the pidmap_lock is held as an
|
|
* interrupt might come in and do read_lock(&tasklist_lock).
|
|
*
|
|
* If we don't disable interrupts there is a nasty deadlock between
|
|
* detach_pid()->free_pid() and another cpu that does
|
|
* spin_lock(&pidmap_lock) followed by an interrupt routine that does
|
|
* read_lock(&tasklist_lock);
|
|
*
|
|
* After we clean up the tasklist_lock and know there are no
|
|
* irq handlers that take it we can leave the interrupts enabled.
|
|
* For now it is easier to be safe than to prove it can't happen.
|
|
*/
|
|
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pidmap_lock);
|
|
|
|
static fastcall void free_pidmap(int pid)
|
|
{
|
|
pidmap_t *map = pidmap_array + pid / BITS_PER_PAGE;
|
|
int offset = pid & BITS_PER_PAGE_MASK;
|
|
|
|
clear_bit(offset, map->page);
|
|
atomic_inc(&map->nr_free);
|
|
}
|
|
|
|
static int alloc_pidmap(void)
|
|
{
|
|
int i, offset, max_scan, pid, last = last_pid;
|
|
pidmap_t *map;
|
|
|
|
pid = last + 1;
|
|
if (pid >= pid_max)
|
|
pid = RESERVED_PIDS;
|
|
offset = pid & BITS_PER_PAGE_MASK;
|
|
map = &pidmap_array[pid/BITS_PER_PAGE];
|
|
max_scan = (pid_max + BITS_PER_PAGE - 1)/BITS_PER_PAGE - !offset;
|
|
for (i = 0; i <= max_scan; ++i) {
|
|
if (unlikely(!map->page)) {
|
|
unsigned long page = get_zeroed_page(GFP_KERNEL);
|
|
/*
|
|
* Free the page if someone raced with us
|
|
* installing it:
|
|
*/
|
|
spin_lock_irq(&pidmap_lock);
|
|
if (map->page)
|
|
free_page(page);
|
|
else
|
|
map->page = (void *)page;
|
|
spin_unlock_irq(&pidmap_lock);
|
|
if (unlikely(!map->page))
|
|
break;
|
|
}
|
|
if (likely(atomic_read(&map->nr_free))) {
|
|
do {
|
|
if (!test_and_set_bit(offset, map->page)) {
|
|
atomic_dec(&map->nr_free);
|
|
last_pid = pid;
|
|
return pid;
|
|
}
|
|
offset = find_next_offset(map, offset);
|
|
pid = mk_pid(map, offset);
|
|
/*
|
|
* find_next_offset() found a bit, the pid from it
|
|
* is in-bounds, and if we fell back to the last
|
|
* bitmap block and the final block was the same
|
|
* as the starting point, pid is before last_pid.
|
|
*/
|
|
} while (offset < BITS_PER_PAGE && pid < pid_max &&
|
|
(i != max_scan || pid < last ||
|
|
!((last+1) & BITS_PER_PAGE_MASK)));
|
|
}
|
|
if (map < &pidmap_array[(pid_max-1)/BITS_PER_PAGE]) {
|
|
++map;
|
|
offset = 0;
|
|
} else {
|
|
map = &pidmap_array[0];
|
|
offset = RESERVED_PIDS;
|
|
if (unlikely(last == offset))
|
|
break;
|
|
}
|
|
pid = mk_pid(map, offset);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
fastcall void put_pid(struct pid *pid)
|
|
{
|
|
if (!pid)
|
|
return;
|
|
if ((atomic_read(&pid->count) == 1) ||
|
|
atomic_dec_and_test(&pid->count))
|
|
kmem_cache_free(pid_cachep, pid);
|
|
}
|
|
|
|
static void delayed_put_pid(struct rcu_head *rhp)
|
|
{
|
|
struct pid *pid = container_of(rhp, struct pid, rcu);
|
|
put_pid(pid);
|
|
}
|
|
|
|
fastcall void free_pid(struct pid *pid)
|
|
{
|
|
/* We can be called with write_lock_irq(&tasklist_lock) held */
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&pidmap_lock, flags);
|
|
hlist_del_rcu(&pid->pid_chain);
|
|
spin_unlock_irqrestore(&pidmap_lock, flags);
|
|
|
|
free_pidmap(pid->nr);
|
|
call_rcu(&pid->rcu, delayed_put_pid);
|
|
}
|
|
|
|
struct pid *alloc_pid(void)
|
|
{
|
|
struct pid *pid;
|
|
enum pid_type type;
|
|
int nr = -1;
|
|
|
|
pid = kmem_cache_alloc(pid_cachep, GFP_KERNEL);
|
|
if (!pid)
|
|
goto out;
|
|
|
|
nr = alloc_pidmap();
|
|
if (nr < 0)
|
|
goto out_free;
|
|
|
|
atomic_set(&pid->count, 1);
|
|
pid->nr = nr;
|
|
for (type = 0; type < PIDTYPE_MAX; ++type)
|
|
INIT_HLIST_HEAD(&pid->tasks[type]);
|
|
|
|
spin_lock_irq(&pidmap_lock);
|
|
hlist_add_head_rcu(&pid->pid_chain, &pid_hash[pid_hashfn(pid->nr)]);
|
|
spin_unlock_irq(&pidmap_lock);
|
|
|
|
out:
|
|
return pid;
|
|
|
|
out_free:
|
|
kmem_cache_free(pid_cachep, pid);
|
|
pid = NULL;
|
|
goto out;
|
|
}
|
|
|
|
struct pid * fastcall find_pid(int nr)
|
|
{
|
|
struct hlist_node *elem;
|
|
struct pid *pid;
|
|
|
|
hlist_for_each_entry_rcu(pid, elem,
|
|
&pid_hash[pid_hashfn(nr)], pid_chain) {
|
|
if (pid->nr == nr)
|
|
return pid;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int fastcall attach_pid(task_t *task, enum pid_type type, int nr)
|
|
{
|
|
struct pid_link *link;
|
|
struct pid *pid;
|
|
|
|
WARN_ON(!task->pid); /* to be removed soon */
|
|
WARN_ON(!nr); /* to be removed soon */
|
|
|
|
link = &task->pids[type];
|
|
link->pid = pid = find_pid(nr);
|
|
hlist_add_head_rcu(&link->node, &pid->tasks[type]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void fastcall detach_pid(task_t *task, enum pid_type type)
|
|
{
|
|
struct pid_link *link;
|
|
struct pid *pid;
|
|
int tmp;
|
|
|
|
link = &task->pids[type];
|
|
pid = link->pid;
|
|
|
|
hlist_del_rcu(&link->node);
|
|
link->pid = NULL;
|
|
|
|
for (tmp = PIDTYPE_MAX; --tmp >= 0; )
|
|
if (!hlist_empty(&pid->tasks[tmp]))
|
|
return;
|
|
|
|
free_pid(pid);
|
|
}
|
|
|
|
struct task_struct * fastcall pid_task(struct pid *pid, enum pid_type type)
|
|
{
|
|
struct task_struct *result = NULL;
|
|
if (pid) {
|
|
struct hlist_node *first;
|
|
first = rcu_dereference(pid->tasks[type].first);
|
|
if (first)
|
|
result = hlist_entry(first, struct task_struct, pids[(type)].node);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Must be called under rcu_read_lock() or with tasklist_lock read-held.
|
|
*/
|
|
task_t *find_task_by_pid_type(int type, int nr)
|
|
{
|
|
return pid_task(find_pid(nr), type);
|
|
}
|
|
|
|
EXPORT_SYMBOL(find_task_by_pid_type);
|
|
|
|
struct task_struct *fastcall get_pid_task(struct pid *pid, enum pid_type type)
|
|
{
|
|
struct task_struct *result;
|
|
rcu_read_lock();
|
|
result = pid_task(pid, type);
|
|
if (result)
|
|
get_task_struct(result);
|
|
rcu_read_unlock();
|
|
return result;
|
|
}
|
|
|
|
struct pid *find_get_pid(pid_t nr)
|
|
{
|
|
struct pid *pid;
|
|
|
|
rcu_read_lock();
|
|
pid = get_pid(find_pid(nr));
|
|
rcu_read_unlock();
|
|
|
|
return pid;
|
|
}
|
|
|
|
/*
|
|
* The pid hash table is scaled according to the amount of memory in the
|
|
* machine. From a minimum of 16 slots up to 4096 slots at one gigabyte or
|
|
* more.
|
|
*/
|
|
void __init pidhash_init(void)
|
|
{
|
|
int i, pidhash_size;
|
|
unsigned long megabytes = nr_kernel_pages >> (20 - PAGE_SHIFT);
|
|
|
|
pidhash_shift = max(4, fls(megabytes * 4));
|
|
pidhash_shift = min(12, pidhash_shift);
|
|
pidhash_size = 1 << pidhash_shift;
|
|
|
|
printk("PID hash table entries: %d (order: %d, %Zd bytes)\n",
|
|
pidhash_size, pidhash_shift,
|
|
pidhash_size * sizeof(struct hlist_head));
|
|
|
|
pid_hash = alloc_bootmem(pidhash_size * sizeof(*(pid_hash)));
|
|
if (!pid_hash)
|
|
panic("Could not alloc pidhash!\n");
|
|
for (i = 0; i < pidhash_size; i++)
|
|
INIT_HLIST_HEAD(&pid_hash[i]);
|
|
}
|
|
|
|
void __init pidmap_init(void)
|
|
{
|
|
pidmap_array->page = (void *)get_zeroed_page(GFP_KERNEL);
|
|
/* Reserve PID 0. We never call free_pidmap(0) */
|
|
set_bit(0, pidmap_array->page);
|
|
atomic_dec(&pidmap_array->nr_free);
|
|
|
|
pid_cachep = kmem_cache_create("pid", sizeof(struct pid),
|
|
__alignof__(struct pid),
|
|
SLAB_PANIC, NULL, NULL);
|
|
}
|