forked from luck/tmp_suning_uos_patched
0804ef4b0d
The problem: An opendir, readdir, closedir sequence can fail to report process ids that are continually in use throughout the sequence of system calls. For this race to trigger the process that proc_pid_readdir stops at must exit before readdir is called again. This can cause ps to fail to report processes, and it is in violation of posix guarantees and normal application expectations with respect to readdir. Currently there is no way to work around this problem in user space short of providing a gargantuan buffer to user space so the directory read all happens in on system call. This patch implements the normal directory semantics for proc, that guarantee that a directory entry that is neither created nor destroyed while reading the directory entry will be returned. For directory that are either created or destroyed during the readdir you may or may not see them. Furthermore you may seek to a directory offset you have previously seen. These are the guarantee that ext[23] provides and that posix requires, and more importantly that user space expects. Plus it is a simple semantic to implement reliable service. It is just a matter of calling readdir a second time if you are wondering if something new has show up. These better semantics are implemented by scanning through the pids in numerical order and by making the file offset a pid plus a fixed offset. The pid scan happens on the pid bitmap, which when you look at it is remarkably efficient for a brute force algorithm. Given that a typical cache line is 64 bytes and thus covers space for 64*8 == 200 pids. There are only 40 cache lines for the entire 32K pid space. A typical system will have 100 pids or more so this is actually fewer cache lines we have to look at to scan a linked list, and the worst case of having to scan the entire pid bitmap is pretty reasonable. If we need something more efficient we can go to a more efficient data structure for indexing the pids, but for now what we have should be sufficient. In addition this takes no additional locks and is actually less code than what we are doing now. Also another very subtle bug in this area has been fixed. It is possible to catch a task in the middle of de_thread where a thread is assuming the thread of it's thread group leader. This patch carefully handles that case so if we hit it we don't fail to return the pid, that is undergoing the de_thread dance. Thanks to KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> for providing the first fix, pointing this out and working on it. [oleg@tv-sign.ru: fix it] Signed-off-by: Eric W. Biederman <ebiederm@xmission.com> Acked-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru> Cc: Jean Delvare <jdelvare@suse.de> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
377 lines
9.3 KiB
C
377 lines
9.3 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;
|
|
}
|
|
|
|
static int next_pidmap(int last)
|
|
{
|
|
int offset;
|
|
pidmap_t *map;
|
|
|
|
offset = (last + 1) & BITS_PER_PAGE_MASK;
|
|
map = &pidmap_array[(last + 1)/BITS_PER_PAGE];
|
|
for (; map < &pidmap_array[PIDMAP_ENTRIES]; map++, offset = 0) {
|
|
if (unlikely(!map->page))
|
|
continue;
|
|
offset = find_next_bit((map)->page, BITS_PER_PAGE, offset);
|
|
if (offset < BITS_PER_PAGE)
|
|
return 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(struct task_struct *task, enum pid_type type, int nr)
|
|
{
|
|
struct pid_link *link;
|
|
struct pid *pid;
|
|
|
|
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(struct task_struct *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);
|
|
}
|
|
|
|
/* transfer_pid is an optimization of attach_pid(new), detach_pid(old) */
|
|
void fastcall transfer_pid(struct task_struct *old, struct task_struct *new,
|
|
enum pid_type type)
|
|
{
|
|
new->pids[type].pid = old->pids[type].pid;
|
|
hlist_replace_rcu(&old->pids[type].node, &new->pids[type].node);
|
|
old->pids[type].pid = NULL;
|
|
}
|
|
|
|
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.
|
|
*/
|
|
struct task_struct *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;
|
|
}
|
|
|
|
/*
|
|
* Used by proc to find the first pid that is greater then or equal to nr.
|
|
*
|
|
* If there is a pid at nr this function is exactly the same as find_pid.
|
|
*/
|
|
struct pid *find_ge_pid(int nr)
|
|
{
|
|
struct pid *pid;
|
|
|
|
do {
|
|
pid = find_pid(nr);
|
|
if (pid)
|
|
break;
|
|
nr = next_pidmap(nr);
|
|
} while (nr > 0);
|
|
|
|
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);
|
|
}
|