Commit 39d36079 authored Jan 09, 2018 by Runmin Wang

tmp-ad490df6' into msm-4.14

* remotes/origin/tmp-ad490df6:
ANDROID: binder: Remove obsolete proc waitqueue.
f2fs: updates on 4.15-rc1
ANDROID: arch_topology: fix build for !CONFIG_CPU_FREQ
ANDROID: ARM64: Tweak defconfig Android EAS features
ANDROID: ARM64: Tweak defconfig for EAS platforms
ANDROID: DEBUG: accumulate debug output and dump all at the end of energy_diff
ANDROID: sched/fair: prevent meaningless active migration
ANDROID: sched/fair: Fall back to slow path wakeup placement if needed
ANDROID: DEBUG: Temporarily disable lockdep asserting on update_task_ravg
ANDROID: sched: Introduce Window Assisted Load Tracking (WALT)
ANDROID: Add find_best_target to minimise energy calculation overhead
ANDROID: Combined EAS Load Balance Tweaks
ANDROID: sched/fair: re-factor energy_diff to use a single (extensible) energy_env
ANDROID: sched/fair: consider task utilization in group_norm/max_util()
ANDROID: refactor select_task_rq_fair et al to be cleaner
ANDROID: sched: fair: Bypass energy-aware wakeup for prefer-idle tasks
ANDROID: sched: Move energy-aware decision into a helper function
ANDROID: sched/fair: Try to estimate possible idle states.
ANDROID: trace/sched: Add tracepoint for sched_overutilized events
ANDROID: sched: fair/tune: Add schedtune with cgroups interface
ANDROID: sched: EAS: take cstate into account when selecting idle core
ANDROID: sched: Unconditionally honor sync flag for energy-aware wakeups
ANDROID: sched: Add KConfig option to set ENERGY_AWARE sched feature on
ANDROID: cpufreq: schedutil: add up/down frequency transition rate limits
ANDROID: sched: Add per-cpu max capacity to sched_group_capacity
ANDROID: sched: cpufreq: use PELT rt_rq as estimate of required RT CPU capacity
ANDROID: trace/sched: add tracepoint for rt_rq PELT signal
FROMLIST: sched/rt: add utilization tracking
FROMLIST: sched/fair: Use wake_q length as a hint for wake_wide
FROMLIST: sched/fair: Update blocked load from newly idle balance
FROMLIST: sched: force update of blocked load of idle cpus
UPSTREAM: sched/fair: Sync task util before slow-path wakeup
UPSTREAM: sched/fair: Fix usage of find_idlest_group() when the local group is idlest
UPSTREAM: sched/fair: Fix usage of find_idlest_group() when no groups are allowed
UPSTREAM: sched/fair: Fix find_idlest_group() when local group is not allowed
UPSTREAM: sched/fair: Remove unnecessary comparison with -1
UPSTREAM: sched/fair: Move select_task_rq_fair() slow-path into its own function
UPSTREAM: sched/fair: Force balancing on NOHZ balance if local group has capacity
ANDROID: sched/events: Introduce task_group load tracking trace event
ANDROID: sched/events: Introduce sched_entity load tracking trace event
ANDROID: sched/events: Introduce cfs_rq load tracking trace event
ANDROID: sched/autogroup: Define autogroup_path() for !CONFIG_SCHED_DEBUG
ANDROID: sched/debug: Add energy procfs interface
ANDROID: arm: Support for extracting EAS energy costs from DT
ANDROID: arm64: Support for extracting EAS energy costs from DT
ANDROID: arm: Add Energy Model to dtb for TC2
ANDROID: hisilicon: Add energy model data to hisilicon 6220 dtb
ANDROID: arm64: Add Energy Model to dtb for Juno-r0 and Juno-r2
ANDROID: Documentation: DT bindings for energy model cost data required by EAS
ANDROID: arm64, dts: add hikey cpu capacity-dmips-mhz information
ANDROID: drivers base/arch_topology: Detect SD_SHARE_CAP_STATES flag
ANDROID: drivers base/arch_topology: enforce SCHED_CAPACITY_SCALE as highest CPU capacity
ANDROID: drivers base/arch_topology: fold two pr_debug()'s into one
ANDROID: sched: Per-Sched-domain over utilization
ANDROID: sched: Disable energy-unfriendly nohz kicks
ANDROID: sched: Consider a not over-utilized energy-aware system as balanced
ANDROID: sched/fair: Energy-aware wake-up task placement
ANDROID: sched: Add over-utilization/tipping point indicator
ANDROID: sched/fair: Add energy_diff dead-zone margin
ANDROID: sched: Determine the current sched_group idle-state
ANDROID: sched, cpuidle: Track cpuidle state index in the scheduler
ANDROID: sched: Estimate energy impact of scheduling decisions
ANDROID: sched: Extend sched_group_energy to test load-balancing decisions
ANDROID: initramfs: call free_initrd() when skipping init
FROMLIST: net: xfrm: allow clearing socket xfrm policies.
FROMLIST: binder: fix proc->files use-after-free
UPSTREAM: arm64: vdso: fix clock_getres for 4GiB-aligned res
UPSTREAM: security: bpf: replace include of linux/bpf.h with forward declarations
BACKPORT: selinux: bpf: Add addtional check for bpf object file receive
UPSTREAM: selinux: bpf: Add selinux check for eBPF syscall operations
BACKPORT: security: bpf: Add LSM hooks for bpf object related syscall
BACKPORT: bpf: Add file mode configuration into bpf maps
UPSTREAM: arm64: Avoid aligning normal memory pointers in __memcpy_{to,from}io
UPSTREAM: android: binder: Change binder_shrinker to static
UPSTREAM: f2fs: expose some sectors to user in inline data or dentry case
UPSTREAM: tracing: Add support for preempt and irq enable/disable events
UPSTREAM: tracing: Prepare to add preempt and irq trace events
BACKPORT: android: binder: Remove unused vma argument
ANDROID: Revert "arm64: move ELF_ET_DYN_BASE to 4GB / 4MB"
ANDROID: Revert "arm: move ELF_ET_DYN_BASE to 4MB"
ANDROID: memory_state_time: fix undefined behavior with missing DT properties
ANDROID: memory_state_time: Implement memory_state_time, used by qcom,cpubw
ANDROID: uid_sys_stats: log task io with a debug flag
ANDROID: uid_sys_stats: check previous uid_entry before call find_or_register_uid
ANDROID: uid_sys_stats: Kconfig: add depends for UID_SYS_STATS
ANDROID: uid_sys_stats: defer io stats calulation for dead tasks
ANDROID: uid_sys_stats: fix access of task_uid(task)
ANDROID: uid_sys_stats: reduce update_io_stats overhead
ANDROID: uid_sys_stats: change to use rt_mutex
ANDROID: uid_sys_stats: account for fsync syscalls
ANDROID: uid_sys_stats: fix negative write bytes.
ANDROID: uid_sys_stats: allow writing same state
ANDROID: uid_sys_stats: rename uid_cputime.c to uid_sys_stats.c
ANDROID: uid_cputime: add per-uid IO usage accounting
ANDROID: uid_cputime: Check for the range while removing range of UIDs.
ANDROID: uid_cputime: Iterates over all the threads instead of processes.
ANDROID: uid_cputime: fix cputime overflow
ANDROID: uid_cputime: Adds accounting for the cputimes per uid.
CHROMIUM: usb: gadget: f_accessory: add .raw_request callback
CHROMIUM: usb: gadget: f_audio_source: add .free_func callback
ANDROID: usb: gadget: f_midi: set fi->f to NULL when free f_midi function
ANDROID: usb: gadget: f_midi: create F_midi device
ANDROID: usb: gadget: f_accessory: assign no-op request complete callbacks
ANDROID: usb: gadget: f_accessory: Fix for UsbAccessory clean unbind.
ANDROID: usb: gadget: f_accessory: fix false disconnect due to a signal sent to the reading process
ANDROID: usb: gadget: f_accessory: Move gadget functions code
ANDROID: usb: gadget: f_accessory: Migrate to USB_FUNCTION API
ANDROID: usb: gadget: f_audio_source: disable the CPU C-states upon playback
ANDROID: usb: gadget: f_audio_source: Move gadget functions code
ANDROID: usb: gadget: f_audio_source: Move to USB_FUNCTION API
ANDROID: usb: gadget: composite: Do not disconnect unregistered dev
ANDROID: usb: gadget: configfs: fix null ptr in android_disconnect
ANDROID: usb: gadget: configfs: Add device attribute to determine gadget state
ANDROID: usb: gadget: configfs: Add "state" attribute to android_device
ANDROID: usb: gadget: configfs: Add function devices to the parent
ANDROID: usb: gadget: configfs: Add Uevent to notify userspace
ANDROID: usb: gadget: configfs: Add usb_function ptr to fi struct
ANDROID: usb: gadget: f_audio_source: Fixed USB Audio Class Interface Descriptor
ANDROID: usb: gadget: f_audio_source: change max ISO packet size
ANDROID: usb: gadget: f_audio_source: New gadget driver for audio output
ANDROID: usb: gadget: f_accessory: check for accessory device before disconnecting HIDs
ANDROID: usb: gadget: f_accessory: Enabled Zero Length Packet (ZLP) for acc_write
ANDROID: usb: gadget: f_accessory: move userspace interface to uapi
ANDROID: usb: gadget: f_accessory: Add support for HID input devices
ANDROID: usb: gadget: f_accessory: Add ACCESSORY_SET_AUDIO_MODE control request and ioctl
ANDROID: usb: gadget: f_accessory: Add Android Accessory function
ANDROID: usb: phy: Dual role sysfs class definition
ANDROID: usb: otg-wakelock: Remove wakelock.h dependencies
ANDROID: usb: otg-wakelock: Temporarily grab wakelock on charger and disconnect events
ANDROID: usb: otg-wakelock: Take wakelock when VBUS present
ANDROID: trace: net: use %pK for kernel pointers
ANDROID: trace: power: add trace_clock_set_parent
ANDROID: trace: cpufreq: Add tracing for min/max cpufreq
ANDROID: trace: gpu: add gpu trace events
ANDROID: trace: sched: add sched blocked tracepoint which dumps out context of sleep.
ANDROID: trace: add non-hierarchical function_graph option
ANDROID: security,perf: Allow further restriction of perf_event_open
ANDROID: rtc-palmas: correct for bcd year
ANDROID: power: wakeup: align wakeup_sources format
ANDROID: power: wakeup: Add the guard condition for len in pm_get_active_wakeup_sources
ANDROID: power: wakeup: Add last wake up source logging for suspend abort reason.
ANDROID: power: wakeup_reason: fix suspend time reporting
ANDROID: power: wakeup_reason: Report suspend times from last_suspend_time
ANDROID: power: wakeup_reason: Add check_wakeup_reason() to verify wakeup source irq
ANDROID: power: wakeup_reason: Adds functionality to log the last suspend abort reason.
ANDROID: power: wakeup_reason: Avoids bogus error messages for the suspend aborts.
ANDROID: power: wakeup_reason: Add guard condition for maximum wakeup reasons
ANDROID: power: wakeup_reason: add an API to log wakeup reasons
ANDROID: power: power_supply: Add property CHARGE_COUNTER_EXT and 64-bit precision properties
ANDROID: power: power_supply: add POWER_SUPPLY_PROP_CHARGE_ENABLED
ANDROID: power: power_supply: add POWER_SUPPLY_PROP_USB_OTG
ANDROID: power: power_supply: Add custom property for USB High Current mode
ANDROID: arm64: copy CONFIG_CMDLINE_EXTEND from ARM
ANDROID: of: Support CONFIG_CMDLINE_EXTEND config option
ANDROID: NFC: st21nfca: Fix memory OOB and leak issues in connectivity events handler
ANDROID: NFC: Fix possible memory corruption when handling SHDLC I-Frame commands
ANDROID: nfc: fdp: Fix possible buffer overflow in WCS4000 NFC driver
ANDROID: NFC: st21nfca: Fix out of bounds kernel access when handling ATR_REQ
ANDROID: netfilter: xt_IDLETIMER: Use fullsock when querying uid
ANDROID: netfilter: xt_IDLETIMER: Fix use after free condition during work
ANDROID: netfilter: xt_IDLETIMER: Adds the uid field in the msg
ANDROID: netfilter: xt_IDLETIMER: time-stamp and suspend/resume handling.
ANDROID: netfilter: xt_IDLETIMER: Add new netlink msg type
ANDROID: netfilter: xt_qtaguid: Use sk_uid to replace uid get from socket file
ANDROID: netfilter: xt_qtaguid: fix handling for cases where tunnels are used.
ANDROID: netfilter: xt_qtaguid: handle properly request sockets
ANDROID: netfilter: xt_qtaguid: Add untag hacks to inet_release function
ANDROID: netfilter: xt_qtaguid: don't check if embedded arrays are NULL
ANDROID: netfilter: xt_qtaguid: fix the deadlock when enable DDEBUG
ANDROID: netfilter: xt_qtaguid: Don't show empty tag stats for unprivileged uids
ANDROID: netfilter: xt_qtaguid: Fix panic caused by processing non-full socket.
ANDROID: netfilter: xt_qtaguid: Fix panic caused by synack processing
ANDROID: netfilter: xt_qtaguid: fix a race condition in if_tag_stat_update
ANDROID: netfilter: xt_qtaguid: xt_socket: build fixes
ANDROID: netfilter: xt_socket/nf_socket: fix refcount underflow and crash
ANDROID: netfilter: xt_qtaguid: Use sk_callback_lock read locks before reading sk->sk_socket
ANDROID: netfilter: xt_qtaguid/xt_socket: Build fixups
ANDROID: netfilter: xt_qtaguid: Fix boot panic
ANDROID: netfilter: xt_qtaguid: fix bad tcp_time_wait sock handling
ANDROID: netfilter: xt_qtaguid: 3.10 fixes
ANDROID: netfilter: xt_qtaguid: rate limit some of the printks
ANDROID: netfilter: xt_qtaguid: Allow tracking loopback
ANDROID: netfilter: xt_qtaguid: extend iface stat to report protocols
ANDROID: netfilter: xt_qtaguid: remove AID_* dependency for access control
ANDROID: netfilter: xt_qtaguid: Don't BUG_ON if create_if_tag_stat fails
ANDROID: netfilter: xt_qtaguid: fix error exit that would keep a spinlock.
ANDROID: netfilter: xt_qtaguid: report only uid tags to non-privileged processes
ANDROID: netfilter: xt_qtaguid: start tracking iface rx/tx at low level
ANDROID: netfilter: xt_qtaguid: fix ipv6 protocol lookup
ANDROID: netfilter: xt_qtaguid: add qtaguid matching module
ANDROID: netfilter: xt_quota2: fixup the quota2, and enable.
ANDROID: netfilter: xt_quota2: adding the original quota2 from xtables-addons
ANDROID: net: xfrm: check dir value of xfrm_userpolicy_id
ANDROID: net: xfrm: make PF_KEY SHA256 use RFC-compliant truncation.
ANDROID: net: wireless: wlcore: Disable filtering in AP role
ANDROID: net: wireless: Decrease scan entry expiration to avoid stall results
ANDROID: net: rfkill: Introduce CONFIG_RFKILL_PM and use instead of CONFIG_PM to power down
ANDROID: net: ipv6: autoconf routes into per-device tables
ANDROID: net: ipv6: fix crash caused by ipv6_find_hdr()
ANDROID: net: ipv4: tcp: add a sysctl to config the tcp_default_init_rwnd
ANDROID: net: ipv4: sysfs_net_ipv4: Add sysfs-based knobs for controlling TCP window size
ANDROID: net: ip-sysctl: Document tcp_fwmark_accept
ANDROID: net: paranoid: commoncap: Begin to warn users of implicit PARANOID_NETWORK capability grants
ANDROID: net: paranoid: security: Add proper checks for Android specific capability checks
ANDROID: net: paranoid: Only NET_ADMIN is allowed to fully control TUN interfaces.
ANDROID: net: paranoid: Replace AID_NET_RAW checks with capable(CAP_NET_RAW).
ANDROID: net: paranoid: security: Add AID_NET_RAW and AID_NET_ADMIN capability check in cap_capable().
ANDROID: net: Paranoid network.
ANDROID: mmc: core: export emmc revision
ANDROID: mmc: core: move to a SCHED_FIFO thread
ANDROID: mmc: core: Add "ignore mmc pm notify" functionality
ANDROID: mmc: sdio: Add concept of an 'embedded' SDIO device.
ANDROID: mmc: sd: Add retries in re-detection
ANDROID: mmc: sd: When resuming, try a little harder to init the card
ANDROID: mmc: sd: Add new CONFIG_MMC_PARANOID_SD_INIT for enabling retries during SD detection
ANDROID: mm: add a field to store names for private anonymous memory
ANDROID: HACK: arm64: use -mno-implicit-float instead of -mgeneral-regs-only
ANDROID: Kbuild, LLVMLinux: allow overriding clang target triple
CHROMIUM: arm64: Disable asm-operand-width warning for clang
CHROMIUM: kbuild: clang: Disable the 'duplicate-decl-specifier' warning
ANDROID: kbuild: Makefile.clean: make Kbuild and Makefile optional
ANDROID: kbuild: make it possible to specify the module output dir
ANDROID: input: goldfish_events: no extra EV_SYN; register goldfish
ANDROID: input: keychord: Fix for a memory leak in keychord.
ANDROID: input: keychord: Fix races in keychord_write.
ANDROID: input: keychord: Fix a slab out-of-bounds read.
ANDROID: input: keychord: log when keychord triggered
ANDROID: input: keyreset: switch to orderly_reboot
ANDROID: input: keyreset: Made keyreset more robust
ANDROID: input: keyreset: Changed keyreset to act as a wrapper for keycombo.
ANDROID: input: keycombo: add keycombo, a general key combo driver.
ANDROID: input: keychord: Add keychord driver
ANDROID: input: keyreset: Add keyreset driver.
ANDROID: input: gpio_matrix: Remove wakelock.h dependencies
ANDROID: input: gpio_input: convert from wakelocks to wakeup sources
ANDROID: input: gpio_event: remove early suspend
ANDROID: input: Generic GPIO Input devices
ANDROID: initramfs: Add skip_initramfs command line option
ANDROID: build: add build server configs for goldfish
ANDROID: goldfish: add ranchu defconfigs
ANDROID: goldfish_sync_timeline: Rename fence to dma_fence
ANDROID: goldfish_sync: 32 max cmds to save stack
ANDROID: goldfish_sync: Fix sync_file_obj is NULL but dereferenced problem
ANDROID: goldfish_sync: Isolate single module to fix compilation
ANDROID: goldfish_sync: upgrade to new fence sync api
ANDROID: goldfish_sync: Add goldfish sync driver
ANDROID: goldfish_audio: Clear audio read buffer status after each read
ANDROID: goldfish_audio: Enable ACPI-based enumeration for goldfish audio
ANDROID: goldfishfb: Set pixclock = 0
ANDROID: goldfishfb: Enable ACPI-based enumeration for goldfish framebuffer
ANDROID: goldfishfb: add devicetree bindings
ANDROID: fs: Fix for in kernel emergency remount when loop mounts are used
ANDROID: fs: Refactor FS readpage/write tracepoints.
ANDROID: fs: FS tracepoints to track IO.
ANDROID: fs: sched: add a counter to track fsync
ANDROID: fs: epoll: use freezable blocking call
ANDROID: fs: ext4: Add support for FIDTRIM, a best-effort ioctl for deep discard trim
ANDROID: fs: fuse: Freeze client on suspend when request sent to userspace
ANDROID: fs: pstore: ram: Add ramoops_console_write_buf api
ANDROID: fs: block_dump: Don't display inode changes if block_dump < 2
ANDROID: dm: verity: add minimum prefetch size
ANDROID: dm: android-verity: mark dev as rw for linear target
ANDROID: dm: android-verity: allow disable dm-verity for Treble VTS
ANDROID: dm: android-verity: fix table_make_digest() error handling
ANDROID: dm: android-verity: rebase for 4.9
ANDROID: dm: android-verity: Remove fec_header location constraint
ANDROID: dm: android-verity: adopt changes made to dm callbacks
ANDROID: dm: android-verity: pack the fec_header structure
ANDROID: dm: android-verity: Verify header before fetching table
ANDROID: dm: android-verity: allow adb disable-verity only in userdebug
ANDROID: dm: android-verity: mount as linear target if eng build
ANDROID: dm: android-verity: use default verity public key
ANDROID: dm: android-verity: fix signature verification flag
ANDROID: dm: android-verity: use name_to_dev_t
ANDROID: dm: android-verity: Mounting root as linear device when verity disabled
ANDROID: dm: android-verity: Add android verity target
ANDROID: dm: do_mounts_dm: Update init/do_mounts_dm.c to the latest ChromiumOS version.
ANDROID: dm: do_mounts_dm: fix dm_substitute_devices()
ANDROID: dm: do_mounts_dm: Rebase on top of 4.9
CHROMIUM: dm: boot time specification of dm=
ANDROID: dm: verity-fec: add sysfs attribute fec/corrected
CHROMIUM: dma-buf: dma-fence: fix warning when releasing active sync point
CHROMIUM: cgroups: relax permissions on moving tasks between cgroups
ANDROID: cpuset: Make cpusets restore on hotplug
ANDROID: cpu: send KOBJ_ONLINE event when enabling cpus
ANDROID: cpuidle: governor: menu: don't use loadavg
ANDROID: binder: clarify deferred thread work.
ANDROID: binder: show high watermark of alloc->pages.
ANDROID: binder: Add thread->process_todo flag.
ANDROID: binder: fix node sched policy calculation
ANDROID: binder: init desired_prio.sched_policy before use it
ANDROID: binder: fix transaction leak.
ANDROID: binder: Add tracing for binder priority inheritance.
ANDROID: binder: don't check prio permissions on restore.
ANDROID: binder: add RT inheritance flag to node.
ANDROID: binder: improve priority inheritance.
ANDROID: binder: add min sched_policy to node.
ANDROID: binder: add support for RT prio inheritance.
ANDROID: ashmem: Shrink directly through shmem_fallocate
ANDROID: ashmem: Add shmem_set_file to mm/shmem.c
ANDROID: fiq_debugger: Remove wakelock.h dependencies
ANDROID: fiq_debugger: Add fiq_debugger.disable option
ANDROID: fiq_debugger: Add option to apply uart overlay by FIQ_DEBUGGER_UART_OVERLAY
ANDROID: fiq_debugger: Add fiq_watchdog_triggered api
ANDROID: fiq_debugger: Call fiq_debugger_printf through a function pointer from cpu specific code
ANDROID: fiq_debugger: add ARM64 support
ANDROID: fiq_debugger: split arm support into fiq_debugger_arm.c
ANDROID: fiq_debugger: use pt_regs for registers
ANDROID: fiq_debugger: allow compiling without CONFIG_FIQ_GLUE
ANDROID: fiq_debugger: rename debug->fiq_debugger
ANDROID: fiq_debugger: move into drivers/staging/android/fiq_debugger/
ANDROID: kdb: support new lines without carriage returns
ANDROID: ARM: fiq_debugger: Update tty code for 3.9
ANDROID: ARM: fiq_debugger: lock between tty and console writes
ANDROID: ARM: fiq_debugger: add process context reboot command
ANDROID: ARM: fiq_debugger: fix multiple consoles and make it a preferred console
ANDROID: ARM: kgdb: ignore breakpoint instructions from user mode
ANDROID: ARM: fiq_debugger: add support for kgdb
ANDROID: ARM: fiq_debugger: add debug_putc
ANDROID: ARM: fiq_debugger: add support for reboot commands
ANDROID: ARM: fiq_debugger: Add generic fiq serial debugger
ANDROID: ARM: fiq_glue: Add custom fiq return handler api.
ANDROID: ARM: fiq_glue: Add fiq_glue
ANDROID: arm64: pass return address to dma_common_contiguous_remap
ANDROID: arm64: check for upper PAGE_SHIFT bits in pfn_valid()
ANDROID: arm: mm: Optionally flush entire dcache from v6_dma_flush_range
ANDROID: arm: decompressor: Flush tlb before swiching domain 0 to client mode
ANDROID: arm: fault: assume no context when IRQs are disabled during data abort.
ANDROID: arm: add option to flush console before reboot
ANDROID: arm64: process: dump memory around registers when displaying regs
ANDROID: arm: process: Add display of memory around registers when displaying regs.
ANDROID: arm64: Allow to choose appended kernel image
ANDROID: arm64: add option to build Image-dtb
ANDROID: arm64: add option to build Image.gz/dtb combo
ANDROID: arm: convert build of appended dtb zImage to list of dtbs
ANDROID: arm: add config option to build zImage/dtb combo
ANDROID: arm: Fix dtb list when DTB_IMAGE_NAMES is empty
ANDROID: arch: force -fno-pic
ANDROID: add script to fetch android kernel config fragments
ANDROID: sched: Calculate energy consumption of sched_group
ANDROID: sched: Highest energy aware balancing sched_domain level pointer
ANDROID: sched: Relocated cpu_util() and change return type
ANDROID: sched: EAS & 'single cpu per cluster'/cpu hotplug interoperability
ANDROID: sched: Introduce SD_SHARE_CAP_STATES sched_domain flag
ANDROID: sched: Initialize energy data structures
ANDROID: sched: Introduce energy data structures
ANDROID: sched: Make energy awareness a sched feature
ANDROID: sched: Documentation for scheduler energy cost model
ANDROID: arm64: Enable dynamic sched_domain flag setting
ANDROID: arm: Enable dynamic sched_domain flag setting
ANDROID: drivers/base/arch_topology: Dynamic sched_domain flag detection
ANDROID: sched/fair: Avoid unnecessary balancing of asymmetric capacity groups
ANDROID: sched: Consider misfit tasks when load-balancing
ANDROID: sched: Add group_misfit_task load-balance type
ANDROID: arm64: wire cpu-invariant accounting support up to the task scheduler
ANDROID: arm64: wire frequency-invariant accounting support up to the task scheduler
ANDROID: arm: wire cpu-invariant accounting support up to the task scheduler
ANDROID: arm: wire frequency-invariant accounting support up to the task scheduler
ANDROID: drivers base/arch_topology: allow inlining cpu-invariant accounting support
ANDROID: drivers base/arch_topology: provide frequency-invariant accounting support
ANDROID: cpufreq: dt: invoke frequency-invariance setter function
ANDROID: cpufreq: arm_big_little: invoke frequency-invariance setter function
ANDROID: cpufreq: provide default frequency-invariance setter function
ANDROID: drivers base/arch_topology: free cpumask cpus_to_visit
ANDROID: sched: Enable idle balance to pull single task towards cpu with higher capacity
ANDROID: sched: Prevent unnecessary active balance of single task in sched group

