mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-24 04:34:08 +08:00
Merge branch 'core-locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull core locking changes from Ingo Molnar:
"The biggest changes:
- add lockdep support for seqcount/seqlocks structures, this
unearthed both bugs and required extra annotation.
- move the various kernel locking primitives to the new
kernel/locking/ directory"
* 'core-locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (21 commits)
block: Use u64_stats_init() to initialize seqcounts
locking/lockdep: Mark __lockdep_count_forward_deps() as static
lockdep/proc: Fix lock-time avg computation
locking/doc: Update references to kernel/mutex.c
ipv6: Fix possible ipv6 seqlock deadlock
cpuset: Fix potential deadlock w/ set_mems_allowed
seqcount: Add lockdep functionality to seqcount/seqlock structures
net: Explicitly initialize u64_stats_sync structures for lockdep
locking: Move the percpu-rwsem code to kernel/locking/
locking: Move the lglocks code to kernel/locking/
locking: Move the rwsem code to kernel/locking/
locking: Move the rtmutex code to kernel/locking/
locking: Move the semaphore core to kernel/locking/
locking: Move the spinlock code to kernel/locking/
locking: Move the lockdep code to kernel/locking/
locking: Move the mutex code to kernel/locking/
hung_task debugging: Add tracepoint to report the hang
x86/locking/kconfig: Update paravirt spinlock Kconfig description
lockstat: Report avg wait and hold times
lockdep, x86/alternatives: Drop ancient lockdep fixup message
...
This commit is contained in:
Linus Torvalds
commit
5e30025a31
@ -1958,7 +1958,7 @@ machines due to caching.
|
||||
<chapter id="apiref-mutex">
|
||||
<title>Mutex API reference</title>
|
||||
!Iinclude/linux/mutex.h
|
||||
!Ekernel/mutex.c
|
||||
!Ekernel/locking/mutex.c
|
||||
</chapter>
|
||||
|
||||
<chapter id="apiref-futex">
|
||||
|
||||
@ -47,15 +47,13 @@ With these hooks we provide the following statistics:
|
||||
wait time min - shortest (non-0) time we ever had to wait for a lock
|
||||
max - longest time we ever had to wait for a lock
|
||||
total - total time we spend waiting on this lock
|
||||
avg - average time spent waiting on this lock
|
||||
acq-bounces - number of lock acquisitions that involved x-cpu data
|
||||
acquisitions - number of times we took the lock
|
||||
hold time min - shortest (non-0) time we ever held the lock
|
||||
max - longest time we ever held the lock
|
||||
total - total time this lock was held
|
||||
|
||||
From these number various other statistics can be derived, such as:
|
||||
|
||||
hold time average = hold time total / acquisitions
|
||||
avg - average time this lock was held
|
||||
|
||||
These numbers are gathered per lock class, per read/write state (when
|
||||
applicable).
|
||||
@ -84,37 +82,38 @@ Look at the current lock statistics:
|
||||
|
||||
# less /proc/lock_stat
|
||||
|
||||
01 lock_stat version 0.3
|
||||
02 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
03 class name con-bounces contentions waittime-min waittime-max waittime-total acq-bounces acquisitions holdtime-min holdtime-max holdtime-total
|
||||
04 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
01 lock_stat version 0.4
|
||||
02-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
03 class name con-bounces contentions waittime-min waittime-max waittime-total waittime-avg acq-bounces acquisitions holdtime-min holdtime-max holdtime-total holdtime-avg
|
||||
04-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
05
|
||||
06 &mm->mmap_sem-W: 233 538 18446744073708 22924.27 607243.51 1342 45806 1.71 8595.89 1180582.34
|
||||
07 &mm->mmap_sem-R: 205 587 18446744073708 28403.36 731975.00 1940 412426 0.58 187825.45 6307502.88
|
||||
06 &mm->mmap_sem-W: 46 84 0.26 939.10 16371.53 194.90 47291 2922365 0.16 2220301.69 17464026916.32 5975.99
|
||||
07 &mm->mmap_sem-R: 37 100 1.31 299502.61 325629.52 3256.30 212344 34316685 0.10 7744.91 95016910.20 2.77
|
||||
08 ---------------
|
||||
09 &mm->mmap_sem 487 [<ffffffff8053491f>] do_page_fault+0x466/0x928
|
||||
10 &mm->mmap_sem 179 [<ffffffff802a6200>] sys_mprotect+0xcd/0x21d
|
||||
11 &mm->mmap_sem 279 [<ffffffff80210a57>] sys_mmap+0x75/0xce
|
||||
12 &mm->mmap_sem 76 [<ffffffff802a490b>] sys_munmap+0x32/0x59
|
||||
09 &mm->mmap_sem 1 [<ffffffff811502a7>] khugepaged_scan_mm_slot+0x57/0x280
|
||||
19 &mm->mmap_sem 96 [<ffffffff815351c4>] __do_page_fault+0x1d4/0x510
|
||||
11 &mm->mmap_sem 34 [<ffffffff81113d77>] vm_mmap_pgoff+0x87/0xd0
|
||||
12 &mm->mmap_sem 17 [<ffffffff81127e71>] vm_munmap+0x41/0x80
|
||||
13 ---------------
|
||||
14 &mm->mmap_sem 270 [<ffffffff80210a57>] sys_mmap+0x75/0xce
|
||||
15 &mm->mmap_sem 431 [<ffffffff8053491f>] do_page_fault+0x466/0x928
|
||||
16 &mm->mmap_sem 138 [<ffffffff802a490b>] sys_munmap+0x32/0x59
|
||||
17 &mm->mmap_sem 145 [<ffffffff802a6200>] sys_mprotect+0xcd/0x21d
|
||||
14 &mm->mmap_sem 1 [<ffffffff81046fda>] dup_mmap+0x2a/0x3f0
|
||||
15 &mm->mmap_sem 60 [<ffffffff81129e29>] SyS_mprotect+0xe9/0x250
|
||||
16 &mm->mmap_sem 41 [<ffffffff815351c4>] __do_page_fault+0x1d4/0x510
|
||||
17 &mm->mmap_sem 68 [<ffffffff81113d77>] vm_mmap_pgoff+0x87/0xd0
|
||||
18
|
||||
19 ...............................................................................................................................................................................................
|
||||
19.............................................................................................................................................................................................................................
|
||||
20
|
||||
21 dcache_lock: 621 623 0.52 118.26 1053.02 6745 91930 0.29 316.29 118423.41
|
||||
22 -----------
|
||||
23 dcache_lock 179 [<ffffffff80378274>] _atomic_dec_and_lock+0x34/0x54
|
||||
24 dcache_lock 113 [<ffffffff802cc17b>] d_alloc+0x19a/0x1eb
|
||||
25 dcache_lock 99 [<ffffffff802ca0dc>] d_rehash+0x1b/0x44
|
||||
26 dcache_lock 104 [<ffffffff802cbca0>] d_instantiate+0x36/0x8a
|
||||
27 -----------
|
||||
28 dcache_lock 192 [<ffffffff80378274>] _atomic_dec_and_lock+0x34/0x54
|
||||
29 dcache_lock 98 [<ffffffff802ca0dc>] d_rehash+0x1b/0x44
|
||||
30 dcache_lock 72 [<ffffffff802cc17b>] d_alloc+0x19a/0x1eb
|
||||
31 dcache_lock 112 [<ffffffff802cbca0>] d_instantiate+0x36/0x8a
|
||||
21 unix_table_lock: 110 112 0.21 49.24 163.91 1.46 21094 66312 0.12 624.42 31589.81 0.48
|
||||
22 ---------------
|
||||
23 unix_table_lock 45 [<ffffffff8150ad8e>] unix_create1+0x16e/0x1b0
|
||||
24 unix_table_lock 47 [<ffffffff8150b111>] unix_release_sock+0x31/0x250
|
||||
25 unix_table_lock 15 [<ffffffff8150ca37>] unix_find_other+0x117/0x230
|
||||
26 unix_table_lock 5 [<ffffffff8150a09f>] unix_autobind+0x11f/0x1b0
|
||||
27 ---------------
|
||||
28 unix_table_lock 39 [<ffffffff8150b111>] unix_release_sock+0x31/0x250
|
||||
29 unix_table_lock 49 [<ffffffff8150ad8e>] unix_create1+0x16e/0x1b0
|
||||
30 unix_table_lock 20 [<ffffffff8150ca37>] unix_find_other+0x117/0x230
|
||||
31 unix_table_lock 4 [<ffffffff8150a09f>] unix_autobind+0x11f/0x1b0
|
||||
|
||||
|
||||
This excerpt shows the first two lock class statistics. Line 01 shows the
|
||||
output version - each time the format changes this will be updated. Line 02-04
|
||||
@ -131,9 +130,9 @@ The integer part of the time values is in us.
|
||||
|
||||
Dealing with nested locks, subclasses may appear:
|
||||
|
||||
32...............................................................................................................................................................................................
|
||||
32...........................................................................................................................................................................................................................
|
||||
33
|
||||
34 &rq->lock: 13128 13128 0.43 190.53 103881.26 97454 3453404 0.00 401.11 13224683.11
|
||||
34 &rq->lock: 13128 13128 0.43 190.53 103881.26 7.91 97454 3453404 0.00 401.11 13224683.11 3.82
|
||||
35 ---------
|
||||
36 &rq->lock 645 [<ffffffff8103bfc4>] task_rq_lock+0x43/0x75
|
||||
37 &rq->lock 297 [<ffffffff8104ba65>] try_to_wake_up+0x127/0x25a
|
||||
@ -145,9 +144,9 @@ Dealing with nested locks, subclasses may appear:
|
||||
43 &rq->lock 4715 [<ffffffff8103ed4b>] double_rq_lock+0x42/0x54
|
||||
44 &rq->lock 893 [<ffffffff81340524>] schedule+0x157/0x7b8
|
||||
45
|
||||
46...............................................................................................................................................................................................
|
||||
46...........................................................................................................................................................................................................................
|
||||
47
|
||||
48 &rq->lock/1: 11526 11488 0.33 388.73 136294.31 21461 38404 0.00 37.93 109388.53
|
||||
48 &rq->lock/1: 1526 11488 0.33 388.73 136294.31 11.86 21461 38404 0.00 37.93 109388.53 2.84
|
||||
49 -----------
|
||||
50 &rq->lock/1 11526 [<ffffffff8103ed58>] double_rq_lock+0x4f/0x54
|
||||
51 -----------
|
||||
@ -163,16 +162,16 @@ double_rq_lock actually acquires a nested lock of two spinlocks.
|
||||
View the top contending locks:
|
||||
|
||||
# grep : /proc/lock_stat | head
|
||||
&inode->i_data.tree_lock-W: 15 21657 0.18 1093295.30 11547131054.85 58 10415 0.16 87.51 6387.60
|
||||
&inode->i_data.tree_lock-R: 0 0 0.00 0.00 0.00 23302 231198 0.25 8.45 98023.38
|
||||
dcache_lock: 1037 1161 0.38 45.32 774.51 6611 243371 0.15 306.48 77387.24
|
||||
&inode->i_mutex: 161 286 18446744073709 62882.54 1244614.55 3653 20598 18446744073709 62318.60 1693822.74
|
||||
&zone->lru_lock: 94 94 0.53 7.33 92.10 4366 32690 0.29 59.81 16350.06
|
||||
&inode->i_data.i_mmap_mutex: 79 79 0.40 3.77 53.03 11779 87755 0.28 116.93 29898.44
|
||||
&q->__queue_lock: 48 50 0.52 31.62 86.31 774 13131 0.17 113.08 12277.52
|
||||
&rq->rq_lock_key: 43 47 0.74 68.50 170.63 3706 33929 0.22 107.99 17460.62
|
||||
&rq->rq_lock_key#2: 39 46 0.75 6.68 49.03 2979 32292 0.17 125.17 17137.63
|
||||
tasklist_lock-W: 15 15 1.45 10.87 32.70 1201 7390 0.58 62.55 13648.47
|
||||
clockevents_lock: 2926159 2947636 0.15 46882.81 1784540466.34 605.41 3381345 3879161 0.00 2260.97 53178395.68 13.71
|
||||
tick_broadcast_lock: 346460 346717 0.18 2257.43 39364622.71 113.54 3642919 4242696 0.00 2263.79 49173646.60 11.59
|
||||
&mapping->i_mmap_mutex: 203896 203899 3.36 645530.05 31767507988.39 155800.21 3361776 8893984 0.17 2254.15 14110121.02 1.59
|
||||
&rq->lock: 135014 136909 0.18 606.09 842160.68 6.15 1540728 10436146 0.00 728.72 17606683.41 1.69
|
||||
&(&zone->lru_lock)->rlock: 93000 94934 0.16 59.18 188253.78 1.98 1199912 3809894 0.15 391.40 3559518.81 0.93
|
||||
tasklist_lock-W: 40667 41130 0.23 1189.42 428980.51 10.43 270278 510106 0.16 653.51 3939674.91 7.72
|
||||
tasklist_lock-R: 21298 21305 0.20 1310.05 215511.12 10.12 186204 241258 0.14 1162.33 1179779.23 4.89
|
||||
rcu_node_1: 47656 49022 0.16 635.41 193616.41 3.95 844888 1865423 0.00 764.26 1656226.96 0.89
|
||||
&(&dentry->d_lockref.lock)->rlock: 39791 40179 0.15 1302.08 88851.96 2.21 2790851 12527025 0.10 1910.75 3379714.27 0.27
|
||||
rcu_node_0: 29203 30064 0.16 786.55 1555573.00 51.74 88963 244254 0.00 398.87 428872.51 1.76
|
||||
|
||||
Clear the statistics:
|
||||
|
||||
|
||||
@ -116,11 +116,11 @@ using mutexes at the moment, please let me know if you find any. ]
|
||||
Implementation of mutexes
|
||||
-------------------------
|
||||
|
||||
'struct mutex' is the new mutex type, defined in include/linux/mutex.h
|
||||
and implemented in kernel/mutex.c. It is a counter-based mutex with a
|
||||
spinlock and a wait-list. The counter has 3 states: 1 for "unlocked",
|
||||
0 for "locked" and negative numbers (usually -1) for "locked, potential
|
||||
waiters queued".
|
||||
'struct mutex' is the new mutex type, defined in include/linux/mutex.h and
|
||||
implemented in kernel/locking/mutex.c. It is a counter-based mutex with a
|
||||
spinlock and a wait-list. The counter has 3 states: 1 for "unlocked", 0 for
|
||||
"locked" and negative numbers (usually -1) for "locked, potential waiters
|
||||
queued".
|
||||
|
||||
the APIs of 'struct mutex' have been streamlined:
|
||||
|
||||
|
||||
@ -635,10 +635,10 @@ config PARAVIRT_SPINLOCKS
|
||||
spinlock implementation with something virtualization-friendly
|
||||
(for example, block the virtual CPU rather than spinning).
|
||||
|
||||
Unfortunately the downside is an up to 5% performance hit on
|
||||
native kernels, with various workloads.
|
||||
It has a minimal impact on native kernels and gives a nice performance
|
||||
benefit on paravirtualized KVM / Xen kernels.
|
||||
|
||||
If you are unsure how to answer this question, answer N.
|
||||
If you are unsure how to answer this question, answer Y.
|
||||
|
||||
source "arch/x86/xen/Kconfig"
|
||||
|
||||
|
||||
@ -402,17 +402,6 @@ void alternatives_enable_smp(void)
|
||||
{
|
||||
struct smp_alt_module *mod;
|
||||
|
||||
#ifdef CONFIG_LOCKDEP
|
||||
/*
|
||||
* Older binutils section handling bug prevented
|
||||
* alternatives-replacement from working reliably.
|
||||
*
|
||||
* If this still occurs then you should see a hang
|
||||
* or crash shortly after this line:
|
||||
*/
|
||||
pr_info("lockdep: fixing up alternatives\n");
|
||||
#endif
|
||||
|
||||
/* Why bother if there are no other CPUs? */
|
||||
BUG_ON(num_possible_cpus() == 1);
|
||||
|
||||
|
||||
@ -178,7 +178,7 @@ notrace static int __always_inline do_realtime(struct timespec *ts)
|
||||
|
||||
ts->tv_nsec = 0;
|
||||
do {
|
||||
seq = read_seqcount_begin(>od->seq);
|
||||
seq = read_seqcount_begin_no_lockdep(>od->seq);
|
||||
mode = gtod->clock.vclock_mode;
|
||||
ts->tv_sec = gtod->wall_time_sec;
|
||||
ns = gtod->wall_time_snsec;
|
||||
@ -198,7 +198,7 @@ notrace static int do_monotonic(struct timespec *ts)
|
||||
|
||||
ts->tv_nsec = 0;
|
||||
do {
|
||||
seq = read_seqcount_begin(>od->seq);
|
||||
seq = read_seqcount_begin_no_lockdep(>od->seq);
|
||||
mode = gtod->clock.vclock_mode;
|
||||
ts->tv_sec = gtod->monotonic_time_sec;
|
||||
ns = gtod->monotonic_time_snsec;
|
||||
@ -214,7 +214,7 @@ notrace static int do_realtime_coarse(struct timespec *ts)
|
||||
{
|
||||
unsigned long seq;
|
||||
do {
|
||||
seq = read_seqcount_begin(>od->seq);
|
||||
seq = read_seqcount_begin_no_lockdep(>od->seq);
|
||||
ts->tv_sec = gtod->wall_time_coarse.tv_sec;
|
||||
ts->tv_nsec = gtod->wall_time_coarse.tv_nsec;
|
||||
} while (unlikely(read_seqcount_retry(>od->seq, seq)));
|
||||
@ -225,7 +225,7 @@ notrace static int do_monotonic_coarse(struct timespec *ts)
|
||||
{
|
||||
unsigned long seq;
|
||||
do {
|
||||
seq = read_seqcount_begin(>od->seq);
|
||||
seq = read_seqcount_begin_no_lockdep(>od->seq);
|
||||
ts->tv_sec = gtod->monotonic_time_coarse.tv_sec;
|
||||
ts->tv_nsec = gtod->monotonic_time_coarse.tv_nsec;
|
||||
} while (unlikely(read_seqcount_retry(>od->seq, seq)));
|
||||
|
||||
@ -402,6 +402,11 @@ struct request_list *__blk_queue_next_rl(struct request_list *rl,
|
||||
#define blk_queue_for_each_rl(rl, q) \
|
||||
for ((rl) = &(q)->root_rl; (rl); (rl) = __blk_queue_next_rl((rl), (q)))
|
||||
|
||||
static inline void blkg_stat_init(struct blkg_stat *stat)
|
||||
{
|
||||
u64_stats_init(&stat->syncp);
|
||||
}
|
||||
|
||||
/**
|
||||
* blkg_stat_add - add a value to a blkg_stat
|
||||
* @stat: target blkg_stat
|
||||
@ -458,6 +463,11 @@ static inline void blkg_stat_merge(struct blkg_stat *to, struct blkg_stat *from)
|
||||
blkg_stat_add(to, blkg_stat_read(from));
|
||||
}
|
||||
|
||||
static inline void blkg_rwstat_init(struct blkg_rwstat *rwstat)
|
||||
{
|
||||
u64_stats_init(&rwstat->syncp);
|
||||
}
|
||||
|
||||
/**
|
||||
* blkg_rwstat_add - add a value to a blkg_rwstat
|
||||
* @rwstat: target blkg_rwstat
|
||||
|
||||
@ -256,6 +256,12 @@ static struct throtl_data *sq_to_td(struct throtl_service_queue *sq)
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
static void tg_stats_init(struct tg_stats_cpu *tg_stats)
|
||||
{
|
||||
blkg_rwstat_init(&tg_stats->service_bytes);
|
||||
blkg_rwstat_init(&tg_stats->serviced);
|
||||
}
|
||||
|
||||
/*
|
||||
* Worker for allocating per cpu stat for tgs. This is scheduled on the
|
||||
* system_wq once there are some groups on the alloc_list waiting for
|
||||
@ -269,12 +275,16 @@ static void tg_stats_alloc_fn(struct work_struct *work)
|
||||
|
||||
alloc_stats:
|
||||
if (!stats_cpu) {
|
||||
int cpu;
|
||||
|
||||
stats_cpu = alloc_percpu(struct tg_stats_cpu);
|
||||
if (!stats_cpu) {
|
||||
/* allocation failed, try again after some time */
|
||||
schedule_delayed_work(dwork, msecs_to_jiffies(10));
|
||||
return;
|
||||
}
|
||||
for_each_possible_cpu(cpu)
|
||||
tg_stats_init(per_cpu_ptr(stats_cpu, cpu));
|
||||
}
|
||||
|
||||
spin_lock_irq(&tg_stats_alloc_lock);
|
||||
|
||||
@ -1508,6 +1508,29 @@ static void cfq_init_cfqg_base(struct cfq_group *cfqg)
|
||||
}
|
||||
|
||||
#ifdef CONFIG_CFQ_GROUP_IOSCHED
|
||||
static void cfqg_stats_init(struct cfqg_stats *stats)
|
||||
{
|
||||
blkg_rwstat_init(&stats->service_bytes);
|
||||
blkg_rwstat_init(&stats->serviced);
|
||||
blkg_rwstat_init(&stats->merged);
|
||||
blkg_rwstat_init(&stats->service_time);
|
||||
blkg_rwstat_init(&stats->wait_time);
|
||||
blkg_rwstat_init(&stats->queued);
|
||||
|
||||
blkg_stat_init(&stats->sectors);
|
||||
blkg_stat_init(&stats->time);
|
||||
|
||||
#ifdef CONFIG_DEBUG_BLK_CGROUP
|
||||
blkg_stat_init(&stats->unaccounted_time);
|
||||
blkg_stat_init(&stats->avg_queue_size_sum);
|
||||
blkg_stat_init(&stats->avg_queue_size_samples);
|
||||
blkg_stat_init(&stats->dequeue);
|
||||
blkg_stat_init(&stats->group_wait_time);
|
||||
blkg_stat_init(&stats->idle_time);
|
||||
blkg_stat_init(&stats->empty_time);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void cfq_pd_init(struct blkcg_gq *blkg)
|
||||
{
|
||||
struct cfq_group *cfqg = blkg_to_cfqg(blkg);
|
||||
@ -1515,6 +1538,8 @@ static void cfq_pd_init(struct blkcg_gq *blkg)
|
||||
cfq_init_cfqg_base(cfqg);
|
||||
cfqg->weight = blkg->blkcg->cfq_weight;
|
||||
cfqg->leaf_weight = blkg->blkcg->cfq_leaf_weight;
|
||||
cfqg_stats_init(&cfqg->stats);
|
||||
cfqg_stats_init(&cfqg->dead_stats);
|
||||
}
|
||||
|
||||
static void cfq_pd_offline(struct blkcg_gq *blkg)
|
||||
|
||||
@ -88,10 +88,16 @@ static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
|
||||
static int dummy_dev_init(struct net_device *dev)
|
||||
{
|
||||
int i;
|
||||
dev->dstats = alloc_percpu(struct pcpu_dstats);
|
||||
if (!dev->dstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_dstats *dstats;
|
||||
dstats = per_cpu_ptr(dev->dstats, i);
|
||||
u64_stats_init(&dstats->syncp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -2148,6 +2148,9 @@ static int be_tx_qs_create(struct be_adapter *adapter)
|
||||
if (status)
|
||||
return status;
|
||||
|
||||
u64_stats_init(&txo->stats.sync);
|
||||
u64_stats_init(&txo->stats.sync_compl);
|
||||
|
||||
/* If num_evt_qs is less than num_tx_qs, then more than
|
||||
* one txq share an eq
|
||||
*/
|
||||
@ -2209,6 +2212,7 @@ static int be_rx_cqs_create(struct be_adapter *adapter)
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
u64_stats_init(&rxo->stats.sync);
|
||||
eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
|
||||
rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
|
||||
if (rc)
|
||||
|
||||
@ -1224,6 +1224,9 @@ static int igb_alloc_q_vector(struct igb_adapter *adapter,
|
||||
ring->count = adapter->tx_ring_count;
|
||||
ring->queue_index = txr_idx;
|
||||
|
||||
u64_stats_init(&ring->tx_syncp);
|
||||
u64_stats_init(&ring->tx_syncp2);
|
||||
|
||||
/* assign ring to adapter */
|
||||
adapter->tx_ring[txr_idx] = ring;
|
||||
|
||||
@ -1257,6 +1260,8 @@ static int igb_alloc_q_vector(struct igb_adapter *adapter,
|
||||
ring->count = adapter->rx_ring_count;
|
||||
ring->queue_index = rxr_idx;
|
||||
|
||||
u64_stats_init(&ring->rx_syncp);
|
||||
|
||||
/* assign ring to adapter */
|
||||
adapter->rx_ring[rxr_idx] = ring;
|
||||
}
|
||||
|
||||
@ -5085,6 +5085,8 @@ int ixgbe_setup_tx_resources(struct ixgbe_ring *tx_ring)
|
||||
if (!tx_ring->tx_buffer_info)
|
||||
goto err;
|
||||
|
||||
u64_stats_init(&tx_ring->syncp);
|
||||
|
||||
/* round up to nearest 4K */
|
||||
tx_ring->size = tx_ring->count * sizeof(union ixgbe_adv_tx_desc);
|
||||
tx_ring->size = ALIGN(tx_ring->size, 4096);
|
||||
@ -5167,6 +5169,8 @@ int ixgbe_setup_rx_resources(struct ixgbe_ring *rx_ring)
|
||||
if (!rx_ring->rx_buffer_info)
|
||||
goto err;
|
||||
|
||||
u64_stats_init(&rx_ring->syncp);
|
||||
|
||||
/* Round up to nearest 4K */
|
||||
rx_ring->size = rx_ring->count * sizeof(union ixgbe_adv_rx_desc);
|
||||
rx_ring->size = ALIGN(rx_ring->size, 4096);
|
||||
|
||||
@ -2792,6 +2792,9 @@ static int mvneta_probe(struct platform_device *pdev)
|
||||
|
||||
pp = netdev_priv(dev);
|
||||
|
||||
u64_stats_init(&pp->tx_stats.syncp);
|
||||
u64_stats_init(&pp->rx_stats.syncp);
|
||||
|
||||
pp->weight = MVNETA_RX_POLL_WEIGHT;
|
||||
pp->phy_node = phy_node;
|
||||
pp->phy_interface = phy_mode;
|
||||
|
||||
@ -4763,6 +4763,9 @@ static struct net_device *sky2_init_netdev(struct sky2_hw *hw, unsigned port,
|
||||
sky2->hw = hw;
|
||||
sky2->msg_enable = netif_msg_init(debug, default_msg);
|
||||
|
||||
u64_stats_init(&sky2->tx_stats.syncp);
|
||||
u64_stats_init(&sky2->rx_stats.syncp);
|
||||
|
||||
/* Auto speed and flow control */
|
||||
sky2->flags = SKY2_FLAG_AUTO_SPEED | SKY2_FLAG_AUTO_PAUSE;
|
||||
if (hw->chip_id != CHIP_ID_YUKON_XL)
|
||||
|
||||
@ -2072,6 +2072,10 @@ static int vxge_open_vpaths(struct vxgedev *vdev)
|
||||
vdev->config.tx_steering_type;
|
||||
vpath->fifo.ndev = vdev->ndev;
|
||||
vpath->fifo.pdev = vdev->pdev;
|
||||
|
||||
u64_stats_init(&vpath->fifo.stats.syncp);
|
||||
u64_stats_init(&vpath->ring.stats.syncp);
|
||||
|
||||
if (vdev->config.tx_steering_type)
|
||||
vpath->fifo.txq =
|
||||
netdev_get_tx_queue(vdev->ndev, i);
|
||||
|
||||
@ -5619,6 +5619,8 @@ static int nv_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
|
||||
spin_lock_init(&np->lock);
|
||||
spin_lock_init(&np->hwstats_lock);
|
||||
SET_NETDEV_DEV(dev, &pci_dev->dev);
|
||||
u64_stats_init(&np->swstats_rx_syncp);
|
||||
u64_stats_init(&np->swstats_tx_syncp);
|
||||
|
||||
init_timer(&np->oom_kick);
|
||||
np->oom_kick.data = (unsigned long) dev;
|
||||
|
||||
@ -790,6 +790,9 @@ static struct net_device *rtl8139_init_board(struct pci_dev *pdev)
|
||||
|
||||
pci_set_master (pdev);
|
||||
|
||||
u64_stats_init(&tp->rx_stats.syncp);
|
||||
u64_stats_init(&tp->tx_stats.syncp);
|
||||
|
||||
retry:
|
||||
/* PIO bar register comes first. */
|
||||
bar = !use_io;
|
||||
|
||||
@ -1008,6 +1008,8 @@ static void tile_net_register(void *dev_ptr)
|
||||
info->egress_timer.data = (long)info;
|
||||
info->egress_timer.function = tile_net_handle_egress_timer;
|
||||
|
||||
u64_stats_init(&info->stats.syncp);
|
||||
|
||||
priv->cpu[my_cpu] = info;
|
||||
|
||||
/*
|
||||
|
||||
@ -987,6 +987,9 @@ static int rhine_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
||||
|
||||
rp->base = ioaddr;
|
||||
|
||||
u64_stats_init(&rp->tx_stats.syncp);
|
||||
u64_stats_init(&rp->rx_stats.syncp);
|
||||
|
||||
/* Get chip registers into a sane state */
|
||||
rhine_power_init(dev);
|
||||
rhine_hw_init(dev, pioaddr);
|
||||
|
||||
@ -265,6 +265,7 @@ MODULE_PARM_DESC(numifbs, "Number of ifb devices");
|
||||
static int __init ifb_init_one(int index)
|
||||
{
|
||||
struct net_device *dev_ifb;
|
||||
struct ifb_private *dp;
|
||||
int err;
|
||||
|
||||
dev_ifb = alloc_netdev(sizeof(struct ifb_private),
|
||||
@ -273,6 +274,10 @@ static int __init ifb_init_one(int index)
|
||||
if (!dev_ifb)
|
||||
return -ENOMEM;
|
||||
|
||||
dp = netdev_priv(dev_ifb);
|
||||
u64_stats_init(&dp->rsync);
|
||||
u64_stats_init(&dp->tsync);
|
||||
|
||||
dev_ifb->rtnl_link_ops = &ifb_link_ops;
|
||||
err = register_netdevice(dev_ifb);
|
||||
if (err < 0)
|
||||
|
||||
@ -137,10 +137,16 @@ static const struct ethtool_ops loopback_ethtool_ops = {
|
||||
|
||||
static int loopback_dev_init(struct net_device *dev)
|
||||
{
|
||||
int i;
|
||||
dev->lstats = alloc_percpu(struct pcpu_lstats);
|
||||
if (!dev->lstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_lstats *lb_stats;
|
||||
lb_stats = per_cpu_ptr(dev->lstats, i);
|
||||
u64_stats_init(&lb_stats->syncp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -534,6 +534,7 @@ static int macvlan_init(struct net_device *dev)
|
||||
{
|
||||
struct macvlan_dev *vlan = netdev_priv(dev);
|
||||
const struct net_device *lowerdev = vlan->lowerdev;
|
||||
int i;
|
||||
|
||||
dev->state = (dev->state & ~MACVLAN_STATE_MASK) |
|
||||
(lowerdev->state & MACVLAN_STATE_MASK);
|
||||
@ -549,6 +550,12 @@ static int macvlan_init(struct net_device *dev)
|
||||
if (!vlan->pcpu_stats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct macvlan_pcpu_stats *mvlstats;
|
||||
mvlstats = per_cpu_ptr(vlan->pcpu_stats, i);
|
||||
u64_stats_init(&mvlstats->syncp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -47,8 +47,16 @@ static int nlmon_change_mtu(struct net_device *dev, int new_mtu)
|
||||
|
||||
static int nlmon_dev_init(struct net_device *dev)
|
||||
{
|
||||
int i;
|
||||
|
||||
dev->lstats = alloc_percpu(struct pcpu_lstats);
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_lstats *nlmstats;
|
||||
nlmstats = per_cpu_ptr(dev->lstats, i);
|
||||
u64_stats_init(&nlmstats->syncp);
|
||||
}
|
||||
|
||||
return dev->lstats == NULL ? -ENOMEM : 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1540,6 +1540,12 @@ static int team_init(struct net_device *dev)
|
||||
if (!team->pcpu_stats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct team_pcpu_stats *team_stats;
|
||||
team_stats = per_cpu_ptr(team->pcpu_stats, i);
|
||||
u64_stats_init(&team_stats->syncp);
|
||||
}
|
||||
|
||||
for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
|
||||
INIT_HLIST_HEAD(&team->en_port_hlist[i]);
|
||||
INIT_LIST_HEAD(&team->port_list);
|
||||
|
||||
@ -570,7 +570,7 @@ static int lb_init(struct team *team)
|
||||
{
|
||||
struct lb_priv *lb_priv = get_lb_priv(team);
|
||||
lb_select_tx_port_func_t *func;
|
||||
int err;
|
||||
int i, err;
|
||||
|
||||
/* set default tx port selector */
|
||||
func = lb_select_tx_port_get_func("hash");
|
||||
@ -588,6 +588,13 @@ static int lb_init(struct team *team)
|
||||
goto err_alloc_pcpu_stats;
|
||||
}
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct lb_pcpu_stats *team_lb_stats;
|
||||
team_lb_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
|
||||
u64_stats_init(&team_lb_stats->syncp);
|
||||
}
|
||||
|
||||
|
||||
INIT_DELAYED_WORK(&lb_priv->ex->stats.refresh_dw, lb_stats_refresh);
|
||||
|
||||
err = team_options_register(team, lb_options, ARRAY_SIZE(lb_options));
|
||||
|
||||
@ -235,10 +235,18 @@ static int veth_change_mtu(struct net_device *dev, int new_mtu)
|
||||
|
||||
static int veth_dev_init(struct net_device *dev)
|
||||
{
|
||||
int i;
|
||||
|
||||
dev->vstats = alloc_percpu(struct pcpu_vstats);
|
||||
if (!dev->vstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_vstats *veth_stats;
|
||||
veth_stats = per_cpu_ptr(dev->vstats, i);
|
||||
u64_stats_init(&veth_stats->syncp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1576,6 +1576,13 @@ static int virtnet_probe(struct virtio_device *vdev)
|
||||
if (vi->stats == NULL)
|
||||
goto free;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct virtnet_stats *virtnet_stats;
|
||||
virtnet_stats = per_cpu_ptr(vi->stats, i);
|
||||
u64_stats_init(&virtnet_stats->tx_syncp);
|
||||
u64_stats_init(&virtnet_stats->rx_syncp);
|
||||
}
|
||||
|
||||
mutex_init(&vi->config_lock);
|
||||
vi->config_enable = true;
|
||||
INIT_WORK(&vi->config_work, virtnet_config_changed_work);
|
||||
|
||||
@ -1880,11 +1880,19 @@ static int vxlan_init(struct net_device *dev)
|
||||
struct vxlan_dev *vxlan = netdev_priv(dev);
|
||||
struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
|
||||
struct vxlan_sock *vs;
|
||||
int i;
|
||||
|
||||
dev->tstats = alloc_percpu(struct pcpu_tstats);
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *vxlan_stats;
|
||||
vxlan_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&vxlan_stats->syncp);
|
||||
}
|
||||
|
||||
|
||||
spin_lock(&vn->sock_lock);
|
||||
vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);
|
||||
if (vs) {
|
||||
|
||||
@ -1340,6 +1340,12 @@ static struct net_device *xennet_create_dev(struct xenbus_device *dev)
|
||||
if (np->stats == NULL)
|
||||
goto exit;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct netfront_stats *xen_nf_stats;
|
||||
xen_nf_stats = per_cpu_ptr(np->stats, i);
|
||||
u64_stats_init(&xen_nf_stats->syncp);
|
||||
}
|
||||
|
||||
/* Initialise tx_skbs as a free chain containing every entry. */
|
||||
np->tx_skb_freelist = 0;
|
||||
for (i = 0; i < NET_TX_RING_SIZE; i++) {
|
||||
|
||||
@ -2606,7 +2606,7 @@ static void __d_move(struct dentry * dentry, struct dentry * target)
|
||||
dentry_lock_for_move(dentry, target);
|
||||
|
||||
write_seqcount_begin(&dentry->d_seq);
|
||||
write_seqcount_begin(&target->d_seq);
|
||||
write_seqcount_begin_nested(&target->d_seq, DENTRY_D_LOCK_NESTED);
|
||||
|
||||
/* __d_drop does write_seqcount_barrier, but they're OK to nest. */
|
||||
|
||||
@ -2738,7 +2738,7 @@ static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
|
||||
dentry_lock_for_move(anon, dentry);
|
||||
|
||||
write_seqcount_begin(&dentry->d_seq);
|
||||
write_seqcount_begin(&anon->d_seq);
|
||||
write_seqcount_begin_nested(&anon->d_seq, DENTRY_D_LOCK_NESTED);
|
||||
|
||||
dparent = dentry->d_parent;
|
||||
|
||||
|
||||
@ -161,6 +161,6 @@ EXPORT_SYMBOL(current_umask);
|
||||
struct fs_struct init_fs = {
|
||||
.users = 1,
|
||||
.lock = __SPIN_LOCK_UNLOCKED(init_fs.lock),
|
||||
.seq = SEQCNT_ZERO,
|
||||
.seq = SEQCNT_ZERO(init_fs.seq),
|
||||
.umask = 0022,
|
||||
};
|
||||
|
||||
@ -110,10 +110,14 @@ static inline bool put_mems_allowed(unsigned int seq)
|
||||
|
||||
static inline void set_mems_allowed(nodemask_t nodemask)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
task_lock(current);
|
||||
local_irq_save(flags);
|
||||
write_seqcount_begin(¤t->mems_allowed_seq);
|
||||
current->mems_allowed = nodemask;
|
||||
write_seqcount_end(¤t->mems_allowed_seq);
|
||||
local_irq_restore(flags);
|
||||
task_unlock(current);
|
||||
}
|
||||
|
||||
|
||||
@ -32,10 +32,10 @@ extern struct fs_struct init_fs;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_CPUSETS
|
||||
#define INIT_CPUSET_SEQ \
|
||||
.mems_allowed_seq = SEQCNT_ZERO,
|
||||
#define INIT_CPUSET_SEQ(tsk) \
|
||||
.mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
|
||||
#else
|
||||
#define INIT_CPUSET_SEQ
|
||||
#define INIT_CPUSET_SEQ(tsk)
|
||||
#endif
|
||||
|
||||
#define INIT_SIGNALS(sig) { \
|
||||
@ -220,7 +220,7 @@ extern struct task_group root_task_group;
|
||||
INIT_FTRACE_GRAPH \
|
||||
INIT_TRACE_RECURSION \
|
||||
INIT_TASK_RCU_PREEMPT(tsk) \
|
||||
INIT_CPUSET_SEQ \
|
||||
INIT_CPUSET_SEQ(tsk) \
|
||||
INIT_VTIME(tsk) \
|
||||
}
|
||||
|
||||
|
||||
@ -497,6 +497,10 @@ static inline void print_irqtrace_events(struct task_struct *curr)
|
||||
#define rwlock_acquire_read(l, s, t, i) lock_acquire_shared_recursive(l, s, t, NULL, i)
|
||||
#define rwlock_release(l, n, i) lock_release(l, n, i)
|
||||
|
||||
#define seqcount_acquire(l, s, t, i) lock_acquire_exclusive(l, s, t, NULL, i)
|
||||
#define seqcount_acquire_read(l, s, t, i) lock_acquire_shared_recursive(l, s, t, NULL, i)
|
||||
#define seqcount_release(l, n, i) lock_release(l, n, i)
|
||||
|
||||
#define mutex_acquire(l, s, t, i) lock_acquire_exclusive(l, s, t, NULL, i)
|
||||
#define mutex_acquire_nest(l, s, t, n, i) lock_acquire_exclusive(l, s, t, n, i)
|
||||
#define mutex_release(l, n, i) lock_release(l, n, i)
|
||||
|
||||
@ -131,7 +131,7 @@ static inline int mutex_is_locked(struct mutex *lock)
|
||||
}
|
||||
|
||||
/*
|
||||
* See kernel/mutex.c for detailed documentation of these APIs.
|
||||
* See kernel/locking/mutex.c for detailed documentation of these APIs.
|
||||
* Also see Documentation/mutex-design.txt.
|
||||
*/
|
||||
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
||||
|
||||
@ -2,8 +2,8 @@
|
||||
#define _SCHED_SYSCTL_H
|
||||
|
||||
#ifdef CONFIG_DETECT_HUNG_TASK
|
||||
extern int sysctl_hung_task_check_count;
|
||||
extern unsigned int sysctl_hung_task_panic;
|
||||
extern unsigned long sysctl_hung_task_check_count;
|
||||
extern unsigned long sysctl_hung_task_timeout_secs;
|
||||
extern unsigned long sysctl_hung_task_warnings;
|
||||
extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
|
||||
|
||||
@ -34,6 +34,7 @@
|
||||
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/preempt.h>
|
||||
#include <linux/lockdep.h>
|
||||
#include <asm/processor.h>
|
||||
|
||||
/*
|
||||
@ -44,10 +45,50 @@
|
||||
*/
|
||||
typedef struct seqcount {
|
||||
unsigned sequence;
|
||||
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
||||
struct lockdep_map dep_map;
|
||||
#endif
|
||||
} seqcount_t;
|
||||
|
||||
#define SEQCNT_ZERO { 0 }
|
||||
#define seqcount_init(x) do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)
|
||||
static inline void __seqcount_init(seqcount_t *s, const char *name,
|
||||
struct lock_class_key *key)
|
||||
{
|
||||
/*
|
||||
* Make sure we are not reinitializing a held lock:
|
||||
*/
|
||||
lockdep_init_map(&s->dep_map, name, key, 0);
|
||||
s->sequence = 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
||||
# define SEQCOUNT_DEP_MAP_INIT(lockname) \
|
||||
.dep_map = { .name = #lockname } \
|
||||
|
||||
# define seqcount_init(s) \
|
||||
do { \
|
||||
static struct lock_class_key __key; \
|
||||
__seqcount_init((s), #s, &__key); \
|
||||
} while (0)
|
||||
|
||||
static inline void seqcount_lockdep_reader_access(const seqcount_t *s)
|
||||
{
|
||||
seqcount_t *l = (seqcount_t *)s;
|
||||
unsigned long flags;
|
||||
|
||||
local_irq_save(flags);
|
||||
seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);
|
||||
seqcount_release(&l->dep_map, 1, _RET_IP_);
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
#else
|
||||
# define SEQCOUNT_DEP_MAP_INIT(lockname)
|
||||
# define seqcount_init(s) __seqcount_init(s, NULL, NULL)
|
||||
# define seqcount_lockdep_reader_access(x)
|
||||
#endif
|
||||
|
||||
#define SEQCNT_ZERO(lockname) { .sequence = 0, SEQCOUNT_DEP_MAP_INIT(lockname)}
|
||||
|
||||
|
||||
/**
|
||||
* __read_seqcount_begin - begin a seq-read critical section (without barrier)
|
||||
@ -75,6 +116,22 @@ repeat:
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* read_seqcount_begin_no_lockdep - start seq-read critical section w/o lockdep
|
||||
* @s: pointer to seqcount_t
|
||||
* Returns: count to be passed to read_seqcount_retry
|
||||
*
|
||||
* read_seqcount_begin_no_lockdep opens a read critical section of the given
|
||||
* seqcount, but without any lockdep checking. Validity of the critical
|
||||
* section is tested by checking read_seqcount_retry function.
|
||||
*/
|
||||
static inline unsigned read_seqcount_begin_no_lockdep(const seqcount_t *s)
|
||||
{
|
||||
unsigned ret = __read_seqcount_begin(s);
|
||||
smp_rmb();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* read_seqcount_begin - begin a seq-read critical section
|
||||
* @s: pointer to seqcount_t
|
||||
@ -86,9 +143,8 @@ repeat:
|
||||
*/
|
||||
static inline unsigned read_seqcount_begin(const seqcount_t *s)
|
||||
{
|
||||
unsigned ret = __read_seqcount_begin(s);
|
||||
smp_rmb();
|
||||
return ret;
|
||||
seqcount_lockdep_reader_access(s);
|
||||
return read_seqcount_begin_no_lockdep(s);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -108,6 +164,8 @@ static inline unsigned read_seqcount_begin(const seqcount_t *s)
|
||||
static inline unsigned raw_seqcount_begin(const seqcount_t *s)
|
||||
{
|
||||
unsigned ret = ACCESS_ONCE(s->sequence);
|
||||
|
||||
seqcount_lockdep_reader_access(s);
|
||||
smp_rmb();
|
||||
return ret & ~1;
|
||||
}
|
||||
@ -152,14 +210,21 @@ static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
|
||||
* Sequence counter only version assumes that callers are using their
|
||||
* own mutexing.
|
||||
*/
|
||||
static inline void write_seqcount_begin(seqcount_t *s)
|
||||
static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)
|
||||
{
|
||||
s->sequence++;
|
||||
smp_wmb();
|
||||
seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
|
||||
}
|
||||
|
||||
static inline void write_seqcount_begin(seqcount_t *s)
|
||||
{
|
||||
write_seqcount_begin_nested(s, 0);
|
||||
}
|
||||
|
||||
static inline void write_seqcount_end(seqcount_t *s)
|
||||
{
|
||||
seqcount_release(&s->dep_map, 1, _RET_IP_);
|
||||
smp_wmb();
|
||||
s->sequence++;
|
||||
}
|
||||
@ -188,7 +253,7 @@ typedef struct {
|
||||
*/
|
||||
#define __SEQLOCK_UNLOCKED(lockname) \
|
||||
{ \
|
||||
.seqcount = SEQCNT_ZERO, \
|
||||
.seqcount = SEQCNT_ZERO(lockname), \
|
||||
.lock = __SPIN_LOCK_UNLOCKED(lockname) \
|
||||
}
|
||||
|
||||
|
||||
@ -67,6 +67,13 @@ struct u64_stats_sync {
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
#if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
|
||||
# define u64_stats_init(syncp) seqcount_init(syncp.seq)
|
||||
#else
|
||||
# define u64_stats_init(syncp) do { } while (0)
|
||||
#endif
|
||||
|
||||
static inline void u64_stats_update_begin(struct u64_stats_sync *syncp)
|
||||
{
|
||||
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
|
||||
|
||||
@ -424,6 +424,25 @@ TRACE_EVENT(sched_pi_setprio,
|
||||
__entry->oldprio, __entry->newprio)
|
||||
);
|
||||
|
||||
#ifdef CONFIG_DETECT_HUNG_TASK
|
||||
TRACE_EVENT(sched_process_hang,
|
||||
TP_PROTO(struct task_struct *tsk),
|
||||
TP_ARGS(tsk),
|
||||
|
||||
TP_STRUCT__entry(
|
||||
__array( char, comm, TASK_COMM_LEN )
|
||||
__field( pid_t, pid )
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
|
||||
__entry->pid = tsk->pid;
|
||||
),
|
||||
|
||||
TP_printk("comm=%s pid=%d", __entry->comm, __entry->pid)
|
||||
);
|
||||
#endif /* CONFIG_DETECT_HUNG_TASK */
|
||||
|
||||
#endif /* _TRACE_SCHED_H */
|
||||
|
||||
/* This part must be outside protection */
|
||||
|
||||
@ -7,22 +7,19 @@ obj-y = fork.o exec_domain.o panic.o \
|
||||
sysctl.o sysctl_binary.o capability.o ptrace.o timer.o user.o \
|
||||
signal.o sys.o kmod.o workqueue.o pid.o task_work.o \
|
||||
extable.o params.o posix-timers.o \
|
||||
kthread.o sys_ni.o posix-cpu-timers.o mutex.o \
|
||||
hrtimer.o rwsem.o nsproxy.o semaphore.o \
|
||||
kthread.o sys_ni.o posix-cpu-timers.o \
|
||||
hrtimer.o nsproxy.o \
|
||||
notifier.o ksysfs.o cred.o reboot.o \
|
||||
async.o range.o groups.o lglock.o smpboot.o
|
||||
async.o range.o groups.o smpboot.o
|
||||
|
||||
ifdef CONFIG_FUNCTION_TRACER
|
||||
# Do not trace debug files and internal ftrace files
|
||||
CFLAGS_REMOVE_lockdep.o = -pg
|
||||
CFLAGS_REMOVE_lockdep_proc.o = -pg
|
||||
CFLAGS_REMOVE_mutex-debug.o = -pg
|
||||
CFLAGS_REMOVE_rtmutex-debug.o = -pg
|
||||
CFLAGS_REMOVE_cgroup-debug.o = -pg
|
||||
CFLAGS_REMOVE_irq_work.o = -pg
|
||||
endif
|
||||
|
||||
obj-y += sched/
|
||||
obj-y += locking/
|
||||
obj-y += power/
|
||||
obj-y += printk/
|
||||
obj-y += cpu/
|
||||
@ -34,26 +31,15 @@ obj-$(CONFIG_FREEZER) += freezer.o
|
||||
obj-$(CONFIG_PROFILING) += profile.o
|
||||
obj-$(CONFIG_STACKTRACE) += stacktrace.o
|
||||
obj-y += time/
|
||||
obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
|
||||
obj-$(CONFIG_LOCKDEP) += lockdep.o
|
||||
ifeq ($(CONFIG_PROC_FS),y)
|
||||
obj-$(CONFIG_LOCKDEP) += lockdep_proc.o
|
||||
endif
|
||||
obj-$(CONFIG_FUTEX) += futex.o
|
||||
ifeq ($(CONFIG_COMPAT),y)
|
||||
obj-$(CONFIG_FUTEX) += futex_compat.o
|
||||
endif
|
||||
obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
|
||||
obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
|
||||
obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
|
||||
obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
|
||||
obj-$(CONFIG_SMP) += smp.o
|
||||
ifneq ($(CONFIG_SMP),y)
|
||||
obj-y += up.o
|
||||
endif
|
||||
obj-$(CONFIG_SMP) += spinlock.o
|
||||
obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
|
||||
obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
|
||||
obj-$(CONFIG_UID16) += uid16.o
|
||||
obj-$(CONFIG_MODULES) += module.o
|
||||
obj-$(CONFIG_MODULE_SIG) += module_signing.o modsign_pubkey.o modsign_certificate.o
|
||||
|
||||
@ -66,7 +66,7 @@
|
||||
|
||||
#include <asm/futex.h>
|
||||
|
||||
#include "rtmutex_common.h"
|
||||
#include "locking/rtmutex_common.h"
|
||||
|
||||
int __read_mostly futex_cmpxchg_enabled;
|
||||
|
||||
|
||||
@ -16,11 +16,12 @@
|
||||
#include <linux/export.h>
|
||||
#include <linux/sysctl.h>
|
||||
#include <linux/utsname.h>
|
||||
#include <trace/events/sched.h>
|
||||
|
||||
/*
|
||||
* The number of tasks checked:
|
||||
*/
|
||||
unsigned long __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT;
|
||||
int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT;
|
||||
|
||||
/*
|
||||
* Limit number of tasks checked in a batch.
|
||||
@ -92,6 +93,9 @@ static void check_hung_task(struct task_struct *t, unsigned long timeout)
|
||||
t->last_switch_count = switch_count;
|
||||
return;
|
||||
}
|
||||
|
||||
trace_sched_process_hang(t);
|
||||
|
||||
if (!sysctl_hung_task_warnings)
|
||||
return;
|
||||
sysctl_hung_task_warnings--;
|
||||
|
||||
25
kernel/locking/Makefile
Normal file
25
kernel/locking/Makefile
Normal file
@ -0,0 +1,25 @@
|
||||
|
||||
obj-y += mutex.o semaphore.o rwsem.o lglock.o
|
||||
|
||||
ifdef CONFIG_FUNCTION_TRACER
|
||||
CFLAGS_REMOVE_lockdep.o = -pg
|
||||
CFLAGS_REMOVE_lockdep_proc.o = -pg
|
||||
CFLAGS_REMOVE_mutex-debug.o = -pg
|
||||
CFLAGS_REMOVE_rtmutex-debug.o = -pg
|
||||
endif
|
||||
|
||||
obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
|
||||
obj-$(CONFIG_LOCKDEP) += lockdep.o
|
||||
ifeq ($(CONFIG_PROC_FS),y)
|
||||
obj-$(CONFIG_LOCKDEP) += lockdep_proc.o
|
||||
endif
|
||||
obj-$(CONFIG_SMP) += spinlock.o
|
||||
obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
|
||||
obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
|
||||
obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
|
||||
obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
|
||||
obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
|
||||
obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock_debug.o
|
||||
obj-$(CONFIG_RWSEM_GENERIC_SPINLOCK) += rwsem-spinlock.o
|
||||
obj-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem-xadd.o
|
||||
obj-$(CONFIG_PERCPU_RWSEM) += percpu-rwsem.o
|
||||
@ -1232,7 +1232,7 @@ static int noop_count(struct lock_list *entry, void *data)
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned long __lockdep_count_forward_deps(struct lock_list *this)
|
||||
static unsigned long __lockdep_count_forward_deps(struct lock_list *this)
|
||||
{
|
||||
unsigned long count = 0;
|
||||
struct lock_list *uninitialized_var(target_entry);
|
||||
@ -1258,7 +1258,7 @@ unsigned long lockdep_count_forward_deps(struct lock_class *class)
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned long __lockdep_count_backward_deps(struct lock_list *this)
|
||||
static unsigned long __lockdep_count_backward_deps(struct lock_list *this)
|
||||
{
|
||||
unsigned long count = 0;
|
||||
struct lock_list *uninitialized_var(target_entry);
|
||||
@ -421,6 +421,7 @@ static void seq_lock_time(struct seq_file *m, struct lock_time *lt)
|
||||
seq_time(m, lt->min);
|
||||
seq_time(m, lt->max);
|
||||
seq_time(m, lt->total);
|
||||
seq_time(m, lt->nr ? div_s64(lt->total, lt->nr) : 0);
|
||||
}
|
||||
|
||||
static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
|
||||
@ -518,20 +519,20 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
|
||||
}
|
||||
if (i) {
|
||||
seq_puts(m, "\n");
|
||||
seq_line(m, '.', 0, 40 + 1 + 10 * (14 + 1));
|
||||
seq_line(m, '.', 0, 40 + 1 + 12 * (14 + 1));
|
||||
seq_puts(m, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void seq_header(struct seq_file *m)
|
||||
{
|
||||
seq_printf(m, "lock_stat version 0.3\n");
|
||||
seq_puts(m, "lock_stat version 0.4\n");
|
||||
|
||||
if (unlikely(!debug_locks))
|
||||
seq_printf(m, "*WARNING* lock debugging disabled!! - possibly due to a lockdep warning\n");
|
||||
|
||||
seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
|
||||
seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
|
||||
seq_line(m, '-', 0, 40 + 1 + 12 * (14 + 1));
|
||||
seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s %14s %14s "
|
||||
"%14s %14s\n",
|
||||
"class name",
|
||||
"con-bounces",
|
||||
@ -539,12 +540,14 @@ static void seq_header(struct seq_file *m)
|
||||
"waittime-min",
|
||||
"waittime-max",
|
||||
"waittime-total",
|
||||
"waittime-avg",
|
||||
"acq-bounces",
|
||||
"acquisitions",
|
||||
"holdtime-min",
|
||||
"holdtime-max",
|
||||
"holdtime-total");
|
||||
seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
|
||||
"holdtime-total",
|
||||
"holdtime-avg");
|
||||
seq_line(m, '-', 0, 40 + 1 + 12 * (14 + 1));
|
||||
seq_printf(m, "\n");
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* kernel/mutex.c
|
||||
* kernel/locking/mutex.c
|
||||
*
|
||||
* Mutexes: blocking mutual exclusion locks
|
||||
*
|
||||
@ -1133,7 +1133,7 @@ void exit_rcu(void)
|
||||
|
||||
#ifdef CONFIG_RCU_BOOST
|
||||
|
||||
#include "../rtmutex_common.h"
|
||||
#include "../locking/rtmutex_common.h"
|
||||
|
||||
#ifdef CONFIG_RCU_TRACE
|
||||
|
||||
|
||||
@ -969,9 +969,10 @@ static struct ctl_table kern_table[] = {
|
||||
{
|
||||
.procname = "hung_task_check_count",
|
||||
.data = &sysctl_hung_task_check_count,
|
||||
.maxlen = sizeof(unsigned long),
|
||||
.maxlen = sizeof(int),
|
||||
.mode = 0644,
|
||||
.proc_handler = proc_doulongvec_minmax,
|
||||
.proc_handler = proc_dointvec_minmax,
|
||||
.extra1 = &zero,
|
||||
},
|
||||
{
|
||||
.procname = "hung_task_timeout_secs",
|
||||
|
||||
@ -42,10 +42,6 @@ obj-$(CONFIG_GENERIC_PCI_IOMAP) += pci_iomap.o
|
||||
obj-$(CONFIG_HAS_IOMEM) += iomap_copy.o devres.o
|
||||
obj-$(CONFIG_CHECK_SIGNATURE) += check_signature.o
|
||||
obj-$(CONFIG_DEBUG_LOCKING_API_SELFTESTS) += locking-selftest.o
|
||||
obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock_debug.o
|
||||
lib-$(CONFIG_RWSEM_GENERIC_SPINLOCK) += rwsem-spinlock.o
|
||||
lib-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem.o
|
||||
lib-$(CONFIG_PERCPU_RWSEM) += percpu-rwsem.o
|
||||
|
||||
CFLAGS_hweight.o = $(subst $(quote),,$(CONFIG_ARCH_HWEIGHT_CFLAGS))
|
||||
obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o
|
||||
|
||||
@ -26,7 +26,7 @@
|
||||
* of ZERO_PAGE(), such as /dev/zero
|
||||
*/
|
||||
static DEFINE_MUTEX(xip_sparse_mutex);
|
||||
static seqcount_t xip_sparse_seq = SEQCNT_ZERO;
|
||||
static seqcount_t xip_sparse_seq = SEQCNT_ZERO(xip_sparse_seq);
|
||||
static struct page *__xip_sparse_page;
|
||||
|
||||
/* called under xip_sparse_mutex */
|
||||
|
||||
@ -539,7 +539,7 @@ static const struct net_device_ops vlan_netdev_ops;
|
||||
static int vlan_dev_init(struct net_device *dev)
|
||||
{
|
||||
struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
|
||||
int subclass = 0;
|
||||
int subclass = 0, i;
|
||||
|
||||
netif_carrier_off(dev);
|
||||
|
||||
@ -593,6 +593,13 @@ static int vlan_dev_init(struct net_device *dev)
|
||||
if (!vlan_dev_priv(dev)->vlan_pcpu_stats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct vlan_pcpu_stats *vlan_stat;
|
||||
vlan_stat = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
|
||||
u64_stats_init(&vlan_stat->syncp);
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -88,11 +88,18 @@ out:
|
||||
static int br_dev_init(struct net_device *dev)
|
||||
{
|
||||
struct net_bridge *br = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
br->stats = alloc_percpu(struct br_cpu_netstats);
|
||||
if (!br->stats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct br_cpu_netstats *br_dev_stats;
|
||||
br_dev_stats = per_cpu_ptr(br->stats, i);
|
||||
u64_stats_init(&br_dev_stats->syncp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1503,6 +1503,7 @@ int snmp_mib_init(void __percpu *ptr[2], size_t mibsize, size_t align)
|
||||
ptr[0] = __alloc_percpu(mibsize, align);
|
||||
if (!ptr[0])
|
||||
return -ENOMEM;
|
||||
|
||||
#if SNMP_ARRAY_SZ == 2
|
||||
ptr[1] = __alloc_percpu(mibsize, align);
|
||||
if (!ptr[1]) {
|
||||
@ -1547,6 +1548,8 @@ static const struct net_protocol icmp_protocol = {
|
||||
|
||||
static __net_init int ipv4_mib_init_net(struct net *net)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (snmp_mib_init((void __percpu **)net->mib.tcp_statistics,
|
||||
sizeof(struct tcp_mib),
|
||||
__alignof__(struct tcp_mib)) < 0)
|
||||
@ -1555,6 +1558,17 @@ static __net_init int ipv4_mib_init_net(struct net *net)
|
||||
sizeof(struct ipstats_mib),
|
||||
__alignof__(struct ipstats_mib)) < 0)
|
||||
goto err_ip_mib;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ipstats_mib *af_inet_stats;
|
||||
af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[0], i);
|
||||
u64_stats_init(&af_inet_stats->syncp);
|
||||
#if SNMP_ARRAY_SZ == 2
|
||||
af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[1], i);
|
||||
u64_stats_init(&af_inet_stats->syncp);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (snmp_mib_init((void __percpu **)net->mib.net_statistics,
|
||||
sizeof(struct linux_mib),
|
||||
__alignof__(struct linux_mib)) < 0)
|
||||
|
||||
@ -976,13 +976,19 @@ int ip_tunnel_init(struct net_device *dev)
|
||||
{
|
||||
struct ip_tunnel *tunnel = netdev_priv(dev);
|
||||
struct iphdr *iph = &tunnel->parms.iph;
|
||||
int err;
|
||||
int i, err;
|
||||
|
||||
dev->destructor = ip_tunnel_dev_free;
|
||||
dev->tstats = alloc_percpu(struct pcpu_tstats);
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ipt_stats;
|
||||
ipt_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ipt_stats->syncp);
|
||||
}
|
||||
|
||||
err = gro_cells_init(&tunnel->gro_cells, dev);
|
||||
if (err) {
|
||||
free_percpu(dev->tstats);
|
||||
|
||||
@ -271,10 +271,24 @@ static void addrconf_mod_dad_timer(struct inet6_ifaddr *ifp,
|
||||
|
||||
static int snmp6_alloc_dev(struct inet6_dev *idev)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (snmp_mib_init((void __percpu **)idev->stats.ipv6,
|
||||
sizeof(struct ipstats_mib),
|
||||
__alignof__(struct ipstats_mib)) < 0)
|
||||
goto err_ip;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ipstats_mib *addrconf_stats;
|
||||
addrconf_stats = per_cpu_ptr(idev->stats.ipv6[0], i);
|
||||
u64_stats_init(&addrconf_stats->syncp);
|
||||
#if SNMP_ARRAY_SZ == 2
|
||||
addrconf_stats = per_cpu_ptr(idev->stats.ipv6[1], i);
|
||||
u64_stats_init(&addrconf_stats->syncp);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
|
||||
GFP_KERNEL);
|
||||
if (!idev->stats.icmpv6dev)
|
||||
|
||||
@ -714,6 +714,8 @@ static void ipv6_packet_cleanup(void)
|
||||
|
||||
static int __net_init ipv6_init_mibs(struct net *net)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (snmp_mib_init((void __percpu **)net->mib.udp_stats_in6,
|
||||
sizeof(struct udp_mib),
|
||||
__alignof__(struct udp_mib)) < 0)
|
||||
@ -726,6 +728,18 @@ static int __net_init ipv6_init_mibs(struct net *net)
|
||||
sizeof(struct ipstats_mib),
|
||||
__alignof__(struct ipstats_mib)) < 0)
|
||||
goto err_ip_mib;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ipstats_mib *af_inet6_stats;
|
||||
af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics[0], i);
|
||||
u64_stats_init(&af_inet6_stats->syncp);
|
||||
#if SNMP_ARRAY_SZ == 2
|
||||
af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics[1], i);
|
||||
u64_stats_init(&af_inet6_stats->syncp);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
if (snmp_mib_init((void __percpu **)net->mib.icmpv6_statistics,
|
||||
sizeof(struct icmpv6_mib),
|
||||
__alignof__(struct icmpv6_mib)) < 0)
|
||||
|
||||
@ -1252,6 +1252,7 @@ static void ip6gre_tunnel_setup(struct net_device *dev)
|
||||
static int ip6gre_tunnel_init(struct net_device *dev)
|
||||
{
|
||||
struct ip6_tnl *tunnel;
|
||||
int i;
|
||||
|
||||
tunnel = netdev_priv(dev);
|
||||
|
||||
@ -1269,6 +1270,13 @@ static int ip6gre_tunnel_init(struct net_device *dev)
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ip6gre_tunnel_stats;
|
||||
ip6gre_tunnel_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ip6gre_tunnel_stats->syncp);
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1449,6 +1457,7 @@ static void ip6gre_netlink_parms(struct nlattr *data[],
|
||||
static int ip6gre_tap_init(struct net_device *dev)
|
||||
{
|
||||
struct ip6_tnl *tunnel;
|
||||
int i;
|
||||
|
||||
tunnel = netdev_priv(dev);
|
||||
|
||||
@ -1462,6 +1471,12 @@ static int ip6gre_tap_init(struct net_device *dev)
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ip6gre_tap_stats;
|
||||
ip6gre_tap_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ip6gre_tap_stats->syncp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -910,7 +910,7 @@ static int ip6_dst_lookup_tail(struct sock *sk,
|
||||
|
||||
out_err_release:
|
||||
if (err == -ENETUNREACH)
|
||||
IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES);
|
||||
IP6_INC_STATS(net, NULL, IPSTATS_MIB_OUTNOROUTES);
|
||||
dst_release(*dst);
|
||||
*dst = NULL;
|
||||
return err;
|
||||
|
||||
@ -1494,12 +1494,19 @@ static inline int
|
||||
ip6_tnl_dev_init_gen(struct net_device *dev)
|
||||
{
|
||||
struct ip6_tnl *t = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
t->dev = dev;
|
||||
t->net = dev_net(dev);
|
||||
dev->tstats = alloc_percpu(struct pcpu_tstats);
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ip6_tnl_stats;
|
||||
ip6_tnl_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ip6_tnl_stats->syncp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1320,6 +1320,7 @@ static void ipip6_tunnel_setup(struct net_device *dev)
|
||||
static int ipip6_tunnel_init(struct net_device *dev)
|
||||
{
|
||||
struct ip_tunnel *tunnel = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
tunnel->dev = dev;
|
||||
tunnel->net = dev_net(dev);
|
||||
@ -1332,6 +1333,12 @@ static int ipip6_tunnel_init(struct net_device *dev)
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ipip6_tunnel_stats;
|
||||
ipip6_tunnel_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ipip6_tunnel_stats->syncp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1341,6 +1348,7 @@ static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
|
||||
struct iphdr *iph = &tunnel->parms.iph;
|
||||
struct net *net = dev_net(dev);
|
||||
struct sit_net *sitn = net_generic(net, sit_net_id);
|
||||
int i;
|
||||
|
||||
tunnel->dev = dev;
|
||||
tunnel->net = dev_net(dev);
|
||||
@ -1354,6 +1362,13 @@ static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
|
||||
dev->tstats = alloc_percpu(struct pcpu_tstats);
|
||||
if (!dev->tstats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *ipip6_fb_stats;
|
||||
ipip6_fb_stats = per_cpu_ptr(dev->tstats, i);
|
||||
u64_stats_init(&ipip6_fb_stats->syncp);
|
||||
}
|
||||
|
||||
dev_hold(dev);
|
||||
rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
|
||||
return 0;
|
||||
|
||||
@ -842,7 +842,7 @@ ip_vs_new_dest(struct ip_vs_service *svc, struct ip_vs_dest_user_kern *udest,
|
||||
struct ip_vs_dest **dest_p)
|
||||
{
|
||||
struct ip_vs_dest *dest;
|
||||
unsigned int atype;
|
||||
unsigned int atype, i;
|
||||
|
||||
EnterFunction(2);
|
||||
|
||||
@ -869,6 +869,12 @@ ip_vs_new_dest(struct ip_vs_service *svc, struct ip_vs_dest_user_kern *udest,
|
||||
if (!dest->stats.cpustats)
|
||||
goto err_alloc;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ip_vs_cpu_stats *ip_vs_dest_stats;
|
||||
ip_vs_dest_stats = per_cpu_ptr(dest->stats.cpustats, i);
|
||||
u64_stats_init(&ip_vs_dest_stats->syncp);
|
||||
}
|
||||
|
||||
dest->af = svc->af;
|
||||
dest->protocol = svc->protocol;
|
||||
dest->vaddr = svc->addr;
|
||||
@ -1134,7 +1140,7 @@ static int
|
||||
ip_vs_add_service(struct net *net, struct ip_vs_service_user_kern *u,
|
||||
struct ip_vs_service **svc_p)
|
||||
{
|
||||
int ret = 0;
|
||||
int ret = 0, i;
|
||||
struct ip_vs_scheduler *sched = NULL;
|
||||
struct ip_vs_pe *pe = NULL;
|
||||
struct ip_vs_service *svc = NULL;
|
||||
@ -1184,6 +1190,13 @@ ip_vs_add_service(struct net *net, struct ip_vs_service_user_kern *u,
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ip_vs_cpu_stats *ip_vs_stats;
|
||||
ip_vs_stats = per_cpu_ptr(svc->stats.cpustats, i);
|
||||
u64_stats_init(&ip_vs_stats->syncp);
|
||||
}
|
||||
|
||||
|
||||
/* I'm the first user of the service */
|
||||
atomic_set(&svc->refcnt, 0);
|
||||
|
||||
@ -3780,7 +3793,7 @@ static struct notifier_block ip_vs_dst_notifier = {
|
||||
|
||||
int __net_init ip_vs_control_net_init(struct net *net)
|
||||
{
|
||||
int idx;
|
||||
int i, idx;
|
||||
struct netns_ipvs *ipvs = net_ipvs(net);
|
||||
|
||||
/* Initialize rs_table */
|
||||
@ -3799,6 +3812,12 @@ int __net_init ip_vs_control_net_init(struct net *net)
|
||||
if (!ipvs->tot_stats.cpustats)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct ip_vs_cpu_stats *ipvs_tot_stats;
|
||||
ipvs_tot_stats = per_cpu_ptr(ipvs->tot_stats.cpustats, i);
|
||||
u64_stats_init(&ipvs_tot_stats->syncp);
|
||||
}
|
||||
|
||||
spin_lock_init(&ipvs->tot_stats.lock);
|
||||
|
||||
proc_create("ip_vs", 0, net->proc_net, &ip_vs_info_fops);
|
||||
|
||||
@ -1199,6 +1199,12 @@ static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
|
||||
goto err_destroy_table;
|
||||
}
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct dp_stats_percpu *dpath_stats;
|
||||
dpath_stats = per_cpu_ptr(dp->stats_percpu, i);
|
||||
u64_stats_init(&dpath_stats->sync);
|
||||
}
|
||||
|
||||
dp->ports = kmalloc(DP_VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
|
||||
GFP_KERNEL);
|
||||
if (!dp->ports) {
|
||||
|
||||
@ -118,6 +118,7 @@ struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
|
||||
{
|
||||
struct vport *vport;
|
||||
size_t alloc_size;
|
||||
int i;
|
||||
|
||||
alloc_size = sizeof(struct vport);
|
||||
if (priv_size) {
|
||||
@ -141,6 +142,13 @@ struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
for_each_possible_cpu(i) {
|
||||
struct pcpu_tstats *vport_stats;
|
||||
vport_stats = per_cpu_ptr(vport->percpu_stats, i);
|
||||
u64_stats_init(&vport_stats->syncp);
|
||||
}
|
||||
|
||||
|
||||
spin_lock_init(&vport->stats_lock);
|
||||
|
||||
return vport;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user