mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 02:32:09 -04:00
Merge branch 'akpm' (patches from Andrew)
Merge more updates from Andrew Morton: - a bit more MM - procfs updates - dynamic-debug fixes - lib/ updates - checkpatch - epoll - nilfs2 - signals - rapidio - PID management cleanup and optimization - kcov updates - sysvipc updates - quite a few misc things all over the place * emailed patches from Andrew Morton <[email protected]>: (94 commits) EXPERT Kconfig menu: fix broken EXPERT menu include/asm-generic/topology.h: remove unused parent_node() macro arch/tile/include/asm/topology.h: remove unused parent_node() macro arch/sparc/include/asm/topology_64.h: remove unused parent_node() macro arch/sh/include/asm/topology.h: remove unused parent_node() macro arch/ia64/include/asm/topology.h: remove unused parent_node() macro drivers/pcmcia/sa1111_badge4.c: avoid unused function warning mm: add infrastructure for get_user_pages_fast() benchmarking sysvipc: make get_maxid O(1) again sysvipc: properly name ipc_addid() limit parameter sysvipc: duplicate lock comments wrt ipc_addid() sysvipc: unteach ids->next_id for !CHECKPOINT_RESTORE initramfs: use time64_t timestamps drivers/watchdog: make use of devm_register_reboot_notifier() kernel/reboot.c: add devm_register_reboot_notifier() kcov: update documentation Makefile: support flag -fsanitizer-coverage=trace-cmp kcov: support comparison operands collection kcov: remove pointless current != NULL check kernel/panic.c: add TAINT_AUX ...
This commit is contained in:
Linus Torvalds
commit
fa7f578076
115 changed files with 1892 additions and 952 deletions
|
|
@ -81,7 +81,8 @@ static int autofs4_write(struct autofs_sb_info *sbi,
|
|||
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
|
||||
}
|
||||
|
||||
return (bytes > 0);
|
||||
/* if 'wr' returned 0 (impossible) we assume -EIO (safe) */
|
||||
return bytes == 0 ? 0 : wr < 0 ? wr : -EIO;
|
||||
}
|
||||
|
||||
static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
|
||||
|
|
@ -95,6 +96,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
|
|||
} pkt;
|
||||
struct file *pipe = NULL;
|
||||
size_t pktsz;
|
||||
int ret;
|
||||
|
||||
pr_debug("wait id = 0x%08lx, name = %.*s, type=%d\n",
|
||||
(unsigned long) wq->wait_queue_token,
|
||||
|
|
@ -169,7 +171,18 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
|
|||
mutex_unlock(&sbi->wq_mutex);
|
||||
|
||||
if (autofs4_write(sbi, pipe, &pkt, pktsz))
|
||||
switch (ret = autofs4_write(sbi, pipe, &pkt, pktsz)) {
|
||||
case 0:
|
||||
break;
|
||||
case -ENOMEM:
|
||||
case -ERESTARTSYS:
|
||||
/* Just fail this one */
|
||||
autofs4_wait_release(sbi, wq->wait_queue_token, ret);
|
||||
break;
|
||||
default:
|
||||
autofs4_catatonic_mode(sbi);
|
||||
break;
|
||||
}
|
||||
fput(pipe);
|
||||
}
|
||||
|
||||
|
|
|
|||
137
fs/eventpoll.c
137
fs/eventpoll.c
|
|
@ -276,12 +276,6 @@ static DEFINE_MUTEX(epmutex);
|
|||
/* Used to check for epoll file descriptor inclusion loops */
|
||||
static struct nested_calls poll_loop_ncalls;
|
||||
|
||||
/* Used for safe wake up implementation */
|
||||
static struct nested_calls poll_safewake_ncalls;
|
||||
|
||||
/* Used to call file's f_op->poll() under the nested calls boundaries */
|
||||
static struct nested_calls poll_readywalk_ncalls;
|
||||
|
||||
/* Slab cache used to allocate "struct epitem" */
|
||||
static struct kmem_cache *epi_cache __read_mostly;
|
||||
|
||||
|
|
@ -551,40 +545,21 @@ out_unlock:
|
|||
* this special case of epoll.
|
||||
*/
|
||||
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
||||
static inline void ep_wake_up_nested(wait_queue_head_t *wqueue,
|
||||
unsigned long events, int subclass)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave_nested(&wqueue->lock, flags, subclass);
|
||||
wake_up_locked_poll(wqueue, events);
|
||||
spin_unlock_irqrestore(&wqueue->lock, flags);
|
||||
}
|
||||
#else
|
||||
static inline void ep_wake_up_nested(wait_queue_head_t *wqueue,
|
||||
unsigned long events, int subclass)
|
||||
{
|
||||
wake_up_poll(wqueue, events);
|
||||
}
|
||||
#endif
|
||||
static struct nested_calls poll_safewake_ncalls;
|
||||
|
||||
static int ep_poll_wakeup_proc(void *priv, void *cookie, int call_nests)
|
||||
{
|
||||
ep_wake_up_nested((wait_queue_head_t *) cookie, POLLIN,
|
||||
1 + call_nests);
|
||||
unsigned long flags;
|
||||
wait_queue_head_t *wqueue = (wait_queue_head_t *)cookie;
|
||||
|
||||
spin_lock_irqsave_nested(&wqueue->lock, flags, call_nests + 1);
|
||||
wake_up_locked_poll(wqueue, POLLIN);
|
||||
spin_unlock_irqrestore(&wqueue->lock, flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform a safe wake up of the poll wait list. The problem is that
|
||||
* with the new callback'd wake up system, it is possible that the
|
||||
* poll callback is reentered from inside the call to wake_up() done
|
||||
* on the poll wait queue head. The rule is that we cannot reenter the
|
||||
* wake up code from the same task more than EP_MAX_NESTS times,
|
||||
* and we cannot reenter the same wait queue head at all. This will
|
||||
* enable to have a hierarchy of epoll file descriptor of no more than
|
||||
* EP_MAX_NESTS deep.
|
||||
*/
|
||||
static void ep_poll_safewake(wait_queue_head_t *wq)
|
||||
{
|
||||
int this_cpu = get_cpu();
|
||||
|
|
@ -595,6 +570,15 @@ static void ep_poll_safewake(wait_queue_head_t *wq)
|
|||
put_cpu();
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void ep_poll_safewake(wait_queue_head_t *wq)
|
||||
{
|
||||
wake_up_poll(wq, POLLIN);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static void ep_remove_wait_queue(struct eppoll_entry *pwq)
|
||||
{
|
||||
wait_queue_head_t *whead;
|
||||
|
|
@ -880,11 +864,33 @@ static int ep_eventpoll_release(struct inode *inode, struct file *file)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static inline unsigned int ep_item_poll(struct epitem *epi, poll_table *pt)
|
||||
{
|
||||
pt->_key = epi->event.events;
|
||||
static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
|
||||
void *priv);
|
||||
static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
|
||||
poll_table *pt);
|
||||
|
||||
return epi->ffd.file->f_op->poll(epi->ffd.file, pt) & epi->event.events;
|
||||
/*
|
||||
* Differs from ep_eventpoll_poll() in that internal callers already have
|
||||
* the ep->mtx so we need to start from depth=1, such that mutex_lock_nested()
|
||||
* is correctly annotated.
|
||||
*/
|
||||
static unsigned int ep_item_poll(struct epitem *epi, poll_table *pt, int depth)
|
||||
{
|
||||
struct eventpoll *ep;
|
||||
bool locked;
|
||||
|
||||
pt->_key = epi->event.events;
|
||||
if (!is_file_epoll(epi->ffd.file))
|
||||
return epi->ffd.file->f_op->poll(epi->ffd.file, pt) &
|
||||
epi->event.events;
|
||||
|
||||
ep = epi->ffd.file->private_data;
|
||||
poll_wait(epi->ffd.file, &ep->poll_wait, pt);
|
||||
locked = pt && (pt->_qproc == ep_ptable_queue_proc);
|
||||
|
||||
return ep_scan_ready_list(epi->ffd.file->private_data,
|
||||
ep_read_events_proc, &depth, depth,
|
||||
locked) & epi->event.events;
|
||||
}
|
||||
|
||||
static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
|
||||
|
|
@ -892,13 +898,15 @@ static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
|
|||
{
|
||||
struct epitem *epi, *tmp;
|
||||
poll_table pt;
|
||||
int depth = *(int *)priv;
|
||||
|
||||
init_poll_funcptr(&pt, NULL);
|
||||
depth++;
|
||||
|
||||
list_for_each_entry_safe(epi, tmp, head, rdllink) {
|
||||
if (ep_item_poll(epi, &pt))
|
||||
if (ep_item_poll(epi, &pt, depth)) {
|
||||
return POLLIN | POLLRDNORM;
|
||||
else {
|
||||
} else {
|
||||
/*
|
||||
* Item has been dropped into the ready list by the poll
|
||||
* callback, but it's not actually ready, as far as
|
||||
|
|
@ -912,48 +920,20 @@ static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
|
||||
poll_table *pt);
|
||||
|
||||
struct readyevents_arg {
|
||||
struct eventpoll *ep;
|
||||
bool locked;
|
||||
};
|
||||
|
||||
static int ep_poll_readyevents_proc(void *priv, void *cookie, int call_nests)
|
||||
{
|
||||
struct readyevents_arg *arg = priv;
|
||||
|
||||
return ep_scan_ready_list(arg->ep, ep_read_events_proc, NULL,
|
||||
call_nests + 1, arg->locked);
|
||||
}
|
||||
|
||||
static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
|
||||
{
|
||||
int pollflags;
|
||||
struct eventpoll *ep = file->private_data;
|
||||
struct readyevents_arg arg;
|
||||
|
||||
/*
|
||||
* During ep_insert() we already hold the ep->mtx for the tfile.
|
||||
* Prevent re-aquisition.
|
||||
*/
|
||||
arg.locked = wait && (wait->_qproc == ep_ptable_queue_proc);
|
||||
arg.ep = ep;
|
||||
int depth = 0;
|
||||
|
||||
/* Insert inside our poll wait queue */
|
||||
poll_wait(file, &ep->poll_wait, wait);
|
||||
|
||||
/*
|
||||
* Proceed to find out if wanted events are really available inside
|
||||
* the ready list. This need to be done under ep_call_nested()
|
||||
* supervision, since the call to f_op->poll() done on listed files
|
||||
* could re-enter here.
|
||||
* the ready list.
|
||||
*/
|
||||
pollflags = ep_call_nested(&poll_readywalk_ncalls, EP_MAX_NESTS,
|
||||
ep_poll_readyevents_proc, &arg, ep, current);
|
||||
|
||||
return pollflags != -1 ? pollflags : 0;
|
||||
return ep_scan_ready_list(ep, ep_read_events_proc,
|
||||
&depth, depth, false);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PROC_FS
|
||||
|
|
@ -1472,7 +1452,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
|
|||
* this operation completes, the poll callback can start hitting
|
||||
* the new item.
|
||||
*/
|
||||
revents = ep_item_poll(epi, &epq.pt);
|
||||
revents = ep_item_poll(epi, &epq.pt, 1);
|
||||
|
||||
/*
|
||||
* We have to check if something went wrong during the poll wait queue
|
||||
|
|
@ -1606,7 +1586,7 @@ static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_even
|
|||
* Get current event bits. We can safely use the file* here because
|
||||
* its usage count has been increased by the caller of this function.
|
||||
*/
|
||||
revents = ep_item_poll(epi, &pt);
|
||||
revents = ep_item_poll(epi, &pt, 1);
|
||||
|
||||
/*
|
||||
* If the item is "hot" and it is not registered inside the ready
|
||||
|
|
@ -1674,7 +1654,7 @@ static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
|
|||
|
||||
list_del_init(&epi->rdllink);
|
||||
|
||||
revents = ep_item_poll(epi, &pt);
|
||||
revents = ep_item_poll(epi, &pt, 1);
|
||||
|
||||
/*
|
||||
* If the event mask intersect the caller-requested one,
|
||||
|
|
@ -2313,11 +2293,10 @@ static int __init eventpoll_init(void)
|
|||
*/
|
||||
ep_nested_calls_init(&poll_loop_ncalls);
|
||||
|
||||
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
||||
/* Initialize the structure used to perform safe poll wait head wake ups */
|
||||
ep_nested_calls_init(&poll_safewake_ncalls);
|
||||
|
||||
/* Initialize the structure used to perform file's f_op->poll() calls */
|
||||
ep_nested_calls_init(&poll_readywalk_ncalls);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* We can have many thousands of epitems, so prevent this from
|
||||
|
|
@ -2327,11 +2306,11 @@ static int __init eventpoll_init(void)
|
|||
|
||||
/* Allocates slab cache used to allocate "struct epitem" items */
|
||||
epi_cache = kmem_cache_create("eventpoll_epi", sizeof(struct epitem),
|
||||
0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
|
||||
0, SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
|
||||
|
||||
/* Allocates slab cache used to allocate "struct eppoll_entry" */
|
||||
pwq_cache = kmem_cache_create("eventpoll_pwq",
|
||||
sizeof(struct eppoll_entry), 0, SLAB_PANIC, NULL);
|
||||
sizeof(struct eppoll_entry), 0, SLAB_PANIC|SLAB_ACCOUNT, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -291,7 +291,6 @@ static int fat_parse_long(struct inode *dir, loff_t *pos,
|
|||
}
|
||||
}
|
||||
parse_long:
|
||||
slots = 0;
|
||||
ds = (struct msdos_dir_slot *)*de;
|
||||
id = ds->id;
|
||||
if (!(id & 0x40))
|
||||
|
|
|
|||
|
|
@ -98,13 +98,11 @@ void hfs_bnode_clear(struct hfs_bnode *node, int off, int len)
|
|||
void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
|
||||
struct hfs_bnode *src_node, int src, int len)
|
||||
{
|
||||
struct hfs_btree *tree;
|
||||
struct page *src_page, *dst_page;
|
||||
|
||||
hfs_dbg(BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
|
||||
if (!len)
|
||||
return;
|
||||
tree = src_node->tree;
|
||||
src += src_node->page_offset;
|
||||
dst += dst_node->page_offset;
|
||||
src_page = src_node->page[0];
|
||||
|
|
@ -237,7 +235,6 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
|
|||
|
||||
static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
|
||||
{
|
||||
struct super_block *sb;
|
||||
struct hfs_bnode *node, *node2;
|
||||
struct address_space *mapping;
|
||||
struct page *page;
|
||||
|
|
@ -249,7 +246,6 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sb = tree->inode->i_sb;
|
||||
size = sizeof(struct hfs_bnode) + tree->pages_per_bnode *
|
||||
sizeof(struct page *);
|
||||
node = kzalloc(size, GFP_KERNEL);
|
||||
|
|
|
|||
|
|
@ -127,14 +127,12 @@ void hfs_bnode_clear(struct hfs_bnode *node, int off, int len)
|
|||
void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
|
||||
struct hfs_bnode *src_node, int src, int len)
|
||||
{
|
||||
struct hfs_btree *tree;
|
||||
struct page **src_page, **dst_page;
|
||||
int l;
|
||||
|
||||
hfs_dbg(BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
|
||||
if (!len)
|
||||
return;
|
||||
tree = src_node->tree;
|
||||
src += src_node->page_offset;
|
||||
dst += dst_node->page_offset;
|
||||
src_page = src_node->page + (src >> PAGE_SHIFT);
|
||||
|
|
@ -401,7 +399,6 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
|
|||
|
||||
static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
|
||||
{
|
||||
struct super_block *sb;
|
||||
struct hfs_bnode *node, *node2;
|
||||
struct address_space *mapping;
|
||||
struct page *page;
|
||||
|
|
@ -414,7 +411,6 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
sb = tree->inode->i_sb;
|
||||
size = sizeof(struct hfs_bnode) + tree->pages_per_bnode *
|
||||
sizeof(struct page *);
|
||||
node = kzalloc(size, GFP_KERNEL);
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
|
|||
if (err)
|
||||
return err;
|
||||
|
||||
inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO);
|
||||
inode = nilfs_new_inode(dir, S_IFLNK | 0777);
|
||||
err = PTR_ERR(inode);
|
||||
if (IS_ERR(inode))
|
||||
goto out;
|
||||
|
|
|
|||
|
|
@ -1954,8 +1954,6 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
|
|||
err, ii->vfs_inode.i_ino);
|
||||
return err;
|
||||
}
|
||||
mark_buffer_dirty(ibh);
|
||||
nilfs_mdt_mark_dirty(ifile);
|
||||
spin_lock(&nilfs->ns_inode_lock);
|
||||
if (likely(!ii->i_bh))
|
||||
ii->i_bh = ibh;
|
||||
|
|
@ -1964,6 +1962,10 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
|
|||
goto retry;
|
||||
}
|
||||
|
||||
// Always redirty the buffer to avoid race condition
|
||||
mark_buffer_dirty(ii->i_bh);
|
||||
nilfs_mdt_mark_dirty(ifile);
|
||||
|
||||
clear_bit(NILFS_I_QUEUED, &ii->i_state);
|
||||
set_bit(NILFS_I_BUSY, &ii->i_state);
|
||||
list_move_tail(&ii->i_dirty, &sci->sc_dirty_files);
|
||||
|
|
@ -2400,11 +2402,11 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
|
|||
return err;
|
||||
}
|
||||
|
||||
static void nilfs_construction_timeout(unsigned long data)
|
||||
static void nilfs_construction_timeout(struct timer_list *t)
|
||||
{
|
||||
struct task_struct *p = (struct task_struct *)data;
|
||||
struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer);
|
||||
|
||||
wake_up_process(p);
|
||||
wake_up_process(sci->sc_timer_task);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -2542,8 +2544,7 @@ static int nilfs_segctor_thread(void *arg)
|
|||
struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
|
||||
int timeout = 0;
|
||||
|
||||
sci->sc_timer.data = (unsigned long)current;
|
||||
sci->sc_timer.function = nilfs_construction_timeout;
|
||||
sci->sc_timer_task = current;
|
||||
|
||||
/* start sync. */
|
||||
sci->sc_task = current;
|
||||
|
|
@ -2674,7 +2675,7 @@ static struct nilfs_sc_info *nilfs_segctor_new(struct super_block *sb,
|
|||
INIT_LIST_HEAD(&sci->sc_gc_inodes);
|
||||
INIT_LIST_HEAD(&sci->sc_iput_queue);
|
||||
INIT_WORK(&sci->sc_iput_work, nilfs_iput_work_func);
|
||||
init_timer(&sci->sc_timer);
|
||||
timer_setup(&sci->sc_timer, nilfs_construction_timeout, 0);
|
||||
|
||||
sci->sc_interval = HZ * NILFS_SC_DEFAULT_TIMEOUT;
|
||||
sci->sc_mjcp_freq = HZ * NILFS_SC_DEFAULT_SR_FREQ;
|
||||
|
|
|
|||
|
|
@ -180,6 +180,7 @@ struct nilfs_sc_info {
|
|||
unsigned long sc_watermark;
|
||||
|
||||
struct timer_list sc_timer;
|
||||
struct task_struct *sc_timer_task;
|
||||
struct task_struct *sc_task;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -630,22 +630,22 @@ void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum,
|
|||
}
|
||||
|
||||
/**
|
||||
* nilfs_sufile_truncate_range - truncate range of segment array
|
||||
* @sufile: inode of segment usage file
|
||||
* @start: start segment number (inclusive)
|
||||
* @end: end segment number (inclusive)
|
||||
*
|
||||
* Return Value: On success, 0 is returned. On error, one of the
|
||||
* following negative error codes is returned.
|
||||
*
|
||||
* %-EIO - I/O error.
|
||||
*
|
||||
* %-ENOMEM - Insufficient amount of memory available.
|
||||
*
|
||||
* %-EINVAL - Invalid number of segments specified
|
||||
*
|
||||
* %-EBUSY - Dirty or active segments are present in the range
|
||||
*/
|
||||
* nilfs_sufile_truncate_range - truncate range of segment array
|
||||
* @sufile: inode of segment usage file
|
||||
* @start: start segment number (inclusive)
|
||||
* @end: end segment number (inclusive)
|
||||
*
|
||||
* Return Value: On success, 0 is returned. On error, one of the
|
||||
* following negative error codes is returned.
|
||||
*
|
||||
* %-EIO - I/O error.
|
||||
*
|
||||
* %-ENOMEM - Insufficient amount of memory available.
|
||||
*
|
||||
* %-EINVAL - Invalid number of segments specified
|
||||
*
|
||||
* %-EBUSY - Dirty or active segments are present in the range
|
||||
*/
|
||||
static int nilfs_sufile_truncate_range(struct inode *sufile,
|
||||
__u64 start, __u64 end)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -160,7 +160,6 @@ struct inode *nilfs_alloc_inode(struct super_block *sb)
|
|||
ii->i_bh = NULL;
|
||||
ii->i_state = 0;
|
||||
ii->i_cno = 0;
|
||||
ii->vfs_inode.i_version = 1;
|
||||
nilfs_mapping_init(&ii->i_btnode_cache, &ii->vfs_inode);
|
||||
return &ii->vfs_inode;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -737,7 +737,7 @@ struct nilfs_root *nilfs_lookup_root(struct the_nilfs *nilfs, __u64 cno)
|
|||
} else if (cno > root->cno) {
|
||||
n = n->rb_right;
|
||||
} else {
|
||||
atomic_inc(&root->count);
|
||||
refcount_inc(&root->count);
|
||||
spin_unlock(&nilfs->ns_cptree_lock);
|
||||
return root;
|
||||
}
|
||||
|
|
@ -776,7 +776,7 @@ nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno)
|
|||
} else if (cno > root->cno) {
|
||||
p = &(*p)->rb_right;
|
||||
} else {
|
||||
atomic_inc(&root->count);
|
||||
refcount_inc(&root->count);
|
||||
spin_unlock(&nilfs->ns_cptree_lock);
|
||||
kfree(new);
|
||||
return root;
|
||||
|
|
@ -786,7 +786,7 @@ nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno)
|
|||
new->cno = cno;
|
||||
new->ifile = NULL;
|
||||
new->nilfs = nilfs;
|
||||
atomic_set(&new->count, 1);
|
||||
refcount_set(&new->count, 1);
|
||||
atomic64_set(&new->inodes_count, 0);
|
||||
atomic64_set(&new->blocks_count, 0);
|
||||
|
||||
|
|
@ -806,7 +806,7 @@ nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno)
|
|||
|
||||
void nilfs_put_root(struct nilfs_root *root)
|
||||
{
|
||||
if (atomic_dec_and_test(&root->count)) {
|
||||
if (refcount_dec_and_test(&root->count)) {
|
||||
struct the_nilfs *nilfs = root->nilfs;
|
||||
|
||||
nilfs_sysfs_delete_snapshot_group(root);
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@
|
|||
#include <linux/blkdev.h>
|
||||
#include <linux/backing-dev.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/refcount.h>
|
||||
|
||||
struct nilfs_sc_info;
|
||||
struct nilfs_sysfs_dev_subgroups;
|
||||
|
|
@ -246,7 +247,7 @@ struct nilfs_root {
|
|||
__u64 cno;
|
||||
struct rb_node rb_node;
|
||||
|
||||
atomic_t count;
|
||||
refcount_t count;
|
||||
struct the_nilfs *nilfs;
|
||||
struct inode *ifile;
|
||||
|
||||
|
|
@ -299,7 +300,7 @@ void nilfs_swap_super_block(struct the_nilfs *);
|
|||
|
||||
static inline void nilfs_get_root(struct nilfs_root *root)
|
||||
{
|
||||
atomic_inc(&root->count);
|
||||
refcount_inc(&root->count);
|
||||
}
|
||||
|
||||
static inline int nilfs_valid_fs(struct the_nilfs *nilfs)
|
||||
|
|
|
|||
23
fs/pipe.c
23
fs/pipe.c
|
|
@ -1018,13 +1018,19 @@ const struct file_operations pipefifo_fops = {
|
|||
|
||||
/*
|
||||
* Currently we rely on the pipe array holding a power-of-2 number
|
||||
* of pages.
|
||||
* of pages. Returns 0 on error.
|
||||
*/
|
||||
static inline unsigned int round_pipe_size(unsigned int size)
|
||||
unsigned int round_pipe_size(unsigned int size)
|
||||
{
|
||||
unsigned long nr_pages;
|
||||
|
||||
if (size < pipe_min_size)
|
||||
size = pipe_min_size;
|
||||
|
||||
nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
||||
if (nr_pages == 0)
|
||||
return 0;
|
||||
|
||||
return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
|
||||
}
|
||||
|
||||
|
|
@ -1040,6 +1046,8 @@ static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
|
|||
long ret = 0;
|
||||
|
||||
size = round_pipe_size(arg);
|
||||
if (size == 0)
|
||||
return -EINVAL;
|
||||
nr_pages = size >> PAGE_SHIFT;
|
||||
|
||||
if (!nr_pages)
|
||||
|
|
@ -1117,20 +1125,13 @@ out_revert_acct:
|
|||
}
|
||||
|
||||
/*
|
||||
* This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
|
||||
* This should work even if CONFIG_PROC_FS isn't set, as proc_dopipe_max_size
|
||||
* will return an error.
|
||||
*/
|
||||
int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
|
||||
size_t *lenp, loff_t *ppos)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
|
||||
if (ret < 0 || !write)
|
||||
return ret;
|
||||
|
||||
pipe_max_size = round_pipe_size(pipe_max_size);
|
||||
return ret;
|
||||
return proc_dopipe_max_size(table, write, buf, lenp, ppos);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ proc-y += loadavg.o
|
|||
proc-y += meminfo.o
|
||||
proc-y += stat.o
|
||||
proc-y += uptime.o
|
||||
proc-y += util.o
|
||||
proc-y += version.o
|
||||
proc-y += softirqs.o
|
||||
proc-y += namespaces.o
|
||||
|
|
|
|||
|
|
@ -366,6 +366,11 @@ static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
|
|||
cpumask_pr_args(&task->cpus_allowed));
|
||||
}
|
||||
|
||||
static inline void task_core_dumping(struct seq_file *m, struct mm_struct *mm)
|
||||
{
|
||||
seq_printf(m, "CoreDumping:\t%d\n", !!mm->core_state);
|
||||
}
|
||||
|
||||
int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
|
||||
struct pid *pid, struct task_struct *task)
|
||||
{
|
||||
|
|
@ -376,6 +381,7 @@ int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
|
|||
|
||||
if (mm) {
|
||||
task_mem(m, mm);
|
||||
task_core_dumping(m, mm);
|
||||
mmput(mm);
|
||||
}
|
||||
task_sig(m, task);
|
||||
|
|
|
|||
|
|
@ -103,28 +103,7 @@ static inline struct task_struct *get_proc_task(struct inode *inode)
|
|||
void task_dump_owner(struct task_struct *task, mode_t mode,
|
||||
kuid_t *ruid, kgid_t *rgid);
|
||||
|
||||
static inline unsigned name_to_int(const struct qstr *qstr)
|
||||
{
|
||||
const char *name = qstr->name;
|
||||
int len = qstr->len;
|
||||
unsigned n = 0;
|
||||
|
||||
if (len > 1 && *name == '0')
|
||||
goto out;
|
||||
while (len-- > 0) {
|
||||
unsigned c = *name++ - '0';
|
||||
if (c > 9)
|
||||
goto out;
|
||||
if (n >= (~0U-9)/10)
|
||||
goto out;
|
||||
n *= 10;
|
||||
n += c;
|
||||
}
|
||||
return n;
|
||||
out:
|
||||
return ~0U;
|
||||
}
|
||||
|
||||
unsigned name_to_int(const struct qstr *qstr);
|
||||
/*
|
||||
* Offset of the first process in the /proc root directory..
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ static int loadavg_proc_show(struct seq_file *m, void *v)
|
|||
LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),
|
||||
LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]),
|
||||
nr_running(), nr_threads,
|
||||
task_active_pid_ns(current)->last_pid);
|
||||
idr_get_cursor(&task_active_pid_ns(current)->idr));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
23
fs/proc/util.c
Normal file
23
fs/proc/util.c
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#include <linux/dcache.h>
|
||||
|
||||
unsigned name_to_int(const struct qstr *qstr)
|
||||
{
|
||||
const char *name = qstr->name;
|
||||
int len = qstr->len;
|
||||
unsigned n = 0;
|
||||
|
||||
if (len > 1 && *name == '0')
|
||||
goto out;
|
||||
do {
|
||||
unsigned c = *name++ - '0';
|
||||
if (c > 9)
|
||||
goto out;
|
||||
if (n >= (~0U-9)/10)
|
||||
goto out;
|
||||
n *= 10;
|
||||
n += c;
|
||||
} while (--len > 0);
|
||||
return n;
|
||||
out:
|
||||
return ~0U;
|
||||
}
|
||||
Loading…
Reference in a new issue