Conflicts:
Documentation/admin-guide/kernel-parameters.txt
Makefile
arch/arm/configs/ranchu_defconfig
arch/arm64/Kconfig
arch/arm64/Makefile
arch/arm64/boot/Makefile
arch/arm64/configs/ranchu64_defconfig
arch/arm64/kernel/io.c
arch/arm64/kernel/process.c
arch/arm64/mm/dma-mapping.c
arch/x86/configs/i386_ranchu_defconfig
arch/x86/configs/x86_64_ranchu_defconfig
drivers/android/binder.c
drivers/dma-buf/sw_sync.c
drivers/md/Kconfig
drivers/md/dm-android-verity.c
drivers/md/dm-android-verity.h
drivers/md/dm-linear.c
drivers/mmc/core/Kconfig
drivers/mmc/core/mmc.c
drivers/power/supply/power_supply_sysfs.c
drivers/staging/android/fiq_debugger/fiq_debugger.c
drivers/staging/android/fiq_debugger/fiq_debugger_arm64.c
drivers/usb/gadget/Kconfig
drivers/usb/gadget/function/Makefile
include/linux/power_supply.h
init/initramfs.c
kernel/power/suspend.c
kernel/sched/sched.h
net/netfilter/xt_qtaguid.c
arch/arm/kernel/topology.c
arch/arm64/boot/dts/hisilicon/hi6220.dtsi
arch/arm64/kernel/topology.c
drivers/base/arch_topology.c
kernel/sched/fair.c
kernel/sched/features.h
kernel/sched/sched.h
kernel/sched/topology.c

