| #ifndef __BACKPORT_LINUX_U64_STATS_SYNC_H |
| #define __BACKPORT_LINUX_U64_STATS_SYNC_H |
| |
| #include <linux/version.h> |
| #include <generated/utsrelease.h> |
| #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) |
| #include_next <linux/u64_stats_sync.h> |
| #else |
| |
| /* |
| * To properly implement 64bits network statistics on 32bit and 64bit hosts, |
| * we provide a synchronization point, that is a noop on 64bit or UP kernels. |
| * |
| * Key points : |
| * 1) Use a seqcount on SMP 32bits, with low overhead. |
| * 2) Whole thing is a noop on 64bit arches or UP kernels. |
| * 3) Write side must ensure mutual exclusion or one seqcount update could |
| * be lost, thus blocking readers forever. |
| * If this synchronization point is not a mutex, but a spinlock or |
| * spinlock_bh() or disable_bh() : |
| * 3.1) Write side should not sleep. |
| * 3.2) Write side should not allow preemption. |
| * 3.3) If applicable, interrupts should be disabled. |
| * |
| * 4) If reader fetches several counters, there is no guarantee the whole values |
| * are consistent (remember point 1) : this is a noop on 64bit arches anyway) |
| * |
| * 5) readers are allowed to sleep or be preempted/interrupted : They perform |
| * pure reads. But if they have to fetch many values, it's better to not allow |
| * preemptions/interruptions to avoid many retries. |
| * |
| * 6) If counter might be written by an interrupt, readers should block interrupts. |
| * (On UP, there is no seqcount_t protection, a reader allowing interrupts could |
| * read partial values) |
| * |
| * 7) For softirq uses, readers can use u64_stats_fetch_begin_irq() and |
| * u64_stats_fetch_retry_irq() helpers |
| * |
| * Usage : |
| * |
| * Stats producer (writer) should use following template granted it already got |
| * an exclusive access to counters (a lock is already taken, or per cpu |
| * data is used [in a non preemptable context]) |
| * |
| * spin_lock_bh(...) or other synchronization to get exclusive access |
| * ... |
| * u64_stats_update_begin(&stats->syncp); |
| * stats->bytes64 += len; // non atomic operation |
| * stats->packets64++; // non atomic operation |
| * u64_stats_update_end(&stats->syncp); |
| * |
| * While a consumer (reader) should use following template to get consistent |
| * snapshot for each variable (but no guarantee on several ones) |
| * |
| * u64 tbytes, tpackets; |
| * unsigned int start; |
| * |
| * do { |
| * start = u64_stats_fetch_begin(&stats->syncp); |
| * tbytes = stats->bytes64; // non atomic operation |
| * tpackets = stats->packets64; // non atomic operation |
| * } while (u64_stats_fetch_retry(&stats->syncp, start)); |
| * |
| * |
| * Example of use in drivers/net/loopback.c, using per_cpu containers, |
| * in BH disabled context. |
| */ |
| #include <linux/seqlock.h> |
| |
| struct u64_stats_sync { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| seqcount_t seq; |
| #endif |
| }; |
| |
| static inline void u64_stats_update_begin(struct u64_stats_sync *syncp) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| write_seqcount_begin(&syncp->seq); |
| #endif |
| } |
| |
| static inline void u64_stats_update_end(struct u64_stats_sync *syncp) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| write_seqcount_end(&syncp->seq); |
| #endif |
| } |
| |
| static inline unsigned int u64_stats_fetch_begin(const struct u64_stats_sync *syncp) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| return read_seqcount_begin(&syncp->seq); |
| #else |
| #if BITS_PER_LONG==32 |
| preempt_disable(); |
| #endif |
| return 0; |
| #endif |
| } |
| |
| static inline bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp, |
| unsigned int start) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| return read_seqcount_retry(&syncp->seq, start); |
| #else |
| #if BITS_PER_LONG==32 |
| preempt_enable(); |
| #endif |
| return false; |
| #endif |
| } |
| |
| #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) */ |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(3,15,0) && \ |
| !(LINUX_VERSION_CODE == KERNEL_VERSION(3,13,11) && UTS_UBUNTU_RELEASE_ABI > 30) |
| static inline unsigned int u64_stats_fetch_begin_irq(const struct u64_stats_sync *syncp) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| return read_seqcount_begin(&syncp->seq); |
| #else |
| #if BITS_PER_LONG==32 |
| local_irq_disable(); |
| #endif |
| return 0; |
| #endif |
| } |
| |
| static inline bool u64_stats_fetch_retry_irq(const struct u64_stats_sync *syncp, |
| unsigned int start) |
| { |
| #if BITS_PER_LONG==32 && defined(CONFIG_SMP) |
| return read_seqcount_retry(&syncp->seq, start); |
| #else |
| #if BITS_PER_LONG==32 |
| local_irq_enable(); |
| #endif |
| return false; |
| #endif |
| } |
| |
| #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */ |
| |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) |
| #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 |
| #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) */ |
| |
| #endif /* __BACKPORT_LINUX_U64_STATS_SYNC_H */ |