Hello community, here is the log from the commit of package kernel-source for openSUSE:Factory checked in at 2013-10-25 18:52:34 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/kernel-source (Old) and /work/SRC/openSUSE:Factory/.kernel-source.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "kernel-source" Changes: -------- --- /work/SRC/openSUSE:Factory/kernel-source/kernel-cubox.changes 2013-10-24 14:08:40.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.kernel-source.new/kernel-cubox.changes 2013-10-25 18:52:39.000000000 +0200 @@ -1,0 +2,13 @@ +Thu Oct 24 18:23:02 CEST 2013 - [email protected] + +- cpufreq: ondemand: Change the calculation of target frequency + (bnc#846734). +- commit 0ba01b7 + +------------------------------------------------------------------- +Thu Oct 24 17:08:03 CEST 2013 - [email protected] + +- Btrfs: fix negative qgroup tracking from owner accounting (bnc#821948) +- commit ef319f1 + +------------------------------------------------------------------- kernel-debug.changes: same change kernel-default.changes: same change kernel-desktop.changes: same change kernel-docs.changes: same change kernel-ec2.changes: same change kernel-exynos.changes: same change kernel-lpae.changes: same change kernel-pae.changes: same change kernel-source.changes: same change kernel-syms.changes: same change kernel-trace.changes: same change kernel-vanilla.changes: same change kernel-xen.changes: same change ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ kernel-cubox.spec ++++++ --- /var/tmp/diff_new_pack.KqvdU6/_old 2013-10-25 18:52:52.000000000 +0200 +++ /var/tmp/diff_new_pack.KqvdU6/_new 2013-10-25 18:52:52.000000000 +0200 @@ -61,7 +61,7 @@ Summary: Kernel for SolidRun Cubox Version: 3.11.6 %if 0%{?is_kotd} -Release: <RELEASE>.g8d7989b +Release: <RELEASE>.g0ba01b7 %else Release: 0 %endif kernel-debug.spec: same change kernel-default.spec: same change kernel-desktop.spec: same change kernel-docs.spec: same change kernel-ec2.spec: same change kernel-exynos.spec: same change kernel-lpae.spec: same change kernel-pae.spec: same change kernel-source.spec: same change ++++++ kernel-syms.spec ++++++ --- /var/tmp/diff_new_pack.KqvdU6/_old 2013-10-25 18:52:52.000000000 +0200 +++ /var/tmp/diff_new_pack.KqvdU6/_new 2013-10-25 18:52:52.000000000 +0200 @@ -26,7 +26,7 @@ Version: 3.11.6 %if %using_buildservice %if 0%{?is_kotd} -Release: <RELEASE>.g8d7989b +Release: <RELEASE>.g0ba01b7 %else Release: 0 %endif ++++++ kernel-trace.spec ++++++ --- /var/tmp/diff_new_pack.KqvdU6/_old 2013-10-25 18:52:52.000000000 +0200 +++ /var/tmp/diff_new_pack.KqvdU6/_new 2013-10-25 18:52:52.000000000 +0200 @@ -61,7 +61,7 @@ Summary: The Standard Kernel with Tracing Features Version: 3.11.6 %if 0%{?is_kotd} -Release: <RELEASE>.g8d7989b +Release: <RELEASE>.g0ba01b7 %else Release: 0 %endif kernel-vanilla.spec: same change kernel-xen.spec: same change ++++++ patches.fixes.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/patches.fixes/cpufreq_performance_tuning.patch new/patches.fixes/cpufreq_performance_tuning.patch --- old/patches.fixes/cpufreq_performance_tuning.patch 1970-01-01 01:00:00.000000000 +0100 +++ new/patches.fixes/cpufreq_performance_tuning.patch 2013-10-24 18:23:02.000000000 +0200 @@ -0,0 +1,185 @@ +From: Stratos Karafotis <[email protected]> +Subject: cpufreq: ondemand: Change the calculation of target frequency +References: bnc#846734 +Patch-Mainline: v3.12-rc1 +Git-commit: dfa5bb622555d9da0df21b50f46ebdeef390041b + + +Signed-off-by: Thomas Renninger <[email protected]> + +The ondemand governor calculates load in terms of frequency and +increases it only if load_freq is greater than up_threshold +multiplied by the current or average frequency. This appears to +produce oscillations of frequency between min and max because, +for example, a relatively small load can easily saturate minimum +frequency and lead the CPU to the max. Then, it will decrease +back to the min due to small load_freq. + +Change the calculation method of load and target frequency on the +basis of the following two observations: + + - Load computation should not depend on the current or average + measured frequency. For example, absolute load of 80% at 100MHz + is not necessarily equivalent to 8% at 1000MHz in the next + sampling interval. + + - It should be possible to increase the target frequency to any + value present in the frequency table proportional to the absolute + load, rather than to the max only, so that: + + Target frequency = C * load + + where we take C = policy->cpuinfo.max_freq / 100. + +Tested on Intel i7-3770 CPU @ 3.40GHz and on Quad core 1500MHz Krait. +Phoronix benchmark of Linux Kernel Compilation 3.1 test shows an +increase ~1.5% in performance. cpufreq_stats (time_in_state) shows +that middle frequencies are used more, with this patch. Highest +and lowest frequencies were used less by ~9%. + +[rjw: We have run multiple other tests on kernels with this + change applied and in the vast majority of cases it turns out + that the resulting performance improvement also leads to reduced + consumption of energy. The change is additionally justified by + the overall simplification of the code in question.] + +Signed-off-by: Stratos Karafotis <[email protected]> +Acked-by: Viresh Kumar <[email protected]> +Signed-off-by: Rafael J. Wysocki <[email protected]> + +diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c +index 7b839a8..7409dbd 100644 +--- a/drivers/cpufreq/cpufreq_governor.c ++++ b/drivers/cpufreq/cpufreq_governor.c +@@ -53,7 +53,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu) + + policy = cdbs->cur_policy; + +- /* Get Absolute Load (in terms of freq for ondemand gov) */ ++ /* Get Absolute Load */ + for_each_cpu(j, policy->cpus) { + struct cpu_dbs_common_info *j_cdbs; + u64 cur_wall_time, cur_idle_time; +@@ -104,14 +104,6 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu) + + load = 100 * (wall_time - idle_time) / wall_time; + +- if (dbs_data->cdata->governor == GOV_ONDEMAND) { +- int freq_avg = __cpufreq_driver_getavg(policy, j); +- if (freq_avg <= 0) +- freq_avg = policy->cur; +- +- load *= freq_avg; +- } +- + if (load > max_load) + max_load = load; + } +diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h +index 6663ec3..0e0dd4c 100644 +--- a/drivers/cpufreq/cpufreq_governor.h ++++ b/drivers/cpufreq/cpufreq_governor.h +@@ -169,7 +169,6 @@ struct od_dbs_tuners { + unsigned int sampling_rate; + unsigned int sampling_down_factor; + unsigned int up_threshold; +- unsigned int adj_up_threshold; + unsigned int powersave_bias; + unsigned int io_is_busy; + }; +diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c +index 93eb5cb..a3c5574 100644 +--- a/drivers/cpufreq/cpufreq_ondemand.c ++++ b/drivers/cpufreq/cpufreq_ondemand.c +@@ -29,11 +29,9 @@ + #include "cpufreq_governor.h" + + /* On-demand governor macros */ +-#define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10) + #define DEF_FREQUENCY_UP_THRESHOLD (80) + #define DEF_SAMPLING_DOWN_FACTOR (1) + #define MAX_SAMPLING_DOWN_FACTOR (100000) +-#define MICRO_FREQUENCY_DOWN_DIFFERENTIAL (3) + #define MICRO_FREQUENCY_UP_THRESHOLD (95) + #define MICRO_FREQUENCY_MIN_SAMPLE_RATE (10000) + #define MIN_FREQUENCY_UP_THRESHOLD (11) +@@ -161,14 +159,10 @@ static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq) + + /* + * Every sampling_rate, we check, if current idle time is less than 20% +- * (default), then we try to increase frequency. Every sampling_rate, we look +- * for the lowest frequency which can sustain the load while keeping idle time +- * over 30%. If such a frequency exist, we try to decrease to this frequency. +- * +- * Any frequency increase takes it to the maximum frequency. Frequency reduction +- * happens at minimum steps of 5% (default) of current frequency ++ * (default), then we try to increase frequency. Else, we adjust the frequency ++ * proportional to load. + */ +-static void od_check_cpu(int cpu, unsigned int load_freq) ++static void od_check_cpu(int cpu, unsigned int load) + { + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu); + struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy; +@@ -178,29 +172,17 @@ static void od_check_cpu(int cpu, unsigned int load_freq) + dbs_info->freq_lo = 0; + + /* Check for frequency increase */ +- if (load_freq > od_tuners->up_threshold * policy->cur) { ++ if (load > od_tuners->up_threshold) { + /* If switching to max speed, apply sampling_down_factor */ + if (policy->cur < policy->max) + dbs_info->rate_mult = + od_tuners->sampling_down_factor; + dbs_freq_increase(policy, policy->max); + return; +- } +- +- /* Check for frequency decrease */ +- /* if we cannot reduce the frequency anymore, break out early */ +- if (policy->cur == policy->min) +- return; +- +- /* +- * The optimal frequency is the frequency that is the lowest that can +- * support the current CPU usage without triggering the up policy. To be +- * safe, we focus 10 points under the threshold. +- */ +- if (load_freq < od_tuners->adj_up_threshold +- * policy->cur) { ++ } else { ++ /* Calculate the next frequency proportional to load */ + unsigned int freq_next; +- freq_next = load_freq / od_tuners->adj_up_threshold; ++ freq_next = load * policy->cpuinfo.max_freq / 100; + + /* No longer fully busy, reset rate_mult */ + dbs_info->rate_mult = 1; +@@ -374,9 +356,6 @@ static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf, + input < MIN_FREQUENCY_UP_THRESHOLD) { + return -EINVAL; + } +- /* Calculate the new adj_up_threshold */ +- od_tuners->adj_up_threshold += input; +- od_tuners->adj_up_threshold -= od_tuners->up_threshold; + + od_tuners->up_threshold = input; + return count; +@@ -525,8 +504,6 @@ static int od_init(struct dbs_data *dbs_data) + if (idle_time != -1ULL) { + /* Idle micro accounting is supported. Use finer thresholds */ + tuners->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD; +- tuners->adj_up_threshold = MICRO_FREQUENCY_UP_THRESHOLD - +- MICRO_FREQUENCY_DOWN_DIFFERENTIAL; + /* + * In nohz/micro accounting case we set the minimum frequency + * not depending on HZ, but fixed (very low). The deferred +@@ -535,8 +512,6 @@ static int od_init(struct dbs_data *dbs_data) + dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE; + } else { + tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; +- tuners->adj_up_threshold = DEF_FREQUENCY_UP_THRESHOLD - +- DEF_FREQUENCY_DOWN_DIFFERENTIAL; + + /* For correct statistics, we need 10 ticks for each measure */ + dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * ++++++ patches.suse.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/patches.suse/btrfs-fix-negative-qgroup-tracking-from-owher.patch new/patches.suse/btrfs-fix-negative-qgroup-tracking-from-owher.patch --- old/patches.suse/btrfs-fix-negative-qgroup-tracking-from-owher.patch 1970-01-01 01:00:00.000000000 +0100 +++ new/patches.suse/btrfs-fix-negative-qgroup-tracking-from-owher.patch 2013-10-24 17:08:03.000000000 +0200 @@ -0,0 +1,71 @@ +From: Jan Schmidt <[email protected]> +Subject: [PATCH] Btrfs: fix negative qgroup tracking from owner accounting (bug #61951) +Patch-mainline: pending +References: bnc#821948 + +btrfs_dec_ref() queued a delayed ref for owner of a tree block. The qgroup +tracking is based on delayed refs. The owner of a tree block is set when a +tree block is allocated, it is never updated. + +When you allocate a tree block and then remove the subvolume that did the +allocation, the qgroup accounting for that removal is correct. However, the +removal was accounted again for each subvolume deletion that also referenced +the tree block, because accounting was erroneously based on the owner. + +Instead of queueing delayed refs for the non-existent owner, we now +queue delayed refs for the root being removed. This fixes the qgroup +accounting. + +Signed-off-by: Jan Schmidt <[email protected]> +Tested-by: <[email protected]> +Signed-off-by: David Sterba <[email protected]> +--- + fs/btrfs/extent-tree.c | 14 +++++++++----- + 1 file changed, 9 insertions(+), 5 deletions(-) + +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -2974,12 +2974,11 @@ out: + static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, + struct btrfs_root *root, + struct extent_buffer *buf, +- int full_backref, int inc, int for_cow) ++ int full_backref, u64 ref_root, int inc, int for_cow) + { + u64 bytenr; + u64 num_bytes; + u64 parent; +- u64 ref_root; + u32 nritems; + struct btrfs_key key; + struct btrfs_file_extent_item *fi; +@@ -2989,7 +2988,6 @@ static int __btrfs_mod_ref(struct btrfs_ + int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *, + u64, u64, u64, u64, u64, u64, int); + +- ref_root = btrfs_header_owner(buf); + nritems = btrfs_header_nritems(buf); + level = btrfs_header_level(buf); + +@@ -3045,13 +3043,19 @@ fail: + int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, + struct extent_buffer *buf, int full_backref, int for_cow) + { +- return __btrfs_mod_ref(trans, root, buf, full_backref, 1, for_cow); ++ u64 ref_root; ++ ++ ref_root = btrfs_header_owner(buf); ++ ++ return __btrfs_mod_ref(trans, root, buf, full_backref, ref_root, ++ 1, for_cow); + } + + int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, + struct extent_buffer *buf, int full_backref, int for_cow) + { +- return __btrfs_mod_ref(trans, root, buf, full_backref, 0, for_cow); ++ return __btrfs_mod_ref(trans, root, buf, full_backref, root->objectid, ++ 0, for_cow); + } + + static int write_one_cache_group(struct btrfs_trans_handle *trans, ++++++ series.conf ++++++ --- /var/tmp/diff_new_pack.KqvdU6/_old 2013-10-25 18:52:53.000000000 +0200 +++ /var/tmp/diff_new_pack.KqvdU6/_new 2013-10-25 18:52:53.000000000 +0200 @@ -221,6 +221,7 @@ ######################################################## +trenn patches.fixes/cpufreq_ondemand_performance_optimise_default_settings.patch + patches.fixes/cpufreq_performance_tuning.patch ## cpuidle perf events cleanups and related patches.arch/perf_timechart_fix_zero_timestamps.patch @@ -302,6 +303,7 @@ +dsterba patches.suse/btrfs-0034-optimize-key-searches-in-btrfs_search_slot.patch patches.suse/btrfs-relocate-csums-properly-with-prealloc-extents.patch + patches.suse/btrfs-fix-negative-qgroup-tracking-from-owher.patch patches.suse/btrfs-use-end-trans-in-label-ioctl patches.suse/btrfs-add-ability-to-query-change-feature-bits-online-ioctl patches.suse/introduce-kobj_completion ++++++ source-timestamp ++++++ --- /var/tmp/diff_new_pack.KqvdU6/_old 2013-10-25 18:52:53.000000000 +0200 +++ /var/tmp/diff_new_pack.KqvdU6/_new 2013-10-25 18:52:53.000000000 +0200 @@ -1,3 +1,3 @@ -2013-10-22 21:17:47 +0200 -GIT Revision: 8d7989b1da96f51a95fcdd352ec19f21351759f0 +2013-10-24 18:23:02 +0200 +GIT Revision: 0ba01b7a2bea03711ab3630db1f03f6fa3035232 GIT Branch: openSUSE-13.1 -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