Change-Id: Ib242448f01dae40bff6a4da72aa4619c44663e76
Signed-off-by: Runmin Wang <runminw@codeaurora.org>

parents 038b5bef ad490df6

.gitignore

+3 −0

Original line number	Diff line number	Diff line
		@@ -115,3 +115,6 @@ all.config

		# Kdevelop4
		*.kdev4

		# fetched Android config fragments
		kernel/configs/android-*.cfg

Documentation/ABI/testing/sysfs-fs-f2fs

+36 −1

Original line number	Diff line number	Diff line
		@@ -51,6 +51,18 @@ Description:
		Controls the dirty page count condition for the in-place-update
		policies.

		What: /sys/fs/f2fs/<disk>/min_hot_blocks
		Date: March 2017
		Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
		Description:
		Controls the dirty page count condition for redefining hot data.

		What: /sys/fs/f2fs/<disk>/min_ssr_sections
		Date: October 2017
		Contact: "Chao Yu" <yuchao0@huawei.com>
		Description:
		Controls the fee section threshold to trigger SSR allocation.

		What: /sys/fs/f2fs/<disk>/max_small_discards
		Date: November 2013
		Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com>
		@@ -102,6 +114,12 @@ Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
		Description:
		Controls the idle timing.

		What: /sys/fs/f2fs/<disk>/iostat_enable
		Date: August 2017
		Contact: "Chao Yu" <yuchao0@huawei.com>
		Description:
		Controls to enable/disable IO stat.

		What: /sys/fs/f2fs/<disk>/ra_nid_pages
		Date: October 2015
		Contact: "Chao Yu" <chao2.yu@samsung.com>
		@@ -122,6 +140,12 @@ Contact: "Shuoran Liu" <liushuoran@huawei.com>
		Description:
		Shows total written kbytes issued to disk.

		What: /sys/fs/f2fs/<disk>/feature
		Date: July 2017
		Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
		Description:
		Shows all enabled features in current device.

		What: /sys/fs/f2fs/<disk>/inject_rate
		Date: May 2016
		Contact: "Sheng Yong" <shengyong1@huawei.com>
		@@ -138,7 +162,18 @@ What: /sys/fs/f2fs/<disk>/reserved_blocks
		Date: June 2017
		Contact: "Chao Yu" <yuchao0@huawei.com>
		Description:
		Controls current reserved blocks in system.
		Controls target reserved blocks in system, the threshold
		is soft, it could exceed current available user space.

		What: /sys/fs/f2fs/<disk>/current_reserved_blocks
		Date: October 2017
		Contact: "Yunlong Song" <yunlong.song@huawei.com>
		Contact: "Chao Yu" <yuchao0@huawei.com>
		Description:
		Shows current reserved blocks in system, it may be temporarily
		smaller than target_reserved_blocks, but will gradually
		increase to target_reserved_blocks when more free blocks are
		freed by user later.

		What: /sys/fs/f2fs/<disk>/gc_urgent
		Date: August 2017

Documentation/scheduler/sched-tune.txt

0 → 100644

+413 −0

Original line number	Diff line number	Diff line
		Central, scheduler-driven, power-performance control
		(EXPERIMENTAL)

		Abstract
		========

		The topic of a single simple power-performance tunable, that is wholly
		scheduler centric, and has well defined and predictable properties has come up
		on several occasions in the past [1,2]. With techniques such as a scheduler
		driven DVFS [3], we now have a good framework for implementing such a tunable.
		This document describes the overall ideas behind its design and implementation.


		Table of Contents
		=================

		1. Motivation
		2. Introduction
		3. Signal Boosting Strategy
		4. OPP selection using boosted CPU utilization
		5. Per task group boosting
		6. Per-task wakeup-placement-strategy Selection
		7. Question and Answers
		- What about "auto" mode?
		- What about boosting on a congested system?
		- How CPUs are boosted when we have tasks with multiple boost values?
		8. References


		1. Motivation
		=============

		Sched-DVFS [3] was a new event-driven cpufreq governor which allows the
		scheduler to select the optimal DVFS operating point (OPP) for running a task
		allocated to a CPU. Later, the cpufreq maintainers introduced a similar
		governor, schedutil. The introduction of schedutil also enables running
		workloads at the most energy efficient OPPs.

		However, sometimes it may be desired to intentionally boost the performance of
		a workload even if that could imply a reasonable increase in energy
		consumption. For example, in order to reduce the response time of a task, we
		may want to run the task at a higher OPP than the one that is actually required
		by it's CPU bandwidth demand.

		This last requirement is especially important if we consider that one of the
		main goals of the utilization-driven governor component is to replace all
		currently available CPUFreq policies. Since sched-DVFS and schedutil are event
		based, as opposed to the sampling driven governors we currently have, they are
		already more responsive at selecting the optimal OPP to run tasks allocated to
		a CPU. However, just tracking the actual task load demand may not be enough
		from a performance standpoint. For example, it is not possible to get
		behaviors similar to those provided by the "performance" and "interactive"
		CPUFreq governors.

		This document describes an implementation of a tunable, stacked on top of the
		utilization-driven governors which extends their functionality to support task
		performance boosting.

		By "performance boosting" we mean the reduction of the time required to
		complete a task activation, i.e. the time elapsed from a task wakeup to its
		next deactivation (e.g. because it goes back to sleep or it terminates). For
		example, if we consider a simple periodic task which executes the same workload
		for 5[s] every 20[s] while running at a certain OPP, a boosted execution of
		that task must complete each of its activations in less than 5[s].

		A previous attempt [5] to introduce such a boosting feature has not been
		successful mainly because of the complexity of the proposed solution. Previous
		versions of the approach described in this document exposed a single simple
		interface to user-space. This single tunable knob allowed the tuning of
		system wide scheduler behaviours ranging from energy efficiency at one end
		through to incremental performance boosting at the other end. This first
		tunable affects all tasks. However, that is not useful for Android products
		so in this version only a more advanced extension of the concept is provided
		which uses CGroups to boost the performance of only selected tasks while using
		the energy efficient default for all others.

		The rest of this document introduces in more details the proposed solution
		which has been named SchedTune.


		2. Introduction
		===============

		SchedTune exposes a simple user-space interface provided through a new
		CGroup controller 'stune' which provides two power-performance tunables
		per group:

		/<stune cgroup mount point>/schedtune.prefer_idle
		/<stune cgroup mount point>/schedtune.boost

		The CGroup implementation permits arbitrary user-space defined task
		classification to tune the scheduler for different goals depending on the
		specific nature of the task, e.g. background vs interactive vs low-priority.

		More details are given in section 5.

		2.1 Boosting
		============

		The boost value is expressed as an integer in the range [-100..0..100].

		A value of 0 (default) configures the CFS scheduler for maximum energy
		efficiency. This means that sched-DVFS runs the tasks at the minimum OPP
		required to satisfy their workload demand.

		A value of 100 configures scheduler for maximum performance, which translates
		to the selection of the maximum OPP on that CPU.

		A value of -100 configures scheduler for minimum performance, which translates
		to the selection of the minimum OPP on that CPU.

		The range between -100, 0 and 100 can be set to satisfy other scenarios suitably.
		For example to satisfy interactive response or depending on other system events
		(battery level etc).

		The overall design of the SchedTune module is built on top of "Per-Entity Load
		Tracking" (PELT) signals and sched-DVFS by introducing a bias on the Operating
		Performance Point (OPP) selection.

		Each time a task is allocated on a CPU, cpufreq is given the opportunity to tune
		the operating frequency of that CPU to better match the workload demand. The
		selection of the actual OPP being activated is influenced by the boost value
		for the task CGroup.

		This simple biasing approach leverages existing frameworks, which means minimal
		modifications to the scheduler, and yet it allows to achieve a range of
		different behaviours all from a single simple tunable knob.

		In EAS schedulers, we use boosted task and CPU utilization for energy
		calculation and energy-aware task placement.

		2.2 prefer_idle
		===============

		This is a flag which indicates to the scheduler that userspace would like
		the scheduler to focus on energy or to focus on performance.

		A value of 0 (default) signals to the CFS scheduler that tasks in this group
		can be placed according to the energy-aware wakeup strategy.

		A value of 1 signals to the CFS scheduler that tasks in this group should be
		placed to minimise wakeup latency.

		The value is combined with the boost value - task placement will not be
		boost aware however CPU OPP selection is still boost aware.

		Android platforms typically use this flag for application tasks which the
		user is currently interacting with.


		3. Signal Boosting Strategy
		===========================

		The whole PELT machinery works based on the value of a few load tracking signals
		which basically track the CPU bandwidth requirements for tasks and the capacity
		of CPUs. The basic idea behind the SchedTune knob is to artificially inflate
		some of these load tracking signals to make a task or RQ appears more demanding
		that it actually is.

		Which signals have to be inflated depends on the specific "consumer". However,
		independently from the specific (signal, consumer) pair, it is important to
		define a simple and possibly consistent strategy for the concept of boosting a
		signal.

		A boosting strategy defines how the "abstract" user-space defined
		sched_cfs_boost value is translated into an internal "margin" value to be added
		to a signal to get its inflated value:

		margin := boosting_strategy(sched_cfs_boost, signal)
		boosted_signal := signal + margin

		Different boosting strategies were identified and analyzed before selecting the
		one found to be most effective.

		Signal Proportional Compensation (SPC)
		--------------------------------------

		In this boosting strategy the sched_cfs_boost value is used to compute a
		margin which is proportional to the complement of the original signal.
		When a signal has a maximum possible value, its complement is defined as
		the delta from the actual value and its possible maximum.

		Since the tunable implementation uses signals which have SCHED_LOAD_SCALE as
		the maximum possible value, the margin becomes:

		margin := sched_cfs_boost * (SCHED_LOAD_SCALE - signal)

		Using this boosting strategy:
		- a 100% sched_cfs_boost means that the signal is scaled to the maximum value
		- each value in the range of sched_cfs_boost effectively inflates the signal in
		question by a quantity which is proportional to the maximum value.

		For example, by applying the SPC boosting strategy to the selection of the OPP
		to run a task it is possible to achieve these behaviors:

		- 0% boosting: run the task at the minimum OPP required by its workload
		- 100% boosting: run the task at the maximum OPP available for the CPU
		- 50% boosting: run at the half-way OPP between minimum and maximum

		Which means that, at 50% boosting, a task will be scheduled to run at half of
		the maximum theoretically achievable performance on the specific target
		platform.

		A graphical representation of an SPC boosted signal is represented in the
		following figure where:
		a) "-" represents the original signal
		b) "b" represents a 50% boosted signal
		c) "p" represents a 100% boosted signal


		^
		\| SCHED_LOAD_SCALE
		+-----------------------------------------------------------------+
		\|pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp
		\|
		\| boosted_signal
		\| bbbbbbbbbbbbbbbbbbbbbbbb
		\|
		\| original signal
		\| bbbbbbbbbbbbbbbbbbbbbbbb+----------------------+
		\| \|
		\|bbbbbbbbbbbbbbbbbb \|
		\| \|
		\| \|
		\| \|
		\| +-----------------------+
		\| \|
		\| \|
		\| \|
		\|------------------+
		\|
		\|
		+----------------------------------------------------------------------->

		The plot above shows a ramped load signal (titled 'original_signal') and it's
		boosted equivalent. For each step of the original signal the boosted signal
		corresponding to a 50% boost is midway from the original signal and the upper
		bound. Boosting by 100% generates a boosted signal which is always saturated to
		the upper bound.


		4. OPP selection using boosted CPU utilization
		==============================================

		It is worth calling out that the implementation does not introduce any new load
		signals. Instead, it provides an API to tune existing signals. This tuning is
		done on demand and only in scheduler code paths where it is sensible to do so.
		The new API calls are defined to return either the default signal or a boosted
		one, depending on the value of sched_cfs_boost. This is a clean an non invasive
		modification of the existing existing code paths.

		The signal representing a CPU's utilization is boosted according to the
		previously described SPC boosting strategy. To sched-DVFS, this allows a CPU
		(ie CFS run-queue) to appear more used then it actually is.

		Thus, with the sched_cfs_boost enabled we have the following main functions to
		get the current utilization of a CPU:

		cpu_util()
		boosted_cpu_util()

		The new boosted_cpu_util() is similar to the first but returns a boosted
		utilization signal which is a function of the sched_cfs_boost value.

		This function is used in the CFS scheduler code paths where sched-DVFS needs to
		decide the OPP to run a CPU at.
		For example, this allows selecting the highest OPP for a CPU which has
		the boost value set to 100%.


		5. Per task group boosting
		==========================

		On battery powered devices there usually are many background services which are
		long running and need energy efficient scheduling. On the other hand, some
		applications are more performance sensitive and require an interactive
		response and/or maximum performance, regardless of the energy cost.

		To better service such scenarios, the SchedTune implementation has an extension
		that provides a more fine grained boosting interface.

		A new CGroup controller, namely "schedtune", can be enabled which allows to
		defined and configure task groups with different boosting values.
		Tasks that require special performance can be put into separate CGroups.
		The value of the boost associated with the tasks in this group can be specified
		using a single knob exposed by the CGroup controller:

		schedtune.boost

		This knob allows the definition of a boost value that is to be used for
		SPC boosting of all tasks attached to this group.

		The current schedtune controller implementation is really simple and has these
		main characteristics:

		1) It is only possible to create 1 level depth hierarchies

		The root control groups define the system-wide boost value to be applied
		by default to all tasks. Its direct subgroups are named "boost groups" and
		they define the boost value for specific set of tasks.
		Further nested subgroups are not allowed since they do not have a sensible
		meaning from a user-space standpoint.

		2) It is possible to define only a limited number of "boost groups"

		This number is defined at compile time and by default configured to 16.
		This is a design decision motivated by two main reasons:
		a) In a real system we do not expect utilization scenarios with more then few
		boost groups. For example, a reasonable collection of groups could be
		just "background", "interactive" and "performance".
		b) It simplifies the implementation considerably, especially for the code
		which has to compute the per CPU boosting once there are multiple
		RUNNABLE tasks with different boost values.

		Such a simple design should allow servicing the main utilization scenarios identified
		so far. It provides a simple interface which can be used to manage the
		power-performance of all tasks or only selected tasks.
		Moreover, this interface can be easily integrated by user-space run-times (e.g.
		Android, ChromeOS) to implement a QoS solution for task boosting based on tasks
		classification, which has been a long standing requirement.

		Setup and usage
		---------------

		0. Use a kernel with CONFIG_SCHED_TUNE support enabled

		1. Check that the "schedtune" CGroup controller is available:

		root@linaro-nano:~# cat /proc/cgroups
		#subsys_name hierarchy num_cgroups enabled
		cpuset 0 1 1
		cpu 0 1 1
		schedtune 0 1 1

		2. Mount a tmpfs to create the CGroups mount point (Optional)

		root@linaro-nano:~# sudo mount -t tmpfs cgroups /sys/fs/cgroup

		3. Mount the "schedtune" controller

		root@linaro-nano:~# mkdir /sys/fs/cgroup/stune
		root@linaro-nano:~# sudo mount -t cgroup -o schedtune stune /sys/fs/cgroup/stune

		4. Create task groups and configure their specific boost value (Optional)

		For example here we create a "performance" boost group configure to boost
		all its tasks to 100%

		root@linaro-nano:~# mkdir /sys/fs/cgroup/stune/performance
		root@linaro-nano:~# echo 100 > /sys/fs/cgroup/stune/performance/schedtune.boost

		5. Move tasks into the boost group

		For example, the following moves the tasks with PID $TASKPID (and all its
		threads) into the "performance" boost group.

		root@linaro-nano:~# echo "TASKPID > /sys/fs/cgroup/stune/performance/cgroup.procs

		This simple configuration allows only the threads of the $TASKPID task to run,
		when needed, at the highest OPP in the most capable CPU of the system.


		6. Per-task wakeup-placement-strategy Selection
		===============================================

		Many devices have a number of CFS tasks in use which require an absolute
		minimum wakeup latency, and many tasks for which wakeup latency is not
		important.

		For touch-driven environments, removing additional wakeup latency can be
		critical.

		When you use the Schedtume CGroup controller, you have access to a second
		parameter which allows a group to be marked such that energy_aware task
		placement is bypassed for tasks belonging to that group.

		prefer_idle=0 (default - use energy-aware task placement if available)
		prefer_idle=1 (never use energy-aware task placement for these tasks)

		Since the regular wakeup task placement algorithm in CFS is biased for
		performance, this has the effect of restoring minimum wakeup latency
		for the desired tasks whilst still allowing energy-aware wakeup placement
		to save energy for other tasks.


		7. Question and Answers
		=======================

		What about "auto" mode?
		-----------------------

		The 'auto' mode as described in [5] can be implemented by interfacing SchedTune
		with some suitable user-space element. This element could use the exposed
		system-wide or cgroup based interface.

		How are multiple groups of tasks with different boost values managed?
		---------------------------------------------------------------------

		The current SchedTune implementation keeps track of the boosted RUNNABLE tasks
		on a CPU. The CPU utilization seen by the scheduler-driven cpufreq governors
		(and used to select an appropriate OPP) is boosted with a value which is the
		maximum of the boost values of the currently RUNNABLE tasks in its RQ.

		This allows cpufreq to boost a CPU only while there are boosted tasks ready
		to run and switch back to the energy efficient mode as soon as the last boosted
		task is dequeued.


		8. References
		=============
		[1] http://lwn.net/Articles/552889
		[2] http://lkml.org/lkml/2012/5/18/91
		[3] http://lkml.org/lkml/2015/6/26/620

Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -717,6 +717,7 @@ KBUILD_CFLAGS += $(call cc-disable-warning, unused-variable)
		KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier)
		KBUILD_CFLAGS += $(call cc-disable-warning, gnu)
		KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)
		KBUILD_CFLAGS += $(call cc-disable-warning, duplicate-decl-specifier)

		KBUILD_CFLAGS += -Wno-asm-operand-widths
		KBUILD_CFLAGS += -Wno-initializer-overrides

arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts

+76 −0

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@
		cci-control-port = <&cci_control1>;
		cpu-idle-states = <&CLUSTER_SLEEP_BIG>;
		capacity-dmips-mhz = <1024>;
		sched-energy-costs = <&CPU_COST_A15 &CLUSTER_COST_A15>;
		};

		cpu1: cpu@1 {
		@@ -50,6 +51,7 @@
		cci-control-port = <&cci_control1>;
		cpu-idle-states = <&CLUSTER_SLEEP_BIG>;
		capacity-dmips-mhz = <1024>;
		sched-energy-costs = <&CPU_COST_A15 &CLUSTER_COST_A15>;
		};

		cpu2: cpu@2 {
		@@ -59,6 +61,7 @@
		cci-control-port = <&cci_control2>;
		cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
		capacity-dmips-mhz = <516>;
		sched-energy-costs = <&CPU_COST_A7 &CLUSTER_COST_A7>;
		};

		cpu3: cpu@3 {
		@@ -68,6 +71,7 @@
		cci-control-port = <&cci_control2>;
		cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
		capacity-dmips-mhz = <516>;
		sched-energy-costs = <&CPU_COST_A7 &CLUSTER_COST_A7>;
		};

		cpu4: cpu@4 {
		@@ -77,6 +81,7 @@
		cci-control-port = <&cci_control2>;
		cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
		capacity-dmips-mhz = <516>;
		sched-energy-costs = <&CPU_COST_A7 &CLUSTER_COST_A7>;
		};

		idle-states {
		@@ -96,6 +101,77 @@
		min-residency-us = <2500>;
		};
		};

		energy-costs {
		CPU_COST_A15: core-cost0 {
		busy-cost-data = <
		426 2021
		512 2312
		597 2756
		682 3125
		768 3524
		853 3846
		938 5177
		1024 6997
		>;
		idle-cost-data = <
		0
		0
		0
		>;
		};
		CPU_COST_A7: core-cost1 {
		busy-cost-data = <
		150 187
		172 275
		215 334
		258 407
		301 447
		344 549
		387 761
		430 1024
		>;
		idle-cost-data = <
		0
		0
		0
		>;
		};
		CLUSTER_COST_A15: cluster-cost0 {
		busy-cost-data = <
		426 7920
		512 8165
		597 8172
		682 8195
		768 8265
		853 8446
		938 11426
		1024 15200
		>;
		idle-cost-data = <
		70
		70
		25
		>;
		};
		CLUSTER_COST_A7: cluster-cost1 {
		busy-cost-data = <
		150 2967
		172 2792
		215 2810
		258 2815
		301 2919
		344 2847
		387 3917
		430 4905
		>;
		idle-cost-data = <
		25
		25
		10
		>;
		};
		};
		};

		memory@80000000 {